ember-source 4.3.0-alpha.1 → 4.3.0-beta.1

package/dist/packages/@ember/-internals/meta/lib/meta.js

@@ -36,9 +36,16 @@ export const UNDEFINED = symbol('undefined');
 let currentListenerVersion = 1;
 export class Meta {
   // DEBUG
+
+  /** @internal */
   constructor(obj) {
+    /** @internal */
     this._listenersVersion = 1;
+    /** @internal */
+
     this._inheritedEnd = -1;
+    /** @internal */
+
     this._flattenedVersion = 0;
 
     if (DEBUG) {
@@ -59,6 +66,8 @@ export class Meta {
     this.proto = obj.constructor === undefined ? undefined : obj.constructor.prototype;
     this._listeners = undefined;
   }
+  /** @internal */
+
 
   get parent() {
     let parent = this._parent;
@@ -74,26 +83,38 @@ export class Meta {
   setInitializing() {
     this._isInit = true;
   }
+  /** @internal */
+
 
   unsetInitializing() {
     this._isInit = false;
   }
+  /** @internal */
+
 
   isInitializing() {
     return this._isInit;
   }
+  /** @internal */
+
 
   isPrototypeMeta(obj) {
     return this.proto === this.source && this.source === obj;
   }
+  /** @internal */
+
 
   _getOrCreateOwnMap(key) {
     return this[key] || (this[key] = Object.create(null));
   }
+  /** @internal */
+
 
   _getOrCreateOwnSet(key) {
     return this[key] || (this[key] = new Set());
   }
+  /** @internal */
+
 
   _findInheritedMap(key, subkey) {
     let pointer = this;
@@ -112,6 +133,8 @@ export class Meta {
       pointer = pointer.parent;
     }
   }
+  /** @internal */
+
 
   _hasInInheritedSet(key, value) {
     let pointer = this;
@@ -128,28 +151,38 @@ export class Meta {
 
     return false;
   }
+  /** @internal */
+
 
   valueFor(key) {
     let values = this._values;
     return values !== undefined ? values[key] : undefined;
   }
+  /** @internal */
+
 
   setValueFor(key, value) {
     let values = this._getOrCreateOwnMap('_values');
 
     values[key] = value;
   }
+  /** @internal */
+
 
   revisionFor(key) {
     let revisions = this._revisions;
     return revisions !== undefined ? revisions[key] : undefined;
   }
+  /** @internal */
+
 
   setRevisionFor(key, revision) {
     let revisions = this._getOrCreateOwnMap('_revisions');
 
     revisions[key] = revision;
   }
+  /** @internal */
+
 
   writableLazyChainsFor(key) {
     if (DEBUG) {
@@ -166,6 +199,8 @@ export class Meta {
 
     return chains;
   }
+  /** @internal */
+
 
   readableLazyChainsFor(key) {
     if (DEBUG) {
@@ -180,6 +215,8 @@ export class Meta {
 
     return undefined;
   }
+  /** @internal */
+
 
   addMixin(mixin) {
     assert(isDestroyed(this.source) ? `Cannot add mixins of \`${toString(mixin)}\` on \`${toString(this.source)}\` call addMixin after it has been destroyed.` : '', !isDestroyed(this.source));
@@ -188,10 +225,14 @@ export class Meta {
 
     set.add(mixin);
   }
+  /** @internal */
+
 
   hasMixin(mixin) {
     return this._hasInInheritedSet('_mixins', mixin);
   }
+  /** @internal */
+
 
   forEachMixins(fn) {
     let pointer = this;
@@ -214,22 +255,30 @@ export class Meta {
       pointer = pointer.parent;
     }
   }
+  /** @internal */
+
 
   writeDescriptors(subkey, value) {
     assert(isDestroyed(this.source) ? `Cannot update descriptors for \`${subkey}\` on \`${toString(this.source)}\` after it has been destroyed.` : '', !isDestroyed(this.source));
     let map = this._descriptors || (this._descriptors = new Map());
     map.set(subkey, value);
   }
+  /** @internal */
+
 
   peekDescriptors(subkey) {
     let possibleDesc = this._findInheritedMap('_descriptors', subkey);
 
     return possibleDesc === UNDEFINED ? undefined : possibleDesc;
   }
+  /** @internal */
+
 
   removeDescriptors(subkey) {
     this.writeDescriptors(subkey, UNDEFINED);
   }
+  /** @internal */
+
 
   forEachDescriptors(fn) {
     let pointer = this;
@@ -254,6 +303,8 @@ export class Meta {
       pointer = pointer.parent;
     }
   }
+  /** @internal */
+
 
   addToListeners(eventName, target, method, once, sync) {
     if (DEBUG) {
@@ -266,6 +317,8 @@ export class Meta {
     /* ADD */
     , sync);
   }
+  /** @internal */
+
 
   removeFromListeners(eventName, target, method) {
     if (DEBUG) {
@@ -303,7 +356,8 @@ export class Meta {
         sync
       });
     } else {
-      let listener = listeners[i]; // If the listener is our own listener and we are trying to remove it, we
+      let listener = listeners[i];
+      assert('has listener', listener); // If the listener is our own listener and we are trying to remove it, we
       // want to splice it out entirely so we don't hold onto a reference.
 
       if (kind === 2
@@ -311,8 +365,8 @@ export class Meta {
       && listener.kind !== 2
       /* REMOVE */
       ) {
-          listeners.splice(i, 1);
-        } else {
+        listeners.splice(i, 1);
+      } else {
         assert(`You attempted to add an observer for the same method on '${event.split(':')[0]}' twice to ${target} as both sync and async. Observers must be either sync or async, they cannot be both. This is likely a mistake, you should either remove the code that added the observer a second time, or update it to always be sync or async. The method was ${method}.`, !(listener.kind === 0
         /* ADD */
         && kind === 0
@@ -394,8 +448,7 @@ export class Meta {
               this._inheritedEnd = 0;
             }
 
-            for (let i = 0; i < parentListeners.length; i++) {
-              let listener = parentListeners[i];
+            for (let listener of parentListeners) {
               let index = indexOfListener(listeners, listener.event, listener.target, listener.method);
 
               if (index === -1) {
@@ -416,6 +469,8 @@ export class Meta {
 
     return this._listeners;
   }
+  /** @internal */
+
 
   matchingListeners(eventName) {
     let listeners = this.flattenedListeners();
@@ -426,10 +481,9 @@ export class Meta {
     }
 
     if (listeners !== undefined) {
-      for (let index = 0; index < listeners.length; index++) {
-        let listener = listeners[index]; // REMOVE listeners are placeholders that tell us not to
+      for (let listener of listeners) {
+        // REMOVE listeners are placeholders that tell us not to
         // inherit, so they never match. Only ADD and ONCE can match.
-
         if (listener.event === eventName && (listener.kind === 0
         /* ADD */
         || listener.kind === 1
@@ -450,6 +504,8 @@ export class Meta {
 
     return result;
   }
+  /** @internal */
+
 
   observerEvents() {
     let listeners = this.flattenedListeners();
@@ -460,10 +516,9 @@ export class Meta {
     }
 
     if (listeners !== undefined) {
-      for (let index = 0; index < listeners.length; index++) {
-        let listener = listeners[index]; // REMOVE listeners are placeholders that tell us not to
+      for (let listener of listeners) {
+        // REMOVE listeners are placeholders that tell us not to
         // inherit, so they never match. Only ADD and ONCE can match.
-
         if ((listener.kind === 0
         /* ADD */
         || listener.kind === 1
@@ -585,6 +640,7 @@ export { counters };
 function indexOfListener(listeners, event, target, method) {
   for (let i = listeners.length - 1; i >= 0; i--) {
     let listener = listeners[i];
+    assert('has listener', listener);
 
     if (listener.event === event && listener.target === target && listener.method === method) {
       return i;