@angular-wave/angular.ts 0.17.0 → 0.19.0

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

@@ -1,10 +1,13 @@
-import { StateDeclaration } from "../state/interface.ts";
+import { BuiltStateDeclaration, StateDeclaration } from "../state/interface.ts";
 import { PredicateBinary } from "../../shared/interface.ts";
 import { Transition } from "./transition.js";
 import { StateObject } from "../state/state-object.js";
 import { PathNode } from "../path/path-node.js";
 import { TargetState } from "../state/target-state.js";
 import { RegisteredHook } from "./hook-registry.js";
+import { TransitionHook } from "./transition-hook.js";
+/** Deregistration function returned by hook registrations */
+export type DeregisterFn = () => void;
 /**
  * The TransitionOptions object can be used to change the behavior of a transition.
  *
@@ -65,7 +68,7 @@ export interface TransitionOptions {
   /**
    * You can define your own Transition Options inside this property and use them, e.g., from a Transition Hook
    */
-  custom?: any;
+  custom?: unknown;
   /**
    * This option may be used to cancel the active transition (if one is active) in favour of the this one.
    * This is the default behaviour or ui-router.
@@ -80,12 +83,15 @@ export interface TransitionOptions {
   supercede?: boolean;
 }
 export interface TransitionHookOptions {
-  current?: () => Transition;
-  transition?: Transition;
+  current: () => Transition | void;
+  transition?: Transition | null;
   hookType?: string;
-  target?: any;
-  traceData?: any;
-  bind?: any;
+  target?: unknown;
+  traceData?: {
+    hookType?: string;
+    context?: any;
+  };
+  bind?: unknown;
   stateHook?: boolean;
 }
 /**
@@ -152,11 +158,6 @@ export interface TreeChanges {
    */
   entering: PathNode[];
 }
-export type IHookRegistration = (
-  matchCriteria: HookMatchCriteria,
-  callback: HookFn,
-  options?: HookRegOptions,
-) => Function;
 /**
  * The signature for Transition Hooks.
  *
@@ -175,7 +176,7 @@ export type IHookRegistration = (
  * - [[HookRegistry.onError]]
  *
  * @param transition the current [[Transition]]
- * @param injector (for ng1 or ng2 only) the injector service
+ * @param injector the injector service
  *
  * @returns a [[HookResult]] which may alter the transition
  *
@@ -223,7 +224,7 @@ export interface TransitionHookFn {
  * @returns an optional [[HookResult]] which may alter the transition
  */
 export interface TransitionStateHookFn {
-  (...injectables: any[]): HookResult;
+  (transition: Transition, state: StateDeclaration): HookResult;
 }
 /**
  * The signature for Transition onCreate Hooks.
@@ -267,7 +268,7 @@ export interface HookRegOptions {
    * Sets the priority of the registered hook
    *
    * Hooks of the same type (onBefore, onStart, etc) are invoked in priority order.  A hook with a higher priority
-   * is invoked before a hook with a lower priority.
+   * is invoked before the hook with a lower priority.
    *
    * The default hook priority is 0
    */
@@ -275,13 +276,110 @@ export interface HookRegOptions {
   /**
    * Specifies what `this` is bound to during hook invocation.
    */
-  bind?: any;
+  bind?: unknown;
   /**
    * Limits the number of times that the hook will be invoked.
    * Once the hook has been invoked this many times, it is automatically deregistered.
    */
   invokeLimit?: number;
 }
