ember-source 4.8.0-beta.1 → 4.8.0-beta.3

package/types/preview/@ember/component/template-only.d.ts

@@ -0,0 +1,47 @@
+declare module '@ember/component/template-only' {
+  import { Opaque } from 'ember/-private/type-utils';
+
+  /**
+   * Template-only components have no backing class instance, so this in their
+   * templates is null. This means that you can only reference passed in arguments
+   * via named argument syntax (e.g. `{{@arg}}`):
+   *
+   * ```hbs
+   * {{!--
+   *   This does not work, since `this` does not exist
+   * --}}
+   * <label for="title">Title</label>
+   * <Input @value={{this.value}} id="title" />
+   * ```
+   *
+   * Additionally, the mut helper generally can't be used for the same reason:
+   *
+   * ```hbs
+   * {{!-- This does not work --}}
+   * <input
+   *   value={{this.value}}
+   *   onkeyup={{action (mut this.value) target="value"}}
+   * />
+   * ```
+   *
+   * Since Octane, a template-only component shares a subset of features that are
+   * available in `@glimmer/component`. Such component can be seamlessly
+   * "upgraded" to a Glimmer component, when you add a JavaScript file alongside
+   * the template.
+   */
+  export interface TemplateOnlyComponent<S = unknown> extends Opaque<S> {
+    toString(): string;
+  }
+
+  /**
+   * A convenience alias for {@link TemplateOnlyComponent}
+   */
+  export type TOC<S> = TemplateOnlyComponent<S>;
+
+  // The generic here is for a *signature: a way to hang information for tools
+  // like Glint which can provide typey checking for component templates using
+  // information supplied via this generic. While it may appear useless on this
+  // class definition and extension, it is used by external tools and should not
+  // be removed.
+  export default function templateOnly<S>(moduleName?: string): TemplateOnlyComponent<S>;
+}

package/types/preview/@ember/component/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}

package/types/preview/@ember/controller/index.d.ts

@@ -0,0 +1,48 @@
+declare module '@ember/controller' {
+  import ActionHandler from '@ember/object/-private/action-handler';
+  import Mixin from '@ember/object/mixin';
+  import EmberObject from '@ember/object';
+  import type { BasicComputedProperty } from '@ember/object/computed';
+
+  type QueryParamTypes = 'boolean' | 'number' | 'array' | 'string';
+  type QueryParamScopeTypes = 'controller' | 'model';
+
+  interface QueryParamConfig {
+    type?: QueryParamTypes | undefined;
+    scope?: QueryParamScopeTypes | undefined;
+    as?: string | undefined;
+  }
+
+  /**
+   * Additional methods for the Controller.
+   */
+  export interface ControllerMixin extends ActionHandler {
+    /**
+     * @deprecated until 5.0. Use `RouterService.replaceWith` instead.
+     */
+    replaceRoute(name: string, ...args: any[]): void;
+    /**
+     * @deprecated until 5.0. Use `RouterService.transitionTo` instead.
+     */
+    transitionToRoute(name: string, ...args: any[]): void;
+    /**
+     * @deprecated until 5.0. Use `RouterService.transitionTo` instead.
+     */
+    transitionToRoute(...args: any[]): void;
+    model: unknown;
+    queryParams: Array<string | Record<string, QueryParamConfig | string | undefined>>;
+    target: object;
+  }
+  export const ControllerMixin: Mixin;
+
+  export default class Controller extends EmberObject {}
+  export default interface Controller extends ControllerMixin {}
+
+  export function inject(): Controller;
+  export function inject<K extends keyof Registry>(name: K): Registry[K] & BasicComputedProperty;
+  export function inject(target: object, propertyKey: string | symbol): void;
+
+  // A type registry for Ember `Controller`s. Meant to be declaration-merged
+  // so string lookups resolve to the correct type.
+  export interface Registry {}
+}

package/types/preview/@ember/controller/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}

package/types/preview/@ember/debug/container-debug-adapter.d.ts

