@angular-wave/angular.ts 0.0.38 → 0.0.40

package/types/router/path/path-utils.d.ts

@@ -2,82 +2,78 @@
  * This class contains functions which convert TargetStates, Nodes and paths from one type to another.
  */
 export class PathUtils {
-  /** Given a PathNode[], create an TargetState */
-  static makeTargetState(registry: any, path: any): TargetState;
-  static buildPath(targetState: any): any;
-  /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */
-  static buildToPath(fromPath: any, targetState: any): any;
-  /**
-   * 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: any, path: any, states: any): 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: any, toPath: any, toKeys?: any[]): any;
-  /**
-   * Computes the tree changes (entering, exiting) between a fromPath and toPath.
-   */
-  static treeChanges(
-    fromPath: any,
-    toPath: any,
-    reloadState: any,
-  ): {
-    from: any;
-    to: any;
-    retained: any;
-    retainedWithToParams: any;
-    exiting: any;
-    entering: any;
-  };
-  /**
-   * 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: any, pathB: any, paramsFn: any): any[];
-  /**
-   * 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: any, pathB: any, paramsFn: any): 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: any, predicate: any): any;
-  static nonDynamicParams(node: any): any;
-  /** Gets the raw parameter values from a path */
-  static paramValues(path: any): any;
+    /** Given a PathNode[], create an TargetState */
+    static makeTargetState(registry: any, path: any): TargetState;
+    static buildPath(targetState: any): any;
+    /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */
+    static buildToPath(fromPath: any, targetState: any): any;
+    /**
+     * 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: any, path: any, states: any): 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: any, toPath: any, toKeys?: any[]): any;
+    /**
+     * Computes the tree changes (entering, exiting) between a fromPath and toPath.
+     */
+    static treeChanges(fromPath: any, toPath: any, reloadState: any): {
+        from: any;
+        to: any;
+        retained: any;
+        retainedWithToParams: any;
+        exiting: any;
+        entering: any;
+    };
+    /**
+     * 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: any, pathB: any, paramsFn: any): any[];
+    /**
+     * 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: any, pathB: any, paramsFn: any): 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: any, predicate: any): any;
+    static nonDynamicParams(node: any): any;
+    /** Gets the raw parameter values from a path */
+    static paramValues(path: any): any;
 }
 import { TargetState } from "../state/target-state";

package/types/router/resolve/resolvable.d.ts

@@ -1,6 +1,6 @@
 export namespace defaultResolvePolicy {
-  let when: string;
-  let async: string;
+    let when: string;
+    let async: string;
 }
 /**
  * The basic building block for the resolve system.
@@ -15,36 +15,36 @@ export namespace defaultResolvePolicy {
  * parameter to those fns.
  */
 export class Resolvable {
-  constructor(arg1: any, resolveFn: any, deps: any, policy: any, data: any);
-  resolved: boolean;
-  promise: any;
-  token: any;
-  policy: any;
-  resolveFn: any;
-  deps: any;
-  data: any;
-  getPolicy(state: any): {
-    when: any;
-    async: any;
-  };
-  /**
-   * Asynchronously resolve this Resolvable's data
-   *
-   * Given a ResolveContext that this Resolvable is found in:
-   * Wait for this Resolvable's dependencies, then invoke this Resolvable's function
-   * and update the Resolvable's state
-   */
-  resolve(resolveContext: any, trans: any): any;
-  /**
-   * Gets a promise for this Resolvable's data.
-   *
-   * Fetches the data and returns a promise.
-   * Returns the existing promise if it has already been fetched once.
-   */
-  get(resolveContext: any, trans: any): any;
-  toString(): string;
-  clone(): Resolvable;
+    constructor(arg1: any, resolveFn: any, deps: any, policy: any, data: any);
+    resolved: boolean;
+    promise: any;
+    token: any;
+    policy: any;
+    resolveFn: any;
+    deps: any;
+    data: any;
+    getPolicy(state: any): {
+        when: any;
+        async: any;
+    };
+    /**
+     * Asynchronously resolve this Resolvable's data
+     *
+     * Given a ResolveContext that this Resolvable is found in:
+     * Wait for this Resolvable's dependencies, then invoke this Resolvable's function
+     * and update the Resolvable's state
+     */
+    resolve(resolveContext: any, trans: any): any;
+    /**
+     * Gets a promise for this Resolvable's data.
+     *
+     * Fetches the data and returns a promise.
+     * Returns the existing promise if it has already been fetched once.
+     */
+    get(resolveContext: any, trans: any): any;
+    toString(): string;
+    clone(): Resolvable;
 }
 export namespace Resolvable {
-  function fromData(token: any, data: any): Resolvable;
+    function fromData(token: any, data: any): Resolvable;
 }

package/types/router/resolve/resolve-context.d.ts

