@angular-wave/angular.ts 0.12.0 → 0.14.0

package/@types/angular.d.ts

@@ -122,14 +122,14 @@ export class Angular {
    *     function that will be invoked by the injector as a `config` block.
    *     See: {@link angular.module modules}
    * @param {import("./interface.ts").AngularBootstrapConfig} [config]
-   * @returns {import('./core/di/internal-injector.js').InjectorService} The created injector instance for this application.
+   * @returns {ng.InjectorService} The created injector instance for this application.
    */
   bootstrap(
     element: string | Element | Document,
     modules?: Array<string | any>,
     config?: import("./interface.ts").AngularBootstrapConfig,
-  ): import("./core/di/internal-injector.js").InjectorService;
-  $rootScope: import("./interface.ts").Scope;
+  ): ng.InjectorService;
+  $rootScope: ng.Scope;
   $injector: import("./interface.ts").InjectorService;
   /**
    * @param {any[]} modules

package/@types/animations/animation.d.ts

@@ -8,7 +8,7 @@ export class AnimationProvider {
         $injector: ng.InjectorService,
         $$rAFScheduler: import("./raf-scheduler.js").RafScheduler,
         $$animateCache: any,
-      ) => (element: any, event: any, options: any) => AnimateRunner)
+      ) => (elementParam: any, event: any, options: any) => AnimateRunner)
   )[];
 }
 import { AnimateRunner } from "./runner/animate-runner.js";

package/@types/animations/raf-scheduler.d.ts

@@ -1,10 +1,9 @@
 /**
  * @typedef {import('./interface.ts').RafScheduler} RafScheduler
- * @typedef {import('../interface.ts').ServiceProvider} ServiceProvider
  */
 /**
  * Service provider that creates a requestAnimationFrame-based scheduler.
- * @type {ServiceProvider}
+ * @type {ng.ServiceProvider}
  */
 export class RafSchedulerProvider {
   /**
@@ -34,4 +33,3 @@ export class RafSchedulerProvider {
   $get(): RafScheduler;
 }
 export type RafScheduler = import("./interface.ts").RafScheduler;
-export type ServiceProvider = import("../interface.ts").ServiceProvider;

package/@types/core/compile/attributes.d.ts

@@ -16,9 +16,9 @@ export class Attributes {
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any,
   );
-  $rootScope: import("../scope/scope.js").Scope;
+  $rootScope: ng.RootScopeService;
   $animate: import("../../interface.ts").AnimateService;
-  $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler;
+  $exceptionHandler: import("../../interface.ts").ExceptionHandler;
   $sce: any;
   $attr: {};
   /** @type {import("../../shared/noderef.js").NodeRef} */

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

@@ -126,11 +126,11 @@ export class CompileProvider {
     | ((
         $injector: ng.InjectorService,
         $interpolate: any,
-        $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
+        $exceptionHandler: ng.ExceptionHandlerService,
         $templateRequest: ng.TemplateRequestService,
         $parse: ng.ParseService,
         $controller: any,
-        $rootScope: import("../scope/scope.js").Scope,
+        $rootScope: ng.Scope,
         $sce: any,
         $animate: ng.AnimateService,
       ) => (

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

@@ -1,22 +1,8 @@
-/** @private */
-export const INJECTOR_LITERAL: "$injector";
-/** @private */
-export const COMPILE_LITERAL: "$compileProvider";
-/** @private */
-export const ANIMATION_LITERAL: "$animateProvider";
-/** @private */
-export const FILTER_LITERAL: "$filterProvider";
-/** @private */
-export const CONTROLLER_LITERAL: "$controllerProvider";
 /**
  * Modules are collections of application configuration information for components:
  * controllers, directives, filters, etc. They provide recipes for the injector
  * to do the actual instantiation. A module itself has no behaviour but only state.
  * A such, it acts as a data structure between the Angular instance and the injector service.
- *
- * Since this is an internal structure that is exposed only via the Angular instance,
- * it contains no validation of the items it receives. It is up to the instantiator on
- * modules to do the actual validation.
  */
 export class NgModule {
   /**
@@ -49,19 +35,19 @@ export class NgModule {
   /** @type {!Array.<ng.Injectable<any>>} */
   runBlocks: Array<ng.Injectable<any>>;
   services: any[];
-  wasmModules: any[];
+  restDefinitions: any[];
   /**
    * @param {string} name
-   * @param {any} object
+   * @param {any} object - Allows undefined
    * @returns {NgModule}
    */
   value(name: string, object: any): NgModule;
   /**
    * @param {string} name
-   * @param {any} object
+   * @param {Object|string|number} object
    * @returns {NgModule}
    */
-  constant(name: string, object: any): NgModule;
+  constant(name: string, object: any | string | number): NgModule;
   /**
    *
    * @param {ng.Injectable<any>} configFn
@@ -117,16 +103,22 @@ export class NgModule {
   animation(name: string, animationFactory: ng.Injectable<any>): NgModule;
   /**
    * @param {string} name
-   * @param {ng.Injectable<any>} filterFn
+   * @param {ng.FilterFactory} filterFn
    * @return {NgModule}
    */
-  filter(name: string, filterFn: ng.Injectable<any>): NgModule;
+  filter(name: string, filterFn: ng.FilterFactory): NgModule;
   /**
-   * @param {string} name
-   * @param {ng.Injectable<any>} ctlFn
+   * The $controller service is used by Angular to create new controllers.
+   * This provider allows controller registration via the register method.
+   *
+   * @param {string} name Controller name
+   * @param {ng.Injectable<ng.ControllerConstructor>} ctlFn Controller constructor fn (optionally decorated with DI annotations in the array notation)
    * @returns {NgModule}
    */
-  controller(name: string, ctlFn: ng.Injectable<any>): NgModule;
+  controller(
+    name: string,
+    ctlFn: ng.Injectable<ng.ControllerConstructor>,
+  ): NgModule;
   /**
    * Register a named WebAssembly module that will be instantiated via $provide.
    *
@@ -174,24 +166,29 @@ export class NgModule {
   /**
    * @param {string} name
    * @param {Function} ctor
+   * @param {ng.StorageType} type
+   * @param {ng.StorageBackend} [backendOrConfig]
    * @returns {NgModule}
    */
-  session(name: string, ctor: Function): NgModule;
-  /**
-   * @param {string} name
-   * @param {Function} ctor
-   * @returns {NgModule}
-   */
-  local(name: string, ctor: Function): NgModule;
+  store(
+    name: string,
+    ctor: Function,
+    type: ng.StorageType,
+    backendOrConfig?: ng.StorageBackend,
+  ): NgModule;
   /**
-   * @param {string} name
-   * @param {Function} ctor
-   * @param {ng.StorageBackend} backendOrConfig
+   * @template T, ID
+   * Register a REST resource during module configuration.
+   * @param {string} name - Service name
+   * @param {string} url - Base URL or URI template
+   * @param {ng.EntityClass<T>} entityClass - Optional constructor for mapping JSON
+   * @param {Object=} options - Optional RestService options (interceptors, etc)
    * @returns {NgModule}
    */
-  store(
+  rest<T, ID>(
     name: string,
-    ctor: Function,
-    backendOrConfig: ng.StorageBackend,
+    url: string,
+    entityClass: ng.EntityClass<T>,
+    options?: any | undefined,
   ): NgModule;
 }

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

@@ -1,3 +1,9 @@
+/**
+ * $filterProvider - $filter - provider in module ng
+ *
+ * Filters are just functions which transform input to an output. However filters need to be Dependency Injected. To achieve this a filter definition consists of a factory function which is annotated with dependencies and is responsible for creating a filter function.
+ * @extends {ng.ServiceProvider}
+ */
 export class FilterProvider {
   static $inject: string[];
   /**
@@ -6,18 +12,11 @@ export class FilterProvider {
   constructor($provide: ng.ProvideService);
   $provide: import("../../interface.ts").Provider;
   /**
-   * @param {string|Record<string, ng.FilterFn>} name
-   * @param {ng.FilterService} [factory]
-   * @return {import('../../interface.ts').Provider}
+   * Register a filter a config phase;
+   * @param {string} name
+   * @param {ng.FilterFactory} factory
+   * @return {ng.FilterProvider}
    */
-  register(
-    name: string | Record<string, ng.FilterFn>,
-    factory?: ng.FilterService,
-  ): import("../../interface.ts").Provider;
-  $get: (
-    | string
-    | ((
-        $injector: import("../../core/di/internal-injector.js").InjectorService,
-      ) => ng.FilterService)
-  )[];
+  register(name: string, factory: ng.FilterFactory): ng.FilterProvider;
+  $get: (string | (($injector: ng.InjectorService) => ng.FilterService))[];
 }

package/@types/core/scope/interface.d.ts

@@ -7,7 +7,7 @@ export interface AsyncQueueTask {
 }
 export type ListenerFn = (newValue?: any, originalTarget?: object) => void;
 export interface Listener {
-  originalTarget: object;
+  originalTarget: any;
   listenerFn: ListenerFn;
   watchFn: CompiledExpression;
   id: number;

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

@@ -10,10 +10,16 @@ export function nextId(): number;
  */
 export function createScope(target?: any, context?: Scope): Scope;
 /**
+ * @ignore
+ * Checks if a target should be excluded from scope observability
  * @param {any} target
  * @returns {boolean}
  */
-export function isUnsafeGlobal(target: any): boolean;
+export function isNonScope(target: any): boolean;
+/**
+ * Decorator for excluding objects from scope observability
+ */
+export const NONSCOPE: "$nonscope";
 export const $postUpdateQueue: any[];
 export let rootScope: any;
 export class RootScopeProvider {
@@ -26,10 +32,6 @@ export class RootScopeProvider {
       ) => Scope)
   )[];
 }
-/**
- * Decorator for excluding objects from scope observability
- */
-export const NONSCOPE: "$nonscope";
 /**
  * Scope class for the Proxy. It intercepts operations like property access (get)
  * and property setting (set), and adds support for deep change tracking and
@@ -84,8 +86,6 @@ export class Scope {
    */
   $root: Scope;
   $parent: Scope;
-  /** @type {import('./interface.ts').AsyncQueueTask[]} */
-  $$asyncQueue: import("./interface.ts").AsyncQueueTask[];
   filters: any[];
   /** @type {boolean} */
   $$destroyed: boolean;
@@ -141,17 +141,16 @@ export class Scope {
   $new(childInstance: any): any;
   $newIsolate(instance: any): any;
   $transcluded(parentInstance: any): any;
-  deregisterForeignKey(key: any, id: any): boolean;
   $eval(expr: any, locals: any): any;
   /**
    * @param {Object} newTarget
    */
   $merge(newTarget: any): void;
   /**
-   * @param {import('../../interface.ts').Expression} expr
+   * @param {ng.Expression} expr
    * @returns {any}
    */
-  $apply(expr: import("../../interface.ts").Expression): any;
+  $apply(expr: ng.Expression): any;
   /**
    * @param {string} name
    * @param {Function} listener

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

@@ -22,7 +22,7 @@ export class AriaProvider {
     $$watchExpr: (
       attrName: any,
       ariaAttr: any,
-      nativeAriaNodeNames: any,
+      nativeAriaNodeNamesParam: any,
       negate: any,
     ) => (scope: any, elem: any, attr: any) => void;
   };
@@ -83,10 +83,10 @@ export function ngModelAriaDirective($aria: any): {
   require: string;
   priority: number;
   compile(
-    elem: any,
+    _: any,
     attr: any,
   ): {
-    post(scope: any, elem: any, attr: any, ngModel: any): void;
+    post(_: any, elem: any, attrPost: any, ngModel: any): void;
   };
 };
 export namespace ngModelAriaDirective {

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

@@ -1,7 +1,7 @@
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngBindDirective(): import("../../interface.ts").Directive;
+export function ngBindDirective(): ng.Directive;
 /**
  * @returns {import('../../interface.ts').Directive}
  */

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

@@ -1,3 +1,3 @@
-export const ngClassDirective: import("../../interface.ts").DirectiveFactory;
-export const ngClassOddDirective: import("../../interface.ts").DirectiveFactory;
-export const ngClassEvenDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassDirective: ng.DirectiveFactory;
+export const ngClassOddDirective: ng.DirectiveFactory;
+export const ngClassEvenDirective: ng.DirectiveFactory;

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

@@ -29,6 +29,6 @@ export function createWindowEventDirective(
   eventName: string,
 ): ng.Directive;
 /**
- * @type {Record<string, ng.DirectiveFactory>}
+ * @type {Record<string, ng.Injectable<any>>}
  */
-export const ngEventDirectives: Record<string, ng.DirectiveFactory>;
+export const ngEventDirectives: Record<string, ng.Injectable<any>>;

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

@@ -243,7 +243,12 @@ export const formDirective: (
         formElement: any,
         attr: any,
       ) => {
-        pre: (scope: any, formElement: any, attr: any, ctrls: any) => void;
+        pre: (
+          scope: any,
+          formElementParam: any,
+          attrParam: any,
+          ctrls: any,
+        ) => void;
       };
     })
 )[];
@@ -258,7 +263,12 @@ export const ngFormDirective: (
         formElement: any,
         attr: any,
       ) => {
-        pre: (scope: any, formElement: any, attr: any, ctrls: any) => void;
+        pre: (
+          scope: any,
+          formElementParam: any,
+          attrParam: any,
+          ctrls: any,
+        ) => void;
       };
     })
 )[];

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

