@angular-wave/angular.ts 0.0.20 → 0.0.22

package/types/router/core/common/common.d.ts

@@ -1,4 +1,4 @@
-import { StateObject } from '../state/stateObject';
+import { StateObject } from "../state/stateObject";
 export declare const root: any;
 export declare const fromJson: any;
 export declare const toJson: any;
@@ -6,10 +6,9 @@ export declare const forEach: any;
 export declare const extend: typeof _extend;
 export declare const equals: any;
 export declare function identity(x: any): any;
-export declare function noop(): any;
 export declare type Mapper<X, T> = (x: X, key?: string | number) => T;
 export interface TypedMap<T> {
-    [key: string]: T;
+  [key: string]: T;
 }
 export declare type Predicate<X> = (x?: X) => boolean;
 export declare type PredicateBinary<X, Y> = (x?: X, y?: Y) => boolean;
@@ -40,7 +39,7 @@ export declare type PredicateBinary<X, Y> = (x?: X, y?: Y) => boolean;
  */
 export declare type IInjectable = Function | any[];
 export interface Obj extends Object {
-    [key: string]: any;
+  [key: string]: any;
 }
 /**
  * Builds proxy functions on the `to` object which pass through to the `from` object.
@@ -98,7 +97,13 @@ export interface Obj extends Object {
  * @param fnNames The function names which will be bound (Defaults to all the functions found on the 'from' object)
  * @param latebind If true, the binding of the function is delayed until the first time it's invoked
  */
-export declare function createProxyFunctions(source: Function, target: Obj, bind: Function, fnNames?: string[], latebind?: boolean): Obj;
+export declare function createProxyFunctions(
+  source: Function,
+  target: Obj,
+  bind: Function,
+  fnNames?: string[],
+  latebind?: boolean,
+): Obj;
 /**
  * prototypal inheritance helper.
  * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it
@@ -136,7 +141,10 @@ export declare const mergeR: (memo: Obj, item: Obj) => any;
  * @param {Object} second The second state.
  * @return {Array} Returns an array of state names in descending order, not including the root.
  */
-export declare function ancestors(first: StateObject, second: StateObject): StateObject[];
+export declare function ancestors(
+  first: StateObject,
+  second: StateObject,
+): StateObject[];
 /**
  * Return a copy of the object only containing the whitelisted properties.
  *
@@ -165,31 +173,55 @@ export declare function omit(obj: Obj, propNames: string[]): Obj;
 /** Given an array of objects, maps each element to a named property of the element. */
 export declare function pluck<T>(collection: Obj[], propName: string): T[];
 /** Given an object, maps each property of the object to a named property of the property. */
