--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui3-3.15.0/build/base-observable/base-observable.js Mon Mar 10 15:19:48 2014 +0100
@@ -0,0 +1,220 @@
+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;
+
+
+}, '@VERSION@', {"requires": ["attribute-observable", "base-core"]});