Improve types for some array internals

Author: wagenet

packages/@ember/-internals/metal/lib/array.ts

@@ -4,7 +4,9 @@ import { addListener, removeListener } from './events';
 
 const EMPTY_ARRAY = Object.freeze([]);
 
-interface ObservedObject<T> extends EmberArray<T> {
+type ObservedArray<T> = (T[] | EmberArray<T>) & ObservedObject;
+
+interface ObservedObject {
   _revalidate?: () => void;
 }
 
@@ -17,13 +19,14 @@ export function objectAt<T>(array: T[] | EmberArray<T>, index: number): T | unde
 }
 
 export function replace<T>(
-  array: NativeArray<T> | MutableArray<T>,
+  array: T[] | MutableArray<T>,
   start: number,
   deleteCount: number,
-  items: T[] = EMPTY_ARRAY as []
+  items: T[] | EmberArray<T> = EMPTY_ARRAY as []
 ): void {
   if (Array.isArray(array)) {
-    replaceInNativeArray(array, start, deleteCount, items);
+    let itemsArray = Array.isArray(items) ? items : items.toArray();
+    replaceInNativeArray(array, start, deleteCount, itemsArray);
   } else {
     array.replace(start, deleteCount, items);
   }
@@ -61,18 +64,18 @@ interface ArrayObserverOptions {
 }
 
 type Operation<T> = (
-  obj: ObservedObject<T>,
+  obj: ObservedArray<T>,
   eventName: string,
   target: object | Function | null,
   callbackName: string
 ) => void;
 
 function arrayObserversHelper<T>(
-  obj: ObservedObject<T>,
+  obj: ObservedArray<T>,
   target: object | Function | null,
   opts: ArrayObserverOptions,
   operation: Operation<T>
-): ObservedObject<T> {
+): ObservedArray<T> {
   let { willChange, didChange } = opts;
 
   operation(obj, '@array:before', target, willChange);
@@ -91,14 +94,14 @@ export function addArrayObserver<T>(
   array: EmberArray<T>,
   target: object | Function | null,
   opts: ArrayObserverOptions
-): ObservedObject<T> {
+): ObservedArray<T> {
   return arrayObserversHelper(array, target, opts, addListener);
 }
 
 export function removeArrayObserver<T>(
-  array: EmberArray<T>,
+  array: T[] | EmberArray<T>,
   target: object | Function | null,
   opts: ArrayObserverOptions
-): ObservedObject<T> {
+): ObservedArray<T> {
   return arrayObserversHelper(array, target, opts, removeListener);
 }

packages/@ember/-internals/runtime/lib/mixins/array.d.ts

@@ -71,7 +71,7 @@ declare const EmberArray: Mixin;
 export default EmberArray;
 
 interface MutableArray<T> extends EmberArray<T>, MutableEnumerable {
-  replace(idx: number, amt: number, objects?: T[]): void;
+  replace(idx: number, amt: number, objects?: T[] | EmberArray<T>): void;
   clear(): this;
   insertAt(idx: number, object: T): this;
   removeAt(start: number, len: number): this;
@@ -107,4 +107,4 @@ export function uniqBy<T>(
   array: T[] | EmberArray<T>,
   keyOrFunc: string | ((item: T) => unknown)
 ): T[] | EmberArray<T>;
-export function isArray(obj: unknown): boolean;
+export function isArray(obj: unknown): obj is ArrayLike<unknown> | EmberArray<unknown>;

packages/@ember/-internals/runtime/lib/system/array_proxy.ts

@@ -16,7 +16,7 @@ import {
 } from '@ember/-internals/metal';
 import { isObject } from '@ember/-internals/utils';
 import EmberObject from './object';
-import EmberArray, { isArray, MutableArray } from '../mixins/array';
+import EmberArray, { MutableArray } from '../mixins/array';
 import { assert } from '@ember/debug';
 import { setCustomTagFor } from '@glimmer/manager';
 import {
@@ -30,7 +30,7 @@ import {
 } from '@glimmer/validator';
 import { PropertyDidChange } from '@ember/-internals/metal/lib/property_events';
 
-function isMutable<T>(obj: EmberArray<T>): obj is MutableArray<T> {
+function isMutable<T>(obj: T[] | EmberArray<T>): obj is T[] | MutableArray<T> {
   return Array.isArray(obj) || typeof (obj as MutableArray<T>).replace === 'function';
 }
 
@@ -116,8 +116,8 @@ function customTagForArrayProxy(proxy: object, key: string) {
   @public
 */
 // eslint-disable-next-line @typescript-eslint/no-empty-interface, @typescript-eslint/no-unused-vars
-interface ArrayProxy<T, C extends EmberArray<T> = EmberArray<T>> extends MutableArray<T> {}
-class ArrayProxy<T, C extends EmberArray<T> = EmberArray<T>>
+interface ArrayProxy<T, C extends EmberArray<T> | T[] = T[]> extends MutableArray<T> {}
+class ArrayProxy<T, C extends EmberArray<T> | T[] = T[]>
   extends EmberObject
   implements PropertyDidChange
 {
@@ -200,7 +200,7 @@ class ArrayProxy<T, C extends EmberArray<T> = EmberArray<T>>
 
   // See additional docs for `replace` from `MutableArray`:
   // https://api.emberjs.com/ember/release/classes/MutableArray/methods/replace?anchor=replace
-  replace(idx: number, amt: number, objects?: T[]) {
+  replace(idx: number, amt: number, objects?: T[] | EmberArray<T>) {
     assert(
       'Mutating an arranged ArrayProxy is not allowed',
       get(this, 'arrangedContent') === get(this, 'content')
@@ -222,11 +222,11 @@ class ArrayProxy<T, C extends EmberArray<T> = EmberArray<T>>
     @return {void}
     @public
   */
-  replaceContent(idx: number, amt: number, objects?: T[]) {
+  replaceContent(idx: number, amt: number, objects?: T[] | EmberArray<T>) {
     let content = get(this, 'content');
     assert('[BUG] Called objectAtContent without content', content);
     assert('Mutating a non-mutable array is not allowed', isMutable(content));
-    content.replace(idx, amt, objects);
+    replace<T>(content, idx, amt, objects);
   }
 
   // Overriding objectAt is not supported.
@@ -312,8 +312,14 @@ class ArrayProxy<T, C extends EmberArray<T> = EmberArray<T>>
       // @ts-expect-error This check is still good for ensuring correctness
       assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
       assert(
-        `ArrayProxy expects an Array or ArrayProxy, but you passed ${typeof arrangedContent}`,
-        isArray(arrangedContent) || (arrangedContent as any).isDestroyed
+        `ArrayProxy expects a native Array, EmberArray, or ArrayProxy, but you passed ${typeof arrangedContent}`,
+        (function (arr: unknown): arr is EmberArray<unknown> {
+          return Array.isArray(arr) || EmberArray.detect(arr);
+        })(arrangedContent)
+      );
+      assert(
+        'ArrayProxy expected its contents to not be destroyed',
+        !(arrangedContent as any).isDestroyed
       );
 
       addArrayObserver(arrangedContent, this, ARRAY_OBSERVER_MAPPING);