@@ -1,12 +1,12 @@
 export namespace resolvePolicies {
-  namespace when {
-    let LAZY: string;
-    let EAGER: string;
-  }
-  namespace async {
-    let WAIT: string;
-    let NOWAIT: string;
-  }
+    namespace when {
+        let LAZY: string;
+        let EAGER: string;
+    }
+    namespace async {
+        let WAIT: string;
+        let NOWAIT: string;
+    }
 }
 export const NATIVE_INJECTOR_TOKEN: "Native Injector";
 /**
@@ -20,83 +20,83 @@ export const NATIVE_INJECTOR_TOKEN: "Native Injector";
  * The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.
  */
 export class ResolveContext {
-  constructor(_path: any);
-  _path: any;
-  /** Gets all the tokens found in the resolve context, de-duplicated */
-  getTokens(): any;
-  /**
-   * Gets the Resolvable that matches the token
-   *
-   * Gets the last Resolvable that matches the token in this context, or undefined.
-   * Throws an error if it doesn't exist in the ResolveContext
-   */
-  getResolvable(token: any): any;
-  /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
-  getPolicy(resolvable: any): any;
-  /**
-   * Returns a ResolveContext that includes a portion of this one
-   *
-   * Given a state, this method creates a new ResolveContext from this one.
-   * The new context starts at the first node (root) and stops at the node for the `state` parameter.
-   *
-   * #### Why
-   *
-   * When a transition is created, the nodes in the "To Path" are injected from a ResolveContext.
-   * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.
-   * The "To State" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).
-   * This method is used to create a narrower context when injecting ancestor nodes.
-   *
-   * @example
-   * `let ABCD = new ResolveContext([A, B, C, D]);`
-   *
-   * Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:
-   * When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.
-   * However, `B` should only be able to access resolvables from `A`, `B`.
-   *
-   * When resolving for the `B` node, first take the full "To Path" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.
-   * `let AB = ABCD.subcontext(a)`
-   */
-  subContext(state: any): ResolveContext;
-  /**
-   * Adds Resolvables to the node that matches the state
-   *
-   * This adds a [[Resolvable]] (generally one created on the fly; not declared on a [[StateDeclaration.resolve]] block).
-   * The resolvable is added to the node matching the `state` parameter.
-   *
-   * These new resolvables are not automatically fetched.
-   * The calling code should either fetch them, fetch something that depends on them,
-   * or rely on [[resolvePath]] being called when some state is being entered.
-   *
-   * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.
-   *
-   * @param newResolvables the new Resolvables
-   * @param state Used to find the node to put the resolvable on
-   */
-  addResolvables(newResolvables: any, state: any): void;
-  /**
-   * Returns a promise for an array of resolved path Element promises
-   *
-   * @param when
-   * @param trans
-   * @returns {Promise<any>|any}
-   */
-  resolvePath(when: string, trans: any): Promise<any> | any;
-  injector(): UIInjectorImpl;
-  _injector: UIInjectorImpl;
-  findNode(resolvable: any): undefined;
-  /**
-   * Gets the async dependencies of a Resolvable
-   *
-   * Given a Resolvable, returns its dependencies as a Resolvable[]
-   */
-  getDependencies(resolvable: any): any;
+    constructor(_path: any);
+    _path: any;
+    /** Gets all the tokens found in the resolve context, de-duplicated */
+    getTokens(): any;
+    /**
+     * Gets the Resolvable that matches the token
+     *
+     * Gets the last Resolvable that matches the token in this context, or undefined.
+     * Throws an error if it doesn't exist in the ResolveContext
+     */
+    getResolvable(token: any): any;
+    /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
+    getPolicy(resolvable: any): any;
+    /**
+     * Returns a ResolveContext that includes a portion of this one
+     *
+     * Given a state, this method creates a new ResolveContext from this one.
+     * The new context starts at the first node (root) and stops at the node for the `state` parameter.
+     *
+     * #### Why
+     *
+     * When a transition is created, the nodes in the "To Path" are injected from a ResolveContext.
+     * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.
+     * The "To State" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).
+     * This method is used to create a narrower context when injecting ancestor nodes.
+     *
+     * @example
+     * `let ABCD = new ResolveContext([A, B, C, D]);`
+     *
+     * Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:
+     * When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.
+     * However, `B` should only be able to access resolvables from `A`, `B`.
+     *
+     * When resolving for the `B` node, first take the full "To Path" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.
+     * `let AB = ABCD.subcontext(a)`
+     */
+    subContext(state: any): ResolveContext;
+    /**
+     * Adds Resolvables to the node that matches the state
+     *
+     * This adds a [[Resolvable]] (generally one created on the fly; not declared on a [[StateDeclaration.resolve]] block).
+     * The resolvable is added to the node matching the `state` parameter.
+     *
+     * These new resolvables are not automatically fetched.
+     * The calling code should either fetch them, fetch something that depends on them,
+     * or rely on [[resolvePath]] being called when some state is being entered.
+     *
+     * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.
+     *
+     * @param newResolvables the new Resolvables
+     * @param state Used to find the node to put the resolvable on
+     */
+    addResolvables(newResolvables: any, state: any): void;
+    /**
+     * Returns a promise for an array of resolved path Element promises
+     *
+     * @param when
+     * @param trans
+     * @returns {Promise<any>|any}
+     */
+    resolvePath(when: string, trans: any): Promise<any> | any;
+    injector(): UIInjectorImpl;
+    _injector: UIInjectorImpl;
+    findNode(resolvable: any): undefined;
+    /**
+     * Gets the async dependencies of a Resolvable
+     *
+     * Given a Resolvable, returns its dependencies as a Resolvable[]
+     */
+    getDependencies(resolvable: any): any;
 }
 declare class UIInjectorImpl {
-  constructor(context: any);
-  context: any;
-  native: any;
-  get(token: any): any;
-  getAsync(token: any): any;
-  getNative(token: any): any;
+    constructor(context: any);
+    context: any;
+    native: any;
+    get(token: any): any;
+    getAsync(token: any): any;
+    getNative(token: any): any;
 }
 export {};

