@angular-wave/angular.ts 0.18.0 → 0.19.0

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

@@ -23,20 +23,36 @@
  */
 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.
-   */
+       * @param {any} 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.
+       */
   constructor(def: any);
   pattern: RegExp;
   inherit: boolean;
-  name: any;
+  /** @type {string|undefined} */
+  name: string | undefined;
+  /**
+   * @param {any} val
+   */
   is(val: any): boolean;
+  /**
+   * @param {any} val
+   */
   encode(val: any): any;
+  /**
+   * @param {any} val
+   */
   decode(val: any): any;
+  /**
+   * @param {any} a
+   * @param {any} b
+   */
   equals(a: any, b: any): boolean;
-  $subPattern(): string;
   toString(): string;
-  /** Given an encoded string, or a decoded object, returns a decoded object */
+  /**
+   * Given an encoded string, or a decoded object, returns a decoded object
+   * @param {any} val
+   */
   $normalize(val: any): any;
   /**
    * Wraps an existing custom ParamType as an array of ParamType, depending on 'mode'.
@@ -47,13 +63,33 @@ export class ParamType {
    * 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]
+   * @param {boolean |'auto'} mode
+   * @param {any} isSearch
    */
-  $asArray(mode: any, isSearch: any): ArrayType;
+  $asArray(mode: boolean | "auto", isSearch: any): ArrayType;
 }
-/** Wraps up a `ParamType` object to handle array values. */
-declare function ArrayType(type: any, mode: any): void;
+/**
+ * Wraps up a `ParamType` object to handle array values.
+ * @this {Record<string, any>}
+ * @param {ParamType & Record<string, any>} type
+ * @param {boolean | 'auto'} mode
+ */
+declare function ArrayType(
+  this: Record<string, any>,
+  type: ParamType & Record<string, any>,
+  mode: boolean | "auto",
+): 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.
+   * @this {Record<string, any>}
+   * @param {ParamType & Record<string, any>} type
+   * @param {boolean | 'auto'} mode
+   */
+  constructor(
+    this: Record<string, any>,
+    type: ParamType & Record<string, any>,
+    mode: boolean | "auto",
+  );
 }
 export {};

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

@@ -0,0 +1,52 @@
+/**
+ * A registry for parameter types.
+ *
+ * This registry manages the built-in (and custom) parameter types.
+ *
+ * The built-in parameter types are:
+ *
+ * - [[string]]
+ * - [[path]]
+ * - [[query]]
+ * - [[hash]]
+ * - [[int]]
+ * - [[bool]]
+ * - [[date]]
+ * - [[json]]
+ * - [[any]]
+ *
+ * To register custom parameter types, use [[UrlConfig.type]], i.e.,
+ *
+ * ```js
+ * router.urlService.config.type(customType)
+ * ```
+ */
+export class ParamTypes {
+  enqueue: boolean;
+  /**
+   * @type {{ name: any; def: any; }[]}
+   */
+  typeQueue: {
+    name: any;
+    def: any;
+  }[];
+  defaultTypes: Record<string, any>;
+  /**
+   * @type {Record<string, any>}
+   */
+  types: Record<string, any>;
+  /**
+   * Registers a parameter type
+   *
+   * End users should call [[UrlMatcherFactory.type]], which delegates to this method.
+   * @param {string} name
+   * @param {import("./interface.ts").ParamTypeDefinition} [definition]
+   * @param {() => import("../params/interface.ts").ParamTypeDefinition} [definitionFn]
+   */
+  type(
+    name: string,
+    definition?: import("./interface.ts").ParamTypeDefinition,
+    definitionFn?: () => import("../params/interface.ts").ParamTypeDefinition,
+  ): any;
+  _flushTypeQueue(): void;
+}

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

