ember-source 4.5.0-alpha.5 → 4.6.0-alpha.2

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

@@ -4,7 +4,12 @@
 import { DEBUG } from '@glimmer/env';
 import { assert } from '@ember/debug';
 import { computed, autoComputed, get, isElementDescriptor } from '@ember/-internals/metal';
-import { compare, isArray, A as emberA, uniqBy as uniqByArray } from '@ember/-internals/runtime';
+import { compare, A as emberA, uniqBy as uniqByArray } from '@ember/-internals/runtime';
+import EmberArray from '@ember/-internals/runtime/lib/mixins/array';
+
+function isNativeOrEmberArray(obj) {
+  return Array.isArray(obj) || EmberArray.detect(obj);
+}
 
 function reduceMacro(dependentKey, callback, initialValue, name) {
   assert(`Dependent key passed to \`${name}\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey));
@@ -33,7 +38,7 @@ function arrayMacro(dependentKey, additionalDependentKeys, callback) {
   return computed(dependentKey, ...additionalDependentKeys, function () {
     let value = get(this, propertyName);
 
-    if (isArray(value)) {
+    if (isNativeOrEmberArray(value)) {
       return emberA(callback.call(this, value));
     } else {
       return emberA();
@@ -203,94 +208,24 @@ export function min(dependentKey) {
   assert('You attempted to use @min as a decorator directly, but it requires a `dependentKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments)));
   return reduceMacro(dependentKey, (min, item) => Math.min(min, item), Infinity, 'min');
 }
