@angular-wave/angular.ts 0.0.60 → 0.0.62

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

@@ -1,107 +0,0 @@
-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-back/router/core/state/stateMatcher.d.ts

@@ -1,13 +0,0 @@
-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-back/router/core/state/stateObject.d.ts

@@ -1,170 +0,0 @@
-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 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-back/router/core/state/stateQueueManager.d.ts

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

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

@@ -1,138 +0,0 @@
-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 { Router } 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` ([[Router.stateRegistry]])
- */
-export declare class StateRegistry {
-  init($injector: any): void;
-  private router;
-  private _root;
-  private states;
-  /** @internal */
-  matcher: StateMatcher;
-  private builder;
-  /** @internal */
-  stateQueue: StateQueueManager;
-  /** @internal */
-  listeners: StateRegistryListener[];
-  /** @internal */
-  constructor(router: Router);
-  /** @internal */
-  private _registerRoot;
-  /**
-   * 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 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;
-}