ember-source 4.8.0-alpha.5 → 4.8.0-beta.2

package/types/preview/@ember/object/observable.d.ts

@@ -0,0 +1,89 @@
+declare module '@ember/object/observable' {
+  import { ObserverMethod } from '@ember/object/-private/types';
+  import Mixin from '@ember/object/mixin';
+  import CoreObject from '@ember/object/core';
+
+  /**
+   * This mixin provides properties and property observing functionality, core features of the Ember object model.
+   */
+  interface Observable extends CoreObject {
+    /**
+     * Retrieves the value of a property from the object.
+     */
+    get<K extends keyof this>(key: K): this[K];
+    get(key: string): unknown;
+    /**
+     * To get the values of multiple properties at once, call `getProperties`
+     * with a list of strings or an array:
+     */
+    getProperties<K extends keyof this>(list: K[]): Pick<this, K>;
+    getProperties<K extends keyof this>(...list: K[]): Pick<this, K>;
+    getProperties(list: string[]): Record<string, unknown>;
+    getProperties(...list: string[]): Record<string, unknown>;
+    /**
+     * Sets the provided key or path to the value.
+     */
+    set<K extends keyof this>(key: K, value: this[K]): this[K];
+    set<T>(key: keyof this, value: T): T;
+    set<T>(key: string, value: T): T;
+    /**
+     * Sets a list of properties at once. These properties are set inside
+     * a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+     * observers will be buffered.
+     */
+    setProperties<K extends keyof this>(hash: Pick<this, K>): Pick<this, K>;
+    setProperties<K extends keyof this>(hash: Record<K, unknown>): Pick<this, K>;
+    setProperties<R extends Record<string, unknown>>(hash: R): R;
+    /**
+     * Notify the observer system that a property has just changed.
+     *
+     * Sometimes you need to change a value directly or indirectly without
+     * actually calling `get()` or `set()` on it. In this case, you can use this
+     * method instead. Calling this method will notify all observers that the
+     * property has potentially changed value.
+     */
+    notifyPropertyChange(keyName: string): this;
+    /**
+     * Adds an observer on a property.
+     */
+    addObserver<Target>(
+      key: keyof this,
+      target: Target,
+      method: ObserverMethod<Target, this>
+    ): this;
+    addObserver(key: keyof this, method: ObserverMethod<this, this>): this;
+    /**
+     * Remove an observer you have previously registered on this object. Pass
+     * the same key, target, and method you passed to `addObserver()` and your
+     * target will no longer receive notifications.
+     */
+    removeObserver<Target>(
+      key: keyof this,
+      target: Target,
+      method: ObserverMethod<Target, this>
+    ): this;
+    removeObserver(key: keyof this, method: ObserverMethod<this, this>): this;
+    /**
+     * Set the value of a property to the current value plus some amount.
+     */
+    incrementProperty(keyName: keyof this, increment?: number): number;
+    /**
+     * Set the value of a property to the current value minus some amount.
+     */
+    decrementProperty(keyName: keyof this, decrement?: number): number;
+    /**
+     * Set the value of a boolean property to the opposite of its
+     * current value.
+     */
+    toggleProperty(keyName: keyof this): boolean;
+    /**
+     * Returns the cached value of a computed property, if it exists.
+     * This allows you to inspect the value of a computed property
+     * without accidentally invoking it if it is intended to be
+     * generated lazily.
+     */
+    cacheFor<K extends keyof this>(key: K): this[K] | undefined;
+  }
+  const Observable: Mixin;
+  export default Observable;
+}

package/types/preview/@ember/object/observers.d.ts

@@ -0,0 +1,34 @@
+declare module '@ember/object/observers' {
+  import { ObserverMethod } from '@ember/object/-private/types';
+
+  /**
+   * Adds an observer on a property.
+   */
+  export function addObserver<Context, Target>(
+    obj: Context,
+    key: keyof Context,
+    target: Target,
+    method: ObserverMethod<Target, Context>
+  ): void;
+  export function addObserver<Context>(
+    obj: Context,
+    key: keyof Context,
+    method: ObserverMethod<Context, Context>
+  ): void;
+  /**
+   * Remove an observer you have previously registered on this object. Pass
+   * the same key, target, and method you passed to `addObserver()` and your
+   * target will no longer receive notifications.
+   */
+  export function removeObserver<Context, Target>(
+    obj: Context,
+    key: keyof Context,
+    target: Target,
+    method: ObserverMethod<Target, Context>
+  ): any;
+  export function removeObserver<Context>(
+    obj: Context,
+    key: keyof Context,
+    method: ObserverMethod<Context, Context>
+  ): any;
+}