@@ -0,0 +1,13 @@
+declare module '@ember/debug/container-debug-adapter' {
+  import type { Resolver } from '@ember/-internals/resolver';
+
+  /**
+   * The ContainerDebugAdapter helps the container and resolver interface
+   * with tools that debug Ember such as the Ember Inspector for Chrome and Firefox.
+   */
+  export default class ContainerDebugAdapter extends Object {
+    resolver: Resolver;
+    canCatalogEntriesByType(type: string): boolean;
+    catalogEntriesByType(type: string): string[];
+  }
+}

package/types/preview/@ember/debug/data-adapter.d.ts

@@ -0,0 +1,64 @@
+declare module '@ember/debug/data-adapter' {
+  import ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
+  import EmberObject from '@ember/object';
+
+  namespace DataAdapter {
+    interface Column {
+      name: string;
+      desc: string;
+    }
+    interface WrappedRecord {
+      columnValues: object;
+      object: object;
+    }
+    interface WrappedType {
+      type: {
+        name: string;
+        count: number;
+        columns: Column[];
+        object: typeof Object;
+      };
+      release: () => void;
+    }
+  }
+
+  /**
+   * The `DataAdapter` helps a data persistence library
+   * interface with tools that debug Ember such as Chrome and Firefox.
+   */
+  export default class DataAdapter extends EmberObject {
+    /**
+     * The container-debug-adapter which is used
+     * to list all models.
+     */
+    containerDebugAdapter: ContainerDebugAdapter;
+    /**
+     * Ember Data > v1.0.0-beta.18
+     * requires string model names to be passed
+     * around instead of the actual factories.
+     */
+    acceptsModelName: boolean;
+    /**
+     * Specifies how records can be filtered.
+     * Records returned will need to have a `filterValues`
+     * property with a key for every name in the returned array.
+     */
+    getFilters(): DataAdapter.Column[];
+    /**
+     * Fetch the model types and observe them for changes.
+     */
+    watchModelTypes(
+      typesAdded: (types: DataAdapter.WrappedType[]) => void,
+      typesUpdated: (types: DataAdapter.WrappedType[]) => void
+    ): () => void;
+    /**
+     * Fetch the records of a given type and observe them for changes.
+     */
+    watchRecords(
+      modelName: string,
+      recordsAdded: (records: DataAdapter.WrappedRecord[]) => void,
+      recordsUpdated: (records: DataAdapter.WrappedRecord[]) => void,
+      recordsRemoved: (idx: number, count: number) => void
+    ): () => void;
+  }
+}

package/types/preview/@ember/debug/index.d.ts

@@ -0,0 +1,98 @@
+declare module '@ember/debug' {
+  /**
+   * Define an assertion that will throw an exception if the condition is not met.
+   */
+  export function assert(desc: string): never;
+  export function assert(desc: string, test: unknown): asserts test;
+
+  /**
+   * Display a debug notice.
+   */
+  export function debug(message: string): void;
+
+  /**
+   * Allows for runtime registration of handler functions that override the default deprecation behavior.
+   * Deprecations are invoked by calls to [Ember.deprecate](http://emberjs.com/api/classes/Ember.html#method_deprecate).
+   * The following example demonstrates its usage by registering a handler that throws an error if the
+   * message contains the word "should", otherwise defers to the default handler.
+   */
+  export function registerDeprecationHandler(
+    handler: (
+      message: string,
+      options: { id: string; until: string } | undefined,
+      next: (message: string, options?: { id: string; until: string }) => void
+    ) => void
+  ): void;
+  /**
+   * Allows for runtime registration of handler functions that override the default warning behavior.
+   * Warnings are invoked by calls made to [Ember.warn](http://emberjs.com/api/classes/Ember.html#method_warn).
+   * The following example demonstrates its usage by registering a handler that does nothing overriding Ember's
+   * default warning behavior.
+   */
+  export function registerWarnHandler(
+    handler: (
+      message: string,
+      options: { id: string } | undefined,
+      next: (message: string, options?: { id: string }) => void
+    ) => void
+  ): void;
+
+  /**
+   * Run a function meant for debugging.
+   */
+  export function runInDebug(func: () => unknown): void;
+
+  /**
+   * Display a warning with the provided message.
+   */
+  export function warn(message: string, test: boolean, options: { id: string }): void;
+  export function warn(message: string, options: { id: string }): void;
+
+  /**
+   * Display a deprecation warning with the provided message and a stack trace
+   * (Chrome and Firefox only).
+   *
+   * In a production build, this method is defined as an empty function (NOP).
+   * Uses of this method in Ember itself are stripped from the ember.prod.js build.
+   *
+   * @param message A description of the deprecation.
+   * @param test If falsy, the deprecation will be displayed.
+   * @param options The deprecation options.
+   */
+  export function deprecate(
+    message: string,
+    test: boolean,
+    options: {
+      /**
+       * A unique id for this deprecation. The id can be used by Ember debugging
+       * tools to change the behavior (raise, log or silence) for that specific
+       * deprecation. The id should be namespaced by dots, e.g.
+       * `"view.helper.select"`.
+       */
+      id: string;
+      /**
+       * The version of Ember when this deprecation warning will be removed.
+       */
+      until: string;
+      /**
+       * An optional url to the transition guide on the emberjs.com website.
+       */
+      url?: string | undefined;
+      /**
+       * A namespace for the deprecation, usually the package name.
+       */
+      for: string;
+      /**
+       * Describes when the deprecation became available and enabled.
+       */
+      since: Available | Enabled;
+    }
+  ): void;
+
+  export interface Available {
+    available: string;
+  }
+  export interface Enabled extends Available {
+    enabled: string;
+  }
+}

