@angular-wave/angular.ts 0.0.35 → 0.0.37

package/types/router/path/path-utils.d.ts

@@ -0,0 +1,83 @@
+/**
+ * This class contains functions which convert TargetStates, Nodes and paths from one type to another.
+ */
+export class PathUtils {
+  /** Given a PathNode[], create an TargetState */
+  static makeTargetState(registry: any, path: any): TargetState;
+  static buildPath(targetState: any): any;
+  /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */
+  static buildToPath(fromPath: any, targetState: any): any;
+  /**
+   * Creates ViewConfig objects and adds to nodes.
+   *
+   * On each [[PathNode]], creates ViewConfig objects from the views: property of the node's state
+   */
+  static applyViewConfigs($view: any, path: any, states: any): void;
+  /**
+   * Given a fromPath and a toPath, returns a new to path which inherits parameters from the fromPath
+   *
+   * For a parameter in a node to be inherited from the from path:
+   * - The toPath's node must have a matching node in the fromPath (by state).
+   * - The parameter name must not be found in the toKeys parameter array.
+   *
+   * Note: the keys provided in toKeys are intended to be those param keys explicitly specified by some
+   * caller, for instance, $state.transitionTo(..., toParams).  If a key was found in toParams,
+   * it is not inherited from the fromPath.
+   */
+  static inheritParams(fromPath: any, toPath: any, toKeys?: any[]): any;
+  /**
+   * Computes the tree changes (entering, exiting) between a fromPath and toPath.
+   */
+  static treeChanges(
+    fromPath: any,
+    toPath: any,
+    reloadState: any,
+  ): {
+    from: any;
+    to: any;
+    retained: any;
+    retainedWithToParams: any;
+    exiting: any;
+    entering: any;
+  };
+  /**
+   * Returns a new path which is: the subpath of the first path which matches the second path.
+   *
+   * The new path starts from root and contains any nodes that match the nodes in the second path.
+   * It stops before the first non-matching node.
+   *
+   * Nodes are compared using their state property and their parameter values.
+   * If a `paramsFn` is provided, only the [[Param]] returned by the function will be considered when comparing nodes.
+   *
+   * @param pathA the first path
+   * @param pathB the second path
+   * @param paramsFn a function which returns the parameters to consider when comparing
+   *
+   * @returns an array of PathNodes from the first path which match the nodes in the second path
+   */
+  static matching(pathA: any, pathB: any, paramsFn: any): any[];
+  /**
+   * Returns true if two paths are identical.
+   *
+   * @param pathA
+   * @param pathB
+   * @param paramsFn a function which returns the parameters to consider when comparing
+   * @returns true if the the states and parameter values for both paths are identical
+   */
+  static equals(pathA: any, pathB: any, paramsFn: any): boolean;
+  /**
+   * Return a subpath of a path, which stops at the first matching node
+   *
+   * Given an array of nodes, returns a subset of the array starting from the first node,
+   * stopping when the first node matches the predicate.
+   *
+   * @param path a path of [[PathNode]]s
+   * @param predicate a [[Predicate]] fn that matches [[PathNode]]s
+   * @returns a subpath up to the matching node, or undefined if no match is found
+   */
+  static subPath(path: any, predicate: any): any;
+  static nonDynamicParams(node: any): any;
+  /** Gets the raw parameter values from a path */
+  static paramValues(path: any): any;
+}
+import { TargetState } from "../state/target-state";

package/types/router/resolve/resolvable.d.ts

@@ -0,0 +1,50 @@
+export namespace defaultResolvePolicy {
+  let when: string;
+  let async: string;
+}
+/**
+ * The basic building block for the resolve system.
+ *
+ * Resolvables encapsulate a state's resolve's resolveFn, the resolveFn's declared dependencies, the wrapped (.promise),
+ * and the unwrapped-when-complete (.data) result of the resolveFn.
+ *
+ * Resolvable.get() either retrieves the Resolvable's existing promise, or else invokes resolve() (which invokes the
+ * resolveFn) and returns the resulting promise.
+ *
+ * Resolvable.get() and Resolvable.resolve() both execute within a context path, which is passed as the first
+ * parameter to those fns.
+ */
+export class Resolvable {
+  constructor(arg1: any, resolveFn: any, deps: any, policy: any, data: any);
+  resolved: boolean;
+  promise: any;
+  token: any;
+  policy: any;
+  resolveFn: any;
+  deps: any;
+  data: any;
+  getPolicy(state: any): {
+    when: any;
+    async: any;
+  };
+  /**
+   * Asynchronously resolve this Resolvable's data
+   *
+   * Given a ResolveContext that this Resolvable is found in:
+   * Wait for this Resolvable's dependencies, then invoke this Resolvable's function
+   * and update the Resolvable's state
+   */
+  resolve(resolveContext: any, trans: any): any;
+  /**
+   * Gets a promise for this Resolvable's data.
+   *
+   * Fetches the data and returns a promise.
+   * Returns the existing promise if it has already been fetched once.
+   */
+  get(resolveContext: any, trans: any): any;
+  toString(): string;
+  clone(): Resolvable;
+}
+export namespace Resolvable {
+  function fromData(token: any, data: any): Resolvable;
+}