+/** A predicate type which tests if a [[StateObject]] and [[Transition]] passes some test. Returns a boolean. */
+export type IStateMatch = PredicateBinary<BuiltStateDeclaration, Transition>;
+/**
+ * Hook Criterion used to match a transition.
+ *
+ * A [[Glob]] string that matches the name of a state.
+ *
+ * Or, a function with the signature `function(state, transition) { return matches; }`
+ * which should return a boolean to indicate if a state matches.
+ *
+ * Or, `true` to always match
+ */
+export type HookMatchCriterion = string | IStateMatch | boolean;
+/**
+ * This object is used to configure whether or not a Transition Hook is invoked for a particular transition,
+ * based on the Transition's "to state" and "from state".
+ *
+ * Each property (`to`, `from`, `exiting`, `retained`, and `entering`) can be a state [[Glob]] string,
+ * a boolean, or a function that takes a state and returns a boolean (see [[HookMatchCriterion]])
+ *
+ * All properties are optional.  If any property is omitted, it is replaced with the value `true`, and always matches.
+ * To match any transition, use an empty criteria object `{}`.
+ *
+ * #### Example:
+ * ```js
+ * // This matches a transition coming from the `parent` state and going to the `parent.child` state.
+ * var match = {
+ *   to: 'parent',
+ *   from: 'parent.child'
+ * }
+ * ```
+ *
+ * #### Example:
+ * ```js
+ * // This matches a transition coming from any substate of `parent` and going directly to the `parent` state.
+ * var match = {
+ *   to: 'parent',
+ *   from: 'parent.**'
+ * }
+ * ```
+ *
+ * #### Example:
+ * ```js
+ * // This matches a transition coming from any state and going to any substate of `mymodule`
+ * var match = {
+ *   to: 'mymodule.**'
+ * }
+ * ```
+ *
+ * #### Example:
+ * ```js
+ * // This matches a transition coming from any state and going to any state that has `data.authRequired`
+ * // set to a truthy value.
+ * var match = {
+ *   to: function(state) {
+ *     return state.data != null && state.data.authRequired === true;
+ *   }
+ * }
+ * ```
+ * #### Example:
+ * ```js
+ * // This will match when route is just entered (initial load) or when the state is hard-refreshed
+ * // by specifying `{refresh: true}` as transition options.
+ * var match = {
+ *   from: (state, transition) => state.self.name === '' || transition.options().reload
+ * }
+ * ```
+ *
+ * #### Example:
+ * ```js
+ * // This matches a transition that is exiting `parent.child`
+ * var match = {
+ *   exiting: 'parent.child'
+ * }
+ * ```
+ */
+export interface HookMatchCriteria {
+  [key: string]: HookMatchCriterion | undefined;
+  /** A [[HookMatchCriterion]] to match the destination state */
+  to?: HookMatchCriterion;
+  /** A [[HookMatchCriterion]] to match the original (from) state */
+  from?: HookMatchCriterion;
+  /** A [[HookMatchCriterion]] to match any state that would be exiting */
+  exiting?: HookMatchCriterion;
+  /** A [[HookMatchCriterion]] to match any state that would be retained */
+  retained?: HookMatchCriterion;
+  /** A [[HookMatchCriterion]] to match any state that would be entering */
+  entering?: HookMatchCriterion;
+}
+export interface IMatchingNodes {
+  [key: string]: PathNode[];
+  to: PathNode[];
+  from: PathNode[];
+  exiting: PathNode[];
+  retained: PathNode[];
+  entering: PathNode[];
+}
 /**
  * This interface specifies the api for registering Transition Hooks.  Both the
  * [[TransitionService]] and also the [[Transition]] object itself implement this interface.
@@ -329,7 +427,6 @@ export interface HookRegistry {
    *
    * @example
    * ```js
-   * // ng2
    * transitionService.onBefore({ to: 'home' }, (trans: Transition) =>
    *     trans.router.stateService.target("home.dashboard"));
    * ```
@@ -346,7 +443,7 @@ export interface HookRegistry {
    * // state declaration
    * {
    *   name: 'home',
-   *   template: '<div ui-view/>',
+   *   template: '<div ng-view/>',
    *   defaultSubstate: 'home.dashboard'
    * }
    *
@@ -388,7 +485,7 @@ export interface HookRegistry {
     matchCriteria: HookMatchCriteria,
     callback: TransitionHookFn,
     options?: HookRegOptions,
-  ): Function;
+  ): DeregisterFn;
   /**
    * Registers a [[TransitionHookFn]], called when a transition starts.
    *
@@ -460,7 +557,7 @@ export interface HookRegistry {
     matchCriteria: HookMatchCriteria,
     callback: TransitionHookFn,
     options?: HookRegOptions,
-  ): Function;
+  ): DeregisterFn;
   /**
    * Registers a [[TransitionStateHookFn]], called when a specific state is entered.
    *
@@ -535,7 +632,7 @@ export interface HookRegistry {
     matchCriteria: HookMatchCriteria,
     callback: TransitionStateHookFn,
     options?: HookRegOptions,
-  ): Function;
+  ): DeregisterFn;
   /**
    * Registers a [[TransitionStateHookFn]], called when a specific state is retained/kept.
    *
@@ -576,7 +673,7 @@ export interface HookRegistry {
     matchCriteria: HookMatchCriteria,
     callback: TransitionStateHookFn,
     options?: HookRegOptions,
-  ): Function;
+  ): DeregisterFn;
   /**
    * Registers a [[TransitionStateHookFn]], called when a specific state is exited.
    *
@@ -619,7 +716,7 @@ export interface HookRegistry {
     matchCriteria: HookMatchCriteria,
     callback: TransitionStateHookFn,
     options?: HookRegOptions,
-  ): Function;
+  ): DeregisterFn;
   /**
    * Registers a [[TransitionHookFn]], called *just before a transition finishes*.
    *
@@ -650,7 +747,7 @@ export interface HookRegistry {
     matchCriteria: HookMatchCriteria,
     callback: TransitionHookFn,
     options?: HookRegOptions,
-  ): Function;
+  ): DeregisterFn;
   /**
    * Registers a [[TransitionHookFn]], called after a successful transition completed.
    *
@@ -680,7 +777,7 @@ export interface HookRegistry {
     matchCriteria: HookMatchCriteria,
     callback: TransitionHookFn,
     options?: HookRegOptions,
-  ): Function;
+  ): DeregisterFn;
   /**
    * Registers a [[TransitionHookFn]], called after a transition has errored.
    *
@@ -726,7 +823,7 @@ export interface HookRegistry {
     matchCriteria: HookMatchCriteria,
     callback: TransitionHookFn,
     options?: HookRegOptions,
-  ): Function;
+  ): DeregisterFn;
   /**
    * Returns all the registered hooks of a given `hookName` type
    *
@@ -737,100 +834,23 @@ export interface HookRegistry {
    */
   getHooks(hookName: string): RegisteredHook[];
 }
