@angular-wave/angular.ts 0.0.21 → 0.0.23

package/types/router/core/state/targetState.d.ts

@@ -1,8 +1,8 @@
-import { StateDeclaration, StateOrName, TargetStateDef } from './interface';
-import { TransitionOptions } from '../transition/interface';
-import { StateObject } from './stateObject';
-import { StateRegistry } from './stateRegistry';
-import { RawParams } from '../params';
+import { StateDeclaration, StateOrName, TargetStateDef } from "./interface";
+import { TransitionOptions } from "../transition/interface";
+import { StateObject } from "./stateObject";
+import { StateRegistry } from "./stateRegistry";
+import { RawParams } from "../params";
 /**
  * Encapsulate the target (destination) state/params/options of a [[Transition]].
  *
@@ -33,68 +33,73 @@ import { RawParams } from '../params';
  * or invalid (the state being targeted is not registered).
  */
 export declare class TargetState {
-    private _stateRegistry;
-    private _identifier;
-    private _definition;
-    private _params;
-    private _options;
-    /** Returns true if the object has a state property that might be a state or state name */
-    static isDef: (obj: any) => obj is TargetStateDef;
-    /**
-     * The TargetState constructor
-     *
-     * Note: Do not construct a `TargetState` manually.
-     * To create a `TargetState`, use the [[StateService.target]] factory method.
-     *
-     * @param _stateRegistry The StateRegistry to use to look up the _definition
-     * @param _identifier An identifier for a state.
-     *    Either a fully-qualified state name, or the object used to define the state.
-     * @param _params Parameters for the target state
-     * @param _options Transition options.
-     *
-     * @internal
-     */
-    constructor(_stateRegistry: StateRegistry, _identifier: StateOrName, _params?: RawParams, _options?: TransitionOptions);
-    /** The name of the state this object targets */
-    name(): string;
-    /** The identifier used when creating this TargetState */
-    identifier(): StateOrName;
-    /** The target parameter values */
-    params(): RawParams;
-    /** The internal state object (if it was found) */
-    $state(): StateObject;
-    /** The internal state declaration (if it was found) */
-    state(): StateDeclaration;
-    /** The target options */
-    options(): TransitionOptions;
-    /** True if the target state was found */
-    exists(): boolean;
-    /** True if the object is valid */
-    valid(): boolean;
-    /** If the object is invalid, returns the reason why */
-    error(): string;
-    toString(): string;
-    /**
-     * Returns a copy of this TargetState which targets a different state.
-     * The new TargetState has the same parameter values and transition options.
-     *
-     * @param state The new state that should be targeted
-     */
-    withState(state: StateOrName): TargetState;
-    /**
-     * Returns a copy of this TargetState, using the specified parameter values.
-     *
-     * @param params the new parameter values to use
-     * @param replace When false (default) the new parameter values will be merged with the current values.
-     *                When true the parameter values will be used instead of the current values.
-     */
-    withParams(params: RawParams, replace?: boolean): TargetState;
-    /**
-     * Returns a copy of this TargetState, using the specified Transition Options.
-     *
-     * @param options the new options to use
-     * @param replace When false (default) the new options will be merged with the current options.
-     *                When true the options will be used instead of the current options.
-     */
-    withOptions(options: TransitionOptions, replace?: boolean): TargetState;
+  private _stateRegistry;
+  private _identifier;
+  private _definition;
+  private _params;
+  private _options;
+  /** Returns true if the object has a state property that might be a state or state name */
+  static isDef: (obj: any) => obj is TargetStateDef;
+  /**
+   * The TargetState constructor
+   *
+   * Note: Do not construct a `TargetState` manually.
+   * To create a `TargetState`, use the [[StateService.target]] factory method.
+   *
+   * @param _stateRegistry The StateRegistry to use to look up the _definition
+   * @param _identifier An identifier for a state.
+   *    Either a fully-qualified state name, or the object used to define the state.
+   * @param _params Parameters for the target state
+   * @param _options Transition options.
+   *
+   * @internal
+   */
+  constructor(
+    _stateRegistry: StateRegistry,
+    _identifier: StateOrName,
+    _params?: RawParams,
+    _options?: TransitionOptions,
+  );
+  /** The name of the state this object targets */
+  name(): string;
+  /** The identifier used when creating this TargetState */
+  identifier(): StateOrName;
+  /** The target parameter values */
+  params(): RawParams;
+  /** The internal state object (if it was found) */
+  $state(): StateObject;
+  /** The internal state declaration (if it was found) */
+  state(): StateDeclaration;
+  /** The target options */
+  options(): TransitionOptions;
+  /** True if the target state was found */
+  exists(): boolean;
+  /** True if the object is valid */
+  valid(): boolean;
+  /** If the object is invalid, returns the reason why */
+  error(): string;
+  toString(): string;
+  /**
+   * Returns a copy of this TargetState which targets a different state.
+   * The new TargetState has the same parameter values and transition options.
+   *
+   * @param state The new state that should be targeted
+   */
+  withState(state: StateOrName): TargetState;
+  /**
+   * Returns a copy of this TargetState, using the specified parameter values.
+   *
+   * @param params the new parameter values to use
+   * @param replace When false (default) the new parameter values will be merged with the current values.
+   *                When true the parameter values will be used instead of the current values.
+   */
+  withParams(params: RawParams, replace?: boolean): TargetState;
+  /**
+   * Returns a copy of this TargetState, using the specified Transition Options.
+   *
+   * @param options the new options to use
+   * @param replace When false (default) the new options will be merged with the current options.
+   *                When true the options will be used instead of the current options.
+   */
+  withOptions(options: TransitionOptions, replace?: boolean): TargetState;
 }

