ember-source 4.10.0-beta.2 → 4.11.0-alpha.2

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

@@ -0,0 +1,88 @@
+declare module '@ember/object/proxy.d.ts' {
+  /**
+  @module @ember/object/proxy
+  */
+  import { FrameworkObject } from '@ember/object/-internals';
+  import { _ProxyMixin } from '@ember/-internals/runtime';
+  /**
+    `ObjectProxy` forwards all properties not defined by the proxy itself
+    to a proxied `content` object.
+
+    ```javascript
+    import EmberObject from '@ember/object';
+    import ObjectProxy from '@ember/object/proxy';
+
+    let exampleObject = EmberObject.create({
+      name: 'Foo'
+    });
+
+    let exampleProxy = ObjectProxy.create({
+      content: exampleObject
+    });
+
+    // Access and change existing properties
+    exampleProxy.get('name');          // 'Foo'
+    exampleProxy.set('name', 'Bar');
+    exampleObject.get('name');         // 'Bar'
+
+    // Create new 'description' property on `exampleObject`
+    exampleProxy.set('description', 'Foo is a whizboo baz');
+    exampleObject.get('description');  // 'Foo is a whizboo baz'
+    ```
+
+    While `content` is unset, setting a property to be delegated will throw an
+    Error.
+
+    ```javascript
+    import ObjectProxy from '@ember/object/proxy';
+
+    let exampleProxy = ObjectProxy.create({
+      content: null,
+      flag: null
+    });
+    exampleProxy.set('flag', true);
+    exampleProxy.get('flag');         // true
+    exampleProxy.get('foo');          // undefined
+    exampleProxy.set('foo', 'data');  // throws Error
+    ```
+
+    Delegated properties can be bound to and will change when content is updated.
+
+    Computed properties on the proxy itself can depend on delegated properties.
+
+    ```javascript
+    import { computed } from '@ember/object';
+    import ObjectProxy from '@ember/object/proxy';
+
+    ProxyWithComputedProperty = ObjectProxy.extend({
+      fullName: computed('firstName', 'lastName', function() {
+        var firstName = this.get('firstName'),
+            lastName = this.get('lastName');
+        if (firstName && lastName) {
+          return firstName + ' ' + lastName;
+        }
+        return firstName || lastName;
+      })
+    });
+
+    let exampleProxy = ProxyWithComputedProperty.create();
+
+    exampleProxy.get('fullName');  // undefined
+    exampleProxy.set('content', {
+      firstName: 'Tom', lastName: 'Dale'
+    }); // triggers property change for fullName on proxy
+
+    exampleProxy.get('fullName');  // 'Tom Dale'
+    ```
+
+    @class ObjectProxy
+    @extends EmberObject
+    @uses Ember.ProxyMixin
+    @public
+  */
+  interface ObjectProxy extends _ProxyMixin {
+  }
+  class ObjectProxy extends FrameworkObject {
+  }
+  export default ObjectProxy;
+}

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

