@angular-wave/angular.ts 0.16.1 → 0.18.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/animate-js-driver.d.ts

@@ -1,6 +1,14 @@
-export function AnimateJsDriverProvider($$animationProvider: any): void;
+/**
+ * @param {import("./animation.js").AnimationProvider} $$animationProvider
+ */
+export function AnimateJsDriverProvider(
+  $$animationProvider: import("./animation.js").AnimationProvider,
+): void;
 export class AnimateJsDriverProvider {
-  constructor($$animationProvider: any);
+  /**
+   * @param {import("./animation.js").AnimationProvider} $$animationProvider
+   */
+  constructor($$animationProvider: import("./animation.js").AnimationProvider);
   $get: (string | (($$animateJs: any) => (animationDetails: any) => any))[];
 }
 export namespace AnimateJsDriverProvider {

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

@@ -3,7 +3,7 @@ export function AnimateProvider($provide: ng.ProvideService): void;
 export class AnimateProvider {
   /** @param {ng.ProvideService} $provide */
   constructor($provide: ng.ProvideService);
-  $$registeredAnimations: any;
+  _registeredAnimations: any;
   /**
    * Registers a new injectable animation factory function. The factory function produces the
    * animation object which contains callback functions for each event that is expected to be

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

@@ -1,14 +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)
+      ) => import("./interface.ts").AnimationService)
   )[];
 }
-import { AnimateRunner } from "./runner/animate-runner.js";

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,10 @@
 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 type AnimationService = (
+  element: HTMLElement,
+  event: string,
+  options?: any,
+) => AnimateRunner;
 export interface AnimationHost {
   /** Pause animation. */
   pause?: () => void;
@@ -100,13 +88,27 @@ export interface AnimationOptions {
   tempClasses: string | string[];
   /** Optional DOM operation callback executed before animation */
   domOperation?: () => void;
-  $$domOperationFired?: boolean;
-  $$prepared?: 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;
+  _willAnimate: true;
   start: () => AnimateRunner;
   end: () => AnimateRunner;
 }

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

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

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

@@ -118,7 +118,7 @@ export function clearGeneratedClasses(
  * @param {boolean} applyBlock
  * @returns {string[]}
  */
-export function blockKeyframeAnimations(
+export function _blockKeyframeAnimations(
   node: HTMLElement,
   applyBlock: boolean,
 ): string[];

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

@@ -19,14 +19,14 @@ export class Attributes {
    *
    * @param {ng.AnimateService} $animate
    * @param {ng.ExceptionHandlerService} $exceptionHandler
-   * @param {ng.SCEService} $sce
+   * @param {ng.SceService} $sce
    * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
    * @param {Object & Record<string, any>} [attributesToCopy]
    */
   constructor(
     $animate: ng.AnimateService,
     $exceptionHandler: ng.ExceptionHandlerService,
-    $sce: ng.SCEService,
+    $sce: ng.SceService,
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any & Record<string, any>,
   );
@@ -34,8 +34,8 @@ export class Attributes {
   _animate: ng.AnimateService;
   /** @type {ng.ExceptionHandlerService} */
   _exceptionHandler: ng.ExceptionHandlerService;
-  /** @type {ng.SCEService} */
-  _sce: ng.SCEService;
+  /** @type {ng.SceService} */
+  _sce: ng.SceService;
   /**
    * 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.

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

@@ -3,11 +3,11 @@ export class CompileProvider {
   static $inject: string[];
   /**
    * @param {import('../../interface.ts').Provider} $provide
-   * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $$sanitizeUriProvider
+   * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $sanitizeUriProvider
    */
   constructor(
     $provide: import("../../interface.ts").Provider,
-    $$sanitizeUriProvider: import("../sanitize/sanitize-uri.js").SanitizeUriProvider,
+    $sanitizeUriProvider: import("../sanitize/sanitize-uri.js").SanitizeUriProvider,
   );
   /**
    * Register a new directive with the compiler.
@@ -130,7 +130,7 @@ export class CompileProvider {
         $templateRequest: ng.TemplateRequestService,
         $parse: ng.ParseService,
         $controller: any,
-        $sce: ng.SCEService,
+        $sce: ng.SceService,
         $animate: ng.AnimateService,
       ) => (
         compileNode: string | Element | Node | ChildNode | NodeList,

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

@@ -21,6 +21,6 @@ export class InterpolateProvider {
   endSymbol: string;
   $get: (
     | string
-    | (($parse: ng.ParseService, $sce: ng.SCEService) => ng.InterpolateService)
+    | (($parse: ng.ParseService, $sce: ng.SceService) => ng.InterpolateService)
   )[];
 }

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.
    */