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

package/types/stable/@ember/array/lib/make-array.d.ts

@@ -0,0 +1,34 @@
+declare module '@ember/array/lib/make-array.d.ts' {
+  /**
+   @module @ember/array
+  */
+  /**
+   Forces the passed object to be part of an array. If the object is already
+   an array, it will return the object. Otherwise, it will add the object to
+   an array. If object is `null` or `undefined`, it will return an empty array.
+
+   ```javascript
+   import { makeArray } from '@ember/array';
+   import ArrayProxy from '@ember/array/proxy';
+
+   makeArray();            // []
+   makeArray(null);        // []
+   makeArray(undefined);   // []
+   makeArray('lindsay');   // ['lindsay']
+   makeArray([1, 2, 42]);  // [1, 2, 42]
+
+   let proxy = ArrayProxy.create({ content: [] });
+
+   makeArray(proxy) === proxy;  // false
+   ```
+
+   @method makeArray
+   @static
+   @for @ember/array
+   @param {Object} obj the object
+   @return {Array}
+   @private
+   */
+  function makeArray<T, TT>(obj: T): T extends TT[] ? T : T extends null | undefined ? [] : [T];
+  export default makeArray;
+}

package/types/stable/@ember/array/mutable.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/array/mutable.d.ts' {
+  export { MutableArray as default } from '@ember/array';
+}

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

@@ -0,0 +1,158 @@
+declare module '@ember/array/proxy.d.ts' {
+  /**
+  @module @ember/array/proxy
+  */
+  import { PROPERTY_DID_CHANGE } from '@ember/-internals/metal';
+  import type { PropertyDidChange } from '@ember/-internals/metal';
+  import EmberObject from '@ember/object';
+  import EmberArray from '@ember/array';
+  import MutableArray from '@ember/array/mutable';
+  import { type Tag, type Revision } from '@glimmer/validator';
+  /**
+    An ArrayProxy wraps any other object that implements `Array` and/or
+    `MutableArray,` forwarding all requests. This makes it very useful for
+    a number of binding use cases or other cases where being able to swap
+    out the underlying array is useful.
+
+    A simple example of usage:
+
+    ```javascript
+    import { A } from '@ember/array';
+    import ArrayProxy from '@ember/array/proxy';
+
+    let pets = ['dog', 'cat', 'fish'];
+    let ap = ArrayProxy.create({ content: A(pets) });
+
+    ap.get('firstObject');                        // 'dog'
+    ap.set('content', ['amoeba', 'paramecium']);
+    ap.get('firstObject');                        // 'amoeba'
+    ```
+
+    This class can also be useful as a layer to transform the contents of
+    an array, as they are accessed. This can be done by overriding
+    `objectAtContent`:
+
+    ```javascript
+    import { A } from '@ember/array';
+    import ArrayProxy from '@ember/array/proxy';
+
+    let pets = ['dog', 'cat', 'fish'];
+    let ap = ArrayProxy.create({
+        content: A(pets),
+        objectAtContent: function(idx) {
+            return this.get('content').objectAt(idx).toUpperCase();
+        }
+    });
+
+    ap.get('firstObject'); // . 'DOG'
+    ```
+
+    When overriding this class, it is important to place the call to
+    `_super` *after* setting `content` so the internal observers have
+    a chance to fire properly:
+
+    ```javascript
+    import { A } from '@ember/array';
+    import ArrayProxy from '@ember/array/proxy';
+
+    export default ArrayProxy.extend({
+      init() {
+        this.set('content', A(['dog', 'cat', 'fish']));
+        this._super(...arguments);
+      }
+    });
+    ```
+
+    @class ArrayProxy
+    @extends EmberObject
+    @uses MutableArray
+    @public
+  */
+  interface ArrayProxy<T, C extends EmberArray<T> | T[] = T[]> extends MutableArray<T> {
+      /**
+        The content array. Must be an object that implements `Array` and/or
+        `MutableArray.`
+    
+        @property content
+        @type EmberArray
+        @public
+      */
+      content: C | null;
+      /**
+        The array that the proxy pretends to be. In the default `ArrayProxy`
+        implementation, this and `content` are the same. Subclasses of `ArrayProxy`
+        can override this property to provide things like sorting and filtering.
+    
+        @property arrangedContent
+        @public
+      */
+      arrangedContent: C | null;
+      /**
+        Should actually retrieve the object at the specified index from the
+        content. You can override this method in subclasses to transform the
+        content item to something new.
+    
+        This method will only be called if content is non-`null`.
+    
+        @method objectAtContent
+        @param {Number} idx The index to retrieve.
+        @return {Object} the value or undefined if none found
+        @public
+      */
+      objectAtContent(idx: number): T | undefined;
+      /**
+        Should actually replace the specified objects on the content array.
+        You can override this method in subclasses to transform the content item
+        into something new.
+    
+        This method will only be called if content is non-`null`.
+    
+        @method replaceContent
+        @param {Number} idx The starting index
+        @param {Number} amt The number of items to remove from the content.
+        @param {Array} objects Optional array of objects to insert.
+        @return {void}
+        @public
+      */
+      replaceContent(idx: number, amt: number, objects?: T[]): void;
+  }
+  class ArrayProxy<T, C extends EmberArray<T> | T[] = T[]> extends EmberObject implements PropertyDidChange {
+      /** @internal */
+      _objectsDirtyIndex: number;
+      /** @internal */
+      _objects: null | T[];
+      /** @internal */
+      _lengthDirty: boolean;
+      /** @internal */
+      _length: number;
+      /** @internal */
+      _arrangedContent: C | null;
+      /** @internal */
+      _arrangedContentIsUpdating: boolean;
+      /** @internal */
+      _arrangedContentTag: Tag | null;
+      /** @internal */
+      _arrangedContentRevision: Revision | null;
+      /** @internal */
+      _lengthTag: Tag | null;
+      /** @internal */
+      _arrTag: Tag | null;
+      init(props: object | undefined): void;
+      [PROPERTY_DID_CHANGE](): void;
+      willDestroy(): void;
+      content: C | null;
+      arrangedContent: C | null;
+      replace(idx: number, amt: number, objects?: T[]): void;
+      objectAt(idx: number): T | undefined;
+      get length(): number;
+      set length(value: number);
+      _updateArrangedContentArray(arrangedContent: C | null): void;
+      _addArrangedContentArrayObserver(arrangedContent: C | null): void;
+      _removeArrangedContentArrayObserver(): void;
+      _arrangedContentArrayWillChange(): void;
+      _arrangedContentArrayDidChange(_proxy: unknown, idx: number, removedCnt: number, addedCnt: number): void;
+      _invalidate(): void;
+      _revalidate(): void;
+  }
+  export default ArrayProxy;
+}