-export declare function pluck(collection: {
-    [key: string]: any;
-}, propName: string): {
+export declare function pluck(
+  collection: {
     [key: string]: any;
+  },
+  propName: string,
+): {
+  [key: string]: any;
 };
 /** Given an array of objects, returns a new array containing only the elements which passed the callback predicate */
-export declare function filter<T>(collection: T[], callback: (t: T, key?: number) => boolean): T[];
+export declare function filter<T>(
+  collection: T[],
+  callback: (t: T, key?: number) => boolean,
+): T[];
 /** Given an object, returns a new object with only those properties that passed the callback predicate */
-export declare function filter<T>(collection: TypedMap<T>, callback: (t: T, key?: string) => boolean): TypedMap<T>;
+export declare function filter<T>(
+  collection: TypedMap<T>,
+  callback: (t: T, key?: string) => boolean,
+): TypedMap<T>;
 /** Given an object, return the first property of that object which passed the callback predicate */
-export declare function find<T>(collection: TypedMap<T>, callback: Predicate<T>): T;
+export declare function find<T>(
+  collection: TypedMap<T>,
+  callback: Predicate<T>,
+): T;
 /** Given an array of objects, returns the first object which passed the callback predicate */
 export declare function find<T>(collection: T[], callback: Predicate<T>): T;
 /** Given an object, returns a new object, where each property is transformed by the callback function */
-export declare let mapObj: <T, U>(collection: {
+export declare let mapObj: <T, U>(
+  collection: {
     [key: string]: T;
-}, callback: Mapper<T, U>, target?: typeof collection) => {
-    [key: string]: U;
+  },
+  callback: Mapper<T, U>,
+  target?: typeof collection,
+) => {
+  [key: string]: U;
 };
 /** Given an array, returns a new array, where each element is transformed by the callback function */
-export declare function map<T, U>(collection: T[], callback: Mapper<T, U>, target?: typeof collection): U[];
-export declare function map<T, U>(collection: {
+export declare function map<T, U>(
+  collection: T[],
+  callback: Mapper<T, U>,
+  target?: typeof collection,
+): U[];
+export declare function map<T, U>(
+  collection: {
     [key: string]: T;
-}, callback: Mapper<T, U>, target?: typeof collection): {
-    [key: string]: U;
+  },
+  callback: Mapper<T, U>,
+  target?: typeof collection,
+): {
+  [key: string]: U;
 };
 /**
  * Given an object, return its enumerable property values
@@ -293,7 +325,10 @@ export declare const flatten: (arr: any[]) => any;
  * oneString.filter(assertPredicate(isNumber, "Not all numbers")); // throws Error(""Not all numbers"");
  * ```
  */
-export declare const assertPredicate: <T>(predicate: Predicate<T>, errMsg: string | Function) => Predicate<T>;
+export declare const assertPredicate: <T>(
+  predicate: Predicate<T>,
+  errMsg: string | Function,
+) => Predicate<T>;
 /**
  * Given a .map function, builds a .map function which throws an error if any mapped elements do not pass a truthyness test.
  * @example
@@ -310,8 +345,14 @@ export declare const assertPredicate: <T>(predicate: Predicate<T>, errMsg: strin
  * // throws Error("Key not found")
  * ```
  */
-export declare const assertMap: <T, U>(mapFn: (t: T) => U, errMsg: string | Function) => (t: T) => U;
-export declare function assertFn(predicateOrMap: Function, errMsg?: string | Function): any;
+export declare const assertMap: <T, U>(
+  mapFn: (t: T) => U,
+  errMsg: string | Function,
+) => (t: T) => U;
+export declare function assertFn(
+  predicateOrMap: Function,
+  errMsg?: string | Function,
+): any;
 /**
  * Like _.pairs: Given an object, returns an array of key/value pairs
  *
@@ -357,7 +398,10 @@ export declare function arrayTuples(...args: any[]): any[];
  * // pairsToObj == { fookey: "fooval", barkey: "barval" }
  * ```
  */
-export declare function applyPairs(memo: TypedMap<any>, keyValTuple: any[]): TypedMap<any>;
+export declare function applyPairs(
+  memo: TypedMap<any>,
+  keyValTuple: any[],
+): TypedMap<any>;
 /** Get the last element of an array */
 export declare function tail<T>(arr: T[]): T;
 /**
@@ -366,5 +410,7 @@ export declare function tail<T>(arr: T[]): T;
 export declare function copy(src: Obj, dest?: Obj): any;
 /** Like Object.assign() */
 export declare function _extend(toObj: Obj, ...fromObjs: Obj[]): any;
-export declare const silenceUncaughtInPromise: (promise: Promise<any>) => Promise<any>;
+export declare const silenceUncaughtInPromise: (
+  promise: Promise<any>,
+) => Promise<any>;
 export declare const silentRejection: (error: any) => Promise<any>;

package/types/router/core/common/coreservices.d.ts

@@ -4,36 +4,34 @@
  *
  * @packageDocumentation
  */
-import { IInjectable, Obj } from './common';
-import { Disposable } from '../interface';
-import { UrlConfig, UrlService } from '../url';
+import { IInjectable, Obj } from "./common";
+import { Disposable } from "../interface";
+import { UrlConfig, UrlService } from "../url";
 export declare const makeStub: <T>(service: string, methods: (keyof T)[]) => T;
 declare const services: CoreServices;
 export interface $QLikeDeferred {
-    resolve: (val?: any) => void;
-    reject: (reason?: any) => void;
-    promise: Promise<any>;
+  resolve: (val?: any) => void;
+  reject: (reason?: any) => void;
+  promise: Promise<any>;
 }
 export interface $QLike {
-    when<T>(value?: T | PromiseLike<T>): Promise<T>;
-    reject<T>(reason: any): Promise<T>;
-    defer(): $QLikeDeferred;
-    all(promises: {
-        [key: string]: Promise<any>;
-    }): Promise<any>;
-    all(promises: Promise<any>[]): Promise<any[]>;
+  when<T>(value?: T | PromiseLike<T>): Promise<T>;
+  reject<T>(reason: any): Promise<T>;
+  defer(): $QLikeDeferred;
+  all(promises: { [key: string]: Promise<any> }): Promise<any>;
+  all(promises: Promise<any>[]): Promise<any[]>;
 }
 export interface $InjectorLike {
-    strictDi?: boolean;
-    get(token: any): any;
-    get<T>(token: any): T;
-    has(token: any): boolean;
-    invoke(fn: IInjectable, context?: any, locals?: Obj): any;
-    annotate(fn: IInjectable, strictDi?: boolean): any[];
+  strictDi?: boolean;
+  get(token: any): any;
+  get<T>(token: any): T;
+  has(token: any): boolean;
+  invoke(fn: IInjectable, context?: any, locals?: Obj): any;
+  annotate(fn: IInjectable, strictDi?: boolean): any[];
 }
 export interface CoreServices {
-    $q: $QLike;
-    $injector: $InjectorLike;
+  $q: $QLike;
+  $injector: $InjectorLike;
 }
 /**
  * Handles low level URL read/write
@@ -49,11 +47,11 @@ export interface CoreServices {
  * - [[MemoryLocationService]]
  */
 export interface LocationServices extends Disposable {
-    /** See: [[UrlService.url]] */ url: UrlService['url'];
-    /** See: [[UrlService.path]] */ path: UrlService['path'];
-    /** See: [[UrlService.search]] */ search: UrlService['search'];
-    /** See: [[UrlService.hash]] */ hash: UrlService['hash'];
-    /** See: [[UrlService.onChange]] */ onChange: UrlService['onChange'];
+  /** See: [[UrlService.url]] */ url: UrlService["url"];
+  /** See: [[UrlService.path]] */ path: UrlService["path"];
+  /** See: [[UrlService.search]] */ search: UrlService["search"];
+  /** See: [[UrlService.hash]] */ hash: UrlService["hash"];
+  /** See: [[UrlService.onChange]] */ onChange: UrlService["onChange"];
 }
 /**
  * Returns low level URL configuration and metadata
@@ -70,11 +68,11 @@ export interface LocationServices extends Disposable {
  * - [[MemoryLocationConfig]]
  */
 export interface LocationConfig extends Disposable {
-    /** See: [[UrlConfig.port]] */ port: UrlConfig['port'];
-    /** See: [[UrlConfig.protocol]] */ protocol: UrlConfig['protocol'];
-    /** See: [[UrlConfig.host]] */ host: UrlConfig['host'];
-    /** See: [[UrlConfig.baseHref]] */ baseHref: UrlConfig['baseHref'];
-    /** See: [[UrlConfig.html5Mode]] */ html5Mode: UrlConfig['html5Mode'];
-    /** See: [[UrlConfig.hashPrefix]] */ hashPrefix: UrlConfig['hashPrefix'];
+  /** See: [[UrlConfig.port]] */ port: UrlConfig["port"];
+  /** See: [[UrlConfig.protocol]] */ protocol: UrlConfig["protocol"];
+  /** See: [[UrlConfig.host]] */ host: UrlConfig["host"];
+  /** See: [[UrlConfig.baseHref]] */ baseHref: UrlConfig["baseHref"];
+  /** See: [[UrlConfig.html5Mode]] */ html5Mode: UrlConfig["html5Mode"];
+  /** See: [[UrlConfig.hashPrefix]] */ hashPrefix: UrlConfig["hashPrefix"];
 }
 export { services };

package/types/router/core/common/glob.d.ts

@@ -48,13 +48,13 @@
  * @packageDocumentation
  */
 export declare class Glob {
-    text: string;
-    glob: Array<string>;
-    regexp: RegExp;
-    /** Returns true if the string has glob-like characters in it */
-    static is(text: string): boolean;
-    /** Returns a glob from the string, or null if the string isn't Glob-like */
-    static fromString(text: string): Glob;
-    constructor(text: string);
-    matches(name: string): boolean;
+  text: string;
+  glob: Array<string>;
+  regexp: RegExp;
+  /** Returns true if the string has glob-like characters in it */
+  static is(text: string): boolean;
+  /** Returns a glob from the string, or null if the string isn't Glob-like */
+  static fromString(text: string): Glob;
+  constructor(text: string);
+  matches(name: string): boolean;
 }

package/types/router/core/common/hof.d.ts

@@ -5,7 +5,7 @@
  *
  * @packageDocumentation
  */
-import { Predicate } from './common';
+import { Predicate } from "./common";
 /**
  * Returns a new function for [Partial Application](https://en.wikipedia.org/wiki/Partial_application) of the original function.
  *
@@ -95,12 +95,18 @@ export declare const not: (fn: Predicate<any>) => Predicate<any>;
  * Given two functions that return truthy or falsey values, returns a function that returns truthy
  * if both functions return truthy for the given arguments
  */
-export declare function and(fn1: Predicate<any>, fn2: Predicate<any>): Predicate<any>;
+export declare function and(
+  fn1: Predicate<any>,
+  fn2: Predicate<any>,
+): Predicate<any>;
 /**
  * Given two functions that return truthy or falsey values, returns a function that returns truthy
  * if at least one of the functions returns truthy for the given arguments
  */
-export declare function or(fn1: Predicate<any>, fn2: Predicate<any>): Predicate<any>;
+export declare function or(
+  fn1: Predicate<any>,
+  fn2: Predicate<any>,
+): Predicate<any>;
 /**
  * Check if all the elements of an array match a predicate function
  *
@@ -110,7 +116,9 @@ export declare function or(fn1: Predicate<any>, fn2: Predicate<any>): Predicate<
 export declare const all: (fn1: Predicate<any>) => (arr: any[]) => boolean;
 export declare const any: (fn1: Predicate<any>) => (arr: any[]) => boolean;
 /** Given a class, returns a Predicate function that returns true if the object is of that class */
-export declare const is: <T>(ctor: new (...args: any[]) => T) => (obj: any) => obj is T;
+export declare const is: <T>(
+  ctor: new (...args: any[]) => T,
+) => (obj: any) => obj is T;
 /** Given a value, returns a Predicate function that returns true if another value is === equal to the original value */
 export declare const eq: (comp: any) => Predicate<any>;
 /** Given a value, returns a function which returns the value */

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

@@ -1,8 +1,8 @@
-export * from './common';
-export * from './coreservices';
-export * from './glob';
-export * from './hof';
-export * from './predicates';
-export * from './queue';
-export * from './strings';
-export * from './trace';
+export * from "./common";
+export * from "./coreservices";
+export * from "./glob";
+export * from "./hof";
+export * from "./predicates";
+export * from "./queue";
+export * from "./strings";
+export * from "./trace";

package/types/router/core/common/predicates.d.ts

@@ -1,4 +1,4 @@
-import { Predicate } from './common';
+import { Predicate } from "./common";
 export declare const isUndefined: (x: any) => boolean;
 export declare const isDefined: Predicate<any>;
 export declare const isNull: (o: any) => boolean;

package/types/router/core/common/queue.d.ts

@@ -1,15 +1,15 @@
 export declare class Queue<T> {
-    private _items;
-    private _limit;
-    private _evictListeners;
-    onEvict: (val: (item: T) => void) => (item: T) => void;
-    constructor(_items?: T[], _limit?: number);
-    enqueue(item: T): T;
-    evict(): T;
-    dequeue(): T;
-    clear(): Array<T>;
-    size(): number;
-    remove(item: T): T;
-    peekTail(): T;
-    peekHead(): T;
+  private _items;
+  private _limit;
+  private _evictListeners;
+  onEvict: (val: (item: T) => void) => (item: T) => void;
+  constructor(_items?: T[], _limit?: number);
+  enqueue(item: T): T;
+  evict(): T;
+  dequeue(): T;
+  clear(): Array<T>;
+  size(): number;
+  remove(item: T): T;
+  peekTail(): T;
+  peekHead(): T;
 }

package/types/router/core/common/safeConsole.d.ts

@@ -1,5 +1,5 @@
 export declare const safeConsole: {
-    log: any;
-    error: any;
-    table: any;
+  log: any;
+  error: any;
+  table: any;
 };

package/types/router/core/common/strings.d.ts

@@ -5,7 +5,7 @@
  *
  * @packageDocumentation
  */
-import { IInjectable } from './common';
+import { IInjectable } from "./common";
 /**
  * Returns a string shortened to a maximum length
  *
@@ -31,7 +31,9 @@ export declare function functionToString(fn: Function): any;
 export declare function fnToString(fn: IInjectable): any;
 export declare function stringify(o: any): string;
 /** Returns a function that splits a string on a character or substring */
-export declare const beforeAfterSubstr: (char: string) => (str: string) => string[];
+export declare const beforeAfterSubstr: (
+  char: string,
+) => (str: string) => string[];
 export declare const hostRegex: RegExp;
 export declare const stripLastPathElement: (str: string) => string;
 export declare const splitHash: (str: string) => string[];

package/types/router/core/common/trace.d.ts

@@ -1,12 +1,12 @@
-import { Transition } from '../transition/transition';
-import { ViewTuple } from '../view';
-import { ActiveUIView, ViewConfig, ViewContext } from '../view/interface';
-import { Resolvable } from '../resolve/resolvable';
-import { PathNode } from '../path/pathNode';
-import { PolicyWhen } from '../resolve/interface';
-import { TransitionHook } from '../transition/transitionHook';
-import { HookResult } from '../transition/interface';
-import { StateObject } from '../state/stateObject';
+import { Transition } from "../transition/transition";
+import { ViewTuple } from "../view";
+import { ActiveUIView, ViewConfig, ViewContext } from "../view/interface";
+import { Resolvable } from "../resolve/resolvable";
+import { PathNode } from "../path/pathNode";
+import { PolicyWhen } from "../resolve/interface";
+import { TransitionHook } from "../transition/transitionHook";
+import { HookResult } from "../transition/interface";
+import { StateObject } from "../state/stateObject";
 /**
  * Trace categories Enum
  *
@@ -21,85 +21,97 @@ import { StateObject } from '../state/stateObject';
  * `trace.enable(1)`
  */
 declare enum Category {
-    RESOLVE = 0,
-    TRANSITION = 1,
-    HOOK = 2,
-    UIVIEW = 3,
-    VIEWCONFIG = 4
+  RESOLVE = 0,
+  TRANSITION = 1,
+  HOOK = 2,
+  UIVIEW = 3,
+  VIEWCONFIG = 4,
 }
 export { Category };
 /**
  * Prints UI-Router Transition trace information to the console.
  */
 export declare class Trace {
-    /** @internal */
-    approximateDigests: number;
-    /** @internal */
-    private _enabled;
-    /** @internal */
-    constructor();
-    /** @internal */
-    private _set;
-    /**
-     * Enables a trace [[Category]]
-     *
-     * ```js
-     * trace.enable("TRANSITION");
-     * ```
-     *
-     * @param categories categories to enable. If `categories` is omitted, all categories are enabled.
-     *        Also takes strings (category name) or ordinal (category position)
-     */
-    enable(...categories: (Category | string | number)[]): any;
-    /**
-     * Disables a trace [[Category]]
-     *
-     * ```js
-     * trace.disable("VIEWCONFIG");
-     * ```
-     *
-     * @param categories categories to disable. If `categories` is omitted, all categories are disabled.
-     *        Also takes strings (category name) or ordinal (category position)
-     */
-    disable(...categories: (Category | string | number)[]): any;
-    /**
-     * Retrieves the enabled stateus of a [[Category]]
-     *
-     * ```js
-     * trace.enabled("VIEWCONFIG"); // true or false
-     * ```
-     *
-     * @returns boolean true if the category is enabled
-     */
-    enabled(category: Category | string | number): boolean;
-    /** @internal called by ui-router code */
-    traceTransitionStart(trans: Transition): void;
-    /** @internal called by ui-router code */
-    traceTransitionIgnored(trans: Transition): void;
-    /** @internal called by ui-router code */
-    traceHookInvocation(step: TransitionHook, trans: Transition, options: any): void;
-    /** @internal called by ui-router code */
-    traceHookResult(hookResult: HookResult, trans: Transition, transitionOptions: any): void;
-    /** @internal called by ui-router code */
-    traceResolvePath(path: PathNode[], when: PolicyWhen, trans?: Transition): void;
-    /** @internal called by ui-router code */
-    traceResolvableResolved(resolvable: Resolvable, trans?: Transition): void;
-    /** @internal called by ui-router code */
-    traceError(reason: any, trans: Transition): void;
-    /** @internal called by ui-router code */
-    traceSuccess(finalState: StateObject, trans: Transition): void;
-    /** @internal called by ui-router code */
-    traceUIViewEvent(event: string, viewData: ActiveUIView, extra?: string): void;
-    /** @internal called by ui-router code */
-    traceUIViewConfigUpdated(viewData: ActiveUIView, context: ViewContext): void;
-    /** @internal called by ui-router code */
-    traceUIViewFill(viewData: ActiveUIView, html: string): void;
-    /** @internal called by ui-router code */
-    traceViewSync(pairs: ViewTuple[]): void;
-    /** @internal called by ui-router code */
-    traceViewServiceEvent(event: string, viewConfig: ViewConfig): void;
-    /** @internal called by ui-router code */
-    traceViewServiceUIViewEvent(event: string, viewData: ActiveUIView): void;
+  /** @internal */
+  approximateDigests: number;
+  /** @internal */
+  private _enabled;
+  /** @internal */
+  constructor();
+  /** @internal */
+  private _set;
+  /**
+   * Enables a trace [[Category]]
+   *
+   * ```js
+   * trace.enable("TRANSITION");
+   * ```
+   *
+   * @param categories categories to enable. If `categories` is omitted, all categories are enabled.
+   *        Also takes strings (category name) or ordinal (category position)
+   */
+  enable(...categories: (Category | string | number)[]): any;
+  /**
+   * Disables a trace [[Category]]
+   *
+   * ```js
+   * trace.disable("VIEWCONFIG");
+   * ```
+   *
+   * @param categories categories to disable. If `categories` is omitted, all categories are disabled.
+   *        Also takes strings (category name) or ordinal (category position)
+   */
+  disable(...categories: (Category | string | number)[]): any;
+  /**
+   * Retrieves the enabled stateus of a [[Category]]
+   *
+   * ```js
+   * trace.enabled("VIEWCONFIG"); // true or false
+   * ```
+   *
+   * @returns boolean true if the category is enabled
+   */
+  enabled(category: Category | string | number): boolean;
+  /** @internal called by ui-router code */
+  traceTransitionStart(trans: Transition): void;
+  /** @internal called by ui-router code */
+  traceTransitionIgnored(trans: Transition): void;
+  /** @internal called by ui-router code */
+  traceHookInvocation(
+    step: TransitionHook,
+    trans: Transition,
+    options: any,
+  ): void;
+  /** @internal called by ui-router code */
+  traceHookResult(
+    hookResult: HookResult,
+    trans: Transition,
+    transitionOptions: any,
+  ): void;
+  /** @internal called by ui-router code */
+  traceResolvePath(
+    path: PathNode[],
+    when: PolicyWhen,
+    trans?: Transition,
+  ): void;
+  /** @internal called by ui-router code */
+  traceResolvableResolved(resolvable: Resolvable, trans?: Transition): void;
+  /** @internal called by ui-router code */
+  traceError(reason: any, trans: Transition): void;
+  /** @internal called by ui-router code */
+  traceSuccess(finalState: StateObject, trans: Transition): void;
+  /** @internal called by ui-router code */
+  traceUIViewEvent(event: string, viewData: ActiveUIView, extra?: string): void;
+  /** @internal called by ui-router code */
+  traceUIViewConfigUpdated(viewData: ActiveUIView, context: ViewContext): void;
+  /** @internal called by ui-router code */
+  traceUIViewFill(viewData: ActiveUIView, html: string): void;
+  /** @internal called by ui-router code */
+  traceViewSync(pairs: ViewTuple[]): void;
+  /** @internal called by ui-router code */
+  traceViewServiceEvent(event: string, viewConfig: ViewConfig): void;
+  /** @internal called by ui-router code */
+  traceViewServiceUIViewEvent(event: string, viewData: ActiveUIView): void;
 }
 /**
  * The [[Trace]] singleton