package/types/preview/@ember/object/promise-proxy-mixin.d.ts

@@ -0,0 +1,37 @@
+declare module '@ember/object/promise-proxy-mixin' {
+  import Mixin from '@ember/object/mixin';
+  import RSVP from 'rsvp';
+
+  /**
+   * A low level mixin making ObjectProxy promise-aware.
+   */
+  interface PromiseProxyMixin<T> extends RSVP.Promise<T> {
+    /**
+     * If the proxied promise is rejected this will contain the reason
+     * provided.
+     */
+    reason: unknown;
+    /**
+     * Once the proxied promise has settled this will become `false`.
+     */
+    isPending: boolean;
+    /**
+     * Once the proxied promise has settled this will become `true`.
+     */
+    isSettled: boolean;
+    /**
+     * Will become `true` if the proxied promise is rejected.
+     */
+    isRejected: boolean;
+    /**
+     * Will become `true` if the proxied promise is fulfilled.
+     */
+    isFulfilled: boolean;
+    /**
+     * The promise whose fulfillment value is being proxied by this object.
+     */
+    promise: RSVP.Promise<T>;
+  }
+  const PromiseProxyMixin: Mixin;
+  export default PromiseProxyMixin;
+}

package/types/preview/@ember/object/proxy.d.ts

@@ -0,0 +1,27 @@
+declare module '@ember/object/proxy' {
+  import EmberObject from '@ember/object';
+
+  /**
+   * `Ember.ObjectProxy` forwards all properties not defined by the proxy itself
+   * to a proxied `content` object.
+   */
+  export default class ObjectProxy<T extends object = object> extends EmberObject {
+    /**
+     * The object whose properties will be forwarded.
+     */
+    content: T | undefined;
+
+    get<K extends keyof this>(key: K): this[K];
+    get<K extends keyof T>(key: K): T[K] | undefined;
+
+    getProperties<K extends keyof this>(list: K[]): Pick<this, K>;
+    getProperties<K extends keyof this>(...list: K[]): Pick<this, K>;
+    getProperties<K extends keyof T>(list: K[]): Pick<Partial<T>, K>;
+    getProperties<K extends keyof T>(...list: K[]): Pick<Partial<T>, K>;
+
+    set<K extends keyof this>(key: K, value: this[K]): this[K];
+    set<K extends keyof T>(key: K, value: T[K]): T[K];
+
+    setProperties<K extends keyof this | keyof T>(hash: Pick<this & T, K>): Pick<this & T, K>;
+  }
+}

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

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

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

@@ -0,0 +1,102 @@
+declare module '@ember/owner' {
+  /**
+   * The name for a factory consists of a namespace and the name of a specific
+   * type within that namespace, like `'service:session'`.
+   */
+  export type FullName = `${string}:${string}`;
+
+  // TODO: when migrating into Ember proper, evaluate whether we should introduce
+  // a registry which users can provide to resolve known types, so e.g.
+  // `owner.lookup('service:session')` can return the right thing.
+  /**
+   * Framework objects in an Ember application (components, services, routes,
+   * etc.) are created via a factory and dependency injection system. Each of
+   * these objects is the responsibility of an "owner", which handled its
+   * instantiation and manages its lifetime.
+   */
+  export default interface Owner {
+    /**
+     * Given a {@linkcode FullName} return a corresponding instance.
+     */
+    lookup(fullName: FullName): unknown;
+
+    /**
+     * Registers a factory or value that can be used for dependency injection
+     * (with `inject`) or for service lookup. Each factory is registered with a
+     * full name including two parts: `'type:name'`.
+     *
+     * - To override the default of instantiating the class on the `Factory`,
+     *   pass the `{ instantiate: false }` option. This is useful when you have
+     *   already instantiated the class to use with this factory.
+     * - To override the default singleton behavior and instead create multiple
+     *   instances, pass the `{ singleton: false }` option.
+     */
+    // Dear future maintainer: yes, I know that `Factory<unknown> | object` is
+    // an exceedingly weird type here. This is how we type it internally in
+    // Ember itself. We actually allow more or less *anything* to be passed
+    // here. In the future, we may possibly be able to update this to actually
+    // take advantage of the `FullName` here to require that the registered
+    // factory and corresponding options do the right thing (passing an *actual*
+    // factory, not needing `create` if `options.instantiate` is `false`, etc.)
+    // but doing so will require rationalizing Ember's own internals and may
+    // need a full Ember RFC.
+    register(
+      fullName: FullName,
+      factory: Factory<unknown> | object,
+      options?: RegisterOptions
+    ): void;
+
+    /**
+     * Given a fullName of the form `'type:name'`, like `'route:application'`,
+     * return a corresponding factory manager.
+     *
+     * Any instances created via the factory's `.create()` method must be
+     * destroyed manually by the caller of `.create()`. Typically, this is done
+     * during the creating objects own `destroy` or `willDestroy` methods.
+     */
+    factoryFor(fullName: FullName): FactoryManager<unknown> | undefined;
+  }
+
+  export interface RegisterOptions {
+    instantiate?: boolean | undefined;
+    singleton?: boolean | undefined;
+  }
+
+  /**
+   * Registered factories are instantiated by having create called on them.
+   * Additionally they are singletons by default, so each time they are looked up
+   * they return the same instance.
+   *
+   * However, that behavior can be modified with the `instantiate` and `singleton`
+   * options to the {@linkcode Owner.register} method.
+   */
+  export interface Factory<T> {
+    /**
+     * A function that will create an instance of the class with any
+     * dependencies injected.
+     *
+     * @param initialValues Any values to set on an instance of the class
+     */
+    create(initialValues?: Partial<T>): T;
+  }
+
+  /**
+   * A manager which can be used for introspection of the factory's class or for
+   * the creation of factory instances with initial properties. The manager is an
+   * object with the following properties:
+   *
+   * - `class` - The registered or resolved class.
+   * - `create` - A function that will create an instance of the class with any
+   *   dependencies injected.
+   *
+   * @note `FactoryManager` is *not* user-constructible; the only legal way to get
+   *   a `FactoryManager` is via {@linkcode Owner.factoryFor}.
+   */
+  export interface FactoryManager<T> extends Factory<T> {
+    /** The registered or resolved class. */
+    readonly class: Factory<T>;
+  }
+
+  // Don't export things unless we *intend* to.
+  export {};
+}

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

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

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

