@angular-wave/angular.ts 0.0.21 → 0.0.23

package/types/router/core/path/pathNode.d.ts

@@ -1,8 +1,8 @@
-import { StateObject } from '../state/stateObject';
-import { RawParams } from '../params/interface';
-import { Param } from '../params/param';
-import { Resolvable } from '../resolve/resolvable';
-import { ViewConfig } from '../view/interface';
+import { StateObject } from "../state/stateObject";
+import { RawParams } from "../params/interface";
+import { Param } from "../params/param";
+import { Resolvable } from "../resolve/resolvable";
+import { ViewConfig } from "../view/interface";
 /**
  * A node in a [[TreeChanges]] path
  *
@@ -11,50 +11,50 @@ import { ViewConfig } from '../view/interface';
  * The stateful information includes parameter values and resolve data.
  */
 export declare class PathNode {
-    /** The state being entered, exited, or retained */
-    state: StateObject;
-    /** The parameters declared on the state */
-    paramSchema: Param[];
-    /** The parameter values that belong to the state */
-    paramValues: {
-        [key: string]: any;
-    };
-    /** The individual (stateful) resolvable objects that belong to the state */
-    resolvables: Resolvable[];
-    /** The state's declared view configuration objects */
-    views: ViewConfig[];
-    /**
-     * Returns a clone of the PathNode
-     * @deprecated use instance method `node.clone()`
-     */
-    static clone: (node: PathNode) => PathNode;
-    /** Creates a copy of a PathNode */
-    constructor(node: PathNode);
-    /** Creates a new (empty) PathNode for a State */
-    constructor(state: StateObject);
-    clone(): PathNode;
-    /** Sets [[paramValues]] for the node, from the values of an object hash */
-    applyRawParams(params: RawParams): PathNode;
-    /** Gets a specific [[Param]] metadata that belongs to the node */
-    parameter(name: string): Param;
-    /**
-     * @returns true if the state and parameter values for another PathNode are
-     * equal to the state and param values for this PathNode
-     */
-    equals(node: PathNode, paramsFn?: GetParamsFn): boolean;
-    /**
-     * Finds Params with different parameter values on another PathNode.
-     *
-     * Given another node (of the same state), finds the parameter values which differ.
-     * Returns the [[Param]] (schema objects) whose parameter values differ.
-     *
-     * Given another node for a different state, returns `false`
-     *
-     * @param node The node to compare to
-     * @param paramsFn A function that returns which parameters should be compared.
-     * @returns The [[Param]]s which differ, or null if the two nodes are for different states
-     */
-    diff(node: PathNode, paramsFn?: GetParamsFn): Param[] | false;
+  /** The state being entered, exited, or retained */
+  state: StateObject;
+  /** The parameters declared on the state */
+  paramSchema: Param[];
+  /** The parameter values that belong to the state */
+  paramValues: {
+    [key: string]: any;
+  };
+  /** The individual (stateful) resolvable objects that belong to the state */
+  resolvables: Resolvable[];
+  /** The state's declared view configuration objects */
+  views: ViewConfig[];
+  /**
+   * Returns a clone of the PathNode
+   * @deprecated use instance method `node.clone()`
+   */
+  static clone: (node: PathNode) => PathNode;
+  /** Creates a copy of a PathNode */
+  constructor(node: PathNode);
+  /** Creates a new (empty) PathNode for a State */
+  constructor(state: StateObject);
+  clone(): PathNode;
+  /** Sets [[paramValues]] for the node, from the values of an object hash */
+  applyRawParams(params: RawParams): PathNode;
+  /** Gets a specific [[Param]] metadata that belongs to the node */
+  parameter(name: string): Param;
+  /**
+   * @returns true if the state and parameter values for another PathNode are
+   * equal to the state and param values for this PathNode
+   */
+  equals(node: PathNode, paramsFn?: GetParamsFn): boolean;
+  /**
+   * Finds Params with different parameter values on another PathNode.
+   *
+   * Given another node (of the same state), finds the parameter values which differ.
+   * Returns the [[Param]] (schema objects) whose parameter values differ.
+   *
+   * Given another node for a different state, returns `false`
+   *
+   * @param node The node to compare to
+   * @param paramsFn A function that returns which parameters should be compared.
+   * @returns The [[Param]]s which differ, or null if the two nodes are for different states
+   */
+  diff(node: PathNode, paramsFn?: GetParamsFn): Param[] | false;
 }
 /** @internal */
 export declare type GetParamsFn = (pathNode: PathNode) => Param[];

package/types/router/core/path/pathUtils.d.ts