-/** A predicate type which tests if a [[StateObject]] and [[Transition]] passes some test. Returns a boolean. */
-export type IStateMatch = PredicateBinary<StateObject, Transition>;
 /**
- * This object is used to configure whether or not a Transition Hook is invoked for a particular transition,
- * based on the Transition's "to state" and "from state".
- *
- * Each property (`to`, `from`, `exiting`, `retained`, and `entering`) can be a state [[Glob]] string,
- * a boolean, or a function that takes a state and returns a boolean (see [[HookMatchCriterion]])
- *
- * All properties are optional.  If any property is omitted, it is replaced with the value `true`, and always matches.
- * To match any transition, use an empty criteria object `{}`.
- *
- * #### Example:
- * ```js
- * // This matches a transition coming from the `parent` state and going to the `parent.child` state.
- * var match = {
- *   to: 'parent',
- *   from: 'parent.child'
- * }
- * ```
- *
- * #### Example:
- * ```js
- * // This matches a transition coming from any substate of `parent` and going directly to the `parent` state.
- * var match = {
- *   to: 'parent',
- *   from: 'parent.**'
- * }
- * ```
- *
- * #### Example:
- * ```js
- * // This matches a transition coming from any state and going to any substate of `mymodule`
- * var match = {
- *   to: 'mymodule.**'
- * }
- * ```
- *
- * #### Example:
- * ```js
- * // This matches a transition coming from any state and going to any state that has `data.authRequired`
- * // set to a truthy value.
- * var match = {
- *   to: function(state) {
- *     return state.data != null && state.data.authRequired === true;
- *   }
- * }
- * ```
- * #### Example:
- * ```js
- * // This will match when route is just entered (initial load) or when the state is hard-refreshed
- * // by specifying `{refresh: true}` as transition options.
- * var match = {
- *   from: (state, transition) => state.self.name === '' || transition.options().reload
- * }
- * ```
+ * TODO: unite with TransitionProvider
+ * The runtime service instance returned from `TransitionProvider.$get`.
  *
- * #### Example:
- * ```js
- * // This matches a transition that is exiting `parent.child`
- * var match = {
- *   exiting: 'parent.child'
- * }
- * ```
+ * Note: In this codebase, `$get` returns the provider instance (`return this;`),
+ * so the "service" surface includes both the public HookRegistry API and
+ * a set of internal fields/methods used by built-in hook registrations/plugins.
  */