package/types/router/services.d.ts

@@ -1,14 +1,9 @@
-export function runBlock(
-  $injector: any,
-  $q: any,
-  $stateRegistry: any,
-  $urlService: any,
-): void;
+export function runBlock($injector: any, $q: any, $stateRegistry: any, $urlService: any): void;
 export namespace runBlock {
-  let $inject: string[];
+    let $inject: string[];
 }
 export function watchDigests($rootScope: any): void;
 export namespace watchDigests {
-  let $inject_1: string[];
-  export { $inject_1 as $inject };
+    let $inject_1: string[];
+    export { $inject_1 as $inject };
 }

package/types/router/state/state-builder.d.ts

@@ -53,33 +53,33 @@ export function resolvablesBuilder(state: any): any[];
  * using the [[builder]] method.
  */
 export class StateBuilder {
-  constructor(matcher: any, urlService: any);
-  matcher: any;
-  $injector: any;
-  builders: {
-    name: (typeof nameBuilder)[];
-    self: (typeof selfBuilder)[];
-    parent: ((state: any) => any)[];
-    data: (typeof dataBuilder)[];
-    url: ((stateObject: any) => any)[];
-    navigable: ((state: any) => any)[];
-    params: ((state: any) => any)[];
-    views: any[];
-    path: (typeof pathBuilder)[];
-    includes: (typeof includesBuilder)[];
-    resolvables: (typeof resolvablesBuilder)[];
-  };
-  builder(name: any, fn: any): any;
-  /**
-   * Builds all of the properties on an essentially blank State object, returning a State object which has all its
-   * properties and API built.
-   *
-   * @param state an uninitialized State object
-   * @returns the built State object
-   */
-  build(state: any): any;
-  parentName(state: any): any;
-  name(state: any): any;
+    constructor(matcher: any, urlService: any);
+    matcher: any;
+    $injector: any;
+    builders: {
+        name: (typeof nameBuilder)[];
+        self: (typeof selfBuilder)[];
+        parent: ((state: any) => any)[];
+        data: (typeof dataBuilder)[];
+        url: ((stateObject: any) => any)[];
+        navigable: ((state: any) => any)[];
+        params: ((state: any) => any)[];
+        views: any[];
+        path: (typeof pathBuilder)[];
+        includes: (typeof includesBuilder)[];
+        resolvables: (typeof resolvablesBuilder)[];
+    };
+    builder(name: any, fn: any): any;
+    /**
+     * Builds all of the properties on an essentially blank State object, returning a State object which has all its
+     * properties and API built.
+     *
+     * @param state an uninitialized State object
+     * @returns the built State object
+     */
+    build(state: any): any;
+    parentName(state: any): any;
+    name(state: any): any;
 }
 declare function nameBuilder(state: any): any;
 declare function selfBuilder(state: any): any;

package/types/router/state/state-matcher.d.ts

@@ -1,7 +1,7 @@
 export class StateMatcher {
-  constructor(_states: any);
-  _states: any;
-  isRelative(stateName: any): boolean;
-  find(stateOrName: any, base: any, matchGlob?: boolean): any;
-  resolvePath(name: any, base: any): string;
+    constructor(_states: any);
+    _states: any;
+    isRelative(stateName: any): boolean;
+    find(stateOrName: any, base: any, matchGlob?: boolean): any;
+    resolvePath(name: any, base: any): string;
 }

package/types/router/state/state-object.d.ts

