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

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

@@ -0,0 +1,52 @@
+declare module '@ember/routing/lib/dsl.d.ts' {
+  import type { InternalFactory } from '@ember/-internals/owner';
+  import type { MatchCallback } from 'route-recognizer';
+  import type { EngineInfo, EngineRouteInfo } from './engines';
+  export interface RouteOptions {
+      path?: string;
+      resetNamespace?: boolean;
+      serialize?: (model: {}, params: string[]) => {
+          [key: string]: unknown | undefined;
+      };
+      overrideNameAssertion?: boolean;
+  }
+  export interface MountOptions {
+      path?: string;
+      as?: string;
+      resetNamespace?: boolean;
+  }
+  export interface DSLCallback {
+      (this: DSL): void;
+  }
+  export interface DSL {
+      route(name: string): void;
+      route(name: string, callback: DSLCallback): void;
+      route(name: string, options: RouteOptions): void;
+      route(name: string, options: RouteOptions, callback: DSLCallback): void;
+      mount(name: string): void;
+      mount(name: string, options: MountOptions): void;
+  }
+  export interface DSLImplOptions {
+      enableLoadingSubstates: boolean;
+      engineInfo?: EngineInfo;
+      addRouteForEngine(name: string, routeOptions: EngineRouteInfo): void;
+      resolveRouteMap(name: string): InternalFactory<any, any>;
+  }
+  export default class DSLImpl implements DSL {
+      parent: string | null;
+      matches: Array<Object | undefined>;
+      enableLoadingSubstates: boolean;
+      explicitIndex: boolean;
+      options: DSLImplOptions;
+      constructor(name: string | null | undefined, options: DSLImplOptions);
+      route(name: string): void;
+      route(name: string, callback: DSLCallback): void;
+      route(name: string, options: RouteOptions): void;
+      route(name: string, options: RouteOptions, callback: DSLCallback): void;
+      push(url: string, name: string, callback?: MatchCallback, serialize?: (model: {}, params: string[]) => {
+          [key: string]: unknown | undefined;
+      }): void;
+      generate(): MatchCallback;
+      mount(_name: string, options?: MountOptions): void;
+  }
+}

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

@@ -0,0 +1,14 @@
+declare module '@ember/routing/lib/engines.d.ts' {
+  export interface EngineInfo {
+      name: string;
+      instanceId: number;
+      mountPoint: string;
+      fullName: string;
+  }
+  export interface EngineRouteInfo extends EngineInfo {
+      localFullName: string;
+      serializeMethod?: (model: {}, params: string[]) => {
+          [key: string]: unknown | undefined;
+      };
+  }
+}

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

@@ -0,0 +1,25 @@
+declare module '@ember/routing/lib/generate_controller.d.ts' {
+  import type { InternalFactory, default as Owner } from '@ember/-internals/owner';
+  import Controller from '@ember/controller';
+  /**
+   @module ember/routing
+  */
+  /**
+    Generates a controller factory
+
+    @for Ember
+    @method generateControllerFactory
+    @private
+  */
+  export function generateControllerFactory(owner: Owner, controllerName: string): InternalFactory<{}>;
+  /**
+    Generates and instantiates a controller extending from `controller:basic`
+    if present, or `Controller` if not.
+
+    @for Ember
+    @method generateController
+    @private
+    @since 1.3.0
+  */
+  export default function generateController(owner: Owner, controllerName: string): Controller;
+}

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

@@ -0,0 +1,31 @@
+declare module '@ember/routing/lib/location-utils.d.ts' {
+  /**
+    @private
+
+    Returns the current `location.pathname`, normalized for IE inconsistencies.
+  */
+  export function getPath(location: Location): string;
+  /**
+    @private
+
+    Returns the current `location.search`.
+  */
+  export function getQuery(location: Location): string;
+  /**
+    @private
+
+    Returns the hash or empty string
+  */
+  export function getHash(location: Location): string;
+  export function getFullPath(location: Location): string;
+  export function getOrigin(location: Location): string;
+  export function supportsHashChange(documentMode: number | undefined, global: Window | null): boolean;
+  export function supportsHistory(userAgent: string, history: History): boolean;
+  /**
+    Replaces the current location, making sure we explicitly include the origin
+    to prevent redirecting to a different origin.
+
+    @private
+  */
+  export function replacePath(location: Location, path: string): void;
+}

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

