Merge pull request #20489 from emberjs/types/resolver-fix

[BUGFIX stable] Fix types for Resolver contract

packages/@ember/-internals/container/lib/registry.ts

@@ -1,4 +1,5 @@
 import type {
+  Factory,
   FactoryClass,
   FullName,
   InternalFactory,
@@ -18,9 +19,11 @@ export interface Injection {
   specifier: FullName;
 }
 
-export interface ResolverClass {
-  create(...args: unknown[]): Resolver;
-}
+export interface ResolverClass
+  extends Factory<Resolver>,
+    Partial<{
+      new (...args: any): Resolver;
+    }> {}
 
 export interface RegistryOptions {
   fallback?: Registry;

packages/@ember/array/proxy.ts

@@ -125,7 +125,7 @@ interface ArrayProxy<T> extends MutableArray<T> {
     @type EmberArray
     @public
   */
-  content: EmberArray<T> | NativeArray<T> | null;
+  content: T[] | EmberArray<T> | NativeArray<T> | null;
   /**
     The array that the proxy pretends to be. In the default `ArrayProxy`
     implementation, this and `content` are the same. Subclasses of `ArrayProxy`
@@ -214,7 +214,7 @@ class ArrayProxy<T> extends EmberObject implements PropertyDidChange {
     this._removeArrangedContentArrayObserver();
   }
 
-  declare content: EmberArray<T> | NativeArray<T> | null;
+  declare content: T[] | EmberArray<T> | NativeArray<T> | null;
 
   declare arrangedContent: EmberArray<T> | null;
 

packages/@ember/array/type-tests/proxy.test.ts

@@ -17,5 +17,5 @@ let proxy = ArrayProxy.create({ content }) as ArrayProxy<Foo>;
 expectTypeOf(proxy).toMatchTypeOf<EmberArray<Foo>>();
 expectTypeOf(proxy).toMatchTypeOf<MutableArray<Foo>>();
 
-expectTypeOf(proxy.content).toEqualTypeOf<EmberArray<Foo> | NativeArray<Foo> | null>();
+expectTypeOf(proxy.content).toEqualTypeOf<Foo[] | EmberArray<Foo> | NativeArray<Foo> | null>();
 expectTypeOf(proxy.arrangedContent).toEqualTypeOf<EmberArray<Foo> | null>();

packages/@ember/object/core.ts

@@ -763,14 +763,21 @@ class CoreObject {
     @param [arguments]*
     @public
   */
+  static create<C extends typeof CoreObject>(this: C): InstanceType<C>;
   static create<
     C extends typeof CoreObject,
     I extends InstanceType<C>,
     K extends keyof I,
-    Args extends Array<Partial<Record<K, I[K]>>>
+    Args extends Array<Partial<{ [Key in K]: I[Key] }>>
+  >(this: C, ...args: Args): InstanceType<C> & MergeArray<Args>;
+  static create<
+    C extends typeof CoreObject,
+    I extends InstanceType<C>,
+    K extends keyof I,
+    Args extends Array<Partial<{ [Key in K]: I[Key] }>>
   >(this: C, ...args: Args): InstanceType<C> & MergeArray<Args> {
     let props = args[0];
-    let instance;
+    let instance: InstanceType<C>;
 
     if (props !== undefined) {
       instance = new this(getOwner(props)) as InstanceType<C>;

packages/internal-test-helpers/lib/build-owner.ts

@@ -4,9 +4,8 @@ import Engine from '@ember/engine';
 import { registerDestructor } from '@ember/destroyable';
 import type Resolver from './test-resolver';
 import type { EngineInstanceOptions } from '@ember/engine/instance';
-import type { ResolverClass } from '@ember/-internals/container';
 
-class ResolverWrapper implements ResolverClass {
+class ResolverWrapper {
   resolver: Resolver;
 
   constructor(resolver: Resolver) {

type-tests/@ember/object-test/create-negative.ts

@@ -1,25 +1,8 @@
-import { expectTypeOf } from 'expect-type';
 import { Person } from './create';
 
-// Let's see some *real* type-unsafety! These demonstrate that we just
-// absolutely lie about the runtime behavior for `.create()`. 😬 The result of
-// calling these with `firstName: 99` is to *change the type* of the resulting
-// object from `Person` to `Person` with `firstName: number`. While we might
-// *like* to prevent that call and make sure that `firstName` matches the type
-// we cannot reasonably do so.
-
-expectTypeOf(Person.create({ firstName: 99 })).toEqualTypeOf<
-  Person & {
-    firstName: number;
-  }
->();
-expectTypeOf(Person.create({}, { firstName: 99 })).toEqualTypeOf<
-  Person & {
-    firstName: number;
-  }
->();
-expectTypeOf(Person.create({}, {}, { firstName: 99 })).toEqualTypeOf<
-  Person & {
-    firstName: number;
-  }
->();
+// @ts-expect-error
+Person.create({ firstName: 99 });
+// @ts-expect-error
+Person.create({}, { firstName: 99 });
+// @ts-expect-error
+Person.create({}, {}, { firstName: 99 });

type-tests/ember/create-negative.ts

@@ -1,25 +1,8 @@
-import { expectTypeOf } from 'expect-type';
 import { Person } from './create';
 
-// Let's see some *real* type-unsafety! These demonstrate that we just
-// absolutely lie about the runtime behavior for `.create()`. 😬 The result of
-// calling these with `firstName: 99` is to *change the type* of the resulting
-// object from `Person` to `Person` with `firstName: number`. While we might
-// *like* to prevent that call and make sure that `firstName` matches the type
-// we cannot reasonably do so.
-
-expectTypeOf(Person.create({ firstName: 99 })).toEqualTypeOf<
-  Person & {
-    firstName: number;
-  }
->();
-expectTypeOf(Person.create({}, { firstName: 99 })).toEqualTypeOf<
-  Person & {
-    firstName: number;
-  }
->();
-expectTypeOf(Person.create({}, {}, { firstName: 99 })).toEqualTypeOf<
-  Person & {
-    firstName: number;
-  }
->();
+// @ts-expect-error
+Person.create({ firstName: 99 });
+// @ts-expect-error
+Person.create({}, { firstName: 99 });
+// @ts-expect-error
+Person.create({}, {}, { firstName: 99 });

type-tests/smoke/basic-app-alike/app.ts

@@ -0,0 +1,12 @@
+import Application from '@ember/application';
+import Resolver from './ember-resolver-alike';
+import loadInitializers from './ember-load-initializers-alike';
+import config from './environment-alike';
+
+export default class App extends Application {
+  modulePrefix = config.modulePrefix;
+  podModulePrefix = config.podModulePrefix;
+  Resolver = Resolver;
+}
+
+loadInitializers(App, config.modulePrefix);

type-tests/smoke/basic-app-alike/ember-load-initializers-alike.d.ts

@@ -0,0 +1,10 @@
+declare global {
+  var requirejs: {
+    _eak_seen: Object;
+  };
+}
+import Engine from '@ember/engine';
+/**
+ * Configure your application as it boots
+ */
+export default function loadInitializers(app: typeof Engine, prefix: string): void;

type-tests/smoke/basic-app-alike/ember-resolver-alike.d.ts

@@ -0,0 +1,4 @@
+import { Resolver as ResolverContract } from '@ember/owner';
+import EmberObject from '@ember/object';
+export default class Resolver extends EmberObject {}
+export default interface Resolver extends Required<ResolverContract> {}

type-tests/smoke/basic-app-alike/environment-alike.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type declarations for
+ *    import config from 'my-app/config/environment'
+ */
+declare const config: {
+  environment: string;
+  modulePrefix: string;
+  podModulePrefix: string;
+  locationType: 'history' | 'hash' | 'none' | 'auto';
+  rootURL: string;
+  APP: Record<string, unknown>;
+};
+
+export default config;