@@ -0,0 +1,80 @@
+declare module '@ember/owner' {
+  /**
+    Ember’s dependency injection system is built on the idea of an "owner": an
+    object responsible for managing items which can be registered and looked up
+    with the system.
+
+    This module does not provide any concrete instances of owners. Instead, it
+    defines the core type, `Owner`, which specifies the public API contract for an
+    owner. The primary concrete implementations of `Owner` are `EngineInstance`,
+    from `@ember/engine/instance`, and its `ApplicationInstance` subclass, from
+    `@ember/application/instance`.
+
+    Along with `Owner` itself, this module provides a number of supporting types
+    related to Ember's DI system:
+
+    - `Factory`, Ember's primary interface for something which can create class
+      instances registered with the DI system.
+
+    - `FactoryManager`, an interface for inspecting a `Factory`'s class.
+
+    - `Resolver`, an interface defining the contract for the object responsible
+      for mapping string names to the corresponding classes. For example, when you
+      write `@service('session')`, a resolver is responsible to map that back to
+      the `Session` service class in your codebase. Normally, this is handled for
+      you automatically with `ember-resolver`, which is the main implementor of
+      this interface.
+
+    For more details on each, see their per-item docs.
+
+    @module @ember/owner
+    @public
+  */
+  import Owner from '@ember/-internals/owner';
+  /**
+    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.
+
+    `getOwner` fetches the owner object responsible for an instance. This can
+    be used to lookup or resolve other class instances, or register new factories
+    into the owner.
+
+    For example, this component dynamically looks up a service based on the
+    `audioType` passed as an argument:
+
+    ```app/components/play-audio.js
+    import Component from '@glimmer/component';
+    import { action } from '@ember/object';
+    import { getOwner } from '@ember/application';
+
+    // Usage:
+    //
+    //   <PlayAudio @audioType={{@model.audioType}} @audioFile={{@model.file}}/>
+    //
+    export default class extends Component {
+      get audioService() {
+        return getOwner(this)?.lookup(`service:${this.args.audioType}`);
+      }
+
+      @action
+      onPlay() {
+        this.audioService?.play(this.args.audioFile);
+      }
+    }
+    ```
+
+    @method getOwner
+    @static
+    @for @ember/owner
+    @param {Object} object An object with an owner.
+    @return {Object} An owner object.
+    @since 2.3.0
+    @public
+  */
+  const getOwner: (object: object) => Owner | undefined;
+  export { getOwner };
+  export default Owner;
+  export { setOwner, FullName, RegisterOptions, Factory, FactoryManager, KnownForTypeResult, Resolver, DIRegistry, } from '@ember/-internals/owner';
+}

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

@@ -0,0 +1,4 @@
+declare module '@ember/polyfills' {
+  export { assign } from './lib/assign';
+  export const hasPropertyAccessors = true;
+}

package/types/stable/@ember/polyfills/lib/assign.d.ts

@@ -0,0 +1,9 @@
+declare module '@ember/polyfills/lib/assign.d.ts' {
+  /**
+   @module @ember/polyfills
+  */
+  export function assign<T, U>(target: T, source: U): T & U;
+  export function assign<T, U, V>(target: T, source1: U, source2: V): T & U & V;
+  export function assign<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+  export function assign(target: object, ...sources: object[]): object;
+}

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

@@ -0,0 +1,28 @@
+declare module '@ember/renderer' {
+  /**
+    @module @ember/renderer
+    @public
+  */
+  /**
+   * @class Renderer
+   * @public
+   */
+  /**
+    Returns a promise which will resolve when rendering has completed. In
+    this context, rendering is completed when all auto-tracked state that is
+    consumed in the template (including any tracked state in models, services,
+      etc.  that are then used in a template) has been updated in the DOM.
+
+      For example, in a test you might want to update some tracked state and
+      then run some assertions after rendering has completed. You _could_ use
+      `await settled()` in that location, but in some contexts you don't want to
+      wait for full settledness (which includes test waiters, pending AJAX/fetch,
+      run loops, etc) but instead only want to know when that updated value has
+      been rendered in the DOM. **THAT** is what `await renderSettled()` is _perfect_
+      for.
+    @method renderSettled
+    @returns {Promise<void>} a promise which fulfills when rendering has completed
+    @public
+  */
+  export { renderSettled } from '@ember/-internals/glimmer';
+}

package/types/stable/@ember/routing/-internals.d.ts

@@ -0,0 +1,11 @@
+declare module '@ember/routing/-internals.d.ts' {
+  export { default as RouterState } from './lib/router_state';
+  export { default as RoutingService } from './lib/routing-service';
+  export { RouteArgs, deprecateTransitionMethods, prefixRouteNameArg } from './lib/utils';
+  export { default as generateController, generateControllerFactory, } from './lib/generate_controller';
+  export { default as BucketCache } from './lib/cache';
+  export { default as DSL, DSLCallback } from './lib/dsl';
+  export { EngineRouteInfo } from './lib/engines';
+  export { RouteInfo, RouteInfoWithAttributes } from './lib/route-info';
+  export { default as controllerFor } from './lib/controller_for';
+}

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

