@angular-wave/angular.ts 0.17.0 → 0.19.0

package/@types/router/template-factory.d.ts

@@ -7,26 +7,19 @@
  * Service which manages loading of templates from a ViewConfig.
  */
 export class TemplateFactoryProvider {
-  /** @type {boolean} */
-  _useHttp: boolean;
   $get: (
     | string
     | ((
         $http: ng.HttpService,
         $templateCache: ng.TemplateCacheService,
         $templateRequest: ng.TemplateRequestService,
-        $injector: import("../core/di/internal-injector.js").InjectorService,
-      ) => this)
+        $injector: ng.InjectorService,
+      ) => TemplateFactoryProvider)
   )[];
   $templateRequest: import("../services/template-request/interface.ts").TemplateRequestService;
-  $http: import("../services/http/interface.ts").HttpService;
+  $http: import("../docs.ts").HttpService;
   $templateCache: ng.TemplateCacheService;
-  $injector: import("../core/di/internal-injector.js").InjectorService;
-  /**
-   * Forces the provider to use $http service directly
-   * @param {boolean} value
-   */
-  useHttpService(value: boolean): void;
+  $injector: import("../docs.ts").InjectorService;
   /**
    * Creates a template from a configuration object.
    *
@@ -62,9 +55,9 @@ export class TemplateFactoryProvider {
    * @param {string|Function} url url of the template to load, or a function
    * that returns a url.
    * @param {Object} params Parameters to pass to the url function.
-   * @return {Promise<string>}
+   * @return {Promise<string> | null}
    */
-  fromUrl(url: string | Function, params: any): Promise<string>;
+  fromUrl(url: string | Function, params: any): Promise<string> | null;
   /**
    * Creates a template by invoking an injectable provider function.
    *
@@ -81,13 +74,13 @@ export class TemplateFactoryProvider {
   ): string | Promise<string>;
   /**
    * Creates a component's template by invoking an injectable provider function.
-   *
    * @param {import('../interface.ts').Injectable<any>} provider Function to invoke via `locals`
+   * @param {import("./resolve/resolve-context.js").ResolveContext} context
    * @return {Promise<any>} The template html as a string: "<component-name input1='::$resolve.foo'></component-name>".
    */
   fromComponentProvider(
     provider: import("../interface.ts").Injectable<any>,
-    context: any,
+    context: import("./resolve/resolve-context.js").ResolveContext,
   ): Promise<any>;
   /**
    * Creates a template from a component's name

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

@@ -1,3 +1,4 @@
+/** @typedef {import("./transition-event-type.js").TransitionEventType} TransitionEventType */
 /**
  * This class returns applicable TransitionHooks for a specific Transition instance.
  *
@@ -19,9 +20,9 @@ export class HookBuilder {
   transition: import("./transition.js").Transition;
   /**
    * @param {TransitionHookPhase} phase
-   * @returns
+   * @returns {TransitionHook[]}
    */
-  buildHooksForPhase(phase: TransitionHookPhase): any;
+  buildHooksForPhase(phase: TransitionHookPhase): TransitionHook[];
   /**
    * Returns an array of newly built TransitionHook objects.
    *
@@ -29,9 +30,10 @@ export class HookBuilder {
    * - Finds [[PathNode]] (or `PathNode[]`) to use as the TransitionHook context(s)
    * - For each of the [[PathNode]]s, creates a TransitionHook
    *
-   * @param hookType the type of the hook registration function, e.g., 'onEnter', 'onFinish'.
+   * @param {TransitionEventType} hookType the type of the hook registration function, e.g., 'onEnter', 'onFinish'.
+   * @returns {TransitionHook[]} an array of TransitionHook objects
    */
-  buildHooks(hookType: any): any;
+  buildHooks(hookType: TransitionEventType): TransitionHook[];
   /**
    * Finds all RegisteredHooks from:
    * - The Transition object instance hook registry
@@ -40,9 +42,18 @@ export class HookBuilder {
    * which matched:
    * - the eventType
    * - the matchCriteria (to, from, exiting, retained, entering)
-   *
    * @returns an array of matched [[RegisteredHook]]s
+   * @param {import("./transition-event-type.js").TransitionEventType} hookType
+   * @param {import("./interface.ts").TreeChanges} treeChanges
+   * @param {import("./transition.js").Transition} transition
    */
