@angular-wave/angular.ts 0.0.20 → 0.0.22

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

@@ -1,65 +1,77 @@
-import { RawParams } from '../params/interface';
-import { ParamType } from './paramType';
-import { StateDeclaration } from '../state';
-import { UrlConfig } from '../url';
+import { RawParams } from "../params/interface";
+import { ParamType } from "./paramType";
+import { StateDeclaration } from "../state";
+import { UrlConfig } from "../url";
 declare enum DefType {
-    PATH = 0,
-    SEARCH = 1,
-    CONFIG = 2
+  PATH = 0,
+  SEARCH = 1,
+  CONFIG = 2,
 }
 export { DefType };
 export declare class Param {
-    id: string;
-    type: ParamType;
-    location: DefType;
-    isOptional: boolean;
-    dynamic: boolean;
-    raw: boolean;
-    squash: boolean | string;
-    replace: [{
-        to: any;
-        from: any;
-    }];
-    inherit: boolean;
-    array: boolean;
-    config: any;
-    /** Cache the default value if it is a static value */
-    _defaultValueCache: {
-        defaultValue: any;
-    };
-    static values(params: Param[], values?: RawParams): RawParams;
-    /**
-     * 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: Param[], values1?: RawParams, values2?: RawParams): Param[];
-    /**
-     * 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: Param[], values1?: {}, values2?: {}): boolean;
-    /** Returns true if a the parameter values are valid, according to the Param definitions */
-    static validates(params: Param[], values?: RawParams): boolean;
-    constructor(id: string, type: ParamType, location: DefType, urlConfig: UrlConfig, state: StateDeclaration);
-    isDefaultValue(value: any): boolean;
-    /**
-     * [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;
-    isSearch(): boolean;
-    validates(value: any): boolean;
-    toString(): string;
+  id: string;
+  type: ParamType;
+  location: DefType;
+  isOptional: boolean;
+  dynamic: boolean;
+  raw: boolean;
+  squash: boolean | string;
+  replace: [
+    {
+      to: any;
+      from: any;
+    },
+  ];
+  inherit: boolean;
+  array: boolean;
+  config: any;
+  /** Cache the default value if it is a static value */
+  _defaultValueCache: {
+    defaultValue: any;
+  };
+  static values(params: Param[], values?: RawParams): RawParams;
+  /**
+   * 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: Param[],
+    values1?: RawParams,
+    values2?: RawParams,
+  ): Param[];
+  /**
+   * 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: Param[], values1?: {}, values2?: {}): boolean;
+  /** Returns true if a the parameter values are valid, according to the Param definitions */
+  static validates(params: Param[], values?: RawParams): boolean;
+  constructor(
+    id: string,
+    type: ParamType,
+    location: DefType,
+    urlConfig: UrlConfig,
+    state: StateDeclaration,
+  );
+  isDefaultValue(value: any): boolean;
+  /**
+   * [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;
+  isSearch(): boolean;
+  validates(value: any): boolean;
+  toString(): string;
 }

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

@@ -1,4 +1,4 @@
-import { ParamTypeDefinition } from './interface';
+import { ParamTypeDefinition } from "./interface";
 /**
  * An internal class which implements [[ParamTypeDefinition]].
  *
@@ -23,43 +23,43 @@ import { ParamTypeDefinition } from './interface';
  * ```
  */
 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;
+  /** @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/router/core/params/paramTypes.d.ts

@@ -1,4 +1,4 @@
-import { ParamTypeDefinition } from './interface';
+import { ParamTypeDefinition } from "./interface";
 /**
  * A registry for parameter types.
  *
@@ -23,168 +23,172 @@ import { ParamTypeDefinition } from './interface';
  * ```
  */
 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();
-    dispose(): void;
-    /**
-     * 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;
+  /**
+   * 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();
+  dispose(): void;
+  /**
+   * 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/router/core/params/stateParams.d.ts

@@ -1,15 +1,15 @@
-import { Obj } from '../common/common';
-import { StateObject } from '../state/stateObject';
+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;
+  [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/router/core/path/index.d.ts

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