@@ -0,0 +1,149 @@
+declare module '@ember/routing/auto-location.d.ts' {
+  import EmberObject from '@ember/object';
+  import type { ILocation as EmberLocation, UpdateCallback } from '@ember/routing/location';
+  /**
+  @module @ember/routing/auto-location
+  */
+  /**
+    AutoLocation will select the best location option based off browser
+    support with the priority order: history, hash, none.
+
+    Clean pushState paths accessed by hashchange-only browsers will be redirected
+    to the hash-equivalent and vice versa so future transitions are consistent.
+
+    Keep in mind that since some of your users will use `HistoryLocation`, your
+    server must serve the Ember app at all the routes you define.
+
+    Browsers that support the `history` API will use `HistoryLocation`, those that
+    do not, but still support the `hashchange` event will use `HashLocation`, and
+    in the rare case neither is supported will use `NoneLocation`.
+
+    Example:
+
+    ```app/router.js
+    Router.map(function() {
+      this.route('posts', function() {
+        this.route('new');
+      });
+    });
+
+    Router.reopen({
+      location: 'auto'
+    });
+    ```
+
+    This will result in a posts.new url of `/posts/new` for modern browsers that
+    support the `history` api or `/#/posts/new` for older ones, like Internet
+    Explorer 9 and below.
+
+    When a user visits a link to your application, they will be automatically
+    upgraded or downgraded to the appropriate `Location` class, with the URL
+    transformed accordingly, if needed.
+
+    Keep in mind that since some of your users will use `HistoryLocation`, your
+    server must serve the Ember app at all the routes you define.
+
+    @class AutoLocation
+    @static
+    @protected
+  */
+  export default class AutoLocation extends EmberObject implements EmberLocation {
+      getURL: () => string;
+      setURL: (url: string) => void;
+      onUpdateURL: (callback: UpdateCallback) => void;
+      formatURL: (url: string) => string;
+      concreteImplementation?: EmberLocation;
+      implementation: string;
+      /** @internal */
+      documentMode: number | undefined;
+      /**
+        @private
+    
+        Will be pre-pended to path upon state change.
+    
+        @since 1.5.1
+        @property rootURL
+        @default '/'
+      */
+      rootURL: string;
+      /**
+        @private
+    
+        The browser's `location` object. This is typically equivalent to
+        `window.location`, but may be overridden for testing.
+    
+        @property location
+        @default environment.location
+      */
+      location: Location;
+      /**
+        @private
+    
+        The browser's `history` object. This is typically equivalent to
+        `window.history`, but may be overridden for testing.
+    
+        @since 1.5.1
+        @property history
+        @default environment.history
+      */
+      history: any;
+      /**
+       @private
+    
+        The user agent's global variable. In browsers, this will be `window`.
+    
+        @since 1.11
+        @property global
+        @default window
+      */
+      global: any;
+      /**
+        @private
+    
+        The browser's `userAgent`. This is typically equivalent to
+        `navigator.userAgent`, but may be overridden for testing.
+    
+        @since 1.5.1
+        @property userAgent
+        @default environment.history
+      */
+      userAgent: string;
+      /**
+        @private
+    
+        This property is used by the router to know whether to cancel the routing
+        setup process, which is needed while we redirect the browser.
+    
+        @since 1.5.1
+        @property cancelRouterSetup
+        @default false
+      */
+      cancelRouterSetup: boolean;
+      /**
+       Called by the router to instruct the location to do any feature detection
+       necessary. In the case of AutoLocation, we detect whether to use history
+       or hash concrete implementations.
+    
+       @private
+      */
+      detect(): void;
+      willDestroy(): void;
+  }
+  /**
+    @private
+
+    Returns the current path as it should appear for HistoryLocation supported
+    browsers. This may very well differ from the real current path (e.g. if it
+    starts off as a hashed URL)
+  */
+  export function getHistoryPath(rootURL: string, location: Location): string;
+  /**
+    @private
+
+    Returns the current path as it should appear for HashLocation supported
+    browsers. This may very well differ from the real current path.
+
+    @method _getHashPath
+  */
+  export function getHashPath(rootURL: string, location: Location): string;
+}

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