-  getMatchingHooks(hookType: any, treeChanges: any, transition: any): any;
+  getMatchingHooks(
+    hookType: import("./transition-event-type.js").TransitionEventType,
+    treeChanges: import("./interface.ts").TreeChanges,
+    transition: import("./transition.js").Transition,
+  ): any;
 }
+export type TransitionEventType =
+  import("./transition-event-type.js").TransitionEventType;
 import { TransitionHookPhase } from "./transition-hook.js";
+import { TransitionHook } from "./transition-hook.js";

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

@@ -1,68 +1,83 @@
 /**
  * Determines if the given state matches the matchCriteria
- *
  * @internal
- *
- * @param state a State Object to test against
- * @param criterion
- * - If a string, matchState uses the string as a glob-matcher against the state name
- * - If an array (of strings), matchState uses each string in the array as a glob-matchers against the state name
- *   and returns a positive match if any of the globs match.
- * - If a function, matchState calls the function with the state and returns true if the function's result is truthy.
+ * @param {import("../state/state-object.js").StateObject} state a State Object to test against
+ * @param {import("./interface.ts").HookMatchCriterion} criterion - If a string, matchState uses the string as a glob-matcher against the state name
+- If an array (of strings), matchState uses each string in the array as a glob-matchers against the state name
+  and returns a positive match if any of the globs match.
+- If a function, matchState calls the function with the state and returns true if the function's result is truthy.
+ * @param {ng.Transition} transition
  * @returns {boolean}
  */
 export function matchState(
-  state: any,
-  criterion: any,
-  transition: any,
+  state: import("../state/state-object.js").StateObject,
+  criterion: import("./interface.ts").HookMatchCriterion,
+  transition: ng.Transition,
 ): boolean;
 /**
- * Return a registration function of the requested type.
+ * Register a transition hook without mutating the hookSource surface.
  * @param {ng.TransitionProvider| import("./transition.js").Transition} hookSource
  * @param {ng.TransitionProvider} transitionService
  * @param {import("./transition-event-type.js").TransitionEventType} eventType
- * @returns {( matchObject: any, callback: Function, options?: Record<string, any> ) => () => void }
+ * @param {import("./interface.ts").HookMatchCriteria} matchCriteria
+ * @param {import("./interface.ts").HookFn} callback
+ * @param {import("./interface.ts").HookRegOptions} options
+ * @returns {import("./interface.ts").DeregisterFn}
  */
