@angular-wave/angular.ts 0.14.2 → 0.15.0

package/@types/router/scroll/view-scroll.d.ts

@@ -0,0 +1,8 @@
+export class ViewScrollProvider {
+  enabled: boolean;
+  useAnchorScroll(): void;
+  $get: (
+    | string
+    | (($anchorScroll: ng.AnchorScrollObject) => ng.ViewScrollService)
+  )[];
+}

package/@types/router/state/interface.d.ts

@@ -352,7 +352,7 @@ export interface StateDeclaration {
    * Note: [State] objects require unique names.
    * The name is used like an id.
    */
-  name?: string;
+  name: string;
   /**
    * Abstract state indicator
    *
@@ -385,131 +385,6 @@ export interface StateDeclaration {
    * ```
    */
   parent?: string | StateDeclaration;
-  /**
-   * Resolve - a mechanism to asynchronously fetch data, participating in the Transition lifecycle
-   *
-   * The `resolve:` property defines data (or other dependencies) to be fetched asynchronously when the state is being entered.
-   * After the data is fetched, it may be used in views, transition hooks or other resolves that belong to this state.
-   * The data may also be used in any views or resolves that belong to nested states.
-   *
-   * ### As an array
-   *
-   * Each array element should be a [[ResolvableLiteral]] object.
-   *
-   * #### Example:
-   * The `user` resolve injects the current `Transition` and the `UserService` (using its token, which is a string).
-   * The [[ResolvableLiteral.resolvePolicy]] sets how the resolve is processed.
-   * The `user` data, fetched asynchronously, can then be used in a view.
-   * ```js
-   * var state = {
-   *   name: 'user',
-   *   url: '/user/:userId
-   *   resolve: [
-   *     {
-   *       token: 'user',
-   *       policy: { when: 'EAGER' },
-   *       deps: ['UserService', Transition],
-   *       resolveFn: (userSvc, trans) => userSvc.fetchUser(trans.params().userId) },
-   *     }
-   *   ]
-   * }
-   * ```
-   *
-   * Note: an Angular 2 style [`useFactory` provider literal](https://angular.io/docs/ts/latest/cookbook/dependency-injection.html#!#provide)
-   * may also be used.  See [[ProviderLike]].
-   * #### Example:
-   * ```
-   * resolve: [
-   *   { provide: 'token', useFactory: (http) => http.get('/'), deps: [ Http ] },
-   * ]
-   * ```
-   *
-   * ### As an object
-   *
-   * The `resolve` property may be an object where:
-   * - Each key (string) is the name of the dependency.
-   * - Each value (function) is an injectable function which returns the dependency, or a promise for the dependency.
-   *
-   * This style is based on AngularTS injectable functions, but can be used with any UI-Router implementation.
-   * If your code will be minified, the function should be ["annotated" in the AngularTS manner](https://docs.angularjs.org/guide/di#dependency-annotation).
-   *
-   * #### AngularTS Example:
-   * ```js
-   * resolve: {
-   *   // If you inject `myStateDependency` into a controller, you'll get "abc"
-   *   myStateDependency: function() {
-   *     return "abc";
-   *   },
-   *   // Dependencies are annotated in "Inline Array Annotation"
-   *   myAsyncData: ['$http', '$transition$' function($http, $transition$) {
-   *     // Return a promise (async) for the data
-   *     return $http.get("/foos/" + $transition$.params().foo);
-   *   }]
-   * }
-   * ```
-   *
-   * Note: You cannot specify a policy for each Resolvable, nor can you use non-string
-   * tokens when using the object style `resolve:` block.
-   *
-   * ### Lifecycle
-   *
-   * Since a resolve function can return a promise, the router will delay entering the state until the promises are ready.
-   * If any of the promises are rejected, the Transition is aborted with an Error.
-   *
-   * By default, resolves for a state are fetched just before that state is entered.
-   * Note that only states which are being *entered* during the `Transition` have their resolves fetched.
-   * States that are "retained" do not have their resolves re-fetched.
-   *
-   * If you are currently in a parent state `parent` and are transitioning to a child state `parent.child`, the
-   * previously resolved data for state `parent` can be injected into `parent.child` without delay.
-   *
-   * Any resolved data for `parent.child` is retained until `parent.child` is exited, e.g., by transitioning back to the `parent` state.
-   *
-   * Because of this scoping and lifecycle, resolves are a great place to fetch your application's primary data.
-   *
-   * ### Injecting resolves into other things
-   *
-   * During a transition, Resolve data can be injected into:
-   *
-   * - Views (the components which fill a `ui-view` tag)
-   * - Transition Hooks
-   * - Other resolves (a resolve may depend on asynchronous data from a different resolve)
-   *
-   * ### Injecting other things into resolves
-   *
-   * Resolve functions usually have dependencies on some other API(s).
-   * The dependencies are usually declared and injected into the resolve function.
-   * A common pattern is to inject a custom service such as `UserService`.
-   * The resolve then delegates to a service method, such as `UserService.list()`;
-   *
-   * #### Special injectable tokens
-   *
-   * - `UIRouter`: The [[UIRouter]] instance which has references to all the UI-Router services.
-   * - `Transition`: The current [[Transition]] object; information and API about the current transition, such as
-   *    "to" and "from" State Parameters and transition options.
-   * - `'$transition$'`: A string alias for the `Transition` injectable
-   * - `'$state$'`: For `onEnter`/`onExit`/`onRetain`, the state being entered/exited/retained.
-   * - Other resolve tokens: A resolve can depend on another resolve, either from the same state, or from any parent state.
-   *
-   * #### Example:
-   * ```js
-   * // Injecting a resolve into another resolve
-   * resolve: [
-   *   // Define a resolve 'allusers' which delegates to the UserService.list()
-   *   // which returns a promise (async) for all the users
-   *   { provide: 'allusers', useFactory: (UserService) => UserService.list(), deps: [UserService] },
-   *
-   *   // Define a resolve 'user' which depends on the allusers resolve.
-   *   // This resolve function is not called until 'allusers' is ready.
-   *   { provide: 'user', (allusers, trans) => _.find(allusers, trans.params().userId, deps: ['allusers', Transition] }
-   * }
-   * ```
-   */
-  resolve?:
-    | ResolveTypes[]
-    | {
-        [key: string]: Injectable<any>;
-      };
   /**
    * Sets the resolve policy defaults for all resolves on this state
    *
@@ -928,6 +803,30 @@ export interface StateDeclaration {
    */
   reloadOnSearch?: boolean;
 }
