@angular-wave/angular.ts 0.0.41 → 0.0.42

package/types/public.d.ts

@@ -1,5 +1,5 @@
 /**
  * Initializes `ng`, `animate`, `message`, `aria` and `router` modules.
- * @returns {import('./index').angular.Module} `ng`module
+ * @returns {import('./index').Module} `ng`module
  */
-export function publishExternalAPI(): import("./index").angular.Module;
+export function publishExternalAPI(): import("./index").Module;

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

@@ -58,21 +58,21 @@ export class TemplateFactory {
     /**
      * Creates a template by invoking an injectable provider function.
      *
-     * @param {angular.IInjectable} provider Function to invoke via `locals`
+     * @param {import('../types').Injectable<any>} provider Function to invoke via `locals`
      * @param {Function} injectFn a function used to invoke the template provider
      * @param {angular.ResolveContext} context
      * @return {string|Promise.<string>} The template html as a string, or a promise
      * for that string.
      */
-    fromProvider(provider: angular.IInjectable, params: any, context: angular.ResolveContext): string | Promise<string>;
+    fromProvider(provider: import("../types").Injectable<any>, params: any, context: angular.ResolveContext): string | Promise<string>;
     /**
      * Creates a component's template by invoking an injectable provider function.
      *
-     * @param {angular.IInjectable} provider Function to invoke via `locals`
+     * @param {import('../types').Injectable<any>} provider Function to invoke via `locals`
      * @param {Function} injectFn a function used to invoke the template provider
      * @return {string} The template html as a string: "<component-name input1='::$resolve.foo'></component-name>".
      */
-    fromComponentProvider(provider: angular.IInjectable, params: any, context: any): string;
+    fromComponentProvider(provider: import("../types").Injectable<any>, params: any, context: any): string;
     /**
      * Creates a template from a component's name
      *

package/types/services/browser.d.ts

@@ -149,7 +149,7 @@ export class Browser {
     cancel: (deferId: number) => boolean;
 }
 /**
- * @typedef {import('../index').angular.ServiceProvider} angular.BrowserProvider
+ * @typedef {import('../types').ServiceProvider} angular.BrowserProvider
  * @description
  * This object has two goals:
  *
@@ -162,11 +162,11 @@ export class Browser {
  * @constructor
  * @this {angular.BrowserProvider}
  */
-export function BrowserProvider(this: import("../index").angular.ServiceProvider): void;
+export function BrowserProvider(this: import("../types").ServiceProvider): void;
 export class BrowserProvider {
     $get: (string | (($$taskTrackerFactory: import("../core/task-tracker-factory").TaskTracker) => Browser))[];
 }
 export type UrlChangeListener = (arg0: string, arg1: string | null) => any;
 export namespace angular {
-    type BrowserProvider = import("../index").angular.ServiceProvider;
+    type BrowserProvider = import("../types").ServiceProvider;
 }

package/types/services/document.d.ts

@@ -1,5 +1,5 @@
 /**
- * @typedef {import('../index').angular.ServiceProvider} angular.DocumentProvider
+ * @typedef {import('../types').ServiceProvider} DocumentProvider
  * @description
  * A {@link angular.element jQuery or JQLite} wrapper for the browser's `window.document` object.
  *
@@ -22,9 +22,9 @@
  */
 /**
  * @constructor
- * @this {angular.DocumentProvider}
+ * @this {DocumentProvider}
  */
-export function $DocumentProvider(this: import("../index").angular.ServiceProvider): void;
+export function $DocumentProvider(this: import("../types").ServiceProvider): void;
 export class $DocumentProvider {
     $get: () => JQLite;
 }
@@ -37,7 +37,5 @@ export function $$IsDocumentHiddenProvider(): void;
 export class $$IsDocumentHiddenProvider {
     $get: (string | (($document: import("../shared/jqlite/jqlite").JQLite, $rootScope: import("../core/scope/scope").Scope) => () => boolean))[];
 }
-export namespace angular {
-    type DocumentProvider = import("../index").angular.ServiceProvider;
-}
+export type DocumentProvider = import("../types").ServiceProvider;
 import { JQLite } from "../shared/jqlite/jqlite";

package/types/services/log.d.ts

@@ -14,7 +14,7 @@
  */
 export let LogService: angular.LogService;
 /**
- * @typedef {import('../index').ServiceProvider} angular.LogProvider
+ * @typedef {import('../types').ServiceProvider} angular.LogProvider
  * @property {function(): boolean} debugEnabled - Function to get the current debug state.
  * @property {function(boolean): angular.LogProvider} debugEnabled - Function to enable or disable debug.
  */
@@ -62,5 +62,5 @@ export namespace angular {
          */
         warn: LogCall;
     };
-    type LogProvider = any;
+    type LogProvider = import("../types").ServiceProvider;
 }

