@angular-wave/angular.ts 0.0.60 → 0.0.61

package/types-back/router/core/params/paramType.d.ts

@@ -1,65 +0,0 @@
-import { ParamTypeDefinition } from "./interface";
-/**
- * An internal class which implements [[ParamTypeDefinition]].
- *
- * A [[ParamTypeDefinition]] is a plain javascript object used to register custom parameter types.
- * When a param type definition is registered, an instance of this class is created internally.
- *
- * This class has naive implementations for all the [[ParamTypeDefinition]] methods.
- *
- * Used by [[UrlMatcher]] when matching or formatting URLs, or comparing and validating parameter values.
- *
- * #### Example:
- * ```js
- * var paramTypeDef = {
- *   decode: function(val) { return parseInt(val, 10); },
- *   encode: function(val) { return val && val.toString(); },
- *   equals: function(a, b) { return this.is(a) && a === b; },
- *   is: function(val) { return angular.isNumber(val) && isFinite(val) && val % 1 === 0; },
- *   pattern: /\d+/
- * }
- *
- * var paramType = new ParamType(paramTypeDef);
- * ```
- */
-export declare class ParamType implements ParamTypeDefinition {
-  /** @inheritdoc */
-  pattern: RegExp;
-  /** The name/id of the parameter type */
-  name: string;
-  /** @inheritdoc */
-  raw: boolean;
-  /** @inheritdoc */
-  dynamic: boolean;
-  /** @inheritdoc */
-  inherit: boolean;
-  /**
-   * @param def  A configuration object which contains the custom type definition.  The object's
-   *        properties will override the default methods and/or pattern in `ParamType`'s public interface.
-   * @returns a new ParamType object
-   */
-  constructor(def: ParamTypeDefinition);
-  /** @inheritdoc */
-  is(val: any, key?: string): boolean;
-  /** @inheritdoc */
-  encode(val: any, key?: string): string | string[];
-  /** @inheritdoc */
-  decode(val: string, key?: string): any;
-  /** @inheritdoc */
-  equals(a: any, b: any): boolean;
-  $subPattern(): string;
-  toString(): string;
-  /** Given an encoded string, or a decoded object, returns a decoded object */
-  $normalize(val: any): any;
-  /**
-   * Wraps an existing custom ParamType as an array of ParamType, depending on 'mode'.
-   * e.g.:
-   * - urlmatcher pattern "/path?{queryParam[]:int}"
-   * - url: "/path?queryParam=1&queryParam=2
-   * - $stateParams.queryParam will be [1, 2]
-   * if `mode` is "auto", then
-   * - url: "/path?queryParam=1 will create $stateParams.queryParam: 1
-   * - url: "/path?queryParam=1&queryParam=2 will create $stateParams.queryParam: [1, 2]
-   */
-  $asArray(mode: boolean | "auto", isSearch: boolean): any;
-}

package/types-back/router/core/params/paramTypes.d.ts