@@ -5,67 +5,91 @@ export namespace DefType {
   let _CONFIG: number;
 }
 export class Param {
-  static values(params: any, values?: {}): {};
+  /**
+   * @param {Param[]} params
+   * @param {Record<string, any>} values
+   * @return {import("./interface.ts").RawParams}
+   */
+  static values(
+    params: Param[],
+    values?: Record<string, any>,
+  ): import("./interface.ts").RawParams;
   /**
    * 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
+   * @param {Param[]} params : The list of Param objects to filter
+   * @param {Record<string, any>} values1 : The first set of parameter values
+   * @param {Record<string, any>} values2 : the second set of parameter values
+   * @returns {Param[]} any Param objects whose values were different between values1 and values2
    */
-  static changed(params: any, values1?: {}, values2?: {}): any;
+  static changed(
+    params: Param[],
+    values1?: Record<string, any>,
+    values2?: Record<string, any>,
+  ): Param[];
   /**
    * Checks if two param value objects are equal (for a set of [[Param]] objects)
-   *
-   * @param params The list of [[Param]] objects to check
+   * @param {any[]} 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;
+  static equals(params: any[], values1?: {}, values2?: {}): boolean;
+  /**
+   * Returns true if a the parameter values are valid, according to the Param definitions
+   * @param {any[]} params
+   * @param {Record<string, any>} values
+   * @return {boolean}
+   */
+  static validates(params: any[], values?: Record<string, any>): boolean;
   /**
    *
-   * @param {*} id
-   * @param {*} type
+   * @param {string} id
+   * @param {ParamType | null} type
    * @param {DefType} location
    * @param {import("../url/url-config.js").UrlConfigProvider} urlConfig
-   * @param {*} state
+   * @param {ng.StateDeclaration} state
    */
   constructor(
-    id: any,
-    type: any,
+    id: string,
+    type: ParamType | null,
     location: DefType,
     urlConfig: import("../url/url-config.js").UrlConfigProvider,
-    state: any,
+    state: ng.StateDeclaration,
   );
   isOptional: boolean;
-  type: any;
+  type: ParamType;
   location: number;
-  id: any;
+  id: string;
   dynamic: boolean;
   raw: boolean;
-  squash: any;
+  squash: string | boolean;
   replace: any;
   inherit: boolean;
-  array: any;
-  config: any;
-  isDefaultValue(value: any): any;
+  array: boolean;
+  config: import("./interface.ts").ParamDeclaration;
+  /** @type {import("./interface.ts").RawParams | undefined} */
+  matchingKeys: import("./interface.ts").RawParams | undefined;
+  /**
+   * @param {any} value
+   */
+  isDefaultValue(value: any): boolean;
   /**
    * [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.
+   * @param {undefined} [value]
    */
-  value(value: any): any;
+  value(value?: undefined): any;
   _defaultValueCache: {
     defaultValue: any;
   };
   isSearch(): boolean;
-  validates(value: any): boolean;
+  /**
+   * @param {null} value
+   */
+  validates(value: null): boolean;
   toString(): string;
 }
+export type ParamDeclaration = import("./interface.ts").ParamDeclaration;
+import { ParamType } from "./param-type.js";

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

@@ -1,3 +1,4 @@
+/** @typedef {import("../state/state-object.js").StateObject} StateObject */
 export class StateParams {
   constructor(params?: {});
   /**
@@ -5,8 +6,9 @@ export class StateParams {
    * 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.
+   * @param {StateObject} $current Internal definition of object representing the current state.
+   * @param {StateObject} $to Internal definition of object representing state to transition to.
    */
-  $inherit(newParams: any, $current: any, $to: any): any;
+  $inherit(newParams: any, $current: StateObject, $to: StateObject): any;
 }
+export type StateObject = import("../state/state-object.js").StateObject;

package/@types/router/path/interface.d.ts

@@ -0,0 +1,3 @@
+import { Param } from "../params/param.js";
+import { PathNode } from "./path-node.js";
+export type GetParamsFn = (pathNode: PathNode) => Param[];

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

