@angular-wave/angular.ts 0.0.60 → 0.0.61

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

@@ -1,75 +0,0 @@
-import { ResolvePolicy, ResolvableLiteral } from "./interface";
-import { ResolveContext } from "./resolveContext";
-import { Transition } from "../transition/transition";
-import { StateObject } from "../state/stateObject";
-export declare let defaultResolvePolicy: ResolvePolicy;
-/**
- * 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 declare class Resolvable implements ResolvableLiteral {
-  token: any;
-  policy: ResolvePolicy;
-  resolveFn: Function;
-  deps: any[];
-  data: any;
-  resolved: boolean;
-  promise: Promise<any>;
-  static fromData: (token: any, data: any) => Resolvable;
-  /** This constructor creates a Resolvable copy */
-  constructor(resolvable: Resolvable);
-  /** This constructor creates a new Resolvable from the plain old [[ResolvableLiteral]] javascript object */
-  constructor(resolvable: ResolvableLiteral);
-  /**
-   * This constructor creates a new `Resolvable`
-   *
-   * #### Example:
-   * ```js
-   * var resolvable1 = new Resolvable('mytoken', http => http.get('foo.json').toPromise(), [Http]);
-   *
-   * var resolvable2 = new Resolvable(UserService, dep => new UserService(dep.data), [SomeDependency]);
-   *
-   * var resolvable1Clone = new Resolvable(resolvable1);
-   * ```
-   *
-   * @param token The new resolvable's injection token, such as `"userList"` (a string) or `UserService` (a class).
-   *              When this token is used during injection, the resolved value will be injected.
-   * @param resolveFn The function that returns the resolved value, or a promise for the resolved value
-   * @param deps An array of dependencies, which will be injected into the `resolveFn`
-   * @param policy the [[ResolvePolicy]] defines when and how the Resolvable is processed
-   * @param data Pre-resolved data. If the resolve value is already known, it may be provided here.
-   */
-  constructor(
-    token: any,
-    resolveFn: Function,
-    deps?: any[],
-    policy?: ResolvePolicy,
-    data?: any,
-  );
-  getPolicy(state: StateObject): ResolvePolicy;
-  /**
-   * 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: ResolveContext, trans?: Transition): Promise<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: ResolveContext, trans?: Transition): Promise<any>;
-  toString(): string;
-  clone(): Resolvable;
-}

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

@@ -1,97 +0,0 @@
-import { PolicyWhen, ResolvePolicy } from "./interface";
-import { PathNode } from "../path/pathNode";
-import { Resolvable } from "./resolvable";
-import { StateObject } from "../state/stateObject";
-import { Transition } from "../transition/transition";
-import { NGInjector } from "../interface";
-export declare const NATIVE_INJECTOR_TOKEN: string;
-/**
- * Encapsulates Dependency Injection for a path of nodes
- *
- * 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 declare class ResolveContext {
-  private _path;
-  _injector: NGInjector;
-  constructor(_path: PathNode[]);
-  /** 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): Resolvable;
-  /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
-  getPolicy(resolvable: Resolvable): ResolvePolicy;
-  /**
-   * 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: StateObject): 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: Resolvable[], state: StateObject): void;
-  /**
-   * Returns a promise for an array of resolved path Element promises
-   *
-   * @param when
-   * @param trans
-   * @returns {Promise<any>|any}
-   */
-  resolvePath(
-    when?: PolicyWhen,
-    trans?: Transition,
-  ): Promise<
-    {
-      token: any;
-      value: any;
-    }[]
-  >;
-  injector(): NGInjector;
-  findNode(resolvable: Resolvable): PathNode;
-  /**
-   * Gets the async dependencies of a Resolvable
-   *
-   * Given a Resolvable, returns its dependencies as a Resolvable[]
-   */
-  getDependencies(resolvable: Resolvable): Resolvable[];
-}

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

@@ -1,57 +0,0 @@
-import { UrlMatcherFactory } from "./url/urlMatcherFactory";
-import { UrlRouter } from "./url/urlRouter";
-import { TransitionService } from "./transition/transitionService";
-import { ViewService } from "./view/view";
-import { StateRegistry } from "./state/stateRegistry";
-import { StateService } from "./state/stateService";
-import { RouterGlobals } from "./globals";
-import { UrlService } from "./url/urlService";
-import { LocationServices, LocationConfig } from "./common/coreservices";
-import { Trace } from "./common/trace";
-/**
- * An instance of Router.
- *
- * This object contains references to service APIs which define your application's routing behavior.
- */
-export declare class Router {
-  locationService: LocationServices;
-  locationConfig: LocationConfig;
-  /** @internal */ $id: number;
-  /** @internal */ _disposed: boolean;
-  /** @internal */ private _disposables;
-  /** Enable/disable tracing to the javascript console */
-  trace: Trace;
-  /** Provides services related to ui-view synchronization */
-  viewService: ViewService;
-  /** An object that contains global router state, such as the current state and params */
-  globals: RouterGlobals;
-  /** A service that exposes global Transition Hooks */
-  transitionService: TransitionService;
-  /**
-   * Deprecated for public use. Use [[urlService]] instead.
-   * @deprecated Use [[urlService]] instead
-   */
-  urlMatcherFactory: UrlMatcherFactory;
-  /**
-   * Deprecated for public use. Use [[urlService]] instead.
-   * @deprecated Use [[urlService]] instead
-   */
-  urlRouter: UrlRouter;
-  /** Provides services related to the URL */
-  urlService: UrlService;
-  /** Provides a registry for states, and related registration services */
-  stateRegistry: StateRegistry;
-  /** Provides services related to states */
-  stateService: StateService;
-  /**
-   * Creates a new `Router` object
-   *
-   * @param locationService a [[LocationServices]] implementation
-   * @param locationConfig a [[LocationConfig]] implementation
-   * @internal
-   */
-  constructor(
-    locationService?: LocationServices,
-    locationConfig?: LocationConfig,
-  );
-}

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

@@ -1,28 +0,0 @@
-/**
- * # The state subsystem
- *
- * This subsystem implements the ui-router state tree
- *
- * - The [[StateService]] has state-related service methods such as:
- *   - [[StateService.get]]: Get a registered [[StateDeclaration]] object
- *   - [[StateService.go]]: Transition from the current state to a new state
- *   - [[StateService.reload]]: Reload the current state
- *   - [[StateService.target]]: Get a [[TargetState]] (useful when redirecting from a Transition Hook)
- *   - [[StateService.onInvalid]]: Register a callback for when a transition to an invalid state is started
- *   - [[StateService.defaultErrorHandler]]: Register a global callback for when a transition errors
- * - The [[StateDeclaration]] interface defines the shape of a state declaration
- * - The [[StateRegistry]] contains all the registered states
- *   - States can be added/removed using the [[StateRegistry.register]] and [[StateRegistry.deregister]]
- *     - Note: Bootstrap state registration differs by front-end framework.
- *   - Get notified of state registration/deregistration using [[StateRegistry.onStatesChanged]].
- *
- * @packageDocumentation
- */
-export * from "./interface";
-export * from "./stateBuilder";
-export * from "./stateObject";
-export * from "./stateMatcher";
-export * from "./stateQueueManager";
-export * from "./stateRegistry";
-export * from "./stateService";
-export * from "./targetState";