@@ -1,193 +0,0 @@
-import { ParamTypeDefinition } from "./interface";
-/**
- * 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 declare class ParamTypes {
-  /**
-   * Built-in parameter type: `string`
-   *
-   * This parameter type coerces values to strings.
-   * It matches anything (`new RegExp(".*")`) in the URL
-   */
-  static string: ParamTypeDefinition;
-  /**
-   * Built-in parameter type: `path`
-   *
-   * This parameter type is the default type for path parameters.
-   * A path parameter is any parameter declared in the path portion of a url
-   *
-   * - `/foo/:param1/:param2`: two path parameters
-   *
-   * This parameter type behaves exactly like the [[string]] type with one exception.
-   * When matching parameter values in the URL, the `path` type does not match forward slashes `/`.
-   *
-   * #### Angular 1 note:
-   * In ng1, this type is overridden with one that pre-encodes slashes as `~2F` instead of `%2F`.
-   * For more details about this angular 1 behavior, see: https://github.com/angular-ui/ui-router/issues/2598
-   */
-  static path: ParamTypeDefinition;
-  /**
-   * Built-in parameter type: `query`
-   *
-   * This parameter type is the default type for query/search parameters.
-   * It behaves the same as the [[string]] parameter type.
-   *
-   * A query parameter is any parameter declared in the query/search portion of a url
-   *
-   * - `/bar?param2`: a query parameter
-   */
-  static query: ParamTypeDefinition;
-  /**
-   * Built-in parameter type: `hash`
-   *
-   * This parameter type is used for the `#` parameter (the hash)
-   * It behaves the same as the [[string]] parameter type.
-   */
-  static hash: ParamTypeDefinition;
-  /**
-   * Built-in parameter type: `int`
-   *
-   * This parameter type serializes javascript integers (`number`s which represent an integer) to the URL.
-   *
-   * #### Example:
-   * ```js
-   * .state({
-   *   name: 'user',
-   *   url: '/user/{id:int}'
-   * });
-   * ```
-   * ```js
-   * $state.go('user', { id: 1298547 });
-   * ```
-   *
-   * The URL will serialize to: `/user/1298547`.
-   *
-   * When the parameter value is read, it will be the `number` `1298547`, not the string `"1298547"`.
-   */
-  static int: ParamTypeDefinition;
-  /**
-   * Built-in parameter type: `bool`
-   *
-   * This parameter type serializes `true`/`false` as `1`/`0`
-   *
-   * #### Example:
-   * ```js
-   * .state({
-   *   name: 'inbox',
-   *   url: '/inbox?{unread:bool}'
-   * });
-   * ```
-   * ```js
-   * $state.go('inbox', { unread: true });
-   * ```
-   *
-   * The URL will serialize to: `/inbox?unread=1`.
-   *
-   * Conversely, if the url is `/inbox?unread=0`, the value of the `unread` parameter will be a `false`.
-   */
-  static bool: ParamTypeDefinition;
-  /**
-   * Built-in parameter type: `date`
-   *
-   * This parameter type can be used to serialize Javascript dates as parameter values.
-   *
-   * #### Example:
-   * ```js
-   * .state({
-   *   name: 'search',
-   *   url: '/search?{start:date}'
-   * });
-   * ```
-   * ```js
-   * $state.go('search', { start: new Date(2000, 0, 1) });
-   * ```
-   *
-   * The URL will serialize to: `/search?start=2000-01-01`.
-   *
-   * Conversely, if the url is `/search?start=2016-12-25`, the value of the `start` parameter will be a `Date` object where:
-   *
-   * - `date.getFullYear() === 2016`
-   * - `date.getMonth() === 11` (month is 0-based)
-   * - `date.getDate() === 25`
-   */
-  static date: ParamTypeDefinition;
-  /**
-   * Built-in parameter type: `json`
-   *
-   * This parameter type can be used to serialize javascript objects into the URL using JSON serialization.
-   *
-   * #### Example:
-   * This example serializes an plain javascript object to the URL
-   * ```js
-   * .state({
-   *   name: 'map',
-   *   url: '/map/{coords:json}'
-   * });
-   * ```
-   * ```js
-   * $state.go('map', { coords: { x: 10399.2, y: 49071 });
-   * ```
-   *
-   * The URL will serialize to: `/map/%7B%22x%22%3A10399.2%2C%22y%22%3A49071%7D`
-   */
-  static json: ParamTypeDefinition;
-  /**
-   * Built-in parameter type: `any`
-   *
-   * This parameter type is used by default for url-less parameters (parameters that do not appear in the URL).
-   * This type does not encode or decode.
-   * It is compared using a deep `equals` comparison.
-   *
-   * #### Example:
-   * This example defines a non-url parameter on a [[StateDeclaration]].
-   * ```js
-   * .state({
-   *   name: 'new',
-   *   url: '/new',
-   *   params: {
-   *     inrepyto: null
-   *   }
-   * });
-   * ```
-   * ```js
-   * $state.go('new', { inreplyto: currentMessage });
-   * ```
-   */
-  static any: ParamTypeDefinition;
-  types: any;
-  enqueue: boolean;
-  typeQueue: any[];
-  private defaultTypes;
-  constructor();
-  /**
-   * Registers a parameter type
-   *
-   * End users should call [[UrlMatcherFactory.type]], which delegates to this method.
-   */
-  type(
-    name: string,
-    definition?: ParamTypeDefinition,
-    definitionFn?: () => ParamTypeDefinition,
-  ): any;
-  _flushTypeQueue(): void;
-}

package/types-back/router/core/params/stateParams.d.ts

