@angular-wave/angular.ts 0.9.0 → 0.9.1

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

@@ -1,36 +0,0 @@
-/**
- * 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;
-  typeQueue: any[];
-  defaultTypes: {};
-  types: any;
-  /**
-   * Registers a parameter type
-   *
-   * End users should call [[UrlMatcherFactory.type]], which delegates to this method.
-   */
-  type(name: any, definition: any, definitionFn: any): any;
-  _flushTypeQueue(): void;
-}

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

@@ -1,71 +0,0 @@
-export type DefType = number;
-export namespace DefType {
-  let PATH: number;
-  let SEARCH: number;
-  let CONFIG: number;
-}
-export class Param {
-  static values(params: any, values?: {}): {};
-  /**
-   * 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
-   */
-  static changed(params: any, values1?: {}, values2?: {}): any;
-  /**
-   * Checks if two param value objects are equal (for a set of [[Param]] objects)
-   *
-   * @param 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;
-  /**
-   *
-   * @param {*} id
-   * @param {*} type
-   * @param {DefType} location
-   * @param {import("../url/url-config.js").UrlConfigProvider} urlConfig
-   * @param {*} state
-   */
-  constructor(
-    id: any,
-    type: any,
-    location: DefType,
-    urlConfig: import("../url/url-config.js").UrlConfigProvider,
-    state: any,
-  );
-  isOptional: boolean;
-  type: any;
-  location: number;
-  id: any;
-  dynamic: boolean;
-  raw: boolean;
-  squash: any;
-  replace: any;
-  inherit: boolean;
-  array: any;
-  config: any;
-  isDefaultValue(value: any): any;
-  /**
-   * [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.
-   */
-  value(value: any): any;
-  _defaultValueCache: {
-    defaultValue: any;
-  };
-  isSearch(): boolean;
-  validates(value: any): boolean;
-  toString(): string;
-}

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

@@ -1,12 +0,0 @@
-export class StateParams {
-  constructor(params?: {});
-  /**
-   * Merges a set of parameters with all parameters inherited between the common parents of the
-   * 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.
-   */
-  $inherit(newParams: any, $current: any, $to: any): any;
-}

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

@@ -1,38 +0,0 @@
-/**
- * A node in a [[TreeChanges]] path
- *
- * For a [[TreeChanges]] path, this class holds the stateful information for a single node in the path.
- * Each PathNode corresponds to a state being entered, exited, or retained.
- * The stateful information includes parameter values and resolve data.
- */
-export class PathNode {
-  constructor(stateOrNode: any);
-  state: any;
-  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): undefined;
-  /**
-   * @returns true if the state and parameter values for another PathNode are
-   * equal to the state and param values for this PathNode
-   */
-  equals(node: any, paramsFn: any): boolean;
-  /**
-   * Finds Params with different parameter values on another PathNode.
-   *
-   * Given another node (of the same state), finds the parameter values which differ.
-   * 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
-   */
-  diff(node: any, paramsFn: any): any;
-}

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

@@ -1,88 +0,0 @@
-/** Given a PathNode[], create an TargetState
- * @param {import("../state/state-registry.js").StateRegistryProvider} registry
- * @param {Array<PathNode>} path
- * @returns
- */
-export function makeTargetState(
-  registry: import("../state/state-registry.js").StateRegistryProvider,
-  path: Array<PathNode>,
-): TargetState;
-/**
- * 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;
-  /**
-   * Creates ViewConfig objects and adds to nodes.
-   *
-   * On each [[PathNode]], creates ViewConfig objects from the views: property of the node's state
-   */
-  static applyViewConfigs($view: any, path: any, states: any): void;
-  /**
-   * Given a fromPath and a toPath, returns a new to path which inherits parameters from the fromPath
-   *
-   * For a parameter in a node to be inherited from the from path:
-   * - The toPath's node must have a matching node in the fromPath (by state).
-   * - The parameter name must not be found in the toKeys parameter array.
-   *
-   * 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.
-   */
-  static inheritParams(fromPath: any, toPath: any, toKeys?: any[]): any;
-  /**
-   * Computes the tree changes (entering, exiting) between a fromPath and toPath.
-   * @param {PathNode[]} fromPath
-   * @param {PathNode[]} toPath
-   * @param {boolean} [reloadState]
-   * @returns {import("../transition/interface.js").TreeChanges}
-   */
-  static treeChanges(
-    fromPath: PathNode[],
-    toPath: PathNode[],
-    reloadState?: boolean,
-  ): import("../transition/interface.js").TreeChanges;
-  /**
-   * Returns a new path which is: the subpath of the first path which matches the second path.
-   *
-   * The new path starts from root and contains any nodes that match the nodes in the second path.
-   * It stops before the first non-matching node.
-   *
-   * 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
-   *
-   * @returns 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[];
-  /**
-   * Returns true if two paths are identical.
-   *
-   * @param pathA
-   * @param pathB
-   * @param 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;
-  /**
-   * 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
-   */
-  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;
-}
-import { PathNode } from "./path-node.js";
-import { TargetState } from "../state/target-state.js";

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

