@angular-wave/angular.ts 0.0.16 → 0.0.18

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

@@ -0,0 +1,370 @@
+import { StateObject } from '../state/stateObject';
+export declare const root: any;
+export declare const fromJson: any;
+export declare const toJson: any;
+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;
+}
+export declare type Predicate<X> = (x?: X) => boolean;
+export declare type PredicateBinary<X, Y> = (x?: X, y?: Y) => boolean;
+/**
+ * An ng1-style injectable
+ *
+ * This could be a (non-minified) function such as:
+ * ```js
+ * function injectableFunction(SomeDependency) {
+ *
+ * }
+ * ```
+ *
+ * or an explicitly annotated function (minify safe)
+ * ```js
+ * injectableFunction.$inject = [ 'SomeDependency' ];
+ * function injectableFunction(SomeDependency) {
+ *
+ * }
+ * ```
+ *
+ * or an array style annotated function (minify safe)
+ * ```js
+ * ['SomeDependency', function injectableFunction(SomeDependency) {
+ *
+ * }];
+ * ```
+ */
+export declare type IInjectable = Function | any[];
+export interface Obj extends Object {
+    [key: string]: any;
+}
+/**
+ * Builds proxy functions on the `to` object which pass through to the `from` object.
+ *
+ * For each key in `fnNames`, creates a proxy function on the `to` object.
+ * The proxy function calls the real function on the `from` object.
+ *
+ *
+ * #### Example:
+ * This example creates an new class instance whose functions are prebound to the new'd object.
+ * ```js
+ * class Foo {
+ *   constructor(data) {
+ *     // Binds all functions from Foo.prototype to 'this',
+ *     // then copies them to 'this'
+ *     bindFunctions(Foo.prototype, this, this);
+ *     this.data = data;
+ *   }
+ *
+ *   log() {
+ *     console.log(this.data);
+ *   }
+ * }
+ *
+ * let myFoo = new Foo([1,2,3]);
+ * var logit = myFoo.log;
+ * logit(); // logs [1, 2, 3] from the myFoo 'this' instance
+ * ```
+ *
+ * #### Example:
+ * This example creates a bound version of a service function, and copies it to another object
+ * ```
+ *
+ * var SomeService = {
+ *   this.data = [3, 4, 5];
+ *   this.log = function() {
+ *     console.log(this.data);
+ *   }
+ * }
+ *
+ * // Constructor fn
+ * function OtherThing() {
+ *   // Binds all functions from SomeService to SomeService,
+ *   // then copies them to 'this'
+ *   bindFunctions(SomeService, this, SomeService);
+ * }
+ *
+ * let myOtherThing = new OtherThing();
+ * myOtherThing.log(); // logs [3, 4, 5] from SomeService's 'this'
+ * ```
+ *
+ * @param source A function that returns the source object which contains the original functions to be bound
+ * @param target A function that returns the target object which will receive the bound functions
+ * @param bind A function that returns the object which the functions will be bound to
+ * @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;
+/**
+ * prototypal inheritance helper.
+ * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it
+ */
+export declare const inherit: (parent: Obj, extra?: Obj) => any;
+/** Given an array, returns true if the object is found in the array, (using indexOf) */
+export declare const inArray: typeof _inArray;
+export declare function _inArray(array: any[], obj: any): boolean;
+export declare function _inArray(array: any[]): (obj: any) => boolean;
+/**
+ * Given an array, and an item, if the item is found in the array, it removes it (in-place).
+ * The same array is returned
+ */
+export declare const removeFrom: typeof _removeFrom;
+export declare function _removeFrom<T>(array: T[], obj: T): T[];
+export declare function _removeFrom<T>(array: T[]): (obj: T) => T[];
+/** pushes a values to an array and returns the value */
+export declare const pushTo: typeof _pushTo;
+export declare function _pushTo<T>(arr: T[], val: T): T;
+export declare function _pushTo<T>(arr: T[]): (val: T) => T;
+/** Given an array of (deregistration) functions, calls all functions and removes each one from the source array */
+export declare const deregAll: (functions: Function[]) => void;
+/**
+ * Applies a set of defaults to an options object.  The options object is filtered
+ * to only those properties of the objects in the defaultsList.
+ * Earlier objects in the defaultsList take precedence when applying defaults.
+ */
+export declare function defaults(opts: any, ...defaultsList: Obj[]): any;
+/** Reduce function that merges each element of the list into a single object, using extend */
+export declare const mergeR: (memo: Obj, item: Obj) => any;
+/**
+ * Finds the common ancestor path between two states.
+ *
+ * @param {Object} first The first state.
+ * @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[];
+/**
+ * Return a copy of the object only containing the whitelisted properties.
+ *
+ * #### Example:
+ * ```
+ * var foo = { a: 1, b: 2, c: 3 };
+ * var ab = pick(foo, ['a', 'b']); // { a: 1, b: 2 }
+ * ```
+ * @param obj the source object
+ * @param propNames an Array of strings, which are the whitelisted property names
+ */
+export declare function pick(obj: Obj, propNames: string[]): Obj;
+/**
+ * Return a copy of the object omitting the blacklisted properties.
+ *
+ * @example
+ * ```
+ *
+ * var foo = { a: 1, b: 2, c: 3 };
+ * var ab = omit(foo, ['a', 'b']); // { c: 3 }
+ * ```
+ * @param obj the source object
+ * @param propNames an Array of strings, which are the blacklisted property names
+ */
+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): {
+    [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[];
+/** 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>;
+/** 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;
+/** 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: {
+    [key: string]: T;
+}, 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: {
+    [key: string]: T;
+}, callback: Mapper<T, U>, target?: typeof collection): {
+    [key: string]: U;
+};
+/**
+ * Given an object, return its enumerable property values
+ *
+ * @example
+ * ```
+ *
+ * let foo = { a: 1, b: 2, c: 3 }
+ * let vals = values(foo); // [ 1, 2, 3 ]
+ * ```
+ */
+export declare const values: <T>(obj: TypedMap<T>) => T[];
+/**
+ * Reduce function that returns true if all of the values are truthy.
+ *
+ * @example
+ * ```
+ *
+ * let vals = [ 1, true, {}, "hello world"];
+ * vals.reduce(allTrueR, true); // true
+ *
+ * vals.push(0);
+ * vals.reduce(allTrueR, true); // false
+ * ```
+ */
+export declare const allTrueR: (memo: boolean, elem: any) => any;
+/**
+ * Reduce function that returns true if any of the values are truthy.
+ *
+ *  * @example
+ * ```
+ *
+ * let vals = [ 0, null, undefined ];
+ * vals.reduce(anyTrueR, true); // false
+ *
+ * vals.push("hello world");
+ * vals.reduce(anyTrueR, true); // true
+ * ```
+ */
+export declare const anyTrueR: (memo: boolean, elem: any) => any;
+/**
+ * Reduce function which un-nests a single level of arrays
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * input.reduce(unnestR, []) // [ "a", "b", "c", "d", [ "double, "nested" ] ]
+ * ```
+ */
+export declare const unnestR: (memo: any[], elem: any[]) => any[];
+/**
+ * Reduce function which recursively un-nests all arrays
+ *
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * input.reduce(unnestR, []) // [ "a", "b", "c", "d", "double, "nested" ]
+ * ```
+ */
+export declare const flattenR: (memo: any[], elem: any) => any[];
+/**
+ * Reduce function that pushes an object to an array, then returns the array.
+ * Mostly just for [[flattenR]] and [[uniqR]]
+ */
+export declare function pushR(arr: any[], obj: any): any[];
+/** Reduce function that filters out duplicates */
+export declare const uniqR: <T>(acc: T[], token: T) => T[];
+/**
+ * Return a new array with a single level of arrays unnested.
+ *
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * unnest(input) // [ "a", "b", "c", "d", [ "double, "nested" ] ]
+ * ```
+ */
+export declare const unnest: (arr: any[]) => any;
+/**
+ * Return a completely flattened version of an array.
+ *
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * flatten(input) // [ "a", "b", "c", "d", "double, "nested" ]
+ * ```
+ */
+export declare const flatten: (arr: any[]) => any;
+/**
+ * Given a .filter Predicate, builds a .filter Predicate which throws an error if any elements do not pass.
+ * @example
+ * ```
+ *
+ * let isNumber = (obj) => typeof(obj) === 'number';
+ * let allNumbers = [ 1, 2, 3, 4, 5 ];
+ * allNumbers.filter(assertPredicate(isNumber)); //OK
+ *
+ * let oneString = [ 1, 2, 3, 4, "5" ];
+ * 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>;
+/**
+ * Given a .map function, builds a .map function which throws an error if any mapped elements do not pass a truthyness test.
+ * @example
+ * ```
+ *
+ * var data = { foo: 1, bar: 2 };
+ *
+ * let keys = [ 'foo', 'bar' ]
+ * let values = keys.map(assertMap(key => data[key], "Key not found"));
+ * // values is [1, 2]
+ *
+ * let keys = [ 'foo', 'bar', 'baz' ]
+ * let values = keys.map(assertMap(key => data[key], "Key not found"));
+ * // 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;
+/**
+ * Like _.pairs: Given an object, returns an array of key/value pairs
+ *
+ * @example
+ * ```
+ *
+ * pairs({ foo: "FOO", bar: "BAR }) // [ [ "foo", "FOO" ], [ "bar": "BAR" ] ]
+ * ```
+ */
+export declare const pairs: (obj: Obj) => any[][];
+/**
+ * Given two or more parallel arrays, returns an array of tuples where
+ * each tuple is composed of [ a[i], b[i], ... z[i] ]
+ *
+ * @example
+ * ```
+ *
+ * let foo = [ 0, 2, 4, 6 ];
+ * let bar = [ 1, 3, 5, 7 ];
+ * let baz = [ 10, 30, 50, 70 ];
+ * arrayTuples(foo, bar);       // [ [0, 1], [2, 3], [4, 5], [6, 7] ]
+ * arrayTuples(foo, bar, baz);  // [ [0, 1, 10], [2, 3, 30], [4, 5, 50], [6, 7, 70] ]
+ * ```
+ */
+export declare function arrayTuples(...args: any[]): any[];
+/**
+ * Reduce function which builds an object from an array of [key, value] pairs.
+ *
+ * Each iteration sets the key/val pair on the memo object, then returns the memo for the next iteration.
+ *
+ * Each keyValueTuple should be an array with values [ key: string, value: any ]
+ *
+ * @example
+ * ```
+ *
+ * var pairs = [ ["fookey", "fooval"], ["barkey", "barval"] ]
+ *
+ * var pairsToObj = pairs.reduce((memo, pair) => applyPairs(memo, pair), {})
+ * // pairsToObj == { fookey: "fooval", barkey: "barval" }
+ *
+ * // Or, more simply:
+ * var pairsToObj = pairs.reduce(applyPairs, {})
+ * // pairsToObj == { fookey: "fooval", barkey: "barval" }
+ * ```
+ */
+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;
+/**
+ * shallow copy from src to dest
+ */
+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 silentRejection: (error: any) => Promise<any>;

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

@@ -0,0 +1,80 @@
+/**
+ * This module is a stub for core services such as Dependency Injection or Browser Location.
+ * Core services may be implemented by a specific framework, such as ng1 or ng2, or be pure javascript.
+ *
+ * @packageDocumentation
+ */
+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>;
+}
+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[]>;
+}
+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[];
+}
+export interface CoreServices {
+    $q: $QLike;
+    $injector: $InjectorLike;
+}
+/**
+ * Handles low level URL read/write
+ *
+ * This service handles low level reads and updates of the URL and listens for url changes.
+ * Implementors should pass these through to the underlying URL mechanism.
+ * The underlying URL mechanism might be browser APIs, framework APIs, or some 3rd party URL management library.
+ *
+ * UI-Router Core includes three basic implementations:
+ *
+ * - [[PushStateLocationService]]
+ * - [[HashLocationService]]
+ * - [[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'];
+}
+/**
+ * Returns low level URL configuration and metadata
+ *
+ * This service returns information about the location configuration.
+ * This service is primarily used when building URLs (e.g., for `hrefs`)
+ *
+ * Implementors should pass these through to the underlying URL APIs.
+ * The underlying URL mechanism might be browser APIs, framework APIs, or some 3rd party URL management library.
+ *
+ * UI-Router Core includes two basic implementations:
+ *
+ * - [[BrowserLocationConfig]]
+ * - [[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'];
+}
+export { services };

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

@@ -0,0 +1,60 @@
+/**
+ * Matches state names using glob-like pattern strings.
+ *
+ * Globs can be used in specific APIs including:
+ *
+ * - [[StateService.is]]
+ * - [[StateService.includes]]
+ * - The first argument to Hook Registration functions like [[TransitionService.onStart]]
+ *    - [[HookMatchCriteria]] and [[HookMatchCriterion]]
+ *
+ * A `Glob` string is a pattern which matches state names.
+ * Nested state names are split into segments (separated by a dot) when processing.
+ * The state named `foo.bar.baz` is split into three segments ['foo', 'bar', 'baz']
+ *
+ * Globs work according to the following rules:
+ *
+ * ### Exact match:
+ *
+ * The glob `'A.B'` matches the state named exactly `'A.B'`.
+ *
+ * | Glob        |Matches states named|Does not match state named|
+ * |:------------|:--------------------|:---------------------|
+ * | `'A'`       | `'A'`               | `'B'` , `'A.C'`      |
+ * | `'A.B'`     | `'A.B'`             | `'A'` , `'A.B.C'`    |
+ * | `'foo'`     | `'foo'`             | `'FOO'` , `'foo.bar'`|
+ *
+ * ### Single star (`*`)
+ *
+ * A single star (`*`) is a wildcard that matches exactly one segment.
+ *
+ * | Glob        |Matches states named  |Does not match state named |
+ * |:------------|:---------------------|:--------------------------|
+ * | `'*'`       | `'A'` , `'Z'`        | `'A.B'` , `'Z.Y.X'`       |
+ * | `'A.*'`     | `'A.B'` , `'A.C'`    | `'A'` , `'A.B.C'`         |
+ * | `'A.*.*'`   | `'A.B.C'` , `'A.X.Y'`| `'A'`, `'A.B'` , `'Z.Y.X'`|
+ *
+ * ### Double star (`**`)
+ *
+ * A double star (`'**'`) is a wildcard that matches *zero or more segments*
+ *
+ * | Glob        |Matches states named                           |Does not match state named         |
+ * |:------------|:----------------------------------------------|:----------------------------------|
+ * | `'**'`      | `'A'` , `'A.B'`, `'Z.Y.X'`                    | (matches all states)              |
+ * | `'A.**'`    | `'A'` , `'A.B'` , `'A.C.X'`                   | `'Z.Y.X'`                         |
+ * | `'**.X'`    | `'X'` , `'A.X'` , `'Z.Y.X'`                   | `'A'` , `'A.login.Z'`             |
+ * | `'A.**.X'`  | `'A.X'` , `'A.B.X'` , `'A.B.C.X'`             | `'A'` , `'A.B.C'`                 |
+ *
+ * @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;
+}

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

@@ -0,0 +1,160 @@
+/**
+ * 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/router/core/common/index.d.ts

@@ -0,0 +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';