ember-source 3.28.5 → 4.0.0-beta.10

package/dist/packages/@ember/object/lib/computed/reduce_computed_macros.js

@@ -7,7 +7,7 @@ import { computed, autoComputed, get, isElementDescriptor } from '@ember/-intern
 import { compare, isArray, A as emberA, uniqBy as uniqByArray } from '@ember/-internals/runtime';
 
 function reduceMacro(dependentKey, callback, initialValue, name) {
-  assert(`Dependent key passed to \`computed.${name}\` shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey));
+  assert(`Dependent key passed to \`${name}\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey));
   return computed(`${dependentKey}.[]`, function () {
     let arr = get(this, dependentKey);
 
@@ -42,7 +42,7 @@ function arrayMacro(dependentKey, additionalDependentKeys, callback) {
 }
 
 function multiArrayMacro(_dependentKeys, callback, name) {
-  assert(`Dependent keys passed to \`computed.${name}\` shouldn't contain brace expanding pattern.`, _dependentKeys.every(dependentKey => !/[[\]{}]/g.test(dependentKey)));
+  assert(`Dependent keys passed to \`${name}\` computed macro shouldn't contain brace expanding pattern.`, _dependentKeys.every(dependentKey => !/[[\]{}]/g.test(dependentKey)));
 
   let dependentKeys = _dependentKeys.map(key => `${key}.[]`);
 
@@ -69,23 +69,6 @@ function multiArrayMacro(_dependentKeys, callback, name) {
   invoice.total; // 13.49
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { sum } from '@ember/object/computed';
-
-  let Invoice = EmberObject.extend({
-    lineItems: [1.00, 2.50, 9.99],
-
-    total: sum('lineItems')
-  })
-
-  let invoice = Invoice.create();
-
-  invoice.total; // 13.49
-  ```
-
   @method sum
   @for @ember/object/computed
   @static
@@ -143,42 +126,6 @@ export function sum(dependentKey) {
   lordByron.maxChildAge; // 8
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject, { set } from '@ember/object';
-  import { mapBy, max } from '@ember/object/computed';
-
-  let Person = EmberObject.extend({
-    childAges: mapBy('children', 'age'),
-    maxChildAge: max('childAges')
-  });
-
-  let lordByron = Person.create({ children: [] });
-
-  lordByron.maxChildAge; // -Infinity
-
-  set(lordByron, 'children', [
-    {
-      name: 'Augusta Ada Byron',
-      age: 7
-    }
-  ]);
-  lordByron.maxChildAge; // 7
-
-  set(lordByron, 'children', [
-    ...lordByron.children,
-    {
-      name: 'Allegra Byron',
-      age: 5
-    }, {
-      name: 'Elizabeth Medora Leigh',
-      age: 8
-    }
-  ]);
-  lordByron.maxChildAge; // 8
-  ```
-
   If the types of the arguments are not numbers, they will be converted to
   numbers and the type of the return value will always be `Number`. For example,
   the max of a list of Date objects will be the highest timestamp as a `Number`.
@@ -239,42 +186,6 @@ export function max(dependentKey) {
   lordByron.minChildAge; // 5
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject, { set } from '@ember/object';
-  import { mapBy, min } from '@ember/object/computed';
-
-  let Person = EmberObject.extend({
-    childAges: mapBy('children', 'age'),
-    minChildAge: min('childAges')
-  });
-
-  let lordByron = Person.create({ children: [] });
-
-  lordByron.minChildAge; // Infinity
-
-  set(lordByron, 'children', [
-    {
-      name: 'Augusta Ada Byron',
-      age: 7
-    }
-  ]);
-  lordByron.minChildAge; // 7
-
-  set(lordByron, 'children', [
-    ...lordByron.children,
-    {
-      name: 'Allegra Byron',
-      age: 5
-    }, {
-      name: 'Elizabeth Medora Leigh',
-      age: 8
-    }
-  ]);
-  lordByron.minChildAge; // 5
-  ```
-
   If the types of the arguments are not numbers, they will be converted to
   numbers and the type of the return value will always be `Number`. For example,
   the min of a list of Date objects will be the lowest timestamp as a `Number`.
@@ -325,25 +236,6 @@ export function min(dependentKey) {
   hamster.excitingChores; // ['CLEAN!', 'WRITE MORE UNIT TESTS!']
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { map } from '@ember/object/computed';
-
-  let Hamster = EmberObject.extend({
-    excitingChores: map('chores', function(chore, index) {
-      return `${chore.toUpperCase()}!`;
-    })
-  });
-
-  let hamster = Hamster.create({
-    chores: ['clean', 'write more unit tests']
-  });
-
-  hamster.excitingChores; // ['CLEAN!', 'WRITE MORE UNIT TESTS!']
-  ```
-
   You can optionally pass an array of additional dependent keys as the second
   parameter to the macro, if your map function relies on any external values:
 
@@ -441,41 +333,6 @@ export function map(dependentKey, additionalDependentKeys, callback) {
   lordByron.childAges; // [7, 5, 8]
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject, { set } from '@ember/object';
-  import { mapBy } from '@ember/object/computed';
-
-  let Person = EmberObject.extend({
-    childAges: mapBy('children', 'age')
-  });
-
-  let lordByron = Person.create({ children: [] });
-
-  lordByron.childAges; // []
-
-  set(lordByron, 'children', [
-    {
-      name: 'Augusta Ada Byron',
-      age: 7
-    }
-  ]);
-  lordByron.childAges; // [7]
-
-  set(lordByron, 'children', [
-    ...lordByron.children,
-    {
-      name: 'Allegra Byron',
-      age: 5
-    }, {
-      name: 'Elizabeth Medora Leigh',
-      age: 8
-    }
-  ]);
-  lordByron.childAges; // [7, 5, 8]
-  ```
-
   @method mapBy
   @for @ember/object/computed
   @static
@@ -487,8 +344,8 @@ export function map(dependentKey, additionalDependentKeys, callback) {
 
 export function mapBy(dependentKey, propertyKey) {
   assert('You attempted to use @mapBy as a decorator directly, but it requires `dependentKey` and `propertyKey` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments)));
-  assert('`computed.mapBy` expects a property string for its second argument, ' + 'perhaps you meant to use "map"', typeof propertyKey === 'string');
-  assert(`Dependent key passed to \`computed.mapBy\` shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey));
+  assert('`mapBy` computed macro expects a property string for its second argument, ' + 'perhaps you meant to use "map"', typeof propertyKey === 'string');
+  assert(`Dependent key passed to \`mapBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey));
   return map(`${dependentKey}.@each.${propertyKey}`, item => get(item, propertyKey));
 }
 /**
@@ -529,29 +386,6 @@ export function mapBy(dependentKey, propertyKey) {
   hamster.remainingChores; // [{name: 'write more unit tests', done: false}]
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { filter } from '@ember/object/computed';
-
-  let Hamster = EmberObject.extend({
-    remainingChores: filter('chores', function(chore, index, array) {
-      return !chore.done;
-    })
-  });
-
-  let hamster = Hamster.create({
-    chores: [
-      { name: 'cook', done: true },
-      { name: 'clean', done: true },
-      { name: 'write more unit tests', done: false }
-    ]
-  });
-
-  hamster.remainingChores; // [{name: 'write more unit tests', done: false}]
-  ```
-
   You can also use `@each.property` in your dependent key, the callback will
   still use the underlying array:
 
@@ -660,27 +494,6 @@ export function filter(dependentKey, additionalDependentKeys, callback) {
   hamster.remainingChores; // [{ name: 'write more unit tests', done: false }]
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { filterBy } from '@ember/object/computed';
-
-  let Hamster = EmberObject.extend({
-    remainingChores: filterBy('chores', 'done', false)
-  });
-
-  let hamster = Hamster.create({
-    chores: [
-      { name: 'cook', done: true },
-      { name: 'clean', done: true },
-      { name: 'write more unit tests', done: false }
-    ]
-  });
-
-  hamster.remainingChores; // [{ name: 'write more unit tests', done: false }]
-  ```
-
   @method filterBy
   @for @ember/object/computed
   @static
@@ -693,7 +506,7 @@ export function filter(dependentKey, additionalDependentKeys, callback) {
 
 export function filterBy(dependentKey, propertyKey, value) {
   assert('You attempted to use @filterBy as a decorator directly, but it requires atleast `dependentKey` and `propertyKey` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments)));
-  assert(`Dependent key passed to \`computed.filterBy\` shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey));
+  assert(`Dependent key passed to \`filterBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey));
   let callback;
 
   if (arguments.length === 2) {
@@ -732,28 +545,6 @@ export function filterBy(dependentKey, propertyKey, value) {
   hamster.uniqueFruits; // ['banana', 'grape', 'kale']
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { uniq } from '@ember/object/computed';
-
-  let Hamster = EmberObject.extend({
-    uniqueFruits: uniq('fruits')
-  });
-
-  let hamster = Hamster.create({
-    fruits: [
-      'banana',
-      'grape',
-      'kale',
-      'banana'
-    ]
-  });
-
-  hamster.uniqueFruits; // ['banana', 'grape', 'kale']
-  ```
-
   @method uniq
   @for @ember/object/computed
   @static
@@ -811,28 +602,6 @@ export function uniq(...args) {
   hamster.uniqueFruits; // [ { id: 1, 'banana' }, { id: 2, 'grape' }, { id: 3, 'peach' }]
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { uniqBy } from '@ember/object/computed';
-
-  let Hamster = EmberObject.extend({
-    uniqueFruits: uniqBy('fruits', 'id')
-  });
-
-  let hamster = Hamster.create({
-    fruits: [
-      { id: 1, 'banana' },
-      { id: 2, 'grape' },
-      { id: 3, 'peach' },
-      { id: 1, 'banana' }
-    ]
-  });
-
-  hamster.uniqueFruits; // [ { id: 1, 'banana' }, { id: 2, 'grape' }, { id: 3, 'peach' }]
-  ```
-
   @method uniqBy
   @for @ember/object/computed
   @static
@@ -845,7 +614,7 @@ export function uniq(...args) {
 
 export function uniqBy(dependentKey, propertyKey) {
   assert('You attempted to use @uniqBy as a decorator directly, but it requires `dependentKey` and `propertyKey` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments)));
-  assert(`Dependent key passed to \`computed.uniqBy\` shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey));
+  assert(`Dependent key passed to \`uniqBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey));
   return computed(`${dependentKey}.[]`, function () {
     let list = get(this, dependentKey);
     return isArray(list) ? uniqByArray(list, propertyKey) : emberA();
@@ -888,34 +657,6 @@ export function uniqBy(dependentKey, propertyKey) {
   hamster.uniqueFruits; // ['banana', 'grape', 'kale', 'tomato', 'carrot', 'lettuce']
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { union } from '@ember/object/computed';
-
-  let Hamster = EmberObject.extend({
-    uniqueFruits: union('fruits', 'vegetables')
-  });
-
-  let hamster = Hamster.create({
-    fruits: [
-      'banana',
-      'grape',
-      'kale',
-      'banana',
-      'tomato'
-    ],
-    vegetables: [
-      'tomato',
-      'carrot',
-      'lettuce'
-    ]
-  });
-
-  hamster.uniqueFruits; // ['banana', 'grape', 'kale', 'tomato', 'carrot', 'lettuce']
-  ```
-
   @method union
   @for @ember/object/computed
   @static
@@ -953,24 +694,6 @@ export let union = uniq;
   groups.friendsInCommon; // ['William King', 'Mary Somerville']
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { intersect } from '@ember/object/computed';
-
-  let FriendGroups = EmberObject.extend({
-    friendsInCommon: intersect('adaFriends', 'charlesFriends')
-  });
-
-  let groups = FriendGroups.create({
-    adaFriends: ['Charles Babbage', 'John Hobhouse', 'William King', 'Mary Somerville'],
-    charlesFriends: ['William King', 'Mary Somerville', 'Ada Lovelace', 'George Peacock']
-  });
-
-  groups.friendsInCommon; // ['William King', 'Mary Somerville']
-  ```
-
   @method intersect
   @for @ember/object/computed
   @static
@@ -1043,31 +766,6 @@ export function intersect(...args) {
   hamster.wants; // ['banana']
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { setDiff } from '@ember/object/computed';
-
-  let Hamster = EmberObject.extend({
-    wants: setDiff('likes', 'fruits')
-  });
-
-  let hamster = Hamster.create({
-    likes: [
-      'banana',
-      'grape',
-      'kale'
-    ],
-    fruits: [
-      'grape',
-      'kale',
-    ]
-  });
-
-  hamster.wants; // ['banana']
-  ```
-
   @method setDiff
   @for @ember/object/computed
   @static
@@ -1080,8 +778,8 @@ export function intersect(...args) {
 
 export function setDiff(setAProperty, setBProperty) {
   assert('You attempted to use @setDiff as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments)));
-  assert('`computed.setDiff` requires exactly two dependent arrays.', arguments.length === 2);
-  assert(`Dependent keys passed to \`computed.setDiff\` shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(setAProperty) && !/[[\]{}]/g.test(setBProperty));
+  assert('`setDiff` computed macro requires exactly two dependent arrays.', arguments.length === 2);
+  assert(`Dependent keys passed to \`setDiff\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(setAProperty) && !/[[\]{}]/g.test(setBProperty));
   return computed(`${setAProperty}.[]`, `${setBProperty}.[]`, function () {
     let setA = get(this, setAProperty);
     let setB = get(this, setBProperty);
@@ -1120,25 +818,6 @@ export function setDiff(setAProperty, setBProperty) {
   hamster.clothes; // ['Camp Hat', 'Camp Shirt']
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject, { set } from '@ember/object';
-  import { collect } from '@ember/object/computed';
-
-  let Hamster = EmberObject.extend({
-    clothes: collect('hat', 'shirt')
-  });
-
-  let hamster = Hamster.create();
-
-  hamster.clothes; // [null, null]
-
-  set(hamster, 'hat', 'Camp Hat');
-  set(hamster, 'shirt', 'Camp Shirt');
-  hamster.clothes; // ['Camp Hat', 'Camp Shirt']
-  ```
-
   @method collect
   @for @ember/object/computed
   @static
@@ -1218,36 +897,6 @@ export function collect(...dependentKeys) {
   todoList.priorityTodos; // [{ name:'Release', priority:1 }, { name:'Unit Test', priority:2 }, { name:'Documentation', priority:3 }]
   ```
 
-  Classic Class Example:
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { sort } from '@ember/object/computed';
-
-  let ToDoList = EmberObject.extend({
-    // using a custom sort function
-    priorityTodos: sort('todos', function(a, b){
-      if (a.priority > b.priority) {
-        return 1;
-      } else if (a.priority < b.priority) {
-        return -1;
-      }
-
-      return 0;
-    })
-  });
-
-  let todoList = ToDoList.create({
-    todos: [
-      { name: 'Unit Test', priority: 2 },
-      { name: 'Documentation', priority: 3 },
-      { name: 'Release', priority: 1 }
-    ]
-  });
-
-  todoList.priorityTodos; // [{ name:'Release', priority:1 }, { name:'Unit Test', priority:2 }, { name:'Documentation', priority:3 }]
-  ```
-
   You can also optionally pass an array of additional dependent keys as the
   second parameter, if your sort function is dependent on additional values that
   could changes:
@@ -1342,7 +991,7 @@ export function sort(itemsKey, additionalDependentKeys, sortDefinition) {
       argumentsValid = typeof itemsKey === 'string' && Array.isArray(additionalDependentKeys) && typeof sortDefinition === 'function';
     }
 
-    assert('`computed.sort` can either be used with an array of sort properties or with a sort function. If used with an array of sort properties, it must receive exactly two arguments: the key of the array to sort, and the key of the array of sort properties. If used with a sort function, it may receive up to three arguments: the key of the array to sort, an optional additional array of dependent keys for the computed property, and the sort function.', argumentsValid);
+    assert('The `sort` computed macro can either be used with an array of sort properties or with a sort function. If used with an array of sort properties, it must receive exactly two arguments: the key of the array to sort, and the key of the array of sort properties. If used with a sort function, it may receive up to three arguments: the key of the array to sort, an optional additional array of dependent keys for the computed property, and the sort function.', argumentsValid);
   }
 
   if (sortDefinition === undefined && !Array.isArray(additionalDependentKeys)) {

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

@@ -1,7 +1,2 @@
-import { MERGE } from '@ember/deprecated-features';
-import { default as deprecatedMerge } from './lib/merge';
-let merge = MERGE ? deprecatedMerge : undefined; // Export `assignPolyfill` for testing
-
-export { default as assign, assign as assignPolyfill } from './lib/assign';
-export { merge };
+export { assign } from './lib/assign';
 export const hasPropertyAccessors = true;

package/dist/packages/@ember/polyfills/lib/assign.js

@@ -1,7 +1,4 @@
-/**
- @module @ember/polyfills
-*/
-
+import { deprecate } from '@ember/debug';
 /**
   Copy properties from a source object to a target object. Source arguments remain unchanged.
 
@@ -23,29 +20,16 @@
   @public
   @static
 */
-export function assign(target) {
-  for (let i = 1; i < arguments.length; i++) {
-    let arg = arguments[i];
-
-    if (!arg) {
-      continue;
-    }
-
-    let updates = Object.keys(arg);
 
-    for (let i = 0; i < updates.length; i++) {
-      let prop = updates[i];
-      target[prop] = arg[prop];
+export function assign(target, ...rest) {
+  deprecate('Use of `assign` has been deprecated. Please use `Object.assign` or the spread operator instead.', false, {
+    id: 'ember-polyfills.deprecate-assign',
+    until: '5.0.0',
+    url: 'https://deprecations.emberjs.com/v4.x/#toc_ember-polyfills-deprecate-assign',
+    for: 'ember-source',
+    since: {
+      enabled: '4.0.0'
     }
-  }
-
-  return target;
-} // Note: We use the bracket notation so
-//       that the babel plugin does not
-//       transform it.
-// https://www.npmjs.com/package/babel-plugin-transform-object-assign
-
-const {
-  assign: _assign
-} = Object;
-export default _assign || assign;
+  });
+  return Object.assign(target, ...rest);
+}

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

@@ -1 +1 @@
-export { LinkComponent as LinkTo } from '@ember/-internals/glimmer';
+export { LinkTo } from '@ember/-internals/glimmer';

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

@@ -1,8 +1,6 @@
-import { DEBUG } from '@glimmer/env';
-import { assert, deprecate } from '@ember/debug';
+import { assert } from '@ember/debug';
 import { onErrorTarget } from '@ember/-internals/error-handling';
 import { flushAsyncObservers } from '@ember/-internals/metal';
-import { onRunloopDotAccess } from '@ember/-internals/overrides';
 import Backburner from 'backburner';
 let currentRunLoop = null;
 export function _getCurrentRunLoop() {
@@ -727,84 +725,4 @@ export function debounce() {
 
 export function throttle() {
   return _backburner.throttle(...arguments);
-}
-export let _deprecatedGlobalGetCurrentRunLoop; // eslint-disable-next-line no-undef
-
-if (DEBUG) {
-  let defaultHandler = (dotKey, importKey, module) => {
-    return `Using \`${dotKey}\` has been deprecated. Instead, import the value directly from ${module}:\n\n  import { ${importKey} } from '${module}';`;
-  };
-
-  let handler = onRunloopDotAccess || defaultHandler;
-
-  let defineDeprecatedRunloopFunc = (key, func) => {
-    Object.defineProperty(run, key, {
-      get() {
-        let message = handler(`run.${key}`, key, '@ember/runloop');
-        deprecate(message, message === null, {
-          id: 'deprecated-run-loop-and-computed-dot-access',
-          until: '4.0.0',
-          for: 'ember-source',
-          since: {
-            enabled: '3.27.0'
-          }
-        });
-        return func;
-      }
-
-    });
-  };
-
-  _deprecatedGlobalGetCurrentRunLoop = () => {
-    let message = handler('run.currentRunLoop', 'getCurrentRunLoop', '@ember/runloop');
-    deprecate(message, message === null, {
-      id: 'deprecated-run-loop-and-computed-dot-access',
-      until: '4.0.0',
-      for: 'ember-source',
-      since: {
-        enabled: '3.27.0'
-      }
-    });
-    return _getCurrentRunLoop();
-  };
-
-  defineDeprecatedRunloopFunc('backburner', _backburner);
-  defineDeprecatedRunloopFunc('begin', begin);
-  defineDeprecatedRunloopFunc('bind', bind);
-  defineDeprecatedRunloopFunc('cancel', cancel);
-  defineDeprecatedRunloopFunc('debounce', debounce);
-  defineDeprecatedRunloopFunc('end', end);
-  defineDeprecatedRunloopFunc('hasScheduledTimers', _hasScheduledTimers);
-  defineDeprecatedRunloopFunc('join', join);
-  defineDeprecatedRunloopFunc('later', later);
-  defineDeprecatedRunloopFunc('next', next);
-  defineDeprecatedRunloopFunc('once', once);
-  defineDeprecatedRunloopFunc('schedule', schedule);
-  defineDeprecatedRunloopFunc('scheduleOnce', scheduleOnce);
-  defineDeprecatedRunloopFunc('throttle', throttle);
-  defineDeprecatedRunloopFunc('cancelTimers', _cancelTimers);
-  Object.defineProperty(run, 'currentRunLoop', {
-    get: _deprecatedGlobalGetCurrentRunLoop,
-    enumerable: false
-  });
-} else {
-  run.backburner = _backburner;
-  run.begin = begin;
-  run.bind = bind;
-  run.cancel = cancel;
-  run.debounce = debounce;
-  run.end = end;
-  run.hasScheduledTimers = _hasScheduledTimers;
-  run.join = join;
-  run.later = later;
-  run.next = next;
-  run.once = once;
-  run.schedule = schedule;
-  run.scheduleOnce = scheduleOnce;
-  run.throttle = throttle;
-  run.cancelTimers = _cancelTimers;
-  Object.defineProperty(run, 'currentRunLoop', {
-    get: _getCurrentRunLoop,
-    enumerable: false
-  });
 }