@@ -9,64 +9,64 @@
  * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
  */
 export class StateObject {
-  /**
-   * Create a state object to put the private/internal implementation details onto.
-   * The object's prototype chain looks like:
-   * (Internal State Object) -> (Copy of State.prototype) -> (State Declaration object) -> (State Declaration's prototype...)
-   *
-   * @param stateDecl the user-supplied State Declaration
-   * @returns {StateObject} an internal State object
-   */
-  static create(stateDecl: any): StateObject;
-  constructor(config: any);
-  /**
-   * Returns true if the provided parameter is the same state.
-   *
-   * Compares the identity of the state against the passed value, which is either an object
-   * reference to the actual `State` instance, the original definition object passed to
-   * `$stateProvider.state()`, or the fully-qualified name.
-   *
-   * @param ref Can be one of (a) a `State` instance, (b) an object that was passed
-   *        into `$stateProvider.state()`, (c) the fully-qualified name of a state as a string.
-   * @returns Returns `true` if `ref` matches the current `State` instance.
-   */
-  is(ref: any): boolean;
-  /**
-   * @deprecated this does not properly handle dot notation
-   * @returns Returns a dot-separated name of the state.
-   */
-  fqn(): any;
-  /**
-   * Returns the root node of this state's tree.
-   *
-   * @returns The root of this state's tree.
-   */
-  root(): any;
-  /**
-   * Gets the state's `Param` objects
-   *
-   * Gets the list of [[Param]] objects owned by the state.
-   * If `opts.inherit` is true, it also includes the ancestor states' [[Param]] objects.
-   * If `opts.matchingKeys` exists, returns only `Param`s whose `id` is a key on the `matchingKeys` object
-   *
-   * @param opts options
-   */
-  parameters(opts: any): any;
-  /**
-   * Returns a single [[Param]] that is owned by the state
-   *
-   * If `opts.inherit` is true, it also searches the ancestor states` [[Param]]s.
-   * @param id the name of the [[Param]] to return
-   * @param opts options
-   */
-  parameter(id: any, opts?: {}): any;
-  toString(): any;
+    /**
+     * Create a state object to put the private/internal implementation details onto.
+     * The object's prototype chain looks like:
+     * (Internal State Object) -> (Copy of State.prototype) -> (State Declaration object) -> (State Declaration's prototype...)
+     *
+     * @param stateDecl the user-supplied State Declaration
+     * @returns {StateObject} an internal State object
+     */
+    static create(stateDecl: any): StateObject;
+    constructor(config: any);
+    /**
+     * Returns true if the provided parameter is the same state.
+     *
+     * Compares the identity of the state against the passed value, which is either an object
+     * reference to the actual `State` instance, the original definition object passed to
+     * `$stateProvider.state()`, or the fully-qualified name.
+     *
+     * @param ref Can be one of (a) a `State` instance, (b) an object that was passed
+     *        into `$stateProvider.state()`, (c) the fully-qualified name of a state as a string.
+     * @returns Returns `true` if `ref` matches the current `State` instance.
+     */
+    is(ref: any): boolean;
+    /**
+     * @deprecated this does not properly handle dot notation
+     * @returns Returns a dot-separated name of the state.
+     */
+    fqn(): any;
+    /**
+     * Returns the root node of this state's tree.
+     *
+     * @returns The root of this state's tree.
+     */
+    root(): any;
+    /**
+     * Gets the state's `Param` objects
+     *
+     * Gets the list of [[Param]] objects owned by the state.
+     * If `opts.inherit` is true, it also includes the ancestor states' [[Param]] objects.
+     * If `opts.matchingKeys` exists, returns only `Param`s whose `id` is a key on the `matchingKeys` object
+     *
+     * @param opts options
+     */
+    parameters(opts: any): any;
+    /**
+     * Returns a single [[Param]] that is owned by the state
+     *
+     * If `opts.inherit` is true, it also searches the ancestor states` [[Param]]s.
+     * @param id the name of the [[Param]] to return
+     * @param opts options
+     */
+    parameter(id: any, opts?: {}): any;
+    toString(): any;
 }
 export namespace StateObject {
-  /** Predicate which returns true if the object is an class with @State() decorator */
-  function isStateClass(stateDecl: any): boolean;
-  /** Predicate which returns true if the object is a [[StateDeclaration]] object */
-  function isStateDeclaration(obj: any): boolean;
-  /** Predicate which returns true if the object is an internal [[StateObject]] object */
-  function isState(obj: any): boolean;
+    /** Predicate which returns true if the object is an class with @State() decorator */
+    function isStateClass(stateDecl: any): boolean;
+    /** Predicate which returns true if the object is a [[StateDeclaration]] object */
+    function isStateDeclaration(obj: any): boolean;
+    /** Predicate which returns true if the object is an internal [[StateObject]] object */
+    function isState(obj: any): boolean;
 }