Current Path : C:/xampp/htdocs/moodle/lib/yuilib/3.17.2/base-observable/ |
Current File : C:/xampp/htdocs/moodle/lib/yuilib/3.17.2/base-observable/base-observable.js |
/* YUI 3.17.2 (build 9c3c78e) Copyright 2014 Yahoo! Inc. All rights reserved. Licensed under the BSD License. http://yuilibrary.com/license/ */ YUI.add('base-observable', function (Y, NAME) { /** The `base-observable` submodule adds observability to Base's lifecycle and attributes, and also make it an `EventTarget`. @module base @submodule base-observable **/ var L = Y.Lang, DESTROY = "destroy", INIT = "init", BUBBLETARGETS = "bubbleTargets", _BUBBLETARGETS = "_bubbleTargets", AttributeObservable = Y.AttributeObservable, BaseCore = Y.BaseCore; /** Provides an augmentable implementation of lifecycle and attribute events for `BaseCore`. @class BaseObservable @extensionfor BaseCore @uses AttributeObservable @uses EventTarget @since 3.8.0 **/ function BaseObservable() {} BaseObservable._ATTR_CFG = AttributeObservable._ATTR_CFG.concat(); BaseObservable._NON_ATTRS_CFG = ["on", "after", "bubbleTargets"]; BaseObservable.prototype = { /** * Initializes Attribute * * @method _initAttribute * @private */ _initAttribute: function() { BaseCore.prototype._initAttribute.apply(this, arguments); AttributeObservable.call(this); this._eventPrefix = this.constructor.EVENT_PREFIX || this.constructor.NAME; this._yuievt.config.prefix = this._eventPrefix; }, /** * Init lifecycle method, invoked during construction. * Fires the init event prior to setting up attributes and * invoking initializers for the class hierarchy. * * @method init * @chainable * @param {Object} config Object with configuration property name/value pairs * @return {Base} A reference to this object */ init: function(config) { /** * <p> * 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. * </p> * <p> * Subscribers to the "after" momemt of this event, will be notified * after initialization of the object is complete (and therefore * cannot prevent initialization). * </p> * * @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); } } }, /** * <p> * Destroy lifecycle method. Fires the destroy * event, prior to invoking destructors for the * class hierarchy. * </p> * <p> * Subscribers to the destroy * event can invoke preventDefault on the event object, to prevent destruction * from proceeding. * </p> * @method destroy * @return {Base} A reference to this object * @chainable */ destroy: function() { /** * <p> * 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. * </p> * <p> * Subscribers to the "after" moment of this event, will be notified * after destruction is complete (and as a result cannot prevent * destruction). * </p> * @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; }, '3.17.2', {"requires": ["attribute-observable", "base-core"]});