@@ -6,22 +6,39 @@
  * The stateful information includes parameter values and resolve data.
  */
 export class PathNode {
-  constructor(stateOrNode: any);
-  state: any;
+  /**
+   * @param {PathNode | ng.StateObject | undefined} stateOrNode
+   */
+  constructor(stateOrNode: PathNode | ng.StateObject | undefined);
+  /** @type {ng.StateObject} */
+  state: ng.StateObject;
   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): any;
   /**
-   * @returns true if the state and parameter values for another PathNode are
-   * equal to the state and param values for this PathNode
+   * Sets [[paramValues]] for the node, from the values of an object hash
+   * @param {import("../params/interface.js").RawParams} params
+   * @returns {PathNode}
+   */
+  applyRawParams(params: import("../params/interface.js").RawParams): PathNode;
+  /**
+   * Gets a specific [[Param]] metadata that belongs to the node
+   * @param {string} name
+   * @returns {Param | undefined}
    */
-  equals(node: any, paramsFn: any): boolean;
+  parameter(name: string): Param | undefined;
+  /**
+     * @param {PathNode} node
+     * @param {import("./interface.js").GetParamsFn} paramsFn
+     * @returns {boolean} 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: import("./interface.js").GetParamsFn,
+  ): boolean;
   /**
    * Finds Params with different parameter values on another PathNode.
    *
@@ -29,10 +46,13 @@ export class PathNode {
    * 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
+   * @param {PathNode} node The node to compare to
+   * @param {import("./interface.js").GetParamsFn} paramsFn A function that returns which parameters should be compared.
+   * @returns { Param[] | false} The [[Param]]s which differ, or null if the two nodes are for different states
    */
-  diff(node: any, paramsFn: any): any;
+  diff(
+    node: PathNode,
+    paramsFn: import("./interface.js").GetParamsFn,
+  ): Param[] | false;
 }
+import { Param } from "../params/param.js";

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

@@ -1,25 +1,46 @@
 /** Given a PathNode[], create an TargetState
  * @param {import("../state/state-registry.js").StateRegistryProvider} registry
  * @param {Array<PathNode>} path
- * @returns
+ * @returns {TargetState}
  */
 export function makeTargetState(
   registry: import("../state/state-registry.js").StateRegistryProvider,
   path: Array<PathNode>,
 ): TargetState;
+/** @typedef {import("../params/param.js").Param} Param */
+/** @typedef {import("./interface.ts").GetParamsFn} GetParamsFn */
+/** @typedef {import("../state/state-object.js").StateObject} StateObject */
+/** @typedef {import("../params/interface.ts").RawParams} RawParams */
 /**
  * This class contains functions which convert TargetStates, Nodes and paths from one type to another.
  */
 export class PathUtils {
-  static buildPath(targetState: any): any;
-  /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */
-  static buildToPath(fromPath: any, targetState: any): any;
+  /**
+   * @param {TargetState} targetState
+   */
+  static buildPath(targetState: TargetState): PathNode[];
+  /**
+   * Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[]
+   * @param {PathNode[]} fromPath
+   * @param {TargetState} targetState
+   */
+  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
+   * @param {ng.ViewService} $view
+   * @param {PathNode[]} path
+   * @param {StateObject[]} states
    */
-  static applyViewConfigs($view: any, path: any, states: any): void;
+  static applyViewConfigs(
+    $view: ng.ViewService,
+    path: PathNode[],
+    states: StateObject[],
+  ): void;
   /**
    * Given a fromPath and a toPath, returns a new to path which inherits parameters from the fromPath
    *
@@ -30,19 +51,27 @@ export class PathUtils {
    * 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.
+   * @param {PathNode[]} fromPath
+   * @param {PathNode[]} toPath
+   * @param {string[]} [toKeys]
+   * @returns {PathNode[]}
    */
-  static inheritParams(fromPath: any, toPath: any, toKeys?: any[]): any;
+  static inheritParams(
+    fromPath: PathNode[],
+    toPath: PathNode[],
+    toKeys?: string[],
+  ): PathNode[];
   /**
    * Computes the tree changes (entering, exiting) between a fromPath and toPath.
    * @param {PathNode[]} fromPath
    * @param {PathNode[]} toPath
-   * @param {boolean} [reloadState]
+   * @param {StateObject} reloadState
    * @returns {import("../transition/interface.ts").TreeChanges}
    */
   static treeChanges(
     fromPath: PathNode[],
     toPath: PathNode[],
-    reloadState?: boolean,
+    reloadState: StateObject,
   ): import("../transition/interface.ts").TreeChanges;
   /**
    * Returns a new path which is: the subpath of the first path which matches the second path.
@@ -53,36 +82,57 @@ export class PathUtils {
    * 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
+   * @param {PathNode[]} pathA the first path
+   * @param {PathNode[]} pathB the second path
+   * @param {GetParamsFn} [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
+   * @returns {PathNode[]} 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[];
+  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
+   * @param {PathNode[]} pathA
+   * @param {PathNode[]} pathB
+   * @param {GetParamsFn} [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;
+  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
+   * @param {PathNode[]} path a path of [[PathNode]]s
+   * @param {import("../../shared/interface.ts").Predicate<PathNode>} predicate a [[Predicate]] fn that matches [[PathNode]]s
+   * @returns {PathNode[] | undefined} a subpath up to the matching node, or undefined if no match is found
+   */
+  static subPath(
+    path: PathNode[],
+    predicate: import("../../shared/interface.ts").Predicate<PathNode>,
+  ): PathNode[] | undefined;
+  /**
+   * @param {PathNode} node
+   * @return {Param[]}
+   */
+  static nonDynamicParams(node: PathNode): Param[];
+  /**
+   * Gets the raw parameter values from a path
+   * @param {PathNode[]} path
    */
-  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;
+  static paramValues(path: PathNode[]): any;
 }
