@angular-wave/angular.ts 0.14.3 → 0.15.1

package/@types/angular.d.ts

@@ -1,35 +1,35 @@
-export class Angular {
-  /** @public */
-  public $cache: Map<number, import("./interface.ts").ExpandoStore>;
+export class Angular extends EventTarget {
+  /** @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
@@ -131,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
    */
@@ -154,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

@@ -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/runner/animate-runner.d.ts

@@ -1,95 +1,116 @@
-/**
- * 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;
   /**
-   * 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;
   /**
-   * @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.
  */

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,6 +1,25 @@
+/**
+ * @extends {Record<string, any>}
+ */
 export class Attributes {
   static $nonscope: boolean;
   /**
+   * Creates an Attributes instance.
+   *
+   * There are two construction modes:
+   *
+   * 1. **Fresh instance** (no `attributesToCopy`):
+   *    - Used when compiling a DOM element for the first time.
+   *    - Initializes a new `$attr` map to track normalized → DOM attribute names.
+   *
+   * 2. **Clone instance** (`attributesToCopy` provided):
+   *    - Used when cloning attributes for directive linking / child scopes.
+   *    - Performs a shallow copy of all properties from the source Attributes object,
+   *      including `$attr`, normalized attribute values, and internal fields
+   *      (e.g. `$$observers`).
+   *    - `$attr` is intentionally **not reinitialized** in this case, because the
+   *      source object already contains the correct normalized → DOM attribute mapping.
+   *
    * @param {ng.AnimateService} $animate
    * @param {ng.ExceptionHandlerService} $exceptionHandler
    * @param {*} $sce
@@ -14,12 +33,16 @@ export class Attributes {
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any,
   );
-  _$animate: import("../../interface.ts").AnimateService;
-  _$exceptionHandler: import("../../interface.ts").ExceptionHandler;
+  _$animate: import("../../animations/interface.ts").AnimateService;
+  _$exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
   _$sce: any;
+  /**
+   * A map of DOM element attribute names to the normalized name. This is needed
+   * to do reverse lookup from normalized name back to actual name.
+   */
   $attr: {};
   /** @type {import("../../shared/noderef.js").NodeRef} */
-  $nodeRef: import("../../shared/noderef.js").NodeRef;
+  _nodeRef: import("../../shared/noderef.js").NodeRef;
   /** @type {Node|Element} */
   get $$element(): Node | Element;
   /**
@@ -59,18 +82,19 @@ 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;
   /**
+     * @template T
      * Observes an interpolated attribute.
      *
      * The observer function will be invoked once during the next `$digest` following
@@ -78,16 +102,22 @@ export class Attributes {
      * changes.
      *
      * @param {string} key Normalized key. (ie ngAttribute) .
-     * @param {any} fn Function that will be called whenever
+     * @param {(value?: T) => any} fn Function that will be called whenever
               the interpolated value of the attribute changes.
     *        See the {@link guide/interpolation#how-text-and-attribute-bindings-work Interpolation
     *        guide} for more info.
-    * @returns {function()} Returns a deregistration function for this observer.
+    * @returns {Function} Returns a deregistration function for this observer.
     */
-  $observe(key: string, fn: any): () => any;
+  $observe<T>(key: string, fn: (value?: T) => any): Function;
   $$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

@@ -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/compile/inteface.d.ts

@@ -1,5 +1,7 @@
 import type { Scope } from "../scope/scope.js";
 import type { NodeRef } from "../../shared/noderef.js";
+type TranscludedNodes = Node | Node[] | NodeList | null;
+type TranscludeFnCb = (clone?: TranscludedNodes, scope?: Scope | null) => void;
 /**
  * A function passed as the fifth argument to a `PublicLinkFn` link function.
  * It behaves like a linking function, with the `scope` argument automatically created
@@ -8,7 +10,8 @@ import type { NodeRef } from "../../shared/noderef.js";
  * The function returns the DOM content to be injected (transcluded) into the directive.
  */
 export type TranscludeFn = {
-  (clone?: Element | Node | ChildNode | NodeList | Node[], scope?: Scope): void;
+  (cb: TranscludeFnCb): void;
+  (scope: Scope, cb?: TranscludeFnCb): void;
   $$slots?: any;
 };
 /**
@@ -84,3 +87,4 @@ export type CompositeLinkFn = (
   $linkNode: NodeRef,
   parentBoundTranscludeFn?: Function,
 ) => void;
+export {};

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/inteface.d.ts

@@ -0,0 +1,11 @@
+export interface StorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+export interface PersistentStoreConfig {
+  backend?: StorageLike;
+  serialize?: (value: unknown) => string;
+  deserialize?: (value: string) => unknown;
+  cookie?: Record<string, unknown>;
+}

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

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

package/@types/core/parse/ast/ast-node.d.ts

@@ -53,4 +53,6 @@ export type ASTNode = {
   filter?: boolean;
   /** Indicates in node depends on non-shallow state of objects */
   isPure?: boolean;
+  /** Indicates the expression is a contant */
+  constant?: boolean;
 };

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

@@ -41,7 +41,7 @@ export interface CompiledExpressionProps {
  * Evaluates the compiled expression.
  */
 export type CompiledExpressionFunction = (
-  context?: Scope,
+  context?: Scope | typeof Proxy<Scope>,
   locals?: object,
   assign?: any,
 ) => any;

package/@types/core/parse/interpreter.d.ts

@@ -10,13 +10,15 @@ export class ASTInterpreter {
    * @param {function(any):any} $filter
    */
   constructor($filter: (arg0: any) => any);
-  $filter: (arg0: any) => any;
+  _$filter: (arg0: any) => any;
   /**
    * Compiles the AST into a function.
-   * @param {import("./ast/ast").ASTNode} ast - The AST to compile.
+   * @param {import("./ast/ast.js").ASTNode} ast - The AST to compile.
    * @returns {import("./interface.ts").CompiledExpression}
    */
-  compile(ast: any): import("./interface.ts").CompiledExpression;
+  compile(
+    ast: import("./ast/ast.js").ASTNode,
+  ): import("./interface.ts").CompiledExpression;
   /**
    * Unary plus operation.
    * @param {function} argument - The argument function.

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

@@ -29,5 +29,8 @@ export class ParseProvider {
     identifierStart?: (arg0: any) => boolean,
     identifierContinue?: (arg0: any) => boolean,
   ) => ParseProvider;
-  $get: (string | (($filter: (any: any) => any) => any))[];
+  $get: (
+    | string
+    | (($filter: (any: any) => any) => import("./interface.ts").ParseService)
+  )[];
 }

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

@@ -10,3 +10,29 @@ export interface Listener {
   watchProp?: string;
   foreignListener?: ProxyConstructor;
 }
+export interface ScopeEvent {
+  /**
+   * the scope on which the event was $emit-ed or $broadcast-ed.
+   */
+  targetScope: ng.Scope;
+  /**
+   * the scope that is currently handling the event. Once the event propagates through the scope hierarchy, this property is set to null.
+   */
+  currentScope: ng.Scope;
+  /**
+   * name of the event.
+   */
+  name: string;
+  /**
+   * calling stopPropagation function will cancel further event propagation (available only for events that were $emit-ed).
+   */
+  stopPropagation?(): void;
+  /**
+   * calling preventDefault sets defaultPrevented flag to true.
+   */
+  preventDefault(): void;
+  /**
+   * true if preventDefault was called.
+   */
+  defaultPrevented: boolean;
+}