@angular-wave/angular.ts 0.14.2 → 0.15.0

package/@types/angular.d.ts

@@ -1,34 +1,35 @@
 export class Angular {
-  $cache: Map<number, import("./interface.ts").ExpandoStore>;
-  /** @type {ng.PubSubService} */
-  $eventBus: ng.PubSubService;
+  /** @private @type {!Array<string|any>} */
+  private _bootsrappedModules;
+  /** @public @type {ng.PubSubService} */
+  public $eventBus: ng.PubSubService;
+  /** @public @type {ng.InjectorService} */
+  public $injector: ng.InjectorService;
   /**
+   * @public
    * @type {string} `version` from `package.json`
    */
-  version: string;
-  /** @type {!Array<string|any>} */
-  bootsrappedModules: Array<string | any>;
+  public version: string;
   /**
    * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
    *
-   * @type {(element: Element, name: string?) => ng.Scope|undefined}
+   * @type {typeof getController}
    */
-  getController: (
-    element: Element,
-    name: string | null,
-  ) => ng.Scope | undefined;
+  getController: typeof getController;
   /**
    * Return instance of InjectorService attached to element
-   * @type {(Element) => ng.InjectorService}
+   * @type {typeof getInjector}
    */
-  getInjector: (Element: any) => ng.InjectorService;
+  getInjector: typeof getInjector;
   /**
    * Gets scope for a given element.
-   * @type {(Element) => ng.Scope}
+   *  @type {typeof getScope}
    */
-  getScope: (Element: any) => ng.Scope;
+  getScope: typeof getScope;
+  /** @type {typeof errorHandlingConfig} */
   errorHandlingConfig: typeof errorHandlingConfig;
-  $t: Readonly<Record<string, string>>;
+  /** @type {ng.InjectionTokens} */
+  $t: ng.InjectionTokens;
   /**
    *
    * The `angular.module` is a global place for creating, registering and retrieving AngularTS
@@ -130,16 +131,12 @@ export class Angular {
     config?: import("./interface.ts").AngularBootstrapConfig,
   ): ng.InjectorService;
   $rootScope: ng.Scope;
-  $injector: import("./interface.ts").InjectorService;
   /**
    * @param {any[]} modules
-   * @param {boolean?} strictDi
-   * @returns {import("./core/di/internal-injector.js").InjectorService}
+   * @param {boolean} [strictDi]
+   * @returns {ng.InjectorService}
    */
-  injector(
-    modules: any[],
-    strictDi: boolean | null,
-  ): import("./core/di/internal-injector.js").InjectorService;
+  injector(modules: any[], strictDi?: boolean): ng.InjectorService;
   /**
    * @param {Element|Document} element
    */
@@ -153,9 +150,15 @@ export class Angular {
    * or defined on `$scope` injectable.
    *
    * @param {string} name
-   * @returns {ProxyHandler<ng.Scope>|undefined}
+   * @returns {Proxy<ng.Scope>|undefined}
    */
-  getScopeByName(name: string): ProxyHandler<ng.Scope> | undefined;
+  getScopeByName(name: string): ProxyConstructor | undefined;
 }
+export type ModuleRegistry = {
+  [x: string]: NgModule;
+};
+import { getController } from "./shared/dom.js";
+import { getInjector } from "./shared/dom.js";
+import { getScope } from "./shared/dom.js";
 import { errorHandlingConfig } from "./shared/utils.js";
 import { NgModule } from "./core/di/ng-module/ng-module.js";

package/@types/animations/animate-cache.d.ts

@@ -44,7 +44,51 @@ export function animateCache(): {
    */
   put(key: string, value: any, isValid: boolean): void;
 };
-export function AnimateCacheProvider(): void;
 export class AnimateCacheProvider {
-  $get: (typeof animateCache)[];
+  $get(): {
+    /**
+     * Generates a unique cache key based on the node's parent and other parameters.
+     * @param {HTMLElement} node - The DOM node to generate the cache key for.
+     * @param {string} method - The animation method being applied.
+     * @param {string} [addClass] - Class to add during the animation.
+     * @param {string} [removeClass] - Class to remove during the animation.
+     * @returns {string} - The generated cache key.
+     */
+    cacheKey(
+      node: HTMLElement,
+      method: string,
+      addClass?: string,
+      removeClass?: string,
+    ): string;
+    /**
+     * Checks if a cached animation without a duration exists.
+     * @param {string} key - The cache key to check.
+     * @returns {boolean} - True if an invalid animation is cached, false otherwise.
+     */
+    containsCachedAnimationWithoutDuration(key: string): boolean;
+    /**
+     * Clears the cache.
+     * @returns {void}
+     */
+    flush(): void;
+    /**
+     * Gets the count of a specific cache entry.
+     * @param {string} key - The cache key to count.
+     * @returns {number} - The count of the cache entry.
+     */
+    count(key: string): number;
+    /**
+     * Retrieves a value associated with a specific cache key.
+     * @param {string} key - The cache key to retrieve.
+     * @returns {any} - The value associated with the cache key.
+     */
+    get(key: string): any;
+    /**
+     * Adds or updates a cache entry.
+     * @param {string} key - The cache key to add or update.
+     * @param {any} value - The value to store.
+     * @param {boolean} isValid - Whether the cache entry is valid.
+     */
+    put(key: string, value: any, isValid: boolean): void;
+  };
 }

package/@types/animations/animate-children-directive.d.ts

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

package/@types/animations/animate-js.d.ts

@@ -3,16 +3,7 @@ export class AnimateJsProvider {
   constructor($animateProvider: any);
   $get: (
     | string
-    | (($injector: ng.InjectorService) => (
-        element: any,
-        event: any,
-        classes: any,
-        options: any,
-      ) => {
-        $$willAnimate: boolean;
-        end(): any;
-        start(): any;
-      })
+    | (($injector: ng.InjectorService) => import("./interface.ts").AnimateJsFn)
   )[];
 }
 export namespace AnimateJsProvider {

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

@@ -93,7 +93,12 @@ export class AnimateProvider {
    * @return {RegExp} The current CSS className expression value. If null then there is no expression value
    */
   classNameFilter: (expression?: RegExp | undefined, ...args: any[]) => RegExp;
-  $get: any[];
+  $get: (
+    | string
+    | ((
+        $$animateQueue: import("./queue/interface.ts").AnimateQueueService,
+      ) => ng.AnimateService)
+  )[];
 }
 export namespace AnimateProvider {
   let $inject: string[];

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

@@ -9,13 +9,13 @@ export type RafScheduler = {
   /**
    * Internal queue of scheduled task arrays.
    */
-  queue: Array<Array<() => void>>;
+  _queue: Array<Array<() => void>>;
   /**
    * Waits until the animation frame is quiet before running the provided function.
    * Cancels any previous animation frame requests.
    * @param fn - The function to run when the frame is quiet.
    */
-  waitUntilQuiet(fn: () => void): void;
+  _waitUntilQuiet(fn: () => void): void;
 };
 export interface AnimationHost {
   /** Pause animation. */
@@ -98,4 +98,19 @@ export interface AnimationOptions {
   removeClass?: string;
   to?: Record<string, string | number>;
   tempClasses: string | string[];
+  /** Optional DOM operation callback executed before animation */
+  domOperation?: () => void;
+}
+export interface AnimateJsRunner {
+  $$willAnimate: true;
+  start: () => AnimateRunner;
+  end: () => AnimateRunner;
+}
+export interface AnimateJsFn {
+  (
+    element: HTMLElement,
+    event: string,
+    classes?: string | null,
+    options?: AnimationOptions,
+  ): AnimateJsRunner;
 }

package/@types/animations/queue/animate-queue.d.ts

@@ -12,7 +12,6 @@ export class AnimateQueueProvider {
         $rootScope: ng.RootScopeService,
         $injector: ng.InjectorService,
         $$animation: any,
-        $templateRequest: ng.TemplateRequestService,
       ) => import("../queue/interface.ts").AnimateQueueService)
   )[];
 }

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

@@ -10,19 +10,19 @@ export class RafSchedulerProvider {
    * Internal task queue, where each item is an array of functions to run.
    * @type {Array<Array<() => void>>}
    */
-  queue: Array<Array<() => void>>;
+  _queue: Array<Array<() => void>>;
   /**
    * ID of the currently scheduled animation frame (if any).
    * Used for cancellation and tracking.
    * @type {number|null}
    */
-  cancelFn: number | null;
+  _cancelFn: number | null;
   /**
    * Processes the next batch of tasks in the animation frame.
    * Executes the first group of functions in the queue, then
    * schedules the next frame if needed.
    */
-  nextTick(): void;
+  _nextTick(): void;
   /**
    * Returns the scheduler function.
    * This function allows tasks to be queued for execution on future animation frames.

package/@types/animations/runner/animate-runner.d.ts

@@ -1,99 +1,123 @@
-/**
- * Schedule a callback to run on the next animation frame.
- * Multiple calls within the same frame are batched together.
- *
- * @param {VoidFunction} fn - The callback to execute.
- */
-export function schedule(fn: VoidFunction): void;
-/**
- * Represents an asynchronous animation operation.
- * Provides both callback-based and promise-based completion APIs.
- */
 export class AnimateRunner {
   /**
-   * Run an array of animation runners in sequence.
-   * Each runner waits for the previous one to complete.
+   * Executes a list of runners sequentially.
+   * Each must complete before the next starts.
    *
-   * @param {AnimateRunner[]} runners - Runners to execute in order.
-   * @param {(ok: boolean) => void} callback - Invoked when all complete or one fails.
+   * @param {AnimateRunner[]} runners
+   * @param {(ok: boolean) => void} callback
    */
-  static chain(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
+  static _chain(
+    runners: AnimateRunner[],
+    callback: (ok: boolean) => void,
+  ): void;
   /**
-   * Waits for all animation runners to complete before invoking the callback.
+   * Waits until all runners complete.
    *
-   * @param {AnimateRunner[]} runners - Active runners to wait for.
-   * @param {(ok: boolean) => void} callback - Called when all runners complete.
+   * @param {AnimateRunner[]} runners
+   * @param {(ok: boolean) => void} callback
    */
-  static all(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
+  static _all(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
   /**
-   * @param {import("../interface.ts").AnimationHost} [host] - Optional animation host.
+   * @param {AnimationHost} [host] - Optional animation host callbacks.
+   * @param {boolean} [jsAnimation=false]
+   *        If true: use RAF/timer ticks.
+   *        If false: use batched CSS animation ticks.
    */
-  constructor(host?: import("../interface.ts").AnimationHost);
-  /** @type {import("../interface.ts").AnimationHost} */
-  host: import("../interface.ts").AnimationHost;
+  constructor(host?: AnimationHost, jsAnimation?: boolean);
+  /** @type {AnimationHost} */
+  _host: AnimationHost;
   /** @type {Array<(ok: boolean) => void>} */
   _doneCallbacks: Array<(ok: boolean) => void>;
   /** @type {RunnerState} */
   _state: RunnerState;
-  /** @type {Promise<void>|null} */
-  _promise: Promise<void> | null;
-  /** @type {(fn: VoidFunction) => void} */
-  _schedule: (fn: VoidFunction) => void;
   /**
-   * Sets or updates the animation host.
-   * @param {import("../interface.ts").AnimationHost} host - The host object.
+   * Deferred promise used by .then/.catch/.finally.
+   * @type {Promise<void>|null}
+   * @private
+   */
+  private _promise;
+  _tick: (fn: any) => void;
+  /**
+   * Sets or replaces the current host.
+   * @param {AnimationHost} host
    */
-  setHost(host: import("../interface.ts").AnimationHost): void;
+  setHost(host: AnimationHost): void;
   /**
-   * Registers a callback to be called once the animation completes.
-   * If the animation is already complete, it's called immediately.
+   * Register a completion callback.
+   * Fires immediately if animation is already done.
    *
-   * @param {(ok: boolean) => void} fn - Completion callback.
+   * @param {(ok: boolean) => void} fn
    */
   done(fn: (ok: boolean) => void): void;
   /**
-   * Notifies the host of animation progress.
-   * @param {...any} args - Progress arguments.
+   * Reports progress to host.
+   * @param {...any} args
    */
   progress(...args: any[]): void;
-  /** Pauses the animation, if supported by the host. */
+  /** Pause underlying animation (if supported). */
   pause(): void;
-  /** Resumes the animation, if supported by the host. */
+  /** Resume underlying animation (if supported). */
   resume(): void;
-  /** Ends the animation successfully. */
+  /**
+   * Ends the animation successfully.
+   * Equivalent to user choosing to finish it immediately.
+   */
   end(): void;
-  /** Cancels the animation. */
-  cancel(): void;
   /**
-   * Marks the animation as complete on the next animation frame.
-   * @param {boolean} [status=true] - True if successful, false if canceled.
+   * Cancels the animation.
    */
-  complete(status?: boolean): void;
+  cancel(): void;
   /**
-   * Returns a promise that resolves or rejects when the animation completes.
-   * @returns {Promise<void>} Promise resolved on success or rejected on cancel.
+   * Schedule animation completion.
+   *
+   * @param {boolean} [status=true]
    */
-  getPromise(): Promise<void>;
-  /** @inheritdoc */
-  then(onFulfilled: any, onRejected: any): Promise<void>;
-  /** @inheritdoc */
-  catch(onRejected: any): Promise<void>;
-  /** @inheritdoc */
-  finally(onFinally: any): Promise<void>;
+  complete(status?: boolean): void;
   /**
    * Completes the animation and invokes all done callbacks.
+   * @param {boolean} status
    * @private
-   * @param {boolean} status - True if completed successfully, false if canceled.
    */
   private _finish;
+  /**
+   * Returns an internal promise that resolves on success,
+   * and rejects on cancel.
+   *
+   * @returns {Promise<void>}
+   */
+  getPromise(): Promise<void>;
+  /**
+   * Standard "thenable" interface
+   * @template T
+   * @param {(value: void) => T|Promise<T>} onFulfilled
+   * @param {(reason: any) => any} [onRejected]
+   * @returns {Promise<T>}
+   */
+  then<T>(
+    onFulfilled: (value: void) => T | Promise<T>,
+    onRejected?: (reason: any) => any,
+  ): Promise<T>;
+  /**
+   * Standard promise catcher.
+   * @param {(reason: any) => any} onRejected
+   * @returns {Promise<void>}
+   */
+  catch(onRejected: (reason: any) => any): Promise<void>;
+  /**
+   * Standard promise finally.
+   * @param {() => any} onFinally
+   * @returns {Promise<void>}
+   */
+  finally(onFinally: () => any): Promise<void>;
 }
+export type AnimationHost = import("../interface.ts").AnimationHost;
 /**
  * Internal runner states.
  */
 type RunnerState = number;
 declare namespace RunnerState {
-  let INITIAL: number;
-  let PENDING: number;
-  let DONE: number;
+  let _INITIAL: number;
+  let _PENDING: number;
+  let _DONE: number;
 }
 export {};

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

@@ -83,20 +83,4 @@ export const ACTIVE_CLASS_SUFFIX: "-active";
 export const PREPARE_CLASS_SUFFIX: "-prepare";
 export const NG_ANIMATE_CLASSNAME: "ng-animate";
 export const NG_ANIMATE_CHILDREN_DATA: "$$ngAnimateChildren";
-export let CSS_PREFIX: string;
-export let TRANSITION_PROP: any;
-export let TRANSITIONEND_EVENT: any;
-export let ANIMATION_PROP: any;
-export let ANIMATIONEND_EVENT: any;
-export const DURATION_KEY: "Duration";
-export const PROPERTY_KEY: number;
-export const DELAY_KEY: "Delay";
-export const TIMING_KEY: "TimingFunction";
-export const ANIMATION_ITERATION_COUNT_KEY: "IterationCount";
-export const ANIMATION_PLAYSTATE_KEY: "PlayState";
-export const SAFE_FAST_FORWARD_DURATION_VALUE: 9999;
-export const ANIMATION_DELAY_PROP: string;
-export const ANIMATION_DURATION_PROP: string;
-export const TRANSITION_DELAY_PROP: string;
-export const TRANSITION_DURATION_PROP: string;
 export const ngMinErr: (arg0: string, ...arg1: any[]) => Error;

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

@@ -1,7 +1,6 @@
 export class Attributes {
   static $nonscope: boolean;
   /**
-   * @param {ng.RootScopeService} $rootScope
    * @param {ng.AnimateService} $animate
    * @param {ng.ExceptionHandlerService} $exceptionHandler
    * @param {*} $sce
@@ -9,17 +8,15 @@ export class Attributes {
    * @param {Object} [attributesToCopy]
    */
   constructor(
-    $rootScope: ng.RootScopeService,
     $animate: ng.AnimateService,
     $exceptionHandler: ng.ExceptionHandlerService,
     $sce: any,
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any,
   );
-  $rootScope: ng.RootScopeService;
-  $animate: import("../../interface.ts").AnimateService;
-  $exceptionHandler: import("../../interface.ts").ExceptionHandler;
-  $sce: any;
+  _$animate: import("../../animations/interface.ts").AnimateService;
+  _$exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
+  _$sce: any;
   $attr: {};
   /** @type {import("../../shared/noderef.js").NodeRef} */
   $nodeRef: import("../../shared/noderef.js").NodeRef;
@@ -62,14 +59,14 @@ export class Attributes {
    * Set a normalized attribute on the element in a way such that all directives
    * can share the attribute. This function properly handles boolean attributes.
    * @param {string} key Normalized key. (ie ngAttribute)
-   * @param {string|boolean} value The value to set. If `null` attribute will be deleted.
+   * @param {string|boolean|null} value The value to set. If `null` attribute will be deleted.
    * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.
    *     Defaults to true.
    * @param {string=} attrName Optional none normalized name. Defaults to key.
    */
   $set(
     key: string,
-    value: string | boolean,
+    value: string | boolean | null,
     writeAttr?: boolean | undefined,
     attrName?: string | undefined,
   ): void;
@@ -90,7 +87,13 @@ export class Attributes {
   $observe(key: string, fn: any): () => any;
   $$observers: any;
   setSpecialAttr(element: any, attrName: any, value: any): void;
-  sanitizeSrcset(value: any, invokeType: any): any;
-  srcset: any;
+  /**
+   *
+   * @param {unknown} value
+   * @param {string} invokeType
+   * @returns {unknown}
+   */
+  sanitizeSrcset(value: unknown, invokeType: string): unknown;
+  srcset: unknown;
 }
 import { directiveNormalize } from "../../shared/utils.js";

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

@@ -113,7 +113,7 @@ export class CompileProvider {
    *
    * @param {string} elementName The element name or '*' to match any element.
    * @param {string} propertyName The DOM property name.
-   * @param {string} ctx The {@link $sce} security context in which this value is safe for use, e.g. `$sce.URL`
+   * @param {string} ctx The {@link _$sce} security context in which this value is safe for use, e.g. `$sce.URL`
    * @returns {object} `this` for chaining
    */
   addPropertySecurityContext: (
@@ -125,7 +125,7 @@ export class CompileProvider {
     | string
     | ((
         $injector: ng.InjectorService,
-        $interpolate: any,
+        $interpolate: ng.InterpolateService,
         $exceptionHandler: ng.ExceptionHandlerService,
         $templateRequest: ng.TemplateRequestService,
         $parse: ng.ParseService,

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

@@ -1,4 +1,4 @@
-export function identifierForController(controller: any, ident: any): any;
+export function identifierForController(controller: any, ident: any): string;
 /**
  * The {@link ng.$controller $controller service} is used by AngularTS to create new
  * controllers.

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

@@ -16,26 +16,27 @@ export class NgModule {
     configFn?: ng.Injectable<any>,
   );
   /**
+   * @public
    * Name of the current module.
    * @type {string}
    */
-  name: string;
+  public name: string;
   /**
    * Array of module names that this module depends on.
    * @type {string[]}
    */
-  requires: string[];
+  _requires: string[];
   /**
    * Holds a collection of tasks, required to instantiate an angular component
    * @type {!Array<Array<*>>}
    */
-  invokeQueue: Array<Array<any>>;
+  _invokeQueue: Array<Array<any>>;
   /** @type {!Array<Array<*>>} */
-  configBlocks: Array<Array<any>>;
+  _configBlocks: Array<Array<any>>;
   /** @type {!Array.<ng.Injectable<any>>} */
-  runBlocks: Array<ng.Injectable<any>>;
-  services: any[];
-  restDefinitions: any[];
+  _runBlocks: Array<ng.Injectable<any>>;
+  _services: any[];
+  _restDefinitions: any[];
   /**
    * @param {string} name
    * @param {any} object - Allows undefined

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

@@ -10,7 +10,7 @@ export class FilterProvider {
    * @param {ng.ProvideService} $provide
    */
   constructor($provide: ng.ProvideService);
-  $provide: import("../../interface.ts").Provider;
+  _$provide: import("../../interface.ts").Provider;
   /**
    * Register a filter a config phase;
    * @param {string} name

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

@@ -1,4 +1,5 @@
 export interface InterpolationFunction {
+  expressions: any[];
   (context: any): string;
 }
 export interface InterpolateService {