@@ -3,15 +3,15 @@
  * @param {ng.TemplateRequestService} $templateRequest
  * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
  * @param {ng.AnimateService} $animate
- * @param {import('../../services/exception/interface.ts').ErrorHandler} $exceptionHandler
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.ExceptionHandlerService} $exceptionHandler
+ * @returns {ng.Directive}
  */
 export function ngIncludeDirective(
   $templateRequest: ng.TemplateRequestService,
   $anchorScroll: import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction,
   $animate: ng.AnimateService,
-  $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler,
-): import("../../interface.ts").Directive;
+  $exceptionHandler: ng.ExceptionHandlerService,
+): ng.Directive;
 export namespace ngIncludeDirective {
   let $inject: string[];
 }

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

@@ -45,12 +45,12 @@ export function rangeInputType(
   ctrl: any,
 ): void;
 /**
- * @param {ng.FilterService} $filter
+ * @param {ng.FilterFactory} $filter
  * @param {ng.ParseService} $parse
  * @returns {ng.Directive}
  */
 export function inputDirective(
-  $filter: ng.FilterService,
+  $filter: ng.FilterFactory,
   $parse: ng.ParseService,
 ): ng.Directive;
 export namespace inputDirective {

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

@@ -37,7 +37,7 @@ declare class NgMessageCtrl {
     $animate: ng.AnimateService,
   );
   $element: Element;
-  $scope: import("../../interface.ts").Scope;
+  $scope: ng.Scope;
   $attrs: ng.Attributes;
   $animate: import("../../interface.ts").AnimateService;
   latestKey: number;

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

@@ -5,7 +5,7 @@ export function ngModelDirective(): {
   priority: number;
   compile: (element: Element) => {
     pre: (scope: any, _element: any, attr: any, ctrls: any) => void;
-    post: (scope: any, element: any, _attr: any, ctrls: any) => void;
+    post: (scope: any, elementPost: any, _attr: any, ctrls: any) => void;
   };
 };
 export const ngModelMinErr: (arg0: string, ...arg1: any[]) => Error;
@@ -49,20 +49,20 @@ export class NgModelController {
   static $nonscope: boolean;
   static $inject: string[];
   /**
-   * @param {import('../../core/scope/scope.js').Scope} $scope
-   * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
-   * @param {import('../../core/compile/attributes.js').Attributes} $attr
+   * @param {ng.Scope} $scope
+   * @param {ng.ExceptionHandlerService} $exceptionHandler
+   * @param {ng.Attributes} $attr
    * @param {Element} $element
-   * @param {import("../../core/parse/interface.ts").ParseService} $parse
+   * @param {ng.ParseService} $parse
    * @param {ng.AnimateService} $animate
    * @param {*} $interpolate
    */
   constructor(
-    $scope: import("../../core/scope/scope.js").Scope,
-    $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
-    $attr: import("../../core/compile/attributes.js").Attributes,
+    $scope: ng.Scope,
+    $exceptionHandler: ng.ExceptionHandlerService,
+    $attr: ng.Attributes,
     $element: Element,
-    $parse: import("../../core/parse/interface.ts").ParseService,
+    $parse: ng.ParseService,
     $animate: ng.AnimateService,
     $interpolate: any,
   );
@@ -72,11 +72,17 @@ export class NgModelController {
   $modelValue: any;
   /** @type {any} */
   $$rawModelValue: any;
-  $validators: {};
-  $asyncValidators: {};
-  $parsers: any[];
-  $formatters: any[];
-  $viewChangeListeners: any[];
+  /** @type {any} */
+  $validators: any;
+  /** @type {any} */
+  $asyncValidators: any;
+  /** @type {Array<any>} */
+  $parsers: Array<any>;
+  /** @type {Array<any>} */
+  $formatters: Array<any>;
+  /** @type {Array<any>} */
+  $viewChangeListeners: Array<any>;
+  /** @type {boolean} */
   $untouched: boolean;
   /** @type {boolean} */
   $touched: boolean;
@@ -123,11 +129,11 @@ export class NgModelController {
   $$parsedNgModelAssign: (context: any, value: any) => any;
   /**
    * @type {import("../../core/parse/interface.ts").CompiledExpression |
-   *        (function(import("../../core/scope/scope.js").Scope): any)}
+   *        (function(ng.Scope): any)}
    */
   $$ngModelGet:
     | import("../../core/parse/interface.ts").CompiledExpression
-    | ((arg0: import("../../core/scope/scope.js").Scope) => any);
+    | ((arg0: ng.Scope) => any);
   $$ngModelSet: (context: any, value: any) => any;
   $$pendingDebounce: number;
   $$parserValid: boolean;
@@ -135,13 +141,13 @@ export class NgModelController {
   $$parserName: string;
   /** @type {number} */
   $$currentValidationRunId: number;
-  /** @type {import('../../core/scope/scope.js').Scope} */
-  $$scope: import("../../core/scope/scope.js").Scope;
-  $$attr: import("../../core/compile/attributes.js").Attributes;
+  /** @type {ng.Scope} */
+  $$scope: ng.Scope;
+  $$attr: ng.Attributes;
   $$element: Element;
   $$animate: import("../../interface.ts").AnimateService;
   $$parse: import("../../core/parse/interface.ts").ParseService;
-  $$exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler;
+  $$exceptionHandler: import("../../interface.ts").ExceptionHandler;
   $$hasNativeValidators: boolean;
   $$classCache: {};
   $$eventRemovers: Set<any>;

package/@types/directive/model-options/model-options.d.ts

@@ -1,5 +1,8 @@
+/**
+ * @returns {ng.Directive}
+ */
+export function ngModelOptionsDirective(): ng.Directive;
 export const defaultModelOptions: ModelOptions;
-export function ngModelOptionsDirective(): import("../../interface.ts").Directive;
 export type ModelOptionsConfig = {
   /**
    * - A string specifying which events the input should be bound to. Multiple events can be set using a space-delimited list. The special event 'default' matches the default events belonging to the control.

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

@@ -1,13 +1,13 @@
 /**
  *
  * @param {ng.CompileService} $compile
- * @param {import("../../core/parse/interface.ts").ParseService} $parse
- * @returns {import("../../interface.ts").Directive}
+ * @param {ng.ParseService} $parse
+ * @returns {ng.Directive}
  */
 export function ngOptionsDirective(
   $compile: ng.CompileService,
-  $parse: import("../../core/parse/interface.ts").ParseService,
-): import("../../interface.ts").Directive;
+  $parse: ng.ParseService,
+): ng.Directive;
 export namespace ngOptionsDirective {
   let $inject: string[];
 }

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

@@ -8,7 +8,7 @@ export function optionDirective($interpolate: any): {
   compile(
     element: any,
     attr: any,
-  ): (scope: any, element: any, attr: any) => void;
+  ): (scope: any, elemParam: any, attrParam: any) => void;
 };
 export namespace optionDirective {
   let $inject: string[];

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

@@ -1,4 +1,4 @@
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngStyleDirective(): import("../../interface.ts").Directive;
+export function ngStyleDirective(): ng.Directive;

package/@types/directive/worker/interface.d.ts

@@ -4,6 +4,8 @@ export interface WorkerConfig {
   autoRestart?: boolean;
   autoTerminate?: boolean;
   transformMessage?: (data: any) => any;
+  logger?: ng.LogService;
+  err?: ng.ExceptionHandlerService;
 }
 export interface WorkerConnection {
   post(data: any): void;

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

@@ -3,11 +3,13 @@
  *
  * @param {ng.ParseService} $parse
  * @param {ng.LogService} $log
+ * @param {ng.ExceptionHandlerService} $exceptionHandler
  * @returns {ng.Directive}
  */
 export function ngWorkerDirective(
   $parse: ng.ParseService,
   $log: ng.LogService,
+  $exceptionHandler: ng.ExceptionHandlerService,
 ): ng.Directive;
 export namespace ngWorkerDirective {
   let $inject: string[];

package/@types/filters/interface.d.ts

@@ -5,4 +5,10 @@ export type FilterFn = (input: any, ...args: any[]) => any;
 /**
  * A filter factory function that returns a FilterFn.
  */
-export type FilterFactory = (...args: any[]) => FilterFn;
+export type FilterFactory = (...args: any[]) => FilterFn & {
+  $$moduleName: string;
+};
+/**
+ * A filter service for retrieving filters functions
+ */
+export type FilterService = (name: string) => FilterFn;