@angular-wave/angular.ts 0.7.8 → 0.8.1

package/@types/{loader.d.ts → angular.d.ts}

@@ -18,7 +18,7 @@ export class Angular {
   getInjector: typeof getInjector;
   getScope: typeof getScope;
   errorHandlingConfig: typeof errorHandlingConfig;
-  $injectTokens: Readonly<Record<string, string>>;
+  $t: Readonly<Record<string, string>>;
   /**
    * Use this function to manually start up AngularTS application.
    *
@@ -124,14 +124,14 @@ export class Angular {
    * @param {string} name The name of the module to create or retrieve.
    * @param {Array.<string>} [requires] If specified then new module is being created. If
    *        unspecified then the module is being retrieved for further configuration.
-   * @param {Array<any>|Function} [configFn] Optional configuration function for the module that gets
+   * @param {import("./interface.js").Injectable} [configFn] Optional configuration function for the module that gets
    *        passed to {@link NgModule.config NgModule.config()}.
    * @returns {NgModule} A newly registered module.
    */
   module(
     name: string,
     requires?: Array<string>,
-    configFn?: Array<any> | Function,
+    configFn?: import("./interface.js").Injectable,
   ): NgModule;
 }
 /**

package/@types/core/di/ng-module.d.ts

@@ -22,9 +22,13 @@ export class NgModule {
   /**
    * @param {string} name - Name of the module
    * @param {Array<string>} requires - List of modules which the injector will load before the current module
-   * @param {Function} [configFn]
+   * @param {import("../../interface.js").Injectable} [configFn]
    */
-  constructor(name: string, requires: Array<string>, configFn?: Function);
+  constructor(
+    name: string,
+    requires: Array<string>,
+    configFn?: import("../../interface.js").Injectable,
+  );
   /**
    * Name of the current module.
    * @type {string}
@@ -42,8 +46,8 @@ export class NgModule {
   invokeQueue: Array<Array<any>>;
   /** @type {!Array<Array<*>>} */
   configBlocks: Array<Array<any>>;
-  /** @type {!Array.<Function>} */
-  runBlocks: Array<Function>;
+  /** @type {!Array.<import("../../interface.js").Injectable>} */
+  runBlocks: Array<import("../../interface.js").Injectable>;
   /**
    * @param {string} name
    * @param {any} object
@@ -58,62 +62,94 @@ export class NgModule {
   constant(name: string, object: any): NgModule;
   /**
    *
-   * @param {Function} configFn
+   * @param {import("../../interface.js").Injectable} configFn
    * @returns {NgModule}
    */
-  config(configFn: Function): NgModule;
+  config(configFn: import("../../interface.js").Injectable): NgModule;
   /**
-   * @param {Function} block
+   * @param {import("../../interface.js").Injectable} block
    * @returns {NgModule}
    */
-  run(block: Function): NgModule;
+  run(block: import("../../interface.js").Injectable): NgModule;
   /**
    * @param {string} name
-   * @param {*} options
+   * @param {import("../../interface.js").Injectable} options
    * @returns {NgModule}
    */
-  component(name: string, options: any): NgModule;
+  component(
+    name: string,
+    options: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} providerFunction
+   * @param {import("../../interface.js").Injectable} providerFunction
    * @returns {NgModule}
    */
-  factory(name: string, providerFunction: any): NgModule;
+  factory(
+    name: string,
+    providerFunction: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} serviceFunction
+   * @param {import("../../interface.js").Injectable} serviceFunction
    * @returns {NgModule}
    */
-  service(name: string, serviceFunction: any): NgModule;
+  service(
+    name: string,
+    serviceFunction: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} providerType
+   * @param {import("../../interface.js").Injectable} providerType
    * @returns {NgModule}
    */
-  provider(name: string, providerType: any): NgModule;
+  provider(
+    name: string,
+    providerType: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} decorFn
+   * @param {import("../../interface.js").Injectable} decorFn
    * @returns {NgModule}
    */
