@angular-wave/angular.ts 0.9.0 → 0.9.1

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

@@ -1,95 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-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

@@ -1,83 +0,0 @@
-/** @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

@@ -1,29 +0,0 @@
-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

@@ -1,134 +0,0 @@
-/** @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;
-  /** @type {import('../../interface.ts').AnnotatedFactory} */
-  $get: import("../../interface.ts").AnnotatedFactory;
-  /**
-   * 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";