@@ -0,0 +1,23 @@
+declare module '@ember/polyfills' {
+  import type { Mix, Mix3, Mix4 } from '@ember/polyfills/types';
+
+  /**
+   * Copy properties from a source object to a target object.
+   * @deprecated until v5.0. You should replace any calls to `Ember.assign` with
+   *   `Object.assign` or use the object spread operator.
+   */
+  export function assign<T extends object, U extends object>(target: T, source: U): Mix<T, U>;
+  export function assign<T extends object, U extends object, V extends object>(
+    target: T,
+    source1: U,
+    source2: V
+  ): Mix3<T, U, V>;
+  export function assign<T extends object, U extends object, V extends object, W extends object>(
+    target: T,
+    source1: U,
+    source2: V,
+    source3: W
+  ): Mix4<T, U, V, W>;
+  export function assign(target: object, ...sources: object[]): unknown;
+  export function assign(target: object, final: undefined | null): never;
+}

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

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

package/types/preview/@ember/polyfills/types.d.ts

@@ -0,0 +1,6 @@
+declare module '@ember/polyfills/types' {
+  export type Mix<A, B> = B & Pick<A, Exclude<keyof A, keyof B>>;
+  export type Mix3<A, B, C> = Mix<Mix<A, B>, C>;
+  export type Mix4<A, B, C, D> = Mix3<Mix<A, B>, C, D>;
+  export default Mix;
+}

package/types/preview/@ember/routing/-private/router-dsl.d.ts

@@ -0,0 +1,20 @@
+declare module '@ember/routing/-private/router-dsl' {
+  export default class RouterDSL {
+    constructor(name: string | null, options: object);
+    route(name: string, callback: (this: RouterDSL) => void): void;
+    route(
+      name: string,
+      options?: { path?: string | undefined; resetNamespace?: boolean | undefined },
+      callback?: (this: RouterDSL) => void
+    ): void;
+    mount(
+      name: string,
+      options?: {
+        as?: string | undefined;
+        path?: string | undefined;
+        resetNamespace?: boolean | undefined;
+        engineInfo?: unknown;
+      }
+    ): void;
+  }
+}

package/types/preview/@ember/routing/auto-location.d.ts

@@ -0,0 +1,8 @@
+declare module '@ember/routing/auto-location' {
+  import EmberObject from '@ember/object';
+
+  /**
+   * AutoLocation will select the best location option based off browser support with the priority order: history, hash, none.
+   */
+  export default class AutoLocation extends EmberObject {}
+}

package/types/preview/@ember/routing/hash-location.d.ts