@@ -1,79 +1,105 @@
-import { Predicate } from '../common/common';
-import { TreeChanges } from '../transition/interface';
-import { StateObject } from '../state/stateObject';
-import { TargetState } from '../state/targetState';
-import { GetParamsFn, PathNode } from './pathNode';
-import { ViewService } from '../view/view';
-import { Param } from '../params/param';
-import { StateRegistry } from '../state';
+import { Predicate } from "../common/common";
+import { TreeChanges } from "../transition/interface";
+import { StateObject } from "../state/stateObject";
+import { TargetState } from "../state/targetState";
+import { GetParamsFn, PathNode } from "./pathNode";
+import { ViewService } from "../view/view";
+import { Param } from "../params/param";
+import { StateRegistry } from "../state";
 /**
  * This class contains functions which convert TargetStates, Nodes and paths from one type to another.
  */
 export declare class PathUtils {
-    /** Given a PathNode[], create an TargetState */
-    static makeTargetState(registry: StateRegistry, path: PathNode[]): TargetState;
-    static buildPath(targetState: TargetState): PathNode[];
-    /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */
-    static buildToPath(fromPath: PathNode[], targetState: TargetState): PathNode[];
-    /**
-     * Creates ViewConfig objects and adds to nodes.
-     *
-     * On each [[PathNode]], creates ViewConfig objects from the views: property of the node's state
-     */
-    static applyViewConfigs($view: ViewService, path: PathNode[], states: StateObject[]): void;
-    /**
-     * Given a fromPath and a toPath, returns a new to path which inherits parameters from the fromPath
-     *
-     * For a parameter in a node to be inherited from the from path:
-     * - The toPath's node must have a matching node in the fromPath (by state).
-     * - The parameter name must not be found in the toKeys parameter array.
-     *
-     * Note: the keys provided in toKeys are intended to be those param keys explicitly specified by some
-     * caller, for instance, $state.transitionTo(..., toParams).  If a key was found in toParams,
-     * it is not inherited from the fromPath.
-     */
-    static inheritParams(fromPath: PathNode[], toPath: PathNode[], toKeys?: string[]): PathNode[];
-    static nonDynamicParams: (node: PathNode) => Param[];
-    /**
-     * Computes the tree changes (entering, exiting) between a fromPath and toPath.
-     */
-    static treeChanges(fromPath: PathNode[], toPath: PathNode[], reloadState: StateObject): TreeChanges;
-    /**
-     * Returns a new path which is: the subpath of the first path which matches the second path.
-     *
-     * The new path starts from root and contains any nodes that match the nodes in the second path.
-     * It stops before the first non-matching node.
-     *
-     * Nodes are compared using their state property and their parameter values.
-     * If a `paramsFn` is provided, only the [[Param]] returned by the function will be considered when comparing nodes.
-     *
-     * @param pathA the first path
-     * @param pathB the second path
-     * @param paramsFn a function which returns the parameters to consider when comparing
-     *
-     * @returns an array of PathNodes from the first path which match the nodes in the second path
-     */
-    static matching(pathA: PathNode[], pathB: PathNode[], paramsFn?: GetParamsFn): PathNode[];
-    /**
-     * Returns true if two paths are identical.
-     *
-     * @param pathA
-     * @param pathB
-     * @param paramsFn a function which returns the parameters to consider when comparing
-     * @returns true if the the states and parameter values for both paths are identical
-     */
-    static equals(pathA: PathNode[], pathB: PathNode[], paramsFn?: GetParamsFn): boolean;
-    /**
-     * Return a subpath of a path, which stops at the first matching node
-     *
-     * Given an array of nodes, returns a subset of the array starting from the first node,
-     * stopping when the first node matches the predicate.
-     *
-     * @param path a path of [[PathNode]]s
-     * @param predicate a [[Predicate]] fn that matches [[PathNode]]s
-     * @returns a subpath up to the matching node, or undefined if no match is found
-     */
-    static subPath(path: PathNode[], predicate: Predicate<PathNode>): PathNode[];
-    /** Gets the raw parameter values from a path */
-    static paramValues: (path: PathNode[]) => any;
+  /** Given a PathNode[], create an TargetState */
+  static makeTargetState(
+    registry: StateRegistry,
+    path: PathNode[],
+  ): TargetState;
+  static buildPath(targetState: TargetState): PathNode[];
+  /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */
+  static buildToPath(
+    fromPath: PathNode[],
+    targetState: TargetState,
+  ): PathNode[];
+  /**
+   * Creates ViewConfig objects and adds to nodes.
+   *
+   * On each [[PathNode]], creates ViewConfig objects from the views: property of the node's state
+   */
+  static applyViewConfigs(
+    $view: ViewService,
+    path: PathNode[],
+    states: StateObject[],
+  ): void;
+  /**
+   * Given a fromPath and a toPath, returns a new to path which inherits parameters from the fromPath
+   *
+   * For a parameter in a node to be inherited from the from path:
+   * - The toPath's node must have a matching node in the fromPath (by state).
+   * - The parameter name must not be found in the toKeys parameter array.
+   *
+   * Note: the keys provided in toKeys are intended to be those param keys explicitly specified by some
+   * caller, for instance, $state.transitionTo(..., toParams).  If a key was found in toParams,
+   * it is not inherited from the fromPath.
+   */
+  static inheritParams(
+    fromPath: PathNode[],
+    toPath: PathNode[],
+    toKeys?: string[],
+  ): PathNode[];
+  static nonDynamicParams: (node: PathNode) => Param[];
+  /**
+   * Computes the tree changes (entering, exiting) between a fromPath and toPath.
+   */
+  static treeChanges(
+    fromPath: PathNode[],
+    toPath: PathNode[],
+    reloadState: StateObject,
+  ): TreeChanges;
+  /**
+   * Returns a new path which is: the subpath of the first path which matches the second path.
+   *
+   * The new path starts from root and contains any nodes that match the nodes in the second path.
+   * It stops before the first non-matching node.
+   *
+   * Nodes are compared using their state property and their parameter values.
+   * If a `paramsFn` is provided, only the [[Param]] returned by the function will be considered when comparing nodes.
+   *
+   * @param pathA the first path
+   * @param pathB the second path
+   * @param paramsFn a function which returns the parameters to consider when comparing
+   *
+   * @returns an array of PathNodes from the first path which match the nodes in the second path
+   */
+  static matching(
+    pathA: PathNode[],
+    pathB: PathNode[],
+    paramsFn?: GetParamsFn,
+  ): PathNode[];
+  /**
+   * Returns true if two paths are identical.
+   *
+   * @param pathA
+   * @param pathB
+   * @param paramsFn a function which returns the parameters to consider when comparing
+   * @returns true if the the states and parameter values for both paths are identical
+   */
+  static equals(
+    pathA: PathNode[],
+    pathB: PathNode[],
+    paramsFn?: GetParamsFn,
+  ): boolean;
+  /**
+   * Return a subpath of a path, which stops at the first matching node
+   *
+   * Given an array of nodes, returns a subset of the array starting from the first node,
+   * stopping when the first node matches the predicate.
+   *
+   * @param path a path of [[PathNode]]s
+   * @param predicate a [[Predicate]] fn that matches [[PathNode]]s
+   * @returns a subpath up to the matching node, or undefined if no match is found
+   */
+  static subPath(path: PathNode[], predicate: Predicate<PathNode>): PathNode[];
+  /** Gets the raw parameter values from a path */
+  static paramValues: (path: PathNode[]) => any;
 }

