@angular-wave/angular.ts 0.0.60 → 0.0.61

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

@@ -1,168 +0,0 @@
-/**
- * Higher order functions
- *
- * These utility functions are exported, but are subject to change without notice.
- *
- * @packageDocumentation
- */
-import { Predicate } from "./common";
-/**
- * Returns a new function for [Partial Application](https://en.wikipedia.org/wiki/Partial_application) of the original function.
- *
- * Given a function with N parameters, returns a new function that supports partial application.
- * The new function accepts anywhere from 1 to N parameters.  When that function is called with M parameters,
- * where M is less than N, it returns a new function that accepts the remaining parameters.  It continues to
- * accept more parameters until all N parameters have been supplied.
- *
- *
- * This contrived example uses a partially applied function as an predicate, which returns true
- * if an object is found in both arrays.
- * @example
- * ```
- * // returns true if an object is in both of the two arrays
- * function inBoth(array1, array2, object) {
- *   return array1.indexOf(object) !== -1 &&
- *          array2.indexOf(object) !== 1;
- * }
- * let obj1, obj2, obj3, obj4, obj5, obj6, obj7
- * let foos = [obj1, obj3]
- * let bars = [obj3, obj4, obj5]
- *
- * // A curried "copy" of inBoth
- * let curriedInBoth = curry(inBoth);
- * // Partially apply both the array1 and array2
- * let inFoosAndBars = curriedInBoth(foos, bars);
- *
- * // Supply the final argument; since all arguments are
- * // supplied, the original inBoth function is then called.
- * let obj1InBoth = inFoosAndBars(obj1); // false
- *
- * // Use the inFoosAndBars as a predicate.
- * // Filter, on each iteration, supplies the final argument
- * let allObjs = [ obj1, obj2, obj3, obj4, obj5, obj6, obj7 ];
- * let foundInBoth = allObjs.filter(inFoosAndBars); // [ obj3 ]
- *
- * ```
- *
- * @param fn
- * @returns {*|function(): (*|any)}
- */
-export declare function curry(fn: Function): Function;
-/**
- * Given a varargs list of functions, returns a function that composes the argument functions, right-to-left
- * given: f(x), g(x), h(x)
- * let composed = compose(f,g,h)
- * then, composed is: f(g(h(x)))
- */
-export declare function compose(): () => any;
-/**
- * Given a varargs list of functions, returns a function that is composes the argument functions, left-to-right
- * given: f(x), g(x), h(x)
- * let piped = pipe(f,g,h);
- * then, piped is: h(g(f(x)))
- */
-export declare function pipe(...funcs: Function[]): (obj: any) => any;
-/**
- * Given a property name, returns a function that returns that property from an object
- * let obj = { foo: 1, name: "blarg" };
- * let getName = prop("name");
- * getName(obj) === "blarg"
- */
-export declare const prop: (name: string) => (obj: any) => any;
-/**
- * Given a property name and a value, returns a function that returns a boolean based on whether
- * the passed object has a property that matches the value
- * let obj = { foo: 1, name: "blarg" };
- * let getName = propEq("name", "blarg");
- * getName(obj) === true
- */
-export declare const propEq: Function;
-/**
- * Given a dotted property name, returns a function that returns a nested property from an object, or undefined
- * let obj = { id: 1, nestedObj: { foo: 1, name: "blarg" }, };
- * let getName = prop("nestedObj.name");
- * getName(obj) === "blarg"
- * let propNotFound = prop("this.property.doesnt.exist");
- * propNotFound(obj) === undefined
- */
-export declare const parse: (name: string) => any;
-/**
- * Given a function that returns a truthy or falsey value, returns a
- * function that returns the opposite (falsey or truthy) value given the same inputs
- */
-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>;
-/**
- * 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>;
-/**
- * Check if all the elements of an array match a predicate function
- *
- * @param fn1 a predicate function `fn1`
- * @returns a function which takes an array and returns true if `fn1` is true for all elements of the array
- */
-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;
-/** 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 */
-export declare const val: <T>(v: T) => () => T;
-export declare function invoke(fnName: string): Function;
-export declare function invoke(fnName: string, args: any[]): Function;
-/**
- * Sorta like Pattern Matching (a functional programming conditional construct)
- *
- * See http://c2.com/cgi/wiki?PatternMatching
- *
- * This is a conditional construct which allows a series of predicates and output functions
- * to be checked and then applied.  Each predicate receives the input.  If the predicate
- * returns truthy, then its matching output function (mapping function) is provided with
- * the input and, then the result is returned.
- *
- * Each combination (2-tuple) of predicate + output function should be placed in an array
- * of size 2: [ predicate, mapFn ]
- *
- * These 2-tuples should be put in an outer array.
- *
- * @example
- * ```
- *
- * // Here's a 2-tuple where the first element is the isString predicate
- * // and the second element is a function that returns a description of the input
- * let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];
- *
- * // Second tuple: predicate "isNumber", mapfn returns a description
- * let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];
- *
- * let third = [ (input) => input === null,  (input) => `Oh, null...` ];
- *
- * let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];
- *
- * let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);
- *
- * console.log(descriptionOf(undefined)); // 'notdefined'
- * console.log(descriptionOf(55)); // '(55) That's a number!'
- * console.log(descriptionOf("foo")); // 'Here's your string foo'
- * ```
- *
- * @param struct A 2D array.  Each element of the array should be an array, a 2-tuple,
- * with a Predicate and a mapping/output function
- * @returns {function(any): *}
- */
-export declare function pattern(struct: Function[][]): Function;

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

