@angular-wave/angular.ts 0.0.16 → 0.0.17

package/types/router/core/state/stateBuilder.d.ts

@@ -0,0 +1,104 @@
+import { StateObject } from './stateObject';
+import { StateMatcher } from './stateMatcher';
+import { UrlMatcherFactory } from '../url/urlMatcherFactory';
+import { Resolvable } from '../resolve/resolvable';
+/**
+ * A function that builds the final value for a specific field on a [[StateObject]].
+ *
+ * A series of builder functions for a given field are chained together.
+ * The final value returned from the chain of builders is applied to the built [[StateObject]].
+ * Builder functions should call the [[parent]] function either first or last depending on the desired composition behavior.
+ *
+ * @param state the _partially built_ [[StateObject]]. The [[StateDeclaration]] can be inspected via [[StateObject.self]]
+ * @param parent the previous builder function in the series.
+ */
+export declare type BuilderFunction = (state: StateObject, parent?: BuilderFunction) => any;
+/**
+ * This is a [[StateBuilder.builder]] function for the `resolve:` block on a [[StateDeclaration]].
+ *
+ * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
+ * validates the `resolve` property and converts it to a [[Resolvable]] array.
+ *
+ * resolve: input value can be:
+ *
+ * {
+ *   // analyzed but not injected
+ *   myFooResolve: function() { return "myFooData"; },
+ *
+ *   // function.toString() parsed, "DependencyName" dep as string (not min-safe)
+ *   myBarResolve: function(DependencyName) { return DependencyName.fetchSomethingAsPromise() },
+ *
+ *   // Array split; "DependencyName" dep as string
+ *   myBazResolve: [ "DependencyName", function(dep) { return dep.fetchSomethingAsPromise() },
+ *
+ *   // Array split; DependencyType dep as token (compared using ===)
+ *   myQuxResolve: [ DependencyType, function(dep) { return dep.fetchSometingAsPromise() },
+ *
+ *   // val.$inject used as deps
+ *   // where:
+ *   //     corgeResolve.$inject = ["DependencyName"];
+ *   //     function corgeResolve(dep) { dep.fetchSometingAsPromise() }
+ *   // then "DependencyName" dep as string
+ *   myCorgeResolve: corgeResolve,
+ *
+ *  // inject service by name
+ *  // When a string is found, desugar creating a resolve that injects the named service
+ *   myGraultResolve: "SomeService"
+ * }
+ *
+ * or:
+ *
+ * [
+ *   new Resolvable("myFooResolve", function() { return "myFooData" }),
+ *   new Resolvable("myBarResolve", function(dep) { return dep.fetchSomethingAsPromise() }, [ "DependencyName" ]),
+ *   { provide: "myBazResolve", useFactory: function(dep) { dep.fetchSomethingAsPromise() }, deps: [ "DependencyName" ] }
+ * ]
+ */
+export declare function resolvablesBuilder(state: StateObject): Resolvable[];
+/**
+ * A internal global service
+ *
+ * StateBuilder is a factory for the internal [[StateObject]] objects.
+ *
+ * When you register a state with the [[StateRegistry]], you register a plain old javascript object which
+ * conforms to the [[StateDeclaration]] interface.  This factory takes that object and builds the corresponding
+ * [[StateObject]] object, which has an API and is used internally.
+ *
+ * Custom properties or API may be added to the internal [[StateObject]] object by registering a decorator function
+ * using the [[builder]] method.
+ */
+export declare class StateBuilder {
+    private matcher;
+    /** An object that contains all the BuilderFunctions registered, key'd by the name of the State property they build */
+    private builders;
+    constructor(matcher: StateMatcher, urlMatcherFactory: UrlMatcherFactory);
+    /**
+     * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).
+     * More than one BuilderFunction can be registered for a given property.
+     *
+     * The BuilderFunction(s) will be used to define the property on any subsequently built [[StateObject]] objects.
+     *
+     * @param property The name of the State property being registered for.
+     * @param fn The BuilderFunction which will be used to build the State property
+     * @returns a function which deregisters the BuilderFunction
+     */
+    builder(property: string, fn: BuilderFunction): Function;
+    /**
+     * Gets the registered builder functions for a given property of [[StateObject]].
+     *
+     * @param property The name of the State property being registered for.
+     * @returns the registered builder(s).
+     *          note: for backwards compatibility, this may be a single builder or an array of builders
+     */
+    builder(property: string): BuilderFunction | BuilderFunction[];
+    /**
+     * Builds all of the properties on an essentially blank State object, returning a State object which has all its
+     * properties and API built.
+     *
+     * @param state an uninitialized State object
+     * @returns the built State object
+     */
+    build(state: StateObject): StateObject;
+    parentName(state: StateObject): string;
+    name(state: StateObject): string;
+}