package/types/preview/@ember/debug/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}

package/types/preview/@ember/destroyable/index.d.ts

@@ -0,0 +1,23 @@
+declare module '@ember/destroyable' {
+  export function associateDestroyableChild<T extends object>(parent: object, child: T): T;
+
+  export function isDestroying(destroyable: object): boolean;
+
+  export function isDestroyed(destroyable: object): boolean;
+
+  export function destroy(destroyable: object): void;
+
+  export function assertDestroyablesDestroyed(): void;
+
+  export function enableDestroyableTracking(): void;
+
+  export function registerDestructor<T extends object>(
+    destroyable: T,
+    destructor: (destroyable: T) => void
+  ): (destroyable: T) => void;
+
+  export function unregisterDestructor<T extends object>(
+    destroyable: T,
+    destructor: (destroyable: T) => void
+  ): void;
+}

package/types/preview/@ember/destroyable/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}

package/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts

@@ -0,0 +1,17 @@
+declare module '@ember/engine/-private/container-proxy-mixin' {
+  import Owner from '@ember/owner';
+  import Mixin from '@ember/object/mixin';
+
+  /**
+   * Given a fullName return a factory manager.
+   */
+  interface ContainerProxyMixin extends Owner {
+    /**
+     * Returns an object that can be used to provide an owner to a
+     * manually created instance.
+     */
+    ownerInjection(): {};
+  }
+  const ContainerProxyMixin: Mixin;
+  export default ContainerProxyMixin;
+}

package/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts

@@ -0,0 +1,54 @@
+declare module '@ember/engine/-private/registry-proxy-mixin' {
+  import Owner from '@ember/owner';
+  import Mixin from '@ember/object/mixin';
+
+  /**
+   * RegistryProxyMixin is used to provide public access to specific
+   * registry functionality.
+   */
+  interface RegistryProxyMixin extends Owner {
+    /**
+     * Given a fullName return the corresponding factory.
+     */
+    resolveRegistration(fullName: string): unknown;
+    /**
+     * Unregister a factory.
+     */
+    unregister(fullName: string): unknown;
+    /**
+     * Check if a factory is registered.
+     */
+    hasRegistration(fullName: string): boolean;
+    /**
+     * Register an option for a particular factory.
+     */
+    registerOption(fullName: string, optionName: string, options: {}): unknown;
+    /**
+     * Return a specific registered option for a particular factory.
+     */
+    registeredOption(fullName: string, optionName: string): {};
+    /**
+     * Register options for a particular factory.
+     */
+    registerOptions(fullName: string, options: {}): unknown;
+    /**
+     * Return registered options for a particular factory.
+     */
+    registeredOptions(fullName: string): {};
+    /**
+     * Allow registering options for all factories of a type.
+     */
+    registerOptionsForType(type: string, options: {}): unknown;
+    /**
+     * Return the registered options for all factories of a type.
+     */
+    registeredOptionsForType(type: string): {};
+    /**
+     * Define a dependency injection onto a specific factory or all factories
+     * of a type.
+     */
+    inject(factoryNameOrType: string, property: string, injectionName: string): unknown;
+  }
+  const RegistryProxyMixin: Mixin;
+  export default RegistryProxyMixin;
+}