@@ -1,200 +0,0 @@
-/**
- * # The Resolve subsystem
- *
- * This subsystem is an asynchronous, hierarchical Dependency Injection system.
- *
- * Typically, resolve is configured on a state using a [[StateDeclaration.resolve]] declaration.
- *
- * @packageDocumentation
- */
-/**
- * An interface which is similar to an Angular 2 `Provider`
- */
-export interface ProviderLike {
-  provide: any;
-  useClass?: any;
-  useFactory?: Function;
-  useValue?: any;
-  useExisting?: any;
-  deps?: any[];
-}
-/**
- * A plain object used to describe a [[Resolvable]]
- *
- * These objects may be used in the [[StateDeclaration.resolve]] array to declare
- * async data that the state or substates require.
- *
- * #### Example:
- * ```js
- *
- * var state = {
- *   name: 'main',
- *   resolve: [
- *     { token: 'myData', deps: [MyDataApi], resolveFn: (myDataApi) => myDataApi.getData() },
- *   ],
- * }
- * ```
- */
-export interface ResolvableLiteral {
-  /**
-   * A Dependency Injection token
-   *
-   * This Resolvable's DI token.
-   * The Resolvable will be injectable elsewhere using the token.
-   */
-  token: any;
-  /**
-   * A function which fetches the Resolvable's data
-   *
-   * A function which returns one of:
-   *
-   * - The resolved value (synchronously)
-   * - A promise for the resolved value
-   * - An Observable of the resolved value(s)
-   *
-   * This function will be provided the dependencies listed in [[deps]] as its arguments.
-   * The resolve system will asynchronously fetch the dependencies before invoking this function.
-   */
-  resolveFn: Function;
-  /**
-   * Defines the Resolve Policy
-   *
-   * A policy that defines when to invoke the resolve,
-   * and whether to wait for async and unwrap the data
-   */
-  policy?: ResolvePolicy;
-  /**
-   * The Dependency Injection tokens
-   *
-   * This is an array of Dependency Injection tokens for the dependencies of the [[resolveFn]].
-   *
-   * The DI tokens are references to other `Resolvables`, or to other
-   * services from the native DI system.
-   */
-  deps?: any[];
-  /** Pre-resolved data. */
-  data?: any;
-}
-/**
- * Defines how a resolve is processed during a transition
- *
- * This object is the [[StateDeclaration.resolvePolicy]] property.
- *
- * #### Example:
- * ```js
- * // Fetched when the resolve's state is being entered.
- * // Wait for the promise to resolve.
- * var policy1 = { when: "LAZY", async: "WAIT" }
- *
- * // Fetched when the Transition is starting.
- * // Do not wait for the returned promise to resolve.
- * // Inject the raw promise/value
- * var policy2 = { when: "EAGER", async: "NOWAIT" }
- * ```
- *
- * The policy for a given Resolvable is merged from three sources (highest priority first):
- *
- * - 1) Individual resolve definition
- * - 2) State definition
- * - 3) Global default
- *
- * #### Example:
- * ```js
- * // Wait for an Observable to emit one item.
- * // Since `wait` is not specified, it uses the `wait`
- * // policy defined on the state, or the global default
- * // if no `wait` policy is defined on the state
- * import { RXWAIT } from '@uirouter/rx';
- *
- * var myResolvablePolicy = { async: RXWAIT }
- * ```
- */
-export interface ResolvePolicy {
-  /**
-   * Defines when a Resolvable is resolved (fetched) during a transition
-   *
-   * - `LAZY` (default)
-   *   - Resolved as the resolve's state is being entered
-   * - `EAGER`
-   *   - Resolved as the transition is starting
-   *
-   * #### Example:
-   * Resolves for `main` and `main.home` are fetched when each state is entered.
-   * All of `main` resolves are processed before fetching `main.home` resolves.
-   * ```js
-   * var state = {
-   *   name: 'main',
-   *   resolve: mainResolves, // defined elsewhere
-   *   resolvePolicy: { when: 'LAZY' }, // default
-   * }
-   *
-   * var state = {
-   *   name: 'main.home',
-   *   resolve: homeResolves, // defined elsewhere
-   *   resolvePolicy: { when: 'LAZY' }, // default
-   * }
-   * ```
-   *
-   * #### Example:
-   * Resolves for `main` and `main.home` are fetched at the same time when the transition starts.
-   * This happens earlier in the lifecycle than when states are entered.
-   * All of the `main` and `main.home` resolves are fetched as soon as possible.
-   * ```js
-   * var mainState = {
-   *   name: 'main',
-   *   resolve: mainResolves, // defined elsewhere
-   *   resolvePolicy: { when: 'EAGER' },
-   * }
-   *
-   * var homeState = {
-   *   name: 'main.home',
-   *   resolve: homeResolves, // defined elsewhere
-   *   resolvePolicy: { when: 'EAGER' },
-   * }
-   * ```
-   */
-  when?: PolicyWhen;
-  /**
-   * Determines the unwrapping behavior of asynchronous resolve values.
-   *
-   * - `WAIT` (default)
-   *   - If a promise is returned from the resolveFn, wait for the promise before proceeding
-   *   - The unwrapped value from the promise
-   * - `NOWAIT`
-   *   - If a promise is returned from the resolve, do not wait for the promise.
-   *   - Any other value returned is wrapped in a promise.
-   *   - The promise will not be unwrapped.
-   *   - The promise itself will be provided when the resolve is injected or bound elsewhere.
-   * - {@link CustomAsyncPolicy}
-   *   - You can define a custom function that will be called with the resolveFn value.
-   *   - This function must return a promise.
-   *   - The transition will wait for this promise before proceeding
-   *
-   *   NOTE: The previous `RXWAIT` policy has become a CustomAsyncPolicy function exported in `@uirouter/rx` package.
-   *
-   * #### Example:
-   * The `Transition` will not wait for the resolve promise(s) from `main` to settle before continuing.
-   * Resolves for `main` will be provided to components wrapped in a `Promise`.
-   *
-   * The `Transition` will wait for the `main.home` resolve promises.
-   * Resolved values will be unwrapped before being provided to components.
-   * ```js
-   * var mainState = {
-   *   name: 'main',
-   *   resolve: mainResolves, // defined elsewhere
-   *   resolvePolicy: { async: 'NOWAIT' },
-   * }
-   * var homeState = {
-   *   name: 'main.home',
-   *   resolve: homeResolves, // defined elsewhere
-   *   resolvePolicy: { async: 'WAIT' }, // default
-   * }
-   * ```
-   */
-  async?: PolicyAsync;
-}
-export type PolicyWhen = "LAZY" | "EAGER";
-export type PolicyAsync = "WAIT" | "NOWAIT" | CustomAsyncPolicy;
-export interface CustomAsyncPolicy {
-  (data: any): Promise<any>;
-}

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

