@angular-wave/angular.ts 0.11.0 → 0.12.0

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

@@ -1,23 +1,23 @@
 export class Attributes {
   static $nonscope: boolean;
   /**
-   * @param {ng.Scope} $rootScope
-   * @param {*} $animate
+   * @param {ng.RootScopeService} $rootScope
+   * @param {ng.AnimateService} $animate
    * @param {ng.ExceptionHandlerService} $exceptionHandler
    * @param {*} $sce
    * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
    * @param {Object} [attributesToCopy]
    */
   constructor(
-    $rootScope: ng.Scope,
-    $animate: any,
+    $rootScope: ng.RootScopeService,
+    $animate: ng.AnimateService,
     $exceptionHandler: ng.ExceptionHandlerService,
     $sce: any,
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any,
   );
   $rootScope: import("../scope/scope.js").Scope;
-  $animate: any;
+  $animate: import("../../interface.ts").AnimateService;
   $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler;
   $sce: any;
   $attr: {};

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

@@ -124,15 +124,15 @@ export class CompileProvider {
   $get: (
     | string
     | ((
-        $injector: import("../../core/di/internal-injector.js").InjectorService,
+        $injector: ng.InjectorService,
         $interpolate: any,
         $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
-        $templateRequest: any,
-        $parse: import("../parse/interface.ts").ParseService,
+        $templateRequest: ng.TemplateRequestService,
+        $parse: ng.ParseService,
         $controller: any,
         $rootScope: import("../scope/scope.js").Scope,
         $sce: any,
-        $animate: any,
+        $animate: ng.AnimateService,
       ) => (
         compileNode: string | Element | Node | ChildNode | NodeList,
         transcludeFn?: import("./inteface.ts").TranscludeFn,

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

@@ -34,7 +34,7 @@ export class ControllerProvider {
   $get: (
     | string
     | ((
-        $injector: import("../../core/di/internal-injector.js").InjectorService,
+        $injector: ng.InjectorService,
       ) => import("./interface.ts").ControllerService)
   )[];
   /**

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

@@ -0,0 +1,26 @@
+/**
+ * @param {Function} fn
+ * @returns {string}
+ */
+export function stringifyFn(fn: Function): string;
+/**
+ * @param {Function} fn
+ * @returns {Array<any>}
+ */
+export function extractArgs(fn: Function): Array<any>;
+/**
+ * @param {Function} func
+ * @returns {boolean}
+ */
+export function isClass(func: Function): boolean;
+/**
+ * @param {any} fn
+ * @param {boolean} [strictDi]
+ * @param {string} [name]
+ * @returns {Array<string>}
+ */
+export function annotate(
+  fn: any,
+  strictDi?: boolean,
+  name?: string,
+): Array<string>;

package/@types/core/di/injector.d.ts

@@ -8,15 +8,4 @@ export function createInjector(
   modulesToLoad: Array<string | Function>,
   strictDi?: boolean,
 ): InjectorService;
-/**
- * @param {any} fn
- * @param {boolean} [strictDi]
- * @param {String} [name]
- * @returns {Array<string>}
- */
-export function annotate(
-  fn: any,
-  strictDi?: boolean,
-  name?: string,
-): Array<string>;
 import { InjectorService } from "./internal-injector.js";

package/@types/core/di/internal-injector.d.ts

@@ -45,9 +45,9 @@ declare class AbstractInjector {
   strictDi: boolean;
   /** @type {string[]} */
   path: string[];
-  /** @type {Object.<string, import("./ng-module.js").NgModule>} */
+  /** @type {Object.<string, ng.NgModule>} */
   modules: {
-    [x: string]: import("./ng-module.js").NgModule;
+    [x: string]: import("./ng-module/ng-module.js").NgModule;
   };
   /**
    * Get a service by name.

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

@@ -0,0 +1,197 @@
+/** @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 {
+  /**
+   * @param {string} name - Name of the module
+   * @param {Array<string>} requires - List of modules which the injector will load before the current module
+   * @param {ng.Injectable<any>} [configFn]
+   */
+  constructor(
+    name: string,
+    requires: Array<string>,
+    configFn?: ng.Injectable<any>,
+  );
+  /**
+   * Name of the current module.
+   * @type {string}
+   */
+  name: string;
+  /**
+   * Array of module names that this module depends on.
+   * @type {string[]}
+   */
+  requires: string[];
+  /**
+   * Holds a collection of tasks, required to instantiate an angular component
+   * @type {!Array<Array<*>>}
+   */
+  invokeQueue: Array<Array<any>>;
+  /** @type {!Array<Array<*>>} */
+  configBlocks: Array<Array<any>>;
+  /** @type {!Array.<ng.Injectable<any>>} */
+  runBlocks: Array<ng.Injectable<any>>;
+  services: any[];
+  wasmModules: any[];
+  /**
+   * @param {string} name
+   * @param {any} object
+   * @returns {NgModule}
+   */
+  value(name: string, object: any): NgModule;
+  /**
+   * @param {string} name
+   * @param {any} object
+   * @returns {NgModule}
+   */
+  constant(name: string, object: any): NgModule;
+  /**
+   *
+   * @param {ng.Injectable<any>} configFn
+   * @returns {NgModule}
+   */
+  config(configFn: ng.Injectable<any>): NgModule;
+  /**
+   * @param {ng.Injectable<any>} block
+   * @returns {NgModule}
+   */
+  run(block: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Component} options
+   * @returns {NgModule}
+   */
+  component(name: string, options: ng.Component): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} providerFunction
+   * @returns {NgModule}
+   */
+  factory(name: string, providerFunction: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} serviceFunction
+   * @returns {NgModule}
+   */
+  service(name: string, serviceFunction: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} providerType
+   * @returns {NgModule}
+   */
+  provider(name: string, providerType: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} decorFn
+   * @returns {NgModule}
+   */
+  decorator(name: string, decorFn: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} directiveFactory
+   * @returns {NgModule}
+   */
+  directive(name: string, directiveFactory: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} animationFactory
+   * @returns {NgModule}
+   */
+  animation(name: string, animationFactory: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} filterFn
+   * @return {NgModule}
+   */
+  filter(name: string, filterFn: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} ctlFn
+   * @returns {NgModule}
+   */
+  controller(name: string, ctlFn: ng.Injectable<any>): NgModule;
+  /**
+   * Register a named WebAssembly module that will be instantiated via $provide.
+   *
+   * @param {string} name - The injectable name used to access the instantiated WebAssembly module.
+   *
+   * @param {string} src - URL of the `.wasm` file to fetch and instantiate.
+   *
+   * @param {Object<string, any>} [imports] WebAssembly import object, passed to `WebAssembly.instantiate` or  `WebAssembly.instantiateStreaming`.
+   *
+   * @param {Object<string, any>} [opts] - Configuration object.
+   *
+   *   Supported keys:
+   *   - **raw**: `boolean`
+   *       - `false` (default): the injectable resolves to `instance.exports`
+   *         (ideal for plain WASM modules).
+   *       - `true`: the injectable resolves to the full instantiation result:
+   *         `{ instance, exports, module }`
+   *         (required for runtimes such as Go, Emscripten, wasm-bindgen, etc).
+   *
+   * @returns {NgModule}
+   */
+  wasm(
+    name: string,
+    src: string,
+    imports?: {
+      [x: string]: any;
+    },
+    opts?: {
+      [x: string]: any;
+    },
+  ): NgModule;
+  /**
+   * Register a named worker that will be instantiated via $provide.
+   *
+   * @param {string} name
+   * @param {string | URL} scriptPath
+   * @param {ng.WorkerConfig} [config]
+   * @returns {NgModule}
+   */
+  worker(
+    name: string,
+    scriptPath: string | URL,
+    config?: ng.WorkerConfig,
+  ): NgModule;
+  /**
+   * @param {string} name
+   * @param {Function} ctor
+   * @returns {NgModule}
+   */
+  session(name: string, ctor: Function): NgModule;
+  /**
+   * @param {string} name
+   * @param {Function} ctor
+   * @returns {NgModule}
+   */
+  local(name: string, ctor: Function): NgModule;
+  /**
+   * @param {string} name
+   * @param {Function} ctor
+   * @param {ng.StorageBackend} backendOrConfig
+   * @returns {NgModule}
+   */
+  store(
+    name: string,
+    ctor: Function,
+    backendOrConfig: ng.StorageBackend,
+  ): NgModule;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Sanitizer function that processes a URI string and optionally
+ * treats it as a media URL.
+ */
+export type SanitizerFn = (
+  uri: string | null | undefined,
+  isMediaUrl?: boolean,
+) => string | null | undefined;

package/@types/core/sanitize/sanitize-uri.d.ts

@@ -33,8 +33,11 @@ export class SanitizeUriProvider implements ServiceProvider {
     regexp?: RegExp | undefined,
   ): RegExp | SanitizeUriProvider;
   /**
-   * @returns {import("./interface").SanitizerFn}
+   * @returns {import("./interface.ts").SanitizerFn}
    */
-  $get(): any;
+  $get: (
+    | string
+    | (($window: ng.WindowService) => import("./interface.ts").SanitizerFn)
+  )[];
 }
 export type ServiceProvider = import("../../interface.ts").ServiceProvider;

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

@@ -5,10 +5,10 @@ export interface AsyncQueueTask {
   fn: (...args: any[]) => any;
   locals: Record<string, any>;
 }
-export type ListenerFunction = (newValue: any, originalTarget: object) => void;
+export type ListenerFn = (newValue?: any, originalTarget?: object) => void;
 export interface Listener {
   originalTarget: object;
-  listenerFn: ListenerFunction;
+  listenerFn: ListenerFn;
   watchFn: CompiledExpression;
   id: number;
   scopeId: number;

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

@@ -15,6 +15,7 @@ export function createScope(target?: any, context?: Scope): Scope;
  */
 export function isUnsafeGlobal(target: any): boolean;
 export const $postUpdateQueue: any[];
+export let rootScope: any;
 export class RootScopeProvider {
   rootScope: Scope;
   $get: (
@@ -89,6 +90,7 @@ export class Scope {
   /** @type {boolean} */
   $$destroyed: boolean;
   scheduled: any[];
+  $scopename: any;
   /** @private */
   private propertyMap;
   /**
@@ -128,12 +130,12 @@ export class Scope {
    * function is invoked when changes to that property are detected.
    *
    * @param {string} watchProp - An expression to be watched in the context of this model.
-   * @param {import('./interface.ts').ListenerFunction} [listenerFn] - A function to execute when changes are detected on watched context.
+   * @param {ng.ListenerFn} [listenerFn] - A function to execute when changes are detected on watched context.
    * @param {boolean} [lazy] - A flag to indicate if the listener should be invoked immediately. Defaults to false.
    */
   $watch(
     watchProp: string,
-    listenerFn?: import("./interface.ts").ListenerFunction,
+    listenerFn?: ng.ListenerFn,
     lazy?: boolean,
   ): () => void;
   $new(childInstance: any): any;
@@ -181,5 +183,6 @@ export class Scope {
    * @returns {Scope|undefined}
    */
   $getById(id: string | number): Scope | undefined;
+  $searchByName(name: any): any;
   #private;
 }

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

@@ -75,16 +75,16 @@ export class FormController {
   static $inject: string[];
   /**
    * @param {Element} $element
-   * @param {import("../../core/compile/attributes.js").Attributes} $attrs
-   * @param {import("../../core/scope/scope.js").Scope} $scope
-   * @param {*} $animate
+   * @param {ng.Attributes} $attrs
+   * @param {ng.Scope} $scope
+   * @param {ng.AnimateService} $animate
    * @param {*} $interpolate
    */
   constructor(
     $element: Element,
-    $attrs: import("../../core/compile/attributes.js").Attributes,
-    $scope: import("../../core/scope/scope.js").Scope,
-    $animate: any,
+    $attrs: ng.Attributes,
+    $scope: ng.Scope,
+    $animate: ng.AnimateService,
     $interpolate: any,
   );
   $$controls: any[];
@@ -103,7 +103,7 @@ export class FormController {
   /** @type {FormController|Object} */
   $$parentForm: FormController | any;
   $$element: Element;
-  $$animate: any;
+  $$animate: import("../../interface.ts").AnimateService;
   $error: {};
   $$success: {};
   $pending: any;

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

@@ -1,8 +1,8 @@
 /**
- * @param {*}  $animate
+ * @param {ng.AnimateService} $animate
  * @returns {ng.Directive}
  */
-export function ngIfDirective($animate: any): ng.Directive;
+export function ngIfDirective($animate: ng.AnimateService): ng.Directive;
 export namespace ngIfDirective {
   let $inject: string[];
 }

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

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

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

@@ -1,8 +1,10 @@
-export function ngMessagesDirective($animate: any): {
-  require: string;
-  restrict: string;
-  controller: ($element: any, $scope: any, $attrs: any) => NgMessageCtrl;
-};
+/**
+ * @param {ng.AnimateService} $animate
+ * @returns {ng.Directive<NgMessageCtrl>}
+ */
+export function ngMessagesDirective(
+  $animate: ng.AnimateService,
+): ng.Directive<NgMessageCtrl>;
 export namespace ngMessagesDirective {
   let $inject: string[];
 }
@@ -18,32 +20,26 @@ export namespace ngMessagesIncludeDirective {
   let $inject_1: string[];
   export { $inject_1 as $inject };
 }
-export const ngMessageDirective: (
-  any: any,
-) => import("../../interface.ts").Directive;
-export const ngMessageExpDirective: (
-  any: any,
-) => import("../../interface.ts").Directive;
-export const ngMessageDefaultDirective: (
-  any: any,
-) => import("../../interface.ts").Directive;
+export const ngMessageDirective: (any: any) => ng.Directive;
+export const ngMessageExpDirective: (any: any) => ng.Directive;
+export const ngMessageDefaultDirective: (any: any) => ng.Directive;
 declare class NgMessageCtrl {
   /**
    * @param {Element} $element
-   * @param {import('../../core/scope/scope.js').Scope} $scope
-   * @param {import('../../core/compile/attributes').Attributes} $attrs
-   * @param {*} $animate
+   * @param {ng.Scope} $scope
+   * @param {ng.Attributes} $attrs
+   * @param {ng.AnimateService} $animate
    */
   constructor(
     $element: Element,
-    $scope: import("../../core/scope/scope.js").Scope,
-    $attrs: any,
-    $animate: any,
+    $scope: ng.Scope,
+    $attrs: ng.Attributes,
+    $animate: ng.AnimateService,
   );
   $element: Element;
   $scope: import("../../interface.ts").Scope;
-  $attrs: any;
-  $animate: any;
+  $attrs: ng.Attributes;
+  $animate: import("../../interface.ts").AnimateService;
   latestKey: number;
   nextAttachId: number;
   messages: {};

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

@@ -54,7 +54,7 @@ export class NgModelController {
    * @param {import('../../core/compile/attributes.js').Attributes} $attr
    * @param {Element} $element
    * @param {import("../../core/parse/interface.ts").ParseService} $parse
-   * @param {*} $animate
+   * @param {ng.AnimateService} $animate
    * @param {*} $interpolate
    */
   constructor(
@@ -63,7 +63,7 @@ export class NgModelController {
     $attr: import("../../core/compile/attributes.js").Attributes,
     $element: Element,
     $parse: import("../../core/parse/interface.ts").ParseService,
-    $animate: any,
+    $animate: ng.AnimateService,
     $interpolate: any,
   );
   /** @type {any} The actual value from the control's view  */
@@ -139,7 +139,7 @@ export class NgModelController {
   $$scope: import("../../core/scope/scope.js").Scope;
   $$attr: import("../../core/compile/attributes.js").Attributes;
   $$element: Element;
-  $$animate: any;
+  $$animate: import("../../interface.ts").AnimateService;
   $$parse: import("../../core/parse/interface.ts").ParseService;
   $$exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler;
   $$hasNativeValidators: boolean;

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

@@ -0,0 +1,4 @@
+/**
+ * @return {ng.Directive}
+ */
+export function ngScopeDirective(): ng.Directive;

package/@types/directive/show-hide/show-hide.d.ts

@@ -1,9 +1,8 @@
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.AnimateService} $animate
+ * @returns {ng.Directive}
  */
-export function ngShowDirective(
-  $animate: any,
-): import("../../interface.ts").Directive;
+export function ngShowDirective($animate: ng.AnimateService): ng.Directive;
 export namespace ngShowDirective {
   let $inject: string[];
 }

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

@@ -1,10 +1,8 @@
 /**
- * @param {*} $animate
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.AnimateService} $animate
+ * @returns {ng.Directive}
  */
-export function ngSwitchDirective(
-  $animate: any,
-): import("../../interface.ts").Directive;
+export function ngSwitchDirective($animate: ng.AnimateService): ng.Directive;
 export namespace ngSwitchDirective {
   let $inject: string[];
 }

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

@@ -0,0 +1,4 @@
+/**
+ * @return {ng.Directive}
+ */
+export function ngWasmDirective(): ng.Directive;

package/@types/{services → directive}/worker/interface.d.ts

@@ -9,4 +9,5 @@ export interface WorkerConnection {
   post(data: any): void;
   terminate(): void;
   restart(): void;
+  config: WorkerConfig;
 }

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

@@ -1,15 +1,25 @@
 /**
- * ngWorker directive factory
  * Usage: <div ng-worker="workerName" data-params="{{ expression }}" data-on-result="callback($result)"></div>
+ *
+ * @param {ng.ParseService} $parse
+ * @param {ng.LogService} $log
+ * @returns {ng.Directive}
  */
 export function ngWorkerDirective(
-  $worker: any,
-  $parse: any,
-  $log: any,
-): {
-  restrict: string;
-  link(scope: any, element: any, attrs: any): void;
-};
+  $parse: ng.ParseService,
+  $log: ng.LogService,
+): ng.Directive;
 export namespace ngWorkerDirective {
   let $inject: string[];
 }
+/**
+ * Creates a managed Web Worker connection.
+ *
+ * @param {string | URL} scriptPath
+ * @param {ng.WorkerConfig} [config]
+ * @returns {ng.WorkerConnection}
+ */
+export function createWorkerConnection(
+  scriptPath: string | URL,
+  config?: ng.WorkerConfig,
+): ng.WorkerConnection;