package/types/preview/@ember/engine/-private/types/initializer.d.ts

@@ -0,0 +1,8 @@
+declare module '@ember/engine/-private/types/initializer' {
+  export default interface Initializer<T> {
+    name: string;
+    before?: string[] | undefined;
+    after?: string[] | undefined;
+    initialize(application: T): void;
+  }
+}

package/types/preview/@ember/engine/index.d.ts

@@ -0,0 +1,45 @@
+declare module '@ember/engine' {
+  import EmberObject from '@ember/object';
+  import type RegistryProxyMixin from '@ember/engine/-private/registry-proxy-mixin';
+  import type Initializer from '@ember/engine/-private/types/initializer';
+  import type EngineInstance from '@ember/engine/instance';
+  import type { Resolver } from '@ember/-internals/resolver';
+
+  /**
+   * The `Engine` class contains core functionality for both applications and
+   * engines.
+   */
+  export default class Engine extends EmberObject {
+    /**
+     * The goal of initializers should be to register dependencies and injections.
+     * This phase runs once. Because these initializers may load code, they are
+     * allowed to defer application readiness and advance it. If you need to access
+     * the container or store you should use an InstanceInitializer that will be run
+     * after all initializers and therefore after all code is loaded and the app is
+     * ready.
+     */
+    static initializer(initializer: Initializer<Engine>): void;
+    /**
+     * Instance initializers run after all initializers have run. Because
+     * instance initializers run after the app is fully set up. We have access
+     * to the store, container, and other items. However, these initializers run
+     * after code has loaded and are not allowed to defer readiness.
+     */
+    static instanceInitializer(instanceInitializer: Initializer<EngineInstance>): void;
+    /**
+     * Set this to provide an alternate class to `DefaultResolver`
+     */
+    resolver: Resolver | null;
+    /**
+     * Create an EngineInstance for this Engine.
+     */
+    buildInstance(options?: object): EngineInstance;
+  }
+
+  export default interface Engine extends RegistryProxyMixin {}
+
+  /**
+   * `getEngineParent` retrieves an engine instance's parent instance.
+   */
+  export function getEngineParent(engine: EngineInstance): EngineInstance;
+}

package/types/preview/@ember/engine/instance.d.ts

@@ -0,0 +1,24 @@
+declare module '@ember/engine/instance' {
+  import ContainerProxyMixin from '@ember/engine/-private/container-proxy-mixin';
+  import RegistryProxyMixin from '@ember/engine/-private/registry-proxy-mixin';
+  import EmberObject from '@ember/object';
+
+  /**
+   * The `EngineInstance` encapsulates all of the stateful aspects of a
+   * running `Engine`.
+   */
+  export default class EngineInstance extends EmberObject {
+    /**
+     * Unregister a factory.
+     */
+    unregister(fullName: string): unknown;
+
+    /**
+     *  Initialize the `EngineInstance` and return a promise that resolves
+     *  with the instance itself when the boot process is complete.
+     */
+    boot(): Promise<EngineInstance>;
+  }
+
+  export default interface EngineInstance extends RegistryProxyMixin, ContainerProxyMixin {}
+}

package/types/preview/@ember/engine/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}

package/types/preview/@ember/error/index.d.ts

@@ -0,0 +1,6 @@
+declare module '@ember/error' {
+  /**
+   * A subclass of the JavaScript Error object for use in Ember.
+   */
+  export default class EmberError extends Error {}
+}

package/types/preview/@ember/error/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}

package/types/preview/@ember/helper/index.d.ts

