@angular-wave/angular.ts 0.8.0 → 0.8.1

package/@types/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/interface.d.ts

@@ -36,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.

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/{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
    *

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;

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

@@ -18,18 +18,18 @@ export class Transition implements IHookRegistry {
    *        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('../globals.js').RouterGlobals} globals
+   * @param {import('../router.js').Router} 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("../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;
   /**

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 */

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

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

@@ -6,13 +6,13 @@ export class UrlService {
   /**
    * @param {import("../../services/location/location").LocationProvider} $locationProvider
    * @param {import("../../router/state/state-service.js").StateProvider} stateService
-   * @param {import("../../router/globals.js").RouterGlobals} globals
+   * @param {import("../router.js").Router} globals
    * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
    */
   constructor(
     $locationProvider: any,
     stateService: import("../../router/state/state-service.js").StateProvider,
-    globals: import("../../router/globals.js").RouterGlobals,
+    globals: import("../router.js").Router,
     urlConfigProvider: import("../../router/url/url-config.js").UrlConfigProvider,
   );
   /** @type {import("../../services/location/location").Location} */

package/@types/shared/hof.d.ts

@@ -54,11 +54,6 @@ export function compose(...args: any[]): () => any;
  * then, piped is: h(g(f(x)))
  */
 export function pipe(...args: any[]): any;
-/**
- * Given two functions that return truthy or falsey values, returns a function that returns truthy
- * if at least one of the functions returns truthy for the given arguments
- */
-export function or(fn1: any, fn2: any): (...args: any[]) => any;
 /**
  * Sorta like Pattern Matching (a functional programming conditional construct)
  *
@@ -109,6 +104,5 @@ export function pattern(struct: any): (arg0: any) => any;
  */
 export const propEq: any;
 export function parse(name: any): any;
-export function all(fn1: any): (arr: any) => any;
 export function is(ctor: any): (obj: any) => boolean;
 export function val(v: any): () => any;