@angular-wave/angular.ts 0.9.1 → 0.9.3

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

@@ -0,0 +1,95 @@
+/**
+ * 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 {
+  /**
+   * @param {import('./state-matcher.js').StateMatcher} matcher
+   * @param urlService
+   */
+  constructor(
+    matcher: import("./state-matcher.js").StateMatcher,
+    urlService: any,
+  );
+  matcher: import("./state-matcher.js").StateMatcher;
+  $injector: any;
+  builders: {
+    name: ((state: any) => any)[];
+    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 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,83 @@
+/** @typedef {import('./interface.js').StateDeclaration} StateDeclaration */
+/**
+ * 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]].
+ * @implements {StateDeclaration}
+ */
+export class StateObject implements StateDeclaration {
+  /**
+   * @param {import('./interface.js').StateDeclaration} config
+   */
+  constructor(config: import("./interface.js").StateDeclaration);
+  name: any;
+  navigable: any;
+  /** @type {?StateObject} */
+  parent: StateObject | null;
+  params: any;
+  url: any;
+  includes: any;
+  $$state: () => this;
+  /**
+   * @type {import('./interface.js').StateDeclaration}
+   */
+  self: import("./interface.js").StateDeclaration;
+  __stateObjectCache: {
+    nameGlob: Glob;
+  };
+  /**
+   * 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 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;
+}
+export type StateDeclaration = import("./interface.js").StateDeclaration;
+import { Glob } from "../glob/glob.js";

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

@@ -0,0 +1,29 @@
+export class StateQueueManager {
+  /**
+   * @param {import("./state-registry.js").StateRegistryProvider} stateRegistry
+   * @param {*} urlServiceRules
+   * @param {*} states
+   * @param {*} builder
+   * @param {*} listeners
+   */
+  constructor(
+    stateRegistry: import("./state-registry.js").StateRegistryProvider,
+    urlServiceRules: any,
+    states: any,
+    builder: any,
+    listeners: any,
+  );
+  stateRegistry: import("./state-registry.js").StateRegistryProvider;
+  urlServiceRules: any;
+  states: any;
+  builder: any;
+  listeners: any;
+  /**
+   * @type {Array<StateObject>}
+   */
+  queue: Array<StateObject>;
+  register(stateDecl: any): StateObject;
+  flush(): any;
+  attachRoute(state: any): void;
+}
+import { StateObject } from "./state-object.js";

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

@@ -0,0 +1,133 @@
+/** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider } */
+/**
+ * A registry for all of the application's [[StateDeclaration]]s
+ *
+ * This API is found at `$stateRegistry` ([[UIRouter.stateRegistry]])
+ *
+ */
+export class StateRegistryProvider {
+  static $inject: string[];
+  /**
+   * @param urlService
+   * @param stateService
+   * @param {import('../router.js').Router} globals
+   * @param viewService
+   */
+  constructor(
+    urlService: any,
+    stateService: any,
+    globals: import("../router.js").Router,
+    viewService: any,
+  );
+  states: {};
+  urlService: any;
+  urlServiceRules: any;
+  $injector: any;
+  listeners: any[];
+  matcher: StateMatcher;
+  builder: StateBuilder;
+  stateQueue: StateQueueManager;
+  $get: (string | (($injector: any) => StateRegistryProvider))[];
+  /**
+   * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
+   * `onRetain` callback hooks on a [[StateDeclaration]].
+   *
+   * 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;
+  /**
+   * @private
+   */
+  private registerRoot;
+  _root: import("./state-object.js").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.js").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.js").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 {import('./state-object').StateObject[]} a list of removed states
+   */
+  deregister(stateOrName: any): any[];
+  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;
+/**
+ * }
+ */
+export type ServiceProvider = import("../../interface.ts").ServiceProvider;
+import { StateMatcher } from "./state-matcher.js";
+import { StateBuilder } from "./state-builder.js";
+import { StateQueueManager } from "./state-queue-manager.js";