@angular-wave/angular.ts 0.0.37 → 0.0.39

package/types/router/params/param-type.d.ts

@@ -22,44 +22,44 @@
  * ```
  */
 export class ParamType {
-  /**
-   * @param def  A configuration object which contains the custom type definition.  The object's
-   *        properties will override the default methods and/or pattern in `ParamType`'s public interface.
-   * @returns a new ParamType object
-   */
-  constructor(def: any);
-  /** @inheritdoc */
-  pattern: RegExp;
-  /** @inheritdoc */
-  inherit: boolean;
-  /** @inheritdoc */
-  is(val: any, key: any): boolean;
-  /** @inheritdoc */
-  encode(val: any, key: any): any;
-  /** @inheritdoc */
-  decode(val: any, key: any): any;
-  /** @inheritdoc */
-  equals(a: any, b: any): boolean;
-  $subPattern(): string;
-  toString(): string;
-  /** Given an encoded string, or a decoded object, returns a decoded object */
-  $normalize(val: any): any;
-  /**
-   * Wraps an existing custom ParamType as an array of ParamType, depending on 'mode'.
-   * e.g.:
-   * - urlmatcher pattern "/path?{queryParam[]:int}"
-   * - url: "/path?queryParam=1&queryParam=2
-   * - $stateParams.queryParam will be [1, 2]
-   * if `mode` is "auto", then
-   * - url: "/path?queryParam=1 will create $stateParams.queryParam: 1
-   * - url: "/path?queryParam=1&queryParam=2 will create $stateParams.queryParam: [1, 2]
-   */
-  $asArray(mode: any, isSearch: any): ArrayType;
+    /**
+     * @param def  A configuration object which contains the custom type definition.  The object's
+     *        properties will override the default methods and/or pattern in `ParamType`'s public interface.
+     * @returns a new ParamType object
+     */
+    constructor(def: any);
+    /** @inheritdoc */
+    pattern: RegExp;
+    /** @inheritdoc */
+    inherit: boolean;
+    /** @inheritdoc */
+    is(val: any, key: any): boolean;
+    /** @inheritdoc */
+    encode(val: any, key: any): any;
+    /** @inheritdoc */
+    decode(val: any, key: any): any;
+    /** @inheritdoc */
+    equals(a: any, b: any): boolean;
+    $subPattern(): string;
+    toString(): string;
+    /** Given an encoded string, or a decoded object, returns a decoded object */
+    $normalize(val: any): any;
+    /**
+     * Wraps an existing custom ParamType as an array of ParamType, depending on 'mode'.
+     * e.g.:
+     * - urlmatcher pattern "/path?{queryParam[]:int}"
+     * - url: "/path?queryParam=1&queryParam=2
+     * - $stateParams.queryParam will be [1, 2]
+     * if `mode` is "auto", then
+     * - url: "/path?queryParam=1 will create $stateParams.queryParam: 1
+     * - url: "/path?queryParam=1&queryParam=2 will create $stateParams.queryParam: [1, 2]
+     */
+    $asArray(mode: any, isSearch: any): ArrayType;
 }
 /** Wraps up a `ParamType` object to handle array values. */
 declare function ArrayType(type: any, mode: any): void;
 declare class ArrayType {
-  /** Wraps up a `ParamType` object to handle array values. */
-  constructor(type: any, mode: any);
+    /** Wraps up a `ParamType` object to handle array values. */
+    constructor(type: any, mode: any);
 }
 export {};

package/types/router/params/param-types.d.ts

@@ -22,15 +22,15 @@
  * ```
  */
 export class ParamTypes {
-  enqueue: boolean;
-  typeQueue: any[];
-  defaultTypes: {};
-  types: any;
-  /**
-   * Registers a parameter type
-   *
-   * End users should call [[UrlMatcherFactory.type]], which delegates to this method.
-   */
-  type(name: any, definition: any, definitionFn: any): any;
-  _flushTypeQueue(): void;
+    enqueue: boolean;
+    typeQueue: any[];
+    defaultTypes: {};
+    types: any;
+    /**
+     * Registers a parameter type
+     *
+     * End users should call [[UrlMatcherFactory.type]], which delegates to this method.
+     */
+    type(name: any, definition: any, definitionFn: any): any;
+    _flushTypeQueue(): void;
 }

package/types/router/params/param.d.ts