+/**
+ * Represents a fully built StateObject, after registration in the StateRegistry
+ * and application of all StateBuilder decorators.
+ */
+export type BuiltStateDeclaration = StateDeclaration & {
+  /** Reference to the original StateDeclaration */
+  self: StateDeclaration;
+  /** Array of Resolvables built from the resolve / resolvePolicy */
+  resolvables: Resolvable[];
+  /** Full path from root down to this state */
+  path: BuiltStateDeclaration[];
+  /** Fast lookup of included states for $state.includes() */
+  includes: Record<string, boolean>;
+  /** Closest ancestor state that has a URL (navigable) */
+  navigable?: BuiltStateDeclaration | null;
+  /** URL object built from url / parent / root */
+  url?: any;
+  /** Computed parameters of this state */
+  params?: Record<string, any>;
+  /** Optional parent state */
+  parent?: BuiltStateDeclaration | null;
+  /** Optional inherited data */
+  data?: any;
+};
 /**
  * The return type of a [[StateDeclaration.lazyLoad]] function
  *

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

@@ -38,8 +38,11 @@
  *   new Resolvable("myBarResolve", function(dep) { return dep.fetchSomethingAsPromise() }, [ "DependencyName" ]),
  *   { provide: "myBazResolve", useFactory: function(dep) { dep.fetchSomethingAsPromise() }, deps: [ "DependencyName" ] }
  * ]
+ * @param {ng.StateObject & ng.StateDeclaration} state
  */