@@ -1,50 +0,0 @@
-export namespace defaultResolvePolicy {
-  let when: string;
-  let async: string;
-}
-/**
- * The basic building block for the resolve system.
- *
- * Resolvables encapsulate a state's resolve's resolveFn, the resolveFn's declared dependencies, the wrapped (.promise),
- * and the unwrapped-when-complete (.data) result of the resolveFn.
- *
- * Resolvable.get() either retrieves the Resolvable's existing promise, or else invokes resolve() (which invokes the
- * resolveFn) and returns the resulting promise.
- *
- * Resolvable.get() and Resolvable.resolve() both execute within a context path, which is passed as the first
- * parameter to those fns.
- */
-export class Resolvable {
-  constructor(arg1: any, resolveFn: any, deps: any, policy: any, data: any);
-  resolved: boolean;
-  promise: Promise<any>;
-  token: any;
-  policy: any;
-  resolveFn: any;
-  deps: any;
-  data: any;
-  getPolicy(state: any): {
-    when: any;
-    async: any;
-  };
-  /**
-   * 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
-   */
-  resolve(resolveContext: any, trans: any): 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.
-   */
-  get(resolveContext: any, trans: any): Promise<any>;
-  toString(): string;
-  clone(): Resolvable;
-}
-export namespace Resolvable {
-  function fromData(token: any, data: any): Resolvable;
-}

package/@types/router/resolve/resolve-context.d.ts