-export function makeEvent(
+export function registerHook(
   hookSource: ng.TransitionProvider | import("./transition.js").Transition,
   transitionService: ng.TransitionProvider,
   eventType: import("./transition-event-type.js").TransitionEventType,
+  matchCriteria: import("./interface.ts").HookMatchCriteria,
+  callback: import("./interface.ts").HookFn,
+  options?: import("./interface.ts").HookRegOptions,
+): import("./interface.ts").DeregisterFn;
+/**
+ * Return a registration function of the requested type.
+ * @param {ng.TransitionProvider| import("./transition.js").Transition} hookSource
+ * @param {ng.TransitionService} transitionService
+ * @param {import("./transition-event-type.js").TransitionEventType} eventType
+ * @returns {function(import("./interface.ts").HookMatchCriteria, import("./interface.ts").HookFn, {}=): (function(): void)|*}
+ */
+export function makeEvent(
+  hookSource: ng.TransitionProvider | import("./transition.js").Transition,
+  transitionService: ng.TransitionService,
+  eventType: import("./transition-event-type.js").TransitionEventType,
 ): (
-  matchObject: any,
-  callback: Function,
-  options?: Record<string, any>,
-) => () => void;
+  arg0: import("./interface.ts").HookMatchCriteria,
+  arg1: import("./interface.ts").HookFn,
+  arg2: {} | undefined,
+) => (() => void) | any;
 /**
  * The registration data for a registered transition hook
  */
 export class RegisteredHook {
   /**
-   * @param {import("./transition-service.js").TransitionProvider} tranSvc
-   * @param eventType
-   * @param callback
-   * @param matchCriteria
-   * @param removeHookFromRegistry
-   * @param options
+   * @param {ng.TransitionService} tranSvc
+   * @param {import("./transition-event-type.js").TransitionEventType} eventType
+   * @param {import("./interface.ts").HookFn} callback
+   * @param {import("./interface.ts").HookMatchCriteria} matchCriteria
+   * @param {(hook: RegisteredHook) => void} removeHookFromRegistry
+   * @param {import("./interface.ts").HookRegOptions} options
    */
   constructor(
-    tranSvc: import("./transition-service.js").TransitionProvider,
-    eventType: any,
-    callback: any,
-    matchCriteria: any,
-    removeHookFromRegistry: any,
-    options?: {},
+    tranSvc: ng.TransitionService,
+    eventType: import("./transition-event-type.js").TransitionEventType,
+    callback: import("./interface.ts").HookFn,
+    matchCriteria: import("./interface.ts").HookMatchCriteria,
+    removeHookFromRegistry: (hook: RegisteredHook) => void,
+    options?: import("./interface.ts").HookRegOptions,
   );
-  /** @type {import("./transition-service.js").TransitionProvider} */
-  tranSvc: import("./transition-service.js").TransitionProvider;
-  eventType: any;
-  callback: any;
-  matchCriteria: any;
-  removeHookFromRegistry: any;
+  tranSvc: import("./interface.ts").TransitionService;
+  eventType: import("./transition-event-type.js").TransitionEventType;
+  callback: import("./interface.ts").HookFn;
+  matchCriteria: import("./interface.ts").HookMatchCriteria;
+  removeHookFromRegistry: (hook: RegisteredHook) => void;
   invokeCount: number;
   _deregistered: boolean;
-  priority: any;
-  bind: any;
-  invokeLimit: any;
+  priority: number;
+  bind: unknown;
+  invokeLimit: number;
   /**
    * Gets the matching [[PathNode]]s
    *
@@ -77,8 +92,16 @@ export class RegisteredHook {
    * to still match a transition, even when `entering === []`.  Contrast that
    * with `entering: (state) => true` which only matches when a state is actually
    * being entered.
+   * @param {import("../resolve/resolve-context.js").PathNode[]} nodes
+   * @param {import("./interface.ts").HookMatchCriterion} criterion
+   * @param {ng.Transition} transition
+   * @return {import("../resolve/resolve-context.js").PathNode[] | null}
    */
-  _matchingNodes(nodes: any, criterion: any, transition: any): any;
+  _matchingNodes(
+    nodes: import("../resolve/resolve-context.js").PathNode[],
+    criterion: import("./interface.ts").HookMatchCriterion,
+    transition: ng.Transition,
+  ): import("../resolve/resolve-context.js").PathNode[] | null;
   /**
    * Gets the default match criteria (all `true`)
    *
@@ -92,8 +115,9 @@ export class RegisteredHook {
    *   exiting: true,
    *   retained: true,
    * }
+   * @returns {import("./interface.ts").HookMatchCriteria}
    */
-  _getDefaultMatchCriteria(): boolean[] | Record<string, boolean>;
+  _getDefaultMatchCriteria(): import("./interface.ts").HookMatchCriteria;
   /**
    * Gets matching nodes as [[IMatchingNodes]]
    *
@@ -108,14 +132,24 @@ export class RegisteredHook {
    *   entering: _matchingNodes(treeChanges.entering,     mc.entering),
    * };
    * ```
+   * @param {import("./interface.ts").TreeChanges} treeChanges
+   * @param {ng.Transition} transition
+   * @returns {{}}
    */
-  _getMatchingNodes(treeChanges: any, transition: any): any;
+  _getMatchingNodes(
+    treeChanges: import("./interface.ts").TreeChanges,
+    transition: ng.Transition,
+  ): {};
   /**
    * Determines if this hook's [[matchCriteria]] match the given [[TreeChanges]]
-   *
-   * @returns an IMatchingNodes object, or null. If an IMatchingNodes object is returned, its values
-   * are the matching [[PathNode]]s for each [[HookMatchCriterion]] (to, from, exiting, retained, entering)
+   * @param {import("./interface.ts").TreeChanges} treeChanges
+   * @param {ng.Transition} transition
+   * @returns {import("./interface.ts").IMatchingNodes | null} an IMatchingNodes object, or null. If an IMatchingNodes object is returned,
+   * its values are the matching [[PathNode]]s for each [[HookMatchCriterion]] (to, from, exiting, retained, entering)
    */
-  matches(treeChanges: any, transition: any): any;
+  matches(
+    treeChanges: import("./interface.ts").TreeChanges,
+    transition: ng.Transition,
+  ): import("./interface.ts").IMatchingNodes | null;
   deregister(): void;
 }