package/types/services/template-request.d.ts

@@ -53,7 +53,7 @@ export class TemplateRequestProvider {
      *
      * @property {number} totalPendingRequests total amount of pending template requests being downloaded.
      */
-    $get: (string | (($exceptionHandler: import("../core/exception-handler").angular.ErrorHandler, $templateCache: any, $http: any, $q: any, $sce: any) => {
+    $get: (string | (($exceptionHandler: import("../core/exception-handler").ErrorHandler, $templateCache: any, $http: any, $q: any, $sce: any) => {
         (tpl: any, ignoreRequestError: any): any;
         totalPendingRequests: number;
     }))[];

package/types/shared/jqlite/jqlite.d.ts

@@ -50,9 +50,17 @@ export class JQLite {
     controller(name?: string): any;
     /**
      * Return instance of injector attached to element
-     * @returns {import('../../types').angular.InjectorService}
+     * @returns {import('../../types').InjectorService}
      */
-    injector(): import("../../types").angular.InjectorService;
+    injector(): import("../../types").InjectorService;
+    /**
+     * Adds an event listener to each element in the JQLite collection.
+     *
+     * @param {string} type - The event type(s) to listen for. Multiple event types can be specified, separated by a space.
+     * @param {Function} fn - The function to execute when the event is triggered.
+     * @returns {JQLite} The JQLite collection for chaining.
+     */
+    on(type: string, fn: Function): JQLite;
     toString(): string;
     eq(index: any): JQLite;
     length: number;

package/types/shared/utils.d.ts

@@ -586,9 +586,9 @@ export function assertArgFn(arg: any, name: any, acceptArrayAnnotation: any): an
  * should all be static strings, not variables or general expressions.
  *
  * @param {string} module The namespace to use for the new minErr instance.
- * @returns {function(string, string, ...*): Error} minErr instance
+ * @returns {function(string, ...*): Error} minErr instance
  */
-export function minErr(module: string): (arg0: string, arg1: string, ...args: any[]) => Error;
+export function minErr(module: string): (arg0: string, ...args: any[]) => Error;
 export function toDebugString(obj: any): any;
 /**
  * Computes a hash of an 'obj'.

package/types/types.d.ts

@@ -1,34 +1,438 @@
-export namespace angular {
-    type InjectorService = {
-        /**
-         * Annotate a function or an array of inline annotations.
-         */
-        annotate: (arg0: Function, arg1: boolean | undefined) => string[];
-        /**
-         * Get a service by name.
-         */
-        get: (arg0: string, arg1: string | undefined) => T;
-        /**
-         * , any=): T} instantiate Instantiate a type constructor with optional locals.
-         */
-        "": new () => (...args: any[]) => any;
-        /**
-         * Invoke a function with optional context and locals.
-         */
-        invoke: (arg0: Injectable<Function | ((...args: any[]) => T)>, arg1: any | undefined, arg2: any | undefined) => T;
-        /**
-         * Add and load new modules to the injector.
-         */
-        loadNewModules: (arg0: Array<IModule | string | Injectable<(...args: any[]) => void>>) => void;
-        /**
-         * A map of all the modules loaded into the injector.
-         */
-        modules: {
-            [x: string]: IModule;
-        };
-        /**
-         * Indicates if strict dependency injection is enforced.
-         */
-        strictDi: boolean;
+export type BootstrapConfig = any;
+export type Injectable<T_1> = Function | Array<string | Function>;
+export type ComponentOptions = any;
+export type ControllerConstructor = Function;
+export type OnChangesObject = any;
+export type ChangesObject = any;
+export type Controller = any;
+export type Attributes = {
+    [x: string]: any;
+};
+export type TScope = import("./core/scope/scope").Scope;
+export type TElement = import("./shared/jqlite/jqlite").JQLite;
+export type TAttributes = Attributes;
+export type TController = DirectiveController;
+export type DirectiveController = Controller | Controller[] | {
+    [key: string]: Controller;
+};
+/**
+ * Compile function for an AngularJS directive.
+ */
+export type DirectiveCompileFn = (templateElement: TElement, templateAttributes: TAttributes, transclude: TranscludeFunction) => any;
+/**
+ * Link function for an AngularJS directive.
+ */
+export type DirectiveLinkFn = (scope: TScope, instanceElement: TElement, instanceAttributes: TAttributes, controller?: TController, transclude?: TranscludeFunction) => void;
+export type CloneAttachFunction = (clonedElement?: JQLite, scope?: Scope) => any;
+/**
+ * This corresponds to $transclude passed to controllers and to the transclude function passed to link functions.
+ * https://docs.angularjs.org/api/ng/service/$compile#-controller-
+ * http://teropa.info/blog/2015/06/09/transclusion.html
+ */
+export type TranscludeFunction = {
+    transcludeWithScope: (arg0: TScope, arg1: CloneAttachFunction, arg2: JQLite | undefined, arg3: string | undefined) => import("./shared/jqlite/jqlite").JQLite;
+    transcludeWithoutScope: (arg0: CloneAttachFunction | undefined, arg1: JQLite | undefined, arg2: string | undefined) => import("./shared/jqlite/jqlite").JQLite;
+    /**
+     * - Returns true if the specified slot contains content (i.e., one or more DOM nodes)
+     */
+    isSlotFilled: (arg0: string) => boolean;
+};
+export type transcludeWithScope = (arg0: TScope, arg1: CloneAttachFunction, arg2: JQLite | undefined, arg3: string | undefined) => import("./shared/jqlite/jqlite").JQLite;
+export type transcludeWithoutScope = (arg0: CloneAttachFunction | undefined, arg1: JQLite | undefined, arg2: string | undefined) => import("./shared/jqlite/jqlite").JQLite;
+/**
+ * Represents the pre and post linking functions of a directive.
+ */
+export type DirectivePrePost = {
+    /**
+     * The pre-linking function of the directive.
+     */
+    pre?: DirectiveLinkFn | undefined;
+    /**
+     * The post-linking function of the directive.
+     */
+    post?: DirectiveLinkFn | undefined;
+};
+/**
+ * Directive definition object.
+ */
+export type Directive = {
+    /**
+     * Compile function for the directive.
+     */
+    compile?: DirectiveCompileFn | undefined;
+    /**
+     * Controller constructor or name.
+     */
+    controller?: string | Injectable<ControllerConstructor> | undefined;
+    /**
+     * Controller alias.
+     */
+    controllerAs?: string | undefined;
+    /**
+     * Bindings to controller.
+     */
+    bindToController?: boolean | {
+        [boundProperty: string]: string;
+    } | undefined;
+    /**
+     * Link function.
+     */
+    link?: DirectiveLinkFn | DirectivePrePost | undefined;
+    /**
+     * Multi-element directive flag.
+     */
+    multiElement?: boolean | undefined;
+    /**
+     * Skip all directives on element
+     */
+    priority?: number | undefined;
+    /**
+     * Directive priority.
+     */
+    terminal?: boolean | undefined;
+    /**
+     * Deprecated: Replace flag.
+     */
+    replace?: boolean | undefined;
+    /**
+     * Required controllers.
+     */
+    require?: string | string[] | {
+        [controller: string]: string;
+    } | undefined;
+    /**
+     * Restriction mode.
+     */
+    restrict?: string | undefined;
+    /**
+     * Scope options.
+     */
+    scope?: boolean | {
+        [boundProperty: string]: string;
+    } | undefined;
+    /**
+     * HTML template.
+     */
+    template?: string | ((tElement: TElement, tAttrs: TAttributes) => string) | undefined;
+    /**
+     * Template namespace.
+     */
+    templateNamespace?: string | undefined;
+    /**
+     * HTML template URL.
+     */
+    templateUrl?: string | ((tElement: TElement, tAttrs: TAttributes) => string) | undefined;
+    /**
+     * Transclusion options.
+     */
+    transclude?: boolean | "element" | {
+        [slot: string]: string;
+    } | undefined;
+};
+/**
+ * Factory function for creating directives.
+ */
+export type DirectiveFactory = (...args: any[]) => Directive | DirectiveLinkFn;
+export type FilterFunction = Function;
+export type FilterFactory = Function;
+/**
+ * Interface for a service provider class.
+ */
+export type ServiceProviderClass = {
+    /**
+     * - The constructor for the service provider.
+     */
+    constructor: Function;
+};
+/**
+ * Interface for a service provider factory function.
+ */
+export type ServiceProviderFactory = Function;
+/**
+ * Interface for a service provider.
+ */
+export type ServiceProvider = {
+    /**
+     * - The $get property that represents a service instance or a factory function.
+     */
+    $get: any;
+};
+export type Module = any;
+export type FormController = {
+    /**
+     * - True if the form has not been modified.
+     */
+    $pristine: boolean;
+    /**
+     * - True if the form has been modified.
+     */
+    $dirty: boolean;
+    /**
+     * - True if the form is valid.
+     */
+    $valid: boolean;
+    /**
+     * - True if the form is invalid.
+     */
+    $invalid: boolean;
+    /**
+     * - True if the form has been submitted.
+     */
+    $submitted: boolean;
+    /**
+     * - An object containing arrays of controls with validation errors keyed by validation error keys.
+     */
+    $error: {
+        [x: string]: Array<NgModelController | FormController>;
     };
-}
+    /**
+     * - The name of the form.
+     */
+    $name?: string | undefined;
+    /**
+     * - An object containing arrays of controls that are pending validation, keyed by validation error keys.
+     */
+    $pending?: {
+        [x: string]: Array<NgModelController | FormController>;
+    } | undefined;
+    /**
+     * - Adds a control to the form.
+     */
+    $addControl: (arg0: NgModelController | FormController) => void;
+    /**
+     * - Returns an array of all controls in the form.
+     */
+    $getControls: () => ReadonlyArray<NgModelController | FormController>;
+    /**
+     * - Removes a control from the form.
+     */
+    $removeControl: (arg0: NgModelController | FormController) => void;
+    /**
+     * - Sets the validity of a control in the form.
+     */
+    $setValidity: (arg0: string, arg1: boolean, arg2: NgModelController | FormController) => void;
+    /**
+     * - Marks the form as dirty.
+     */
+    $setDirty: () => void;
+    /**
+     * - Marks the form as pristine.
+     */
+    $setPristine: () => void;
+    /**
+     * - Commits the view value of all controls in the form.
+     */
+    $commitViewValue: () => void;
+    /**
+     * - Rolls back the view value of all controls in the form.
+     */
+    $rollbackViewValue: () => void;
+    /**
+     * - Marks the form as submitted.
+     */
+    $setSubmitted: () => void;
+    /**
+     * - Marks the form controls as untouched.
+     */
+    $setUntouched: () => void;
+    /**
+     * - An indexer for additional properties.
+     */
+    name?: (arg0: string) => any;
+};
+export type NgModelController = {
+    /**
+     * - Renders the view value.
+     */
+    $render: () => void;
+    /**
+     * - Sets the validity state.
+     */
+    $setValidity: (arg0: string, arg1: boolean) => void;
+    /**
+     * - Sets the view value.
+     */
+    $setViewValue: (arg0: any, arg1: string | undefined) => void;
+    /**
+     * - Marks the control as pristine.
+     */
+    $setPristine: () => void;
+    /**
+     * - Marks the control as dirty.
+     */
+    $setDirty: () => void;
+    /**
+     * - Validates the control.
+     */
+    $validate: () => void;
+    /**
+     * - Marks the control as touched.
+     */
+    $setTouched: () => void;
+    /**
+     * - Marks the control as untouched.
+     */
+    $setUntouched: () => void;
+    /**
+     * - Rolls back the view value.
+     */
+    $rollbackViewValue: () => void;
+    /**
+     * - Commits the view value.
+     */
+    $commitViewValue: () => void;
+    /**
+     * - Processes the model value.
+     */
+    $processModelValue: () => void;
+    /**
+     * - Checks if the value is empty.
+     */
+    $isEmpty: (arg0: any) => boolean;
+    /**
+     * - Overrides model options.
+     */
+    $overrideModelOptions: (arg0: NgModelOptions) => void;
+    /**
+     * - The current view value.
+     */
+    $viewValue: any;
+    /**
+     * - The current model value.
+     */
+    $modelValue: any;
+    /**
+     * - Array of parsers.
+     */
+    $parsers: Array<(arg0: any, arg1: any) => boolean>;
+    /**
+     * - Array of formatters.
+     */
+    $formatters: Array<(arg0: any) => any>;
+    /**
+     * - Array of view change listeners.
+     */
+    $viewChangeListeners: Array<() => any>;
+    /**
+     * - Validation errors.
+     */
+    $error: {
+        [x: string]: boolean;
+    };
+    /**
+     * - The name of the control.
+     */
+    $name?: string | undefined;
+    /**
+     * - True if the control has been touched.
+     */
+    $touched: boolean;
+    /**
+     * - True if the control has not been touched.
+     */
+    $untouched: boolean;
+    /**
+     * - Synchronous validators.
+     */
+    $validators: {
+        [x: string]: (arg0: any, arg1: any) => boolean;
+    };
+    /**
+     * - Asynchronous validators.
+     */
+    $asyncValidators: {
+        [x: string]: (arg0: any, arg1: any) => Promise<any>;
+    };
+    /**
+     * - Pending validation.
+     */
+    $pending?: {
+        [x: string]: boolean;
+    } | undefined;
+    /**
+     * - True if the control is pristine.
+     */
+    $pristine: boolean;
+    /**
+     * - True if the control is dirty.
+     */
+    $dirty: boolean;
+    /**
+     * - True if the control is valid.
+     */
+    $valid: boolean;
+    /**
+     * - True if the control is invalid.
+     */
+    $invalid: boolean;
+};
+export type NgModelOptions = {
+    /**
+     * - The event to update on.
+     */
+    updateOn?: string | undefined;
+    /**
+     * - The debounce delay.
+     */
+    debounce?: number | {
+        [x: string]: number;
+    } | undefined;
+    /**
+     * - Allows invalid models.
+     */
+    allowInvalid?: boolean | undefined;
+    /**
+     * - Indicates if getter/setter syntax is allowed.
+     */
+    getterSetter?: boolean | undefined;
+    /**
+     * - The timezone.
+     */
+    timezone?: string | undefined;
+    /**
+     * - The format for seconds in time and datetime-local inputs.
+     */
+    timeSecondsFormat?: string | undefined;
+    /**
+     * - Indicates if zero seconds should be stripped.
+     */
+    timeStripZeroSeconds?: boolean | undefined;
+};
+export type ModelValidators = {
+    [x: string]: (arg0: any, arg1: any) => boolean;
+};
+export type AsyncModelValidators = {
+    [x: string]: (arg0: any, arg1: any) => Promise<any>;
+};
+export type InjectorService = {
+    /**
+     * - Annotate a function or an array of inline annotations.
+     */
+    annotate: (arg0: Function, arg1: boolean | undefined) => string[];
+    /**
+     * - Get a service by name.
+     */
+    get: (arg0: string, arg1: string | undefined) => any;
+    /**
+     * - Instantiate a type constructor with optional locals.
+     */
+    instantiate: (arg0: Function, arg1: any | null) => any;
+    /**
+     * - Invoke a function with optional context and locals.
+     */
+    invoke: (arg0: Injectable<Function | ((...args: any[]) => any)>, arg1: any | undefined, arg2: any | undefined) => any;
+    /**
+     * - Add and load new modules to the injector.
+     */
+    loadNewModules: (arg0: Array<Module | string | Injectable<(...args: any[]) => void>>) => void;
+    /**
+     * - A map of all the modules loaded into the injector.
+     */
+    modules: {
+        [x: string]: Module;
+    };
+    /**
+     * - Indicates if strict dependency injection is enforced.
+     */
+    strictDi: boolean;
+};

package/types-back/index.d.ts

@@ -27,11 +27,6 @@ declare namespace angular {
     (...args: any[]): IServiceProvider;
   }
 
-  // All service providers extend this interface
-  interface IServiceProvider {
-    $get: any;
-  }
-
   ///////////////////////////////////////////////////////////////////////////
   // Module
   // see http://docs.angularjs.org/api/angular.Module
@@ -141,7 +136,7 @@ declare namespace angular {
     /**
      * Run blocks are the closest thing in Angular to the main method. A run block is the code which needs to run to kickstart the application. It is executed after all of the service have been configured and the injector has been created. Run blocks typically contain code which is hard to unit-test, and for this reason should be declared in isolated modules, so that they can be ignored in the unit-tests.
      */
-    run(initializationFunction: Injectable<Function>): IModule;
+    run(initializationFuncti  Injectable<Function>): IModule;
     /**
      * Register a service constructor, which will be invoked with new to create the service instance. This is short for registering a service where its provider's $get property is a factory function that returns an instance instantiated by the injector from the service constructor function.
      *
@@ -259,27 +254,6 @@ declare namespace angular {
     $invalid: boolean;
   }
 
-  // Allows tuning how model updates are done.
-  // https://docs.angularjs.org/api/ng/directive/ngModelOptions
-  interface INgModelOptions {
-    updateOn?: string | undefined;
-    debounce?: number | { [key: string]: number } | undefined;
-    allowInvalid?: boolean | undefined;
-    getterSetter?: boolean | undefined;
-    timezone?: string | undefined;
-    /**
-     * Defines if the time and datetime-local types should show seconds and milliseconds.
-     * The option follows the format string of date filter.
-     * By default, the options is undefined which is equal to 'ss.sss' (seconds and milliseconds)
-     */
-    timeSecondsFormat?: string | undefined;
-    /**
-     * Defines if the time and datetime-local types should strip the seconds and milliseconds
-     * from the formatted value if they are zero. This option is applied after `timeSecondsFormat`
-     */
-    timeStripZeroSeconds?: boolean | undefined;
-  }
-
   interface IModelValidators {
     /**
      * viewValue is any because it can be an object that is called in the view like $viewValue.name:$viewValue.subName