@angular-wave/angular.ts 0.18.0 → 0.19.0

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

@@ -1,3 +1,5 @@
+/** @typedef {import("../params/param.js").Param} Param */
+/** @typedef {import("../resolve/resolvable.js").Resolvable} Resolvable */
 /**
  * Internal representation of a ng-router state.
  *
@@ -14,21 +16,59 @@ export class StateObject {
    * @param {import('./interface.ts').StateDeclaration} config
    */
   constructor(config: import("./interface.ts").StateDeclaration);
-  name: any;
-  navigable: any;
-  /** @type {?StateObject} */
-  parent: StateObject | null;
-  params: any;
-  url: any;
+  /**
+   * @type {string}
+   */
+  name: string;
+  /**
+   * @type {{ url: any; } | undefined | null}
+   */
+  navigable:
+    | {
+        url: any;
+      }
+    | undefined
+    | null;
+  /** @type {StateObject | undefined} */
+  parent: StateObject | undefined;
+  /**
+   * @type {ArrayLike<Param> | undefined}
+   */
+  params: ArrayLike<Param> | undefined;
+  /**
+   * @type {{ parameter: (arg0: any, arg1: {}) => any; } | undefined}
+   */
+  url:
+    | {
+        parameter: (arg0: any, arg1: {}) => any;
+      }
+    | undefined;
+  /**
+   * @type {any}
+   */
   includes: any;
-  _state: () => this;
   /**
-   * @type {ng.StateDeclaration|ng.BuiltStateDeclaration}
+   * @type {StateObject[] | undefined}
+   */
+  path: StateObject[] | undefined;
+  /**
+   * @type {any}
+   */
+  views: any;
+  /**
+   * A list of [[Resolvable]] objects.  The internal representation of [[resolve]].
+   * @type {Resolvable[] | undefined}
+   */
+  resolvables: Resolvable[] | undefined;
+  /**
+   * @type {ng.StateDeclaration}
    */
-  self: ng.StateDeclaration | ng.BuiltStateDeclaration;
+  self: ng.StateDeclaration;
   _stateObjectCache: {
     nameGlob: Glob;
   };
+  /** @returns {StateObject} */
+  _state(): StateObject;
   /**
    * Returns true if the provided parameter is the same state.
    *
@@ -36,22 +76,22 @@ export class StateObject {
    * 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
+   * @param {any} 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.
+   * @returns {string} Returns a dot-separated name of the state.
    */
-  fqn(): any;
+  fqn(): string;
   /**
    * Returns the root node of this state's tree.
    *
-   * @returns The root of this state's tree.
+   * @returns {StateObject} The root of this state's tree.
    */
-  root(): any;
+  root(): StateObject;
   /**
    * Gets the state's `Param` objects
    *
@@ -59,23 +99,29 @@ export class StateObject {
    * 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
+   * @param {Partial<Param>} [opts] options
+   * @returns {Param[]} the list of [[Param]] objects
    */
-  parameters(opts: any): any;
+  parameters(opts?: Partial<Param>): Param[];
   /**
    * 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
+   * @param {string} id the name of the [[Param]] to return
+   * @param {Param} [opts] options
+   * @returns {Param | undefined} the [[Param]] object, or undefined if it does not exist
    */
-  parameter(id: any, opts?: {}): any;
-  toString(): any;
+  parameter(id: string, opts?: Param): Param | undefined;
+  toString(): string;
 }
 export namespace StateObject {
   /** Predicate which returns true if the object is a [[StateDeclaration]] object */
-  function isStateDeclaration(obj: any): boolean;
+  function isStateDeclaration(
+    obj: StateObject | import("../state/interface.js").StateDeclaration,
+  ): boolean;
   /** Predicate which returns true if the object is an internal [[StateObject]] object */
   function isState(obj: any): boolean;
 }
+export type Param = import("../params/param.js").Param;
+export type Resolvable = import("../resolve/resolvable.js").Resolvable;
 import { Glob } from "../glob/glob.js";

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