package/types/router/resolve/resolve-context.d.ts

@@ -0,0 +1,102 @@
+export namespace resolvePolicies {
+  namespace when {
+    let LAZY: string;
+    let EAGER: string;
+  }
+  namespace async {
+    let WAIT: string;
+    let NOWAIT: string;
+  }
+}
+export const NATIVE_INJECTOR_TOKEN: "Native Injector";
+/**
+ * Encapsulates Dependency Injection for a path of nodes
+ *
+ * ng-router states are organized as a tree.
+ * A nested state has a path of ancestors to the root of the tree.
+ * When a state is being activated, each element in the path is wrapped as a [[PathNode]].
+ * A `PathNode` is a stateful object that holds things like parameters and resolvables for the state being activated.
+ *
+ * The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.
+ */
+export class ResolveContext {
+  constructor(_path: any);
+  _path: any;
+  /** Gets all the tokens found in the resolve context, de-duplicated */
+  getTokens(): any;
+  /**
+   * Gets the Resolvable that matches the token
+   *
+   * Gets the last Resolvable that matches the token in this context, or undefined.
+   * Throws an error if it doesn't exist in the ResolveContext
+   */
+  getResolvable(token: any): any;
+  /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
+  getPolicy(resolvable: any): any;
+  /**
+   * Returns a ResolveContext that includes a portion of this one
+   *
+   * Given a state, this method creates a new ResolveContext from this one.
+   * The new context starts at the first node (root) and stops at the node for the `state` parameter.
+   *
+   * #### Why
+   *
+   * When a transition is created, the nodes in the "To Path" are injected from a ResolveContext.
+   * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.
+   * The "To State" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).
+   * This method is used to create a narrower context when injecting ancestor nodes.
+   *
+   * @example
+   * `let ABCD = new ResolveContext([A, B, C, D]);`
+   *
+   * Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:
+   * When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.
+   * However, `B` should only be able to access resolvables from `A`, `B`.
+   *
+   * When resolving for the `B` node, first take the full "To Path" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.
+   * `let AB = ABCD.subcontext(a)`
+   */
+  subContext(state: any): ResolveContext;
+  /**
+   * Adds Resolvables to the node that matches the state
+   *
+   * This adds a [[Resolvable]] (generally one created on the fly; not declared on a [[StateDeclaration.resolve]] block).
+   * The resolvable is added to the node matching the `state` parameter.
+   *
+   * These new resolvables are not automatically fetched.
+   * The calling code should either fetch them, fetch something that depends on them,
+   * or rely on [[resolvePath]] being called when some state is being entered.
+   *
+   * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.
+   *
+   * @param newResolvables the new Resolvables
+   * @param state Used to find the node to put the resolvable on
+   */
+  addResolvables(newResolvables: any, state: any): void;
+  /**
+   * Returns a promise for an array of resolved path Element promises
+   *
+   * @param when
+   * @param trans
+   * @returns {Promise<any>|any}
+   */
+  resolvePath(when: string, trans: any): Promise<any> | any;
+  injector(): UIInjectorImpl;
+  _injector: UIInjectorImpl;
+  findNode(resolvable: any): undefined;
+  /**
+   * Gets the async dependencies of a Resolvable
+   *
+   * Given a Resolvable, returns its dependencies as a Resolvable[]
+   */
+  getDependencies(resolvable: any): any;
+}
+declare class UIInjectorImpl {
+  constructor(context: any);
+  context: any;
+  native: any;
+  get(token: any): any;
+  getAsync(token: any): any;
+  getNative(token: any): any;
+}
+export {};

package/types/router/services.d.ts