package/types/router/core/state/stateMatcher.d.ts

@@ -0,0 +1,11 @@
+import { StateOrName } from './interface';
+import { StateObject } from './stateObject';
+export declare class StateMatcher {
+    private _states;
+    constructor(_states: {
+        [key: string]: StateObject;
+    });
+    isRelative(stateName: string): boolean;
+    find(stateOrName: StateOrName, base?: StateOrName, matchGlob?: boolean): StateObject;
+    resolvePath(name: string, base: StateOrName): string;
+}

package/types/router/core/state/stateObject.d.ts

@@ -0,0 +1,155 @@
+import { StateDeclaration, _ViewDeclaration, _StateDeclaration, LazyLoadResult } from './interface';
+import { Param } from '../params/param';
+import { UrlMatcher } from '../url/urlMatcher';
+import { Resolvable } from '../resolve/resolvable';
+import { TransitionStateHookFn } from '../transition/interface';
+import { TargetState } from './targetState';
+import { Transition } from '../transition/transition';
+import { Glob } from '../common/glob';
+/**
+ * Internal representation of a UI-Router state.
+ *
+ * Instances of this class are created when a [[StateDeclaration]] is registered with the [[StateRegistry]].
+ *
+ * A registered [[StateDeclaration]] is augmented with a getter ([[StateDeclaration.$$state]]) which returns the corresponding [[StateObject]] object.
+ *
+ * This class prototypally inherits from the corresponding [[StateDeclaration]].
+ * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
+ */
+export declare class StateObject {
+    /** The parent [[StateObject]] */
+    parent: StateObject;
+    /** The name used to register the state */
+    name: string;
+    /** Prototypally inherits from [[StateDeclaration.abstract]] */
+    abstract: boolean;
+    /** Prototypally inherits from [[StateDeclaration.resolve]] */
+    resolve: {
+        [key: string]: string | any[] | Function;
+    } | any[];
+    /** A list of [[Resolvable]] objects.  The internal representation of [[resolve]]. */
+    resolvables: Resolvable[];
+    /** Prototypally inherits from [[StateDeclaration.resolvePolicy]] */
+    resolvePolicy: any;
+    /** A compiled URLMatcher which detects when the state's URL is matched */
+    url: UrlMatcher;
+    /** The parameters for the state, built from the URL and [[StateDeclaration.params]] */
+    params: {
+        [key: string]: Param;
+    };
+    /**
+     * The views for the state.
+     * Note: `@uirouter/core` does not register a builder for views.
+     * The framework specific code should register a `views` builder.
+     */
+    views: {
+        [key: string]: _ViewDeclaration;
+    };
+    /**
+     * The original [[StateDeclaration]] used to build this [[StateObject]].
+     * Note: `this` object also prototypally inherits from the `self` declaration object.
+     */
+    self: StateDeclaration;
+    /** The nearest parent [[StateObject]] which has a URL */
+    navigable: StateObject;
+    /** The parent [[StateObject]] objects from this state up to the root */
+    path: StateObject[];
+    /**
+     * Prototypally inherits from [[StateDeclaration.data]]
+     * Note: This is the only field on the [[StateDeclaration]] which is mutated.
+     * The definition object's `data` field is replaced with a new object
+     * which prototypally inherits from the parent state definition's `data` field.
+     */
+    data: any;
+    /**
+     * An object containing the parent States' names as keys and
+     * true as their values.
+     */
+    includes: {
+        [name: string]: boolean;
+    };
+    /** Prototypally inherits from [[StateDeclaration.onExit]] */
+    onExit: TransitionStateHookFn;
+    /** Prototypally inherits from [[StateDeclaration.onRetain]] */
+    onRetain: TransitionStateHookFn;
+    /** Prototypally inherits from [[StateDeclaration.onEnter]] */
+    onEnter: TransitionStateHookFn;
+    /** Prototypally inherits from [[StateDeclaration.lazyLoad]] */
+    lazyLoad: (transition: Transition, state: StateDeclaration) => Promise<LazyLoadResult>;
+    /** Prototypally inherits from [[StateDeclaration.redirectTo]] */
+    redirectTo: string | (($transition$: Transition) => TargetState) | {
+        state: string | StateDeclaration;
+        params: {
+            [key: string]: any;
+        };
+    };
+    /** @internal */
+    __stateObjectCache: {
+        /** Might be null */
+        nameGlob?: Glob;
+    };
+    /**
+     * Create a state object to put the private/internal implementation details onto.
+     * The object's prototype chain looks like:
+     * (Internal State Object) -> (Copy of State.prototype) -> (State Declaration object) -> (State Declaration's prototype...)
+     *
+     * @param stateDecl the user-supplied State Declaration
+     * @returns {StateObject} an internal State object
+     */
+    static create(stateDecl: _StateDeclaration): StateObject;
+    /** Predicate which returns true if the object is an class with @State() decorator */
+    static isStateClass: (stateDecl: _StateDeclaration) => stateDecl is new () => StateDeclaration;
+    /** Predicate which returns true if the object is a [[StateDeclaration]] object */
+    static isStateDeclaration: (obj: any) => obj is StateDeclaration;
+    /** Predicate which returns true if the object is an internal [[StateObject]] object */
+    static isState: (obj: any) => obj is StateObject;
+    /** @deprecated use State.create() */
+    constructor(config?: StateDeclaration);
+    /**
+     * Returns true if the provided parameter is the same state.
+     *
+     * Compares the identity of the state against the passed value, which is either an object
+     * reference to the actual `State` instance, the original definition object passed to
+     * `$stateProvider.state()`, or the fully-qualified name.
+     *
+     * @param ref Can be one of (a) a `State` instance, (b) an object that was passed
+     *        into `$stateProvider.state()`, (c) the fully-qualified name of a state as a string.
+     * @returns Returns `true` if `ref` matches the current `State` instance.
+     */
+    is(ref: StateObject | StateDeclaration | string): boolean;
+    /**
+     * @deprecated this does not properly handle dot notation
+     * @returns Returns a dot-separated name of the state.
+     */
+    fqn(): string;
+    /**
+     * Returns the root node of this state's tree.
+     *
+     * @returns The root of this state's tree.
+     */
+    root(): StateObject;
+    /**
+     * Gets the state's `Param` objects
+     *
+     * Gets the list of [[Param]] objects owned by the state.
+     * If `opts.inherit` is true, it also includes the ancestor states' [[Param]] objects.
+     * If `opts.matchingKeys` exists, returns only `Param`s whose `id` is a key on the `matchingKeys` object
+     *
+     * @param opts options
+     */
+    parameters(opts?: {
+        inherit?: boolean;
+        matchingKeys?: any;
+    }): Param[];
+    /**
+     * Returns a single [[Param]] that is owned by the state
+     *
+     * If `opts.inherit` is true, it also searches the ancestor states` [[Param]]s.
+     * @param id the name of the [[Param]] to return
+     * @param opts options
+     */
+    parameter(id: string, opts?: {
+        inherit?: boolean;
+    }): Param;
+    toString(): string;
+}