-/**
-  Returns an array mapped via the callback
-
-  The callback method you provide should have the following signature:
-  - `item` is the current item in the iteration.
-  - `index` is the integer index of the current item in the iteration.
-
-  ```javascript
-  function mapCallback(item, index);
-  ```
-
-  Example:
-
-  ```javascript
-  import { set } from '@ember/object';
-  import { map } from '@ember/object/computed';
-
-  class Hamster {
-    constructor(chores) {
-      set(this, 'chores', chores);
-    }
-
-    @map('chores', function(chore, index) {
-      return `${chore.toUpperCase()}!`;
-    })
-    excitingChores;
-  });
-
-  let hamster = new Hamster(['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:
-
-  ```javascript
-  import { set } from '@ember/object';
-  import { map } from '@ember/object/computed';
-
-  class Hamster {
-    shouldUpperCase = false;
-
-    constructor(chores) {
-      set(this, 'chores', chores);
-    }
-
-    @map('chores', ['shouldUpperCase'], function(chore, index) {
-      if (this.shouldUpperCase) {
-        return `${chore.toUpperCase()}!`;
-      } else {
-        return `${chore}!`;
-      }
-    })
-    excitingChores;
-  }
-
-  let hamster = new Hamster(['clean', 'write more unit tests']);
-
-  hamster.excitingChores; // ['clean!', 'write more unit tests!']
-
-  set(hamster, 'shouldUpperCase', true);
-  hamster.excitingChores; // ['CLEAN!', 'WRITE MORE UNIT TESTS!']
-  ```
-
-  @method map
-  @for @ember/object/computed
-  @static
-  @param {String} dependentKey
-  @param {Array} [additionalDependentKeys] optional array of additional
-  dependent keys
-  @param {Function} callback
-  @return {ComputedProperty} an array mapped via the callback
-  @public
-*/
-
-export function map(dependentKey, additionalDependentKeys, callback) {
+export function map(dependentKey, additionalDependentKeysOrCallback, callback) {
   assert('You attempted to use @map as a decorator directly, but it requires atleast `dependentKey` and `callback` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments)));
+  assert('The final parameter provided to map must be a callback function', typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function');
+  assert('The second parameter provided to map must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function');
+  let additionalDependentKeys;
 
-  if (callback === undefined && typeof additionalDependentKeys === 'function') {
-    callback = additionalDependentKeys;
+  if (typeof additionalDependentKeysOrCallback === 'function') {
+    callback = additionalDependentKeysOrCallback;
     additionalDependentKeys = [];
+  } else {
+    additionalDependentKeys = additionalDependentKeysOrCallback;
   }
 
-  assert('The final parameter provided to map must be a callback function', typeof callback === 'function');
-  assert('The second parameter provided to map must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeys));
+  const cCallback = callback;
+  assert('[BUG] Missing callback', cCallback);
   return arrayMacro(dependentKey, additionalDependentKeys, function (value) {
-    return value.map(callback, this);
+    // This is so dumb...
+    return Array.isArray(value) ? value.map(cCallback, this) : value.map(cCallback, this);
   });
 }
 /**
@@ -348,124 +283,23 @@ export function mapBy(dependentKey, propertyKey) {
   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));
 }
-/**
-  Filters the array by the callback.
-
-  The callback method you provide should have the following signature:
-  - `item` is the current item in the iteration.
-  - `index` is the integer index of the current item in the iteration.
-  - `array` is the dependant array itself.
-
-  ```javascript
-  function filterCallback(item, index, array);
-  ```
-
-  Example:
-
-  ```javascript
-  import { set } from '@ember/object';
-  import { filter } from '@ember/object/computed';
-
-  class Hamster {
-    constructor(chores) {
-      set(this, 'chores', chores);
-    }
-
-    @filter('chores', function(chore, index, array) {
-      return !chore.done;
-    })
-    remainingChores;
-  }
-
-  let hamster = Hamster.create([
-    { 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:
-
-  ```javascript
-  import { set } from '@ember/object';
-  import { filter } from '@ember/object/computed';
-
-  class Hamster {
-    constructor(chores) {
-      set(this, 'chores', chores);
-    }
-
-    @filter('chores.@each.done', function(chore, index, array) {
-      return !chore.done;
-    })
-    remainingChores;
-  }
-
-  let hamster = new Hamster([
-    { name: 'cook', done: true },
-    { name: 'clean', done: true },
-    { name: 'write more unit tests', done: false }
-  ]);
-  hamster.remainingChores; // [{name: 'write more unit tests', done: false}]
-
-  set(hamster.chores[2], 'done', true);
-  hamster.remainingChores; // []
-  ```
-
-  Finally, you can optionally pass an array of additional dependent keys as the
-  second parameter to the macro, if your filter function relies on any external
-  values:
-
-  ```javascript
-  import { filter } from '@ember/object/computed';
-
-  class Hamster {
-    constructor(chores) {
-      set(this, 'chores', chores);
-    }
-
-    doneKey = 'finished';
-
-    @filter('chores', ['doneKey'], function(chore, index, array) {
-      return !chore[this.doneKey];
-    })
-    remainingChores;
-  }
-
-  let hamster = new Hamster([
-    { name: 'cook', finished: true },
-    { name: 'clean', finished: true },
-    { name: 'write more unit tests', finished: false }
-  ]);
-
-  hamster.remainingChores; // [{name: 'write more unit tests', finished: false}]
-  ```
-
-  @method filter
-  @for @ember/object/computed
-  @static
-  @param {String} dependentKey
-  @param {Array} [additionalDependentKeys] optional array of additional dependent keys
-  @param {Function} callback
-  @return {ComputedProperty} the filtered array
-  @public
-*/
-
-export function filter(dependentKey, additionalDependentKeys, callback) {
+export function filter(dependentKey, additionalDependentKeysOrCallback, callback) {
   assert('You attempted to use @filter as a decorator directly, but it requires atleast `dependentKey` and `callback` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments)));
+  assert('The final parameter provided to filter must be a callback function', typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function');
+  assert('The second parameter provided to filter must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function');
+  let additionalDependentKeys;
 
-  if (callback === undefined && typeof additionalDependentKeys === 'function') {
-    callback = additionalDependentKeys;
+  if (typeof additionalDependentKeysOrCallback === 'function') {
+    callback = additionalDependentKeysOrCallback;
     additionalDependentKeys = [];
+  } else {
+    additionalDependentKeys = additionalDependentKeysOrCallback;
   }
 
-  assert('The final parameter provided to filter must be a callback function', typeof callback === 'function');
-  assert('The second parameter provided to filter must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeys));
+  const cCallback = callback;
   return arrayMacro(dependentKey, additionalDependentKeys, function (value) {
-    return value.filter(callback, this);
+    // This is a really silly way to keep TS happy
+    return Array.isArray(value) ? value.filter(cCallback, this) : value.filter(cCallback, this);
   });
 }
 /**
@@ -554,15 +388,16 @@ export function filterBy(dependentKey, propertyKey, value) {
   @public
 */
 
-export function uniq(...args) {
+export function uniq(dependentKey, ...additionalDependentKeys) {
   assert('You attempted to use @uniq/@union as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments)));
+  let args = [dependentKey, ...additionalDependentKeys];
   return multiArrayMacro(args, function (dependentKeys) {
     let uniq = emberA();
     let seen = new Set();
     dependentKeys.forEach(dependentKey => {
       let value = get(this, dependentKey);
 
-      if (isArray(value)) {
+      if (isNativeOrEmberArray(value)) {
         value.forEach(item => {
           if (!seen.has(item)) {
             seen.add(item);
@@ -617,7 +452,7 @@ export function uniqBy(dependentKey, propertyKey) {
   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();
+    return isNativeOrEmberArray(list) ? uniqByArray(list, propertyKey) : emberA();
   }).readOnly();
 }
 /**
@@ -703,20 +538,22 @@ export let union = uniq;
   @public
 */
 
-export function intersect(...args) {
+export function intersect(dependentKey, ...additionalDependentKeys) {
   assert('You attempted to use @intersect as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments)));
+  let args = [dependentKey, ...additionalDependentKeys];
   return multiArrayMacro(args, function (dependentKeys) {
     let arrays = dependentKeys.map(dependentKey => {
       let array = get(this, dependentKey);
-      return isArray(array) ? array : [];
+      return Array.isArray(array) ? array : [];
     });
-    let results = arrays.pop().filter(candidate => {
-      for (let i = 0; i < arrays.length; i++) {
+    let firstArray = arrays.pop();
+    assert('Attempted to apply multiArrayMacro for intersect without any dependentKeys', firstArray);
+    let results = firstArray.filter(candidate => {
+      for (let array of arrays) {
         let found = false;
-        let array = arrays[i];
 
-        for (let j = 0; j < array.length; j++) {
-          if (array[j] === candidate) {
+        for (let item of array) {
+          if (item === candidate) {
             found = true;
             break;
           }
@@ -784,11 +621,11 @@ export function setDiff(setAProperty, setBProperty) {
     let setA = get(this, setAProperty);
     let setB = get(this, setBProperty);
 
-    if (!isArray(setA)) {
+    if (!isNativeOrEmberArray(setA)) {
       return emberA();
     }
 
-    if (!isArray(setB)) {
+    if (!isNativeOrEmberArray(setB)) {
       return emberA(setA);
     }
 
@@ -827,8 +664,9 @@ export function setDiff(setAProperty, setBProperty) {
   @public
 */
 
-export function collect(...dependentKeys) {
+export function collect(dependentKey, ...additionalDependentKeys) {
   assert('You attempted to use @collect as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments)));
+  let dependentKeys = [dependentKey, ...additionalDependentKeys];
   return multiArrayMacro(dependentKeys, function () {
     let res = dependentKeys.map(key => {
       let val = get(this, key);
@@ -837,172 +675,38 @@ export function collect(...dependentKeys) {
     return emberA(res);
   }, 'collect');
 }
-/**
-  A computed property which returns a new array with all the properties from the
-  first dependent array sorted based on a property or sort function. The sort
-  macro can be used in two different ways:
-
-  1. By providing a sort callback function
-  2. By providing an array of keys to sort the array
-
-  In the first form, the callback method you provide should have the following
-  signature:
-
-  ```javascript
-  function sortCallback(itemA, itemB);
-  ```
-
-  - `itemA` the first item to compare.
-  - `itemB` the second item to compare.
-
-  This function should return negative number (e.g. `-1`) when `itemA` should
-  come before `itemB`. It should return positive number (e.g. `1`) when `itemA`
-  should come after `itemB`. If the `itemA` and `itemB` are equal this function
-  should return `0`.
-
-  Therefore, if this function is comparing some numeric values, simple `itemA -
-  itemB` or `itemA.get( 'foo' ) - itemB.get( 'foo' )` can be used instead of
-  series of `if`.
-
-  Example:
-
-  ```javascript
-  import { set } from '@ember/object';
-  import { sort } from '@ember/object/computed';
-
-  class ToDoList {
-    constructor(todos) {
-      set(this, 'todos', todos);
-    }
-
-    // using a custom sort function
-    @sort('todos', function(a, b){
-      if (a.priority > b.priority) {
-        return 1;
-      } else if (a.priority < b.priority) {
-        return -1;
-      }
-
-      return 0;
-    })
-    priorityTodos;
-  }
-
-  let todoList = new ToDoList([
-    { 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:
-
-  ```js
-  import EmberObject, { set } from '@ember/object';
-  import { sort } from '@ember/object/computed';
-
-  class ToDoList {
-    sortKey = 'priority';
-
-    constructor(todos) {
-      set(this, 'todos', todos);
-    }
-
-    // using a custom sort function
-    @sort('todos', ['sortKey'], function(a, b){
-      if (a[this.sortKey] > b[this.sortKey]) {
-        return 1;
-      } else if (a[this.sortKey] < b[this.sortKey]) {
-        return -1;
-      }
-
-      return 0;
-    })
-    sortedTodos;
-  });
-
-  let todoList = new ToDoList([
-    { 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 }]
-  ```
-
-  In the second form, you should provide the key of the array of sort values as
-  the second parameter:
-
-  ```javascript
-  import { set } from '@ember/object';
-  import { sort } from '@ember/object/computed';
-
-  class ToDoList {
-    constructor(todos) {
-      set(this, 'todos', todos);
-    }
-
-    // using standard ascending sort
-    todosSorting = ['name'];
-    @sort('todos', 'todosSorting') sortedTodos;
-
-    // using descending sort
-    todosSortingDesc = ['name:desc'];
-    @sort('todos', 'todosSortingDesc') sortedTodosDesc;
-  }
-
-  let todoList = new ToDoList([
-    { name: 'Unit Test', priority: 2 },
-    { name: 'Documentation', priority: 3 },
-    { name: 'Release', priority: 1 }
-  ]);
-
-  todoList.sortedTodos; // [{ name:'Documentation', priority:3 }, { name:'Release', priority:1 }, { name:'Unit Test', priority:2 }]
-  todoList.sortedTodosDesc; // [{ name:'Unit Test', priority:2 }, { name:'Release', priority:1 }, { name:'Documentation', priority:3 }]
-  ```
-
-  @method sort
-  @for @ember/object/computed
-  @static
-  @param {String} itemsKey
-  @param {String|Function|Array} sortDefinitionOrDependentKeys The key of the sort definition (an array of sort properties),
-  the sort function, or an array of additional dependent keys
-  @param {Function?} sortDefinition the sort function (when used with additional dependent keys)
-  @return {ComputedProperty} computes a new sorted array based on the sort
-  property array or callback function
-  @public
-*/
-
-export function sort(itemsKey, additionalDependentKeys, sortDefinition) {
+export function sort(itemsKey, additionalDependentKeysOrDefinition, sortDefinition) {
   assert('You attempted to use @sort as a decorator directly, but it requires atleast an `itemsKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments)));
 
   if (DEBUG) {
     let argumentsValid = false;
 
     if (arguments.length === 2) {
-      argumentsValid = typeof itemsKey === 'string' && (typeof additionalDependentKeys === 'string' || typeof additionalDependentKeys === 'function');
+      argumentsValid = typeof itemsKey === 'string' && (typeof additionalDependentKeysOrDefinition === 'string' || typeof additionalDependentKeysOrDefinition === 'function');
     }
 
     if (arguments.length === 3) {
-      argumentsValid = typeof itemsKey === 'string' && Array.isArray(additionalDependentKeys) && typeof sortDefinition === 'function';
+      argumentsValid = typeof itemsKey === 'string' && Array.isArray(additionalDependentKeysOrDefinition) && typeof sortDefinition === 'function';
     }
 
     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)) {
-    sortDefinition = additionalDependentKeys;
+  let additionalDependentKeys;
+  let sortDefinitionOrString;
+
+  if (Array.isArray(additionalDependentKeysOrDefinition)) {
+    additionalDependentKeys = additionalDependentKeysOrDefinition;
+    sortDefinitionOrString = sortDefinition;
+  } else {
     additionalDependentKeys = [];
+    sortDefinitionOrString = additionalDependentKeysOrDefinition;
   }
 
-  if (typeof sortDefinition === 'function') {
-    return customSort(itemsKey, additionalDependentKeys, sortDefinition);
+  if (typeof sortDefinitionOrString === 'function') {
+    return customSort(itemsKey, additionalDependentKeys, sortDefinitionOrString);
   } else {
-    return propertySort(itemsKey, sortDefinition);
+    return propertySort(itemsKey, sortDefinitionOrString);
   }
 }
 
@@ -1017,12 +721,14 @@ function customSort(itemsKey, additionalDependentKeys, comparator) {
 function propertySort(itemsKey, sortPropertiesKey) {
   let cp = autoComputed(function (key) {
     let sortProperties = get(this, sortPropertiesKey);
-    assert(`The sort definition for '${key}' on ${this} must be a function or an array of strings`, isArray(sortProperties) && sortProperties.every(s => typeof s === 'string'));
+    assert(`The sort definition for '${key}' on ${this} must be a function or an array of strings`, function (arr) {
+      return isNativeOrEmberArray(arr) && arr.every(s => typeof s === 'string');
+    }(sortProperties));
     let itemsKeyIsAtThis = itemsKey === '@this';
     let normalizedSortProperties = normalizeSortProperties(sortProperties);
     let items = itemsKeyIsAtThis ? this : get(this, itemsKey);
 
-    if (!isArray(items)) {
+    if (!isNativeOrEmberArray(items)) {
       return emberA();
     }
 
@@ -1036,17 +742,20 @@ function propertySort(itemsKey, sortPropertiesKey) {
 }
 
 function normalizeSortProperties(sortProperties) {
-  return sortProperties.map(p => {
+  let callback = p => {
     let [prop, direction] = p.split(':');
-    direction = direction || 'asc';
+    direction = direction || 'asc'; // SAFETY: There will always be at least one value returned by split
+
     return [prop, direction];
-  });
+  }; // This nonsense is necessary since technically the two map implementations diverge.
+
+
+  return Array.isArray(sortProperties) ? sortProperties.map(callback) : sortProperties.map(callback);
 }
 
 function sortByNormalizedSortProperties(items, normalizedSortProperties) {
   return emberA(items.slice().sort((itemA, itemB) => {
-    for (let i = 0; i < normalizedSortProperties.length; i++) {
-      let [prop, direction] = normalizedSortProperties[i];
+    for (let [prop, direction] of normalizedSortProperties) {
       let result = compare(get(itemA, prop), get(itemB, prop));
 
       if (result !== 0) {

package/dist/packages/ember/version.js

@@ -1 +1 @@
-export default "4.5.0-alpha.5";
+export default "4.6.0-alpha.2";

package/dist/packages/ember-testing/lib/adapters/adapter.js

@@ -1,8 +1,4 @@
 import { Object as EmberObject } from '@ember/-internals/runtime';
-
-function K() {
-  return this;
-}
 /**
  @module @ember/test
 */
@@ -15,7 +11,6 @@ function K() {
   @public
 */
 
-
 export default EmberObject.extend({
   /**
     This callback will be called whenever an async operation is about to start.
@@ -24,14 +19,14 @@ export default EmberObject.extend({
      @public
     @method asyncStart
   */
-  asyncStart: K,
+  asyncStart() {},
 
   /**
     This callback will be called whenever an async operation has completed.
      @public
     @method asyncEnd
   */
-  asyncEnd: K,
+  asyncEnd() {},
 
   /**
     Override this method with your testing framework's false assertion.