@@ -1,35 +1,44 @@
+/** @typedef {import("./state-registry.js").StateRegistryListener} StateRegistryListener */
 export class StateQueueManager {
   /**
    * @param {import("./state-registry.js").StateRegistryProvider} stateRegistry
    * @param {import("../url/url-rules.js").UrlRules} urlServiceRules
    * @param {import("./interface.ts").StateStore} states
-   * @param {*} builder
-   * @param {*} listeners
+   * @param {import("./state-builder.js").StateBuilder} builder
+   * @param {StateRegistryListener[]} listeners
    */
   constructor(
     stateRegistry: import("./state-registry.js").StateRegistryProvider,
     urlServiceRules: import("../url/url-rules.js").UrlRules,
     states: import("./interface.ts").StateStore,
-    builder: any,
-    listeners: any,
+    builder: import("./state-builder.js").StateBuilder,
+    listeners: StateRegistryListener[],
   );
   stateRegistry: import("./state-registry.js").StateRegistryProvider;
   /** @type {import("../url/url-rules.js").UrlRules} */
   urlServiceRules: import("../url/url-rules.js").UrlRules;
+  /** @type {import("./interface.ts").StateStore} */
   states: import("./interface.ts").StateStore;
-  builder: any;
-  listeners: any;
+  builder: import("./state-builder.js").StateBuilder;
+  /** @type {StateRegistryListener[]} */
+  listeners: StateRegistryListener[];
   /**
    * @type {Array<StateObject>}
    */
   queue: Array<StateObject>;
-  register(stateDecl: any): StateObject;
+  /**
+   * @param {ng.StateDeclaration} stateDecl
+   * @returns {StateObject}
+   */
+  register(stateDecl: ng.StateDeclaration): StateObject;
   flush(): import("./interface.ts").StateStore;
   /**
    *
-   * @param {ng.StateDeclaration} state
-   * @returns {() => void} a function that deregisters the rule
+   * @param {StateObject | ng.StateDeclaration} state
+   * @returns {void} a function that deregisters the rule
    */
-  attachRoute(state: ng.StateDeclaration): () => void;
+  attachRoute(state: StateObject | ng.StateDeclaration): void;
 }
+export type StateRegistryListener =
+  import("./state-registry.js").StateRegistryListener;
 import { StateObject } from "./state-object.js";

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

@@ -1,4 +1,9 @@
+/** @typedef {import("./state-object.js").StateObject} StateObject */
+/** @typedef {import("./interface.ts").BuiltStateDeclaration} BuiltStateDeclaration */
 /** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider } */
+/** @typedef {import("./interface.ts").StateRegistryListener} StateRegistryListener */
+/** @typedef {import("./interface.ts").StateDeclaration} StateDeclaration */
+/** @typedef {import("./interface.ts").StateOrName} StateOrName */
 /**
  * A registry for all of the application's [[StateDeclaration]]s
  *
@@ -21,11 +26,29 @@ export class StateRegistryProvider {
   );
   /** @type {import("./interface.ts").StateStore} */
   states: import("./interface.ts").StateStore;
-  urlService: import("../url/url-service.js").UrlService;
+  /**
+   * @type {ng.UrlService}
+   */
+  urlService: ng.UrlService;
+  /**
+   * @type {import("../url/url-rules.js").UrlRules}
+   */
   urlServiceRules: import("../url/url-rules.js").UrlRules;
-  $injector: any;
-  listeners: any[];
+  /**
+   * @type {ng.InjectorService|undefined}
+   */
+  $injector: ng.InjectorService | undefined;
+  /**
+   * @type {StateRegistryListener[]}
+   */
+  listeners: StateRegistryListener[];
+  /**
+   *@type {StateMatcher}
+   */
   matcher: StateMatcher;
+  /**
+   * @type {StateBuilder}
+   */
   builder: StateBuilder;
   stateQueue: StateQueueManager;
   $get: (string | (($injector: any) => StateRegistryProvider))[];
@@ -33,14 +56,15 @@ export class StateRegistryProvider {
    * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
    * `onRetain` callback hooks on a [[StateDeclaration]].
    *
-   * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
-   * ensures that those hooks are injectable for @uirouter/angularjs (ng1).
-   *
-   * @internalapi
+   * @param {string} hookName
    */
   getStateHookBuilder(
-    hookName: any,
-  ): (stateObject: any) => (trans: any, state: any) => any;
+    hookName: string,
+  ): (
+    stateObject: any & Record<string, any>,
+  ) =>
+    | ((trans: ng.Transition, state: ng.BuiltStateDeclaration) => any)
+    | undefined;
   /**
    * @private
    */
