Version 3.18.1
Show:

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);
            
                        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() {
                        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;