@@ -0,0 +1,10 @@
+declare module '@ember/routing/hash-location' {
+  import EmberObject from '@ember/object';
+
+  /**
+   * `Ember.HashLocation` implements the location API using the browser's
+   * hash. At present, it relies on a `hashchange` event existing in the
+   * browser.
+   */
+  export default class HashLocation extends EmberObject {}
+}

package/types/preview/@ember/routing/history-location.d.ts

@@ -0,0 +1,9 @@
+declare module '@ember/routing/history-location' {
+  import EmberObject from '@ember/object';
+
+  /**
+   * Ember.HistoryLocation implements the location API using the browser's
+   * history.pushState API.
+   */
+  export default class HistoryLocation extends EmberObject {}
+}

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

@@ -0,0 +1,20 @@
+declare module '@ember/routing' {
+  export { default as Route } from '@ember/routing/route';
+  export { default as Router } from '@ember/routing/router';
+
+  import { Opaque } from 'ember/-private/type-utils';
+
+  // In normal TypeScript, this component 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 LinkTo extends Opaque<'component:link-to'> {}
+
+  /**
+   * The `LinkTo` component renders a link to the supplied `route` passing
+   * an optionally supplied model to the route as its `model` context of the route.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.components/methods/LinkTo?anchor=LinkTo
+   */
+  export const LinkTo: LinkTo;
+}

package/types/preview/@ember/routing/none-location.d.ts

@@ -0,0 +1,11 @@
+declare module '@ember/routing/none-location' {
+  import EmberObject from '@ember/object';
+
+  /**
+   * Ember.NoneLocation does not interact with the browser. It is useful for
+   * testing, or when you need to manage state with your Router, but temporarily
+   * don't want it to muck with the URL (for example when you embed your
+   * application in a larger page).
+   */
+  export default class NoneLocation extends EmberObject {}
+}

package/types/preview/@ember/routing/route-info.d.ts

@@ -0,0 +1,74 @@
+declare module '@ember/routing/route-info' {
+  // https://api.emberjs.com/ember/4.0/classes/RouteInfo
+  /**
+   * A `RouteInfo` is an object that contains metadata about a specific route within a `Transition`.
+   * It is read-only and internally immutable.
+   * It is also not observable, because a `Transition` instance is never changed after creation.
+   */
+  export default interface RouteInfo {
+    /**
+     * A reference to the childe route's `RouteInfo`.
+     * This can be used to traverse downward to the leafmost `RouteInfo`.
+     */
+    readonly child: RouteInfo | null;
+    /**
+     * The final segment of the fully-qualified name of the route, like "index".
+     */
+    readonly localName: string;
+    /**
+     * The dot-separated, fully-qualified name of the route, like "people.index".
+     */
+    readonly name: string;
+    /**
+     * The ordered list of the names of the params required for this route.
+     * It will contain the same strings as `Object.keys(params)`, but here the order is significant.
+     * This allows users to correctly pass params into routes programmatically.
+     */
+    readonly paramNames: string[];
+    /**
+     * The values of the route's parameters.
+     * These are the same params that are received as arguments to the route's `model` hook.
+     * Contains only the parameters valid for this route, if any (params for parent or child routes are not merged).
+     */
+    readonly params: { [key: string]: string | undefined };
+    /**
+     * A reference to the parent route's `RouteInfo`.
+     * This can be used to traverse upward to the topmost `RouteInfo`.
+     */
+    readonly parent: RouteInfo | null;
+    /**
+     * The values of any query params on this route.
+     */
+    readonly queryParams: { [key: string]: string | undefined };
+    /**
+     * Will contain the result `Route#buildRouteInfoMetadata`
+     * for the corresponding Route.
+     */
+    readonly metadata: unknown;
+    /**
+     * Allows you to traverse through the linked list of `RouteInfo`s from the topmost to leafmost.
+     * Returns the first `RouteInfo` in the linked list for which the callback returns true.
+     *
+     * @param callback the callback to execute.
+     */
+    find(callback: (item: RouteInfo) => boolean): RouteInfo | undefined;
+  }
+
+  // https://api.emberjs.com/ember/4.0/classes/RouteInfoWithAttributes
+  /**
+   * A `RouteInfoWithAttributes` is an object that contains
+   * metadata, including the resolved value from the routes
+   * `model` hook. Like `RouteInfo`, a `RouteInfoWithAttributes`
+   * represents a specific route within a Transition.
+   * It is read-only and internally immutable. It is also not
+   * observable, because a Transition instance is never
+   * changed after creation.
+   */
+  export interface RouteInfoWithAttributes extends RouteInfo {
+    /**
+     * This is the resolved return value from the
+     * route's model hook.
+     */
+    readonly attributes: unknown;
+  }
+}