package/types/stable/@ember/canary-features/index.d.ts

@@ -0,0 +1,49 @@
+declare module '@ember/canary-features' {
+  /**
+    Set `EmberENV.FEATURES` in your application's `config/environment.js` file
+    to enable canary features in your application.
+
+    See the [feature flag guide](https://guides.emberjs.com/release/configuring-ember/feature-flags/)
+    for more details.
+
+    @module @ember/canary-features
+    @public
+  */
+  export const DEFAULT_FEATURES: {
+      EMBER_UNIQUE_ID_HELPER: boolean;
+      EMBER_DEFAULT_HELPER_MANAGER: boolean;
+  };
+  /**
+    The hash of enabled Canary features. Add to this, any canary features
+    before creating your application.
+
+    @class FEATURES
+    @static
+    @since 1.1.0
+    @public
+  */
+  export const FEATURES: {
+      EMBER_UNIQUE_ID_HELPER: boolean;
+      EMBER_DEFAULT_HELPER_MANAGER: boolean;
+  } & {
+      [feature: string]: boolean;
+  };
+  /**
+    Determine whether the specified `feature` is enabled. Used by Ember's
+    build tools to exclude experimental features from beta/stable builds.
+
+    You can define the following configuration options:
+
+    * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
+      enabled/disabled.
+
+    @method isEnabled
+    @param {String} feature The feature to check
+    @return {Boolean}
+    @since 1.1.0
+    @public
+  */
+  export function isEnabled(feature: string): boolean;
+  export const EMBER_UNIQUE_ID_HELPER: boolean | null;
+  export const EMBER_DEFAULT_HELPER_MANAGER: boolean | null;
+}

package/types/stable/@ember/component/helper.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/component/helper.d.ts' {
+  export { Helper as default, helper } from '@ember/-internals/glimmer';
+}

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