@@ -0,0 +1,113 @@
+declare module '@ember/routing/hash-location.d.ts' {
+  import EmberObject from '@ember/object';
+  import type { ILocation as EmberLocation, UpdateCallback } from '@ember/routing/location';
+  /**
+  @module @ember/routing/hash-location
+  */
+  /**
+    `HashLocation` implements the location API using the browser's
+    hash. At present, it relies on a `hashchange` event existing in the
+    browser.
+
+    Using `HashLocation` results in URLs with a `#` (hash sign) separating the
+    server side URL portion of the URL from the portion that is used by Ember.
+
+    Example:
+
+    ```app/router.js
+    Router.map(function() {
+      this.route('posts', function() {
+        this.route('new');
+      });
+    });
+
+    Router.reopen({
+      location: 'hash'
+    });
+    ```
+
+    This will result in a posts.new url of `/#/posts/new`.
+
+    @class HashLocation
+    @extends EmberObject
+    @protected
+  */
+  export default class HashLocation extends EmberObject implements EmberLocation {
+      implementation: string;
+      _hashchangeHandler?: EventListener;
+      private _location?;
+      location: Location;
+      init(): void;
+      /**
+        @private
+    
+        Returns normalized location.hash
+    
+        @since 1.5.1
+        @method getHash
+      */
+      getHash(): string;
+      /**
+        Returns the normalized URL, constructed from `location.hash`.
+    
+        e.g. `#/foo` => `/foo` as well as `#/foo#bar` => `/foo#bar`.
+    
+        By convention, hashed paths must begin with a forward slash, otherwise they
+        are not treated as a path so we can distinguish intent.
+    
+        @private
+        @method getURL
+      */
+      getURL(): string;
+      /**
+        Set the `location.hash` and remembers what was set. This prevents
+        `onUpdateURL` callbacks from triggering when the hash was set by
+        `HashLocation`.
+    
+        @private
+        @method setURL
+        @param path {String}
+      */
+      setURL(path: string): void;
+      /**
+        Uses location.replace to update the url without a page reload
+        or history modification.
+    
+        @private
+        @method replaceURL
+        @param path {String}
+      */
+      replaceURL(path: string): void;
+      lastSetURL: string | null;
+      /**
+        Register a callback to be invoked when the hash changes. These
+        callbacks will execute when the user presses the back or forward
+        button, but not after `setURL` is invoked.
+    
+        @private
+        @method onUpdateURL
+        @param callback {Function}
+      */
+      onUpdateURL(callback: UpdateCallback): void;
+      /**
+        Given a URL, formats it to be placed into the page as part
+        of an element's `href` attribute.
+    
+        This is used, for example, when using the {{action}} helper
+        to generate a URL based on an event.
+    
+        @private
+        @method formatURL
+        @param url {String}
+      */
+      formatURL(url: string): string;
+      /**
+        Cleans up the HashLocation event listener.
+    
+        @private
+        @method willDestroy
+      */
+      willDestroy(): void;
+      _removeEventListener(): void;
+  }
+}

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