+export type Param = import("../params/param.js").Param;
+export type GetParamsFn = import("./interface.ts").GetParamsFn;
+export type StateObject = import("../state/state-object.js").StateObject;
+export type RawParams = import("../params/interface.ts").RawParams;
 import { PathNode } from "./path-node.js";
 import { TargetState } from "../state/target-state.js";

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

@@ -15,7 +15,20 @@ export namespace defaultResolvePolicy {
  * parameter to those fns.
  */
 export class Resolvable {
-  constructor(arg1: any, resolveFn: any, deps: any, policy: any, data: any);
+  /**
+   * @param {any} arg1
+   * @param {Function | undefined} [resolveFn]
+   * @param {any[]} [deps]
+   * @param {import("./interface.ts").ResolvePolicy | undefined} [policy]
+   * @param {any} [data]
+   */
+  constructor(
+    arg1: any,
+    resolveFn?: Function | undefined,
+    deps?: any[],
+    policy?: import("./interface.ts").ResolvePolicy | undefined,
+    data?: any,
+  );
   resolved: boolean;
   promise: Promise<any>;
   token: any;
@@ -23,25 +36,39 @@ export class Resolvable {
   resolveFn: any;
   deps: any;
   data: any;
-  getPolicy(state: any): {
-    when: any;
-    async: any;
-  };
+  /**
+   * @param {ng.BuiltStateDeclaration} state
+   * @returns {import("./interface.ts").ResolvePolicy}
+   */
+  getPolicy(
+    state: ng.BuiltStateDeclaration,
+  ): import("./interface.ts").ResolvePolicy;
   /**
    * 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
+   * @param {import("./resolve-context.js").ResolveContext} resolveContext
+   * @param {ng.Transition} [trans]
    */
-  resolve(resolveContext: any, trans: any): Promise<any>;
+  resolve(
+    resolveContext: import("./resolve-context.js").ResolveContext,
+    trans?: ng.Transition,
+  ): Promise<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.
+   * @param {import("./resolve-context.js").ResolveContext} resolveContext
+   * @param {ng.Transition | undefined} [trans]
+   * @return {Promise<any>}
    */
-  get(resolveContext: any, trans: any): Promise<any>;
+  get(
+    resolveContext: import("./resolve-context.js").ResolveContext,
+    trans?: ng.Transition | undefined,
+  ): Promise<any>;
   toString(): string;
   clone(): Resolvable;
 }