@@ -0,0 +1,5 @@
+declare module '@ember/component' {
+  export { setComponentTemplate, getComponentTemplate } from '@glimmer/manager';
+  export { Component as default, Input, Textarea } from '@ember/-internals/glimmer';
+  export { componentCapabilities as capabilities, setComponentManager, } from '@ember/-internals/glimmer';
+}

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

@@ -0,0 +1,33 @@
+declare module '@ember/component/template-only.d.ts' {
+  /**
+    @module @ember/component/template-only
+    @public
+  */
+  /**
+    This utility function is used to declare a given component has no backing class. When the rendering engine detects this it
+    is able to perform a number of optimizations. Templates that are associated with `templateOnly()` will be rendered _as is_
+    without adding a wrapping `<div>` (or any of the other element customization behaviors of [@ember/component](/ember/release/classes/Component)).
+    Specifically, this means that the template will be rendered as "outer HTML".
+
+    In general, this method will be used by build time tooling and would not be directly written in an application. However,
+    at times it may be useful to use directly to leverage the "outer HTML" semantics mentioned above. For example, if an addon would like
+    to use these semantics for its templates but cannot be certain it will only be consumed by applications that have enabled the
+    `template-only-glimmer-components` optional feature.
+
+    @example
+
+    ```js
+    import templateOnly from '@ember/component/template-only';
+
+    export default templateOnly();
+    ```
+
+    @public
+    @static
+    @method templateOnly
+    @param {String} moduleName the module name that the template only component represents, this will be used for debugging purposes
+    @for @ember/component/template-only
+    @category EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
+  */
+  export { templateOnlyComponent as default } from '@glimmer/runtime';
+}

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