package/types/router/core/transition/hookBuilder.d.ts

@@ -1,8 +1,8 @@
-import { TreeChanges, TransitionHookPhase } from './interface';
-import { Transition } from './transition';
-import { TransitionHook } from './transitionHook';
-import { TransitionEventType } from './transitionEventType';
-import { RegisteredHook } from './hookRegistry';
+import { TreeChanges, TransitionHookPhase } from "./interface";
+import { Transition } from "./transition";
+import { TransitionHook } from "./transitionHook";
+import { TransitionEventType } from "./transitionEventType";
+import { RegisteredHook } from "./hookRegistry";
 /**
  * This class returns applicable TransitionHooks for a specific Transition instance.
  *
@@ -17,29 +17,33 @@ import { RegisteredHook } from './hookRegistry';
  * in the Transition class, so we must also provide the Transition's _treeChanges)
  */
 export declare class HookBuilder {
-    private transition;
-    constructor(transition: Transition);
-    buildHooksForPhase(phase: TransitionHookPhase): TransitionHook[];
-    /**
-     * Returns an array of newly built TransitionHook objects.
-     *
-     * - Finds all RegisteredHooks registered for the given `hookType` which matched the transition's [[TreeChanges]].
-     * - 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'.
-     */
-    buildHooks(hookType: TransitionEventType): TransitionHook[];
-    /**
-     * Finds all RegisteredHooks from:
-     * - The Transition object instance hook registry
-     * - The TransitionService ($transitions) global hook registry
-     *
-     * which matched:
-     * - the eventType
-     * - the matchCriteria (to, from, exiting, retained, entering)
-     *
-     * @returns an array of matched [[RegisteredHook]]s
-     */
-    getMatchingHooks(hookType: TransitionEventType, treeChanges: TreeChanges, transition: Transition): RegisteredHook[];
+  private transition;
+  constructor(transition: Transition);
+  buildHooksForPhase(phase: TransitionHookPhase): TransitionHook[];
+  /**
+   * Returns an array of newly built TransitionHook objects.
+   *
+   * - Finds all RegisteredHooks registered for the given `hookType` which matched the transition's [[TreeChanges]].
+   * - 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'.
+   */
+  buildHooks(hookType: TransitionEventType): TransitionHook[];
+  /**
+   * Finds all RegisteredHooks from:
+   * - The Transition object instance hook registry
+   * - The TransitionService ($transitions) global hook registry
+   *
+   * which matched:
+   * - the eventType
+   * - the matchCriteria (to, from, exiting, retained, entering)
+   *
+   * @returns an array of matched [[RegisteredHook]]s
+   */
+  getMatchingHooks(
+    hookType: TransitionEventType,
+    treeChanges: TreeChanges,
+    transition: Transition,
+  ): RegisteredHook[];
 }

