[Summary view] [Print] [Text view]

   1  /*
   2  YUI 3.17.2 (build 9c3c78e)
   3  Copyright 2014 Yahoo! Inc. All rights reserved.
   4  Licensed under the BSD License.
   5  http://yuilibrary.com/license/
   6  */
   7  
   8  YUI.add('base-observable', function (Y, NAME) {
   9  
  10      /**
  11      The `base-observable` submodule adds observability to Base's lifecycle and
  12      attributes, and also make it an `EventTarget`.
  13  
  14      @module base
  15      @submodule base-observable
  16      **/
  17      var L = Y.Lang,
  18  
  19          DESTROY = "destroy",
  20          INIT = "init",
  21  
  22          BUBBLETARGETS = "bubbleTargets",
  23          _BUBBLETARGETS = "_bubbleTargets",
  24  
  25          AttributeObservable = Y.AttributeObservable,
  26          BaseCore            = Y.BaseCore;
  27  
  28      /**
  29      Provides an augmentable implementation of lifecycle and attribute events for
  30      `BaseCore`.
  31  
  32      @class BaseObservable
  33      @extensionfor BaseCore
  34      @uses AttributeObservable
  35      @uses EventTarget
  36      @since 3.8.0
  37      **/
  38      function BaseObservable() {}
  39  
  40      BaseObservable._ATTR_CFG      = AttributeObservable._ATTR_CFG.concat();
  41      BaseObservable._NON_ATTRS_CFG = ["on", "after", "bubbleTargets"];
  42  
  43      BaseObservable.prototype = {
  44  
  45          /**
  46           * Initializes Attribute
  47           *
  48           * @method _initAttribute
  49           * @private
  50           */
  51          _initAttribute: function() {
  52              BaseCore.prototype._initAttribute.apply(this, arguments);
  53              AttributeObservable.call(this);
  54  
  55              this._eventPrefix = this.constructor.EVENT_PREFIX || this.constructor.NAME;
  56              this._yuievt.config.prefix = this._eventPrefix;
  57          },
  58  
  59          /**
  60           * Init lifecycle method, invoked during construction.
  61           * Fires the init event prior to setting up attributes and
  62           * invoking initializers for the class hierarchy.
  63           *
  64           * @method init
  65           * @chainable
  66           * @param {Object} config Object with configuration property name/value pairs
  67           * @return {Base} A reference to this object
  68           */
  69          init: function(config) {
  70  
  71              /**
  72               * <p>
  73               * Lifecycle event for the init phase, fired prior to initialization.
  74               * Invoking the preventDefault() method on the event object provided
  75               * to subscribers will prevent initialization from occuring.
  76               * </p>
  77               * <p>
  78               * Subscribers to the "after" momemt of this event, will be notified
  79               * after initialization of the object is complete (and therefore
  80               * cannot prevent initialization).
  81               * </p>
  82               *
  83               * @event init
  84               * @preventable _defInitFn
  85               * @param {EventFacade} e Event object, with a cfg property which
  86               * refers to the configuration object passed to the constructor.
  87               */
  88  
  89              // PERF: Using lower level _publish() for
  90              // critical path performance
  91  
  92              var type = this._getFullType(INIT),
  93                  e = this._publish(type);
  94  
  95              e.emitFacade = true;
  96              e.fireOnce = true;
  97              e.defaultTargetOnly = true;
  98              e.defaultFn = this._defInitFn;
  99  
 100              this._preInitEventCfg(config);
 101  
 102              if (e._hasPotentialSubscribers()) {
 103                  this.fire(type, {cfg: config});
 104              } else {
 105  
 106                  this._baseInit(config);
 107  
 108                  // HACK. Major hack actually. But really fast for no-listeners.
 109                  // Since it's fireOnce, subscribers may come along later, so since we're
 110                  // bypassing the event stack the first time, we need to tell the published
 111                  // event that it's been "fired". Could extract it into a CE method?
 112                  e.fired = true;
 113                  e.firedWith = [{cfg:config}];
 114              }
 115  
 116              return this;
 117          },
 118  
 119          /**
 120           * Handles the special on, after and target properties which allow the user to
 121           * easily configure on and after listeners as well as bubble targets during
 122           * construction, prior to init.
 123           *
 124           * @private
 125           * @method _preInitEventCfg
 126           * @param {Object} config The user configuration object
 127           */
 128          _preInitEventCfg : function(config) {
 129              if (config) {
 130                  if (config.on) {
 131                      this.on(config.on);
 132                  }
 133                  if (config.after) {
 134                      this.after(config.after);
 135                  }
 136              }
 137  
 138              var i, l, target,
 139                  userTargets = (config && BUBBLETARGETS in config);
 140  
 141              if (userTargets || _BUBBLETARGETS in this) {
 142                  target = userTargets ? (config && config.bubbleTargets) : this._bubbleTargets;
 143  
 144                  if (L.isArray(target)) {
 145                      for (i = 0, l = target.length; i < l; i++) {
 146                          this.addTarget(target[i]);
 147                      }
 148                  } else if (target) {
 149                      this.addTarget(target);
 150                  }
 151              }
 152          },
 153  
 154          /**
 155           * <p>
 156           * Destroy lifecycle method. Fires the destroy
 157           * event, prior to invoking destructors for the
 158           * class hierarchy.
 159           * </p>
 160           * <p>
 161           * Subscribers to the destroy
 162           * event can invoke preventDefault on the event object, to prevent destruction
 163           * from proceeding.
 164           * </p>
 165           * @method destroy
 166           * @return {Base} A reference to this object
 167           * @chainable
 168           */
 169          destroy: function() {
 170  
 171              /**
 172               * <p>
 173               * Lifecycle event for the destroy phase,
 174               * fired prior to destruction. Invoking the preventDefault
 175               * method on the event object provided to subscribers will
 176               * prevent destruction from proceeding.
 177               * </p>
 178               * <p>
 179               * Subscribers to the "after" moment of this event, will be notified
 180               * after destruction is complete (and as a result cannot prevent
 181               * destruction).
 182               * </p>
 183               * @event destroy
 184               * @preventable _defDestroyFn
 185               * @param {EventFacade} e Event object
 186               */
 187              this.publish(DESTROY, {
 188                  fireOnce:true,
 189                  defaultTargetOnly:true,
 190                  defaultFn: this._defDestroyFn
 191              });
 192              this.fire(DESTROY);
 193  
 194              this.detachAll();
 195              return this;
 196          },
 197  
 198          /**
 199           * Default init event handler
 200           *
 201           * @method _defInitFn
 202           * @param {EventFacade} e Event object, with a cfg property which
 203           * refers to the configuration object passed to the constructor.
 204           * @protected
 205           */
 206          _defInitFn : function(e) {
 207              this._baseInit(e.cfg);
 208          },
 209  
 210          /**
 211           * Default destroy event handler
 212           *
 213           * @method _defDestroyFn
 214           * @param {EventFacade} e Event object
 215           * @protected
 216           */
 217          _defDestroyFn : function(e) {
 218              this._baseDestroy(e.cfg);
 219          }
 220      };
 221  
 222      Y.mix(BaseObservable, AttributeObservable, false, null, 1);
 223  
 224      Y.BaseObservable = BaseObservable;
 225  
 226  
 227  }, '3.17.2', {"requires": ["attribute-observable", "base-core"]});