@@ -0,0 +1,277 @@
+declare module '@ember/controller' {
+  import { FrameworkObject } from '@ember/object/-internals';
+  import type { DecoratorPropertyDescriptor, ElementDescriptor } from '@ember/-internals/metal';
+  import Mixin from '@ember/object/mixin';
+  import type { RouteArgs } from '@ember/routing/-internals';
+  import { ActionHandler } from '@ember/-internals/runtime';
+  import type Route from '@ember/routing/route';
+  import type { Transition } from 'router_js';
+  export type ControllerQueryParamType = 'boolean' | 'number' | 'array' | 'string';
+  export type ControllerQueryParam = string | Record<string, {
+      type: ControllerQueryParamType;
+  }>;
+  /**
+  @module ember/controller
+  */
+  /**
+    @class ControllerMixin
+    @namespace Ember
+    @uses Ember.ActionHandler
+    @private
+  */
+  interface ControllerMixin<T> extends ActionHandler {
+      /** @internal */
+      _qpDelegate: unknown | null;
+      isController: true;
+      /**
+        The object to which actions from the view should be sent.
+    
+        For example, when a Handlebars template uses the `{{action}}` helper,
+        it will attempt to send the action to the view's controller's `target`.
+    
+        By default, the value of the target property is set to the router, and
+        is injected when a controller is instantiated. This injection is applied
+        as part of the application's initialization process. In most cases the
+        `target` property will automatically be set to the logical consumer of
+        actions for the controller.
+    
+        @property target
+        @default null
+        @public
+      */
+      target: unknown | null;
+      /**
+        The controller's current model. When retrieving or modifying a controller's
+        model, this property should be used instead of the `content` property.
+    
+        @property model
+        @public
+      */
+      model: T;
+      /**
+        Defines which query parameters the controller accepts.
+        If you give the names `['category','page']` it will bind
+        the values of these query parameters to the variables
+        `this.category` and `this.page`.
+    
+        By default, query parameters are parsed as strings. This
+        may cause unexpected behavior if a query parameter is used with `toggleProperty`,
+        because the initial value set for `param=false` will be the string `"false"`, which is truthy.
+    
+        To avoid this, you may specify that the query parameter should be parsed as a boolean
+        by using the following verbose form with a `type` property:
+        ```javascript
+          queryParams: [{
+            category: {
+              type: 'boolean'
+            }
+          }]
+        ```
+        Available values for the `type` parameter are `'boolean'`, `'number'`, `'array'`, and `'string'`.
+        If query param type is not specified, it will default to `'string'`.
+    
+        @for Ember.ControllerMixin
+        @property queryParams
+        @public
+      */
+      queryParams: Readonly<Array<ControllerQueryParam>>;
+      /**
+        Transition the application into another route. The route may
+        be either a single route or route path:
+    
+        ```javascript
+        aController.transitionToRoute('blogPosts');
+        aController.transitionToRoute('blogPosts.recentEntries');
+        ```
+    
+        Optionally supply a model for the route in question. The model
+        will be serialized into the URL using the `serialize` hook of
+        the route:
+    
+        ```javascript
+        aController.transitionToRoute('blogPost', aPost);
+        ```
+    
+        If a literal is passed (such as a number or a string), it will
+        be treated as an identifier instead. In this case, the `model`
+        hook of the route will be triggered:
+    
+        ```javascript
+        aController.transitionToRoute('blogPost', 1);
+        ```
+    
+        Multiple models will be applied last to first recursively up the
+        route tree.
+    
+        ```app/router.js
+        Router.map(function() {
+          this.route('blogPost', { path: ':blogPostId' }, function() {
+            this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
+          });
+        });
+        ```
+    
+        ```javascript
+        aController.transitionToRoute('blogComment', aPost, aComment);
+        aController.transitionToRoute('blogComment', 1, 13);
+        ```
+    
+        It is also possible to pass a URL (a string that starts with a
+        `/`).
+    
+        ```javascript
+        aController.transitionToRoute('/');
+        aController.transitionToRoute('/blog/post/1/comment/13');
+        aController.transitionToRoute('/blog/posts?sort=title');
+        ```
+    
+        An options hash with a `queryParams` property may be provided as
+        the final argument to add query parameters to the destination URL.
+    
+        ```javascript
+        aController.transitionToRoute('blogPost', 1, {
+          queryParams: { showComments: 'true' }
+        });
+    
+        // if you just want to transition the query parameters without changing the route
+        aController.transitionToRoute({ queryParams: { sort: 'date' } });
+        ```
+    
+        See also [replaceRoute](/ember/release/classes/Ember.ControllerMixin/methods/replaceRoute?anchor=replaceRoute).
+    
+        @for Ember.ControllerMixin
+        @method transitionToRoute
+        @deprecated Use transitionTo from the Router service instead.
+        @param {String} [name] the name of the route or a URL
+        @param {...Object} models the model(s) or identifier(s) to be used
+          while transitioning to the route.
+        @param {Object} [options] optional hash with a queryParams property
+          containing a mapping of query parameters
+        @return {Transition} the transition object associated with this
+          attempted transition
+        @public
+      */
+      transitionToRoute(...args: RouteArgs<Route>): Transition;
+      /**
+        Transition into another route while replacing the current URL, if possible.
+        This will replace the current history entry instead of adding a new one.
+        Beside that, it is identical to `transitionToRoute` in all other respects.
+    
+        ```javascript
+        aController.replaceRoute('blogPosts');
+        aController.replaceRoute('blogPosts.recentEntries');
+        ```
+    
+        Optionally supply a model for the route in question. The model
+        will be serialized into the URL using the `serialize` hook of
+        the route:
+    
+        ```javascript
+        aController.replaceRoute('blogPost', aPost);
+        ```
+    
+        If a literal is passed (such as a number or a string), it will
+        be treated as an identifier instead. In this case, the `model`
+        hook of the route will be triggered:
+    
+        ```javascript
+        aController.replaceRoute('blogPost', 1);
+        ```
+    
+        Multiple models will be applied last to first recursively up the
+        route tree.
+    
+        ```app/router.js
+        Router.map(function() {
+          this.route('blogPost', { path: ':blogPostId' }, function() {
+            this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
+          });
+        });
+        ```
+    
+        ```
+        aController.replaceRoute('blogComment', aPost, aComment);
+        aController.replaceRoute('blogComment', 1, 13);
+        ```
+    
+        It is also possible to pass a URL (a string that starts with a
+        `/`).
+    
+        ```javascript
+        aController.replaceRoute('/');
+        aController.replaceRoute('/blog/post/1/comment/13');
+        ```
+    
+        @for Ember.ControllerMixin
+        @method replaceRoute
+        @deprecated Use replaceWith from the Router service instead.
+        @param {String} [name] the name of the route or a URL
+        @param {...Object} models the model(s) or identifier(s) to be used
+        while transitioning to the route.
+        @param {Object} [options] optional hash with a queryParams property
+        containing a mapping of query parameters
+        @return {Transition} the transition object associated with this
+          attempted transition
+        @public
+      */
+      replaceRoute(...args: RouteArgs<Route>): Transition;
+  }
+  const ControllerMixin: Mixin;
+  /**
+    @class Controller
+    @extends EmberObject
+    @uses Ember.ControllerMixin
+    @public
+  */
+  interface Controller<T = unknown> extends FrameworkObject, ControllerMixin<T> {
+  }
+  const Controller_base: Readonly<typeof import("@ember/object").default> & (new (owner?: import("@ember/-internals/owner").default | undefined) => import("@ember/object").default);
+  class Controller<T = unknown> extends Controller_base {
+  }
+  /**
+    Creates a property that lazily looks up another controller in the container.
+    Can only be used when defining another controller.
+
+    Example:
+
+    ```app/controllers/post.js
+    import Controller, {
+      inject as controller
+    } from '@ember/controller';
+
+    export default class PostController extends Controller {
+      @controller posts;
+    }
+    ```
+
+    Classic Class Example:
+
+    ```app/controllers/post.js
+    import Controller, {
+      inject as controller
+    } from '@ember/controller';
+
+    export default Controller.extend({
+      posts: controller()
+    });
+    ```
+
+    This example will create a `posts` property on the `post` controller that
+    looks up the `posts` controller in the container, making it easy to reference
+    other controllers.
+
+    @method inject
+    @static
+    @for @ember/controller
+    @since 1.10.0
+    @param {String} name (optional) name of the controller to inject, defaults to
+           the property's name
+    @return {ComputedDecorator} injection decorator instance
+    @public
+  */
+  export function inject(name: string): PropertyDecorator;
+  export function inject(...args: [ElementDescriptor[0], ElementDescriptor[1]]): void;
+  export function inject(...args: ElementDescriptor): DecoratorPropertyDescriptor;
+  export function inject(): PropertyDecorator;
+  export { Controller as default, ControllerMixin };
+}

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