@@ -0,0 +1,49 @@
+declare module '@ember/helper' {
+  import type { Opaque } from 'ember/-private/type-utils';
+
+  // In normal TypeScript, these helpers are essentially opaque tokens that just
+  // need to be importable. Declaring them with unique interfaces like this,
+  // however, gives tools like Glint (that DO have a richer notion of what they
+  // are) a place to install more detailed type information.
+  export interface ArrayHelper extends Opaque<'helper:array'> {}
+  export interface ConcatHelper extends Opaque<'helper:concat'> {}
+  export interface FnHelper extends Opaque<'helper:fn'> {}
+  export interface GetHelper extends Opaque<'helper:get'> {}
+  export interface HashHelper extends Opaque<'helper:hash'> {}
+
+  /**
+   * Use the `{{array}}` helper to create an array to pass as an option to your components.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/array?anchor=array
+   */
+  export const array: ArrayHelper;
+
+  /**
+   * Concatenates the given arguments into a string.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/concat?anchor=concat
+   */
+  export const concat: ConcatHelper;
+
+  /**
+   * The `fn` helper allows you to ensure a function that you are passing off to another component, helper, or modifier
+   * has access to arguments that are available in the template.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/fn?anchor=fn
+   */
+  export const fn: FnHelper;
+
+  /**
+   * Dynamically look up a property on an object.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/get?anchor=get
+   */
+  export const get: GetHelper;
+
+  /**
+   * Use the `{{hash}}` helper to create a hash to pass as an option to your components.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/hash?anchor=hash
+   */
+  export const hash: HashHelper;
+}

package/types/preview/@ember/helper/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}

package/types/preview/@ember/modifier/index.d.ts

@@ -0,0 +1,33 @@
+declare module '@ember/modifier' {
+  import type Owner from '@ember/owner';
+  import type { Opaque } from 'ember/-private/type-utils';
+
+  // In normal TypeScript, this modifier is essentially an opaque token
+  // that just needs to be importable. Declaring it with a unique interface
+  // like this, however, gives tools like Glint (that DO have a richer
+  // notion of what it is) a place to install more detailed type information.
+  export interface OnModifier extends Opaque<'modifier:on'> {}
+
+  /**
+   * The `{{on}}` modifier lets you easily add event listeners.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/on?anchor=on
+   */
+  export const on: OnModifier;
+
+  /**
+   * Given a modifier manager factory and a modifier, tell Ember to set the
+   * manager returned by that factory as the manager for the modifier.
+   *
+   * @param factory A function which takes an `owner` and returns a [modifier
+   *   manager](https://emberjs.github.io/rfcs/0373-Element-Modifier-Managers.html).
+   * @param modifier The modifier definition to associate with the manager.
+   */
+  export function setModifierManager<T>(factory: (owner: Owner) => unknown, modifier: T): T;
+
+  /**
+   * Given a target version of Ember, return an opaque token which Ember can use
+   * to determine what a given modifier manager supports.
+   */
+  export function capabilities(version: string): unknown;
+}

package/types/preview/@ember/modifier/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}

package/types/preview/@ember/object/-private/action-handler.d.ts

@@ -0,0 +1,31 @@
+declare module '@ember/object/-private/action-handler' {
+  import { AnyFn } from 'ember/-private/type-utils';
+  import type Mixin from '@ember/object/mixin';
+
+  interface ActionsHash {
+    [index: string]: AnyFn;
+  }
+
+  /**
+   * Ember.ActionHandler is available on some familiar classes including Ember.Route,
+   * Ember.Component, and Ember.Controller. (Internally the mixin is used by Ember.CoreView,
+   * Ember.ControllerMixin, and Ember.Route and available to the above classes through inheritance.)
+   */
+  interface ActionHandler {
+    /**
+     * Triggers a named action on the ActionHandler. Any parameters supplied after the actionName
+     * string will be passed as arguments to the action target function.
+     *
+     * If the ActionHandler has its target property set, actions may bubble to the target.
+     * Bubbling happens when an actionName can not be found in the ActionHandler's actions
+     * hash or if the action target function returns true.
+     */
+    send(actionName: string, ...args: any[]): void;
+    /**
+     * The collection of functions, keyed by name, available on this ActionHandler as action targets.
+     */
+    actions: ActionsHash;
+  }
+  const ActionHandler: Mixin;
+  export default ActionHandler;
+}