ember-source 5.0.0 → 5.1.0-alpha.2

package/types/stable/@ember/-internals/glimmer/lib/component.d.ts

@@ -20,6 +20,136 @@ declare module '@ember/-internals/glimmer/lib/component' {
   /**
     @module @ember/component
     */
+  interface ComponentMethods {
+    /**
+         Called when the attributes passed into the component have been updated.
+          Called both during the initial render of a container and during a rerender.
+          Can be used in place of an observer; code placed here will be executed
+          every time any attribute updates.
+          @method didReceiveAttrs
+          @public
+          @since 1.13.0
+          */
+    didReceiveAttrs(): void;
+    /**
+         Called when the attributes passed into the component have been updated.
+          Called both during the initial render of a container and during a rerender.
+          Can be used in place of an observer; code placed here will be executed
+          every time any attribute updates.
+          @event didReceiveAttrs
+          @public
+          @since 1.13.0
+          */
+    /**
+         Called after a component has been rendered, both on initial render and
+          in subsequent rerenders.
+          @method didRender
+          @public
+          @since 1.13.0
+          */
+    didRender(): void;
+    /**
+         Called after a component has been rendered, both on initial render and
+          in subsequent rerenders.
+          @event didRender
+          @public
+          @since 1.13.0
+          */
+    /**
+         Called before a component has been rendered, both on initial render and
+          in subsequent rerenders.
+          @method willRender
+          @public
+          @since 1.13.0
+          */
+    willRender(): void;
+    /**
+         Called before a component has been rendered, both on initial render and
+          in subsequent rerenders.
+          @event willRender
+          @public
+          @since 1.13.0
+          */
+    /**
+         Called when the attributes passed into the component have been changed.
+          Called only during a rerender, not during an initial render.
+          @method didUpdateAttrs
+          @public
+          @since 1.13.0
+          */
+    didUpdateAttrs(): void;
+    /**
+         Called when the attributes passed into the component have been changed.
+          Called only during a rerender, not during an initial render.
+          @event didUpdateAttrs
+          @public
+          @since 1.13.0
+          */
+    /**
+         Called when the component is about to update and rerender itself.
+          Called only during a rerender, not during an initial render.
+          @method willUpdate
+          @public
+          @since 1.13.0
+          */
+    willUpdate(): void;
+    /**
+         Called when the component is about to update and rerender itself.
+          Called only during a rerender, not during an initial render.
+          @event willUpdate
+          @public
+          @since 1.13.0
+          */
+    /**
+         Called when the component has updated and rerendered itself.
+          Called only during a rerender, not during an initial render.
+          @method didUpdate
+          @public
+          @since 1.13.0
+          */
+    didUpdate(): void;
+    /**
+         Called when the component has updated and rerendered itself.
+          Called only during a rerender, not during an initial render.
+          @event didUpdate
+          @public
+          @since 1.13.0
+          */
+    /**
+          The HTML `id` of the component's element in the DOM. You can provide this
+          value yourself but it must be unique (just as in HTML):
+      
+          ```handlebars
+          {{my-component elementId="a-really-cool-id"}}
+          ```
+      
+          ```handlebars
+          <MyComponent @elementId="a-really-cool-id" />
+          ```
+          If not manually set a default value will be provided by the framework.
+          Once rendered an element's `elementId` is considered immutable and you
+          should never change it. If you need to compute a dynamic value for the
+          `elementId`, you should do this when the component or element is being
+          instantiated:
+      
+          ```javascript
+          export default Component.extend({
+            init() {
+              this._super(...arguments);
+      
+              var index = this.get('index');
+              this.set('elementId', `component-id${index}`);
+            }
+          });
+          ```
+      
+          @property elementId
+          @type String
+          @public
+        */
+    layoutName?: string;
+  }
+  const SIGNATURE: unique symbol;
   /**
       A component is a reusable UI element that consists of a `.hbs` template and an
       optional JavaScript class that defines its behavior. For example, someone
@@ -634,136 +764,7 @@ declare module '@ember/-internals/glimmer/lib/component' {
       @uses Ember.ViewStateSupport
       @public
     */
-  interface ComponentMethods {
-    /**
-         Called when the attributes passed into the component have been updated.
-          Called both during the initial render of a container and during a rerender.
-          Can be used in place of an observer; code placed here will be executed
-          every time any attribute updates.
-          @method didReceiveAttrs
-          @public
-          @since 1.13.0
-          */
-    didReceiveAttrs(): void;
-    /**
-         Called when the attributes passed into the component have been updated.
-          Called both during the initial render of a container and during a rerender.
-          Can be used in place of an observer; code placed here will be executed
-          every time any attribute updates.
-          @event didReceiveAttrs
-          @public
-          @since 1.13.0
-          */
-    /**
-         Called after a component has been rendered, both on initial render and
-          in subsequent rerenders.
-          @method didRender
-          @public
-          @since 1.13.0
-          */
-    didRender(): void;
-    /**
-         Called after a component has been rendered, both on initial render and
-          in subsequent rerenders.
-          @event didRender
-          @public
-          @since 1.13.0
-          */
-    /**
-         Called before a component has been rendered, both on initial render and
-          in subsequent rerenders.
-          @method willRender
-          @public
-          @since 1.13.0
-          */
-    willRender(): void;
-    /**
-         Called before a component has been rendered, both on initial render and
-          in subsequent rerenders.
-          @event willRender
-          @public
-          @since 1.13.0
-          */
-    /**
-         Called when the attributes passed into the component have been changed.
-          Called only during a rerender, not during an initial render.
-          @method didUpdateAttrs
-          @public
-          @since 1.13.0
-          */
-    didUpdateAttrs(): void;
-    /**
-         Called when the attributes passed into the component have been changed.
-          Called only during a rerender, not during an initial render.
-          @event didUpdateAttrs
-          @public
-          @since 1.13.0
-          */
-    /**
-         Called when the component is about to update and rerender itself.
-          Called only during a rerender, not during an initial render.
-          @method willUpdate
-          @public
-          @since 1.13.0
-          */
-    willUpdate(): void;
-    /**
-         Called when the component is about to update and rerender itself.
-          Called only during a rerender, not during an initial render.
-          @event willUpdate
-          @public
-          @since 1.13.0
-          */
-    /**
-         Called when the component has updated and rerendered itself.
-          Called only during a rerender, not during an initial render.
-          @method didUpdate
-          @public
-          @since 1.13.0
-          */
-    didUpdate(): void;
-    /**
-         Called when the component has updated and rerendered itself.
-          Called only during a rerender, not during an initial render.
-          @event didUpdate
-          @public
-          @since 1.13.0
-          */
-    /**
-          The HTML `id` of the component's element in the DOM. You can provide this
-          value yourself but it must be unique (just as in HTML):
-      
-          ```handlebars
-          {{my-component elementId="a-really-cool-id"}}
-          ```
-      
-          ```handlebars
-          <MyComponent @elementId="a-really-cool-id" />
-          ```
-          If not manually set a default value will be provided by the framework.
-          Once rendered an element's `elementId` is considered immutable and you
-          should never change it. If you need to compute a dynamic value for the
-          `elementId`, you should do this when the component or element is being
-          instantiated:
-      
-          ```javascript
-          export default Component.extend({
-            init() {
-              this._super(...arguments);
-      
-              var index = this.get('index');
-              this.set('elementId', `component-id${index}`);
-            }
-          });
-          ```
-      
-          @property elementId
-          @type String
-          @public
-        */
-    layoutName?: string;
-  }
-  interface Component
+  interface Component<S = unknown>
     extends CoreView,
       ChildViewsSupport,
       ViewStateSupport,
@@ -773,9 +774,12 @@ declare module '@ember/-internals/glimmer/lib/component' {
       ViewMixin,
       ComponentMethods {}
   const Component_base: Readonly<typeof CoreView> &
-    (new (owner?: import('@ember/-internals/owner').default | undefined) => CoreView);
-  class Component extends Component_base implements PropertyDidChange {
+    (new (owner?: import('@ember/-internals/owner').default | undefined) => CoreView) &
+    import('@ember/object/mixin').default &
+    ComponentMethods;
+  class Component<S = unknown> extends Component_base implements PropertyDidChange {
     isComponent: boolean;
+    private [SIGNATURE];
     _superRerender: ViewMixin['rerender'];
     [IS_DISPATCHING_ATTRS]: boolean;
     [DIRTY_TAG]: DirtyableTag;
@@ -824,6 +828,126 @@ declare module '@ember/-internals/glimmer/lib/component' {
           */
     readDOMAttr(name: string): any;
     attributeBindings?: string[];
+    /**
+         Enables components to take a list of parameters as arguments.
+          For example, a component that takes two parameters with the names
+          `name` and `age`:
+      
+          ```app/components/my-component.js
+          import Component from '@ember/component';
+      
+          let MyComponent = Component.extend();
+      
+          MyComponent.reopenClass({
+            positionalParams: ['name', 'age']
+          });
+      
+          export default MyComponent;
+          ```
+      
+          It can then be invoked like this:
+      
+          ```hbs
+          {{my-component "John" 38}}
+          ```
+      
+          The parameters can be referred to just like named parameters:
+      
+          ```hbs
+          Name: {{name}}, Age: {{age}}.
+          ```
+      
+          Using a string instead of an array allows for an arbitrary number of
+          parameters:
+      
+          ```app/components/my-component.js
+          import Component from '@ember/component';
+      
+          let MyComponent = Component.extend();
+      
+          MyComponent.reopenClass({
+            positionalParams: 'names'
+          });
+      
+          export default MyComponent;
+          ```
+      
+          It can then be invoked like this:
+      
+          ```hbs
+          {{my-component "John" "Michael" "Scott"}}
+          ```
+          The parameters can then be referred to by enumerating over the list:
+      
+          ```hbs
+          {{#each names as |name|}}{{name}}{{/each}}
+          ```
+      
+          @static
+          @public
+          @property positionalParams
+          @since 1.13.0
+          */ /**
+       Enables components to take a list of parameters as arguments.
+        For example, a component that takes two parameters with the names
+        `name` and `age`:
+
+        ```app/components/my-component.js
+        import Component from '@ember/component';
+
+        let MyComponent = Component.extend();
+
+        MyComponent.reopenClass({
+          positionalParams: ['name', 'age']
+        });
+
+        export default MyComponent;
+        ```
+
+        It can then be invoked like this:
+
+        ```hbs
+        {{my-component "John" 38}}
+        ```
+
+        The parameters can be referred to just like named parameters:
+
+        ```hbs
+        Name: {{name}}, Age: {{age}}.
+        ```
+
+        Using a string instead of an array allows for an arbitrary number of
+        parameters:
+
+        ```app/components/my-component.js
+        import Component from '@ember/component';
+
+        let MyComponent = Component.extend();
+
+        MyComponent.reopenClass({
+          positionalParams: 'names'
+        });
+
+        export default MyComponent;
+        ```
+
+        It can then be invoked like this:
+
+        ```hbs
+        {{my-component "John" "Michael" "Scott"}}
+        ```
+        The parameters can then be referred to by enumerating over the list:
+
+        ```hbs
+        {{#each names as |name|}}{{name}}{{/each}}
+        ```
+
+        @static
+        @public
+        @property positionalParams
+        @since 1.13.0
+        */
+    static positionalParams: string | string[];
     /**
           Layout can be used to wrap content in a component.
           @property layout

package/types/stable/@ember/-internals/glimmer/lib/components/input.d.ts

@@ -1,4 +1,7 @@
 declare module '@ember/-internals/glimmer/lib/components/input' {
-  const _default: import('@ember/-internals/glimmer/lib/components/internal').OpaqueInternalComponentConstructor;
-  export default _default;
+  import { type Opaque } from '@ember/-internals/utility-types';
+  import { type OpaqueInternalComponentConstructor } from '@ember/-internals/glimmer/lib/components/internal';
+  const Input: Input;
+  interface Input extends Opaque<'component:input'>, OpaqueInternalComponentConstructor {}
+  export default Input;
 }

package/types/stable/@ember/-internals/glimmer/lib/components/link-to.d.ts

@@ -1,4 +1,7 @@
 declare module '@ember/-internals/glimmer/lib/components/link-to' {
-  const _default: import('@ember/-internals/glimmer/lib/components/internal').OpaqueInternalComponentConstructor;
-  export default _default;
+  import { type OpaqueInternalComponentConstructor } from '@ember/-internals/glimmer/lib/components/internal';
+  import { type Opaque } from '@ember/-internals/utility-types';
+  const LinkTo: LinkTo;
+  interface LinkTo extends Opaque<'component:link-to'>, OpaqueInternalComponentConstructor {}
+  export default LinkTo;
 }

package/types/stable/@ember/-internals/glimmer/lib/components/textarea.d.ts

@@ -1,4 +1,10 @@
 declare module '@ember/-internals/glimmer/lib/components/textarea' {
-  const _default: import('@ember/-internals/glimmer/lib/components/internal').OpaqueInternalComponentConstructor;
-  export default _default;
+  /**
+    @module @ember/component
+    */
+  import { type Opaque } from '@ember/-internals/utility-types';
+  import { type OpaqueInternalComponentConstructor } from '@ember/-internals/glimmer/lib/components/internal';
+  const Textarea: Textarea;
+  interface Textarea extends Opaque<'component:textarea'>, OpaqueInternalComponentConstructor {}
+  export default Textarea;
 }

package/types/stable/@ember/-internals/glimmer/lib/helper.d.ts

@@ -2,57 +2,30 @@ declare module '@ember/-internals/glimmer/lib/helper' {
   /**
     @module @ember/component
     */
-  import type { InternalFactory } from '@ember/-internals/owner';
   import { FrameworkObject } from '@ember/object/-internals';
-  import type { Arguments, Dict, HelperManager } from '@glimmer/interfaces';
+  import type { Arguments, HelperManager } from '@glimmer/interfaces';
   import type { DirtyableTag } from '@glimmer/validator';
   export const RECOMPUTE_TAG: unique symbol;
-  export type HelperFunction<T, P extends unknown[], N extends Dict<unknown>> = (
-    positional: P,
-    named: N
-  ) => T;
-  export type SimpleHelperFactory<
-    T,
-    P extends unknown[],
-    N extends Dict<unknown>
-  > = InternalFactory<SimpleHelper<T, P, N>, HelperFactory<SimpleHelper<T, P, N>>>;
-  export type ClassHelperFactory = InternalFactory<HelperInstance, HelperFactory<HelperInstance>>;
+  type GetOr<T, K, Else> = K extends keyof T ? T[K] : Else;
+  type Args<S> = GetOr<S, 'Args', {}>;
+  type DefaultPositional = unknown[];
+  type Positional<S> = GetOr<Args<S>, 'Positional', DefaultPositional>;
+  type Named<S> = GetOr<Args<S>, 'Named', object>;
+  type Return<S> = GetOr<S, 'Return', unknown>;
   export interface HelperFactory<T> {
     isHelperFactory: true;
     create(): T;
   }
-  export interface HelperInstance<T = unknown> {
-    compute(positional: unknown[], named: Dict<unknown>): T;
+  export interface HelperInstance<S> {
+    compute(positional: Positional<S>, named: Named<S>): Return<S>;
     destroy(): void;
     [RECOMPUTE_TAG]: DirtyableTag;
   }
   const IS_CLASSIC_HELPER: unique symbol;
-  export interface SimpleHelper<T, P extends unknown[], N extends Dict<unknown>> {
-    compute: HelperFunction<T, P, N>;
+  export interface SimpleHelper<S> {
+    compute: (positional: Positional<S>, named: Named<S>) => Return<S>;
   }
-  /**
-      In many cases it is not necessary to use the full `Helper` class.
-      The `helper` method create pure-function helpers without instances.
-      For example:
-
-      ```app/helpers/format-currency.js
-      import { helper } from '@ember/component/helper';
-
-      export default helper(function([cents], {currency}) {
-        return `${currency}${cents * 0.01}`;
-      });
-      ```
-
-      @static
-      @param {Function} helper The helper function
-      @method helper
-      @for @ember/component/helper
-      @public
-      @since 1.13.0
-    */
-  export function helper<T, P extends unknown[], N extends Dict<unknown>>(
-    helperFn: HelperFunction<T, P, N>
-  ): HelperFactory<SimpleHelper<T, P, N>>;
+  const SIGNATURE: unique symbol;
   /**
       Ember Helpers are functions that can compute values, and are used in templates.
       For example, this code calls a helper named `format-currency`:
@@ -98,24 +71,25 @@ declare module '@ember/-internals/glimmer/lib/helper' {
       @public
       @since 1.13.0
     */
-  interface Helper {
+  export default interface Helper<S = unknown> {
     /**
           Override this function when writing a class-based helper.
       
           @method compute
-          @param {Array} params The positional arguments to the helper
-          @param {Object} hash The named arguments to the helper
+          @param {Array} positional The positional arguments to the helper
+          @param {Object} named The named arguments to the helper
           @public
           @since 1.13.0
         */
-    compute(params: unknown[], hash: Dict<unknown>): unknown;
+    compute(positional: Positional<S>, named: Named<S>): Return<S>;
   }
-  class Helper extends FrameworkObject {
+  export default class Helper<S = unknown> extends FrameworkObject {
     static isHelperFactory: boolean;
     static [IS_CLASSIC_HELPER]: boolean;
     /** @deprecated */
     static helper: typeof helper;
     [RECOMPUTE_TAG]: DirtyableTag;
+    private [SIGNATURE];
     init(properties: object | undefined): void;
     /**
           On a class-based helper, it may be useful to force a recomputation of that
@@ -152,18 +126,11 @@ declare module '@ember/-internals/glimmer/lib/helper' {
   export const CLASSIC_HELPER_MANAGER:
     | import('@glimmer/interfaces').Helper<object>
     | import('@glimmer/manager').CustomHelperManager<object>;
-  class Wrapper<
-    T = unknown,
-    P extends unknown[] = unknown[],
-    N extends Dict<unknown> = Dict<unknown>
-  > implements HelperFactory<SimpleHelper<T, P, N>>
-  {
-    compute: HelperFunction<T, P, N>;
+  class Wrapper<S = unknown> implements HelperFactory<SimpleHelper<S>> {
+    compute: (positional: Positional<S>, named: Named<S>) => Return<S>;
     readonly isHelperFactory = true;
-    constructor(compute: HelperFunction<T, P, N>);
-    create(): {
-      compute: HelperFunction<T, P, N>;
-    };
+    constructor(compute: (positional: Positional<S>, named: Named<S>) => Return<S>);
+    create(): SimpleHelper<S>;
   }
   class SimpleClassicHelperManager implements HelperManager<() => unknown> {
     capabilities: import('@glimmer/interfaces').HelperCapabilities;
@@ -172,5 +139,48 @@ declare module '@ember/-internals/glimmer/lib/helper' {
     getDebugName(definition: Wrapper): string;
   }
   export const SIMPLE_CLASSIC_HELPER_MANAGER: SimpleClassicHelperManager;
-  export default Helper;
+  /**
+   * The type of a function-based helper.
+   *
+   * @note This is *not* user-constructible: it is exported only so that the type
+   *   returned by the `helper` function can be named (and indeed can be exported
+   *   like `export default helper(...)` safely).
+   */
+  export type FunctionBasedHelper<S> = abstract new () => FunctionBasedHelperInstance<S>;
+  export abstract class FunctionBasedHelperInstance<S> extends Helper<S> {
+    protected abstract __concrete__: never;
+  }
+  /**
+      In many cases it is not necessary to use the full `Helper` class.
+      The `helper` method create pure-function helpers without instances.
+      For example:
+
+      ```app/helpers/format-currency.js
+      import { helper } from '@ember/component/helper';
+
+      export default helper(function([cents], {currency}) {
+        return `${currency}${cents * 0.01}`;
+      });
+      ```
+
+      @static
+      @param {Function} helper The helper function
+      @method helper
+      @for @ember/component/helper
+      @public
+      @since 1.13.0
+    */
+  export function helper<P extends DefaultPositional, N extends object, R = unknown>(
+    helperFn: (positional: P, named: N) => R
+  ): FunctionBasedHelper<{
+    Args: {
+      Positional: P;
+      Named: N;
+    };
+    Return: R;
+  }>;
+  export function helper<S>(
+    helperFn: (positional: Positional<S>, named: Named<S>) => Return<S>
+  ): FunctionBasedHelper<S>;
+  export {};
 }

package/types/stable/@ember/-internals/glimmer/lib/templates/empty.d.ts

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/glimmer/lib/templates/empty' {
+  import type { TemplateFactory } from '@glimmer/interfaces';
+  const TEMPLATE: TemplateFactory;
+  export default TEMPLATE;
+}

package/types/stable/@ember/-internals/glimmer/lib/templates/input.d.ts

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/glimmer/lib/templates/input' {
+  import type { TemplateFactory } from '@glimmer/interfaces';
+  const TEMPLATE: TemplateFactory;
+  export default TEMPLATE;
+}

package/types/stable/@ember/-internals/glimmer/lib/templates/link-to.d.ts

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/glimmer/lib/templates/link-to' {
+  import type { TemplateFactory } from '@glimmer/interfaces';
+  const TEMPLATE: TemplateFactory;
+  export default TEMPLATE;
+}

package/types/stable/@ember/-internals/glimmer/lib/templates/outlet.d.ts

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/glimmer/lib/templates/outlet' {
+  import type { TemplateFactory } from '@glimmer/interfaces';
+  const TEMPLATE: TemplateFactory;
+  export default TEMPLATE;
+}

package/types/stable/@ember/-internals/glimmer/lib/templates/root.d.ts

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/glimmer/lib/templates/root' {
+  import type { TemplateFactory } from '@glimmer/interfaces';
+  const TEMPLATE: TemplateFactory;
+  export default TEMPLATE;
+}

package/types/stable/@ember/-internals/glimmer/lib/templates/textarea.d.ts

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/glimmer/lib/templates/textarea' {
+  import type { TemplateFactory } from '@glimmer/interfaces';
+  const TEMPLATE: TemplateFactory;
+  export default TEMPLATE;
+}

package/types/stable/@ember/-internals/metal/lib/computed.d.ts

@@ -331,7 +331,8 @@ declare module '@ember/-internals/metal/lib/computed' {
           @chainable
           @public
         */
-    meta(this: ExtendedMethodDecorator, meta?: unknown): unknown;
+    meta(): unknown;
+    meta(meta: unknown): ComputedDecorator;
     /** @internal */
     get _getter(): ComputedPropertyGetterFunction | undefined;
     /** @internal */

package/types/stable/@ember/-internals/metal/lib/computed_cache.d.ts

@@ -1,3 +1,4 @@
 declare module '@ember/-internals/metal/lib/computed_cache' {
+  export function getCachedValueFor<T, K extends keyof T>(obj: T, key: K): T[K] | undefined;
   export function getCachedValueFor(obj: object, key: string): unknown;
 }