package/types/router/core/state/stateQueueManager.d.ts

@@ -0,0 +1,24 @@
+import { _StateDeclaration } from './interface';
+import { StateObject } from './stateObject';
+import { StateBuilder } from './stateBuilder';
+import { StateRegistryListener } from './stateRegistry';
+import { Disposable } from '../interface';
+import { UIRouter } from '../router';
+export declare class StateQueueManager implements Disposable {
+    private router;
+    states: {
+        [key: string]: StateObject;
+    };
+    builder: StateBuilder;
+    listeners: StateRegistryListener[];
+    queue: StateObject[];
+    constructor(router: UIRouter, states: {
+        [key: string]: StateObject;
+    }, builder: StateBuilder, listeners: StateRegistryListener[]);
+    dispose(): void;
+    register(stateDecl: _StateDeclaration): StateObject;
+    flush(): {
+        [key: string]: StateObject;
+    };
+    attachRoute(state: StateObject): void;
+}

package/types/router/core/state/stateRegistry.d.ts

@@ -0,0 +1,136 @@
+import { StateObject } from './stateObject';
+import { StateMatcher } from './stateMatcher';
+import { StateQueueManager } from './stateQueueManager';
+import { StateDeclaration, _StateDeclaration } from './interface';
+import { BuilderFunction } from './stateBuilder';
+import { StateOrName } from './interface';
+import { UIRouter } from '../router';
+/**
+ * The signature for the callback function provided to [[StateRegistry.onStatesChanged]].
+ *
+ * This callback receives two parameters:
+ *
+ * @param event a string; either "registered" or "deregistered"
+ * @param states the list of [[StateDeclaration]]s that were registered (or deregistered).
+ */
+export declare type StateRegistryListener = (event: 'registered' | 'deregistered', states: StateDeclaration[]) => void;
+/**
+ * A registry for all of the application's [[StateDeclaration]]s
+ *
+ * This API is found at `router.stateRegistry` ([[UIRouter.stateRegistry]])
+ */
+export declare class StateRegistry {
+    private router;
+    private _root;
+    private states;
+    /** @internal */
+    matcher: StateMatcher;
+    private builder;
+    /** @internal */
+    stateQueue: StateQueueManager;
+    /** @internal */
+    listeners: StateRegistryListener[];
+    /** @internal */
+    constructor(router: UIRouter);
+    /** @internal */
+    private _registerRoot;
+    /** @internal */
+    dispose(): void;
+    /**
+     * Listen for a State Registry events
+     *
+     * Adds a callback that is invoked when states are registered or deregistered with the StateRegistry.
+     *
+     * #### Example:
+     * ```js
+     * let allStates = registry.get();
+     *
+     * // Later, invoke deregisterFn() to remove the listener
+     * let deregisterFn = registry.onStatesChanged((event, states) => {
+     *   switch(event) {
+     *     case: 'registered':
+     *       states.forEach(state => allStates.push(state));
+     *       break;
+     *     case: 'deregistered':
+     *       states.forEach(state => {
+     *         let idx = allStates.indexOf(state);
+     *         if (idx !== -1) allStates.splice(idx, 1);
+     *       });
+     *       break;
+     *   }
+     * });
+     * ```
+     *
+     * @param listener a callback function invoked when the registered states changes.
+     *        The function receives two parameters, `event` and `state`.
+     *        See [[StateRegistryListener]]
+     * @return a function that deregisters the listener
+     */
+    onStatesChanged(listener: StateRegistryListener): () => void;
+    /**
+     * Gets the implicit root state
+     *
+     * Gets the root of the state tree.
+     * The root state is implicitly created by UI-Router.
+     * Note: this returns the internal [[StateObject]] representation, not a [[StateDeclaration]]
+     *
+     * @return the root [[StateObject]]
+     */
+    root(): StateObject;
+    /**
+     * Adds a state to the registry
+     *
+     * Registers a [[StateDeclaration]] or queues it for registration.
+     *
+     * Note: a state will be queued if the state's parent isn't yet registered.
+     *
+     * @param stateDefinition the definition of the state to register.
+     * @returns the internal [[StateObject]] object.
+     *          If the state was successfully registered, then the object is fully built (See: [[StateBuilder]]).
+     *          If the state was only queued, then the object is not fully built.
+     */
+    register(stateDefinition: _StateDeclaration): StateObject;
+    /** @internal */
+    private _deregisterTree;
+    /**
+     * Removes a state from the registry
+     *
+     * This removes a state from the registry.
+     * If the state has children, they are are also removed from the registry.
+     *
+     * @param stateOrName the state's name or object representation
+     * @returns {StateObject[]} a list of removed states
+     */
+    deregister(stateOrName: StateOrName): StateObject[];
+    /**
+     * Gets all registered states
+     *
+     * Calling this method with no arguments will return a list of all the states that are currently registered.
+     * Note: this does not return states that are *queued* but not yet registered.
+     *
+     * @return a list of [[StateDeclaration]]s
+     */
+    get(): StateDeclaration[];
+    /**
+     * Gets a registered state
+     *
+     * Given a state or a name, finds and returns the [[StateDeclaration]] from the registry.
+     * Note: this does not return states that are *queued* but not yet registered.
+     *
+     * @param stateOrName either the name of a state, or a state object.
+     * @param base the base state to use when stateOrName is relative.
+     * @return a registered [[StateDeclaration]] that matched the `stateOrName`, or null if the state isn't registered.
+     */
+    get(stateOrName: StateOrName, base?: StateOrName): StateDeclaration;
+    /**
+     * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).
+     * More than one BuilderFunction can be registered for a given property.
+     *
+     * The BuilderFunction(s) will be used to define the property on any subsequently built [[StateObject]] objects.
+     *
+     * @param property The name of the State property being registered for.
+     * @param builderFunction The BuilderFunction which will be used to build the State property
+     * @returns a function which deregisters the BuilderFunction
+     */
+    decorator(property: string, builderFunction: BuilderFunction): Function;
+}