@angular-wave/angular.ts 0.0.16 → 0.0.17

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

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

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

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

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

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

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

@@ -0,0 +1,114 @@
+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
+ *
+ * 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,
+    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;
+}
+/**
+ * The [[Trace]] singleton
+ *
+ * #### Example:
+ * ```js
+ * import {trace} from "@uirouter/core";
+ * trace.enable(1, 5);
+ * ```
+ */
+declare const trace: Trace;
+export { trace };

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

@@ -0,0 +1,45 @@
+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';
+import { Disposable } from './interface';
+/**
+ * Global router state
+ *
+ * This is where we hold the global mutable state such as current state, current
+ * params, current transition, etc.
+ */
+export declare class UIRouterGlobals implements Disposable {
+    /**
+     * 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>;
+    dispose(): void;
+}

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

@@ -0,0 +1,4 @@
+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/router/core/hooks/ignoredTransition.d.ts

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

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

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

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

@@ -0,0 +1,12 @@
+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/router/core/hooks/onEnterExitRetain.d.ts

@@ -0,0 +1,4 @@
+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/router/core/hooks/redirectTo.d.ts

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

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

@@ -0,0 +1,5 @@
+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/router/core/hooks/updateGlobals.d.ts

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+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 './vanilla';
+export * from './interface';

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

@@ -0,0 +1,102 @@
+import { UIRouter } 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 `UIInjector` 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 UIInjector {
+    /**
+     * 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;
+}
+export interface UIRouterPlugin extends Disposable {
+    name: string;
+}
+export declare abstract class UIRouterPluginBase implements UIRouterPlugin, Disposable {
+    abstract name: string;
+    dispose(router: UIRouter): void;
+}
+export interface Disposable {
+    /** Instructs the Disposable to clean up any resources */
+    dispose(router?: UIRouter): any;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * 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';