ember-source 2.17.0.beta.4 → 2.17.0.beta.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c3ced36784ffb932cea00fb55298db42494772d2
-  data.tar.gz: 4897f81d2d6f0b336a2c58abde17fe595df5d64c
+SHA256:
+  metadata.gz: 8db7c51ac4f81fcb3621cf22fd9440340c9915a1b5c0c5363adbd729f29e606f
+  data.tar.gz: 8a9c2e3b2b27d0c9ee95a19f731dfc0e557a5abcc3c497371780c7a76cace422
 SHA512:
-  metadata.gz: 7ebf8e643ac64bf05f8bcc2505c462de576150bf42674e8332f1a647ef90b275b32c6095f1e6e34b0c2e242b4ed98ac191763c7192d271cf588b2837582de623
-  data.tar.gz: 5435dade5b64307db24e9b86fb04e59caaaf59d8827fccd3cffa65510a24eb9821f734c2549fc79066c65f7c61e4f2fda56eb87ca8ef29727935a7a0b83317ff
+  metadata.gz: fb410d9a8ee421a728ad50ad2a0e76f3fac57890364e438f0fa73930356a116c0c091e2a2cc40f01294f7be8776fd5ea8cac63bcd1c7cdda44ca4bc2d9f08395
+  data.tar.gz: 46b1e4aa61a60c7f8e2d77e4ddd1d6b73bc17c0881ae4e1f9b4374e9555dc4c71edb5dcbbd785d70cbbea875426b6b253aae8fd9c3822be16546cfd0f87105ee

data/dist/ember-runtime.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   2.17.0-beta.4
+ * @version   2.17.0-beta.5
  */
 
 var enifed, requireModule, Ember;
@@ -1989,6 +1989,146 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     return ObserverSet;
   }();
 
+  /**
+   @module ember
+  */
+  var id = 0;
+
+  // Returns whether Type(value) is Object according to the terminology in the spec
+  function isObject$1(value) {
+    return typeof value === 'object' && value !== null || typeof value === 'function';
+  }
+
+  /*
+   * @class Ember.WeakMap
+   * @public
+   * @category ember-metal-weakmap
+   *
+   * A partial polyfill for [WeakMap](http://www.ecma-international.org/ecma-262/6.0/#sec-weakmap-objects).
+   *
+   * There is a small but important caveat. This implementation assumes that the
+   * weak map will live longer (in the sense of garbage collection) than all of its
+   * keys, otherwise it is possible to leak the values stored in the weak map. In
+   * practice, most use cases satisfy this limitation which is why it is included
+   * in ember-metal.
+   */
+  var WeakMapPolyfill = function () {
+    function WeakMapPolyfill(iterable) {
+      emberBabel.classCallCheck(this, WeakMapPolyfill);
+
+      this._id = emberUtils.GUID_KEY + id++;
+
+      if (iterable === null || iterable === undefined) {
+        return;
+      } else if (Array.isArray(iterable)) {
+        for (var i = 0; i < iterable.length; i++) {
+          var _iterable$i = iterable[i],
+              key = _iterable$i[0],
+              value = _iterable$i[1];
+
+          this.set(key, value);
+        }
+      } else {
+        throw new TypeError('The weak map constructor polyfill only supports an array argument');
+      }
+    }
+
+    /*
+     * @method get
+     * @param key {Object | Function}
+     * @return {Any} stored value
+     */
+
+    WeakMapPolyfill.prototype.get = function get(obj) {
+      if (!isObject$1(obj)) {
+        return undefined;
+      }
+
+      var meta$$1 = exports.peekMeta(obj);
+      if (meta$$1 !== undefined) {
+        var map = meta$$1.readableWeak();
+        if (map !== undefined) {
+          var val = map[this._id];
+          if (val === UNDEFINED) {
+            return undefined;
+          }
+          return val;
+        }
+      }
+    };
+
+    /*
+     * @method set
+     * @param key {Object | Function}
+     * @param value {Any}
+     * @return {WeakMap} the weak map
+     */
+
+    WeakMapPolyfill.prototype.set = function set(obj, value) {
+      if (!isObject$1(obj)) {
+        throw new TypeError('Invalid value used as weak map key');
+      }
+
+      if (value === undefined) {
+        value = UNDEFINED;
+      }
+
+      meta(obj).writableWeak()[this._id] = value;
+
+      return this;
+    };
+
+    /*
+     * @method has
+     * @param key {Object | Function}
+     * @return {boolean} if the key exists
+     */
+
+    WeakMapPolyfill.prototype.has = function has(obj) {
+      if (!isObject$1(obj)) {
+        return false;
+      }
+
+      var meta$$1 = exports.peekMeta(obj);
+      if (meta$$1 !== undefined) {
+        var map = meta$$1.readableWeak();
+        if (map !== undefined) {
+          return map[this._id] !== undefined;
+        }
+      }
+
+      return false;
+    };
+
+    /*
+     * @method delete
+     * @param key {Object | Function}
+     * @return {boolean} if the key was deleted
+     */
+
+    WeakMapPolyfill.prototype.delete = function _delete(obj) {
+      if (this.has(obj)) {
+        delete exports.peekMeta(obj).writableWeak()[this._id];
+        return true;
+      } else {
+        return false;
+      }
+    };
+
+    /*
+     * @method toString
+     * @return {String}
+     */
+
+    WeakMapPolyfill.prototype.toString = function toString$$1() {
+      return '[object WeakMap]';
+    };
+
+    return WeakMapPolyfill;
+  }();
+
+  var WeakMap$1 = emberUtils.HAS_NATIVE_WEAKMAP ? WeakMap : WeakMapPolyfill;
+
   exports.runInTransaction = void 0;
   exports.didRender = void 0;
   exports.assertNotRendered = void 0;