-export function resolvablesBuilder(state: any): any[];
+export function resolvablesBuilder(
+  state: ng.StateObject & ng.StateDeclaration,
+): any[];
 /**
  * A internal global service
  *

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

@@ -24,9 +24,9 @@ export class StateObject implements StateDeclaration {
   includes: any;
   $$state: () => this;
   /**
-   * @type {import('./interface.ts').StateDeclaration}
+   * @type {ng.StateDeclaration|ng.BuiltStateDeclaration}
    */
-  self: import("./interface.ts").StateDeclaration;
+  self: ng.StateDeclaration | ng.BuiltStateDeclaration;
   __stateObjectCache: {
     nameGlob: Glob;
   };

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

@@ -2,20 +2,20 @@ export class StateQueueManager {
   /**
    * @param {import("./state-registry.js").StateRegistryProvider} stateRegistry
    * @param {*} urlServiceRules
-   * @param {*} states
+   * @param {Record<string, ng.StateObject>} states
    * @param {*} builder
    * @param {*} listeners
    */
   constructor(
     stateRegistry: import("./state-registry.js").StateRegistryProvider,
     urlServiceRules: any,
-    states: any,
+    states: Record<string, ng.StateObject>,
     builder: any,
     listeners: any,
   );
   stateRegistry: import("./state-registry.js").StateRegistryProvider;
   urlServiceRules: any;
-  states: any;
+  states: Record<string, StateObject>;
   builder: any;
   listeners: any;
   /**
@@ -23,7 +23,7 @@ export class StateQueueManager {
    */
   queue: Array<StateObject>;
   register(stateDecl: any): StateObject;
-  flush(): any;
+  flush(): Record<string, StateObject>;
   attachRoute(state: any): void;
 }
 import { StateObject } from "./state-object.js";

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

