ember-source 4.1.0-alpha.7 → 4.2.0-alpha.2

package/dist/header/license.js

@@ -5,5 +5,5 @@
  *            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   4.1.0-alpha.7
+ * @version   4.2.0-alpha.2
  */

package/dist/packages/@ember/-internals/glimmer/index.js

@@ -4483,6 +4483,11 @@ setGlobalContext({
       let {
         id
       } = options;
+
+      if (id === 'argument-less-helper-paren-less-invocation') {
+        throw new Error(`A resolved helper cannot be passed as a named argument as the syntax is ` + `ambiguously a pass-by-reference or invocation. Use the ` + `\`{{helper 'foo-helper}}\` helper to pass by reference or explicitly ` + `invoke the helper with parens: \`{{(fooHelper)}}\`.`);
+      }
+
       let override = VM_DEPRECATION_OVERRIDES.filter(o => o.id === id)[0];
       if (!override) throw new Error(`deprecation override for ${id} not found`); // allow deprecations to be disabled in the VM_DEPRECATION_OVERRIDES array below
 
@@ -4507,14 +4512,6 @@ if (DEBUG) {
 
 
 const VM_DEPRECATION_OVERRIDES = [{
-  id: 'argument-less-helper-paren-less-invocation',
-  url: 'https://deprecations.emberjs.com/v3.x#toc_argument-less-helper-paren-less-invocation',
-  until: '4.0.0',
-  for: 'ember-source',
-  since: {
-    enabled: '3.27.0'
-  }
-}, {
   id: 'setting-on-hash',
   until: '4.4.0',
   for: 'ember-source',

package/dist/packages/@ember/-internals/metal/index.js

@@ -1,5 +1,5 @@
 import { meta, peekMeta } from '@ember/-internals/meta';
-import { setListeners, isObject, setupMandatorySetter, symbol, toString, enumerableSymbol, getDebugName, inspect, setWithMandatorySetter, Cache, isEmberArray, setProxy, lookupDescriptor, getName, setName, guidFor, makeArray, observerListenerMetaFor, ROOT, setObservers, wrap } from '@ember/-internals/utils';
+import { setListeners, isObject, setupMandatorySetter, symbol, toString, enumerableSymbol, inspect, setWithMandatorySetter, Cache, isEmberArray, setProxy, lookupDescriptor, getName, setName, guidFor, makeArray, observerListenerMetaFor, ROOT, setObservers, wrap } from '@ember/-internals/utils';
 import { assert, deprecate, debug, warn } from '@ember/debug';
 import { ENV, context } from '@ember/-internals/environment';
 import { schedule } from '@ember/runloop';
@@ -651,43 +651,29 @@ function replaceInNativeArray(array, start, deleteCount, items) {
   arrayContentDidChange(array, start, deleteCount, items.length);
 }
 
-function arrayObserversHelper(obj, target, opts, operation, notify) {
-  let willChange = opts && opts.willChange || 'arrayWillChange';
-  let didChange = opts && opts.didChange || 'arrayDidChange';
-  let hasObservers = obj.hasArrayObservers;
+function arrayObserversHelper(obj, target, opts, operation) {
+  var _a;
+
+  let {
+    willChange,
+    didChange
+  } = opts;
   operation(obj, '@array:before', target, willChange);
   operation(obj, '@array:change', target, didChange);
+  /*
+   * Array proxies have a `_revalidate` method which must be called to set
+   * up their internal array observation systems.
+   */
 
-  if (hasObservers === notify) {
-    notifyPropertyChange(obj, 'hasArrayObservers');
-  }
-
+  (_a = obj._revalidate) === null || _a === void 0 ? void 0 : _a.call(obj);
   return obj;
 }
 
-function addArrayObserver(array, target, opts, suppress = false) {
-  deprecate(`Array observers have been deprecated. Added an array observer to ${getDebugName === null || getDebugName === void 0 ? void 0 : getDebugName(array)}.`, suppress, {
-    id: 'array-observers',
-    url: 'https://deprecations.emberjs.com/v3.x#toc_array-observers',
-    until: '4.0.0',
-    for: 'ember-source',
-    since: {
-      enabled: '3.26.0-beta.1'
-    }
-  });
-  return arrayObserversHelper(array, target, opts, addListener, false);
+function addArrayObserver(array, target, opts) {
+  return arrayObserversHelper(array, target, opts, addListener);
 }
-function removeArrayObserver(array, target, opts, suppress = false) {
-  deprecate(`Array observers have been deprecated. Removed an array observer from ${getDebugName === null || getDebugName === void 0 ? void 0 : getDebugName(array)}.`, suppress, {
-    id: 'array-observers',
-    url: 'https://deprecations.emberjs.com/v3.x#toc_array-observers',
-    until: '4.0.0',
-    for: 'ember-source',
-    since: {
-      enabled: '3.26.0-beta.1'
-    }
-  });
-  return arrayObserversHelper(array, target, opts, removeListener, true);
+function removeArrayObserver(array, target, opts) {
+  return arrayObserversHelper(array, target, opts, removeListener);
 }
 
 const CHAIN_PASS_THROUGH = new _WeakSet();

package/dist/packages/@ember/-internals/routing/lib/services/router.js

@@ -373,7 +373,7 @@ export default class RouterService extends Service {
 
 }
 
-if (false
+if (true
 /* EMBER_ROUTING_ROUTER_SERVICE_REFRESH */
 ) {
   RouterService.reopen({

package/dist/packages/@ember/-internals/routing/lib/system/route.js

@@ -14,7 +14,6 @@ import { isProxy, lookupDescriptor, symbol } from '@ember/-internals/utils';
 import { assert, info, isTesting } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { once } from '@ember/runloop';
-import { classify } from '@ember/string';
 import { DEBUG } from '@glimmer/env';
 import { PARAMS_SYMBOL, STATE_SYMBOL } from 'router_js';
 import { calculateCacheKey, deprecateTransitionMethods, normalizeControllerQueryParams, prefixRouteNameArg, stashParamNames } from '../utils';
@@ -255,7 +254,8 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   _optionsForQueryParam(qp) {
-    return get(this, `queryParams.${qp.urlKey}`) || get(this, `queryParams.${qp.prop}`) || {};
+    const queryParams = get(this, 'queryParams');
+    return get(queryParams, qp.urlKey) || get(queryParams, qp.prop) || queryParams[qp.urlKey] || queryParams[qp.prop] || {};
   }
   /**
     A hook you can use to reset controller values either when the model
@@ -1331,18 +1331,17 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
   get store() {
     let owner = getOwner(this);
     let routeName = this.routeName;
-    let namespace = get(this, '_router.namespace');
     return {
       find(name, value) {
         let modelClass = owner.factoryFor(`model:${name}`);
-        assert(`You used the dynamic segment ${name}_id in your route ${routeName}, but ${namespace}.${classify(name)} did not exist and you did not override your route's \`model\` hook.`, Boolean(modelClass));
+        assert(`You used the dynamic segment \`${name}_id\` in your route ` + `\`${routeName}\` for which Ember requires you provide a ` + `data-loading implementation. Commonly, that is done by ` + `adding a model hook implementation on the route ` + `(\`model({${name}_id}) {\`) or by injecting an implemention of ` + `a data store: \`@service store;\`.`, Boolean(modelClass));
 
         if (!modelClass) {
           return;
         }
 
         modelClass = modelClass.class;
-        assert(`${classify(name)} has no method \`find\`.`, typeof modelClass.find === 'function');
+        assert(`You used the dynamic segment \`${name}_id\` in your route ` + `\`${routeName}\` for which Ember requires you provide a ` + `data-loading implementation. Commonly, that is done by ` + `adding a model hook implementation on the route ` + `(\`model({${name}_id}) {\`) or by injecting an implemention of ` + `a data store: \`@service store;\`.\n\n` + `Rarely, applications may attempt to use a legacy behavior where ` + `the model class (in this case \`${name}\`) is resolved and the ` + `\`find\` method on that class is invoked to load data. In this ` + `application, a model of \`${name}\` was found but it did not ` + `provide a \`find\` method. You should not add a \`find\` ` + `method to your model. Instead, please implement an appropriate ` + `\`model\` hook on the \`${routeName}\` route.`, typeof modelClass.find === 'function');
         return modelClass.find(value);
       }
 

package/dist/packages/@ember/-internals/runtime/lib/mixins/array.js

@@ -4,7 +4,7 @@
 import { DEBUG } from '@glimmer/env';
 import { PROXY_CONTENT } from '@ember/-internals/metal';
 import { setEmberArray } from '@ember/-internals/utils';
-import { get, set, objectAt, replaceInNativeArray, replace, computed, Mixin, hasListeners, beginPropertyChanges, endPropertyChanges, addArrayObserver, removeArrayObserver, arrayContentWillChange, arrayContentDidChange, nativeDescDecorator as descriptor } from '@ember/-internals/metal';
+import { get, set, objectAt, replaceInNativeArray, replace, computed, Mixin, beginPropertyChanges, endPropertyChanges } from '@ember/-internals/metal';
 import { assert } from '@ember/debug';
 import Enumerable from './enumerable';
 import compare from '../compare';
@@ -441,177 +441,6 @@ const ArrayMixin = Mixin.create(Enumerable, {
     return -1;
   },
 
-  // ..........................................................
-  // ARRAY OBSERVERS
-  //
-
-  /**
-    Adds an array observer to the receiving array. The array observer object
-    normally must implement two methods:
-     * `willChange(observedObj, start, removeCount, addCount)` - This method will be
-      called just before the array is modified.
-    * `didChange(observedObj, start, removeCount, addCount)` - This method will be
-      called just after the array is modified.
-     Both callbacks will be passed the observed object, starting index of the
-    change as well as a count of the items to be removed and added. You can use
-    these callbacks to optionally inspect the array during the change, clear
-    caches, or do any other bookkeeping necessary.
-     In addition to passing a target, you can also include an options hash
-    which you can use to override the method names that will be invoked on the
-    target.
-     @method addArrayObserver
-    @param {Object} target The observer object.
-    @param {Object} opts Optional hash of configuration options including
-      `willChange` and `didChange` option.
-    @return {EmberArray} receiver
-    @public
-    @example
-        import Service from '@ember/service';
-         export default Service.extend({
-          data: Ember.A(),
-           init() {
-            this._super(...arguments);
-             this.data.addArrayObserver(this, {
-              willChange: 'dataWillChange',
-              didChange: 'dataDidChange'
-            });
-          },
-           dataWillChange(array, start, removeCount, addCount) {
-            console.log('array will change', array, start, removeCount, addCount);
-          },
-           dataDidChange(array, start, removeCount, addCount) {
-            console.log('array did change', array, start, removeCount, addCount);
-          }
-        });
-  */
-  addArrayObserver(target, opts) {
-    return addArrayObserver(this, target, opts);
-  },
-
-  /**
-    Removes an array observer from the object if the observer is current
-    registered. Calling this method multiple times with the same object will
-    have no effect.
-     @method removeArrayObserver
-    @param {Object} target The object observing the array.
-    @param {Object} opts Optional hash of configuration options including
-      `willChange` and `didChange` option.
-    @return {EmberArray} receiver
-    @public
-  */
-  removeArrayObserver(target, opts) {
-    return removeArrayObserver(this, target, opts);
-  },
-
-  /**
-    Becomes true whenever the array currently has observers watching changes
-    on the array.
-     ```javascript
-    let arr = [1, 2, 3, 4, 5];
-    arr.hasArrayObservers; // false
-     arr.addArrayObserver(this, {
-      willChange() {
-        console.log('willChange');
-      }
-    });
-    arr.hasArrayObservers; // true
-    ```
-     @property {Boolean} hasArrayObservers
-    @public
-  */
-  hasArrayObservers: descriptor({
-    configurable: true,
-    enumerable: false,
-
-    get() {
-      return hasListeners(this, '@array:change') || hasListeners(this, '@array:before');
-    }
-
-  }),
-
-  /**
-    If you are implementing an object that supports `EmberArray`, call this
-    method just before the array content changes to notify any observers and
-    invalidate any related properties. Pass the starting index of the change
-    as well as a delta of the amounts to change.
-     ```app/components/show-post.js
-    import Component from '@ember/component';
-    import EmberObject from '@ember/object';
-     const Post = EmberObject.extend({
-      body: '',
-      save() {}
-    })
-     export default Component.extend({
-      attemptsToModify: 0,
-      successfulModifications: 0,
-      posts: null,
-       init() {
-        this._super(...arguments);
-         this.posts = [1, 2, 3].map(i => Post.create({ body: i }));
-        this.posts.addArrayObserver(this, {
-          willChange() {
-            this.incrementProperty('attemptsToModify');
-          },
-          didChange() {
-            this.incrementProperty('successfulModifications');
-          }
-        });
-      },
-       actions: {
-        editPost(post, newContent) {
-          let oldContent = post.body,
-              postIndex = this.posts.indexOf(post);
-           this.posts.arrayContentWillChange(postIndex, 0, 0); // attemptsToModify = 1
-          post.set('body', newContent);
-           post.save()
-            .then(response => {
-              this.posts.arrayContentDidChange(postIndex, 0, 0); // successfulModifications = 1
-            })
-            .catch(error => {
-              post.set('body', oldContent);
-            })
-        }
-      }
-    });
-    ```
-     @method arrayContentWillChange
-    @param {Number} startIdx The starting index in the array that will change.
-    @param {Number} removeAmt The number of items that will be removed. If you
-      pass `null` assumes 0
-    @param {Number} addAmt The number of items that will be added. If you
-      pass `null` assumes 0.
-    @return {EmberArray} receiver
-    @public
-  */
-  arrayContentWillChange(startIdx, removeAmt, addAmt) {
-    return arrayContentWillChange(this, startIdx, removeAmt, addAmt);
-  },
-
-  /**
-    If you are implementing an object that supports `EmberArray`, call this
-    method just after the array content changes to notify any observers and
-    invalidate any related properties. Pass the starting index of the change
-    as well as a delta of the amounts to change.
-     ```javascript
-    let arr = [1, 2, 3, 4, 5];
-     arr.copyWithin(-2); // [1, 2, 3, 1, 2]
-    // arr.lastObject = 5
-    arr.arrayContentDidChange(3, 2, 2);
-    // arr.lastObject = 2
-    ```
-     @method arrayContentDidChange
-    @param {Number} startIdx The starting index in the array that did change.
-    @param {Number} removeAmt The number of items that were removed. If you
-      pass `null` assumes 0
-    @param {Number} addAmt The number of items that were added. If you
-      pass `null` assumes 0.
-    @return {EmberArray} receiver
-    @public
-  */
-  arrayContentDidChange(startIdx, removeAmt, addAmt) {
-    return arrayContentDidChange(this, startIdx, removeAmt, addAmt);
-  },
-
   /**
     Iterates through the array, calling the passed function on each
     item. This method corresponds to the `forEach()` method defined in
@@ -1339,7 +1168,7 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
     __Required.__ You must implement this method to apply this mixin.
      This is one of the primitives you must implement to support `Array`.
     You should replace amt objects started at idx with the objects in the
-    passed array. You should also call `this.arrayContentDidChange()`
+    passed array.
      Note that this method is expected to validate the type(s) of objects that it expects.
      @method replace
     @param {Number} idx Starting index in the array to replace. If

package/dist/packages/@ember/-internals/runtime/lib/system/array_proxy.js

@@ -1,7 +1,7 @@
 /**
 @module @ember/array
 */
-import { get, objectAt, alias, PROPERTY_DID_CHANGE, addArrayObserver, removeArrayObserver, replace, arrayContentDidChange, tagForProperty } from '@ember/-internals/metal';
+import { get, objectAt, alias, PROPERTY_DID_CHANGE, addArrayObserver, removeArrayObserver, replace, arrayContentDidChange, arrayContentWillChange, tagForProperty } from '@ember/-internals/metal';
 import { isObject } from '@ember/-internals/utils';
 import EmberObject from './object';
 import { isArray, MutableArray } from '../mixins/array';
@@ -237,11 +237,11 @@ export default class ArrayProxy extends EmberObject {
 
     this._removeArrangedContentArrayObserver();
 
-    this.arrayContentWillChange(0, oldLength, newLength);
+    arrayContentWillChange(this, 0, oldLength, newLength);
 
     this._invalidate();
 
-    this.arrayContentDidChange(0, oldLength, newLength);
+    arrayContentDidChange(this, 0, oldLength, newLength, false);
 
     this._addArrangedContentArrayObserver(arrangedContent);
   }
@@ -250,21 +250,21 @@ export default class ArrayProxy extends EmberObject {
     if (arrangedContent && !arrangedContent.isDestroyed) {
       assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
       assert(`ArrayProxy expects an Array or ArrayProxy, but you passed ${typeof arrangedContent}`, isArray(arrangedContent) || arrangedContent.isDestroyed);
-      addArrayObserver(arrangedContent, this, ARRAY_OBSERVER_MAPPING, true);
+      addArrayObserver(arrangedContent, this, ARRAY_OBSERVER_MAPPING);
       this._arrangedContent = arrangedContent;
     }
   }
 
   _removeArrangedContentArrayObserver() {
     if (this._arrangedContent) {
-      removeArrayObserver(this._arrangedContent, this, ARRAY_OBSERVER_MAPPING, true);
+      removeArrayObserver(this._arrangedContent, this, ARRAY_OBSERVER_MAPPING);
     }
   }
 
   _arrangedContentArrayWillChange() {}
 
   _arrangedContentArrayDidChange(proxy, idx, removedCnt, addedCnt) {
-    this.arrayContentWillChange(idx, removedCnt, addedCnt);
+    arrayContentWillChange(this, idx, removedCnt, addedCnt);
     let dirtyIndex = idx;
 
     if (dirtyIndex < 0) {
@@ -277,7 +277,7 @@ export default class ArrayProxy extends EmberObject {
     }
 
     this._lengthDirty = true;
-    this.arrayContentDidChange(idx, removedCnt, addedCnt);
+    arrayContentDidChange(this, idx, removedCnt, addedCnt, false);
   }
 
   _invalidate() {
@@ -324,12 +324,5 @@ ArrayProxy.reopen(MutableArray, {
      @property arrangedContent
     @public
   */
-  arrangedContent: alias('content'),
-
-  // Array proxies don't need to notify when they change since their `[]` tag is
-  // already dependent on the `[]` tag of `arrangedContent`
-  arrayContentDidChange(startIdx, removeAmt, addAmt) {
-    return arrayContentDidChange(this, startIdx, removeAmt, addAmt, false);
-  }
-
+  arrangedContent: alias('content')
 });

package/dist/packages/@ember/canary-features/index.js

@@ -18,7 +18,7 @@ export const DEFAULT_FEATURES = {
   EMBER_GLIMMER_INVOKE_HELPER: true,
   EMBER_STRICT_MODE: true,
   EMBER_DYNAMIC_HELPERS_AND_MODIFIERS: true,
-  EMBER_ROUTING_ROUTER_SERVICE_REFRESH: null,
+  EMBER_ROUTING_ROUTER_SERVICE_REFRESH: true,
   EMBER_CACHED: true
 };
 /**

package/dist/packages/@ember/destroyable/index.js

@@ -22,7 +22,9 @@ import { registerDestructor as _registerDestructor, unregisterDestructor as _unr
 
   ```js
   class CustomSelect extends Component {
-    constructor() {
+    constructor(...args) {
+      super(...args);
+
       // obj is now a child of the component. When the component is destroyed,
       // obj will also be destroyed, and have all of its destructors triggered.
       this.obj = associateDestroyableChild(this, {});
@@ -153,12 +155,15 @@ import { registerDestructor as _registerDestructor, unregisterDestructor as _unr
   parent is destroyed, the destructor function will be called.
 
   ```js
+  import Component from '@glimmer/component';
   import { registerDestructor } from '@ember/destroyable';
 
   class Modal extends Component {
     @service resize;
 
-    constructor() {
+    constructor(...args) {
+      super(...args);
+
       this.resize.register(this, this.layout);
 
       registerDestructor(this, () => this.resize.unregister(this));
@@ -175,6 +180,7 @@ import { registerDestructor as _registerDestructor, unregisterDestructor as _unr
   than creating a closure function per destroyable.
 
   ```js
+  import Component from '@glimmer/component';
   import { registerDestructor } from '@ember/destroyable';
 
   function unregisterResize(instance) {
@@ -184,7 +190,9 @@ import { registerDestructor as _registerDestructor, unregisterDestructor as _unr
   class Modal extends Component {
     @service resize;
 
-    constructor() {
+    constructor(...args) {
+      super(...args);
+
       this.resize.register(this, this.layout);
 
       registerDestructor(this, unregisterResize);
@@ -208,12 +216,15 @@ export function registerDestructor(destroyable, destructor) {
   from the destroyable.
 
   ```js
+  import Component from '@glimmer/component';
   import { registerDestructor, unregisterDestructor } from '@ember/destroyable';
 
   class Modal extends Component {
     @service modals;
 
-    constructor() {
+    constructor(...args) {
+      super(...args);
+
       this.modals.add(this);
 
       this.modalDestructor = registerDestructor(this, () => this.modals.remove(this));

package/dist/packages/ember/version.js

@@ -1 +1 @@
-export default "4.1.0-alpha.7";
+export default "4.2.0-alpha.2";