package/types/router/core/resolve/index.d.ts

@@ -1,3 +1,3 @@
-export * from './interface';
-export * from './resolvable';
-export * from './resolveContext';
+export * from "./interface";
+export * from "./resolvable";
+export * from "./resolveContext";

package/types/router/core/resolve/interface.d.ts

@@ -11,12 +11,12 @@
  * An interface which is similar to an Angular 2 `Provider`
  */
 export interface ProviderLike {
-    provide: any;
-    useClass?: any;
-    useFactory?: Function;
-    useValue?: any;
-    useExisting?: any;
-    deps?: any[];
+  provide: any;
+  useClass?: any;
+  useFactory?: Function;
+  useValue?: any;
+  useExisting?: any;
+  deps?: any[];
 }
 /**
  * A plain object used to describe a [[Resolvable]]
@@ -36,44 +36,44 @@ export interface ProviderLike {
  * ```
  */
 export interface ResolvableLiteral {
-    /**
-     * A Dependency Injection token
-     *
-     * This Resolvable's DI token.
-     * The Resolvable will be injectable elsewhere using the token.
-     */
-    token: any;
-    /**
-     * A function which fetches the Resolvable's data
-     *
-     * A function which returns one of:
-     *
-     * - The resolved value (synchronously)
-     * - A promise for the resolved value
-     * - An Observable of the resolved value(s)
-     *
-     * This function will be provided the dependencies listed in [[deps]] as its arguments.
-     * The resolve system will asynchronously fetch the dependencies before invoking this function.
-     */
-    resolveFn: Function;
-    /**
-     * Defines the Resolve Policy
-     *
-     * A policy that defines when to invoke the resolve,
-     * and whether to wait for async and unwrap the data
-     */
-    policy?: ResolvePolicy;
-    /**
-     * The Dependency Injection tokens
-     *
-     * This is an array of Dependency Injection tokens for the dependencies of the [[resolveFn]].
-     *
-     * The DI tokens are references to other `Resolvables`, or to other
-     * services from the native DI system.
-     */
-    deps?: any[];
-    /** Pre-resolved data. */
-    data?: any;
+  /**
+   * A Dependency Injection token
+   *
+   * This Resolvable's DI token.
+   * The Resolvable will be injectable elsewhere using the token.
+   */
+  token: any;
+  /**
+   * A function which fetches the Resolvable's data
+   *
+   * A function which returns one of:
+   *
+   * - The resolved value (synchronously)
+   * - A promise for the resolved value
+   * - An Observable of the resolved value(s)
+   *
+   * This function will be provided the dependencies listed in [[deps]] as its arguments.
+   * The resolve system will asynchronously fetch the dependencies before invoking this function.
+   */
+  resolveFn: Function;
+  /**
+   * Defines the Resolve Policy
+   *
+   * A policy that defines when to invoke the resolve,
+   * and whether to wait for async and unwrap the data
+   */
+  policy?: ResolvePolicy;
+  /**
+   * The Dependency Injection tokens
+   *
+   * This is an array of Dependency Injection tokens for the dependencies of the [[resolveFn]].
+   *
+   * The DI tokens are references to other `Resolvables`, or to other
+   * services from the native DI system.
+   */
+  deps?: any[];
+  /** Pre-resolved data. */
+  data?: any;
 }
 /**
  * Defines how a resolve is processed during a transition
@@ -110,101 +110,101 @@ export interface ResolvableLiteral {
  * ```
  */
 export interface ResolvePolicy {
-    /**
-     * Defines when a Resolvable is resolved (fetched) during a transition
-     *
-     * - `LAZY` (default)
-     *   - Resolved as the resolve's state is being entered
-     * - `EAGER`
-     *   - Resolved as the transition is starting
-     *
-     * #### Example:
-     * Resolves for `main` and `main.home` are fetched when each state is entered.
-     * All of `main` resolves are processed before fetching `main.home` resolves.
-     * ```js
-     * var state = {
-     *   name: 'main',
-     *   resolve: mainResolves, // defined elsewhere
-     *   resolvePolicy: { when: 'LAZY' }, // default
-     * }
-     *
-     * var state = {
-     *   name: 'main.home',
-     *   resolve: homeResolves, // defined elsewhere
-     *   resolvePolicy: { when: 'LAZY' }, // default
-     * }
-     * ```
-     *
-     * #### Example:
-     * Resolves for `main` and `main.home` are fetched at the same time when the transition starts.
-     * This happens earlier in the lifecycle than when states are entered.
-     * All of the `main` and `main.home` resolves are fetched as soon as possible.
-     * ```js
-     * var mainState = {
-     *   name: 'main',
-     *   resolve: mainResolves, // defined elsewhere
-     *   resolvePolicy: { when: 'EAGER' },
-     * }
-     *
-     * var homeState = {
-     *   name: 'main.home',
-     *   resolve: homeResolves, // defined elsewhere
-     *   resolvePolicy: { when: 'EAGER' },
-     * }
-     * ```
-     */
-    when?: PolicyWhen;
-    /**
-     * Determines the unwrapping behavior of asynchronous resolve values.
-     *
-     * - `WAIT` (default)
-     *   - If a promise is returned from the resolveFn, wait for the promise before proceeding
-     *   - The unwrapped value from the promise
-     * - `NOWAIT`
-     *   - If a promise is returned from the resolve, do not wait for the promise.
-     *   - Any other value returned is wrapped in a promise.
-     *   - The promise will not be unwrapped.
-     *   - The promise itself will be provided when the resolve is injected or bound elsewhere.
-     * - {@link CustomAsyncPolicy}
-     *   - You can define a custom function that will be called with the resolveFn value.
-     *   - This function must return a promise.
-     *   - The transition will wait for this promise before proceeding
-     *
-     *   NOTE: The previous `RXWAIT` policy has become a CustomAsyncPolicy function exported in `@uirouter/rx` package.
-     *
-     * #### Example:
-     * The `Transition` will not wait for the resolve promise(s) from `main` to settle before continuing.
-     * Resolves for `main` will be provided to components wrapped in a `Promise`.
-     *
-     * The `Transition` will wait for the `main.home` resolve promises.
-     * Resolved values will be unwrapped before being provided to components.
-     * ```js
-     * var mainState = {
-     *   name: 'main',
-     *   resolve: mainResolves, // defined elsewhere
-     *   resolvePolicy: { async: 'NOWAIT' },
-     * }
-     * var homeState = {
-     *   name: 'main.home',
-     *   resolve: homeResolves, // defined elsewhere
-     *   resolvePolicy: { async: 'WAIT' }, // default
-     * }
-     * ```
-     */
-    async?: PolicyAsync;
+  /**
+   * Defines when a Resolvable is resolved (fetched) during a transition
+   *
+   * - `LAZY` (default)
+   *   - Resolved as the resolve's state is being entered
+   * - `EAGER`
+   *   - Resolved as the transition is starting
+   *
+   * #### Example:
+   * Resolves for `main` and `main.home` are fetched when each state is entered.
+   * All of `main` resolves are processed before fetching `main.home` resolves.
+   * ```js
+   * var state = {
+   *   name: 'main',
+   *   resolve: mainResolves, // defined elsewhere
+   *   resolvePolicy: { when: 'LAZY' }, // default
+   * }
+   *
+   * var state = {
+   *   name: 'main.home',
+   *   resolve: homeResolves, // defined elsewhere
+   *   resolvePolicy: { when: 'LAZY' }, // default
+   * }
+   * ```
+   *
+   * #### Example:
+   * Resolves for `main` and `main.home` are fetched at the same time when the transition starts.
+   * This happens earlier in the lifecycle than when states are entered.
+   * All of the `main` and `main.home` resolves are fetched as soon as possible.
+   * ```js
+   * var mainState = {
+   *   name: 'main',
+   *   resolve: mainResolves, // defined elsewhere
+   *   resolvePolicy: { when: 'EAGER' },
+   * }
+   *
+   * var homeState = {
+   *   name: 'main.home',
+   *   resolve: homeResolves, // defined elsewhere
+   *   resolvePolicy: { when: 'EAGER' },
+   * }
+   * ```
+   */
+  when?: PolicyWhen;
+  /**
+   * Determines the unwrapping behavior of asynchronous resolve values.
+   *
+   * - `WAIT` (default)
+   *   - If a promise is returned from the resolveFn, wait for the promise before proceeding
+   *   - The unwrapped value from the promise
+   * - `NOWAIT`
+   *   - If a promise is returned from the resolve, do not wait for the promise.
+   *   - Any other value returned is wrapped in a promise.
+   *   - The promise will not be unwrapped.
+   *   - The promise itself will be provided when the resolve is injected or bound elsewhere.
+   * - {@link CustomAsyncPolicy}
+   *   - You can define a custom function that will be called with the resolveFn value.
+   *   - This function must return a promise.
+   *   - The transition will wait for this promise before proceeding
+   *
+   *   NOTE: The previous `RXWAIT` policy has become a CustomAsyncPolicy function exported in `@uirouter/rx` package.
+   *
+   * #### Example:
+   * The `Transition` will not wait for the resolve promise(s) from `main` to settle before continuing.
+   * Resolves for `main` will be provided to components wrapped in a `Promise`.
+   *
+   * The `Transition` will wait for the `main.home` resolve promises.
+   * Resolved values will be unwrapped before being provided to components.
+   * ```js
+   * var mainState = {
+   *   name: 'main',
+   *   resolve: mainResolves, // defined elsewhere
+   *   resolvePolicy: { async: 'NOWAIT' },
+   * }
+   * var homeState = {
+   *   name: 'main.home',
+   *   resolve: homeResolves, // defined elsewhere
+   *   resolvePolicy: { async: 'WAIT' }, // default
+   * }
+   * ```
+   */
+  async?: PolicyAsync;
 }
-export declare type PolicyWhen = 'LAZY' | 'EAGER';
-export declare type PolicyAsync = 'WAIT' | 'NOWAIT' | CustomAsyncPolicy;
+export declare type PolicyWhen = "LAZY" | "EAGER";
+export declare type PolicyAsync = "WAIT" | "NOWAIT" | CustomAsyncPolicy;
 export interface CustomAsyncPolicy {
-    (data: any): Promise<any>;
+  (data: any): Promise<any>;
 }
 export declare let resolvePolicies: {
-    when: {
-        LAZY: string;
-        EAGER: string;
-    };
-    async: {
-        WAIT: string;
-        NOWAIT: string;
-    };
+  when: {
+    LAZY: string;
+    EAGER: string;
+  };
+  async: {
+    WAIT: string;
+    NOWAIT: string;
+  };
 };