@@ -1,8 +0,0 @@
-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-back/router/core/common/predicates.d.ts

@@ -1,25 +0,0 @@
-import { Predicate } from "./common";
-export declare const isUndefined: (x: any) => boolean;
-export declare const isDefined: Predicate<any>;
-export declare const isNull: (o: any) => boolean;
-export declare const isNullOrUndefined: Predicate<any>;
-export declare const isFunction: (x: any) => x is Function;
-export declare const isNumber: (x: any) => x is number;
-export declare const isString: (x: any) => x is string;
-export declare const isObject: (x: any) => boolean;
-export declare const isArray: (arg: any) => arg is any[];
-export declare const isDate: (x: any) => x is Date;
-export declare const isRegExp: (x: any) => x is RegExp;
-/**
- * Predicate which checks if a value is injectable
- *
- * A value is "injectable" if it is a function, or if it is an ng1 array-notation-style array
- * where all the elements in the array are Strings, except the last one, which is a Function
- */
-export declare function isInjectable(val: any): boolean;
-/**
- * Predicate which checks if a value looks like a Promise
- *
- * It is probably a Promise if it's an object, and it has a `then` property which is a Function
- */
-export declare const isPromise: (x: any) => x is Promise<any>;

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

@@ -1,15 +0,0 @@
-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;
-}

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

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

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

@@ -1,66 +0,0 @@
-/**
- * Functions that manipulate strings
- *
- * Although these functions are exported, they are subject to change without notice.
- *
- * @packageDocumentation
- */
-import { IInjectable } from "./common";
-/**
- * Returns a string shortened to a maximum length
- *
- * If the string is already less than the `max` length, return the string.
- * Else return the string, shortened to `max - 3` and append three dots ("...").
- *
- * @param max the maximum length of the string to return
- * @param str the input string
- */
-export declare function maxLength(max: number, str: string): string;
-/**
- * Returns a string, with spaces added to the end, up to a desired str length
- *
- * If the string is already longer than the desired length, return the string.
- * Else returns the string, with extra spaces on the end, such that it reaches `length` characters.
- *
- * @param length the desired length of the string to return
- * @param str the input string
- */
-export declare function padString(length: number, str: string): string;
-export declare function kebobString(camelCase: string): string;
-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 hostRegex: RegExp;
-export declare const stripLastPathElement: (str: string) => string;
-export declare const splitHash: (str: string) => string[];
-export declare const splitQuery: (str: string) => string[];
-export declare const splitEqual: (str: string) => string[];
-export declare const trimHashVal: (str: string) => string;
-/**
- * Splits on a delimiter, but returns the delimiters in the array
- *
- * #### Example:
- * ```js
- * var splitOnSlashes = splitOnDelim('/');
- * splitOnSlashes("/foo"); // ["/", "foo"]
- * splitOnSlashes("/foo/"); // ["/", "foo", "/"]
- * ```
- */
-export declare function splitOnDelim(delim: string): (str: string) => string[];
-/**
- * Reduce fn that joins neighboring strings
- *
- * Given an array of strings, returns a new array
- * where all neighboring strings have been joined.
- *
- * #### Example:
- * ```js
- * let arr = ["foo", "bar", 1, "baz", "", "qux" ];
- * arr.reduce(joinNeighborsR, []) // ["foobar", 1, "bazqux" ]
- * ```
- */
-export declare function joinNeighborsR(acc: any[], x: any): any[];

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