@@ -1,41 +1,41 @@
 export class Param {
-  static values(params: any, values?: {}): {};
-  /**
-   * Finds [[Param]] objects which have different param values
-   *
-   * Filters a list of [[Param]] objects to only those whose parameter values differ in two param value objects
-   *
-   * @param params: The list of Param objects to filter
-   * @param values1: The first set of parameter values
-   * @param values2: the second set of parameter values
-   *
-   * @returns any Param objects whose values were different between values1 and values2
-   */
-  static changed(params: any, values1?: {}, values2?: {}): any;
-  /**
-   * Checks if two param value objects are equal (for a set of [[Param]] objects)
-   *
-   * @param params The list of [[Param]] objects to check
-   * @param values1 The first set of param values
-   * @param values2 The second set of param values
-   *
-   * @returns true if the param values in values1 and values2 are equal
-   */
-  static equals(params: any, values1?: {}, values2?: {}): boolean;
-  /** Returns true if a the parameter values are valid, according to the Param definitions */
-  static validates(params: any, values?: {}): any;
-  constructor(id: any, type: any, location: any, urlConfig: any, state: any);
-  isDefaultValue(value: any): any;
-  /**
-   * [Internal] Gets the decoded representation of a value if the value is defined, otherwise, returns the
-   * default value, which may be the result of an injectable function.
-   */
-  value(value: any): any;
-  _defaultValueCache: {
-    defaultValue: any;
-  };
-  isSearch(): boolean;
-  validates(value: any): boolean;
-  toString(): string;
+    static values(params: any, values?: {}): {};
+    /**
+     * Finds [[Param]] objects which have different param values
+     *
+     * Filters a list of [[Param]] objects to only those whose parameter values differ in two param value objects
+     *
+     * @param params: The list of Param objects to filter
+     * @param values1: The first set of parameter values
+     * @param values2: the second set of parameter values
+     *
+     * @returns any Param objects whose values were different between values1 and values2
+     */
+    static changed(params: any, values1?: {}, values2?: {}): any;
+    /**
+     * Checks if two param value objects are equal (for a set of [[Param]] objects)
+     *
+     * @param params The list of [[Param]] objects to check
+     * @param values1 The first set of param values
+     * @param values2 The second set of param values
+     *
+     * @returns true if the param values in values1 and values2 are equal
+     */
+    static equals(params: any, values1?: {}, values2?: {}): boolean;
+    /** Returns true if a the parameter values are valid, according to the Param definitions */
+    static validates(params: any, values?: {}): any;
+    constructor(id: any, type: any, location: any, urlConfig: any, state: any);
+    isDefaultValue(value: any): any;
+    /**
+     * [Internal] Gets the decoded representation of a value if the value is defined, otherwise, returns the
+     * default value, which may be the result of an injectable function.
+     */
+    value(value: any): any;
+    _defaultValueCache: {
+        defaultValue: any;
+    };
+    isSearch(): boolean;
+    validates(value: any): boolean;
+    toString(): string;
 }
 export var DefType: any;

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

@@ -1,12 +1,12 @@
 export class StateParams {
-  constructor(params?: {});
-  /**
-   * Merges a set of parameters with all parameters inherited between the common parents of the
-   * current state and a given destination state.
-   *
-   * @param {Object} newParams The set of parameters which will be composited with inherited params.
-   * @param {Object} $current Internal definition of object representing the current state.
-   * @param {Object} $to Internal definition of object representing state to transition to.
-   */
-  $inherit(newParams: any, $current: any, $to: any): any;
+    constructor(params?: {});
+    /**
+     * Merges a set of parameters with all parameters inherited between the common parents of the
+     * current state and a given destination state.
+     *
+     * @param {Object} newParams The set of parameters which will be composited with inherited params.
+     * @param {Object} $current Internal definition of object representing the current state.
+     * @param {Object} $to Internal definition of object representing state to transition to.
+     */
+    $inherit(newParams: any, $current: any, $to: any): any;
 }

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

@@ -6,40 +6,40 @@
  * The stateful information includes parameter values and resolve data.
  */
 export class PathNode {
-  constructor(stateOrNode: any);
-  state: any;
-  paramSchema: any;
-  paramValues: any;
-  resolvables: any;
-  views: any;
-  clone(): PathNode;
-  /** Sets [[paramValues]] for the node, from the values of an object hash */
-  applyRawParams(params: any): this;
-  /** Gets a specific [[Param]] metadata that belongs to the node */
-  parameter(name: any): undefined;
-  /**
-   * @returns true if the state and parameter values for another PathNode are
-   * equal to the state and param values for this PathNode
-   */
-  equals(node: any, paramsFn: any): 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: any, paramsFn: any): any;
+    constructor(stateOrNode: any);
+    state: any;
+    paramSchema: any;
+    paramValues: any;
+    resolvables: any;
+    views: any;
+    clone(): PathNode;
+    /** Sets [[paramValues]] for the node, from the values of an object hash */
+    applyRawParams(params: any): this;
+    /** Gets a specific [[Param]] metadata that belongs to the node */
+    parameter(name: any): undefined;
+    /**
+     * @returns true if the state and parameter values for another PathNode are
+     * equal to the state and param values for this PathNode
+     */
+    equals(node: any, paramsFn: any): 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: any, paramsFn: any): any;
 }
 export namespace PathNode {
-  /**
-   * Returns a clone of the PathNode
-   * @deprecated use instance method `node.clone()`
-   */
-  function clone(node: any): any;
+    /**
+     * Returns a clone of the PathNode
+     * @deprecated use instance method `node.clone()`
+     */
+    function clone(node: any): any;
 }

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