@@ -0,0 +1,143 @@
+declare module '@ember/routing/history-location.d.ts' {
+  import EmberObject from '@ember/object';
+  import type { ILocation as EmberLocation, UpdateCallback } from '@ember/routing/location';
+  /**
+    HistoryLocation implements the location API using the browser's
+    history.pushState API.
+
+    Using `HistoryLocation` results in URLs that are indistinguishable from a
+    standard URL. This relies upon the browser's `history` API.
+
+    Example:
+
+    ```app/router.js
+    Router.map(function() {
+      this.route('posts', function() {
+        this.route('new');
+      });
+    });
+
+    Router.reopen({
+      location: 'history'
+    });
+    ```
+
+    This will result in a posts.new url of `/posts/new`.
+
+    Keep in mind that your server must serve the Ember app at all the routes you
+    define.
+
+    Using `HistoryLocation` will also result in location states being recorded by
+    the browser `history` API with the following schema:
+
+    ```
+    window.history.state -> { path: '/', uuid: '3552e730-b4a6-46bd-b8bf-d8c3c1a97e0a' }
+    ```
+
+    This allows each in-app location state to be tracked uniquely across history
+    state changes via the `uuid` field.
+
+    @class HistoryLocation
+    @extends EmberObject
+    @protected
+  */
+  export default class HistoryLocation extends EmberObject implements EmberLocation {
+      location: Location;
+      baseURL: string;
+      history?: any;
+      implementation: string;
+      _previousURL?: string;
+      _popstateHandler?: EventListener;
+      /**
+        Will be pre-pended to path upon state change
+    
+        @property rootURL
+        @default '/'
+        @private
+      */
+      rootURL: string;
+      /**
+        @private
+    
+        Returns normalized location.hash
+    
+        @method getHash
+      */
+      getHash(): string;
+      init(): void;
+      /**
+        Used to set state on first call to setURL
+    
+        @private
+        @method initState
+      */
+      initState(): void;
+      /**
+        Returns the current `location.pathname` without `rootURL` or `baseURL`
+    
+        @private
+        @method getURL
+        @return url {String}
+      */
+      getURL(): string;
+      /**
+        Uses `history.pushState` to update the url without a page reload.
+    
+        @private
+        @method setURL
+        @param path {String}
+      */
+      setURL(path: string): void;
+      /**
+        Uses `history.replaceState` to update the url without a page reload
+        or history modification.
+    
+        @private
+        @method replaceURL
+        @param path {String}
+      */
+      replaceURL(path: string): void;
+      /**
+       Pushes a new state.
+    
+       @private
+       @method pushState
+       @param path {String}
+      */
+      pushState(path: string): void;
+      /**
+       Replaces the current state.
+    
+       @private
+       @method replaceState
+       @param path {String}
+      */
+      replaceState(path: string): void;
+      /**
+        Register a callback to be invoked whenever the browser
+        history changes, including using forward and back buttons.
+    
+        @private
+        @method onUpdateURL
+        @param callback {Function}
+      */
+      onUpdateURL(callback: UpdateCallback): void;
+      /**
+        Used when using `{{action}}` helper.  The url is always appended to the rootURL.
+    
+        @private
+        @method formatURL
+        @param url {String}
+        @return formatted url {String}
+      */
+      formatURL(url: string): string;
+      /**
+        Cleans up the HistoryLocation event listener.
+    
+        @private
+        @method willDestroy
+      */
+      willDestroy(): void;
+      _removeEventListener(): void;
+  }
+}

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

@@ -0,0 +1,3 @@
+declare module '@ember/routing' {
+  export { LinkTo } from '@ember/-internals/glimmer';
+}

package/types/stable/@ember/routing/lib/cache.d.ts

@@ -0,0 +1,16 @@
+declare module '@ember/routing/lib/cache.d.ts' {
+  /**
+    A two-tiered cache with support for fallback values when doing lookups.
+    Uses "buckets" and then "keys" to cache values.
+
+    @private
+    @class BucketCache
+  */
+  export default class BucketCache {
+      cache: Map<string, Map<string, any>>;
+      constructor();
+      has(bucketKey: string): boolean;
+      stash(bucketKey: string, key: string, value: any): void;
+      lookup(bucketKey: string, prop: string, defaultValue: any): any;
+  }
+}

package/types/stable/@ember/routing/lib/controller_for.d.ts

@@ -0,0 +1,15 @@
+declare module '@ember/routing/lib/controller_for.d.ts' {
+  import type { Container } from '@ember/-internals/container';
+  import type { RegisterOptions } from '@ember/owner';
+  /**
+    @module ember/routing
+  */
+  /**
+    Finds a controller instance.
+
+    @for Ember
+    @method controllerFor
+    @private
+  */
+  export default function controllerFor(container: Container, controllerName: string, lookupOptions: RegisterOptions): object | import("../../-internals/owner").InternalFactory<object, import("../../-internals/owner").FactoryClass> | undefined;
+}