@angular-wave/angular.ts 0.16.0 → 0.17.0

package/@types/angular.d.ts

@@ -85,6 +85,10 @@ export class Angular extends EventTarget {
     requires?: Array<string>,
     configFn?: ng.Injectable<any>,
   ): NgModule;
+  /**
+   * @param {CustomEvent} event
+   */
+  dispatchEvent(event: CustomEvent): boolean;
   /**
    * Use this function to manually start up AngularTS application.
    *

package/@types/animations/animate-css-driver.d.ts

@@ -1,6 +1,14 @@
-export function AnimateCssDriverProvider($$animationProvider: any): void;
+/**
+ * @param {import("./animation.js").AnimationProvider} $$animationProvider
+ */
+export function AnimateCssDriverProvider(
+  $$animationProvider: import("./animation.js").AnimationProvider,
+): void;
 export class AnimateCssDriverProvider {
-  constructor($$animationProvider: any);
+  /**
+   * @param {import("./animation.js").AnimationProvider} $$animationProvider
+   */
+  constructor($$animationProvider: import("./animation.js").AnimationProvider);
   /**
    * @returns {Function}
    */

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

@@ -1,17 +1,11 @@
 export function AnimateCssProvider(): void;
 export class AnimateCssProvider {
-  $get: (
-    | string
-    | ((
-        $$animateCache: any,
-        $$rAFScheduler: any,
-      ) => (
-        element: any,
-        initialOptions: any,
-      ) => {
-        $$willAnimate: boolean;
-        start(): any;
-        end: () => void;
-      })
-  )[];
+  $get: (() => (
+    element: HTMLElement,
+    initialOptions: ng.AnimationOptions,
+  ) => {
+    $$willAnimate: boolean;
+    start(): any;
+    end: () => void;
+  })[];
 }

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

@@ -1,13 +1,11 @@
 export function AnimationProvider(): void;
 export class AnimationProvider {
-  drivers: any[];
+  drivers: string[];
   $get: (
     | string
     | ((
         $rootScope: ng.RootScopeService,
         $injector: ng.InjectorService,
-        $$rAFScheduler: import("./raf-scheduler.js").RafScheduler,
-        $$animateCache: any,
       ) => (elementParam: any, event: any, options: any) => AnimateRunner)
   )[];
 }

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

@@ -0,0 +1,99 @@
+/**
+ * Animation cache responsible for:
+ *  - Generating stable animation cache keys
+ *  - Tracking cached animation results
+ *  - Avoiding repeated animation work
+ *
+ * Cache keys are scoped per parent node to prevent collisions between
+ * structurally identical nodes in different DOM subtrees.
+ *
+ * @internal
+ */
+export class AnimateCache {
+  /**
+   * Generates a stable cache key for an animation invocation.
+   *
+   * The key is derived from:
+   *  - The node's parent (used as a cache namespace)
+   *  - The animation method (e.g. enter, leave, addClass)
+   *  - The node's current CSS class state
+   *  - Any classes being added or removed
+   *
+   * If the node is not attached to the DOM, the node itself is used
+   * as the parent scope to avoid key collisions.
+   *
+   * @param {HTMLElement} node
+   *   Target element being animated.
+   * @param {string} method
+   *   Animation method name.
+   * @param {string} [addClass]
+   *   CSS class scheduled to be added during the animation.
+   * @param {string} [removeClass]
+   *   CSS class scheduled to be removed during the animation.
+   *
+   * @returns {string}
+   *   A unique, deterministic cache key.
+   */
+  _cacheKey(
+    node: HTMLElement,
+    method: string,
+    addClass?: string,
+    removeClass?: string,
+  ): string;
+  /**
+   * Determines whether a cache entry exists but is marked as invalid.
+   *
+   * This is typically used to detect animations that were previously
+   * cached but resolved without a duration.
+   *
+   * @param {string} key
+   *   Cache key to test.
+   * @returns {boolean}
+   *   True if an invalid cache entry exists, false otherwise.
+   */
+  _containsCachedAnimationWithoutDuration(key: string): boolean;
+  /**
+   * Clears all cached animation entries.
+   *
+   * Does not reset parent IDs.
+   *
+   * @returns {void}
+   */
+  _flush(): void;
+  /**
+   * Returns the number of times a cache entry has been used.
+   *
+   * @param {string} key
+   *   Cache key to query.
+   * @returns {number}
+   *   Usage count, or 0 if the entry does not exist.
+   */
+  _count(key: string): number;
+  /**
+   * Retrieves the cached value associated with a cache key.
+   *
+   * @param {string} key
+   *   Cache key to retrieve.
+   * @returns {any}
+   *   Cached value, or undefined if not present.
+   */
+  _get(key: string): any;
+  /**
+   * Inserts or updates a cache entry.
+   *
+   * Existing entries will have their usage count incremented
+   * and their value replaced.
+   *
+   * @param {string} key
+   *   Cache key.
+   * @param {any} value
+   *   Value to cache.
+   * @param {boolean} isValid
+   *   Whether the cached value is considered valid.
+   *
+   * @returns {void}
+   */
+  _put(key: string, value: any, isValid: boolean): void;
+  #private;
+}
+export const animateCache: AnimateCache;

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

@@ -0,0 +1,17 @@
+/**
+ * Internal cache entry used to track animation results and usage.
+ */
+export interface CacheEntry {
+  /**
+   * Number of times this cache entry has been accessed or reused.
+   */
+  total: number;
+  /**
+   * Cached animation result (typically an animation runner or metadata).
+   */
+  value: any;
+  /**
+   * Whether the cached animation is considered valid (e.g. has a duration).
+   */
+  isValid: boolean;
+}

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

@@ -1,22 +1,5 @@
 import { AnimateRunner } from "./runner/animate-runner.js";
 import { QueuePhase } from "./queue/interface.ts";
-export type RafScheduler = {
-  /**
-   * Schedules a list of functions to run on the next animation frame(s).
-   * @param tasks - The tasks to be scheduled.
-   */
-  (tasks: Array<() => void>): void;
-  /**
-   * Internal queue of scheduled task arrays.
-   */
-  _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;
-};
 export interface AnimationHost {
   /** Pause animation. */
   pause?: () => void;
@@ -100,10 +83,24 @@ export interface AnimationOptions {
   tempClasses: string | string[];
   /** Optional DOM operation callback executed before animation */
   domOperation?: () => void;
-  $$domOperationFired?: boolean;
+  onDone?: () => void;
+  _domOperationFired?: boolean;
   $$prepared?: boolean;
+  $$skipPreparationClasses?: boolean;
+  cleanupStyles?: boolean;
   preparationClasses?: string;
   activeClasses?: string;
+  duration?: number | string;
+  event?: string | string[];
+  easing?: string;
+  delay?: string;
+  structural?: boolean;
+  transitionStyle?: string;
+  staggerIndex?: number;
+  skipBlocking?: boolean;
+  stagger?: number | string;
+  keyframeStyle?: string;
+  applyClassesEarly?: boolean;
 }
 export interface AnimateJsRunner {
   $$willAnimate: true;

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

@@ -0,0 +1,37 @@
+/**
+ * A requestAnimationFrame-based scheduler.
+ */
+export class RafScheduler {
+  /**
+   * Internal task queue, where each item is an array of functions to run.
+   * @type {Array<() => void>}
+   */
+  _queue: Array<() => void>;
+  /**
+   * ID of the currently scheduled animation frame (if any).
+   * Used for cancellation and tracking.
+   * @type {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;
+  /**
+   * The main scheduler function.
+   * Accepts an array of functions and schedules them to run in the next available frame(s).
+   *
+   * @param {Array<() => void>} tasks
+   */
+  _schedule(tasks: Array<() => void>): void;
+  /**
+   * Cancels any pending frame and runs the given function once the frame is idle.
+   * Useful for debounced updates.
+   *
+   * @param {Function} fn - Function to run when the animation frame is quiet.
+   */
+  _waitUntilQuiet(fn: Function): void;
+}
+export const rafScheduler: RafScheduler;

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

@@ -2,6 +2,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;
+export type ChildTranscludeOrLinkFn = TranscludeFn | PublicLinkFn;
 /**
  * A function passed as the fifth argument to a `PublicLinkFn` link function.
  * It behaves like a linking function, with the `scope` argument automatically created
@@ -12,13 +13,33 @@ type TranscludeFnCb = (clone?: TranscludedNodes, scope?: Scope | null) => void;
 export type TranscludeFn = {
   (cb: TranscludeFnCb): void;
   (scope: Scope, cb?: TranscludeFnCb): void;
-  $$slots?: any;
+  _slots?: any;
 };
+export type CloneAttachFn = (
+  clone: Node | Element | NodeList,
+  scope?: Scope,
+) => void;
 /**
  * A specialized version of `TranscludeFn` with the scope argument already bound.
  * This function requires no parameters and returns the same result as `TranscludeFn`.
  */
-export type BoundTranscludeFn = () => Element | Node;
+export interface BoundTranscludeFn {
+  (
+    scope?: Scope,
+    cloneAttachFn?: CloneAttachFn,
+    transcludeControllers?: unknown,
+    _futureParentElement?: Node | Element,
+    scopeToChild?: Scope,
+  ): Node | Element | NodeList;
+  _slots: Record<string, SlotTranscludeFn | null | undefined>;
+}
+export type SlotTranscludeFn = (
+  scope?: Scope,
+  cloneAttachFn?: CloneAttachFn,
+  transcludeControllers?: unknown,
+  _futureParentElement?: Node | Element,
+  scopeToChild?: Scope,
+) => Node | Element | NodeList;
 /**
  * Represents a simple change in a watched value.
  */
@@ -60,17 +81,27 @@ export interface LinkFnMapping {
  * Function that compiles a list of nodes and returns a composite linking function.
  */
 export type CompileNodesFn = () => CompositeLinkFn;
+export type ChildLinkFn = (
+  scope: Scope,
+  nodeRef: NodeRef,
+  _parentBoundTranscludeFn: BoundTranscludeFn | null,
+) => void;
 /**
  * A function used to link a specific node.
  */
-export type NodeLinkFn = () => Node | Element | NodeList;
+export type NodeLinkFn = (
+  childLinkFn: ChildLinkFn | null,
+  scope: Scope,
+  node: Node | Element,
+  boundTranscludeFn: BoundTranscludeFn | null,
+) => void;
 /**
  * Context information for a NodeLinkFn.
  */
 export interface NodeLinkFnCtx {
   nodeLinkFn: NodeLinkFn;
   terminal: boolean;
-  transclude: TranscludeFn;
+  transclude: ChildTranscludeOrLinkFn;
   transcludeOnThisElement: boolean;
   templateOnThisElement: boolean;
   newScope: boolean;
@@ -85,6 +116,6 @@ export type ApplyDirectivesToNodeFn = () => NodeLinkFn;
 export type CompositeLinkFn = (
   scope: Scope,
   $linkNode: NodeRef,
-  parentBoundTranscludeFn?: Function,
+  _parentBoundTranscludeFn?: Function,
 ) => void;
 export {};

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

@@ -1,6 +1,12 @@
 export interface InterpolationFunction {
   expressions: any[];
-  (context: any): string;
+  /**
+   * Evaluate the interpolation.
+   * @param context - The scope/context
+   * @param cb - Optional callback when expressions change
+   */
+  (context: any, cb?: (val: any) => void): any;
+  exp: string;
 }
 export interface InterpolateService {
   (

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

@@ -1,25 +1,29 @@
 import { ASTType } from "../ast-type.js";
-/**
- * Represents a node in an Abstract Syntax Tree (AST).
- */
-export type ASTNode = {
+/** The kind of an object property */
+export type PropertyKind = "init" | "get" | "set";
+/** Base properties for all AST nodes */
+interface BaseNode {
   /** The type of the AST node. */
   type: ASTType;
-  /** The name of the identifier, if applicable. */
-  name?: string;
-  /** The kind of the property (e.g., 'init'). */
-  kind?: string;
-  /** The value of the node if it is a literal. */
-  value?: any;
-  /** The elements of an array node. */
-  elements?: ASTNode[];
-  /** The properties of an object node. */
-  properties?: ASTNode[];
-  /** The key of an object property. */
-  key?: ASTNode;
-  /** The left-hand side of a binary expression. */
+  /** Indicates whether the node depends on non-shallow state. */
+  isPure?: boolean;
+  /** Indicates whether the expression is a constant. */
+  constant?: boolean;
+}
+/** A node that contains a list of statements, e.g., Program or BlockStatement */
+export interface BodyNode extends BaseNode {
+  /** The body of the program or block. Always present; empty if no statements. */
+  body: ASTNode[];
+  /** Optional list of expressions to observe for changes (Angular-specific). */
+  toWatch: ASTNode[];
+}
+/** Expression nodes, e.g., BinaryExpression, UnaryExpression, ConditionalExpression, CallExpression, MemberExpression */
+export interface ExpressionNode extends BaseNode {
+  /** The single expression contained by an ExpressionStatement. */
+  expression?: ASTNode;
+  /** The left-hand side of a binary or logical expression. */
   left?: ASTNode;
-  /** The right-hand side of a binary expression. */
+  /** The right-hand side of a binary or logical expression. */
   right?: ASTNode;
   /** The argument of a unary expression. */
   argument?: ASTNode;
@@ -29,30 +33,63 @@ export type ASTNode = {
   alternate?: ASTNode;
   /** The consequent expression of a conditional expression. */
   consequent?: ASTNode;
-  /** The body of a program or block statement. */
-  body?: ASTNode[];
-  /** A list of expressions to observe in a program or block statement. */
-  toWatch?: ASTNode[];
-  /** The expression of an expression statement. */
-  expression?: ASTNode;
-  /** The callee of a call expression. */
+  /** The callee of a function or method call expression. */
   callee?: ASTNode;
-  /** The arguments of a call expression. */
+  /** The arguments of a function or method call expression. */
   arguments?: ASTNode[];
-  /** Indicates if a unary operator is a prefix. */
-  prefix?: boolean;
-  /** The object of a member expression. */
+  /** The object of a member expression (e.g., `obj` in `obj.prop`). */
   object?: ASTNode;
-  /** The property of a member expression. */
+  /** The property of a member expression (e.g., `prop` in `obj.prop`). */
   property?: ASTNode;
-  /** Indicates if a member expression is computed. */
+  /** Indicates if the member expression is computed (`obj[prop]` vs `obj.prop`). */
   computed?: boolean;
-  /** The operator of a binary or logical expression. */
+  /** The operator of a binary or logical expression, e.g., "+", "*", "&&". */
   operator?: string;
-  /** Indicates if the expression should be filtered. */
+  /** Indicates if the expression should be filtered (Angular-specific). */
   filter?: boolean;
-  /** Indicates in node depends on non-shallow state of objects */
-  isPure?: boolean;
-  /** Indicates the expression is a contant */
-  constant?: boolean;
-};
+  /** Indicates if the unary operator is a prefix, e.g., `++i` vs `i++`. */
+  prefix?: boolean;
+}
+/** Leaf node representing a literal or identifier */
+export interface LiteralNode extends BaseNode {
+  /** The value of a literal node, e.g., number, string, boolean. */
+  value?: any;
+  /** The name of an identifier node. */
+  name?: string;
+}
+/** Node representing an array literal */
+export interface ArrayNode extends BaseNode {
+  /** The elements of the array. */
+  elements: ASTNode[];
+}
+/** Node representing an object literal */
+export interface ObjectNode extends BaseNode {
+  /** The properties of the object. */
+  properties: ASTNode[];
+}
+/** Node representing a single property of an object literal */
+export interface ObjectPropertyNode extends BaseNode {
+  /** Property kind (only "init" is used in Angular expressions) */
+  kind: "init";
+  /** Property key: identifier, literal, or expression */
+  key: ASTNode;
+  /** Property value expression */
+  value: ASTNode;
+  /** Whether the property key is computed (`{ [expr]: value }`) */
+  computed: boolean;
+}
+/** Statement node that wraps an expression */
+export interface ExpressionStatementNode extends BaseNode {
+  /** The expression contained in this statement. */
+  expression: ASTNode;
+}
+/** The union type covering all AST nodes */
+export type ASTNode =
+  | BodyNode
+  | ExpressionNode
+  | LiteralNode
+  | ArrayNode
+  | ObjectNode
+  | ObjectPropertyNode
+  | ExpressionStatementNode;
+export {};

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

@@ -1,6 +1,3 @@
-/**
- * @class
- */
 export class AST {
   /**
    * @param {import('../lexer/lexer.js').Lexer} lexer - The lexer instance for tokenizing input

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

@@ -1,5 +1,5 @@
-import type { DecoratedASTNode } from "./interpreter.js";
 import type { Scope } from "../scope/scope.js";
+import { BodyNode } from "./ast/ast-node.ts";
 /**
  * Describes metadata and behavior for a compiled AngularTS expression.
  */
@@ -11,7 +11,7 @@ export interface CompiledExpressionProps {
   /** Optional flag for pure expressions. */
   _isPure?: boolean;
   /** AST node decorated with metadata. */
-  _decoratedNode: DecoratedASTNode;
+  _decoratedNode: BodyNode;
   /** Expression inputs; may be an array or a function. */
   _inputs?: any[] | Function;
   /**

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

@@ -3,6 +3,15 @@
  * @returns {boolean}
  */
 export function isAssignable(ast: any): boolean;
+/** @typedef {import("./ast/ast-node.ts").ASTNode} ASTNode */
+/** @typedef {import("./ast/ast-node.ts").BodyNode} BodyNode */
+/** @typedef {import("./ast/ast-node.ts").ExpressionNode} ExpressionNode */
+/** @typedef {import("./ast/ast-node.ts").ArrayNode} ArrayNode */
+/** @typedef {import("./ast/ast-node.ts").LiteralNode} LiteralNode */
+/** @typedef {import("./ast/ast-node.ts").ObjectNode} ObjectNode */
+/** @typedef {import("./ast/ast-node.ts").ObjectPropertyNode} ObjectPropertyNode */
+/** @typedef {import("./interface.ts").CompiledExpression} CompiledExpression */
+/** @typedef {import("./interface.ts").CompiledExpressionFunction} CompiledExpressionFunction */
 export const PURITY_ABSOLUTE: 1;
 export const PURITY_RELATIVE: 2;
 export class ASTInterpreter {
@@ -14,12 +23,10 @@ export class ASTInterpreter {
   _$filter: ng.FilterService;
   /**
    * Compiles the AST into a function.
-   * @param {import("./ast/ast.js").ASTNode} ast - The AST to compile.
-   * @returns {import("./interface.ts").CompiledExpression}
+   * @param {ASTNode} ast - The AST to compile.
+   * @returns {CompiledExpression}
    */
-  compile(
-    ast: import("./ast/ast.js").ASTNode,
-  ): import("./interface.ts").CompiledExpression;
+  compile(ast: ASTNode): CompiledExpression;
   /**
    * Unary plus operation.
    * @param {function} argument - The argument function.
@@ -218,8 +225,13 @@ export class ASTInterpreter {
   ): Function;
   #private;
 }
-export type DecoratedASTNode = any & {
-  isPure: boolean | number;
-  constant: boolean;
-  toWatch: any[];
-};
+export type ASTNode = import("./ast/ast-node.ts").ASTNode;
+export type BodyNode = import("./ast/ast-node.ts").BodyNode;
+export type ExpressionNode = import("./ast/ast-node.ts").ExpressionNode;
+export type ArrayNode = import("./ast/ast-node.ts").ArrayNode;
+export type LiteralNode = import("./ast/ast-node.ts").LiteralNode;
+export type ObjectNode = import("./ast/ast-node.ts").ObjectNode;
+export type ObjectPropertyNode = import("./ast/ast-node.ts").ObjectPropertyNode;
+export type CompiledExpression = import("./interface.ts").CompiledExpression;
+export type CompiledExpressionFunction =
+  import("./interface.ts").CompiledExpressionFunction;

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

@@ -1,6 +1,13 @@
 import type { CompiledExpression } from "../parse/interface.ts";
 export type ListenerFn = (newValue?: any, originalTarget?: object) => void;
-export type NonScope = string[] | boolean | undefined;
+export type NonScope = string[] | boolean;
+export interface NonScopeMarked {
+  $nonscope?: NonScope;
+  [key: string]: any;
+  constructor?: {
+    $nonscope?: NonScope;
+  };
+}
 export interface Listener {
   originalTarget: any;
   listenerFn: ListenerFn;
@@ -9,17 +16,16 @@ export interface Listener {
   scopeId: number;
   property: string[];
   watchProp?: string;
-  foreignListener?: ProxyConstructor;
 }
 export interface ScopeEvent {
   /**
    * the scope on which the event was $emit-ed or $broadcast-ed.
    */
-  targetScope: ng.Scope;
+  targetScope: typeof Proxy<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;
+  currentScope: typeof Proxy<ng.Scope> | null;
   /**
    * name of the event.
    */
@@ -32,6 +38,10 @@ export interface ScopeEvent {
    * calling preventDefault sets defaultPrevented flag to true.
    */
   preventDefault(): void;
+  /**
+   * Whether propagation has been stopped
+   */
+  stopped: boolean;
   /**
    * true if preventDefault was called.
    */