@angular-wave/angular.ts 0.16.1 → 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/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.
    */

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

@@ -46,9 +46,8 @@ export class Scope {
    * @param {Scope} [parent] - Custom parent.
    */
   constructor(context?: Scope, parent?: Scope);
-  context: Scope;
-  /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners */
-  watchers: Map<string, Array<import("./interface.ts").Listener>>;
+  /** @ignore @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners */
+  _watchers: Map<string, Array<import("./interface.ts").Listener>>;
   /** @private @type {Map<String, Function[]>} Event listeners */
   private _listeners;
   /** @private @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
@@ -59,25 +58,26 @@ export class Scope {
   private _objectListeners;
   /** @type {Proxy<Scope>} Current proxy being operated on */
   $proxy: ProxyConstructor;
-  /** @type {Scope} The actual proxy */
+  /** @type {Scope} This is the reference to the Scope object with acts as the actual proxy */
   $handler: Scope;
   /** @type {*} Current target being called on */
   $target: any;
-  /** @type {*} Value wrapped by the proxy */
-  $value: any;
   /**
-   * @type {Scope[]}
+   * @ignore @type {Scope[]}
    */
-  $children: Scope[];
+  _children: Scope[];
   /**
    * @type {number} Unique model ID (monotonically increasing) useful for debugging.
    */
   $id: number;
   /**
-   * @type {Scope}
+   * @type {ng.RootScopeService}
    */
-  $root: Scope;
-  $parent: Scope;
+  $root: ng.RootScopeService;
+  /**
+   * @type {Scope | undefined}
+   */
+  $parent: Scope | undefined;
   /** @ignore @type {boolean} */
   _destroyed: boolean;
   /** @private @type {import("./interface.ts").Listener[]} A list of scheduled Event listeners */
@@ -90,14 +90,14 @@ export class Scope {
    * Intercepts and handles property assignments on the target object. If a new value is
    * an object, it will be recursively proxied.
    *
-   * @param {Object} target - The target object.
+   * @param {Object & Record<string, any>} target - The target object.
    * @param {string} property - The name of the property being set.
    * @param {*} value - The new value being assigned to the property.
    * @param {Proxy<Scope>} proxy - The proxy intercepting property access
    * @returns {boolean} - Returns true to indicate success of the operation.
    */
   set(
-    target: any,
+    target: any & Record<string, any>,
     property: string,
     value: any,
     proxy: ProxyConstructor,
@@ -107,17 +107,21 @@ export class Scope {
    * properties (`watch` and `sync`) and binds their methods. For other properties,
    * it returns the value directly.
    *
-   * @param {Object} target - The target object.
+   * @param {Object & Record<string, any>} target - The target object.
    * @param {string|number|symbol} property - The name of the property being accessed.
    * @param {Proxy<Scope>} proxy - The proxy object being invoked
    * @returns {*} - The value of the property or a method if accessing `watch` or `sync`.
    */
   get(
-    target: any,
+    target: any & Record<string, any>,
     property: string | number | symbol,
     proxy: ProxyConstructor,
   ): any;
-  deleteProperty(target: any, property: any): boolean;
+  /**
+   * @param {Object & Record<string, any>} target - The target object.
+   * @param {string} property - The name of the property being deleted
+   */
+  deleteProperty(target: any & Record<string, any>, property: string): boolean;
   /**
    * Registers a watcher for a property along with a listener function. The listener
    * function is invoked when changes to that property are detected.
@@ -131,10 +135,42 @@ export class Scope {
     listenerFn?: ng.ListenerFn,
     lazy?: boolean,
   ): () => void;
-  $new(childInstance: any): any;
-  $newIsolate(instance: any): any;
-  $transcluded(parentInstance: any): any;
-  $eval(expr: any, locals: any): any;
+  /**
+   * @param {ng.Scope} [childInstance]
+   * @returns {Proxy<ng.Scope> & ng.Scope}
+   */
+  $new(childInstance?: ng.Scope): ProxyConstructor & ng.Scope;
+  /**
+   * @param {ng.Scope} [instance]
+   * @returns {Proxy<ng.Scope> & ng.Scope}
+   */
+  $newIsolate(instance?: ng.Scope): ProxyConstructor & ng.Scope;
+  /**
+   * @param {ng.Scope} parentInstance
+   * @returns {Proxy<ng.Scope> & ng.Scope}
+   */
+  $transcluded(parentInstance: ng.Scope): ProxyConstructor & ng.Scope;
+  /**
+   * @param {string} key
+   * @param {import("./interface.ts").Listener} listener
+   */
+  _registerForeignKey(
+    key: string,
+    listener: import("./interface.ts").Listener,
+  ): void;
+  /**
+   * @param {string} key
+   * @param {number} id
+   */
+  _deregisterForeignKey(key: string, id: number): boolean;
+  /**
+   * Evaluates an Angular expression in the context of this scope.
+   *
+   * @param {string} expr - Angular expression to evaluate
+   * @param {Record<string, any>} [locals] - Optional local variables
+   * @returns {any}
+   */
+  $eval(expr: string, locals?: Record<string, any>): any;
   /**
    * @param {Object} newTarget
    */
@@ -153,9 +189,9 @@ export class Scope {
   /**
    * @param {string} name
    * @param  {...any} args
-   * @returns {void}
+   * @returns {ng.ScopeEvent | undefined}
    */
-  $emit(name: string, ...args: any[]): void;
+  $emit(name: string, ...args: any[]): ng.ScopeEvent | undefined;
   /**
    * @param {string} name
    * @param  {...any} args

package/@types/directive/form/form.d.ts

@@ -1,4 +1,14 @@
 export function setupValidity(instance: any): void;
+/**
+ * @param {FormController|ng.NgModelController} ctrl
+ * @param {string} className
+ * @param {boolean} switchValue
+ */
+export function cachedToggleClass(
+  ctrl: FormController | ng.NgModelController,
+  className: string,
+  switchValue: boolean,
+): void;
 /**
  * @type {{
  *   $nonscope: boolean,
@@ -74,21 +84,23 @@ export class FormController {
   static $nonscope: boolean;
   static $inject: string[];
   /**
-   * @param {Element} $element
+   * @param {HTMLFormElement} $element
    * @param {ng.Attributes} $attrs
    * @param {ng.Scope} $scope
    * @param {ng.AnimateService} $animate
    * @param {ng.InterpolateService} $interpolate
    */
   constructor(
-    $element: Element,
+    $element: HTMLFormElement,
     $attrs: ng.Attributes,
     $scope: ng.Scope,
     $animate: ng.AnimateService,
     $interpolate: ng.InterpolateService,
   );
+  /** @type {boolean} */
+  _isAnimated: boolean;
   _controls: any[];
-  $name: string;
+  $name: any;
   /**
    * @property {boolean} $dirty True if user has already interacted with the form.
    */
@@ -102,7 +114,7 @@ export class FormController {
   $submitted: boolean;
   /** @type {FormController|Object} */
   _parentForm: FormController | any;
-  _element: Element;
+  _element: HTMLFormElement;
   _animate: import("../../animations/interface.ts").AnimateService;
   $error: {};
   _success: {};

package/@types/directive/model/model.d.ts

@@ -52,7 +52,7 @@ export class NgModelController {
    * @param {ng.Scope} $scope
    * @param {ng.ExceptionHandlerService} $exceptionHandler
    * @param {ng.Attributes} $attr
-   * @param {Element} $element
+   * @param {HTMLElement} $element
    * @param {ng.ParseService} $parse
    * @param {ng.AnimateService} $animate
    * @param {ng.InterpolateService} $interpolate
@@ -61,11 +61,13 @@ export class NgModelController {
     $scope: ng.Scope,
     $exceptionHandler: ng.ExceptionHandlerService,
     $attr: ng.Attributes,
-    $element: Element,
+    $element: HTMLElement,
     $parse: ng.ParseService,
     $animate: ng.AnimateService,
     $interpolate: ng.InterpolateService,
   );
+  /** @type {boolean} */
+  _isAnimated: boolean;
   /** @type {any} The actual value from the control's view  */
   $viewValue: any;
   /** @type {any} The value in the model that the control is bound to. */
@@ -97,7 +99,7 @@ export class NgModelController {
   $error: {};
   _success: {};
   $pending: any;
-  $name: string;
+  $name: any;
   _parentForm: {
     $nonscope: boolean;
     $addControl: Function;
@@ -144,7 +146,7 @@ export class NgModelController {
   /** @type {ng.Scope} */
   _scope: ng.Scope;
   _attr: ng.Attributes;
-  _element: Element;
+  _element: HTMLElement;
   _animate: import("../../animations/interface.ts").AnimateService;
   _parse: import("../../core/parse/interface.ts").ParseService;
   _exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;

package/@types/filters/order-by.d.ts

@@ -6,3 +6,16 @@ export function orderByFilter($parse: ng.ParseService): ng.FilterFn;
 export namespace orderByFilter {
   let $inject: string[];
 }
+export type ComparisonObject = {
+  value: any;
+  tieBreaker: {
+    value: number;
+    type: string;
+    index: number;
+  };
+  predicateValues: Array<{
+    value: any;
+    type: string;
+    index: number;
+  }>;
+};