ember-source 6.12.0 → 7.0.0-alpha.1

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

@@ -0,0 +1,591 @@
+import { b as beginPropertyChanges, a as endPropertyChanges, c as computed } from '../../shared-chunks/namespace_search-Aog9nySA.js';
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import '../../@glimmer/validator/index.js';
+import { g as get, n as objectAt } from '../../shared-chunks/observers-R1ZklwWy.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { s as set } from '../../shared-chunks/property_set-O080KTKZ.js';
+import { e as replaceInNativeArray, r as replace } from '../../shared-chunks/array-EwekEvId.js';
+import { setEmberArray, isEmberArray } from './-internals.js';
+import '../object/index.js';
+import Mixin from '../object/mixin.js';
+import Enumerable from '../enumerable/index.js';
+import MutableEnumerable from '../enumerable/mutable.js';
+import typeOf from '../utils/lib/type-of.js';
+import compare from '../utils/lib/compare.js';
+import Observable from '../object/observable.js';
+export { default as makeArray } from './lib/make-array.js';
+
+/**
+@module @ember/array
+*/
+
+const EMPTY_ARRAY = Object.freeze([]);
+const identityFunction = item => item;
+function uniqBy(array, keyOrFunc = identityFunction) {
+  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);
+}
+function removeAt(array, index, len) {
+  replace(array, index, len ?? 1, EMPTY_ARRAY);
+  return array;
+}
+function insertAt(array, index, item) {
+  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
+*/
+function isArray(obj) {
+
+  // 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.
+*/
+function nonEnumerableComputed(callback) {
+  let property = computed(callback);
+  property.enumerable = false;
+  return property;
+}
+function mapBy(key) {
+  return this.map(next => get(next, key));
+}
+
+// ..........................................................
+// ARRAY
+//
+/**
+  This mixin implements Observer-friendly Array-like behavior. It is not a
+  concrete implementation, but it can be used up by other classes that want
+  to appear like arrays.
+
+  For example, ArrayProxy is a concrete class that can be instantiated to
+  implement array-like behavior. This class uses the Array Mixin by way of
+  the MutableArray mixin, which allows observable changes to be made to the
+  underlying array.
+
+  This mixin defines methods specifically for collections that provide
+  index-ordered access to their contents. When you are designing code that
+  needs to accept any kind of Array-like object, you should use these methods
+  instead of Array primitives because these will properly notify observers of
+  changes to the array.
+
+  Although these methods are efficient, they do add a layer of indirection to
+  your application so it is a good idea to use them only when you need the
+  flexibility of using both true JavaScript arrays and "virtual" arrays such
+  as controllers and collections.
+
+  You can use the methods defined in this module to access and modify array
+  contents in an observable-friendly way. You can also be notified whenever
+  the membership of an array changes by using `.observes('myArray.[]')`.
+
+  To support `EmberArray` in your own class, you must override two
+  primitives to use it: `length()` and `objectAt()`.
+
+  @class EmberArray
+  @uses Enumerable
+  @since Ember 0.9.0
+  @public
+*/
+
+const EmberArray = Mixin.create(Enumerable, {
+  init() {
+    this._super(...arguments);
+    setEmberArray(this);
+  },
+  objectsAt(indexes) {
+    return indexes.map(idx => objectAt(this, idx));
+  },
+  '[]': nonEnumerableComputed({
+    get() {
+      return this;
+    },
+    set(_key, value) {
+      this.replace(0, this.length, value);
+      return this;
+    }
+  }),
+  firstObject: nonEnumerableComputed(function () {
+    return objectAt(this, 0);
+  }).readOnly(),
+  lastObject: nonEnumerableComputed(function () {
+    return objectAt(this, this.length - 1);
+  }).readOnly(),
+  // Add any extra methods to EmberArray that are native to the built-in Array.
+  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;
+  },
+  indexOf(object, startAt) {
+    return indexOf(this, object, startAt, false);
+  },
+  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;
+  },
+  forEach(callback, target = null) {
+    let length = this.length;
+    for (let index = 0; index < length; index++) {
+      let item = this.objectAt(index);
+      callback.call(target, item, index, this);
+    }
+    return this;
+  },
+  getEach: mapBy,
+  setEach(key, value) {
+    return this.forEach(item => set(item, key, value));
+  },
+  map(callback, target = null) {
+    let ret = A();
+    this.forEach((x, idx, i) => ret[idx] = callback.call(target, x, idx, i));
+    return ret;
+  },
+  mapBy,
+  filter(callback, target = null) {
+    let ret = A();
+    this.forEach((x, idx, i) => {
+      if (callback.call(target, x, idx, i)) {
+        ret.push(x);
+      }
+    });
+    return ret;
+  },
+  reject(callback, target = null) {
+    return this.filter(function () {
+      // @ts-expect-error TS doesn't like us using arguments like this
+      return !callback.apply(target, arguments);
+    });
+  },
+  filterBy() {
+    // @ts-expect-error TS doesn't like the ...arguments spread here.
+    return this.filter(iter(...arguments));
+  },
+  rejectBy() {
+    // @ts-expect-error TS doesn't like the ...arguments spread here.
+    return this.reject(iter(...arguments));
+  },
+  find(callback, target = null) {
+    return find(this, callback, target);
+  },
+  findBy() {
+    // @ts-expect-error TS doesn't like the ...arguments spread here.
+    let callback = iter(...arguments);
+    return find(this, callback);
+  },
+  every(callback, target = null) {
+    return every(this, callback, target);
+  },
+  isEvery() {
+    // @ts-expect-error TS doesn't like the ...arguments spread here.
+    let callback = iter(...arguments);
+    return every(this, callback);
+  },
+  any(callback, target = null) {
+    return any(this, callback, target);
+  },
+  isAny() {
+    // @ts-expect-error TS doesn't like us using arguments like this
+    let callback = iter(...arguments);
+    return any(this, callback);
+  },
+  // FIXME: When called without initialValue, behavior does not match native behavior
+  reduce(callback, initialValue) {
+    let hasInitialValue = arguments.length > 1;
+    let ret = initialValue;
+    let startIndex = 0;
+    if (!hasInitialValue) {
+      if (this.length === 0) {
+        throw new TypeError('Reduce of empty array with no initial value');
+      }
+      ret = this.objectAt(0);
+      startIndex = 1;
+    }
+    for (let i = startIndex; i < this.length; i++) {
+      let item = this.objectAt(i);
+      ret = callback(ret, item, i, this);
+    }
+    return ret;
+  },
+  invoke(methodName, ...args) {
+    let ret = A();
+
+    // SAFETY: This is not entirely safe and the code will not work with Ember proxies
+    this.forEach(item => ret.push(item[methodName]?.(...args)));
+    return ret;
+  },
+  toArray() {
+    return this.map(item => item);
+  },
+  compact() {
+    return this.filter(value => value != null);
+  },
+  includes(object, startAt) {
+    return indexOf(this, object, startAt, true) !== -1;
+  },
+  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;
+    });
+  },
+  uniq() {
+    return uniqBy(this);
+  },
+  uniqBy(key) {
+    return uniqBy(this, key);
+  },
+  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);
+  }
+});
+
+/**
+  This mixin defines the API for modifying array-like objects. These methods
+  can be applied only to a collection that keeps its items in an ordered set.
+  It builds upon the Array mixin and adds methods to modify the array.
+  One concrete implementations of this class include ArrayProxy.
+
+  It is important to use the methods in this class to modify arrays so that
+  changes are observable. This allows the binding system in Ember to function
+  correctly.
+
+
+  Note that an Array can change even if it does not implement this mixin.
+  For example, one might implement a SparseArray that cannot be directly
+  modified, but if its underlying enumerable changes, it will change also.
+
+  @class MutableArray
+  @uses EmberArray
+  @uses MutableEnumerable
+  @public
+*/
+
+const MutableArray = Mixin.create(EmberArray, MutableEnumerable, {
+  clear() {
+    let len = this.length;
+    if (len === 0) {
+      return this;
+    }
+    this.replace(0, len, EMPTY_ARRAY);
+    return this;
+  },
+  insertAt(idx, object) {
+    insertAt(this, idx, object);
+    return this;
+  },
+  removeAt(start, len) {
+    return removeAt(this, start, len);
+  },
+  pushObject(obj) {
+    return insertAt(this, this.length, obj);
+  },
+  pushObjects(objects) {
+    this.replace(this.length, 0, objects);
+    return this;
+  },
+  popObject() {
+    let len = this.length;
+    if (len === 0) {
+      return null;
+    }
+    let ret = objectAt(this, len - 1);
+    this.removeAt(len - 1, 1);
+    return ret;
+  },
+  shiftObject() {
+    if (this.length === 0) {
+      return null;
+    }
+    let ret = objectAt(this, 0);
+    this.removeAt(0);
+    return ret;
+  },
+  unshiftObject(obj) {
+    return insertAt(this, 0, obj);
+  },
+  unshiftObjects(objects) {
+    this.replace(0, 0, objects);
+    return this;
+  },
+  reverseObjects() {
+    let len = this.length;
+    if (len === 0) {
+      return this;
+    }
+    let objects = this.toArray().reverse();
+    this.replace(0, len, objects);
+    return this;
+  },
+  setObjects(objects) {
+    if (objects.length === 0) {
+      return this.clear();
+    }
+    let len = this.length;
+    this.replace(0, len, objects);
+    return this;
+  },
+  removeObject(obj) {
+    let loc = this.length || 0;
+    while (--loc >= 0) {
+      let curObject = objectAt(this, loc);
+      if (curObject === obj) {
+        this.removeAt(loc);
+      }
+    }
+    return this;
+  },
+  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;
+  },
+  addObject(obj) {
+    let included = this.includes(obj);
+    if (!included) {
+      this.pushObject(obj);
+    }
+    return this;
+  },
+  addObjects(objects) {
+    beginPropertyChanges();
+    objects.forEach(obj => this.addObject(obj));
+    endPropertyChanges();
+    return this;
+  }
+});
+
+/**
+  Creates an `NativeArray` from an Array-like object.
+  Does not modify the original object's contents.
+
+  Example
+
+  ```app/components/my-component.js
+  import Component from '@ember/component';
+  import { A } from '@ember/array';
+
+  export default Component.extend({
+    tagName: 'ul',
+    classNames: ['pagination'],
+
+    init() {
+      this._super(...arguments);
+
+      if (!this.get('content')) {
+        this.set('content', A());
+        this.set('otherContent', A([1,2,3]));
+      }
+    }
+  });
+  ```
+
+  @method A
+  @static
+  @for @ember/array
+  @return {Ember.NativeArray}
+  @public
+*/
+
+// Add Ember.Array to Array.prototype. Remove methods with native
+// implementations and supply some more optimized versions of generic methods
+// because they are so common.
+/**
+@module ember
+*/
+
+/**
+ * The final definition of NativeArray removes all native methods. This is the list of removed methods
+ * when run in Chrome 106.
+ */
+
+/**
+ * These additional items must be redefined since `Omit` causes methods that return `this` to return the
+ * type at the time of the Omit.
+ */
+
+// This is the same as MutableArray, but removes the actual native methods that exist on Array.prototype.
+
+/**
+  The NativeArray mixin contains the properties needed to make the native
+  Array support MutableArray and all of its dependent APIs.
+
+  @class Ember.NativeArray
+  @uses MutableArray
+  @uses Observable
+  @public
+*/
+
+let NativeArray = Mixin.create(MutableArray, Observable, {
+  objectAt(idx) {
+    return this[idx];
+  },
+  // primitive for array support.
+  replace(start, deleteCount, items = EMPTY_ARRAY) {
+    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;
+A = function (arr) {
+  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 ?? []);
+  }
+};
+
+export { A, MutableArray, NativeArray, EmberArray as default, isArray, removeAt, uniqBy };

package/dist/prod/packages/@ember/array/lib/make-array.js

@@ -0,0 +1,42 @@
+const {
+  isArray
+} = Array;
+/**
+ @module @ember/array
+*/
+/**
+ Forces the passed object to be part of an array. If the object is already
+ an array, it will return the object. Otherwise, it will add the object to
+ an array. If object is `null` or `undefined`, it will return an empty array.
+
+ ```javascript
+ import { makeArray } from '@ember/array';
+ import ArrayProxy from '@ember/array/proxy';
+
+ makeArray();            // []
+ makeArray(null);        // []
+ makeArray(undefined);   // []
+ makeArray('lindsay');   // ['lindsay']
+ makeArray([1, 2, 42]);  // [1, 2, 42]
+
+ let proxy = ArrayProxy.create({ content: [] });
+
+ makeArray(proxy) === proxy;  // false
+ ```
+
+ @method makeArray
+ @static
+ @for @ember/array
+ @param {Object} obj the object
+ @return {Array}
+ @private
+ */
+
+function makeArray(obj) {
+  if (obj === null || obj === undefined) {
+    return [];
+  }
+  return isArray(obj) ? obj : [obj];
+}
+
+export { makeArray as default };

package/dist/prod/packages/@ember/array/make.js

@@ -0,0 +1 @@
+export { default } from './lib/make-array.js';

package/dist/prod/packages/@ember/array/mutable.js

@@ -0,0 +1 @@
+export { MutableArray as default } from './index.js';