#

API Docs for: 3.10.3
Show: Inherited Protected Private Deprecated

# File: base/js/BaseObservable.js

        /**
        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);

                this.fire(type, {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() {
                Y.log('destroy called', 'life', 'base');

                /**
                 * <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;