@angular-wave/angular.ts 0.15.2 → 0.16.0

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

@@ -100,6 +100,10 @@ export interface AnimationOptions {
   tempClasses: string | string[];
   /** Optional DOM operation callback executed before animation */
   domOperation?: () => void;
+  $$domOperationFired?: boolean;
+  $$prepared?: boolean;
+  preparationClasses?: string;
+  activeClasses?: string;
 }
 export interface AnimateJsRunner {
   $$willAnimate: true;

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

@@ -36,7 +36,8 @@ export class AnimateRunner {
    * @private
    */
   private _promise;
-  _tick: (fn: any) => void;
+  /** @type {(fn: VoidFunction) => void} */
+  _tick: (fn: VoidFunction) => void;
   /**
    * Sets or replaces the current host.
    * @param {AnimationHost} host

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

@@ -1,10 +1,25 @@
-export function assertArg(arg: any, name: any, reason: any): any;
-export function packageStyles(options: any): {
-  to: any;
-  from: any;
-};
-export function pendClasses(classes: any, fix: any, isPrefix: any): string;
-export function removeFromArray(arr: any, val: any): void;
+/**
+ * @param {ng.AnimationOptions} options
+ */
+export function packageStyles(options: ng.AnimationOptions):
+  | {
+      to: Record<string, string | number>;
+      from: Record<string, string | number>;
+    }
+  | {
+      to?: undefined;
+      from?: undefined;
+    };
+/**
+ * @param {string | string[]} classes
+ * @param {string} fix
+ * @param {boolean | undefined} [isPrefix]
+ */
+export function pendClasses(
+  classes: string | string[],
+  fix: string,
+  isPrefix?: boolean | undefined,
+): string;
 /**
  *
  * @param {NodeList|Node} element
@@ -13,17 +28,24 @@ export function removeFromArray(arr: any, val: any): void;
 export function stripCommentsFromElement(
   element: NodeList | Node,
 ): Node[] | Node | undefined;
-/**
- * @param {NodeList|Node} element
- * @returns {Node}
- */
-export function extractElementNode(element: NodeList | Node): Node;
 export function applyAnimationClassesFactory(): (
-  element: any,
-  options: any,
+  /** @type {HTMLElement} */ element: HTMLElement,
+  /** @type {ng.AnimationOptions} */ options: ng.AnimationOptions,
 ) => void;
-export function prepareAnimationOptions(options: any): any;
-export function applyAnimationStyles(element: any, options: any): void;
+/**
+ * @param {ng.AnimationOptions | undefined} options
+ */
+export function prepareAnimationOptions(
+  options: ng.AnimationOptions | undefined,
+): import("./interface.ts").AnimationOptions;
+/**
+ * @param {HTMLElement} element
+ * @param {ng.AnimationOptions | undefined} options
+ */
+export function applyAnimationStyles(
+  element: HTMLElement,
+  options: ng.AnimationOptions | undefined,
+): void;
 /**
  * Applies initial animation styles to a DOM element.
  *
@@ -31,13 +53,11 @@ export function applyAnimationStyles(element: any, options: any): void;
  * defined in `options.from`, then clears the property to prevent reuse.
  *
  * @param {HTMLElement} element - The target DOM element to apply styles to.
- * @param {{ from?: Partial<CSSStyleDeclaration> | null }} options - options containing a `from` object with CSS property–value pairs.
+ * @param {ng.AnimationOptions} [options] - options containing a `from` object with CSS property–value pairs.
  */
 export function applyAnimationFromStyles(
   element: HTMLElement,
-  options: {
-    from?: Partial<CSSStyleDeclaration> | null;
-  },
+  options?: ng.AnimationOptions,
 ): void;
 /**
  * Applies final animation styles to a DOM element.
@@ -46,36 +66,73 @@ export function applyAnimationFromStyles(
  * defined in `options.to`, then clears the property to prevent reuse.
  *
  * @param {HTMLElement} element - The target DOM element to apply styles to.
- * @param {{ to?: Partial<CSSStyleDeclaration> | null }} options - options containing a `from` object with CSS property–value pairs.
+ * @param {ng.AnimationOptions} [options] - options containing a `from` object with CSS property–value pairs.
  */
 export function applyAnimationToStyles(
   element: HTMLElement,
-  options: {
-    to?: Partial<CSSStyleDeclaration> | null;
-  },
+  options?: ng.AnimationOptions,
 ): void;
+/**
+ * Merge old and new animation options for an element, computing
+ * the final addClass and removeClass values.
+ *
+ * @param {HTMLElement} element - The DOM element being animated.
+ * @param {{ options?: ng.AnimationOptions; addClass?: string; removeClass?: string }} oldAnimation
+ * @param {{ options?: ng.AnimationOptions; addClass?: string; removeClass?: string; preparationClasses?: string }} newAnimation
+ * @returns {ng.AnimationOptions} - The merged animation options.
+ */
 export function mergeAnimationDetails(
-  element: any,
-  oldAnimation: any,
-  newAnimation: any,
-): any;
-export function resolveElementClasses(
-  existing: any,
-  toAdd: any,
-  toRemove: any,
-): {
-  addClass: string;
-  removeClass: string;
-};
+  element: HTMLElement,
+  oldAnimation: {
+    options?: ng.AnimationOptions;
+    addClass?: string;
+    removeClass?: string;
+  },
+  newAnimation: {
+    options?: ng.AnimationOptions;
+    addClass?: string;
+    removeClass?: string;
+    preparationClasses?: string;
+  },
+): ng.AnimationOptions;
+/**
+ * @param {HTMLElement} element
+ * @param {string | null} event
+ * @param {ng.AnimationOptions} options
+ */
 export function applyGeneratedPreparationClasses(
-  element: any,
-  event: any,
-  options: any,
+  element: HTMLElement,
+  event: string | null,
+  options: ng.AnimationOptions,
 ): void;
-export function clearGeneratedClasses(element: any, options: any): void;
-export function blockKeyframeAnimations(node: any, applyBlock: any): string[];
-export function applyInlineStyle(node: any, styleTuple: any): void;
-export function concatWithSpace(a: any, b: any): any;
+/**
+ * @param {HTMLElement} element
+ * @param {ng.AnimationOptions} options
+ */
+export function clearGeneratedClasses(
+  element: HTMLElement,
+  options: ng.AnimationOptions,
+): void;
+/**
+ * @param {HTMLElement} node
+ * @param {boolean} applyBlock
+ * @returns {string[]}
+ */
+export function blockKeyframeAnimations(
+  node: HTMLElement,
+  applyBlock: boolean,
+): string[];
+/**
+ * @param {HTMLElement} node
+ * @param {any[]} styleTuple
+ */
+export function applyInlineStyle(node: HTMLElement, styleTuple: any[]): void;
+/**
+ * @param {string} a
+ * @param {string} b
+ * @returns {string}
+ */
+export function concatWithSpace(a: string, b: string): string;
 export const ADD_CLASS_SUFFIX: "-add";
 export const REMOVE_CLASS_SUFFIX: "-remove";
 export const EVENT_CLASS_PREFIX: "ng-";
@@ -83,4 +140,3 @@ 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 const ngMinErr: (arg0: string, ...arg1: any[]) => Error;

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

@@ -1,6 +1,3 @@
-/**
- * @extends {Record<string, any>}
- */
 export class Attributes {
   static $nonscope: boolean;
   /**
@@ -16,35 +13,39 @@ export class Attributes {
    *    - 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`).
+   *      (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
+   * @param {ng.SCEService} $sce
    * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
-   * @param {Object} [attributesToCopy]
+   * @param {Object & Record<string, any>} [attributesToCopy]
    */
   constructor(
     $animate: ng.AnimateService,
     $exceptionHandler: ng.ExceptionHandlerService,
-    $sce: any,
+    $sce: ng.SCEService,
     nodeRef?: import("../../shared/noderef.js").NodeRef,
-    attributesToCopy?: any,
+    attributesToCopy?: any & Record<string, any>,
   );
-  _$animate: import("../../animations/interface.ts").AnimateService;
-  _$exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
-  _$sce: any;
+  /** @type {ng.AnimateService} */
+  _animate: ng.AnimateService;
+  /** @type {ng.ExceptionHandlerService} */
+  _exceptionHandler: ng.ExceptionHandlerService;
+  /** @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.
+   * @type {Record<string, string>}
    */
-  $attr: {};
-  /** @type {import("../../shared/noderef.js").NodeRef} */
-  _nodeRef: import("../../shared/noderef.js").NodeRef;
-  /** @type {Node|Element} */
-  get $$element(): Node | Element;
+  $attr: Record<string, string>;
+  /** @type {import("../../shared/noderef.js").NodeRef | undefined} */
+  _nodeRef: import("../../shared/noderef.js").NodeRef | undefined;
+  /** @ignore @returns {Node|Element} */
+  _element(): Node | Element;
   /**
    * Converts an attribute name (e.g. dash/colon/underscore-delimited string, optionally prefixed with `x-` or
    * `data-`) to its normalized, camelCase form.
@@ -109,8 +110,23 @@ export class Attributes {
     * @returns {Function} Returns a deregistration function for this observer.
     */
   $observe<T>(key: string, fn: (value?: T) => any): Function;
-  $$observers: any;
-  setSpecialAttr(element: any, attrName: any, value: any): void;
+  _observers: any;
+  /**
+   * Sets a special (non-standard) attribute on an element.
+   *
+   * Used for attribute names that cannot be set via `setAttribute`
+   * (e.g. names not starting with a letter like `(click)`).
+   *
+   * @param {Element} element
+   * @param {string} attrName
+   * @param {string | null} value
+   * @returns {void}
+   */
+  setSpecialAttr(
+    element: Element,
+    attrName: string,
+    value: string | null,
+  ): void;
   /**
    *
    * @param {unknown} value

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: (
@@ -130,15 +130,14 @@ export class CompileProvider {
         $templateRequest: ng.TemplateRequestService,
         $parse: ng.ParseService,
         $controller: any,
-        $rootScope: ng.Scope,
-        $sce: any,
+        $sce: ng.SCEService,
         $animate: ng.AnimateService,
       ) => (
         compileNode: string | Element | Node | ChildNode | NodeList,
-        transcludeFn?: import("./inteface.ts").TranscludeFn,
+        transcludeFn?: import("./interface.ts").TranscludeFn,
         maxPriority?: number,
         ignoreDirective?: string,
         previousCompileContext?: any,
-      ) => import("./inteface.ts").PublicLinkFn)
+      ) => import("./interface.ts").PublicLinkFn)
   )[];
 }

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

@@ -1,5 +1,5 @@
 export type ControllerService = (
-  expression: string | Function | any[],
+  expression: string | Function | ng.AnnotatedFactory<any>,
   locals?: Record<string, any>,
   later?: boolean,
   ident?: string,

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

@@ -1,13 +1,3 @@
-/**
- * @param {Function} fn
- * @returns {string}
- */
-export function stringifyFn(fn: Function): string;
-/**
- * @param {Function} fn
- * @returns {Array<any>}
- */
-export function extractArgs(fn: Function): Array<any>;
 /**
  * @param {Function} func
  * @returns {boolean}

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

@@ -0,0 +1,28 @@
+import { InjectorService, ProviderInjector } from "./internal-injector.js";
+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>;
+}
+export interface ProviderCache {
+  [key: string]: any;
+  $provide: {
+    provider: Function;
+    factory: Function;
+    service: Function;
+    value: Function;
+    constant: Function;
+    store: Function;
+    decorator: Function;
+  };
+  $injectorProvider?: {
+    $get: () => InjectorService;
+  };
+  $injector?: ProviderInjector;
+}

package/@types/core/di/internal-injector.d.ts

@@ -3,10 +3,11 @@
  */
 export class ProviderInjector extends AbstractInjector {
   /**
-   * @param {Object} cache
+   * @param {import('./interface.ts').ProviderCache} cache
    * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
    */
-  constructor(cache: any, strictDi: boolean);
+  constructor(cache: import("./interface.ts").ProviderCache, strictDi: boolean);
+  _cache: import("./interface.ts").ProviderCache;
   /**
    * Factory method for creating services.
    * @param {string} caller - The name of the caller requesting the service.
@@ -23,8 +24,12 @@ export class InjectorService extends AbstractInjector {
    * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
    */
   constructor(providerInjector: ProviderInjector, strictDi: boolean);
-  /** @type {ProviderInjector} */
-  providerInjector: ProviderInjector;
+  /** @type {(mods: Array<Function | string | ng.AnnotatedFactory<any>>) => void} */
+  loadNewModules: (
+    mods: Array<Function | string | ng.AnnotatedFactory<any>>,
+  ) => void;
+  /** @private @type {ProviderInjector} */
+  private _providerInjector;
   /**
    *
    * @param {string} name
@@ -40,13 +45,13 @@ declare class AbstractInjector {
   /**
    * @type {Object<String, Function>}
    */
-  cache: any;
+  _cache: any;
   /** @type {boolean} */
   strictDi: boolean;
   /** @type {string[]} */
-  path: string[];
+  _path: string[];
   /** @type {Object.<string, ng.NgModule>} */
-  modules: {
+  _modules: {
     [x: string]: import("./ng-module/ng-module.js").NgModule;
   };
   /**
@@ -59,38 +64,42 @@ declare class AbstractInjector {
   /**
    * Get the injection arguments for a function.
    *
-   * @param {Function|Array} fn
-   * @param {Object} locals
-   * @param {string} serviceName
+   * @param {Function|ng.AnnotatedFactory<any>} fn
+   * @param {Object & Record<string, any>} [locals]
+   * @param {string} [serviceName]
    * @returns
    */
-  injectionArgs(fn: Function | any[], locals: any, serviceName: string): any[];
+  _injectionArgs(
+    fn: Function | ng.AnnotatedFactory<any>,
+    locals?: any & Record<string, any>,
+    serviceName?: string,
+  ): any[];
   /**
    * Invoke a function with optional context and locals.
    *
-   * @param {Function|String|Array<any>} fn
+   * @param {Function|String|ng.AnnotatedFactory<any>} fn
    * @param {*} [self]
    * @param {Object} [locals]
    * @param {string} [serviceName]
    * @returns {*}
    */
   invoke(
-    fn: Function | string | Array<any>,
+    fn: Function | string | ng.AnnotatedFactory<any>,
     self?: any,
     locals?: any,
     serviceName?: string,
   ): any;
   /**
    * Instantiate a type constructor with optional locals.
-   * @param {Function|Array} type
+   * @param {Function|ng.AnnotatedFactory<any>} type
    * @param {*} [locals]
    * @param {string} [serviceName]
    */
-  instantiate(type: Function | any[], locals?: any, serviceName?: string): any;
-  /**
-   * @abstract
-   */
-  loadNewModules(): void;
+  instantiate(
+    type: Function | ng.AnnotatedFactory<any>,
+    locals?: any,
+    serviceName?: string,
+  ): any;
   /**
    * @abstract
    * @param {string} _serviceName

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

@@ -23,20 +23,27 @@ export class NgModule {
   public name: string;
   /**
    * Array of module names that this module depends on.
+   * @ignore
    * @type {string[]}
    */
   _requires: string[];
   /**
    * Holds a collection of tasks, required to instantiate an angular component
+   * @ignore
    * @type {!Array<Array<*>>}
    */
   _invokeQueue: Array<Array<any>>;
-  /** @type {!Array<Array<*>>} */
+  /**
+   * @ignore
+   * @type {!Array<Array<*>>}
+   */
   _configBlocks: Array<Array<any>>;
-  /** @type {!Array.<ng.Injectable<any>>} */
+  /** @ignore @type {!Array.<ng.Injectable<any>>} */
   _runBlocks: Array<ng.Injectable<any>>;
-  _services: any[];
-  _restDefinitions: any[];
+  /** @ignore @type {!Array.<ng.Injectable<any>>} */
+  _services: Array<ng.Injectable<any>>;
+  /** @ignore @type {!Array.<ng.RestDefinition<any>>} */
+  _restDefinitions: Array<ng.RestDefinition<any>>;
   /**
    * @param {string} name
    * @param {any} object - Allows undefined
@@ -192,4 +199,28 @@ export class NgModule {
     entityClass: ng.EntityClass<T>,
     options?: any | undefined,
   ): NgModule;
+  /**
+   * Register a pre-configured SSE connection during module configuration.
+   *
+   * @param {string} name - Injectable name
+   * @param {string} url - SSE endpoint
+   * @param {ng.SseConfig} [options] - Optional SSE config
+   * @returns {NgModule}
+   */
+  sse(name: string, url: string, options?: ng.SseConfig): NgModule;
+  /**
+   * Register a pre-configured WebSocket connection during module configuration.
+   *
+   * @param {string} name - Injectable name
+   * @param {string} url - WebSocket endpoint
+   * @param {string[]} [protocols] - Optional subprotocols
+   * @param {ng.WebSocketConfig} [options] - Optional WebSocket configuration
+   * @returns {NgModule}
+   */
+  websocket(
+    name: string,
+    url: string,
+    protocols?: string[],
+    options?: ng.WebSocketConfig,
+  ): NgModule;
 }

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

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

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

@@ -8,14 +8,8 @@ export class AST {
   constructor(lexer: import("../lexer/lexer.js").Lexer);
   /** @type {import('../lexer/lexer.js').Lexer} */
   _lexer: import("../lexer/lexer.js").Lexer;
-  _selfReferential: {
-    this: {
-      type: number;
-    };
-    $locals: {
-      type: number;
-    };
-  };
+  /** @type {Record<string, any>} */
+  _selfReferential: Record<string, any>;
   _index: number;
   /**
    * Parses the input text and generates an AST.
@@ -124,9 +118,9 @@ export class AST {
   /**
    * Throws a syntax error.
    * @param {string} msg - The error message.
-   * @param {import("../lexer/lexer.js").Token} [token] - The token that caused the error.
+   * @param {import("../lexer/lexer.js").Token} token - The token that caused the error.
    */
-  _throwError(msg: string, token?: import("../lexer/lexer.js").Token): void;
+  _throwError(msg: string, token: import("../lexer/lexer.js").Token): void;
   /**
    * Consumes a token if it matches the expected type.
    * @param {string} [e1] - The expected token type.
@@ -140,13 +134,13 @@ export class AST {
   _peekToken(): import("../lexer/lexer.js").Token;
   /**
    * Checks if the next token matches any of the expected types.
-   * @param {...string} [expected] - The expected token types.
+   * @param {...string} expected - The expected token types.
    * @returns {import('../lexer/lexer.js').Token|boolean} The next token if it matches, otherwise false.
    */
   _peek(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
   /**
    * Consumes the next token if it matches any of the expected types.
-   * @param {...string} [expected] - The expected token types.
+   * @param {...string} expected - The expected token types.
    * @returns {import("../lexer/lexer.js").Token|boolean} The consumed token if it matches, otherwise false.
    */
   _expect(...expected: string[]): import("../lexer/lexer.js").Token | boolean;

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

@@ -16,5 +16,5 @@ export namespace ASTType {
   let _ObjectExpression: number;
   let _ThisExpression: number;
   let _LocalsExpression: number;
-  let NGValueParameter: number;
+  let _NGValueParameter: number;
 }

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

@@ -5,36 +5,21 @@ import type { Scope } from "../scope/scope.js";
  */
 export interface CompiledExpressionProps {
   /** Indicates if the expression is a literal. */
-  literal: boolean;
+  _literal: boolean;
   /** Indicates if the expression is constant. */
   constant: boolean;
   /** Optional flag for pure expressions. */
-  isPure?: boolean;
-  /** Indicates if the expression should be evaluated only once. */
-  oneTime: boolean;
+  _isPure?: boolean;
   /** AST node decorated with metadata. */
-  decoratedNode: DecoratedASTNode;
-  /**
-   * Optional custom watch delegate function for the expression.
-   * @param scope - The current scope.
-   * @param listener - A listener function.
-   * @param equalityCheck - Whether to use deep equality.
-   * @param expression - The compiled expression or string.
-   */
-  $$watchDelegate?: (
-    scope: Scope,
-    listener: Function,
-    equalityCheck: boolean,
-    expression: CompiledExpression | string | ((scope: Scope) => any),
-  ) => any;
+  _decoratedNode: DecoratedASTNode;
   /** Expression inputs; may be an array or a function. */
-  inputs: any[] | Function;
+  _inputs?: any[] | Function;
   /**
    * Optional assign function for two-way binding.
    * Assigns a value to a context.
    * If value is not provided, may return the getter.
    */
-  assign?: (context: any, value: any) => any;
+  _assign?: (context: any, value: any) => any;
 }
 /**
  * Expression function with context and optional locals/assign.
@@ -50,30 +35,13 @@ export type CompiledExpressionFunction = (
  */
 export type CompiledExpression = CompiledExpressionFunction &
   CompiledExpressionProps;
-/**
- * Map used for expressions that watch specific object keys.
- */
-export interface CompiledExpressionHandlerMap {
-  /** Indicates if the expression is a literal. */
-  literal: boolean;
-  /** Indicates if the expression is constant. */
-  constant: boolean;
-  /** Optional flag for pure expressions. */
-  isPure?: boolean;
-  /** Indicates if the expression should be evaluated only once. */
-  oneTime: boolean;
-  /** A map of property keys to observe. */
-  keyMap: Map<string, Function>;
-}
 /**
  * Parses a string or expression function into a compiled expression.
- * @param expression - The input expression (string or function).
+ * @param expression - The input expression to evaluate.
  * @param interceptorFn - Optional value transformer.
- * @param expensiveChecks - Whether to enable expensive change detection.
  * @returns A compiled expression.
  */
 export type ParseService = (
-  expression?: CompiledExpression | string | ((scope: Scope) => any),
-  interceptorFn?: (value: any, scope: Scope, locals: any) => any,
-  expensiveChecks?: boolean,
+  expression: string,
+  interceptorFn?: (value: any) => any,
 ) => CompiledExpression;