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