@@ -0,0 +1,7 @@
+declare module '@ember/routing/lib/query_params.d.ts' {
+  export default class QueryParams {
+      values: null | object;
+      isQueryParams: boolean;
+      constructor(values?: null);
+  }
+}

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

@@ -0,0 +1,3 @@
+declare module '@ember/routing/lib/route-info.d.ts' {
+  export { RouteInfo, RouteInfoWithAttributes } from 'router_js';
+}

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

@@ -0,0 +1,13 @@
+declare module '@ember/routing/lib/router_state.d.ts' {
+  import type { ModelFor, TransitionState } from 'router_js';
+  import type Router from 'router_js';
+  import type Route from '@ember/routing/route';
+  import type EmberRouter from '@ember/routing/router';
+  export default class RouterState<R extends Route> {
+      router: Router<R>;
+      emberRouter: EmberRouter<R>;
+      routerJsState: TransitionState<R>;
+      constructor(emberRouter: EmberRouter<R>, router: Router<R>, routerJsState: TransitionState<R>);
+      isActiveIntent(routeName: string, models: ModelFor<R>[], queryParams?: Record<string, unknown>): boolean;
+  }
+}

package/types/stable/@ember/routing/lib/routing-service.d.ts

@@ -0,0 +1,35 @@
+declare module '@ember/routing/lib/routing-service.d.ts' {
+  /**
+  @module ember
+  */
+  import Service from '@ember/service';
+  import type { ModelFor } from 'router_js';
+  import type Route from '@ember/routing/route';
+  import EmberRouter from '@ember/routing/router';
+  import type { RouterState } from '@ember/routing/-internals';
+  import { ROUTER } from '@ember/routing/router-service';
+  /**
+    The Routing service is used by LinkTo, and provides facilities for
+    the component/view layer to interact with the router.
+
+    This is a private service for internal usage only. For public usage,
+    refer to the `Router` service.
+
+    @private
+    @class RoutingService
+  */
+  export default class RoutingService<R extends Route> extends Service {
+      targetState: EmberRouter['targetState'];
+      currentState: EmberRouter['currentState'];
+      currentRouteName: EmberRouter['currentRouteName'];
+      currentPath: EmberRouter['currentPath'];
+      [ROUTER]?: EmberRouter<R>;
+      get router(): EmberRouter<R>;
+      hasRoute(routeName: string): boolean;
+      transitionTo(routeName: string, models: ModelFor<R>[], queryParams: Record<string, unknown>, shouldReplace: boolean): import("router_js").Transition;
+      normalizeQueryParams(routeName: string, models: ModelFor<R>[], queryParams: Record<string, unknown>): void;
+      _generateURL(routeName: string, models: ModelFor<R>[], queryParams: Record<string, unknown>): string;
+      generateURL(routeName: string, models: ModelFor<R>[], queryParams: Record<string, unknown>): string | undefined;
+      isActiveForRoute(contexts: ModelFor<R>[], queryParams: Record<string, unknown> | undefined, routeName: string, routerState: RouterState<R>): boolean;
+  }
+}

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

@@ -0,0 +1,36 @@
+declare module '@ember/routing/lib/utils.d.ts' {
+  import type { ControllerQueryParam, ControllerQueryParamType } from '@ember/controller';
+  import type { ModelFor } from 'router_js';
+  import type Router from 'router_js';
+  import type { ExtendedInternalRouteInfo } from '@ember/routing/route';
+  import type Route from '@ember/routing/route';
+  import type EmberRouter from '@ember/routing/router';
+  export type ExpandedControllerQueryParam = {
+      as: string | null;
+      scope: string;
+      type?: ControllerQueryParamType;
+  };
+  export type NamedRouteArgs<R extends Route> = [routeNameOrUrl: string, ...modelsAndOptions: [...ModelFor<R>[], RouteOptions]] | [routeNameOrUrl: string, ...models: ModelFor<R>[]];
+  export type UnnamedRouteArgs<R extends Route> = [...modelsAndOptions: [...ModelFor<R>[], RouteOptions]] | [...models: ModelFor<R>[]] | [options: RouteOptions];
+  export type RouteArgs<R extends Route> = NamedRouteArgs<R> | UnnamedRouteArgs<R>;
+  type ExtractedArgs<R extends Route> = {
+      routeName: string | undefined;
+      models: ModelFor<R>[];
+      queryParams: Record<string, unknown>;
+  };
+  export type RouteOptions = {
+      queryParams: Record<string, unknown>;
+  };
+  export function extractRouteArgs<R extends Route>(args: RouteArgs<R>): ExtractedArgs<R>;
+  export function getActiveTargetName(router: Router<Route>): string;
+  export function stashParamNames<R extends Route>(router: EmberRouter<R>, routeInfos: Array<ExtendedInternalRouteInfo<R>> & {
+      _namesStashed?: boolean;
+  }): void;
+  export function calculateCacheKey(prefix: string, parts: string[] | undefined, values: {} | null): string;
+  export function normalizeControllerQueryParams(queryParams: Readonly<ControllerQueryParam[]>): Record<string, ExpandedControllerQueryParam>;
+  export function resemblesURL(str: unknown): str is string;
+  export function prefixRouteNameArg<T extends NamedRouteArgs<Route> | UnnamedRouteArgs<Route>>(route: Route, args: T): T;
+  export function shallowEqual<A extends object, B extends object>(a: A, b: B): boolean;
+  export function deprecateTransitionMethods(frameworkClass: string, methodName: string): void;
+  export {};
+}

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