@@ -1996,80 +2136,200 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   // detect-backtracking-rerender by default is debug build only
   // detect-glimmer-allow-backtracking-rerender can be enabled in custom builds
   if (ember_features.EMBER_GLIMMER_DETECT_BACKTRACKING_RERENDER || ember_features.EMBER_GLIMMER_ALLOW_BACKTRACKING_RERENDER) {
-    var counter = 0;
-    var inTransaction = false;
-    var shouldReflush = void 0;
-    var debugStack = void 0;
 
-    exports.runInTransaction = function (context$$1, methodName) {
-      shouldReflush = false;
-      inTransaction = true;
-      {
-        debugStack = context$$1.env.debugStack;
-      }
-      context$$1[methodName]();
-      inTransaction = false;
-      counter++;
-      return shouldReflush;
-    };
+    // there are 4 states
 
-    exports.didRender = function (object, key, reference) {
-      if (!inTransaction) {
-        return;
-      }
-      var meta$$1 = meta(object);
-      var lastRendered = meta$$1.writableLastRendered();
-      lastRendered[key] = counter;
+    // NATIVE WEAKMAP AND DEBUG
+    // tracks lastRef and lastRenderedIn per rendered object and key during a transaction
+    // release everything via normal weakmap semantics by just derefencing the weakmap
 
-      {
-        var referenceMap = meta$$1.writableLastRenderedReferenceMap();
-        referenceMap[key] = reference;
+    // NATIVE WEAKMAP AND RELEASE
+    // tracks transactionId per rendered object and key during a transaction
+    // release everything via normal weakmap semantics by just derefencing the weakmap
+
+    // WEAKMAP POLYFILL AND DEBUG
+    // tracks lastRef and lastRenderedIn per rendered object and key during a transaction
+    // since lastRef retains a lot of app state (will have a ref to the Container)
+    // if the object rendered is retained (like a immutable POJO in module state)
+    // during acceptance tests this adds up and obfuscates finding other leaks.
+
+    // WEAKMAP POLYFILL AND RELEASE
+    // tracks transactionId per rendered object and key during a transaction
+    // leaks it because small and likely not worth tracking it since it will only
+    // be leaked if the object is retained
 
-        var templateMap = meta$$1.writableLastRenderedTemplateMap();
-        if (templateMap[key] === undefined) {
-          templateMap[key] = debugStack.peek();
+    var TransactionRunner = function () {
+      function TransactionRunner() {
+        emberBabel.classCallCheck(this, TransactionRunner);
+
+        this.transactionId = 0;
+        this.inTransaction = false;
+        this.shouldReflush = false;
+        this.weakMap = new WeakMap$1();
+        {
+          // track templates
+          this.debugStack = undefined;
+
+          if (!emberUtils.HAS_NATIVE_WEAKMAP) {
+            // DEBUG AND POLYFILL
+            // needs obj tracking
+            this.objs = [];
+          }
         }
       }
-    };
 
-    exports.assertNotRendered = function (object, key, _meta) {
-      var meta$$1 = _meta || meta(object);
-      var lastRendered = meta$$1.readableLastRendered();
+      TransactionRunner.prototype.runInTransaction = function runInTransaction(context$$1, methodName) {
+        this.before(context$$1);
+        try {
+          context$$1[methodName]();
+        } finally {
+          this.after();
+        }
+        return this.shouldReflush;
+      };
 
-      if (lastRendered && lastRendered[key] === counter) {
+      TransactionRunner.prototype.didRender = function didRender(object, key, reference) {
+        if (!this.inTransaction) {
+          return;
+        }
         {
-          var templateMap = meta$$1.readableLastRenderedTemplateMap();
-          var lastRenderedIn = templateMap[key];
-          var currentlyIn = debugStack.peek();
-
-          var referenceMap = meta$$1.readableLastRenderedReferenceMap();
-          var lastRef = referenceMap[key];
-          var parts = [];
-          var label = void 0;
-
-          if (lastRef) {
-            while (lastRef && lastRef._propertyKey) {
-              parts.unshift(lastRef._propertyKey);
-              lastRef = lastRef._parentReference;
+          this.setKey(object, key, {
+            lastRef: reference,
+            lastRenderedIn: this.debugStack.peek()
+          });
+        }
+      };
+
+      TransactionRunner.prototype.assertNotRendered = function assertNotRendered(object, key) {
+        if (!this.inTransaction) {
+          return;
+        }
+        if (this.hasRendered(object, key)) {
+          {
+            var _getKey = this.getKey(object, key),
+                lastRef = _getKey.lastRef,
+                lastRenderedIn = _getKey.lastRenderedIn;
+
+            var currentlyIn = this.debugStack.peek();
+
+            var parts = [];
+            var label = void 0;
+
+            if (lastRef !== undefined) {
+              while (lastRef && lastRef._propertyKey) {
+                parts.unshift(lastRef._propertyKey);
+                lastRef = lastRef._parentReference;
+              }
+
+              label = parts.join('.');
+            } else {
+              label = 'the same value';
             }
 
-            label = parts.join('.');
-          } else {
-            label = 'the same value';
+            var message = 'You modified "' + label + '" twice on ' + object + ' in a single render. It was rendered in ' + lastRenderedIn + ' and modified in ' + currentlyIn + '. This was unreliable and slow in Ember 1.x and';
+
+            if (ember_features.EMBER_GLIMMER_ALLOW_BACKTRACKING_RERENDER) {
+              true && !false && emberDebug.deprecate(message + ' will be removed in Ember 3.0.', false, { id: 'ember-views.render-double-modify', until: '3.0.0' });
+            } else {
+              true && !false && emberDebug.assert(message + ' is no longer supported. See https://github.com/emberjs/ember.js/issues/13948 for more details.', false);
+            }
           }
 
-          var message = 'You modified "' + label + '" twice on ' + object + ' in a single render. It was rendered in ' + lastRenderedIn + ' and modified in ' + currentlyIn + '. This was unreliable and slow in Ember 1.x and';
+          this.shouldReflush = true;
+        }
+      };
 
-          if (ember_features.EMBER_GLIMMER_ALLOW_BACKTRACKING_RERENDER) {
-            true && !false && emberDebug.deprecate(message + ' will be removed in Ember 3.0.', false, { id: 'ember-views.render-double-modify', until: '3.0.0' });
-          } else {
-            true && !false && emberDebug.assert(message + ' is no longer supported. See https://github.com/emberjs/ember.js/issues/13948 for more details.', false);
+      TransactionRunner.prototype.hasRendered = function hasRendered(object, key) {
+        if (!this.inTransaction) {
+          return false;
+        }
+        {
+          return this.getKey(object, key) !== undefined;
+        }
+        return this.getKey(object, key) === this.transactionId;
+      };
+
+      TransactionRunner.prototype.before = function before(context$$1) {
+        this.inTransaction = true;
+        this.shouldReflush = false;
+        {
+          this.debugStack = context$$1.env.debugStack;
+        }
+      };
+
+      TransactionRunner.prototype.after = function after() {
+        this.transactionId++;
+        this.inTransaction = false;
+        {
+          this.debugStack = undefined;
+        }
+        this.clearObjectMap();
+      };
+
+      TransactionRunner.prototype.createMap = function createMap(object) {
+        var map = Object.create(null);
+        this.weakMap.set(object, map);
+        if (true && !emberUtils.HAS_NATIVE_WEAKMAP) {
+          // POLYFILL AND DEBUG
+          // requires tracking objects
+          this.objs.push(object);
+        }
+        return map;
+      };
+
+      TransactionRunner.prototype.getOrCreateMap = function getOrCreateMap(object) {
+        var map = this.weakMap.get(object);
+        if (map === undefined) {
+          map = this.createMap(object);
+        }
+        return map;
+      };
+
+      TransactionRunner.prototype.setKey = function setKey(object, key, value) {
+        var map = this.getOrCreateMap(object);
+        map[key] = value;
+      };
+
+      TransactionRunner.prototype.getKey = function getKey(object, key) {
+        var map = this.weakMap.get(object);
+        if (map !== undefined) {
+          return map[key];
+        }
+      };
+
+      TransactionRunner.prototype.clearObjectMap = function clearObjectMap() {
+        if (emberUtils.HAS_NATIVE_WEAKMAP) {
+          // NATIVE AND (DEBUG OR RELEASE)
+          // if we have a real native weakmap
+          // releasing the ref will allow the values to be GCed
+          this.weakMap = new WeakMap$1();
+        } else {
+          // POLYFILL AND DEBUG
+          // with a polyfill the weakmap keys must be cleared since
+          // they have the last reference, acceptance tests will leak
+          // the container if you render a immutable object retained
+          // in module scope.
+          var objs = this.objs,
+              weakMap = this.weakMap;
+
+          this.objs = [];
+          for (var i = 0; i < objs.length; i++) {
+            weakMap.delete(objs[i]);
           }
         }
+        // POLYFILL AND RELEASE
+        // we leak the key map if the object is retained but this is
+        // a POJO of keys to transaction ids
+      };
 
-        shouldReflush = true;
-      }
-    };
+      return TransactionRunner;
+    }();
+
+    var runner = new TransactionRunner();
+
+    exports.runInTransaction = runner.runInTransaction.bind(runner);
+    exports.didRender = runner.didRender.bind(runner);
+    exports.assertNotRendered = runner.assertNotRendered.bind(runner);
   } else {
     // in production do nothing to detect reflushes
     exports.runInTransaction = function (context$$1, methodName) {
@@ -3230,14 +3490,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       // inherited, and we can optimize it much better than JS runtimes.
       this.parent = parentMeta;
 
-      if (ember_features.EMBER_GLIMMER_DETECT_BACKTRACKING_RERENDER || ember_features.EMBER_GLIMMER_ALLOW_BACKTRACKING_RERENDER) {
-        this._lastRendered = undefined;
-        {
-          this._lastRenderedReferenceMap = undefined;
-          this._lastRenderedTemplateMap = undefined;
-        }
-      }
-
       this._listeners = undefined;
       this._listenersFinalized = false;
       this._suspendedListeners = undefined;
@@ -3605,29 +3857,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     return Meta;
   }();
 
-  if (ember_features.EMBER_GLIMMER_DETECT_BACKTRACKING_RERENDER || ember_features.EMBER_GLIMMER_ALLOW_BACKTRACKING_RERENDER) {
-    Meta.prototype.writableLastRendered = function () {
-      return this._getOrCreateOwnMap('_lastRendered');
-    };
-    Meta.prototype.readableLastRendered = function () {
-      return this._lastRendered;
-    };
-    {
-      Meta.prototype.writableLastRenderedReferenceMap = function () {
-        return this._getOrCreateOwnMap('_lastRenderedReferenceMap');
-      };
-      Meta.prototype.readableLastRenderedReferenceMap = function () {
-        return this._lastRenderedReferenceMap;
-      };
-      Meta.prototype.writableLastRenderedTemplateMap = function () {
-        return this._getOrCreateOwnMap('_lastRenderedTemplateMap');
-      };
-      Meta.prototype.readableLastRenderedTemplateMap = function () {
-        return this._lastRenderedTemplateMap;
-      };
-    }
-  }
-
   for (var name in protoMethods) {
     Meta.prototype[name] = protoMethods[name];
   }
@@ -5356,146 +5585,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     }
   }
 
-  /**
-   @module ember
-  */
-  var id = 0;
-
-  // Returns whether Type(value) is Object according to the terminology in the spec
-  function isObject$1(value) {
-    return typeof value === 'object' && value !== null || typeof value === 'function';
-  }
-
-  /*
-   * @class Ember.WeakMap
-   * @public
-   * @category ember-metal-weakmap
-   *
-   * A partial polyfill for [WeakMap](http://www.ecma-international.org/ecma-262/6.0/#sec-weakmap-objects).
-   *
-   * There is a small but important caveat. This implementation assumes that the
-   * weak map will live longer (in the sense of garbage collection) than all of its
-   * keys, otherwise it is possible to leak the values stored in the weak map. In
-   * practice, most use cases satisfy this limitation which is why it is included
-   * in ember-metal.
-   */
-  var WeakMapPolyfill = function () {
-    function WeakMapPolyfill(iterable) {
-      emberBabel.classCallCheck(this, WeakMapPolyfill);
-
-      this._id = emberUtils.GUID_KEY + id++;
-
-      if (iterable === null || iterable === undefined) {
-        return;
-      } else if (Array.isArray(iterable)) {
-        for (var i = 0; i < iterable.length; i++) {
-          var _iterable$i = iterable[i],
-              key = _iterable$i[0],
-              value = _iterable$i[1];
-
-          this.set(key, value);
-        }
-      } else {
-        throw new TypeError('The weak map constructor polyfill only supports an array argument');
-      }
-    }
-
-    /*
-     * @method get
-     * @param key {Object | Function}
-     * @return {Any} stored value
-     */
-
-    WeakMapPolyfill.prototype.get = function get(obj) {
-      if (!isObject$1(obj)) {
-        return undefined;
-      }
-
-      var meta$$1 = exports.peekMeta(obj);
-      if (meta$$1 !== undefined) {
-        var map = meta$$1.readableWeak();
-        if (map !== undefined) {
-          var val = map[this._id];
-          if (val === UNDEFINED) {
-            return undefined;
-          }
-          return val;
-        }
-      }
-    };
-
-    /*
-     * @method set
-     * @param key {Object | Function}
-     * @param value {Any}
-     * @return {WeakMap} the weak map
-     */
-
-    WeakMapPolyfill.prototype.set = function set(obj, value) {
-      if (!isObject$1(obj)) {
-        throw new TypeError('Invalid value used as weak map key');
-      }
-
-      if (value === undefined) {
-        value = UNDEFINED;
-      }
-
-      meta(obj).writableWeak()[this._id] = value;
-
-      return this;
-    };
-
-    /*
-     * @method has
-     * @param key {Object | Function}
-     * @return {boolean} if the key exists
-     */
-
-    WeakMapPolyfill.prototype.has = function has(obj) {
-      if (!isObject$1(obj)) {
-        return false;
-      }
-
-      var meta$$1 = exports.peekMeta(obj);
-      if (meta$$1 !== undefined) {
-        var map = meta$$1.readableWeak();
-        if (map !== undefined) {
-          return map[this._id] !== undefined;
-        }
-      }
-
-      return false;
-    };
-
-    /*
-     * @method delete
-     * @param key {Object | Function}
-     * @return {boolean} if the key was deleted
-     */
-
-    WeakMapPolyfill.prototype.delete = function _delete(obj) {
-      if (this.has(obj)) {
-        delete exports.peekMeta(obj).writableWeak()[this._id];
-        return true;
-      } else {
-        return false;
-      }
-    };
-
-    /*
-     * @method toString
-     * @return {String}
-     */
-
-    WeakMapPolyfill.prototype.toString = function toString$$1() {
-      return '[object WeakMap]';
-    };
-
-    return WeakMapPolyfill;
-  }();
-
-  var weak_map = emberUtils.HAS_NATIVE_WEAKMAP ? WeakMap : WeakMapPolyfill;
-
   /**
    @module @ember/utils
   */
@@ -8668,7 +8757,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   exports.getWithDefault = getWithDefault;
   exports.set = set;
   exports.trySet = trySet;
-  exports.WeakMap = weak_map;
+  exports.WeakMap = WeakMap$1;
   exports.WeakMapPolyfill = WeakMapPolyfill;
   exports.addListener = addListener;
   exports.hasListeners = hasListeners;