@@ -1,126 +0,0 @@
-import { Transition } from "../transition/transition";
-import { ViewTuple } from "../view";
-import { ActiveNGView, 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
- *
- * Enable or disable a category using [[Trace.enable]] or [[Trace.disable]]
- *
- * `trace.enable(Category.TRANSITION)`
- *
- * These can also be provided using a matching string, or position ordinal
- *
- * `trace.enable("TRANSITION")`
- *
- * `trace.enable(1)`
- */
-declare enum Category {
-  RESOLVE = 0,
-  TRANSITION = 1,
-  HOOK = 2,
-  NGVIEW = 3,
-  VIEWCONFIG = 4,
-}
-export { Category };
-/**
- * Prints 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 */
-  traceNGViewEvent(event: string, viewData: ActiveNGView, extra?: string): void;
-  /** @internal called by ui-router code */
-  traceNGViewConfigUpdated(viewData: ActiveNGView, context: ViewContext): void;
-  /** @internal called by ui-router code */
-  traceNGViewFill(viewData: ActiveNGView, 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 */
-  traceViewServiceNGViewEvent(event: string, viewData: ActiveNGView): void;
-}
-/**
- * The [[Trace]] singleton
- *
- * #### Example:
- * ```js
- * import {trace} from "@uirouter/core";
- * trace.enable(1, 5);
- * ```
- */
-declare const trace: Trace;
-export { trace };

package/types-back/router/core/globals.d.ts

@@ -1,43 +0,0 @@
-import { StateParams } from "./params/stateParams";
-import { StateDeclaration } from "./state/interface";
-import { StateObject } from "./state/stateObject";
-import { Transition } from "./transition/transition";
-import { Queue } from "./common/queue";
-/**
- * Global router state
- *
- * This is where we hold the global mutable state such as current state, current
- * params, current transition, etc.
- */
-export declare class RouterGlobals {
-  /**
-   * Current parameter values
-   *
-   * The parameter values from the latest successful transition
-   */
-  params: StateParams;
-  /**
-   * Current state
-   *
-   * The to-state from the latest successful transition
-   */
-  current: StateDeclaration;
-  /**
-   * Current state (internal object)
-   *
-   * The to-state from the latest successful transition
-   * @internal
-   */
-  $current: StateObject;
-  /**
-   * The current started/running transition.
-   * This transition has reached at least the onStart phase, but is not yet complete
-   */
-  transition: Transition;
-  /** @internal */
-  lastStartedTransitionId: number;
-  /** @internal */
-  transitionHistory: Queue<Transition>;
-  /** @internal */
-  successfulTransitions: Queue<Transition>;
-}

package/types-back/router/core/hooks/coreResolvables.d.ts

@@ -1,6 +0,0 @@
-import { Transition } from "../transition/transition";
-import { TransitionService } from "../transition/transitionService";
-export declare const registerAddCoreResolvables: (
-  transitionService: TransitionService,
-) => Function;
-export declare const treeChangesCleanup: (trans: Transition) => void;

package/types-back/router/core/hooks/ignoredTransition.d.ts

@@ -1,4 +0,0 @@
-import { TransitionService } from "../transition/transitionService";
-export declare const registerIgnoredTransitionHook: (
-  transitionService: TransitionService,
-) => Function;

package/types-back/router/core/hooks/invalidTransition.d.ts

@@ -1,4 +0,0 @@
-import { TransitionService } from "../transition/transitionService";
-export declare const registerInvalidTransitionHook: (
-  transitionService: TransitionService,
-) => Function;

package/types-back/router/core/hooks/lazyLoad.d.ts

@@ -1,17 +0,0 @@
-import { Transition } from "../transition/transition";
-import { TransitionService } from "../transition/transitionService";
-import { StateDeclaration, LazyLoadResult } from "../state/interface";
-export declare const registerLazyLoadHook: (
-  transitionService: TransitionService,
-) => Function;
-/**
- * Invokes a state's lazy load function
- *
- * @param transition a Transition context
- * @param state the state to lazy load
- * @returns A promise for the lazy load result
- */
-export declare function lazyLoadState(
-  transition: Transition,
-  state: StateDeclaration,
-): Promise<LazyLoadResult>;

package/types-back/router/core/hooks/onEnterExitRetain.d.ts

@@ -1,10 +0,0 @@
-import { TransitionService } from "../transition/transitionService";
-export declare const registerOnExitHook: (
-  transitionService: TransitionService,
-) => Function;
-export declare const registerOnRetainHook: (
-  transitionService: TransitionService,
-) => Function;
-export declare const registerOnEnterHook: (
-  transitionService: TransitionService,
-) => Function;

package/types-back/router/core/hooks/redirectTo.d.ts

@@ -1,4 +0,0 @@
-import { TransitionService } from "../transition/transitionService";
-export declare const registerRedirectToHook: (
-  transitionService: TransitionService,
-) => Function;

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

@@ -1,11 +0,0 @@
-import { TransitionService } from "../transition/transitionService";
-export declare const RESOLVE_HOOK_PRIORITY = 1000;
-export declare const registerEagerResolvePath: (
-  transitionService: TransitionService,
-) => Function;
-export declare const registerLazyResolveState: (
-  transitionService: TransitionService,
-) => Function;
-export declare const registerResolveRemaining: (
-  transitionService: TransitionService,
-) => Function;

package/types-back/router/core/hooks/updateGlobals.d.ts

@@ -1,4 +0,0 @@
-import { TransitionService } from "../transition/transitionService";
-export declare const registerUpdateGlobalState: (
-  transitionService: TransitionService,
-) => Function;

package/types-back/router/core/hooks/url.d.ts

@@ -1,4 +0,0 @@
-import { TransitionService } from "../transition/transitionService";
-export declare const registerUpdateUrl: (
-  transitionService: TransitionService,
-) => Function;

package/types-back/router/core/hooks/views.d.ts

@@ -1,7 +0,0 @@
-import { TransitionService } from "../transition/transitionService";
-export declare const registerLoadEnteringViews: (
-  transitionService: TransitionService,
-) => Function;
-export declare const registerActivateViews: (
-  transitionService: TransitionService,
-) => Function;

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

@@ -1,11 +0,0 @@
-export * from "./common/index";
-export * from "./params/index";
-export * from "./path/index";
-export * from "./resolve/index";
-export * from "./state/index";
-export * from "./transition/index";
-export * from "./url/index";
-export * from "./view/index";
-export * from "./globals";
-export * from "./router";
-export * from "./interface";

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

@@ -1,91 +0,0 @@
-import { Router } from "./router";
-/**
- * An interface for getting values from dependency injection.
- *
- * This is primarily used to get resolve values for a given token.
- * An instance of the `NGInjector` can be retrieved from the current transition using [[Transition.injector]].
- *
- * ---
- *
- * If no resolve is found for a token, then it will delegate to the native injector.
- * The native injector may be Angular 1 `$injector`, Angular 2 `Injector`, or a simple polyfill.
- *
- * In Angular 2, the native injector might be the root Injector,
- * or it might be a lazy loaded `NgModule` injector scoped to a lazy load state tree.
- */
-export interface NGInjector {
-  /**
-   * Gets a value from the injector.
-   *
-   * For a given token, returns the value from the injector that matches the token.
-   * If the token is for a resolve that has not yet been fetched, this throws an error.
-   *
-   * #### Example:
-   * ```js
-   * var myResolve = injector.get('myResolve');
-   * ```
-   *
-   * #### ng1 Example:
-   * ```js
-   * // Fetch StateService
-   * injector.get('$state').go('home');
-   * ```
-   *
-   * #### ng2 Example:
-   * ```js
-   * import {StateService} from "ui-router-ng2";
-   * // Fetch StateService
-   * injector.get(StateService).go('home');
-   * ```
-   *
-   * #### Typescript Example:
-   * ```js
-   * var stringArray = injector.get<string[]>('myStringArray');
-   * ```
-   *
-   * ### `NOWAIT` policy
-   *
-   * When using [[ResolvePolicy.async]] === `NOWAIT`, the value returned from `get()` is a promise for the result.
-   * The promise is not automatically unwrapped.
-   *
-   * @param token the key for the value to get.  May be a string, a class, or any arbitrary object.
-   * @return the Dependency Injection value that matches the token
-   */
-  get(token: any): any;
-  /** Gets a value as type `T` (generics parameter) */
-  get<T>(token: any): T;
-  /**
-   * Asynchronously gets a value from the injector
-   *
-   * For a given token, returns a promise for the value from the injector that matches the token.
-   * If the token is for a resolve that has not yet been fetched, this triggers the resolve to load.
-   *
-   * #### Example:
-   * ```js
-   * return injector.getAsync('myResolve').then(value => {
-   *   if (value === 'declined') return false;
-   * });
-   * ```
-   *
-   * @param token the key for the value to get.  May be a string or arbitrary object.
-   * @return a Promise for the Dependency Injection value that matches the token
-   */
-  getAsync(token: any): Promise<any>;
-  /** Asynchronously gets a value as type `T` (generics parameter) */
-  getAsync<T>(token: any): Promise<T>;
-  /**
-   * Gets a value from the native injector
-   *
-   * Returns a value from the native injector, bypassing anything in the [[ResolveContext]].
-   *
-   * Example:
-   * ```js
-   * let someThing = injector.getNative(SomeToken);
-   * ```
-   *
-   * @param token the key for the value to get.  May be a string or arbitrary object.
-   * @return the Dependency Injection value that matches the token
-   */
-  getNative(token: any): any;
-  getNative<T>(token: any): T;
-}

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

@@ -1,12 +0,0 @@
-/**
- * This module contains code for State Parameters.
- *
- * See [[ParamDeclaration]]
- *
- * @packageDocumentation @preferred
- */
-export * from "./interface";
-export * from "./param";
-export * from "./paramTypes";
-export * from "./stateParams";
-export * from "./paramType";