@@ -1,15 +0,0 @@
-import { Obj } from "../common/common";
-import { StateObject } from "../state/stateObject";
-export declare class StateParams {
-  [key: string]: any;
-  constructor(params?: Obj);
-  /**
-   * 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: Obj, $current: StateObject, $to: StateObject): any;
-}

package/types-back/router/core/path/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./pathNode";
-export * from "./pathUtils";

package/types-back/router/core/path/pathNode.d.ts

@@ -1,60 +0,0 @@
-import { StateObject } from "../state/stateObject";
-import { RawParams } from "../params/interface";
-import { Param } from "../params/param";
-import { Resolvable } from "../resolve/resolvable";
-import { ViewConfig } from "../view/interface";
-/**
- * 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 declare class PathNode {
-  /** The state being entered, exited, or retained */
-  state: StateObject;
-  /** The parameters declared on the state */
-  paramSchema: Param[];
-  /** The parameter values that belong to the state */
-  paramValues: {
-    [key: string]: any;
-  };
-  /** The individual (stateful) resolvable objects that belong to the state */
-  resolvables: Resolvable[];
-  /** The state's declared view configuration objects */
-  views: ViewConfig[];
-  /**
-   * Returns a clone of the PathNode
-   * @deprecated use instance method `node.clone()`
-   */
-  static clone: (node: PathNode) => PathNode;
-  /** Creates a copy of a PathNode */
-  constructor(node: PathNode);
-  /** Creates a new (empty) PathNode for a State */
-  constructor(state: StateObject);
-  clone(): PathNode;
-  /** Sets [[paramValues]] for the node, from the values of an object hash */
-  applyRawParams(params: RawParams): PathNode;
-  /** Gets a specific [[Param]] metadata that belongs to the node */
-  parameter(name: string): Param;
-  /**
-   * @returns true if the state and parameter values for another PathNode are
-   * equal to the state and param values for this PathNode
-   */
-  equals(node: PathNode, paramsFn?: GetParamsFn): 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: PathNode, paramsFn?: GetParamsFn): Param[] | false;
-}
-/** @internal */
-export declare type GetParamsFn = (pathNode: PathNode) => Param[];

package/types-back/router/core/path/pathUtils.d.ts

@@ -1,105 +0,0 @@
-import { Predicate } from "../common/common";
-import { TreeChanges } from "../transition/interface";
-import { StateObject } from "../state/stateObject";
-import { TargetState } from "../state/targetState";
-import { GetParamsFn, PathNode } from "./pathNode";
-import { ViewService } from "../view/view";
-import { Param } from "../params/param";
-import { StateRegistry } from "../state";
-/**
- * This class contains functions which convert TargetStates, Nodes and paths from one type to another.
- */
-export declare class PathUtils {
-  /** Given a PathNode[], create an TargetState */
-  static makeTargetState(
-    registry: StateRegistry,
-    path: PathNode[],
-  ): TargetState;
-  static buildPath(targetState: TargetState): PathNode[];
-  /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */
-  static buildToPath(
-    fromPath: PathNode[],
-    targetState: TargetState,
-  ): PathNode[];
-  /**
-   * 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: ViewService,
-    path: PathNode[],
-    states: StateObject[],
-  ): 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: PathNode[],
-    toPath: PathNode[],
-    toKeys?: string[],
-  ): PathNode[];
-  static nonDynamicParams: (node: PathNode) => Param[];
-  /**
-   * Computes the tree changes (entering, exiting) between a fromPath and toPath.
-   */
-  static treeChanges(
-    fromPath: PathNode[],
-    toPath: PathNode[],
-    reloadState: StateObject,
-  ): 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: PathNode[],
-    pathB: PathNode[],
-    paramsFn?: GetParamsFn,
-  ): PathNode[];
-  /**
-   * 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: PathNode[],
-    pathB: PathNode[],
-    paramsFn?: GetParamsFn,
-  ): 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: PathNode[], predicate: Predicate<PathNode>): PathNode[];
-  /** Gets the raw parameter values from a path */
-  static paramValues: (path: PathNode[]) => any;
-}

package/types-back/router/core/resolve/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./interface";
-export * from "./resolvable";
-export * from "./resolveContext";

package/types-back/router/core/resolve/interface.d.ts

@@ -1,210 +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 declare type PolicyWhen = "LAZY" | "EAGER";
-export declare type PolicyAsync = "WAIT" | "NOWAIT" | CustomAsyncPolicy;
-export interface CustomAsyncPolicy {
-  (data: any): Promise<any>;
-}
-export declare let resolvePolicies: {
-  when: {
-    LAZY: string;
-    EAGER: string;
-  };
-  async: {
-    WAIT: string;
-    NOWAIT: string;
-  };
-};