@@ -8,20 +8,21 @@
 export class StateRegistryProvider {
   static $inject: string[];
   /**
-   * @param urlService
-   * @param stateService
-   * @param {import('../router.js').Router} globals
-   * @param viewService
+   * @param {ng.UrlService} urlService
+   * @param {ng.StateService} stateService
+   * @param {ng.RouterService} globals
+   * @param {ng.ViewService} viewService
    */
   constructor(
-    urlService: any,
-    stateService: any,
-    globals: import("../router.js").Router,
-    viewService: any,
+    urlService: ng.UrlService,
+    stateService: ng.StateService,
+    globals: ng.RouterService,
+    viewService: ng.ViewService,
   );
-  states: {};
-  urlService: any;
-  urlServiceRules: any;
+  /** @type {Record<string, import("./state-object.js").StateObject>} */
+  states: Record<string, import("./state-object.js").StateObject>;
+  urlService: import("../url/url-service.js").UrlService;
+  urlServiceRules: import("../url/url-rules.js").UrlRules;
   $injector: any;
   listeners: any[];
   matcher: StateMatcher;
@@ -110,6 +111,10 @@ export class StateRegistryProvider {
    * @returns {import('./state-object').StateObject[]} a list of removed states
    */
   deregister(stateOrName: any): any[];
+  /**
+   * @return {ng.BuiltStateDeclaration[]}
+   */
+  getAll(): ng.BuiltStateDeclaration[];
   get(stateOrName: any, base: any, ...args: any[]): any;
   /**
    * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).

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

@@ -7,14 +7,14 @@ export class StateProvider {
   static $inject: string[];
   /**
    *
-   * @param {import('../router.js').Router} globals
-   * @param {*} transitionService
-   * @param {import('../../core/di/internal-injector.js').InjectorService} $injector
+   * @param {ng.RouterProvider} globals
+   * @param {ng.TransitionProvider} transitionService
+   * @param {ng.ExceptionHandlerProvider} exceptionHandlerProvider
    */
   constructor(
-    globals: import("../router.js").Router,
-    transitionService: any,
-    $injector: import("../../core/di/internal-injector.js").InjectorService,
+    globals: ng.RouterProvider,
+    transitionService: ng.TransitionProvider,
+    exceptionHandlerProvider: ng.ExceptionHandlerProvider,
   );
   /**
    * The latest successful state parameters
@@ -34,14 +34,20 @@ export class StateProvider {
    * @deprecated This is a passthrough through to [[Router.$current]]
    */
   get $current(): import("./state-object.js").StateObject;
+  globals: import("../router.js").RouterProvider;
+  transitionService: import("../transition/transition-service.js").TransitionProvider;
   stateRegistry: any;
-  urlService: any;
-  globals: import("../router.js").Router;
-  transitionService: any;
-  $injector: import("../../core/di/internal-injector.js").InjectorService;
+  /** @type {ng.UrlService} */
+  urlService: ng.UrlService;
+  /** @type {ng.InjectorService} */
+  $injector: ng.InjectorService;
   invalidCallbacks: any[];
-  _defaultErrorHandler: ($error$: any) => never;
-  $get: () => this;
+  /** @type {ng.ExceptionHandlerService} */
+  _defaultErrorHandler: ng.ExceptionHandlerService;
+  $get: (
+    | string
+    | (($injector: ng.InjectorService, $url: any) => StateProvider)
+  )[];
   /**
    * Decorates states when they are registered
    *

package/@types/router/template-factory.d.ts

@@ -19,9 +19,9 @@ export class TemplateFactoryProvider {
       ) => this)
   )[];
   $templateRequest: any;
-  $http: import("../interface.ts").HttpService;
+  $http: import("../services/http/interface.ts").HttpService;
   $templateCache: ng.TemplateCacheService;
-  $injector: import("../interface.ts").InjectorService;
+  $injector: import("../core/di/internal-injector.js").InjectorService;
   /**
    * Forces the provider to use $http service directly
    * @param {boolean} value

package/@types/router/transition/interface.d.ts

@@ -168,11 +168,11 @@ export type IHookRegistration = (
  *
  * #### See:
  *
- * - [[IHookRegistry.onBefore]]
- * - [[IHookRegistry.onStart]]
- * - [[IHookRegistry.onFinish]]
- * - [[IHookRegistry.onSuccess]]
- * - [[IHookRegistry.onError]]
+ * - [[HookRegistry.onBefore]]
+ * - [[HookRegistry.onStart]]
+ * - [[HookRegistry.onFinish]]
+ * - [[HookRegistry.onSuccess]]
+ * - [[HookRegistry.onError]]
  *
  * @param transition the current [[Transition]]
  * @param injector (for ng1 or ng2 only) the injector service
@@ -196,9 +196,9 @@ export interface TransitionHookFn {
  *
  * #### See also:
  *
- * - [[IHookRegistry.onExit]]
- * - [[IHookRegistry.onRetain]]
- * - [[IHookRegistry.onEnter]]
+ * - [[HookRegistry.onExit]]
+ * - [[HookRegistry.onRetain]]
+ * - [[HookRegistry.onEnter]]
  *
  * #### Example:
  * ```js
@@ -287,7 +287,7 @@ export interface HookRegOptions {
  * [[TransitionService]] and also the [[Transition]] object itself implement this interface.
  * Note: the Transition object only allows hooks to be registered before the Transition is started.
  */
-export interface IHookRegistry {
+export interface HookRegistry {
   /**
    * Registers a [[TransitionHookFn]], called *before a transition starts*.
    *

package/@types/router/transition/reject-factory.d.ts

@@ -3,11 +3,11 @@
  */
 export type RejectType = number;
 export namespace RejectType {
-  let SUPERSEDED: number;
-  let ABORTED: number;
-  let INVALID: number;
-  let IGNORED: number;
-  let ERROR: number;
+  let _SUPERSEDED: number;
+  let _ABORTED: number;
+  let _INVALID: number;
+  let _IGNORED: number;
+  let _ERROR: number;
 }
 export class Rejection {
   /** Returns a Rejection due to transition superseded */

package/@types/router/transition/transition-hook.d.ts

@@ -2,33 +2,21 @@
  * Enum representing the different phases of a transition hook.
  */
 export type TransitionHookPhase = number;
-/**
- * Enum representing the different phases of a transition hook.
- *
- * @readonly
- * @enum {number}
- */
-export const TransitionHookPhase: Readonly<{
-  CREATE: 0;
-  BEFORE: 1;
-  RUN: 2;
-  SUCCESS: 3;
-  ERROR: 4;
-}>;
+export namespace TransitionHookPhase {
+  let _CREATE: number;
+  let _BEFORE: number;
+  let _RUN: number;
+  let _SUCCESS: number;
+  let _ERROR: number;
+}
 /**
  * Enum representing the scope in which a transition hook operates.
  */
 export type TransitionHookScope = number;
-/**
- * Enum representing the scope in which a transition hook operates.
- *
- * @readonly
- * @enum {number}
- */
-export const TransitionHookScope: Readonly<{
-  TRANSITION: 0;
-  STATE: 1;
-}>;
+export namespace TransitionHookScope {
+  let _TRANSITION: number;
+  let _STATE: number;
+}
 export class TransitionHook {
   /**
    * Chains together an array of TransitionHooks.
@@ -65,11 +53,20 @@ export class TransitionHook {
    * Run all TransitionHooks, ignoring their return value.
    */
   static runAllHooks(hooks: any): void;
+  /**
+   *
+   * @param {*} transition
+   * @param {*} stateContext
+   * @param {*} registeredHook
+   * @param {*} options
+   * @param {ng.ExceptionHandlerService} exceptionHandler
+   */
   constructor(
     transition: any,
     stateContext: any,
     registeredHook: any,
     options: any,
+    exceptionHandler: ng.ExceptionHandlerService,
   );
   transition: any;
   stateContext: any;
@@ -77,6 +74,8 @@ export class TransitionHook {
   options: any;
   isSuperseded: () => boolean;
   type: any;
+  /** @type {ng.ExceptionHandlerService} */
+  _exceptionHandler: ng.ExceptionHandlerService;
   logError(err: any): void;
   invokeHook(): any;
   /**

package/@types/router/transition/transition-service.d.ts

@@ -23,10 +23,15 @@ export namespace defaultTransOpts {
 export class TransitionProvider {
   static $inject: string[];
   /**
-   * @param {import('../router.js').Router} globals
-   * @param viewService
+   * @param {ng.RouterService} globals
+   * @param {ng.ViewService} viewService
+   * @param {ng.ExceptionHandlerProvider} $exceptionHandler
    */
-  constructor(globals: import("../router.js").Router, viewService: any);
+  constructor(
+    globals: ng.RouterService,
+    viewService: ng.ViewService,
+    $exceptionHandler: ng.ExceptionHandlerProvider,
+  );
   _transitionCount: number;
   /** The transition hook types, such as `onEnter`, `onStart`, etc */
   _eventTypes: any[];
@@ -34,9 +39,11 @@ export class TransitionProvider {
   _registeredHooks: {};
   /** The  paths on a criteria object */
   _criteriaPaths: {};
-  globals: import("../router.js").Router;
-  $view: any;
+  globals: import("../router.js").RouterProvider;
+  $view: import("../view/view.js").ViewService;
   _deregisterHookFns: {};
+  /** @type {ng.ExceptionHandlerService} */
+  _$exceptionHandler: ng.ExceptionHandlerService;
   $get: (
     | string
     | ((

package/@types/router/transition/transition.d.ts

@@ -5,9 +5,9 @@
  *
  * This object contains all contextual information about the to/from states, parameters, resolves.
  * It has information about all states being entered and exited as a result of the transition.
- * @implements {IHookRegistry}
+ * @implements {HookRegistry}
  */
-export class Transition implements IHookRegistry {
+export class Transition implements HookRegistry {
   /**
    * Creates a new Transition object.
    *
@@ -16,20 +16,20 @@ export class Transition implements IHookRegistry {
    * @param {Array<import('../path/path-node.js').PathNode>} fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
    *        encapsulates the "from state".
    * @param {import('../state/target-state.js').TargetState} targetState The target state and parameters being transitioned to (also, the transition options)
-   * @param {import('../transition/transition-service.js').TransitionProvider} transitionService The [[TransitionService]] instance
-   * @param {import('../router.js').Router} globals
+   * @param {ng.TransitionProvider} transitionService The [[TransitionService]] instance
+   * @param {ng.RouterService} globals
    */
   constructor(
     fromPath: Array<import("../path/path-node.js").PathNode>,
     targetState: import("../state/target-state.js").TargetState,
-    transitionService: import("../transition/transition-service.js").TransitionProvider,
-    globals: import("../router.js").Router,
+    transitionService: ng.TransitionProvider,
+    globals: ng.RouterService,
   );
   /**
-   * @type {import('../router.js').Router}
+   * @type {import('../router.js').RouterProvider}
    */
-  globals: import("../router.js").Router;
-  transitionService: import("../transition/transition-service.js").TransitionProvider;
+  _globals: import("../router.js").RouterProvider;
+  _transitionService: import("./transition-service.js").TransitionProvider;
   _deferred: any;
   /**
    * This promise is resolved or rejected based on the outcome of the Transition.
@@ -77,7 +77,9 @@ export class Transition implements IHookRegistry {
    *
    * @returns The state declaration object for the Transition's ("from state").
    */
-  from(): import("../state/interface.ts").StateDeclaration;
+  from():
+    | import("../state/interface.ts").StateDeclaration
+    | import("../state/interface.ts").BuiltStateDeclaration;
   /**
    * Returns the "to state"
    *
@@ -85,7 +87,9 @@ export class Transition implements IHookRegistry {
    *
    * @returns The state declaration object for the Transition's target state ("to state").
    */
-  to(): import("../state/interface.ts").StateDeclaration;
+  to():
+    | import("../state/interface.ts").StateDeclaration
+    | import("../state/interface.ts").BuiltStateDeclaration;
   /**
    * Gets the Target State
    *
@@ -280,7 +284,7 @@ export class Transition implements IHookRegistry {
    * @returns true if the Transition is ignored.
    */
   ignored(): boolean;
-  _ignoredReason(): "SameAsCurrent" | "SameAsPending";
+  _ignoredReason(): "SameAsPending" | "SameAsCurrent";
   /**
    * Runs the transition
    *
@@ -326,5 +330,5 @@ export class Transition implements IHookRegistry {
 export namespace Transition {
   export { Transition as diToken };
 }
-export type IHookRegistry = import("./interface.ts").IHookRegistry;
+export type HookRegistry = import("./interface.ts").HookRegistry;
 import { HookBuilder } from "./hook-builder.js";

package/@types/router/url/url-rule.d.ts

@@ -1,17 +1,20 @@
 export class UrlRuleFactory {
   /**
-   * @param {import('../url/url-service.js').UrlService} urlService
-   * @param {import('../state/state-service.js').StateProvider} stateService
-   * @param {import('../router.js').Router} routerGlobals
+   * @param {ng.UrlService} urlService
+   * @param {ng.StateService} stateService
+   * @param {ng.RouterService} routerGlobals
    */
   constructor(
-    urlService: import("../url/url-service.js").UrlService,
-    stateService: import("../state/state-service.js").StateProvider,
-    routerGlobals: import("../router.js").Router,
+    urlService: ng.UrlService,
+    stateService: ng.StateService,
+    routerGlobals: ng.RouterService,
   );
-  urlService: import("../url/url-service.js").UrlService;
-  stateService: import("../state/state-service.js").StateProvider;
-  routerGlobals: import("../router.js").Router;
+  /** @type {ng.UrlService} */
+  urlService: ng.UrlService;
+  /** @type {ng.StateService} */
+  stateService: ng.StateService;
+  /** @type {ng.RouterService} */
+  routerGlobals: ng.RouterService;
   /**
    *
    * @param {*} what