@@ -0,0 +1,108 @@
+declare module '@ember/routing/location.d.ts' {
+  export interface ILocation {
+      implementation: string;
+      cancelRouterSetup?: boolean;
+      getURL(): string;
+      setURL(url: string): void;
+      replaceURL?(url: string): void;
+      onUpdateURL(callback: UpdateCallback): void;
+      formatURL(url: string): string;
+      detect?(): void;
+      initState?(): void;
+      destroy(): void;
+  }
+  export type UpdateCallback = (url: string) => void;
+  /**
+  @module @ember/routing/location
+  */
+  /**
+    Location returns an instance of the correct implementation of
+    the `location` API.
+
+    ## Implementations
+
+    You can pass an implementation name (`hash`, `history`, `none`, `auto`) to force a
+    particular implementation to be used in your application.
+
+    See [HashLocation](/ember/release/classes/HashLocation).
+    See [HistoryLocation](/ember/release/classes/HistoryLocation).
+    See [NoneLocation](/ember/release/classes/NoneLocation).
+    See [AutoLocation](/ember/release/classes/AutoLocation).
+
+    ## Location API
+
+    Each location implementation must provide the following methods:
+
+    * implementation: returns the string name used to reference the implementation.
+    * getURL: returns the current URL.
+    * setURL(path): sets the current URL.
+    * replaceURL(path): replace the current URL (optional).
+    * onUpdateURL(callback): triggers the callback when the URL changes.
+    * formatURL(url): formats `url` to be placed into `href` attribute.
+    * detect() (optional): instructs the location to do any feature detection
+        necessary. If the location needs to redirect to a different URL, it
+        can cancel routing by setting the `cancelRouterSetup` property on itself
+        to `false`.
+
+    Calling setURL or replaceURL will not trigger onUpdateURL callbacks.
+
+    ## Custom implementation
+
+    Ember scans `app/locations/*` for extending the Location API.
+
+    Example:
+
+    ```javascript
+    import HistoryLocation from '@ember/routing/history-location';
+
+    export default class MyHistory {
+      implementation = 'my-custom-history';
+
+      constructor() {
+        this._history = HistoryLocation.create(...arguments);
+      }
+
+      create() {
+        return new this(...arguments);
+      }
+
+      pushState(path) {
+         this._history.pushState(path);
+      }
+    }
+    ```
+
+    @class Location
+    @private
+  */
+  const _default: {
+      /**
+       This is deprecated in favor of using the container to lookup the location
+       implementation as desired.
+    
+       For example:
+    
+       ```javascript
+       // Given a location registered as follows:
+       container.register('location:history-test', HistoryTestLocation);
+    
+       // You could create a new instance via:
+       container.lookup('location:history-test');
+       ```
+    
+        @method create
+        @param {Object} options
+        @return {Object} an instance of an implementation of the `location` API
+        @deprecated Use the container to lookup the location implementation that you
+        need.
+        @private
+      */
+      create(options?: {
+          implementation: string;
+      }): ILocation;
+      implementations: Record<string, {
+          create: (...args: any[]) => ILocation;
+      }>;
+  };
+  export default _default;
+}

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

