ember-source 4.9.0-beta.3 → 4.9.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-source",
-  "version": "4.9.0-beta.3",
+  "version": "4.9.0-beta.4",
   "description": "A JavaScript framework for creating ambitious web applications",
   "keywords": [
     "ember-addon"
@@ -179,7 +179,7 @@
       ]
     }
   },
-  "_originalVersion": "4.9.0-beta.3",
+  "_originalVersion": "4.9.0-beta.4",
   "_versionPreviouslyCalculated": true,
   "publishConfig": {
     "tag": "beta"

package/types/preview/@ember/application/index.d.ts

@@ -123,7 +123,13 @@ declare module '@ember/application' {
   // whenever we add new base classes to the framework. For example, if we
   // introduce a standalone `Service` or `Route` base class which *does not*
   // extend from `EmberObject`, it will need to be added here.
-  type FrameworkObject = EmberObject | GlimmerComponent;
+  //
+  // NOTE: we use `any` here because we need to make sure *not* to fix the
+  // actual GlimmerComponent type; using `unknown` or `{}` or `never` (the
+  // obvious alternatives here) results in a version which is too narrow, such
+  // that any subclass which applies a signature does not get resolved by the
+  // definition of `getOwner()` below.
+  type KnownFrameworkObject = EmberObject | GlimmerComponent<any>;
 
   /**
    * Framework objects in an Ember application (components, services, routes, etc.)
@@ -131,7 +137,15 @@ declare module '@ember/application' {
    * objects is the responsibility of an "owner", which handled its
    * instantiation and manages its lifetime.
    */
-  export function getOwner(object: FrameworkObject): Owner;
+  // SAFETY: this first overload is, strictly speaking, *unsafe*. It is possible
+  // to do `let x = EmberObject.create(); getOwner(x);` and the result will *not*
+  // be `Owner` but instead `undefined`. However, that's quite unusual at this
+  // point, and more to the point we cannot actually distinguish a `Service`
+  // subclass from `EmberObject` at this point: `Service` subclasses `EmberObject`
+  // and adds nothing to it. Accordingly, if we want to catch `Service`s with this
+  // (and `getOwner(this)` for some service will definitely be defined!), it has
+  // to be this way. :sigh:
+  export function getOwner(object: KnownFrameworkObject): Owner;
   export function getOwner(object: unknown): Owner | undefined;
   /**
    * `setOwner` forces a new owner on a given object instance. This is primarily

package/types/preview/@ember/array/-private/native-array.d.ts

@@ -1,11 +1,172 @@
 declare module '@ember/array/-private/native-array' {
   import Observable from '@ember/object/observable';
+  import EmberArray from '@ember/array';
   import MutableArray from '@ember/array/mutable';
   import Mixin from '@ember/object/mixin';
 
   // Get an alias to the global Array type to use in inner scope below.
   type Array<T> = T[];
 
+  type AnyArray<T> = EmberArray<T> | Array<T>;
+
+  /**
+   * The final definition of NativeArray removes all native methods. This is the list of removed methods
+   * when run in Chrome 106.
+   */
+  type IGNORED_MUTABLE_ARRAY_METHODS =
+    | 'length'
+    | 'slice'
+    | 'indexOf'
+    | 'lastIndexOf'
+    | 'forEach'
+    | 'map'
+    | 'filter'
+    | 'find'
+    | 'every'
+    | 'reduce'
+    | 'includes';
+
+  /**
+   * These additional items must be redefined since `Omit` causes methods that return `this` to return the
+   * type at the time of the Omit.
+   */
+  type RETURN_SELF_ARRAY_METHODS =
+    | '[]'
+    | 'clear'
+    | 'insertAt'
+    | 'removeAt'
+    | 'pushObjects'
+    | 'unshiftObjects'
+    | 'reverseObjects'
+    | 'setObjects'
+    | 'removeObject'
+    | 'removeObjects'
+    | 'addObject'
+    | 'addObjects'
+    | 'setEach';
+
+  // This is the same as MutableArray, but removes the actual native methods that exist on Array.prototype.
+  interface MutableArrayWithoutNative<T>
+    extends Omit<MutableArray<T>, IGNORED_MUTABLE_ARRAY_METHODS | RETURN_SELF_ARRAY_METHODS> {
+    /**
+     * Remove all elements from the array. This is useful if you
+     * want to reuse an existing array without having to recreate it.
+     */
+    clear(): this;
+    /**
+     * This will use the primitive `replace()` method to insert an object at the
+     * specified index.
+     */
+    insertAt(idx: number, object: T): 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.
+     */
+    removeAt(start: number, len?: number): this;
+    /**
+     * Add the objects in the passed numerable to the end of the array. Defers
+     * notifying observers of the change until all objects are added.
+     */
+    pushObjects(objects: AnyArray<T>): this;
+    /**
+     * Adds the named objects to the beginning of the array. Defers notifying
+     * observers until all objects have been added.
+     */
+    unshiftObjects(objects: AnyArray<T>): this;
+    /**
+     * Reverse objects in the array. Works just like `reverse()` but it is
+     * KVO-compliant.
+     */
+    reverseObjects(): this;
+    /**
+     * Replace all the receiver's content with content of the argument.
+     * If argument is an empty array receiver will be cleared.
+     */
+    setObjects(objects: AnyArray<T>): 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(object: T): this;
+    /**
+     * Removes each object in the passed array from the receiver.
+     */
+    removeObjects(objects: AnyArray<T>): 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: T): this;
+    /**
+     * Adds each object in the passed enumerable to the receiver.
+     */
+    addObjects(objects: AnyArray<T>): this;
+    /**
+      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<K extends keyof T>(key: K, value: T[K]): this;
+    /**
+      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
+    */
+    get '[]'(): this;
+    set '[]'(newValue: T[] | this);
+  }
+
   /**
    * The NativeArray mixin contains the properties needed to make the native
    * Array support Ember.MutableArray and all of its dependent APIs. Unless you
@@ -13,10 +174,7 @@ declare module '@ember/array/-private/native-array' {
    * false, this will be applied automatically. Otherwise you can apply the mixin
    * at anytime by calling `Ember.NativeArray.apply(Array.prototype)`.
    */
-  interface NativeArray<T>
-    extends Omit<Array<T>, 'every' | 'filter' | 'find' | 'forEach' | 'map' | 'reduce' | 'slice'>,
-      Observable,
-      MutableArray<T> {}
+  interface NativeArray<T> extends Array<T>, Observable, MutableArrayWithoutNative<T> {}
 
   const NativeArray: Mixin;
   export default NativeArray;

package/types/preview/@ember/array/index.d.ts

@@ -73,7 +73,7 @@ declare module '@ember/array' {
      * implements Ember.Observable, the value will be changed to `set(),` otherwise
      * it will be set directly. `null` objects are skipped.
      */
-    setEach<K extends keyof T>(key: K, value: T[K]): void;
+    setEach<K extends keyof T>(key: K, value: T[K]): this;
     /**
      * 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.
@@ -111,12 +111,14 @@ declare module '@ember/array' {
      * this will match any property that evaluates to `true`.
      */
     filterBy<K extends keyof T>(key: K, value?: T[K]): NativeArray<T>;
+    filterBy(key: string, value?: unknown): NativeArray<T>;
     /**
      * Returns an array with the items that do not have truthy values for
      * key.  You can pass an optional second argument with the target value.  Otherwise
      * this will match any property that evaluates to false.
      */
     rejectBy<K extends keyof T>(key: K, value?: T[K]): NativeArray<T>;
+    rejectBy(key: string, value?: unknown): NativeArray<T>;
     /**
      * Returns the first item in the array for which the callback returns true.
      * This method works similar to the `filter()` method defined in JavaScript 1.6
@@ -136,6 +138,7 @@ declare module '@ember/array' {
      * this will match any property that evaluates to `true`.
      */
     findBy<K extends keyof T>(key: K, value?: T[K]): T | undefined;
+    findBy(key: string, value?: unknown): T | undefined;
     /**
      * Returns `true` if the passed function returns true for every item in the
      * enumeration. This corresponds with the `every()` method in JavaScript 1.6.
@@ -150,6 +153,7 @@ declare module '@ember/array' {
      * than using a callback.
      */
     isEvery<K extends keyof T>(key: K, value?: T[K]): boolean;
+    isEvery(key: string, value?: unknown): boolean;
     /**
      * Returns `true` if the passed function returns true for any item in the
      * enumeration.
@@ -164,12 +168,16 @@ declare module '@ember/array' {
      * than using a callback.
      */
     isAny<K extends keyof T>(key: K, value?: T[K]): boolean;
+    isAny(key: string, value?: unknown): boolean;
     /**
      * This will combine the values of the enumerator into a single value. It
      * is a useful way to collect a summary value from an enumeration. This
      * corresponds to the `reduce()` method defined in JavaScript 1.8.
      */
-    reduce: T[]['reduce'];
+    reduce<V>(
+      callback: (summation: V, current: T, index: number, arr: this) => V,
+      initialValue?: V
+    ): V;
     /**
      * Invokes the named method on every object in the receiver that
      * implements it. This method corresponds to the implementation in
@@ -178,7 +186,7 @@ declare module '@ember/array' {
     invoke<M extends MethodNamesOf<T>>(
       methodName: M,
       ...args: MethodParams<T, M>
-    ): Array<MethodReturns<T, M>>;
+    ): NativeArray<MethodReturns<T, M>>;
     /**
      * Simply converts the enumerable into a genuine array. The order is not
      * guaranteed. Corresponds to the method implemented by Prototype.
@@ -196,7 +204,7 @@ declare module '@ember/array' {
      * Converts the enumerable into an array and sorts by the keys
      * specified in the argument.
      */
-    sortBy(...properties: string[]): NativeArray<T>;
+    sortBy(...properties: string[]): T[];
     /**
      * Returns a new enumerable that excludes the passed value. The default
      * implementation returns an array regardless of the receiver type.
@@ -219,8 +227,8 @@ declare module '@ember/array' {
      * this property, it will return this. If you set this property to a new
      * array, it will replace the current content.
      */
-    get '[]'(): NativeArray<T>;
-    set '[]'(newValue: NativeArray<T>);
+    get '[]'(): this;
+    set '[]'(newValue: T[] | Array<T>);
   }
   // Ember.Array rather than Array because the `array-type` lint rule doesn't realize the global is shadowed
   const Array: Mixin;

package/types/preview/@ember/array/mutable.d.ts

@@ -15,7 +15,7 @@ declare module '@ember/array/mutable' {
     /**
      * __Required.__ You must implement this method to apply this mixin.
      */
-    replace(idx: number, amt: number, objects: T[]): this;
+    replace(idx: number, amt: number, objects: T[]): void;
     /**
      * Remove all elements from the array. This is useful if you
      * want to reuse an existing array without having to recreate it.
@@ -45,12 +45,12 @@ declare module '@ember/array/mutable' {
      * Pop object from array or nil if none are left. Works just like `pop()` but
      * it is KVO-compliant.
      */
-    popObject(): T;
+    popObject(): T | null | undefined;
     /**
      * Shift an object from start of array or nil if none are left. Works just
      * like `shift()` but it is KVO-compliant.
      */
-    shiftObject(): T;
+    shiftObject(): T | null | undefined;
     /**
      * Unshift an object to start of array. Works just like `unshift()` but it is
      * KVO-compliant.
@@ -82,7 +82,7 @@ declare module '@ember/array/mutable' {
     /**
      * __Required.__ You must implement this method to apply this mixin.
      */
-    addObject(object: T): T;
+    addObject(object: T): this;
     /**
      * Adds each object in the passed enumerable to the receiver.
      */

package/types/preview/ember/-private/type-utils.d.ts

@@ -7,15 +7,19 @@ declare module 'ember/-private/type-utils' {
 
   export type AnyMethod<Target> = (this: Target, ...args: any[]) => unknown;
 
-  export type MethodsOf<O> = {
-    [K in keyof O]: O[K] extends AnyFn ? O[K] : never;
+  // The formatting here is designed to help make this type actually be
+  // comprehensible to mortals, including the mortals who came up with it.
+  // prettier-ignore
+  export type MethodsOf<T> = {
+    // This `keyof` check is the thing which gives us *only* these keys, and no
+    // `foo: never` appears in the final type.
+    [K in keyof T as T[K] extends AnyFn ? K : never]:
+      // While this makes sure the resolved type only has `AnyFn` in it, so that
+      // the resulting type is known to be only function types.
+      T[K] extends AnyFn ? T[K] : never;
   };
 
-  // Not just `keyof MethodsOf<O>` because that doesn't correctly exclude all the
-  // `never` fields.
-  export type MethodNamesOf<O> = {
-    [K in keyof O]: O[K] extends AnyFn ? K : never;
-  }[keyof O];
+  export type MethodNamesOf<T> = keyof MethodsOf<T>;
 
   export type MethodParams<T, M extends MethodNamesOf<T>> = Parameters<MethodsOf<T>[M]>;
 
@@ -24,16 +28,15 @@ declare module 'ember/-private/type-utils' {
   // prettier-ignore
   /** Get the return value of a method string name or a function. */
   export type EmberMethodParams<T, M extends EmberMethod<T>> =
-  M extends AnyMethod<T> ? Parameters<M> :
-  M extends keyof T ? T[M] extends AnyMethod<T> ? Parameters<MethodsOf<T>[M]> : never :
-  never;
+    // For a basic method, we can just use the direct accessor.
+    M extends AnyMethod<T> ? Parameters<M> :
+    M extends MethodNamesOf<T> ? Parameters<MethodsOf<T>[M]> : never;
 
   // prettier-ignore
   /** Get the return value of a method string name or a function. */
   export type EmberMethodReturn<T, M extends EmberMethod<T>> =
-  M extends AnyMethod<T> ? ReturnType<M> :
-  M extends keyof T ? T[M] extends AnyMethod<T> ? ReturnType<MethodsOf<T>[M]> : never :
-  never;
+    M extends AnyMethod<T> ? ReturnType<M> :
+    M extends MethodNamesOf<T> ? ReturnType<MethodsOf<T>[M]> : never;
 
   /**
    * A type utility for Ember's common name-of-object-on-target-or-function