ember-source 7.3.0 → 7.4.0-beta.1

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

@@ -1,5 +1,4 @@
 declare module '@ember/routing/router-service' {
-    import Evented from "@ember/object/evented";
     import Service from "@ember/service";
     import type { ModelFor, Transition } from "router_js";
     import type Route from "@ember/routing/route";
@@ -7,6 +6,7 @@ declare module '@ember/routing/router-service' {
     import type { RouteInfo, RouteInfoWithAttributes } from "@ember/routing/lib/route-info";
     import type { RouteArgs, RouteOptions } from "@ember/routing/lib/utils";
     export const ROUTER: unique symbol;
+    type EventName = "routeWillChange" | "routeDidChange";
     /**
        The Router service is the public API that provides access to the router.
 
@@ -38,12 +38,60 @@ declare module '@ember/routing/router-service' {
        @extends Service
        @class RouterService
      */
-    interface RouterService extends Evented {
-        on(eventName: "routeWillChange" | "routeDidChange", callback: (transition: Transition) => void): this;
-    }
-    const RouterService_base: Readonly<typeof Service> & (new (owner?: import("@ember/owner").default) => Service) & import("@ember/object/mixin").default;
-    class RouterService extends RouterService_base {
+    class RouterService extends Service {
         [ROUTER]?: EmberRouter;
+        /**
+          Subscribes to a named event with given function.
+      
+          @method on
+          @param {String} name The name of the event
+          @param {Object} [target] The "this" binding for the callback
+          @param {Function|String} method A function or the name of a function to be called on `target`
+          @return this
+        */
+        on(name: "routeWillChange" | "routeDidChange", callback: (transition: Transition) => void): this;
+        on<Target>(name: EventName, target: Target, method: string | ((this: Target, ...args: any[]) => void)): this;
+        on(name: EventName, method: ((...args: any[]) => void) | string): this;
+        /**
+          Subscribes a function to a named event and then cancels the subscription
+          after the first time the event is triggered.
+      
+          @method one
+          @param {String} name The name of the event
+          @param {Object} [target] The "this" binding for the callback
+          @param {Function|String} method A function or the name of a function to be called on `target`
+          @return this
+        */
+        one<Target>(name: string, target: Target, method: string | ((this: Target, ...args: any[]) => void)): this;
+        one(name: string, method: string | ((...args: any[]) => void)): this;
+        /**
+          Triggers a named event for the object.
+      
+          @method trigger
+          @param {String} name The name of the event
+          @param {Object...} args Optional arguments to pass on
+          @return {boolean} true if listeners were notified, false otherwise
+        */
+        trigger(name: string, ...args: any[]): boolean;
+        /**
+          Cancels subscription for given name, target, and method.
+      
+          @method off
+          @param {String} name The name of the event
+          @param {Object} target The target of the subscription
+          @param {Function|String} method The function or the name of a function of the subscription
+          @return this
+        */
+        off<Target>(name: string, target: Target, method: string | ((this: Target, ...args: any[]) => void)): this;
+        off(name: string, method: string | ((...args: any[]) => void)): this;
+        /**
+          Checks to see if object has any subscriptions for named event.
+      
+          @method has
+          @param {String} name The name of the event
+          @return {Boolean} does the object have a subscription for event
+         */
+        has(name: string): boolean;
         get _router(): EmberRouter;
         willDestroy(): void;
         /**

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

@@ -8,7 +8,6 @@ declare module '@ember/routing/router' {
     import type { default as EmberLocation, Registry as LocationRegistry } from "@ember/routing/location";
     import type RouterService from "@ember/routing/router-service";
     import EmberObject from "@ember/object";
-    import Evented from "@ember/object/evented";
     import { type QueryParamMeta, type default as Route } from "@ember/routing/route";
     import type { InternalRouteInfo, ModelFor, RouteInfo, RouteInfoWithAttributes, Transition, TransitionState } from "router_js";
     import Router from "router_js";
@@ -40,7 +39,6 @@ declare module '@ember/routing/router' {
         serializedDefaultValue: string | null | undefined;
         controllerName: string;
     }
-    const EmberRouter_base: Readonly<typeof EmberObject> & (new (owner?: Owner) => 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.
@@ -50,7 +48,7 @@ declare module '@ember/routing/router' {
       @uses Evented
       @public
     */
-    class EmberRouter extends EmberRouter_base implements Evented {
+    class EmberRouter extends EmberObject {
         /**
          Represents the URL of the root of the application, often '/'. This prefix is
           assumed on all routes defined on this router.
@@ -100,11 +98,14 @@ declare module '@ember/routing/router' {
         _routerService: RouterService;
         _slowTransitionTimer: Timer | null;
         private namespace;
-        on: (name: string, method: ((...args: any[]) => void) | string) => this;
-        one: (name: string, method: string | ((...args: any[]) => void)) => this;
-        trigger: (name: string, ...args: any[]) => unknown;
-        off: (name: string, method: string | ((...args: any[]) => void)) => this;
-        has: (name: string) => boolean;
+        on<Target>(name: string, target: Target, method: string | ((this: Target, ...args: any[]) => void)): this;
+        on(name: string, method: ((...args: any[]) => void) | string): this;
+        one<Target>(name: string, target: Target, method: string | ((this: Target, ...args: any[]) => void)): this;
+        one(name: string, method: string | ((...args: any[]) => void)): this;
+        trigger(name: string, ...args: any[]): void;
+        off<Target>(name: string, target: Target, method: string | ((this: Target, ...args: any[]) => void)): this;
+        off(name: string, method: string | ((...args: any[]) => void)): this;
+        has(name: string): boolean;
         private static dslCallbacks?;
         /**
           The `Router.map` function allows you to define mappings from URLs to routes

package/types/stable/@glimmer/destroyable/index.d.ts

@@ -1,5 +1,6 @@
 declare module '@glimmer/destroyable' {
     import type { Destroyable, Destructor } from "@glimmer/interfaces";
+    export { DESTROYABLE_META_KEY } from "@glimmer/util/lib/destroyable-key";
     export function associateDestroyableChild<T extends Destroyable>(parent: Destroyable, child: T): T;
     export function registerDestructor<T extends Destroyable>(destroyable: T, destructor: Destructor<T>, eager?: boolean): Destructor<T>;
     export function unregisterDestructor<T extends Destroyable>(destroyable: T, destructor: Destructor<T>, eager?: boolean): void;

package/types/stable/@glimmer/runtime/lib/vm/element-builder.d.ts

@@ -1,5 +1,6 @@
 declare module '@glimmer/runtime/lib/vm/element-builder' {
     import type { AppendingBlock, AttrNamespace, Bounds, Cursor, ElementOperations, Environment, GlimmerTreeChanges, GlimmerTreeConstruction, Maybe, ModifierInstance, Nullable, ResettableBlock, SimpleComment, SimpleDocumentFragment, SimpleElement, SimpleNode, SimpleText, TreeBuilder } from "@glimmer/interfaces";
+    import { DESTROYABLE_META_KEY } from "@glimmer/util/lib/destroyable-key";
     import { StackImpl as Stack } from "@glimmer/util/lib/collections";
     import type { DynamicAttribute } from "@glimmer/runtime/lib/vm/attributes/dynamic";
     import { CursorImpl } from "@glimmer/runtime/lib/bounds";
@@ -92,6 +93,7 @@ declare module '@glimmer/runtime/lib/vm/element-builder' {
             first: () => Nullable<SimpleNode>;
             last: () => Nullable<SimpleNode>;
         };
+        [DESTROYABLE_META_KEY]: object | undefined;
         protected first: Nullable<FirstNode>;
         protected last: Nullable<LastNode>;
         protected nesting: number;

package/types/stable/@glimmer/runtime/lib/vm/render-result.d.ts

@@ -1,10 +1,12 @@
 declare module '@glimmer/runtime/lib/vm/render-result' {
     import type { AppendingBlock, Environment, RenderResult, SimpleElement, SimpleNode, UpdatingOpcode } from "@glimmer/interfaces";
+    import { DESTROYABLE_META_KEY } from "@glimmer/util/lib/destroyable-key";
     export default class RenderResultImpl implements RenderResult {
         env: Environment;
         private updating;
         private bounds;
         readonly drop: object;
+        [DESTROYABLE_META_KEY]: object | undefined;
         constructor(env: Environment, updating: UpdatingOpcode[], bounds: AppendingBlock, drop: object);
         rerender({ alwaysRevalidate }?: {
             alwaysRevalidate?: false;

package/types/stable/@glimmer/runtime/lib/vm/update.d.ts

@@ -2,6 +2,7 @@ declare module '@glimmer/runtime/lib/vm/update' {
     import type { AppendingBlock, Bounds, DynamicScope, Environment, EvaluationContext, ExceptionHandler, GlimmerTreeChanges, Nullable, ResettableBlock, Scope, UpdatingOpcode, UpdatingVM as IUpdatingVM } from "@glimmer/interfaces";
     import type { OpaqueIterator } from "@glimmer/reference/lib/iterable";
     import type { Reference } from "@glimmer/reference/lib/reference";
+    import { DESTROYABLE_META_KEY } from "@glimmer/util/lib/destroyable-key";
     import type { Closure } from "@glimmer/runtime/lib/vm/append";
     import type { AppendingBlockList } from "@glimmer/runtime/lib/vm/element-builder";
     export class UpdatingVM implements IUpdatingVM {
@@ -28,6 +29,7 @@ declare module '@glimmer/runtime/lib/vm/update' {
     export abstract class BlockOpcode implements UpdatingOpcode, Bounds {
         protected state: Closure;
         protected context: EvaluationContext;
+        [DESTROYABLE_META_KEY]: object | undefined;
         children: UpdatingOpcode[];
         protected readonly bounds: AppendingBlock;
         constructor(state: Closure, context: EvaluationContext, bounds: AppendingBlock, children: UpdatingOpcode[]);

package/types/stable/@glimmer/syntax/lib/keywords.d.ts

@@ -8,7 +8,7 @@ declare module '@glimmer/syntax/lib/keywords' {
      * language, and where their valid usages are.
      */
     export const KEYWORDS_TYPES: {
-        action: ("Modifier" | "Call")[];
+        action: ("Call" | "Modifier")[];
         component: ("Block" | "Call" | "Append")[];
         debugger: "Append"[];
         "each-in": "Block"[];
@@ -20,7 +20,7 @@ declare module '@glimmer/syntax/lib/keywords' {
         "in-element": "Block"[];
         let: "Block"[];
         log: ("Call" | "Append")[];
-        modifier: ("Modifier" | "Call")[];
+        modifier: ("Call" | "Modifier")[];
         mount: "Append"[];
         mut: ("Call" | "Append")[];
         outlet: "Append"[];

package/types/stable/@glimmer/util/lib/destroyable-key.d.ts

@@ -0,0 +1,15 @@
+declare module '@glimmer/util/lib/destroyable-key' {
+    /**
+     * Classes Glimmer constructs itself declare this slot, so that
+     * `@glimmer/destroyable` can hold their meta directly rather than in its
+     * `WeakMap`. It lives here so packages below `@glimmer/destroyable` can declare
+     * the slot without depending on it.
+     *
+     * Never write this onto an object Glimmer did not construct. Destroyables are
+     * public through `@ember/destroyable` and can be any object a user hands in.
+     */
+    export const DESTROYABLE_META_KEY: unique symbol;
+    export interface HasDestroyableMetaSlot {
+        [DESTROYABLE_META_KEY]?: object | undefined;
+    }
+}

package/types/stable/index.d.ts

@@ -115,6 +115,7 @@
 /// <reference path="./@glimmer/util/lib/is-serialization-first-node.d.ts" />
 /// <reference path="./@glimmer/util/lib/intern.d.ts" />
 /// <reference path="./@glimmer/util/lib/dom.d.ts" />
+/// <reference path="./@glimmer/util/lib/destroyable-key.d.ts" />
 /// <reference path="./@glimmer/util/lib/debug-steps.d.ts" />
 /// <reference path="./@glimmer/util/lib/collections.d.ts" />
 /// <reference path="./@glimmer/util/lib/array-utils.d.ts" />
@@ -496,6 +497,7 @@
 /// <reference path="./@ember/-internals/views/index.d.ts" />
 /// <reference path="./@ember/-internals/views/lib/views/states.d.ts" />
 /// <reference path="./@ember/-internals/views/lib/views/core_view.d.ts" />
+/// <reference path="./@ember/-internals/views/lib/views/core-view-utils.d.ts" />
 /// <reference path="./@ember/-internals/views/lib/system/utils.d.ts" />
 /// <reference path="./@ember/-internals/views/lib/system/event_dispatcher.d.ts" />
 /// <reference path="./@ember/-internals/views/lib/mixins/action_support.d.ts" />
@@ -510,6 +512,7 @@
 /// <reference path="./@ember/-internals/utils/lib/lookup-descriptor.d.ts" />
 /// <reference path="./@ember/-internals/utils/lib/is_proxy.d.ts" />
 /// <reference path="./@ember/-internals/utils/lib/invoke.d.ts" />
+/// <reference path="./@ember/-internals/utils/lib/internal-mixin-create.d.ts" />
 /// <reference path="./@ember/-internals/utils/lib/intern.d.ts" />
 /// <reference path="./@ember/-internals/utils/lib/guid.d.ts" />
 /// <reference path="./@ember/-internals/utils/lib/get-debug-name.d.ts" />
@@ -544,6 +547,7 @@
 /// <reference path="./@ember/-internals/metal/lib/get_properties.d.ts" />
 /// <reference path="./@ember/-internals/metal/lib/expand_properties.d.ts" />
 /// <reference path="./@ember/-internals/metal/lib/events.d.ts" />
+/// <reference path="./@ember/-internals/metal/lib/evented-methods.d.ts" />
 /// <reference path="./@ember/-internals/metal/lib/each_proxy_events.d.ts" />
 /// <reference path="./@ember/-internals/metal/lib/deprecate_property.d.ts" />
 /// <reference path="./@ember/-internals/metal/lib/decorator.d.ts" />