ember-source 4.8.0-alpha.5 → 4.8.0-beta.2

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

@@ -1,2 +1,1503 @@
-export { Array as default, NativeArray, isArray, A } from '@ember/-internals/runtime';
-export { makeArray } from '@ember/-internals/utils';
+/**
+@module @ember/array
+*/
+import { DEBUG } from '@glimmer/env';
+import { PROXY_CONTENT } from '@ember/-internals/metal';
+import { isEmberArray, setEmberArray } from '@ember/-internals/utils';
+import { objectAt, replaceInNativeArray, replace, computed, beginPropertyChanges, endPropertyChanges } from '@ember/-internals/metal';
+import { get, set } from '@ember/object';
+import Mixin from '@ember/object/mixin';
+import { assert } from '@ember/debug';
+import Enumerable from '@ember/enumerable';
+import MutableEnumerable from '@ember/enumerable/mutable';
+import { compare, typeOf } from '@ember/utils';
+import { ENV } from '@ember/-internals/environment';
+import Observable from '@ember/object/observable';
+export { makeArray } from '@ember/-internals/utils';
+const EMPTY_ARRAY = Object.freeze([]);
+
+const identityFunction = item => item;
+
+export function uniqBy(array, keyOrFunc = identityFunction) {
+  assert(`first argument passed to \`uniqBy\` should be array`, isArray(array));
+  let ret = A();
+  let seen = new Set();
+  let getter = typeof keyOrFunc === 'function' ? keyOrFunc : item => get(item, keyOrFunc);
+  array.forEach(item => {
+    let val = getter(item);
+
+    if (!seen.has(val)) {
+      seen.add(val);
+      ret.push(item);
+    }
+  });
+  return ret;
+}
+
+function iter(...args) {
+  let valueProvided = args.length === 2;
+  let [key, value] = args;
+  return valueProvided ? item => value === get(item, key) : item => Boolean(get(item, key));
+}
+
+function findIndex(array, predicate, startAt) {
+  let len = array.length;
+
+  for (let index = startAt; index < len; index++) {
+    // SAFETY: Because we're checking the index this value should always be set.
+    let item = objectAt(array, index);
+
+    if (predicate(item, index, array)) {
+      return index;
+    }
+  }
+
+  return -1;
+}
+
+function find(array, callback, target = null) {
+  let predicate = callback.bind(target);
+  let index = findIndex(array, predicate, 0);
+  return index === -1 ? undefined : objectAt(array, index);
+}
+
+function any(array, callback, target = null) {
+  let predicate = callback.bind(target);
+  return findIndex(array, predicate, 0) !== -1;
+}
+
+function every(array, callback, target = null) {
+  let cb = callback.bind(target);
+
+  let predicate = (item, index, array) => !cb(item, index, array);
+
+  return findIndex(array, predicate, 0) === -1;
+}
+
+function indexOf(array, val, startAt = 0, withNaNCheck) {
+  let len = array.length;
+
+  if (startAt < 0) {
+    startAt += len;
+  } // SameValueZero comparison (NaN !== NaN)
+
+
+  let predicate = withNaNCheck && val !== val ? item => item !== item : item => item === val;
+  return findIndex(array, predicate, startAt);
+}
+
+export function removeAt(array, index, len) {
+  assert(`\`removeAt\` index provided is out of range`, index > -1 && index < array.length);
+  replace(array, index, len !== null && len !== void 0 ? len : 1, EMPTY_ARRAY);
+  return array;
+}
+
+function insertAt(array, index, item) {
+  assert(`\`insertAt\` index provided is out of range`, index > -1 && index <= array.length);
+  replace(array, index, 0, [item]);
+  return item;
+}
+/**
+  Returns true if the passed object is an array or Array-like.
+
+  Objects are considered Array-like if any of the following are true:
+
+    - the object is a native Array
+    - the object has an objectAt property
+    - the object is an Object, and has a length property
+
+  Unlike `typeOf` this method returns true even if the passed object is
+  not formally an array but appears to be array-like (i.e. implements `Array`)
+
+  ```javascript
+  import { isArray } from '@ember/array';
+  import ArrayProxy from '@ember/array/proxy';
+
+  isArray();                                      // false
+  isArray([]);                                    // true
+  isArray(ArrayProxy.create({ content: [] }));    // true
+  ```
+
+  @method isArray
+  @static
+  @for @ember/array
+  @param {Object} obj The object to test
+  @return {Boolean} true if the passed object is an array or Array-like
+  @public
+*/
+
+
+export function isArray(obj) {
+  if (DEBUG && typeof obj === 'object' && obj !== null) {
+    // SAFETY: Property read checks are safe if it's an object
+    let possibleProxyContent = obj[PROXY_CONTENT];
+
+    if (possibleProxyContent !== undefined) {
+      obj = possibleProxyContent;
+    }
+  } // SAFETY: Property read checks are safe if it's an object
+
+
+  if (!obj || obj.setInterval) {
+    return false;
+  }
+
+  if (Array.isArray(obj) || EmberArray.detect(obj)) {
+    return true;
+  }
+
+  let type = typeOf(obj);
+
+  if ('array' === type) {
+    return true;
+  } // SAFETY: Property read checks are safe if it's an object
+
+
+  let length = obj.length;
+
+  if (typeof length === 'number' && length === length && 'object' === type) {
+    return true;
+  }
+
+  return false;
+}
+/*
+  This allows us to define computed properties that are not enumerable.
+  The primary reason this is important is that when `NativeArray` is
+  applied to `Array.prototype` we need to ensure that we do not add _any_
+  new enumerable properties.
+*/
+
+function nonEnumerableComputed(callback) {
+  let property = computed(callback);
+  property.enumerable = false;
+  return property;
+}
+
+function mapBy(key) {
+  return this.map(next => get(next, key));
+}
+
+const EmberArray = Mixin.create(Enumerable, {
+  init() {
+    this._super(...arguments);
+
+    setEmberArray(this);
+  },
+
+  /**
+    __Required.__ You must implement this method to apply this mixin.
+       Your array must support the `length` property. Your replace methods should
+    set this property whenever it changes.
+       @property {Number} length
+    @public
+  */
+
+  /**
+    Returns the object at the given `index`. If the given `index` is negative
+    or is greater or equal than the array length, returns `undefined`.
+       This is one of the primitives you must implement to support `EmberArray`.
+    If your object supports retrieving the value of an array item using `get()`
+    (i.e. `myArray.get(0)`), then you do not need to implement this method
+    yourself.
+       ```javascript
+    let arr = ['a', 'b', 'c', 'd'];
+       arr.objectAt(0);   // 'a'
+    arr.objectAt(3);   // 'd'
+    arr.objectAt(-1);  // undefined
+    arr.objectAt(4);   // undefined
+    arr.objectAt(5);   // undefined
+    ```
+       @method objectAt
+    @param {Number} idx The index of the item to return.
+    @return {*} item at index or undefined
+    @public
+  */
+
+  /**
+    This returns the objects at the specified indexes, using `objectAt`.
+       ```javascript
+    let arr = ['a', 'b', 'c', 'd'];
+       arr.objectsAt([0, 1, 2]);  // ['a', 'b', 'c']
+    arr.objectsAt([2, 3, 4]);  // ['c', 'd', undefined]
+    ```
+       @method objectsAt
+    @param {Array} indexes An array of indexes of items to return.
+    @return {Array}
+    @public
+   */
+  objectsAt(indexes) {
+    return indexes.map(idx => objectAt(this, idx));
+  },
+
+  /**
+    This is the handler for the special array content property. If you get
+    this property, it will return this. If you set this property to a new
+    array, it will replace the current content.
+       ```javascript
+    let peopleToMoon = ['Armstrong', 'Aldrin'];
+       peopleToMoon.get('[]'); // ['Armstrong', 'Aldrin']
+       peopleToMoon.set('[]', ['Collins']); // ['Collins']
+    peopleToMoon.get('[]'); // ['Collins']
+    ```
+       @property []
+    @return this
+    @public
+  */
+  '[]': nonEnumerableComputed({
+    get() {
+      return this;
+    },
+
+    set(_key, value) {
+      this.replace(0, this.length, value);
+      return this;
+    }
+
+  }),
+
+  /**
+    The first object in the array, or `undefined` if the array is empty.
+       ```javascript
+    let vowels = ['a', 'e', 'i', 'o', 'u'];
+    vowels.firstObject; // 'a'
+       vowels.shiftObject();
+    vowels.firstObject; // 'e'
+       vowels.reverseObjects();
+    vowels.firstObject; // 'u'
+       vowels.clear();
+    vowels.firstObject; // undefined
+    ```
+       @property firstObject
+    @return {Object | undefined} The first object in the array
+    @public
+  */
+  firstObject: nonEnumerableComputed(function () {
+    return objectAt(this, 0);
+  }).readOnly(),
+
+  /**
+    The last object in the array, or `undefined` if the array is empty.
+       @property lastObject
+    @return {Object | undefined} The last object in the array
+    @public
+  */
+  lastObject: nonEnumerableComputed(function () {
+    return objectAt(this, this.length - 1);
+  }).readOnly(),
+
+  // Add any extra methods to EmberArray that are native to the built-in Array.
+
+  /**
+    Returns a new array that is a slice of the receiver. This implementation
+    uses the observable array methods to retrieve the objects for the new
+    slice.
+       ```javascript
+    let arr = ['red', 'green', 'blue'];
+       arr.slice(0);       // ['red', 'green', 'blue']
+    arr.slice(0, 2);    // ['red', 'green']
+    arr.slice(1, 100);  // ['green', 'blue']
+    ```
+       @method slice
+    @param {Number} beginIndex (Optional) index to begin slicing from.
+    @param {Number} endIndex (Optional) index to end the slice at (but not included).
+    @return {Array} New array with specified slice
+    @public
+  */
+  slice(beginIndex = 0, endIndex) {
+    let ret = A();
+    let length = this.length;
+
+    if (beginIndex < 0) {
+      beginIndex = length + beginIndex;
+    }
+
+    let validatedEndIndex;
+
+    if (endIndex === undefined || endIndex > length) {
+      validatedEndIndex = length;
+    } else if (endIndex < 0) {
+      validatedEndIndex = length + endIndex;
+    } else {
+      validatedEndIndex = endIndex;
+    }
+
+    while (beginIndex < validatedEndIndex) {
+      ret[ret.length] = objectAt(this, beginIndex++);
+    }
+
+    return ret;
+  },
+
+  /**
+    Used to determine the passed object's first occurrence in the array.
+    Returns the index if found, -1 if no match is found.
+       The optional `startAt` argument can be used to pass a starting
+    index to search from, effectively slicing the searchable portion
+    of the array. If it's negative it will add the array length to
+    the startAt value passed in as the index to search from. If less
+    than or equal to `-1 * array.length` the entire array is searched.
+       ```javascript
+    let arr = ['a', 'b', 'c', 'd', 'a'];
+       arr.indexOf('a');       //  0
+    arr.indexOf('z');       // -1
+    arr.indexOf('a', 2);    //  4
+    arr.indexOf('a', -1);   //  4, equivalent to indexOf('a', 4)
+    arr.indexOf('a', -100); //  0, searches entire array
+    arr.indexOf('b', 3);    // -1
+    arr.indexOf('a', 100);  // -1
+       let people = [{ name: 'Zoey' }, { name: 'Bob' }]
+    let newPerson = { name: 'Tom' };
+    people = [newPerson, ...people, newPerson];
+       people.indexOf(newPerson);     //  0
+    people.indexOf(newPerson, 1);  //  3
+    people.indexOf(newPerson, -4); //  0
+    people.indexOf(newPerson, 10); // -1
+    ```
+       @method indexOf
+    @param {Object} object the item to search for
+    @param {Number} startAt optional starting location to search, default 0
+    @return {Number} index or -1 if not found
+    @public
+  */
+  indexOf(object, startAt) {
+    return indexOf(this, object, startAt, false);
+  },
+
+  /**
+    Returns the index of the given `object`'s last occurrence.
+       - If no `startAt` argument is given, the search starts from
+    the last position.
+    - If it's greater than or equal to the length of the array,
+    the search starts from the last position.
+    - If it's negative, it is taken as the offset from the end
+    of the array i.e. `startAt + array.length`.
+    - If it's any other positive number, will search backwards
+    from that index of the array.
+       Returns -1 if no match is found.
+       ```javascript
+    let arr = ['a', 'b', 'c', 'd', 'a'];
+       arr.lastIndexOf('a');       //  4
+    arr.lastIndexOf('z');       // -1
+    arr.lastIndexOf('a', 2);    //  0
+    arr.lastIndexOf('a', -1);   //  4
+    arr.lastIndexOf('a', -3);   //  0
+    arr.lastIndexOf('b', 3);    //  1
+    arr.lastIndexOf('a', 100);  //  4
+    ```
+       @method lastIndexOf
+    @param {Object} object the item to search for
+    @param {Number} startAt optional starting location to search from
+    backwards, defaults to `(array.length - 1)`
+    @return {Number} The last index of the `object` in the array or -1
+    if not found
+    @public
+  */
+  lastIndexOf(object, startAt) {
+    let len = this.length;
+
+    if (startAt === undefined || startAt >= len) {
+      startAt = len - 1;
+    }
+
+    if (startAt < 0) {
+      startAt += len;
+    }
+
+    for (let idx = startAt; idx >= 0; idx--) {
+      if (objectAt(this, idx) === object) {
+        return idx;
+      }
+    }
+
+    return -1;
+  },
+
+  /**
+    Iterates through the array, calling the passed function on each
+    item. This method corresponds to the `forEach()` method defined in
+    JavaScript 1.6.
+       The callback method you provide should have the following signature (all
+    parameters are optional):
+       ```javascript
+    function(item, index, array);
+    ```
+       - `item` is the current item in the iteration.
+    - `index` is the current index in the iteration.
+    - `array` is the array itself.
+       Note that in addition to a callback, you can also pass an optional target
+    object that will be set as `this` on the context. This is a good way
+    to give your iterator function access to the current object.
+       Example Usage:
+       ```javascript
+    let foods = [
+      { name: 'apple', eaten: false },
+      { name: 'banana', eaten: false },
+      { name: 'carrot', eaten: false }
+    ];
+       foods.forEach((food) => food.eaten = true);
+       let output = '';
+    foods.forEach((item, index, array) =>
+      output += `${index + 1}/${array.length} ${item.name}\n`;
+    );
+    console.log(output);
+    // 1/3 apple
+    // 2/3 banana
+    // 3/3 carrot
+    ```
+       @method forEach
+    @param {Function} callback The callback to execute
+    @param {Object} [target] The target object to use
+    @return {Object} receiver
+    @public
+  */
+  forEach(callback, target = null) {
+    assert('`forEach` expects a function as first argument.', typeof callback === 'function');
+    let length = this.length;
+
+    for (let index = 0; index < length; index++) {
+      let item = this.objectAt(index);
+      callback.call(target, item, index, this);
+    }
+
+    return this;
+  },
+
+  /**
+    Alias for `mapBy`.
+       Returns the value of the named
+    property on all items in the enumeration.
+       ```javascript
+    let people = [{name: 'Joe'}, {name: 'Matt'}];
+       people.getEach('name');
+    // ['Joe', 'Matt'];
+       people.getEach('nonexistentProperty');
+    // [undefined, undefined];
+    ```
+       @method getEach
+    @param {String} key name of the property
+    @return {Array} The mapped array.
+    @public
+  */
+  getEach: mapBy,
+
+  /**
+    Sets the value on the named property for each member. This is more
+    ergonomic than using other methods defined on this helper. If the object
+    implements Observable, the value will be changed to `set(),` otherwise
+    it will be set directly. `null` objects are skipped.
+       ```javascript
+    let people = [{name: 'Joe'}, {name: 'Matt'}];
+       people.setEach('zipCode', '10011');
+    // [{name: 'Joe', zipCode: '10011'}, {name: 'Matt', zipCode: '10011'}];
+    ```
+       @method setEach
+    @param {String} key The key to set
+    @param {Object} value The object to set
+    @return {Object} receiver
+    @public
+  */
+  setEach(key, value) {
+    return this.forEach(item => set(item, key, value));
+  },
+
+  /**
+    Maps all of the items in the enumeration to another value, returning
+    a new array. This method corresponds to `map()` defined in JavaScript 1.6.
+       The callback method you provide should have the following signature (all
+    parameters are optional):
+       ```javascript
+    function(item, index, array);
+    let arr = [1, 2, 3, 4, 5, 6];
+       arr.map(element => element * element);
+    // [1, 4, 9, 16, 25, 36];
+       arr.map((element, index) => element + index);
+    // [1, 3, 5, 7, 9, 11];
+    ```
+       - `item` is the current item in the iteration.
+    - `index` is the current index in the iteration.
+    - `array` is the array itself.
+       It should return the mapped value.
+       Note that in addition to a callback, you can also pass an optional target
+    object that will be set as `this` on the context. This is a good way
+    to give your iterator function access to the current object.
+       @method map
+    @param {Function} callback The callback to execute
+    @param {Object} [target] The target object to use
+    @return {Array} The mapped array.
+    @public
+  */
+  map(callback, target = null) {
+    assert('`map` expects a function as first argument.', typeof callback === 'function');
+    let ret = A();
+    this.forEach((x, idx, i) => ret[idx] = callback.call(target, x, idx, i));
+    return ret;
+  },
+
+  /**
+    Similar to map, this specialized function returns the value of the named
+    property on all items in the enumeration.
+       ```javascript
+    let people = [{name: 'Joe'}, {name: 'Matt'}];
+       people.mapBy('name');
+    // ['Joe', 'Matt'];
+       people.mapBy('unknownProperty');
+    // [undefined, undefined];
+    ```
+       @method mapBy
+    @param {String} key name of the property
+    @return {Array} The mapped array.
+    @public
+  */
+  mapBy,
+
+  /**
+    Returns a new array with all of the items in the enumeration that the provided
+    callback function returns true for. This method corresponds to [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter).
+       The callback method should have the following signature:
+       ```javascript
+    function(item, index, array);
+    ```
+       - `item` is the current item in the iteration.
+    - `index` is the current index in the iteration.
+    - `array` is the array itself.
+       All parameters are optional. The function should return `true` to include the item
+    in the results, and `false` otherwise.
+       Example:
+       ```javascript
+    function isAdult(person) {
+      return person.age > 18;
+    };
+       let people = Ember.A([{ name: 'John', age: 14 }, { name: 'Joan', age: 45 }]);
+       people.filter(isAdult); // returns [{ name: 'Joan', age: 45 }];
+    ```
+       Note that in addition to a callback, you can pass an optional target object
+    that will be set as `this` on the context. This is a good way to give your
+    iterator function access to the current object. For example:
+       ```javascript
+    function isAdultAndEngineer(person) {
+      return person.age > 18 && this.engineering;
+    }
+       class AdultsCollection {
+      engineering = false;
+         constructor(opts = {}) {
+        super(...arguments);
+           this.engineering = opts.engineering;
+        this.people = Ember.A([{ name: 'John', age: 14 }, { name: 'Joan', age: 45 }]);
+      }
+    }
+       let collection = new AdultsCollection({ engineering: true });
+    collection.people.filter(isAdultAndEngineer, { target: collection });
+    ```
+       @method filter
+    @param {Function} callback The callback to execute
+    @param {Object} [target] The target object to use
+    @return {Array} A filtered array.
+    @public
+  */
+  filter(callback, target = null) {
+    assert('`filter` expects a function as first argument.', typeof callback === 'function');
+    let ret = A();
+    this.forEach((x, idx, i) => {
+      if (callback.call(target, x, idx, i)) {
+        ret.push(x);
+      }
+    });
+    return ret;
+  },
+
+  /**
+    Returns an array with all of the items in the enumeration where the passed
+    function returns false. This method is the inverse of filter().
+       The callback method you provide should have the following signature (all
+    parameters are optional):
+       ```javascript
+    function(item, index, array);
+    ```
+       - *item* is the current item in the iteration.
+    - *index* is the current index in the iteration
+    - *array* is the array itself.
+       It should return a falsey value to include the item in the results.
+       Note that in addition to a callback, you can also pass an optional target
+    object that will be set as "this" on the context. This is a good way
+    to give your iterator function access to the current object.
+       Example Usage:
+       ```javascript
+    const food = [
+      { food: 'apple', isFruit: true },
+      { food: 'bread', isFruit: false },
+      { food: 'banana', isFruit: true }
+    ];
+    const nonFruits = food.reject(function(thing) {
+      return thing.isFruit;
+    }); // [{food: 'bread', isFruit: false}]
+    ```
+       @method reject
+    @param {Function} callback The callback to execute
+    @param {Object} [target] The target object to use
+    @return {Array} A rejected array.
+    @public
+  */
+  reject(callback, target = null) {
+    assert('`reject` expects a function as first argument.', typeof callback === 'function');
+    return this.filter(function () {
+      // @ts-expect-error TS doesn't like us using arguments like this
+      return !callback.apply(target, arguments);
+    });
+  },
+
+  /**
+    Filters the array by the property and an optional value. If a value is given, it returns
+    the items that have said value for the property. If not, it returns all the items that
+    have a truthy value for the property.
+       Example Usage:
+       ```javascript
+    let things = Ember.A([{ food: 'apple', isFruit: true }, { food: 'beans', isFruit: false }]);
+       things.filterBy('food', 'beans'); // [{ food: 'beans', isFruit: false }]
+    things.filterBy('isFruit'); // [{ food: 'apple', isFruit: true }]
+    ```
+       @method filterBy
+    @param {String} key the property to test
+    @param {*} [value] optional value to test against.
+    @return {Array} filtered array
+    @public
+  */
+  filterBy() {
+    // @ts-expect-error TS doesn't like the ...arguments spread here.
+    return this.filter(iter(...arguments));
+  },
+
+  /**
+    Returns an array with the items that do not have truthy values for the provided key.
+    You can pass an optional second argument with a target value to reject for the key.
+    Otherwise this will reject objects where the provided property evaluates to false.
+       Example Usage:
+       ```javascript
+      let food = [
+        { name: "apple", isFruit: true },
+        { name: "carrot", isFruit: false },
+        { name: "bread", isFruit: false },
+      ];
+      food.rejectBy('isFruit'); // [{ name: "carrot", isFruit: false }, { name: "bread", isFruit: false }]
+      food.rejectBy('name', 'carrot'); // [{ name: "apple", isFruit: true }}, { name: "bread", isFruit: false }]
+    ```
+       @method rejectBy
+    @param {String} key the property to test
+    @param {*} [value] optional value to test against.
+    @return {Array} rejected array
+    @public
+  */
+  rejectBy() {
+    // @ts-expect-error TS doesn't like the ...arguments spread here.
+    return this.reject(iter(...arguments));
+  },
+
+  /**
+    Returns the first item in the array for which the callback returns true.
+    This method is similar to the `find()` method defined in ECMAScript 2015.
+       The callback method you provide should have the following signature (all
+    parameters are optional):
+       ```javascript
+    function(item, index, array);
+    ```
+       - `item` is the current item in the iteration.
+    - `index` is the current index in the iteration.
+    - `array` is the array itself.
+       It should return the `true` to include the item in the results, `false`
+    otherwise.
+       Note that in addition to a callback, you can also pass an optional target
+    object that will be set as `this` on the context. This is a good way
+    to give your iterator function access to the current object.
+       Example Usage:
+       ```javascript
+    let users = [
+      { id: 1, name: 'Yehuda' },
+      { id: 2, name: 'Tom' },
+      { id: 3, name: 'Melanie' },
+      { id: 4, name: 'Leah' }
+    ];
+       users.find((user) => user.name == 'Tom'); // [{ id: 2, name: 'Tom' }]
+    users.find(({ id }) => id == 3); // [{ id: 3, name: 'Melanie' }]
+    ```
+       @method find
+    @param {Function} callback The callback to execute
+    @param {Object} [target] The target object to use
+    @return {Object} Found item or `undefined`.
+    @public
+  */
+  find(callback, target = null) {
+    assert('`find` expects a function as first argument.', typeof callback === 'function');
+    return find(this, callback, target);
+  },
+
+  /**
+    Returns the first item with a property matching the passed value. You
+    can pass an optional second argument with the target value. Otherwise
+    this will match any property that evaluates to `true`.
+       This method works much like the more generic `find()` method.
+       Usage Example:
+       ```javascript
+    let users = [
+      { id: 1, name: 'Yehuda', isTom: false },
+      { id: 2, name: 'Tom', isTom: true },
+      { id: 3, name: 'Melanie', isTom: false },
+      { id: 4, name: 'Leah', isTom: false }
+    ];
+       users.findBy('id', 4); // { id: 4, name: 'Leah', isTom: false }
+    users.findBy('name', 'Melanie'); // { id: 3, name: 'Melanie', isTom: false }
+    users.findBy('isTom'); // { id: 2, name: 'Tom', isTom: true }
+    ```
+       @method findBy
+    @param {String} key the property to test
+    @param {String} [value] optional value to test against.
+    @return {Object} found item or `undefined`
+    @public
+  */
+  findBy() {
+    // @ts-expect-error TS doesn't like the ...arguments spread here.
+    let callback = iter(...arguments);
+    return find(this, callback);
+  },
+
+  /**
+    Returns `true` if the passed function returns true for every item in the
+    enumeration. This corresponds with the `Array.prototype.every()` method defined in ES5.
+       The callback method should have the following signature:
+       ```javascript
+    function(item, index, array);
+    ```
+       - `item` is the current item in the iteration.
+    - `index` is the current index in the iteration.
+    - `array` is the array itself.
+       All params are optional. The method should return `true` or `false`.
+       Note that in addition to a callback, you can also pass an optional target
+    object that will be set as `this` on the context. This is a good way
+    to give your iterator function access to the current object.
+       Usage example:
+       ```javascript
+    function isAdult(person) {
+      return person.age > 18;
+    };
+       const people = Ember.A([{ name: 'John', age: 24 }, { name: 'Joan', age: 45 }]);
+    const areAllAdults = people.every(isAdult);
+    ```
+       @method every
+    @param {Function} callback The callback to execute
+    @param {Object} [target] The target object to use
+    @return {Boolean}
+    @public
+  */
+  every(callback, target = null) {
+    assert('`every` expects a function as first argument.', typeof callback === 'function');
+    return every(this, callback, target);
+  },
+
+  /**
+    Returns `true` if the passed property resolves to the value of the second
+    argument for all items in the array. This method is often simpler/faster
+    than using a callback.
+       Note that like the native `Array.every`, `isEvery` will return true when called
+    on any empty array.
+    ```javascript
+    class Language {
+      constructor(name, isProgrammingLanguage) {
+        this.name = name;
+        this.programmingLanguage = isProgrammingLanguage;
+      }
+    }
+       const compiledLanguages = [
+      new Language('Java', true),
+      new Language('Go', true),
+      new Language('Rust', true)
+    ]
+       const languagesKnownByMe = [
+      new Language('Javascript', true),
+      new Language('English', false),
+      new Language('Ruby', true)
+    ]
+       compiledLanguages.isEvery('programmingLanguage'); // true
+    languagesKnownByMe.isEvery('programmingLanguage'); // false
+    ```
+       @method isEvery
+    @param {String} key the property to test
+    @param {String} [value] optional value to test against. Defaults to `true`
+    @return {Boolean}
+    @since 1.3.0
+    @public
+  */
+  isEvery() {
+    // @ts-expect-error TS doesn't like the ...arguments spread here.
+    let callback = iter(...arguments);
+    return every(this, callback);
+  },
+
+  /**
+    The any() method executes the callback function once for each element
+    present in the array until it finds the one where callback returns a truthy
+    value (i.e. `true`). If such an element is found, any() immediately returns
+    true. Otherwise, any() returns false.
+       ```javascript
+    function(item, index, array);
+    ```
+       - `item` is the current item in the iteration.
+    - `index` is the current index in the iteration.
+    - `array` is the array object itself.
+       Note that in addition to a callback, you can also pass an optional target
+    object that will be set as `this` on the context. It can be a good way
+    to give your iterator function access to an object in cases where an ES6
+    arrow function would not be appropriate.
+       Usage Example:
+       ```javascript
+    let includesManager = people.any(this.findPersonInManagersList, this);
+       let includesStockHolder = people.any(person => {
+      return this.findPersonInStockHoldersList(person)
+    });
+       if (includesManager || includesStockHolder) {
+      Paychecks.addBiggerBonus();
+    }
+    ```
+       @method any
+    @param {Function} callback The callback to execute
+    @param {Object} [target] The target object to use
+    @return {Boolean} `true` if the passed function returns `true` for any item
+    @public
+  */
+  any(callback, target = null) {
+    assert('`any` expects a function as first argument.', typeof callback === 'function');
+    return any(this, callback, target);
+  },
+
+  /**
+    Returns `true` if the passed property resolves to the value of the second
+    argument for any item in the array. This method is often simpler/faster
+    than using a callback.
+       Example usage:
+       ```javascript
+    const food = [
+      { food: 'apple', isFruit: true },
+      { food: 'bread', isFruit: false },
+      { food: 'banana', isFruit: true }
+    ];
+       food.isAny('isFruit'); // true
+    ```
+       @method isAny
+    @param {String} key the property to test
+    @param {String} [value] optional value to test against. Defaults to `true`
+    @return {Boolean}
+    @since 1.3.0
+    @public
+  */
+  isAny() {
+    // @ts-expect-error TS doesn't like us using arguments like this
+    let callback = iter(...arguments);
+    return any(this, callback);
+  },
+
+  /**
+    This will combine the values of the array into a single value. It
+    is a useful way to collect a summary value from an array. This
+    corresponds to the `reduce()` method defined in JavaScript 1.8.
+       The callback method you provide should have the following signature (all
+    parameters are optional):
+       ```javascript
+    function(previousValue, item, index, array);
+    ```
+       - `previousValue` is the value returned by the last call to the iterator.
+    - `item` is the current item in the iteration.
+    - `index` is the current index in the iteration.
+    - `array` is the array itself.
+       Return the new cumulative value.
+       In addition to the callback you can also pass an `initialValue`. An error
+    will be raised if you do not pass an initial value and the enumerator is
+    empty.
+       Note that unlike the other methods, this method does not allow you to
+    pass a target object to set as this for the callback. It's part of the
+    spec. Sorry.
+       Example Usage:
+       ```javascript
+      let numbers = [1, 2, 3, 4, 5];
+         numbers.reduce(function(summation, current) {
+        return summation + current;
+      }); // 15 (1 + 2 + 3 + 4 + 5)
+         numbers.reduce(function(summation, current) {
+        return summation + current;
+      }, -15); // 0 (-15 + 1 + 2 + 3 + 4 + 5)
+   
+      let binaryValues = [true, false, false];
+         binaryValues.reduce(function(truthValue, current) {
+        return truthValue && current;
+      }); // false (true && false && false)
+    ```
+       @method reduce
+    @param {Function} callback The callback to execute
+    @param {Object} initialValue Initial value for the reduce
+    @return {Object} The reduced value.
+    @public
+  */
+  // FIXME: When called without initialValue, behavior does not match native behavior
+  reduce(callback, initialValue) {
+    assert('`reduce` expects a function as first argument.', typeof callback === 'function');
+    let ret = initialValue;
+    this.forEach(function (item, i) {
+      ret = callback(ret, item, i, this);
+    }, this);
+    return ret;
+  },
+
+  /**
+    Invokes the named method on every object in the receiver that
+    implements it. This method corresponds to the implementation in
+    Prototype 1.6.
+       ```javascript
+    class Person {
+      name = null;
+         constructor(name) {
+        this.name = name;
+      }
+         greet(prefix='Hello') {
+        return `${prefix} ${this.name}`;
+      }
+    }
+       let people = [new Person('Joe'), new Person('Matt')];
+       people.invoke('greet'); // ['Hello Joe', 'Hello Matt']
+    people.invoke('greet', 'Bonjour'); // ['Bonjour Joe', 'Bonjour Matt']
+    ```
+       @method invoke
+    @param {String} methodName the name of the method
+    @param {Object...} args optional arguments to pass as well.
+    @return {Array} return values from calling invoke.
+    @public
+  */
+  invoke(methodName, ...args) {
+    let ret = A(); // SAFETY: This is not entirely safe and the code will not work with Ember proxies
+
+    this.forEach(item => {
+      var _a, _b;
+
+      return ret.push((_b = (_a = item)[methodName]) === null || _b === void 0 ? void 0 : _b.call(_a, ...args));
+    });
+    return ret;
+  },
+
+  /**
+    Simply converts the object into a genuine array. The order is not
+    guaranteed. Corresponds to the method implemented by Prototype.
+       @method toArray
+    @return {Array} the object as an array.
+    @public
+  */
+  toArray() {
+    return this.map(item => item);
+  },
+
+  /**
+    Returns a copy of the array with all `null` and `undefined` elements removed.
+       ```javascript
+    let arr = ['a', null, 'c', undefined];
+    arr.compact();  // ['a', 'c']
+    ```
+       @method compact
+    @return {Array} the array without null and undefined elements.
+    @public
+  */
+  compact() {
+    return this.filter(value => value != null);
+  },
+
+  /**
+    Used to determine if the array contains the passed object.
+    Returns `true` if found, `false` otherwise.
+       The optional `startAt` argument can be used to pass a starting
+    index to search from, effectively slicing the searchable portion
+    of the array. If it's negative it will add the array length to
+    the startAt value passed in as the index to search from. If less
+    than or equal to `-1 * array.length` the entire array is searched.
+       This method has the same behavior of JavaScript's [Array.includes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes).
+       ```javascript
+    [1, 2, 3].includes(2);     // true
+    [1, 2, 3].includes(4);     // false
+    [1, 2, 3].includes(3, 2);  // true
+    [1, 2, 3].includes(3, 3);  // false
+    [1, 2, 3].includes(3, -1); // true
+    [1, 2, 3].includes(1, -1); // false
+    [1, 2, 3].includes(1, -4); // true
+    [1, 2, NaN].includes(NaN); // true
+    ```
+       @method includes
+    @param {Object} object The object to search for.
+    @param {Number} startAt optional starting location to search, default 0
+    @return {Boolean} `true` if object is found in the array.
+    @public
+  */
+  includes(object, startAt) {
+    return indexOf(this, object, startAt, true) !== -1;
+  },
+
+  /**
+    Sorts the array by the keys specified in the argument.
+       You may provide multiple arguments to sort by multiple properties.
+       ```javascript
+   let colors = [
+     { name: 'red', weight: 500 },
+     { name: 'green', weight: 600 },
+     { name: 'blue', weight: 500 }
+    ];
+      colors.sortBy('name');
+   // [{name: 'blue', weight: 500}, {name: 'green', weight: 600}, {name: 'red', weight: 500}]
+      colors.sortBy('weight', 'name');
+   // [{name: 'blue', weight: 500}, {name: 'red', weight: 500}, {name: 'green', weight: 600}]
+   ```
+       @method sortBy
+    @param {String} property name(s) to sort on
+    @return {Array} The sorted array.
+    @since 1.2.0
+    @public
+  */
+  sortBy() {
+    let sortKeys = arguments;
+    return this.toArray().sort((a, b) => {
+      for (let i = 0; i < sortKeys.length; i++) {
+        let key = sortKeys[i];
+        let propA = get(a, key);
+        let propB = get(b, key); // return 1 or -1 else continue to the next sortKey
+
+        let compareValue = compare(propA, propB);
+
+        if (compareValue) {
+          return compareValue;
+        }
+      }
+
+      return 0;
+    });
+  },
+
+  /**
+    Returns a new array that contains only unique values. The default
+    implementation returns an array regardless of the receiver type.
+       ```javascript
+    let arr = ['a', 'a', 'b', 'b'];
+    arr.uniq();  // ['a', 'b']
+    ```
+       This only works on primitive data types, e.g. Strings, Numbers, etc.
+       @method uniq
+    @return {EmberArray}
+    @public
+  */
+  uniq() {
+    return uniqBy(this);
+  },
+
+  /**
+    Returns a new array that contains only items containing a unique property value.
+    The default implementation returns an array regardless of the receiver type.
+       ```javascript
+    let arr = [{ value: 'a' }, { value: 'a' }, { value: 'b' }, { value: 'b' }];
+    arr.uniqBy('value');  // [{ value: 'a' }, { value: 'b' }]
+       let arr = [2.2, 2.1, 3.2, 3.3];
+    arr.uniqBy(Math.floor);  // [2.2, 3.2];
+    ```
+       @method uniqBy
+    @param {String,Function} key
+    @return {EmberArray}
+    @public
+  */
+  uniqBy(key) {
+    return uniqBy(this, key);
+  },
+
+  /**
+    Returns a new array that excludes the passed value. The default
+    implementation returns an array regardless of the receiver type.
+    If the receiver does not contain the value it returns the original array.
+       ```javascript
+    let arr = ['a', 'b', 'a', 'c'];
+    arr.without('a');  // ['b', 'c']
+    ```
+       @method without
+    @param {Object} value
+    @return {EmberArray}
+    @public
+  */
+  without(value) {
+    if (!this.includes(value)) {
+      return this; // nothing to do
+    } // SameValueZero comparison (NaN !== NaN)
+
+
+    let predicate = value === value ? item => item !== value : item => item === item;
+    return this.filter(predicate);
+  }
+
+});
+const MutableArray = Mixin.create(EmberArray, 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.
+       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
+      idx >= length, then append to the end of the array.
+    @param {Number} amt Number of elements that should be removed from
+      the array, starting at *idx*.
+    @param {EmberArray} [objects] An optional array of zero or more objects that should be
+      inserted into the array at *idx*
+    @public
+  */
+
+  /**
+    Remove all elements from the array. This is useful if you
+    want to reuse an existing array without having to recreate it.
+       ```javascript
+    let colors = ['red', 'green', 'blue'];
+       colors.length;  // 3
+    colors.clear(); // []
+    colors.length;  // 0
+    ```
+       @method clear
+    @return {Array} An empty Array.
+    @public
+  */
+  clear() {
+    let len = this.length;
+
+    if (len === 0) {
+      return this;
+    }
+
+    this.replace(0, len, EMPTY_ARRAY);
+    return this;
+  },
+
+  /**
+    This will use the primitive `replace()` method to insert an object at the
+    specified index.
+       ```javascript
+    let colors = ['red', 'green', 'blue'];
+       colors.insertAt(2, 'yellow');  // ['red', 'green', 'yellow', 'blue']
+    colors.insertAt(5, 'orange');  // Error: Index out of range
+    ```
+       @method insertAt
+    @param {Number} idx index of insert the object at.
+    @param {Object} object object to insert
+    @return {EmberArray} receiver
+    @public
+  */
+  insertAt(idx, object) {
+    insertAt(this, idx, object);
+    return this;
+  },
+
+  /**
+    Remove an object at the specified index using the `replace()` primitive
+    method. You can pass either a single index, or a start and a length.
+       If you pass a start and length that is beyond the
+    length this method will throw an assertion.
+       ```javascript
+    let colors = ['red', 'green', 'blue', 'yellow', 'orange'];
+       colors.removeAt(0);     // ['green', 'blue', 'yellow', 'orange']
+    colors.removeAt(2, 2);  // ['green', 'blue']
+    colors.removeAt(4, 2);  // Error: Index out of range
+    ```
+       @method removeAt
+    @param {Number} start index, start of range
+    @param {Number} len length of passing range
+    @return {EmberArray} receiver
+    @public
+  */
+  removeAt(start, len) {
+    return removeAt(this, start, len);
+  },
+
+  /**
+    Push the object onto the end of the array. Works just like `push()` but it
+    is KVO-compliant.
+       ```javascript
+    let colors = ['red', 'green'];
+       colors.pushObject('black');     // ['red', 'green', 'black']
+    colors.pushObject(['yellow']);  // ['red', 'green', ['yellow']]
+    ```
+       @method pushObject
+    @param {*} obj object to push
+    @return object same object passed as a param
+    @public
+  */
+  pushObject(obj) {
+    return insertAt(this, this.length, obj);
+  },
+
+  /**
+    Add the objects in the passed array to the end of the array. Defers
+    notifying observers of the change until all objects are added.
+       ```javascript
+    let colors = ['red'];
+       colors.pushObjects(['yellow', 'orange']);  // ['red', 'yellow', 'orange']
+    ```
+       @method pushObjects
+    @param {Array} objects the objects to add
+    @return {MutableArray} receiver
+    @public
+  */
+  pushObjects(objects) {
+    this.replace(this.length, 0, objects);
+    return this;
+  },
+
+  /**
+    Pop object from array or nil if none are left. Works just like `pop()` but
+    it is KVO-compliant.
+       ```javascript
+    let colors = ['red', 'green', 'blue'];
+       colors.popObject();   // 'blue'
+    console.log(colors);  // ['red', 'green']
+    ```
+       @method popObject
+    @return object
+    @public
+  */
+  popObject() {
+    let len = this.length;
+
+    if (len === 0) {
+      return null;
+    }
+
+    let ret = objectAt(this, len - 1);
+    this.removeAt(len - 1, 1);
+    return ret;
+  },
+
+  /**
+    Shift an object from start of array or nil if none are left. Works just
+    like `shift()` but it is KVO-compliant.
+       ```javascript
+    let colors = ['red', 'green', 'blue'];
+       colors.shiftObject();  // 'red'
+    console.log(colors);   // ['green', 'blue']
+    ```
+       @method shiftObject
+    @return object
+    @public
+  */
+  shiftObject() {
+    if (this.length === 0) {
+      return null;
+    }
+
+    let ret = objectAt(this, 0);
+    this.removeAt(0);
+    return ret;
+  },
+
+  /**
+    Unshift an object to start of array. Works just like `unshift()` but it is
+    KVO-compliant.
+       ```javascript
+    let colors = ['red'];
+       colors.unshiftObject('yellow');    // ['yellow', 'red']
+    colors.unshiftObject(['black']);   // [['black'], 'yellow', 'red']
+    ```
+       @method unshiftObject
+    @param {*} obj object to unshift
+    @return object same object passed as a param
+    @public
+  */
+  unshiftObject(obj) {
+    return insertAt(this, 0, obj);
+  },
+
+  /**
+    Adds the named objects to the beginning of the array. Defers notifying
+    observers until all objects have been added.
+       ```javascript
+    let colors = ['red'];
+       colors.unshiftObjects(['black', 'white']);   // ['black', 'white', 'red']
+    colors.unshiftObjects('yellow'); // Type Error: 'undefined' is not a function
+    ```
+       @method unshiftObjects
+    @param {Enumerable} objects the objects to add
+    @return {EmberArray} receiver
+    @public
+  */
+  unshiftObjects(objects) {
+    this.replace(0, 0, objects);
+    return this;
+  },
+
+  /**
+    Reverse objects in the array. Works just like `reverse()` but it is
+    KVO-compliant.
+       @method reverseObjects
+    @return {EmberArray} receiver
+     @public
+  */
+  reverseObjects() {
+    let len = this.length;
+
+    if (len === 0) {
+      return this;
+    }
+
+    let objects = this.toArray().reverse();
+    this.replace(0, len, objects);
+    return this;
+  },
+
+  /**
+    Replace all the receiver's content with content of the argument.
+    If argument is an empty array receiver will be cleared.
+       ```javascript
+    let colors = ['red', 'green', 'blue'];
+       colors.setObjects(['black', 'white']);  // ['black', 'white']
+    colors.setObjects([]);                  // []
+    ```
+       @method setObjects
+    @param {EmberArray} objects array whose content will be used for replacing
+        the content of the receiver
+    @return {EmberArray} receiver with the new content
+    @public
+  */
+  setObjects(objects) {
+    if (objects.length === 0) {
+      return this.clear();
+    }
+
+    let len = this.length;
+    this.replace(0, len, objects);
+    return this;
+  },
+
+  /**
+    Remove all occurrences of an object in the array.
+       ```javascript
+    let cities = ['Chicago', 'Berlin', 'Lima', 'Chicago'];
+       cities.removeObject('Chicago');  // ['Berlin', 'Lima']
+    cities.removeObject('Lima');     // ['Berlin']
+    cities.removeObject('Tokyo')     // ['Berlin']
+    ```
+       @method removeObject
+    @param {*} obj object to remove
+    @return {EmberArray} receiver
+    @public
+  */
+  removeObject(obj) {
+    let loc = this.length || 0;
+
+    while (--loc >= 0) {
+      let curObject = objectAt(this, loc);
+
+      if (curObject === obj) {
+        this.removeAt(loc);
+      }
+    }
+
+    return this;
+  },
+
+  /**
+    Removes each object in the passed array from the receiver.
+       @method removeObjects
+    @param {EmberArray} objects the objects to remove
+    @return {EmberArray} receiver
+    @public
+  */
+  removeObjects(objects) {
+    beginPropertyChanges();
+
+    for (let i = objects.length - 1; i >= 0; i--) {
+      // SAFETY: Due to the loop structure we know this will always exist.
+      this.removeObject(objects[i]);
+    }
+
+    endPropertyChanges();
+    return this;
+  },
+
+  /**
+    Push the object onto the end of the array if it is not already
+    present in the array.
+       ```javascript
+    let cities = ['Chicago', 'Berlin'];
+       cities.addObject('Lima');    // ['Chicago', 'Berlin', 'Lima']
+    cities.addObject('Berlin');  // ['Chicago', 'Berlin', 'Lima']
+    ```
+       @method addObject
+    @param {*} obj object to add, if not already present
+    @return {EmberArray} receiver
+    @public
+  */
+  addObject(obj) {
+    let included = this.includes(obj);
+
+    if (!included) {
+      this.pushObject(obj);
+    }
+
+    return this;
+  },
+
+  /**
+    Adds each object in the passed array to the receiver.
+       @method addObjects
+    @param {EmberArray} objects the objects to add.
+    @return {EmberArray} receiver
+    @public
+  */
+  addObjects(objects) {
+    beginPropertyChanges();
+    objects.forEach(obj => this.addObject(obj));
+    endPropertyChanges();
+    return this;
+  }
+
+});
+let NativeArray = Mixin.create(MutableArray, Observable, {
+  objectAt(idx) {
+    return this[idx];
+  },
+
+  // primitive for array support.
+  replace(start, deleteCount, items = EMPTY_ARRAY) {
+    assert('The third argument to replace needs to be an array.', Array.isArray(items));
+    replaceInNativeArray(this, start, deleteCount, items);
+    return this;
+  }
+
+}); // Remove any methods implemented natively so we don't override them
+
+const ignore = ['length'];
+NativeArray.keys().forEach(methodName => {
+  // SAFETY: It's safe to read unknown properties from an object
+  if (Array.prototype[methodName]) {
+    ignore.push(methodName);
+  }
+});
+NativeArray = NativeArray.without(...ignore);
+let A;
+
+if (ENV.EXTEND_PROTOTYPES.Array) {
+  NativeArray.apply(Array.prototype, true);
+
+  A = function (arr) {
+    assert('You cannot create an Ember Array with `new A()`, please update to calling A as a function: `A()`', !(this instanceof A)); // SAFTEY: Since we are extending prototypes all true native arrays are Ember NativeArrays
+
+    return arr || [];
+  };
+} else {
+  A = function (arr) {
+    assert('You cannot create an Ember Array with `new A()`, please update to calling A as a function: `A()`', !(this instanceof A));
+
+    if (isEmberArray(arr)) {
+      // SAFETY: If it's a true native array and it is also an EmberArray then it should be an Ember NativeArray
+      return arr;
+    } else {
+      // SAFETY: This will return an NativeArray but TS can't infer that.
+      return NativeArray.apply(arr !== null && arr !== void 0 ? arr : []);
+    }
+  };
+}
+
+export { A, NativeArray, MutableArray };
+export default EmberArray;