ember-source 5.0.0 → 5.1.0-alpha.2

package/types/stable/@ember/routing/router.d.ts

@@ -29,14 +29,11 @@ declare module '@ember/routing/router' {
   /**
     @module @ember/routing/router
     */
-  function defaultDidTransition<R extends Route>(
-    this: EmberRouter<R>,
-    infos: InternalRouteInfo<R>[]
-  ): void;
-  function defaultWillTransition<R extends Route>(
-    this: EmberRouter<R>,
-    oldInfos: InternalRouteInfo<R>[],
-    newInfos: InternalRouteInfo<R>[]
+  function defaultDidTransition(this: EmberRouter, infos: InternalRouteInfo<Route>[]): void;
+  function defaultWillTransition(
+    this: EmberRouter,
+    oldInfos: InternalRouteInfo<Route>[],
+    newInfos: InternalRouteInfo<Route>[]
   ): void;
   export interface QueryParam {
     prop: string;
@@ -54,7 +51,8 @@ declare module '@ember/routing/router' {
     controllerName: string;
   }
   const EmberRouter_base: Readonly<typeof EmberObject> &
-    (new (owner?: Owner | undefined) => EmberObject);
+    (new (owner?: Owner | undefined) => EmberObject) &
+    import('@ember/object/mixin').default;
   /**
       The `EmberRouter` class manages the application state and URLs. Refer to
       the [routing guide](https://guides.emberjs.com/release/routing/) for documentation.
@@ -64,7 +62,7 @@ declare module '@ember/routing/router' {
       @uses Evented
       @public
     */
-  class EmberRouter<R extends Route = Route> extends EmberRouter_base implements Evented {
+  class EmberRouter extends EmberRouter_base implements Evented {
     /**
          Represents the URL of the root of the application, often '/'. This prefix is
           assumed on all routes defined on this router.
@@ -93,7 +91,7 @@ declare module '@ember/routing/router' {
           @public
         */
     location: (keyof LocationRegistry & string) | EmberLocation;
-    _routerMicrolib: Router<R>;
+    _routerMicrolib: Router<Route>;
     _didSetupRouter: boolean;
     _initialTransitionStarted: boolean;
     currentURL: string | null;
@@ -114,7 +112,7 @@ declare module '@ember/routing/router' {
     _handledErrors: Set<unknown>;
     _engineInstances: Record<string, Record<string, EngineInstance>>;
     _engineInfoByRoute: any;
-    _routerService: RouterService<R>;
+    _routerService: RouterService;
     _slowTransitionTimer: Timer | null;
     private namespace;
     on: (name: string, method: ((...args: any[]) => void) | string) => this;
@@ -181,11 +179,11 @@ declare module '@ember/routing/router' {
     startRouting(): void;
     setupRouter(): boolean;
     _setOutlets(): void;
-    handleURL(url: string): import('router_js').InternalTransition<R>;
+    handleURL(url: string): import('router_js').InternalTransition<Route<unknown>>;
     _doURLTransition<M extends 'handleURL' | 'transitionTo'>(
       routerJsMethod: M,
       url: string
-    ): import('router_js').InternalTransition<R>;
+    ): import('router_js').InternalTransition<Route<unknown>>;
     /**
           Transition the application into another route. The route may
           be either a single route or route path:
@@ -200,7 +198,7 @@ declare module '@ember/routing/router' {
             attempted transition
           @public
         */
-    transitionTo(...args: RouteArgs<R>): Transition;
+    transitionTo(...args: RouteArgs): Transition;
     intermediateTransitionTo(name: string, ...args: any[]): void;
     /**
           Similar to `transitionTo`, but instead of adding the destination to the browser's URL history,
@@ -219,8 +217,11 @@ declare module '@ember/routing/router' {
             attempted transition
           @public
         */
-    replaceWith(...args: RouteArgs<R>): Transition;
-    generate(name: string, ...args: ModelFor<R>[] | [...ModelFor<R>[], RouteOptions]): string;
+    replaceWith(...args: RouteArgs): Transition;
+    generate(
+      name: string,
+      ...args: ModelFor<Route>[] | [...ModelFor<Route>[], RouteOptions]
+    ): string;
     /**
           Determines if the supplied route is currently active.
       
@@ -245,7 +246,7 @@ declare module '@ember/routing/router' {
         */
     isActiveIntent(
       routeName: string,
-      models: ModelFor<R>[],
+      models: ModelFor<Route>[],
       queryParams: Record<string, unknown>
     ): boolean;
     send(name: string, ...args: any[]): void;
@@ -280,7 +281,7 @@ declare module '@ember/routing/router' {
           @return {Void}
         */
     _serializeQueryParams(
-      routeInfos: InternalRouteInfo<R>[],
+      routeInfos: InternalRouteInfo<Route>[],
       queryParams: Record<string, unknown>
     ): asserts queryParams is Record<string, string | null | undefined>;
     /**
@@ -302,7 +303,7 @@ declare module '@ember/routing/router' {
           @return {Void}
         */
     _deserializeQueryParams(
-      routeInfos: InternalRouteInfo<R>[],
+      routeInfos: InternalRouteInfo<Route>[],
       queryParams: Record<string, unknown>
     ): void;
     /**
@@ -325,18 +326,18 @@ declare module '@ember/routing/router' {
           @return {Void}
         */
     _pruneDefaultQueryParamValues(
-      routeInfos: InternalRouteInfo<R>[],
+      routeInfos: InternalRouteInfo<Route>[],
       queryParams: Record<string, string | null | undefined>
     ): void;
     _doTransition(
       _targetRouteName: string | undefined,
-      models: ModelFor<R>[],
+      models: ModelFor<Route>[],
       _queryParams: Record<string, unknown>,
       _fromRouterService?: boolean
     ): Transition;
     _processActiveTransitionQueryParams(
       targetRouteName: string,
-      models: ModelFor<R>[],
+      models: ModelFor<Route>[],
       queryParams: Record<string, unknown>,
       _queryParams: {}
     ): void;
@@ -354,7 +355,7 @@ declare module '@ember/routing/router' {
         */
     _prepareQueryParams(
       targetRouteName: string,
-      models: ModelFor<R>[],
+      models: ModelFor<Route>[],
       queryParams: Record<string, unknown>,
       _fromRouterService?: boolean
     ): void;
@@ -367,7 +368,7 @@ declare module '@ember/routing/router' {
           @param {RouteInfo} routeInfo
           @return {Object}
         */
-    _getQPMeta(routeInfo: InternalRouteInfo<R>): QueryParamMeta | undefined;
+    _getQPMeta(routeInfo: InternalRouteInfo<Route>): QueryParamMeta | undefined;
     /**
           Returns a merged query params meta object for a given set of routeInfos.
           Useful for knowing what query params are available for a given route hierarchy.
@@ -377,7 +378,7 @@ declare module '@ember/routing/router' {
           @param {Array<RouteInfo>} routeInfos
           @return {Object}
          */
-    _queryParamsFor(routeInfos: InternalRouteInfo<R>[]): {
+    _queryParamsFor(routeInfos: InternalRouteInfo<Route>[]): {
       qps: QueryParam[];
       map: Record<string, QueryParam>;
     };
@@ -394,7 +395,7 @@ declare module '@ember/routing/router' {
         */
     _fullyScopeQueryParams(
       leafRouteName: string,
-      contexts: ModelFor<R>[],
+      contexts: ModelFor<Route>[],
       queryParams: QueryParams
     ): void;
     /**
@@ -409,13 +410,13 @@ declare module '@ember/routing/router' {
           @return {Void}
         */
     _hydrateUnsuppliedQueryParams(
-      state: TransitionState<R>,
+      state: TransitionState<Route>,
       queryParams: QueryParams,
       _fromRouterService: boolean
     ): void;
     _scheduleLoadingEvent(transition: Transition, originRoute: Route): void;
-    currentState: null | RouterState<R>;
-    targetState: null;
+    currentState: null | RouterState;
+    targetState: null | RouterState;
     _handleSlowTransition(transition: Transition, originRoute: Route): void;
     _cancelSlowTransitionTimer(): void;
     _markErrorAsHandled(error: Error): void;
@@ -487,29 +488,26 @@ declare module '@ember/routing/router' {
   }
   let defaultActionHandlers: {
     willResolveModel<R extends Route<unknown>>(
-      this: EmberRouter<R>,
-      _routeInfos: InternalRouteInfo<R>[],
+      this: EmberRouter,
+      _routeInfos: InternalRouteInfo<Route>[],
       transition: Transition,
       originRoute: R
     ): void;
-    error<R_1 extends Route<unknown>>(
-      this: EmberRouter<R_1>,
-      routeInfos: InternalRouteInfo<R_1>[],
+    error(
+      this: EmberRouter,
+      routeInfos: InternalRouteInfo<Route>[],
       error: Error,
       transition: Transition
     ): void;
-    loading<R_2 extends Route<unknown>>(
-      this: EmberRouter<R_2>,
-      routeInfos: InternalRouteInfo<R_2>[],
+    loading(
+      this: EmberRouter,
+      routeInfos: InternalRouteInfo<Route>[],
       transition: Transition
     ): void;
   };
-  export function triggerEvent<
-    R extends Route,
-    N extends MethodNamesOf<typeof defaultActionHandlers>
-  >(
-    this: EmberRouter<R>,
-    routeInfos: InternalRouteInfo<R>[],
+  export function triggerEvent<N extends MethodNamesOf<typeof defaultActionHandlers>>(
+    this: EmberRouter,
+    routeInfos: InternalRouteInfo<Route>[],
     ignoreFailure: boolean,
     name: N,
     args: OmitFirst<Parameters<typeof defaultActionHandlers[N]>>

package/types/stable/@ember/routing/service-ext.d.ts

@@ -0,0 +1,14 @@
+// This module provides an 'extension' to the `@ember/service` module from the
+// `@ember/routing` package, so that users can rely on `@service('router')` type
+// checking and `Owner.lookup('service:router')` returning `RouterService`. Our
+// type publishing infrastructure will pass it through unchanged, so end users
+// will get this extension.
+
+import '@ember/service';
+import type RouterService from '@ember/routing/router-service';
+
+declare module '@ember/service' {
+  export interface Registry {
+    router: RouterService;
+  }
+}

package/types/stable/@ember/runloop/-private/backburner.d.ts

@@ -0,0 +1,7 @@
+declare module '@ember/runloop/-private/backburner' {
+  import type Backburner from 'backburner.js';
+  export type { Backburner };
+  export type DebugInfo = ReturnType<Backburner['getDebugInfo']>;
+  export { IQueueItem as QueueItem } from 'backburner.js/dist/backburner/interfaces';
+  export { DeferredActionQueues } from 'backburner.js';
+}

package/types/stable/@ember/runloop/index.d.ts

@@ -1,6 +1,5 @@
 declare module '@ember/runloop' {
-  import type { DeferredActionQueues } from 'backburner.js';
-  import Backburner, { Timer } from 'backburner.js';
+  import Backburner, { Timer, type DeferredActionQueues } from 'backburner.js';
   import type { AnyFn } from '@ember/-internals/utility-types';
   export { Timer };
   type PartialParams<P extends any[]> = P extends [infer First, ...infer Rest]
@@ -38,6 +37,10 @@ declare module '@ember/runloop' {
       @private
     */
   export const _queues: string[];
+  /**
+   * @internal
+   * @private
+   */
   export const _backburner: Backburner;
   /**
      @module @ember/runloop
@@ -223,6 +226,11 @@ declare module '@ember/runloop' {
   ): T[U] extends AnyFn
     ? (...args: RemainingParams<A, Parameters<T[U]>>) => ReturnType<T[U]> | void
     : never;
+  export function bind<T, M extends keyof T & PropertyKey>(
+    target: T,
+    methodName: M,
+    ...args: any[]
+  ): (...args: any[]) => unknown;
   /**
       Begins a new RunLoop. Any deferred actions invoked after the begin will
       be buffered until you invoke a matching call to `end()`. This is
@@ -626,11 +634,11 @@ declare module '@ember/runloop' {
       @method cancel
       @static
       @for @ember/runloop
-      @param {Object} timer Timer object to cancel
+      @param {Object} [timer] Timer object to cancel
       @return {Boolean} true if canceled or false/undefined if it wasn't found
       @public
     */
-  export function cancel(timer: Timer): boolean;
+  export function cancel(timer?: Timer): boolean;
   /**
       Delay calling the target method until the debounce period has elapsed
       with no additional debounce calls. If `debounce` is called again before

package/types/stable/@ember/service/index.d.ts

@@ -82,12 +82,25 @@ declare module '@ember/service' {
   /**
       A type registry for Ember `Service`s. Meant to be declaration-merged so string
       lookups resolve to the correct type.
-     */
-  export interface Registry {}
-}
 
-declare module '@ember/owner' {
-  interface DIRegistry {
-    service: Registry;
-  }
+      Blueprints should include such a declaration merge for TypeScript:
+
+      ```ts
+      import Service from '@ember/service';
+
+      export default class ExampleService extends Service {
+        // ...
+      }
+
+      declare module '@ember/service' {
+        export interface Registry {
+          example: ExampleService;
+        }
+      }
+      ```
+
+      Then `@service` can check that the service is registered correctly, and APIs
+      like `owner.lookup('service:example')` can return `ExampleService`.
+     */
+  export interface Registry extends Record<string, object | undefined> {}
 }

package/types/stable/@ember/service/owner-ext.d.ts

@@ -0,0 +1,11 @@
+// This module provides an 'extension' to the `@ember/owner` module from the
+// `@ember/service` module. Our type publishing infrastructure will pass it
+// through unchanged, so end users will get this extension.
+
+import type { Registry } from '@ember/service';
+
+declare module '@ember/owner' {
+  export interface DIRegistry {
+    service: Registry;
+  }
+}

package/types/stable/@ember/template-compilation/index.d.ts

@@ -1,4 +1,19 @@
 declare module '@ember/template-compilation' {
+  import type { TemplateFactory } from '@glimmer/interfaces';
   export { compile as compileTemplate } from 'ember-template-compiler';
-  export let precompileTemplate: (() => never) | undefined;
+  interface CommonOptions {
+    moduleName?: string;
+  }
+  interface LooseModeOptions extends CommonOptions {
+    strictMode?: false;
+  }
+  interface StrictModeOptions extends CommonOptions {
+    strictMode: true;
+    scope: () => Record<string, unknown>;
+  }
+  interface PrecompileTemplate {
+    (templateString: string, options?: LooseModeOptions): TemplateFactory;
+    (templateString: string, options: StrictModeOptions): TemplateFactory;
+  }
+  export let precompileTemplate: PrecompileTemplate;
 }

package/types/stable/@ember/test/index.d.ts

@@ -1,8 +1,8 @@
 declare module '@ember/test' {
-  import { type Test } from 'ember-testing';
-  export let registerAsyncHelper: typeof Test['registerAsyncHelper'] | (() => never);
-  export let registerHelper: typeof Test['registerHelper'] | (() => never);
-  export let registerWaiter: typeof Test['registerWaiter'] | (() => never);
-  export let unregisterHelper: typeof Test['unregisterHelper'] | (() => never);
-  export let unregisterWaiter: typeof Test['unregisterWaiter'] | (() => never);
+  import { type Test as TestNS } from 'ember-testing';
+  export let registerAsyncHelper: typeof TestNS['registerAsyncHelper'];
+  export let registerHelper: typeof TestNS['registerHelper'];
+  export let registerWaiter: typeof TestNS['registerWaiter'];
+  export let unregisterHelper: typeof TestNS['unregisterHelper'];
+  export let unregisterWaiter: typeof TestNS['unregisterWaiter'];
 }

package/types/stable/@ember/utils/lib/compare.d.ts

@@ -49,6 +49,6 @@ declare module '@ember/utils/lib/compare' {
      @return {Number} -1 if v < w, 0 if v = w and 1 if v > w.
      @public
     */
-  export default function compare(v: unknown, w: unknown): Compare;
+  export default function compare<T>(v: T, w: T): Compare;
   export {};
 }