@@ -0,0 +1,73 @@
+declare module '@ember/debug/container-debug-adapter.d.ts' {
+  import EmberObject from '@ember/object';
+  import type Owner from '@ember/owner';
+  import type { Resolver } from '@ember/owner';
+  /**
+  @module @ember/debug/container-debug-adapter
+  */
+  /**
+    The `ContainerDebugAdapter` helps the container and resolver interface
+    with tools that debug Ember such as the
+    [Ember Inspector](https://github.com/emberjs/ember-inspector)
+    for Chrome and Firefox.
+
+    This class can be extended by a custom resolver implementer
+    to override some of the methods with library-specific code.
+
+    The methods likely to be overridden are:
+
+    * `canCatalogEntriesByType`
+    * `catalogEntriesByType`
+
+    The adapter will need to be registered
+    in the application's container as `container-debug-adapter:main`.
+
+    Example:
+
+    ```javascript
+    Application.initializer({
+      name: "containerDebugAdapter",
+
+      initialize(application) {
+        application.register('container-debug-adapter:main', require('app/container-debug-adapter'));
+      }
+    });
+    ```
+
+    @class ContainerDebugAdapter
+    @extends EmberObject
+    @since 1.5.0
+    @public
+  */
+  export default class ContainerDebugAdapter extends EmberObject {
+      constructor(owner: Owner);
+      /**
+        The resolver instance of the application
+        being debugged. This property will be injected
+        on creation.
+    
+        @property resolver
+        @public
+      */
+      resolver: Resolver;
+      /**
+        Returns true if it is possible to catalog a list of available
+        classes in the resolver for a given type.
+    
+        @method canCatalogEntriesByType
+        @param {String} type The type. e.g. "model", "controller", "route".
+        @return {boolean} whether a list is available for this type.
+        @public
+      */
+      canCatalogEntriesByType(type: string): boolean;
+      /**
+        Returns the available classes a given type.
+    
+        @method catalogEntriesByType
+        @param {String} type The type. e.g. "model", "controller", "route".
+        @return {Array} An array of strings.
+        @public
+      */
+      catalogEntriesByType(type: string): string[];
+  }
+}