+ * Lifecycle event for the init phase, fired prior to initialization. + * Invoking the preventDefault() method on the event object provided + * to subscribers will prevent initialization from occuring. + *
+ *+ * Subscribers to the "after" momemt of this event, will be notified + * after initialization of the object is complete (and therefore + * cannot prevent initialization). + *
+ * + * @event init + * @preventable _defInitFn + * @param {EventFacade} e Event object, with a cfg property which + * refers to the configuration object passed to the constructor. + */ + + // PERF: Using lower level _publish() for + // critical path performance + + var type = this._getFullType(INIT), + e = this._publish(type); + + e.emitFacade = true; + e.fireOnce = true; + e.defaultTargetOnly = true; + e.defaultFn = this._defInitFn; + + this._preInitEventCfg(config); + + if (e._hasPotentialSubscribers()) { + this.fire(type, {cfg: config}); + } else { + + this._baseInit(config); + + // HACK. Major hack actually. But really fast for no-listeners. + // Since it's fireOnce, subscribers may come along later, so since we're + // bypassing the event stack the first time, we need to tell the published + // event that it's been "fired". Could extract it into a CE method? + e.fired = true; + e.firedWith = [{cfg:config}]; + } + + return this; + }, + + /** + * Handles the special on, after and target properties which allow the user to + * easily configure on and after listeners as well as bubble targets during + * construction, prior to init. + * + * @private + * @method _preInitEventCfg + * @param {Object} config The user configuration object + */ + _preInitEventCfg : function(config) { + if (config) { + if (config.on) { + this.on(config.on); + } + if (config.after) { + this.after(config.after); + } + } + + var i, l, target, + userTargets = (config && BUBBLETARGETS in config); + + if (userTargets || _BUBBLETARGETS in this) { + target = userTargets ? (config && config.bubbleTargets) : this._bubbleTargets; + + if (L.isArray(target)) { + for (i = 0, l = target.length; i < l; i++) { + this.addTarget(target[i]); + } + } else if (target) { + this.addTarget(target); + } + } + }, + + /** + *+ * Destroy lifecycle method. Fires the destroy + * event, prior to invoking destructors for the + * class hierarchy. + *
+ *+ * Subscribers to the destroy + * event can invoke preventDefault on the event object, to prevent destruction + * from proceeding. + *
+ * @method destroy + * @return {Base} A reference to this object + * @chainable + */ + destroy: function() { + Y.log('destroy called', 'life', 'base'); + + /** + *+ * Lifecycle event for the destroy phase, + * fired prior to destruction. Invoking the preventDefault + * method on the event object provided to subscribers will + * prevent destruction from proceeding. + *
+ *+ * Subscribers to the "after" moment of this event, will be notified + * after destruction is complete (and as a result cannot prevent + * destruction). + *
+ * @event destroy + * @preventable _defDestroyFn + * @param {EventFacade} e Event object + */ + this.publish(DESTROY, { + fireOnce:true, + defaultTargetOnly:true, + defaultFn: this._defDestroyFn + }); + this.fire(DESTROY); + + this.detachAll(); + return this; + }, + + /** + * Default init event handler + * + * @method _defInitFn + * @param {EventFacade} e Event object, with a cfg property which + * refers to the configuration object passed to the constructor. + * @protected + */ + _defInitFn : function(e) { + this._baseInit(e.cfg); + }, + + /** + * Default destroy event handler + * + * @method _defDestroyFn + * @param {EventFacade} e Event object + * @protected + */ + _defDestroyFn : function(e) { + this._baseDestroy(e.cfg); + } + }; + + Y.mix(BaseObservable, AttributeObservable, false, null, 1); + + Y.BaseObservable = BaseObservable; + + +}, '@VERSION@', {"requires": ["attribute-observable", "base-core"]});