-export interface HookMatchCriteria {
-  [key: string]: HookMatchCriterion | undefined;
-  /** A [[HookMatchCriterion]] to match the destination state */
-  to?: HookMatchCriterion;
-  /** A [[HookMatchCriterion]] to match the original (from) state */
-  from?: HookMatchCriterion;
-  /** A [[HookMatchCriterion]] to match any state that would be exiting */
-  exiting?: HookMatchCriterion;
-  /** A [[HookMatchCriterion]] to match any state that would be retained */
-  retained?: HookMatchCriterion;
-  /** A [[HookMatchCriterion]] to match any state that would be entering */
-  entering?: HookMatchCriterion;
+export interface TransitionService extends HookRegistry {
+  /**
+   * Internal factory used by StateService.
+   */
+  create(fromPath: PathNode[], targetState: TargetState): Transition;
+  _exceptionHandler: ng.ExceptionHandlerService;
 }
-export interface IMatchingNodes {
-  [key: string]: PathNode[];
-  to: PathNode[];
-  from: PathNode[];
-  exiting: PathNode[];
-  retained: PathNode[];
-  entering: PathNode[];
+export interface HookTuple {
+  hook: RegisteredHook;
+  node: PathNode;
+  transitionHook: TransitionHook;
 }
-/**
- * Hook Criterion used to match a transition.
- *
- * A [[Glob]] string that matches the name of a state.
- *
- * Or, a function with the signature `function(state, transition) { return matches; }`
- * which should return a boolean to indicate if a state matches.
- *
- * Or, `true` to always match
- */
-export type HookMatchCriterion = string | IStateMatch | boolean;

package/@types/router/transition/reject-factory.d.ts

@@ -10,29 +10,56 @@ export namespace RejectType {
   let _ERROR: number;
 }
 export class Rejection {
-  /** Returns a Rejection due to transition superseded */
-  static superseded(detail: any, options: any): Rejection;
-  /** Returns a Rejection due to redirected transition
-   * @param {any} detail @returns {Rejection}
+  /**
+   * Returns a Rejection due to transition superseded
+   *
+   * @param {any} [detail]
+   * @param {{ redirected?: boolean } | undefined} [options]
+   * @returns {Rejection}
    */
-  static redirected(detail: any): Rejection;
-  /** Returns a Rejection due to invalid transition
-   * @param {any} detail @returns {Rejection}
+  static superseded(
+    detail?: any,
+    options?:
+      | {
+          redirected?: boolean;
+        }
+      | undefined,
+  ): Rejection;
+  /**
+   * Returns a Rejection due to redirected transition
+   *
+   * @param {any} [detail]
+   * @returns {Rejection}
+   */
+  static redirected(detail?: any): Rejection;
+  /**
+   * Returns a Rejection due to invalid transition
+   *
+   * @param {any} detail
+   * @returns {Rejection}
    */
   static invalid(detail: any): Rejection;
-  /** Returns a Rejection due to ignored transition
-   * @param {any} detail @returns {Rejection}
+  /**
+   * Returns a Rejection due to ignored transition
+   *
+   * @param {any} [detail]
+   * @returns {Rejection}
    */
-  static ignored(detail: any): Rejection;
-  /** Returns a Rejection due to aborted transition
-   * @param {any} detail @returns {Rejection}
+  static ignored(detail?: any): Rejection;
+  /**
+   * Returns a Rejection due to aborted transition
+   *
+   * @param {any} [detail]
+   * @returns {Rejection}
    */
-  static aborted(detail: any): Rejection;
-  /** Returns a Rejection due to aborted transition
-   * @param detail
+  static aborted(detail?: any): Rejection;
+  /**
+   * Returns a Rejection due to errored transition
+   *
+   * @param {any} [detail]
    * @returns {Rejection}
    */
-  static errored(detail: any): Rejection;
+  static errored(detail?: any): Rejection;
   /**
    * Returns a Rejection
    *
@@ -40,25 +67,34 @@ export class Rejection {
    * If the value is already a Rejection, returns it.
    * Otherwise, wraps and returns the value as a Rejection (Rejection type: ERROR).
    *
-   * @returns `detail` if it is already a `Rejection`, else returns an ERROR Rejection.
+   * @param {any} detail
+   * @returns {Rejection} `detail` if it is already a `Rejection`, else returns an ERROR Rejection.
    */
-  static normalize(detail: any): any;
+  static normalize(detail: any): Rejection;
   /**
    * @param {number} type
    * @param {string} message
-   * @param {any} detail
+   * @param {any} [detail]
    */
-  constructor(type: number, message: string, detail: any);
+  constructor(type: number, message: string, detail?: any);
   /** @type {number} */
   $id: number;
+  /** @type {number} */
   type: number;
+  /** @type {string} */
   message: string;
+  /** @type {any} */
   detail: any;
+  /** @type {boolean} */
   redirected: boolean;
-  /** @returns {string} */
+  /**
+   * @returns {string}
+   */
   toString(): string;
   /**
-   * @returns {Promise<any> & {_transitionRejection: Rejection}}
+   * Returns a rejected Promise annotated with `_transitionRejection` for identification.
+   *
+   * @returns {Promise<any> & { _transitionRejection: Rejection }}
    */
   toPromise(): Promise<any> & {
     _transitionRejection: Rejection;

package/@types/router/transition/transition-event-type.d.ts

@@ -3,22 +3,33 @@
  * Plugins can define custom hook types, such as sticky states does for `onInactive`.
  */
 export class TransitionEventType {
+  /**
+   * @param {string} name
+   * @param {number} hookPhase
+   * @param {number} hookOrder
+   * @param {any} criteriaMatchPath
+   */
   constructor(
-    name: any,
-    hookPhase: any,
-    hookOrder: any,
+    name: string,
+    hookPhase: number,
+    hookOrder: number,
     criteriaMatchPath: any,
     reverseSort?: boolean,
-    getResultHandler?: (hook: any) => (result: any) => any,
+    getResultHandler?: (
+      hook: TransitionHook,
+    ) => (result: import("./transition-hook.js").HookResult) => Promise<any>,
     getErrorHandler?: () => (error: any) => Promise<never>,
     synchronous?: boolean,
   );
-  name: any;
-  hookPhase: any;
-  hookOrder: any;
+  name: string;
+  hookPhase: number;
+  hookOrder: number;
   criteriaMatchPath: any;
   reverseSort: boolean;
-  getResultHandler: (hook: any) => (result: any) => any;
+  getResultHandler: (
+    hook: TransitionHook,
+  ) => (result: import("./transition-hook.js").HookResult) => Promise<any>;
   getErrorHandler: () => (error: any) => Promise<never>;
   synchronous: boolean;
 }
+import { TransitionHook } from "./transition-hook.js";

package/@types/router/transition/transition-hook.d.ts

@@ -32,52 +32,60 @@ export class TransitionHook {
    * promise.then(handleSuccess, handleError);
    * ```
    *
-   * @param hooks the list of hooks to chain together
-   * @param waitFor if provided, the chain is `.then()`'ed off this promise
+   * @param {TransitionHook[]} hooks the list of hooks to chain together
+   * @param {Promise<any>} [waitFor] if provided, the chain is `.then()`'ed off this promise
    * @returns a `Promise` for sequentially invoking the hooks (in order)
    */
-  static chain(hooks: any, waitFor: any): any;
+  static chain(hooks: TransitionHook[], waitFor?: Promise<any>): Promise<any>;
   /**
    * Invokes all the provided TransitionHooks, in order.
    * Each hook's return value is checked.
    * If any hook returns a promise, then the rest of the hooks are chained off that promise, and the promise is returned.
    * If no hook returns a promise, then all hooks are processed synchronously.
    *
-   * @param hooks the list of TransitionHooks to invoke
-   * @param doneCallback a callback that is invoked after all the hooks have successfully completed
+   * @param {TransitionHook[]} hooks the list of TransitionHooks to invoke
+   * @param {() => Promise<any>} doneCallback a callback that is invoked after all the hooks have successfully completed
    *
-   * @returns a promise for the async result, or the result of the callback
+   * @returns {Promise<any>} a promise for the async result, or the result of the callback
    */
-  static invokeHooks(hooks: any, doneCallback: any): any;
+  static invokeHooks(
+    hooks: TransitionHook[],
+    doneCallback: () => Promise<any>,
+  ): Promise<any>;
   /**
    * Run all TransitionHooks, ignoring their return value.
+   * @param {TransitionHook[]} hooks
    */
-  static runAllHooks(hooks: any): void;
+  static runAllHooks(hooks: TransitionHook[]): void;
   /**
    *
-   * @param {*} transition
-   * @param {*} stateContext
-   * @param {*} registeredHook
-   * @param {*} options
+   * @param {Transition} transition
+   * @param {import("../state/interface.ts").StateDeclaration | null} stateContext
+   * @param {RegisteredHook} registeredHook
+   * @param {TransitionHookOptions} options
    * @param {ng.ExceptionHandlerService} exceptionHandler
    */
   constructor(
-    transition: any,
-    stateContext: any,
-    registeredHook: any,
-    options: any,
+    transition: Transition,
+    stateContext: import("../state/interface.ts").StateDeclaration | null,
+    registeredHook: RegisteredHook,
+    options: TransitionHookOptions,
     exceptionHandler: ng.ExceptionHandlerService,
   );
-  transition: any;
-  stateContext: any;
-  registeredHook: any;
-  options: any;
+  transition: import("./transition.js").Transition;
+  stateContext: import("../state/interface.ts").StateDeclaration;
+  registeredHook: import("./hook-registry.js").RegisteredHook;
+  /** @type {TransitionHookOptions} */
+  options: TransitionHookOptions;
+  type: import("./transition-event-type.js").TransitionEventType;
   isSuperseded: () => boolean;
-  type: any;
   /** @type {ng.ExceptionHandlerService} */
   _exceptionHandler: ng.ExceptionHandlerService;
-  logError(err: any): void;
-  invokeHook(): any;
+  /**
+   * @param {unknown} err
+   */
+  logError(err: unknown): void;
+  invokeHook(): Promise<any>;
   /**
    * This method handles the return value of a Transition Hook.
    *
@@ -86,8 +94,10 @@ export class TransitionHook {
    *
    * This also handles "transition superseded" -- when a new transition
    * was started while the hook was still running
+   * @param {HookResult} result
+   * @returns {Promise<any> | undefined}
    */
-  handleHookResult(result: any): any;
+  handleHookResult(result: HookResult): Promise<any> | undefined;
   /**
    * Return a Rejection promise if the transition is no longer current due
    * a new transition has started and superseded this one.
@@ -102,18 +112,29 @@ export namespace TransitionHook {
    * These GetResultHandler(s) are used by [[invokeHook]] below
    * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])
    */
-  function HANDLE_RESULT(hook: any): (result: any) => any;
+  function HANDLE_RESULT(
+    hook: TransitionHook,
+  ): (/** @type {HookResult} */ result: HookResult) => Promise<any>;
   /**
    * If the result is a promise rejection, log it.
    * Otherwise, ignore the result.
    */
-  function LOG_REJECTED_RESULT(hook: any): (result: any) => any;
+  function LOG_REJECTED_RESULT(hook: {
+    logError: (arg0: Rejection) => any;
+  }): (/** @type {HookResult} */ result: HookResult) => any;
   /**
    * These GetErrorHandler(s) are used by [[invokeHook]] below
    * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])
    */
-  function LOG_ERROR(hook: any): (error: any) => any;
-  function REJECT_ERROR(): (error: any) => Promise<never>;
-  function THROW_ERROR(): (error: any) => never;
+  function LOG_ERROR(hook?: {
+    logError: (arg0: any) => any;
+  }): (/** @type {any} */ error: any) => any;
+  function REJECT_ERROR(): (/** @type {any} */ error: any) => Promise<never>;
+  function THROW_ERROR(): (/** @type {any} */ error: any) => never;
 }
+export type TransitionHookOptions =
+  import("./interface.ts").TransitionHookOptions;
+export type HookResult = import("./interface.ts").HookResult;
+export type Transition = import("./transition.js").Transition;
+export type RegisteredHook = import("./hook-registry.js").RegisteredHook;
 import { Rejection } from "./reject-factory.js";