@@ -1,15 +1,14 @@
-import { IRootScopeService } from "../";
-import { ResolveContext, TypedMap } from "./core";
-import { StateProvider } from "./stateProvider";
-declare module "./core/lib/router" {
-  interface Router {
-    /** @hidden */
-    stateProvider: StateProvider;
-  }
+export function runBlock(
+  $injector: any,
+  $q: any,
+  $stateRegistry: any,
+  $urlService: any,
+): void;
+export namespace runBlock {
+  let $inject: string[];
 }
-export declare function watchDigests($rootScope: IRootScopeService): void;
-export declare namespace watchDigests {
-  var $inject: string[];
+export function watchDigests($rootScope: any): void;
+export namespace watchDigests {
+  let $inject_1: string[];
+  export { $inject_1 as $inject };
 }
-/** @hidden TODO: find a place to move this */
-export declare const getLocals: (ctx: ResolveContext) => TypedMap<any>;

package/types/router/state/state-builder.d.ts

@@ -0,0 +1,89 @@
+/**
+ * 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 function resolvablesBuilder(state: any): any[];
+/**
+ * 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 class StateBuilder {
+  constructor(matcher: any, urlService: any);
+  matcher: any;
+  $injector: any;
+  builders: {
+    name: (typeof nameBuilder)[];
+    self: (typeof selfBuilder)[];
+    parent: ((state: any) => any)[];
+    data: (typeof dataBuilder)[];
+    url: ((stateObject: any) => any)[];
+    navigable: ((state: any) => any)[];
+    params: ((state: any) => any)[];
+    views: any[];
+    path: (typeof pathBuilder)[];
+    includes: (typeof includesBuilder)[];
+    resolvables: (typeof resolvablesBuilder)[];
+  };
+  builder(name: any, fn: any): any;
+  /**
+   * 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: any): any;
+  parentName(state: any): any;
+  name(state: any): any;
+}
+declare function nameBuilder(state: any): any;
+declare function selfBuilder(state: any): any;
+declare function dataBuilder(state: any): any;
+declare function pathBuilder(state: any): any;
+declare function includesBuilder(state: any): any;
+export {};

package/types/router/state/state-matcher.d.ts

@@ -0,0 +1,7 @@
+export class StateMatcher {
+  constructor(_states: any);
+  _states: any;
+  isRelative(stateName: any): boolean;
+  find(stateOrName: any, base: any, matchGlob?: boolean): any;
+  resolvePath(name: any, base: any): string;
+}

package/types/router/state/state-object.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Internal representation of a ng-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 class StateObject {
+  /**
+   * 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: any): StateObject;
+  constructor(config: any);
+  /**
+   * 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: any): boolean;
+  /**
+   * @deprecated this does not properly handle dot notation
+   * @returns Returns a dot-separated name of the state.
+   */
+  fqn(): any;
+  /**
+   * Returns the root node of this state's tree.
+   *
+   * @returns The root of this state's tree.
+   */
+  root(): any;
+  /**
+   * 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: any): any;
+  /**
+   * 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: any, opts?: {}): any;
+  toString(): any;
+}
+export namespace StateObject {
+  /** Predicate which returns true if the object is an class with @State() decorator */
+  function isStateClass(stateDecl: any): boolean;
+  /** Predicate which returns true if the object is a [[StateDeclaration]] object */
+  function isStateDeclaration(obj: any): boolean;
+  /** Predicate which returns true if the object is an internal [[StateObject]] object */
+  function isState(obj: any): boolean;
+}

package/types/router/state/state-queue-manager.d.ts

@@ -0,0 +1,19 @@
+export class StateQueueManager {
+  constructor(
+    stateRegistry: any,
+    urlServiceRules: any,
+    states: any,
+    builder: any,
+    listeners: any,
+  );
+  stateRegistry: any;
+  urlServiceRules: any;
+  states: any;
+  builder: any;
+  listeners: any;
+  queue: any[];
+  register(stateDecl: any): StateObject;
+  flush(): any;
+  attachRoute(state: any): void;
+}
+import { StateObject } from "./state-object";

package/types/router/state/state-registry.d.ts

@@ -0,0 +1,118 @@
+/**
+ * A registry for all of the application's [[StateDeclaration]]s
+ *
+ * This API is found at `$stateRegistry` ([[UIRouter.stateRegistry]])
+ */
+export class StateRegistry {
+  static $inject: string[];
+  constructor(
+    urlService: any,
+    stateService: any,
+    globals: any,
+    viewService: any,
+  );
+  states: {};
+  urlService: any;
+  urlServiceRules: any;
+  $injector: any;
+  listeners: any[];
+  matcher: StateMatcher;
+  builder: StateBuilder;
+  stateQueue: StateQueueManager;
+  $get: (string | (($injector: any) => this))[];
+  /**
+   * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
+   * `onRetain` callback hooks on a [[Ng1StateDeclaration]].
+   *
+   * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
+   * ensures that those hooks are injectable for @uirouter/angularjs (ng1).
+   *
+   * @internalapi
+   */
+  getStateHookBuilder(
+    hookName: any,
+  ): (stateObject: any) => (trans: any, state: any) => any;
+  _registerRoot(): void;
+  _root: import("./state-object").StateObject;
+  /**
+   * 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: any): any;
+  /**
+   * Gets the implicit root state
+   *
+   * Gets the root of the state tree.
+   * The root state is implicitly created by ng-router.
+   * Note: this returns the internal [[StateObject]] representation, not a [[StateDeclaration]]
+   *
+   * @return the root [[StateObject]]
+   */
+  root(): import("./state-object").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: any): import("./state-object").StateObject;
+  _deregisterTree(state: any): any[];
+  /**
+   * 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: any): StateObject[];
+  get(stateOrName: any, base: any, ...args: any[]): any;
+  /**
+   * 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: any, builderFunction: any): any;
+}
+export function getLocals(ctx: any): any;
+import { StateMatcher } from "./state-matcher";
+import { StateBuilder } from "./state-builder";
+import { StateQueueManager } from "./state-queue-manager";