-  decorator(name: string, decorFn: any): NgModule;
+  decorator(
+    name: string,
+    decorFn: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} directiveFactory
+   * @param {import("../../interface.js").Injectable} directiveFactory
    * @returns {NgModule}
    */
-  directive(name: string, directiveFactory: any): NgModule;
+  directive(
+    name: string,
+    directiveFactory: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} animationFactory
+   * @param {import("../../interface.js").Injectable} animationFactory
    * @returns {NgModule}
    */
-  animation(name: string, animationFactory: any): NgModule;
-  filter(name: any, filterFn: any): this;
+  animation(
+    name: string,
+    animationFactory: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} ctlFn
+   * @param {import("../../interface.js").Injectable} filterFn
+   * @return {NgModule}
+   */
+  filter(
+    name: string,
+    filterFn: import("../../interface.js").Injectable,
+  ): NgModule;
+  /**
+   * @param {string} name
+   * @param {import("../../interface.js").Injectable} ctlFn
    * @returns {NgModule}
    */
-  controller(name: string, ctlFn: any): NgModule;
+  controller(
+    name: string,
+    ctlFn: import("../../interface.js").Injectable,
+  ): NgModule;
 }

package/@types/core/parse/parse.d.ts

@@ -1,4 +1,9 @@
-export function ParseProvider(): void;
+export function constantWatchDelegate(
+  scope: any,
+  listener: any,
+  objectEquality: any,
+  parsedExpression: any,
+): any;
 export class ParseProvider {
   /**
    * Allows defining the set of characters that are allowed in AngularTS expressions. The function
@@ -26,9 +31,3 @@ export class ParseProvider {
   ) => ParseProvider;
   $get: (string | (($filter: (any: any) => any) => any))[];
 }
-export function constantWatchDelegate(
-  scope: any,
-  listener: any,
-  objectEquality: any,
-  parsedExpression: any,
-): any;

package/@types/directive/bind/bind.d.ts

@@ -7,10 +7,11 @@ export function ngBindDirective(): import("../../interface.ts").Directive;
  */
 export function ngBindTemplateDirective(): import("../../interface.ts").Directive;
 /**
+ * @param {import('../../core/parse/interface.ts').ParseService} $parse
  * @returns {import('../../interface.ts').Directive}
  */
 export function ngBindHtmlDirective(
-  $parse: any,
+  $parse: import("../../core/parse/interface.ts").ParseService,
 ): import("../../interface.ts").Directive;
 export namespace ngBindHtmlDirective {
   let $inject: string[];

package/@types/index.d.ts

@@ -1,2 +1,2 @@
 export const angular: Angular;
-import { Angular } from "./loader.js";
+import { Angular } from "./angular.js";

package/@types/interface.d.ts

@@ -4,6 +4,8 @@ export * from "./core/di/ng-module.js";
 export * from "./services/http/interface.ts";
 export * from "./services/log/interface.ts";
 export * from "./services/log/log.js";
+export * from "./services/location/interface.ts";
+export * from "./services/location/location.js";
 export * from "./services/pubsub/pubsub.js";
 export * from "./services/template-cache/interface.ts";
 export * from "./services/template-cache/template-cache.js";
@@ -34,13 +36,13 @@ export type ExpandoStore = {
  * ```
  */
 export type AnnotatedFactory = [...string[], (...args: any[]) => any];
+export type InjectableFactory = (...args: any[]) => any;
 /**
  * A factory that can be either a standalone function or a dependency-annotated array.
  *
  * The array form is used to support minification-safe dependency injection.
  * See {@link AnnotatedFactory}.
  */
-export type InjectableFactory = (...args: any[]) => any;
 export type Injectable = AnnotatedFactory | InjectableFactory;
 /**
  * An object that defines how a service is constructed.
@@ -61,7 +63,7 @@ export interface Provider {
   /**
    * Register a directive
    * @param name - The name of the directive.
-   * @param provider - An object with a `$get` property that defines how the service is created.
+   * @param directive - An object with a `$get` property that defines how the service is created.
    */
   directive(name: string, directive: DirectiveFactory): Provider;
   /**

package/@types/{public.d.ts → ng.d.ts}

@@ -1,8 +1,8 @@
 /**
  * Initializes core `ng` module.
- * @param {import('./loader.js').Angular} angular
+ * @param {import('./angular.js').Angular} angular
  * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
  */
 export function registerNgModule(
-  angular: import("./loader.js").Angular,
+  angular: import("./angular.js").Angular,
 ): import("./core/di/ng-module.js").NgModule;

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

@@ -27,7 +27,7 @@ export namespace $StateRefDynamicDirective {
 }
 /**
  * @param {*} $state
- * @param {import('../globals.js').RouterGlobals} $routerGlobals
+ * @param {import('../router.js').Router} $router
  * @param {*} $interpolate
  * @param {*} $stateRegistry
  * @param {*} $transitions
@@ -35,7 +35,7 @@ export namespace $StateRefDynamicDirective {
  */
 export function $StateRefActiveDirective(
   $state: any,
-  $routerGlobals: import("../globals.js").RouterGlobals,
+  $router: import("../router.js").Router,
   $interpolate: any,
   $stateRegistry: any,
   $transitions: any,

package/@types/router/directives/view-directive.d.ts

@@ -20,7 +20,7 @@ export namespace $ViewDirectiveFill {
  *   The ng-view can be targeted in a View using the name ([[StateDeclaration.views]]).
  *
  * - `autoscroll`: an expression. When it evaluates to true, the `ng-view` will be scrolled into view when it is activated.
- *   Uses [[$ngViewScroll]] to do the scrolling.
+ *   Uses [[$viewScroll]] to do the scrolling.
  *
  * - `onload`: Expression to evaluate whenever the view updates.
  *

package/@types/router/params/param-type.d.ts

@@ -25,7 +25,6 @@ export class ParamType {
   /**
    * @param def  A configuration object which contains the custom type definition.  The object's
    *        properties will override the default methods and/or pattern in `ParamType`'s public interface.
-   * @returns a new ParamType object
    */
   constructor(def: any);
   pattern: RegExp;

package/@types/router/path/path-utils.d.ts

@@ -34,19 +34,16 @@ export class PathUtils {
   static inheritParams(fromPath: any, toPath: any, toKeys?: any[]): any;
   /**
    * Computes the tree changes (entering, exiting) between a fromPath and toPath.
+   * @param {PathNode[]} fromPath
+   * @param {PathNode[]} toPath
+   * @param {boolean} [reloadState]
+   * @returns {import("../transition/interface.js").TreeChanges}
    */
   static treeChanges(
-    fromPath: any,
-    toPath: any,
-    reloadState: any,
-  ): {
-    from: any;
-    to: any;
-    retained: any;
-    retainedWithToParams: any;
-    exiting: any;
-    entering: any;
-  };
+    fromPath: PathNode[],
+    toPath: PathNode[],
+    reloadState?: boolean,
+  ): import("../transition/interface.js").TreeChanges;
   /**
    * Returns a new path which is: the subpath of the first path which matches the second path.
    *

package/@types/router/{globals.d.ts → router.d.ts}

@@ -5,7 +5,7 @@
  * This is where we hold the global mutable state such as current state, current
  * params, current transition, etc.
  */
-export class RouterGlobals {
+export class Router {
   /**
    * Current parameter values
    *
@@ -44,4 +44,4 @@ export class RouterGlobals {
  */
 export type ServiceProvider = import("../interface.ts").ServiceProvider;
 import { StateParams } from "./params/state-params.js";
-import { Queue } from "./common/queue.js";
+import { Queue } from "../shared/queue.js";

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

@@ -589,7 +589,7 @@ export interface StateDeclaration {
    *
    * An optional object which defines multiple views, or explicitly targets specific named ui-views.
    *
-   * - What is a view config
+   * - What is a view urlConfig
    * - What is a ui-view
    * - Shorthand controller/template
    * - Incompatible with ^

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

@@ -80,4 +80,4 @@ export namespace StateObject {
   function isState(obj: any): boolean;
 }
 export type StateDeclaration = import("./interface.js").StateDeclaration;
-import { Glob } from "../common/glob.js";
+import { Glob } from "../glob/glob.js";

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

@@ -10,13 +10,13 @@ export class StateRegistryProvider {
   /**
    * @param urlService
    * @param stateService
-   * @param {import('../globals.js').RouterGlobals} globals
+   * @param {import('../router.js').Router} globals
    * @param viewService
    */
   constructor(
     urlService: any,
     stateService: any,
-    globals: import("../globals.js").RouterGlobals,
+    globals: import("../router.js").Router,
     viewService: any,
   );
   states: {};

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

@@ -7,34 +7,31 @@ export class StateProvider {
   static $inject: string[];
   /**
    *
-   * @param {import('../globals.js').RouterGlobals} globals
+   * @param {import('../router.js').Router} globals
    * @param {*} transitionService
    */
-  constructor(
-    globals: import("../globals.js").RouterGlobals,
-    transitionService: any,
-  );
+  constructor(globals: import("../router.js").Router, transitionService: any);
   /**
    * The latest successful state parameters
    *
-   * @deprecated This is a passthrough through to [[RouterGlobals.params]]
+   * @deprecated This is a passthrough through to [[Router.params]]
    */
   get params(): import("../params/state-params.js").StateParams;
   /**
    * The current [[StateDeclaration]]
    *
-   * @deprecated This is a passthrough through to [[RouterGlobals.current]]
+   * @deprecated This is a passthrough through to [[Router.current]]
    */
   get current(): import("./interface.js").StateDeclaration;
   /**
    * The current [[StateObject]] (an internal API)
    *
-   * @deprecated This is a passthrough through to [[RouterGlobals.$current]]
+   * @deprecated This is a passthrough through to [[Router.$current]]
    */
   get $current(): import("./state-object.js").StateObject;
   stateRegistry: any;
   urlService: any;
-  globals: import("../globals.js").RouterGlobals;
+  globals: import("../router.js").Router;
   transitionService: any;
   invalidCallbacks: any[];
   _defaultErrorHandler: ($error$: any) => never;
@@ -76,9 +73,9 @@ export class StateProvider {
    * - **params** `{object}` - returns an array of state params that are ensured to
    *   be a super-set of parent's params.
    * - **views** `{object}` - returns a views object where each key is an absolute view
-   *   name (i.e. "viewName@stateName") and each value is the config object
+   *   name (i.e. "viewName@stateName") and each value is the urlConfig object
    *   (template, controller) for the view. Even when you don't use the views object
-   *   explicitly on a state config, one is still created for you internally.
+   *   explicitly on a state urlConfig, one is still created for you internally.
    *   So by decorating this builder function you have access to decorating template
    *   and controller properties.
    * - **ownParams** `{object}` - returns an array of params that belong to the state,
@@ -96,10 +93,10 @@ export class StateProvider {
    *   let result = {},
    *       views = parent(state);
    *
-   *   angular.forEach(views, function (config, name) {
+   *   angular.forEach(views, function (urlConfig, name) {
    *     let autoName = (state.name + '.' + name).replace('.', '/');
-   *     config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';
-   *     result[name] = config;
+   *     urlConfig.templateUrl = urlConfig.templateUrl || '/partials/' + autoName + '.html';
+   *     result[name] = urlConfig;
    *   });
    *   return result;
    * });
@@ -123,7 +120,7 @@ export class StateProvider {
    * @param {object} func A function that is responsible for decorating the original
    * builder function. The function receives two parameters:
    *
-   *   - `{object}` - state - The state config object.
+   *   - `{object}` - state - The state urlConfig object.
    *   - `{object}` - super - The original builder function.
    *
    * @return {object} $stateProvider - $stateProvider instance
@@ -265,7 +262,7 @@ export class StateProvider {
    * This may be returned from a Transition Hook to redirect a transition, for example.
    */
   target(identifier: any, params: any, options?: {}): TargetState;
-  getCurrentPath(): any;
+  getCurrentPath(): PathNode[];
   /**
    * Low-level method for transitioning to a new state.
    *
@@ -419,3 +416,4 @@ export class StateProvider {
   lazyLoad(stateOrName: any, transition: any): any;
 }
 import { TargetState } from "./target-state.js";
+import { PathNode } from "../path/path-node.js";

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

@@ -1,15 +1,37 @@
 /**
+ * `isState` Filter: truthy if the current state is the parameter
+ *
+ * Translates to [[StateService.is]] `$state.is("stateName")`.
+ *
+ * #### Example:
+ * ```html
+ * <div ng-if="'stateName' | isState">show if state is 'stateName'</div>
+ * ```
+ *
+ * @param {import('./state/state-service.js').StateProvider} $state
  * @returns {import('../interface.ts').FilterFn}
  */
-export function $IsStateFilter($state: any): import("../interface.ts").FilterFn;
+export function $IsStateFilter(
+  $state: import("./state/state-service.js").StateProvider,
+): import("../interface.ts").FilterFn;
 export namespace $IsStateFilter {
   let $inject: string[];
 }
 /**
+ * `includedByState` Filter: truthy if the current state includes the parameter
+ *
+ * Translates to [[StateService.includes]]` $state.is("fullOrPartialStateName")`.
+ *
+ * #### Example:
+ * ```html
+ * <div ng-if="'fullOrPartialStateName' | includedByState">show if state includes 'fullOrPartialStateName'</div>
+ * ```
+ *
+ * @param {import('./state/state-service.js').StateProvider} $state
  * @returns {import('../interface.ts').FilterFn}
  */
 export function $IncludedByStateFilter(
-  $state: any,
+  $state: import("./state/state-service.js").StateProvider,
 ): import("../interface.ts").FilterFn;
 export namespace $IncludedByStateFilter {
   let $inject_1: string[];

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

@@ -23,10 +23,10 @@ export namespace defaultTransOpts {
 export class TransitionProvider {
   static $inject: string[];
   /**
-   * @param {import('../globals.js').RouterGlobals} globals
+   * @param {import('../router.js').Router} globals
    * @param viewService
    */
-  constructor(globals: import("../globals.js").RouterGlobals, viewService: any);
+  constructor(globals: import("../router.js").Router, viewService: any);
   _transitionCount: number;
   /** The transition hook types, such as `onEnter`, `onStart`, etc */
   _eventTypes: any[];
@@ -34,7 +34,7 @@ export class TransitionProvider {
   _registeredHooks: {};
   /** The  paths on a criteria object */
   _criteriaPaths: {};
-  globals: import("../globals.js").RouterGlobals;
+  globals: import("../router.js").Router;
   $view: any;
   _deregisterHookFns: {};
   _pluginapi: any;

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

@@ -14,22 +14,22 @@ export class Transition implements IHookRegistry {
    *
    * If the target state is not valid, an error is thrown.
    *
-   * @param fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
+   * @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 targetState The target state and parameters being transitioned to (also, the transition options)
+   * @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('../globals.js').RouterGlobals} globals
+   * @param {import('../router.js').Router} globals
    */
   constructor(
-    fromPath: any,
-    targetState: any,
+    fromPath: Array<import("../path/path-node.js").PathNode>,
+    targetState: import("../state/target-state.js").TargetState,
     transitionService: import("../transition/transition-service.js").TransitionProvider,
-    globals: import("../globals.js").RouterGlobals,
+    globals: import("../router.js").Router,
   );
   /**
-   * @type {import('../globals.js').RouterGlobals}
+   * @type {import('../router.js').Router}
    */
-  globals: import("../globals.js").RouterGlobals;
+  globals: import("../router.js").Router;
   transitionService: import("../transition/transition-service.js").TransitionProvider;
   _deferred: any;
   /**
@@ -44,17 +44,10 @@ export class Transition implements IHookRegistry {
   _hookBuilder: HookBuilder;
   /** Checks if this transition is currently active/running. */
   isActive: () => boolean;
-  _targetState: any;
+  _targetState: import("../state/target-state.js").TargetState;
   _options: any;
   $id: number;
-  _treeChanges: {
-    from: any;
-    to: any;
-    retained: any;
-    retainedWithToParams: any;
-    exiting: any;
-    entering: any;
-  };
+  _treeChanges: import("./interface.js").TreeChanges;
   onStart: any;
   onBefore: any;
   onSuccess: any;
@@ -101,7 +94,7 @@ export class Transition implements IHookRegistry {
    *
    * @returns the [[TargetState]] of this Transition
    */
-  targetState(): any;
+  targetState(): import("../state/target-state.js").TargetState;
   /**
    * Determines whether two transitions are equivalent.
    * @deprecated
@@ -319,7 +312,11 @@ export class Transition implements IHookRegistry {
    * @returns a list of ViewConfig objects for the given path.
    */
   views(pathname: string, state: any): any;
-  treeChanges(pathname: any): any;
+  treeChanges(
+    pathname: any,
+  ):
+    | import("../path/path-node.js").PathNode[]
+    | import("./interface.js").TreeChanges;
   /**
    * Creates a new transition that is a redirection of the current one.
    *

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

@@ -50,7 +50,6 @@
  *
  */
 export class UrlMatcher {
-  static encodeDashes(str: any): string;
   /** @internal Given a matcher, return an array with the matcher's path segments and path params, in order */
   static pathSegmentsAndParams(matcher: any): any;
   /** @internal Given a matcher, return an array with the matcher's query params */
@@ -112,9 +111,9 @@ export class UrlMatcher {
    * // returns { id: 'bob', q: 'hello', r: null }
    * ```
    *
-   * @param path    The URL path to match, e.g. `$location.path()`.
-   * @param search  URL search parameters, e.g. `$location.search()`.
-   * @param hash    URL hash e.g. `$location.hash()`.
+   * @param path    The URL path to match, e.g. `$location.getPath()`.
+   * @param search  URL search parameters, e.g. `$location.getSearch()`.
+   * @param hash    URL hash e.g. `$location.getHash()`.
    *
    * @returns The captured parameter values.
    */

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

@@ -9,10 +9,19 @@
  * - [[StateObject]]
  */
 export class UrlRuleFactory {
-  constructor(urlService: any, stateService: any, routerGlobals: any);
-  urlService: any;
-  stateService: any;
-  routerGlobals: any;
+  /**
+   * @param {import('../url/url-service.js').UrlService} urlService
+   * @param {import('../state/state-service.js').StateProvider} stateService
+   * @param {import('../router.js').Router} routerGlobals
+   */
+  constructor(
+    urlService: import("../url/url-service.js").UrlService,
+    stateService: import("../state/state-service.js").StateProvider,
+    routerGlobals: import("../router.js").Router,
+  );
+  urlService: import("../url/url-service.js").UrlService;
+  stateService: import("../state/state-service.js").StateProvider;
+  routerGlobals: import("../router.js").Router;
   /**
    *
    * @param {*} what
@@ -142,6 +151,7 @@ export class BaseUrlRule {
   $id: number;
   _group: any;
   handler: any;
+  priority: any;
   /**
    * This function should be overridden
    * @param {*} [params]