@@ -0,0 +1,83 @@
+declare module '@ember/routing/none-location.d.ts' {
+  import EmberObject from '@ember/object';
+  import type { ILocation as EmberLocation, UpdateCallback } from '@ember/routing/location';
+  /**
+  @module @ember/routing/none-location
+  */
+  /**
+    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).
+
+    Using `NoneLocation` causes Ember to not store the applications URL state
+    in the actual URL. This is generally used for testing purposes, and is one
+    of the changes made when calling `App.setupForTesting()`.
+
+    @class NoneLocation
+    @extends EmberObject
+    @protected
+  */
+  export default class NoneLocation extends EmberObject implements EmberLocation {
+      updateCallback: UpdateCallback;
+      implementation: string;
+      path: string;
+      /**
+        Will be pre-pended to path.
+    
+        @private
+        @property rootURL
+        @default '/'
+      */
+      rootURL: string;
+      initState(): void;
+      /**
+        Returns the current path without `rootURL`.
+    
+        @private
+        @method getURL
+        @return {String} path
+      */
+      getURL(): string;
+      /**
+        Set the path and remembers what was set. Using this method
+        to change the path will not invoke the `updateURL` callback.
+    
+        @private
+        @method setURL
+        @param path {String}
+      */
+      setURL(path: string): void;
+      /**
+        Register a callback to be invoked when the path 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: (url: string) => void): void;
+      /**
+        Sets the path and calls the `updateURL` callback.
+    
+        @private
+        @method handleURL
+        @param url {String}
+      */
+      handleURL(url: string): 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}
+        @return {String} url
+      */
+      formatURL(url: string): string;
+  }
+}

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

@@ -0,0 +1,125 @@
+declare module '@ember/routing/route-info.d.ts' {
+  /**
+    Re-exports the `RouteInfo` and `RouteInfoWithMetadata` types from [router.js].
+    `RouteInfo` and `RouteInfoWithMetadata` appear as properties on `Transition`
+    instances.
+
+    [router.js]: https://github.com/tildeio/router.js
+
+    @module @ember/routing/route-info
+   */
+  /**
+    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.
+
+    A `RouteInfo` is not user-constructible; the only legal way to get one is from
+    a valid `Transition`. However, you can import the type by using `import type`
+    syntax with TypeScript or `import()` in JSDoc comments.
+
+    @class RouteInfo
+    @public
+   */
+  /**
+    The dot-separated, fully-qualified name of the route, like `"people.index"`.
+    @property {String} name
+    @public
+   */
+  /**
+    The final segment of the fully-qualified name of the route, like `"index"`
+    @property {String} localName
+    @public
+   */
+  /**
+    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).
+    @property {Object} params
+    @public
+   */
+  /**
+    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.
+    @property {Array} paramNames
+    @public
+   */
+  /**
+    The values of any queryParams on this route.
+    @property {Object} queryParams
+    @public
+   */
+  /**
+    Will contain the result `Route#buildRouteInfoMetadata` for the corresponding
+    Route.
+    @property {Any} metadata
+    @public
+   */
+  /**
+    A reference to the parent route's `RouteInfo`. This can be used to traverse
+    upward to the topmost `RouteInfo`.
+    @property {RouteInfo|null} parent
+    @public
+   */
+  /**
+    A reference to the child route's `RouteInfo`. This can be used to traverse
+    downward to the leafmost `RouteInfo`.
+    @property {RouteInfo|null} child
+    @public
+   */
+  /**
+    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.
+
+    This method is similar to the `find()` method defined in ECMAScript 2015.
+
+    The callback method you provide should have the following signature (all
+    parameters are optional):
+
+    ```javascript
+    function(item, index, array);
+    ```
+
+    - `item` is the current item in the iteration.
+    - `index` is the current index in the iteration.
+    - `array` is the array itself.
+
+    It should return the `true` to include the item in the results, `false`
+    otherwise.
+
+    Note that in addition to a callback, you can also pass an optional target
+    object that will be set as `this` on the context.
+
+    @method find
+    @param {Function} callback the callback to execute
+    @param {Object} [target*] optional target to use
+    @returns {Object} Found item or undefined
+    @public
+   */
+  /**
+    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.
+
+    A `RouteInfoWithAttributes` is not user-constructible; the only legal way to
+    get one is from a valid `Transition`. However, you can import the type by
+    using `import type` syntax with TypeScript or `import()` in JSDoc comments.
+
+    @class RouteInfoWithAttributes
+    @extends RouteInfo
+    @public
+   */
+  /**
+     This is the resolved return value from the
+     route's model hook.
+     @property {Object|Array|String|undefined} attributes
+     @public
+   */
+  export type { RouteInfo as default, RouteInfoWithAttributes } from './lib/route-info';
+}