@angular-wave/angular.ts 0.0.38 → 0.0.39

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;
 }

package/types/router/state/state-queue-manager.d.ts

@@ -1,19 +1,13 @@
 export class StateQueueManager {
-  constructor(
-    stateRegistry: any,
-    urlServiceRules: any,
-    states: any,
-    builder: any,
-    listeners: any,
-  );
-  stateRegistry: any;
-  urlServiceRules: any;
-  states: any;
-  builder: any;
-  listeners: any;
-  queue: any[];
-  register(stateDecl: any): StateObject;
-  flush(): any;
-  attachRoute(state: any): void;
+    constructor(stateRegistry: any, urlServiceRules: any, states: any, builder: any, listeners: any);
+    stateRegistry: any;
+    urlServiceRules: any;
+    states: any;
+    builder: any;
+    listeners: any;
+    queue: any[];
+    register(stateDecl: any): StateObject;
+    flush(): any;
+    attachRoute(state: any): void;
 }
 import { StateObject } from "./state-object";