@@ -71,12 +95,14 @@ export class StateRegistryProvider {
    * });
    * ```
    *
-   * @param listener a callback function invoked when the registered states changes.
+   * @param {import("./interface.ts").StateRegistryListener} listener a callback function invoked when the registered states changes.
    *        The function receives two parameters, `event` and `state`.
    *        See [[StateRegistryListener]]
    * @return a function that deregisters the listener
    */
-  onStatesChanged(listener: any): any;
+  onStatesChanged(
+    listener: import("./interface.ts").StateRegistryListener,
+  ): () => void;
   /**
    * Gets the implicit root state
    *
@@ -94,54 +120,80 @@ export class StateRegistryProvider {
    *
    * Note: a state will be queued if the state's parent isn't yet registered.
    *
-   * @param stateDefinition the definition of the state to register.
+   * @param {import("./interface.ts")._StateDeclaration} stateDefinition the definition of the state to register.
    * @returns the internal [[StateObject]] object.
    *          If the state was successfully registered, then the object is fully built (See: [[StateBuilder]]).
    *          If the state was only queued, then the object is not fully built.
    */
-  register(stateDefinition: any): import("./state-object.js").StateObject;
-  _deregisterTree(state: any): any[];
+  register(
+    stateDefinition: import("./interface.ts")._StateDeclaration,
+  ): import("./state-object.js").StateObject;
+  /**
+   *
+   * @param {BuiltStateDeclaration} state
+   * @returns {BuiltStateDeclaration[]}
+   */
+  _deregisterTree(state: BuiltStateDeclaration): BuiltStateDeclaration[];
   /**
    * Removes a state from the registry
    *
    * This removes a state from the registry.
    * If the state has children, they are are also removed from the registry.
    *
-   * @param stateOrName the state's name or object representation
-   * @returns {import('./state-object').StateObject[]} a list of removed states
+   * @param {StateOrName} stateOrName the state's name or object representation
+   * @returns {BuiltStateDeclaration[]} a list of removed states
    */
-  deregister(stateOrName: any): any[];
+  deregister(stateOrName: StateOrName): BuiltStateDeclaration[];
   /**
    * @return {ng.BuiltStateDeclaration[]}
    */
   getAll(): ng.BuiltStateDeclaration[];
+  /**
+   *
+   * @param {StateOrName} [stateOrName]
+   * @param {StateOrName} [base]
+   * @returns {import("./state-service.js").StateDeclaration | import("./state-service.js").StateDeclaration[] | null}
+   */
   get(
-    stateOrName: any,
-    base: any,
+    stateOrName?: StateOrName,
+    base?: StateOrName,
     ...args: any[]
   ):
-    | import("./interface.ts").StateDeclaration
-    | (
-        | import("./interface.ts").StateDeclaration
-        | import("./interface.ts").BuiltStateDeclaration
-      )[];
+    | import("./state-service.js").StateDeclaration
+    | import("./state-service.js").StateDeclaration[]
+    | null;
   /**
    * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).
    * More than one BuilderFunction can be registered for a given property.
    *
    * The BuilderFunction(s) will be used to define the property on any subsequently built [[StateObject]] objects.
    *
-   * @param property The name of the State property being registered for.
-   * @param builderFunction The BuilderFunction which will be used to build the State property
+   * @param {string} property The name of the State property being registered for.
+   * @param {import("./interface.ts").BuilderFunction} builderFunction The BuilderFunction which will be used to build the State property
    * @returns a function which deregisters the BuilderFunction
    */
-  decorator(property: any, builderFunction: any): any;
+  decorator(
+    property: string,
+    builderFunction: import("./interface.ts").BuilderFunction,
+  ):
+    | import("./interface.ts").BuilderFunction
+    | import("./interface.ts").BuilderFunction[];
 }
-export function getLocals(ctx: any): any;
+export function getLocals(ctx: ResolveContext): {
+  [x: string]: any;
+};
+export type StateObject = import("./state-object.js").StateObject;
+export type BuiltStateDeclaration =
+  import("./interface.ts").BuiltStateDeclaration;
 /**
  * }
  */
 export type ServiceProvider = import("../../interface.ts").ServiceProvider;
+export type StateRegistryListener =
+  import("./interface.ts").StateRegistryListener;
+export type StateDeclaration = import("./interface.ts").StateDeclaration;
+export type StateOrName = import("./interface.ts").StateOrName;
 import { StateMatcher } from "./state-matcher.js";
 import { StateBuilder } from "./state-builder.js";
 import { StateQueueManager } from "./state-queue-manager.js";
+import { ResolveContext } from "../resolve/resolve-context.js";