package/types/router/core/transition/hookRegistry.d.ts

@@ -1,9 +1,16 @@
-import { IHookRegistry } from './interface';
-import { HookRegOptions, HookMatchCriteria, TreeChanges, HookMatchCriterion, IMatchingNodes, HookFn } from './interface';
-import { Transition } from './transition';
-import { StateObject } from '../state/stateObject';
-import { TransitionEventType } from './transitionEventType';
-import { TransitionService } from './transitionService';
+import { IHookRegistry } from "./interface";
+import {
+  HookRegOptions,
+  HookMatchCriteria,
+  TreeChanges,
+  HookMatchCriterion,
+  IMatchingNodes,
+  HookFn,
+} from "./interface";
+import { Transition } from "./transition";
+import { StateObject } from "../state/stateObject";
+import { TransitionEventType } from "./transitionEventType";
+import { TransitionService } from "./transitionService";
 /**
  * Determines if the given state matches the matchCriteria
  *
@@ -17,77 +24,92 @@ import { TransitionService } from './transitionService';
  * - If a function, matchState calls the function with the state and returns true if the function's result is truthy.
  * @returns {boolean}
  */
-export declare function matchState(state: StateObject, criterion: HookMatchCriterion, transition: Transition): boolean;
+export declare function matchState(
+  state: StateObject,
+  criterion: HookMatchCriterion,
+  transition: Transition,
+): boolean;
 /**
  * The registration data for a registered transition hook
  */
 export declare class RegisteredHook {
-    tranSvc: TransitionService;
-    eventType: TransitionEventType;
-    callback: HookFn;
-    matchCriteria: HookMatchCriteria;
-    removeHookFromRegistry: (hook: RegisteredHook) => void;
-    priority: number;
-    bind: any;
-    invokeCount: number;
-    invokeLimit: number;
-    _deregistered: boolean;
-    constructor(tranSvc: TransitionService, eventType: TransitionEventType, callback: HookFn, matchCriteria: HookMatchCriteria, removeHookFromRegistry: (hook: RegisteredHook) => void, options?: HookRegOptions);
-    /**
-     * Gets the matching [[PathNode]]s
-     *
-     * Given an array of [[PathNode]]s, and a [[HookMatchCriterion]], returns an array containing
-     * the [[PathNode]]s that the criteria matches, or `null` if there were no matching nodes.
-     *
-     * Returning `null` is significant to distinguish between the default
-     * "match-all criterion value" of `true` compared to a `() => true` function,
-     * when the nodes is an empty array.
-     *
-     * This is useful to allow a transition match criteria of `entering: true`
-     * to still match a transition, even when `entering === []`.  Contrast that
-     * with `entering: (state) => true` which only matches when a state is actually
-     * being entered.
-     */
-    private _matchingNodes;
-    /**
-     * Gets the default match criteria (all `true`)
-     *
-     * Returns an object which has all the criteria match paths as keys and `true` as values, i.e.:
-     *
-     * ```js
-     * {
-     *   to: true,
-     *   from: true,
-     *   entering: true,
-     *   exiting: true,
-     *   retained: true,
-     * }
-     */
-    private _getDefaultMatchCriteria;
-    /**
-     * Gets matching nodes as [[IMatchingNodes]]
-     *
-     * Create a IMatchingNodes object from the TransitionHookTypes that is roughly equivalent to:
-     *
-     * ```js
-     * let matches: IMatchingNodes = {
-     *   to:       _matchingNodes([tail(treeChanges.to)],   mc.to),
-     *   from:     _matchingNodes([tail(treeChanges.from)], mc.from),
-     *   exiting:  _matchingNodes(treeChanges.exiting,      mc.exiting),
-     *   retained: _matchingNodes(treeChanges.retained,     mc.retained),
-     *   entering: _matchingNodes(treeChanges.entering,     mc.entering),
-     * };
-     * ```
-     */
-    private _getMatchingNodes;
-    /**
-     * 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)
-     */
-    matches(treeChanges: TreeChanges, transition: Transition): IMatchingNodes;
-    deregister(): void;
+  tranSvc: TransitionService;
+  eventType: TransitionEventType;
+  callback: HookFn;
+  matchCriteria: HookMatchCriteria;
+  removeHookFromRegistry: (hook: RegisteredHook) => void;
+  priority: number;
+  bind: any;
+  invokeCount: number;
+  invokeLimit: number;
+  _deregistered: boolean;
+  constructor(
+    tranSvc: TransitionService,
+    eventType: TransitionEventType,
+    callback: HookFn,
+    matchCriteria: HookMatchCriteria,
+    removeHookFromRegistry: (hook: RegisteredHook) => void,
+    options?: HookRegOptions,
+  );
+  /**
+   * Gets the matching [[PathNode]]s
+   *
+   * Given an array of [[PathNode]]s, and a [[HookMatchCriterion]], returns an array containing
+   * the [[PathNode]]s that the criteria matches, or `null` if there were no matching nodes.
+   *
+   * Returning `null` is significant to distinguish between the default
+   * "match-all criterion value" of `true` compared to a `() => true` function,
+   * when the nodes is an empty array.
+   *
+   * This is useful to allow a transition match criteria of `entering: true`
+   * to still match a transition, even when `entering === []`.  Contrast that
+   * with `entering: (state) => true` which only matches when a state is actually
+   * being entered.
+   */
+  private _matchingNodes;
+  /**
+   * Gets the default match criteria (all `true`)
+   *
+   * Returns an object which has all the criteria match paths as keys and `true` as values, i.e.:
+   *
+   * ```js
+   * {
+   *   to: true,
+   *   from: true,
+   *   entering: true,
+   *   exiting: true,
+   *   retained: true,
+   * }
+   */
+  private _getDefaultMatchCriteria;
+  /**
+   * Gets matching nodes as [[IMatchingNodes]]
+   *
+   * Create a IMatchingNodes object from the TransitionHookTypes that is roughly equivalent to:
+   *
+   * ```js
+   * let matches: IMatchingNodes = {
+   *   to:       _matchingNodes([tail(treeChanges.to)],   mc.to),
+   *   from:     _matchingNodes([tail(treeChanges.from)], mc.from),
+   *   exiting:  _matchingNodes(treeChanges.exiting,      mc.exiting),
+   *   retained: _matchingNodes(treeChanges.retained,     mc.retained),
+   *   entering: _matchingNodes(treeChanges.entering,     mc.entering),
+   * };
+   * ```
+   */
+  private _getMatchingNodes;
+  /**
+   * 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)
+   */
+  matches(treeChanges: TreeChanges, transition: Transition): IMatchingNodes;
+  deregister(): void;
 }
 /** Return a registration function of the requested type. */
-export declare function makeEvent(registry: IHookRegistry, transitionService: TransitionService, eventType: TransitionEventType): (matchObject: any, callback: any, options?: {}) => any;
+export declare function makeEvent(
+  registry: IHookRegistry,
+  transitionService: TransitionService,
+  eventType: TransitionEventType,
+): (matchObject: any, callback: any, options?: {}) => any;

package/types/router/core/transition/index.d.ts

@@ -10,11 +10,11 @@
  *
  * @packageDocumentation @preferred
  */
-export * from './interface';
-export * from './hookBuilder';
-export * from './hookRegistry';
-export * from './rejectFactory';
-export * from './transition';
-export * from './transitionHook';
-export * from './transitionEventType';
-export * from './transitionService';
+export * from "./interface";
+export * from "./hookBuilder";
+export * from "./hookRegistry";
+export * from "./rejectFactory";
+export * from "./transition";
+export * from "./transitionHook";
+export * from "./transitionEventType";
+export * from "./transitionService";