@@ -1,102 +0,0 @@
-export namespace resolvePolicies {
-  namespace when {
-    let LAZY: string;
-    let EAGER: string;
-  }
-  namespace async {
-    let WAIT: string;
-    let NOWAIT: string;
-  }
-}
-/**
- * Encapsulates Dependency Injection for a path of nodes
- *
- * ng-router states are organized as a tree.
- * A nested state has a path of ancestors to the root of the tree.
- * When a state is being activated, each element in the path is wrapped as a [[PathNode]].
- * A `PathNode` is a stateful object that holds things like parameters and resolvables for the state being activated.
- *
- * The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.
- */
-export class ResolveContext {
-  constructor(_path: any);
-  _path: any;
-  /** Gets all the tokens found in the resolve context, de-duplicated */
-  getTokens(): any;
-  /**
-   * Gets the Resolvable that matches the token
-   *
-   * Gets the last Resolvable that matches the token in this context, or undefined.
-   * Throws an error if it doesn't exist in the ResolveContext
-   */
-  getResolvable(token: any): any;
-  /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
-  getPolicy(resolvable: any): any;
-  /**
-   * Returns a ResolveContext that includes a portion of this one
-   *
-   * Given a state, this method creates a new ResolveContext from this one.
-   * The new context starts at the first node (root) and stops at the node for the `state` parameter.
-   *
-   * #### Why
-   *
-   * When a transition is created, the nodes in the "To Path" are injected from a ResolveContext.
-   * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.
-   * The "To State" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).
-   * This method is used to create a narrower context when injecting ancestor nodes.
-   *
-   * @example
-   * `let ABCD = new ResolveContext([A, B, C, D]);`
-   *
-   * Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:
-   * When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.
-   * However, `B` should only be able to access resolvables from `A`, `B`.
-   *
-   * When resolving for the `B` node, first take the full "To Path" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.
-   * `let AB = ABCD.subcontext(a)`
-   */
-  subContext(state: any): ResolveContext;
-  /**
-   * Adds Resolvables to the node that matches the state
-   *
-   * This adds a [[Resolvable]] (generally one created on the fly; not declared on a [[StateDeclaration.resolve]] block).
-   * The resolvable is added to the node matching the `state` parameter.
-   *
-   * These new resolvables are not automatically fetched.
-   * The calling code should either fetch them, fetch something that depends on them,
-   * or rely on [[resolvePath]] being called when some state is being entered.
-   *
-   * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.
-   *
-   * @param {Resolvable[]} newResolvables the new Resolvables
-   * @param state Used to find the node to put the resolvable on
-   */
-  addResolvables(newResolvables: Resolvable[], state: any): void;
-  /**
-   * Returns a promise for an array of resolved path Element promises
-   *
-   * @param {string} when
-   * @param trans
-   * @returns {Promise<any>|any}
-   */
-  resolvePath(when: string, trans: any): Promise<any> | any;
-  injector(): UIInjectorImpl;
-  _injector: UIInjectorImpl;
-  findNode(resolvable: any): undefined;
-  /**
-   * Gets the async dependencies of a Resolvable
-   *
-   * Given a Resolvable, returns its dependencies as a Resolvable[]
-   * @param {Resolvable} resolvable
-   * @returns {Resolvable[]}
-   */
-  getDependencies(resolvable: Resolvable): Resolvable[];
-}
-import { Resolvable } from "./resolvable.js";
-declare class UIInjectorImpl {
-  native: any;
-  get(token: any): any;
-  getAsync(token: any): Promise<any>;
-  getNative(token: any): any;
-}
-export {};

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

@@ -1,47 +0,0 @@
-/** @typedef {import('../interface.ts').ServiceProvider} ServiceProvider } */
-/**
- * Global router state
- *
- * This is where we hold the global mutable state such as current state, current
- * params, current transition, etc.
- */
-export class Router {
-  /**
-   * Current parameter values
-   *
-   * The parameter values from the latest successful transition
-   * @type {StateParams}
-   */
-  params: StateParams;
-  /**
-   * @type {number}
-   */
-  lastStartedTransitionId: number;
-  /**
-   * @type {Queue<import("./transition/transition.js").Transition>}
-   */
-  transitionHistory: Queue<import("./transition/transition.js").Transition>;
-  /**
-   * @type {Queue<import("./transition/transition.js").Transition>}
-   */
-  successfulTransitions: Queue<import("./transition/transition.js").Transition>;
-  /**
-   * @type {import("./state/interface.ts").StateDeclaration|undefined}
-   */
-  current: import("./state/interface.ts").StateDeclaration | undefined;
-  /**
-   * @type {import("./state/state-object.js").StateObject|undefined}
-   */
-  $current: import("./state/state-object.js").StateObject | undefined;
-  /**
-   * @type {import("./transition/transition.js").Transition|undefined}
-   */
-  transition: import("./transition/transition.js").Transition | undefined;
-  $get: () => this;
-}
-/**
- * }
- */
-export type ServiceProvider = import("../interface.ts").ServiceProvider;
-import { StateParams } from "./params/state-params.js";
-import { Queue } from "../shared/queue.js";