@angular-wave/angular.ts 0.10.0 → 0.12.0

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

@@ -1,3 +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).
@@ -15,3 +17,85 @@ export type RafScheduler = {
    */
   waitUntilQuiet(fn: () => void): void;
 };
+export interface AnimationHost {
+  /** Pause animation. */
+  pause?: () => void;
+  /** Resume animation. */
+  resume?: () => void;
+  /** End animation. */
+  end?: () => void;
+  /** Cancel animation. */
+  cancel?: () => void;
+  /** Report animation progress. */
+  progress?: (...args: any[]) => void;
+}
+export interface AnimateService {
+  on(
+    event: string,
+    container: Element,
+    callback: (
+      element: Element,
+      phase: QueuePhase,
+      data: {
+        addClass?: string | null;
+        removeClass?: string | null;
+        from?: Record<string, any> | null;
+        to?: Record<string, any> | null;
+      },
+    ) => void,
+  ): void;
+  off(event: string, container?: Element, callback?: Function): void;
+  pin(element: Element, parentElement: Element): void;
+  enabled(element?: Element, enabled?: boolean): boolean;
+  cancel(runner: AnimateRunner): void;
+  enter(
+    element: Element,
+    parent: Element,
+    after?: Element,
+    options?: AnimationOptions,
+  ): AnimateRunner;
+  move(
+    element: Element,
+    parent: Element,
+    after?: Element,
+    options?: AnimationOptions,
+  ): AnimateRunner;
+  leave(element: Element, options?: AnimationOptions): AnimateRunner;
+  addClass(
+    element: Element,
+    className: string,
+    options?: AnimationOptions,
+  ): AnimateRunner;
+  removeClass(
+    element: Element,
+    className: string,
+    options?: AnimationOptions,
+  ): AnimateRunner;
+  setClass(
+    element: Element,
+    add: string,
+    remove: string,
+    options?: AnimationOptions,
+  ): AnimateRunner;
+  animate(
+    element: Element,
+    from: Record<string, any>,
+    to: Record<string, any>,
+    className?: string,
+    options?: AnimationOptions,
+  ): AnimateRunner;
+}
+export type AnimationMethod =
+  | "enter"
+  | "leave"
+  | "move"
+  | "addClass"
+  | "setClass"
+  | "removeClass";
+export interface AnimationOptions {
+  addClass?: string;
+  from?: Record<string, string | number>;
+  removeClass?: string;
+  to?: Record<string, string | number>;
+  tempClasses: string | string[];
+}

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

@@ -0,0 +1,21 @@
+export function AnimateQueueProvider($animateProvider: any): void;
+export class AnimateQueueProvider {
+  constructor($animateProvider: any);
+  rules: {
+    skip: any[];
+    cancel: any[];
+    join: any[];
+  };
+  $get: (
+    | string
+    | ((
+        $rootScope: ng.RootScopeService,
+        $injector: ng.InjectorService,
+        $$animation: any,
+        $templateRequest: ng.TemplateRequestService,
+      ) => import("../queue/interface.ts").AnimateQueueService)
+  )[];
+}
+export namespace AnimateQueueProvider {
+  let $inject: string[];
+}

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

@@ -0,0 +1,50 @@
+import { AnimateRunner } from "../runner/animate-runner.js";
+export type QueuePhase =
+  | "start"
+  | "close"
+  | "cancel"
+  | "progress"
+  | "dom"
+  | string;
+export interface QueueAnimationData {
+  addClass: string | null;
+  removeClass: string | null;
+  from: Record<string, any> | null;
+  to: Record<string, any> | null;
+  [key: string]: any;
+}
+export interface AnimateQueueService {
+  on(
+    event: string,
+    container: Element,
+    callback?: (
+      el: Element,
+      phase: QueuePhase,
+      data: QueueAnimationData,
+    ) => void,
+  ): void;
+  off(
+    event: string,
+    container?: Element,
+    callback?: (
+      el: Element,
+      phase: QueuePhase,
+      data: QueueAnimationData,
+    ) => void,
+  ): void;
+  pin(element: Element, parent: Element): void;
+  push(
+    element: Element,
+    event: string,
+    options: {
+      addClass?: string | null;
+      removeClass?: string | null;
+      from?: Record<string, any> | null;
+      to?: Record<string, any> | null;
+      tempClasses?: string | string[] | null;
+      domOperation?: () => void;
+      [key: string]: any;
+    },
+    domOperation?: () => void,
+  ): AnimateRunner;
+}

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

@@ -0,0 +1,99 @@
+/**
+ * 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.
+   *
+   * @param {AnimateRunner[]} runners - Runners to execute in order.
+   * @param {(ok: boolean) => void} callback - Invoked when all complete or one fails.
+   */
+  static chain(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
+  /**
+   * Waits for all animation runners to complete before invoking the callback.
+   *
+   * @param {AnimateRunner[]} runners - Active runners to wait for.
+   * @param {(ok: boolean) => void} callback - Called when all runners complete.
+   */
+  static all(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
+  /**
+   * @param {import("../interface.ts").AnimationHost} [host] - Optional animation host.
+   */
+  constructor(host?: import("../interface.ts").AnimationHost);
+  /** @type {import("../interface.ts").AnimationHost} */
+  host: import("../interface.ts").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.
+   */
+  setHost(host: import("../interface.ts").AnimationHost): void;
+  /**
+   * Registers a callback to be called once the animation completes.
+   * If the animation is already complete, it's called immediately.
+   *
+   * @param {(ok: boolean) => void} fn - Completion callback.
+   */
+  done(fn: (ok: boolean) => void): void;
+  /**
+   * Notifies the host of animation progress.
+   * @param {...any} args - Progress arguments.
+   */
+  progress(...args: any[]): void;
+  /** Pauses the animation, if supported by the host. */
+  pause(): void;
+  /** Resumes the animation, if supported by the host. */
+  resume(): void;
+  /** Ends the animation successfully. */
+  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.
+   */
+  complete(status?: boolean): void;
+  /**
+   * Returns a promise that resolves or rejects when the animation completes.
+   * @returns {Promise<void>} Promise resolved on success or rejected on cancel.
+   */
+  getPromise(): Promise<void>;
+  /** @inheritdoc */
+  then(onFulfilled: any, onRejected: any): Promise<void>;
+  /** @inheritdoc */
+  catch(onRejected: any): Promise<void>;
+  /** @inheritdoc */
+  finally(onFinally: any): Promise<void>;
+  /**
+   * Completes the animation and invokes all done callbacks.
+   * @private
+   * @param {boolean} status - True if completed successfully, false if canceled.
+   */
+  private _finish;
+}
+/**
+ * Internal runner states.
+ */
+type RunnerState = number;
+declare namespace RunnerState {
+  let INITIAL: number;
+  let PENDING: number;
+  let DONE: number;
+}
+export {};

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

@@ -1,23 +1,23 @@
 export class Attributes {
   static $nonscope: boolean;
   /**
-   * @param {ng.Scope} $rootScope
-   * @param {*} $animate
+   * @param {ng.RootScopeService} $rootScope
+   * @param {ng.AnimateService} $animate
    * @param {ng.ExceptionHandlerService} $exceptionHandler
    * @param {*} $sce
    * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
    * @param {Object} [attributesToCopy]
    */
   constructor(
-    $rootScope: ng.Scope,
-    $animate: any,
+    $rootScope: ng.RootScopeService,
+    $animate: ng.AnimateService,
     $exceptionHandler: ng.ExceptionHandlerService,
     $sce: any,
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any,
   );
   $rootScope: import("../scope/scope.js").Scope;
-  $animate: any;
+  $animate: import("../../interface.ts").AnimateService;
   $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler;
   $sce: any;
   $attr: {};

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

@@ -124,15 +124,15 @@ export class CompileProvider {
   $get: (
     | string
     | ((
-        $injector: import("../../core/di/internal-injector.js").InjectorService,
+        $injector: ng.InjectorService,
         $interpolate: any,
         $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
-        $templateRequest: any,
-        $parse: import("../parse/interface.ts").ParseService,
+        $templateRequest: ng.TemplateRequestService,
+        $parse: ng.ParseService,
         $controller: any,
         $rootScope: import("../scope/scope.js").Scope,
         $sce: any,
-        $animate: any,
+        $animate: ng.AnimateService,
       ) => (
         compileNode: string | Element | Node | ChildNode | NodeList,
         transcludeFn?: import("./inteface.ts").TranscludeFn,

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

@@ -34,7 +34,7 @@ export class ControllerProvider {
   $get: (
     | string
     | ((
-        $injector: import("../../core/di/internal-injector.js").InjectorService,
+        $injector: ng.InjectorService,
       ) => import("./interface.ts").ControllerService)
   )[];
   /**

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

@@ -0,0 +1,26 @@
+/**
+ * @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}
+ */
+export function isClass(func: Function): boolean;
+/**
+ * @param {any} fn
+ * @param {boolean} [strictDi]
+ * @param {string} [name]
+ * @returns {Array<string>}
+ */
+export function annotate(
+  fn: any,
+  strictDi?: boolean,
+  name?: string,
+): Array<string>;

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

@@ -8,15 +8,4 @@ export function createInjector(
   modulesToLoad: Array<string | Function>,
   strictDi?: boolean,
 ): InjectorService;
-/**
- * @param {any} fn
- * @param {boolean} [strictDi]
- * @param {String} [name]
- * @returns {Array<string>}
- */
-export function annotate(
-  fn: any,
-  strictDi?: boolean,
-  name?: string,
-): Array<string>;
 import { InjectorService } from "./internal-injector.js";

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

@@ -45,9 +45,9 @@ declare class AbstractInjector {
   strictDi: boolean;
   /** @type {string[]} */
   path: string[];
-  /** @type {Object.<string, import("./ng-module.js").NgModule>} */
+  /** @type {Object.<string, ng.NgModule>} */
   modules: {
-    [x: string]: import("./ng-module.js").NgModule;
+    [x: string]: import("./ng-module/ng-module.js").NgModule;
   };
   /**
    * Get a service by name.

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

@@ -0,0 +1,197 @@
+/** @private */
+export const INJECTOR_LITERAL: "$injector";
+/** @private */
+export const COMPILE_LITERAL: "$compileProvider";
+/** @private */
+export const ANIMATION_LITERAL: "$animateProvider";
+/** @private */
+export const FILTER_LITERAL: "$filterProvider";
+/** @private */
+export const CONTROLLER_LITERAL: "$controllerProvider";
+/**
+ * Modules are collections of application configuration information for components:
+ * controllers, directives, filters, etc. They provide recipes for the injector
+ * to do the actual instantiation. A module itself has no behaviour but only state.
+ * A such, it acts as a data structure between the Angular instance and the injector service.
+ *
+ * Since this is an internal structure that is exposed only via the Angular instance,
+ * it contains no validation of the items it receives. It is up to the instantiator on
+ * modules to do the actual validation.
+ */
+export class NgModule {
+  /**
+   * @param {string} name - Name of the module
+   * @param {Array<string>} requires - List of modules which the injector will load before the current module
+   * @param {ng.Injectable<any>} [configFn]
+   */
+  constructor(
+    name: string,
+    requires: Array<string>,
+    configFn?: ng.Injectable<any>,
+  );
+  /**
+   * Name of the current module.
+   * @type {string}
+   */
+  name: string;
+  /**
+   * Array of module names that this module depends on.
+   * @type {string[]}
+   */
+  requires: string[];
+  /**
+   * Holds a collection of tasks, required to instantiate an angular component
+   * @type {!Array<Array<*>>}
+   */
+  invokeQueue: Array<Array<any>>;
+  /** @type {!Array<Array<*>>} */
+  configBlocks: Array<Array<any>>;
+  /** @type {!Array.<ng.Injectable<any>>} */
+  runBlocks: Array<ng.Injectable<any>>;
+  services: any[];
+  wasmModules: any[];
+  /**
+   * @param {string} name
+   * @param {any} object
+   * @returns {NgModule}
+   */
+  value(name: string, object: any): NgModule;
+  /**
+   * @param {string} name
+   * @param {any} object
+   * @returns {NgModule}
+   */
+  constant(name: string, object: any): NgModule;
+  /**
+   *
+   * @param {ng.Injectable<any>} configFn
+   * @returns {NgModule}
+   */
+  config(configFn: ng.Injectable<any>): NgModule;
+  /**
+   * @param {ng.Injectable<any>} block
+   * @returns {NgModule}
+   */
+  run(block: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Component} options
+   * @returns {NgModule}
+   */
+  component(name: string, options: ng.Component): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} providerFunction
+   * @returns {NgModule}
+   */
+  factory(name: string, providerFunction: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} serviceFunction
+   * @returns {NgModule}
+   */
+  service(name: string, serviceFunction: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} providerType
+   * @returns {NgModule}
+   */
+  provider(name: string, providerType: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} decorFn
+   * @returns {NgModule}
+   */
+  decorator(name: string, decorFn: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} directiveFactory
+   * @returns {NgModule}
+   */
+  directive(name: string, directiveFactory: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} animationFactory
+   * @returns {NgModule}
+   */
+  animation(name: string, animationFactory: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} filterFn
+   * @return {NgModule}
+   */
+  filter(name: string, filterFn: ng.Injectable<any>): NgModule;
+  /**
+   * @param {string} name
+   * @param {ng.Injectable<any>} ctlFn
+   * @returns {NgModule}
+   */
+  controller(name: string, ctlFn: ng.Injectable<any>): NgModule;
+  /**
+   * Register a named WebAssembly module that will be instantiated via $provide.
+   *
+   * @param {string} name - The injectable name used to access the instantiated WebAssembly module.
+   *
+   * @param {string} src - URL of the `.wasm` file to fetch and instantiate.
+   *
+   * @param {Object<string, any>} [imports] WebAssembly import object, passed to `WebAssembly.instantiate` or  `WebAssembly.instantiateStreaming`.
+   *
+   * @param {Object<string, any>} [opts] - Configuration object.
+   *
+   *   Supported keys:
+   *   - **raw**: `boolean`
+   *       - `false` (default): the injectable resolves to `instance.exports`
+   *         (ideal for plain WASM modules).
+   *       - `true`: the injectable resolves to the full instantiation result:
+   *         `{ instance, exports, module }`
+   *         (required for runtimes such as Go, Emscripten, wasm-bindgen, etc).
+   *
+   * @returns {NgModule}
+   */
+  wasm(
+    name: string,
+    src: string,
+    imports?: {
+      [x: string]: any;
+    },
+    opts?: {
+      [x: string]: any;
+    },
+  ): NgModule;
+  /**
+   * Register a named worker that will be instantiated via $provide.
+   *
+   * @param {string} name
+   * @param {string | URL} scriptPath
+   * @param {ng.WorkerConfig} [config]
+   * @returns {NgModule}
+   */
+  worker(
+    name: string,
+    scriptPath: string | URL,
+    config?: ng.WorkerConfig,
+  ): NgModule;
+  /**
+   * @param {string} name
+   * @param {Function} ctor
+   * @returns {NgModule}
+   */
+  session(name: string, ctor: Function): NgModule;
+  /**
+   * @param {string} name
+   * @param {Function} ctor
+   * @returns {NgModule}
+   */
+  local(name: string, ctor: Function): NgModule;
+  /**
+   * @param {string} name
+   * @param {Function} ctor
+   * @param {ng.StorageBackend} backendOrConfig
+   * @returns {NgModule}
+   */
+  store(
+    name: string,
+    ctor: Function,
+    backendOrConfig: ng.StorageBackend,
+  ): NgModule;
+}

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

@@ -1,9 +1,9 @@
 export class FilterProvider {
   static $inject: string[];
   /**
-   * @param {import('../../interface.ts').Provider} $provide
+   * @param {ng.ProvideService} $provide
    */
-  constructor($provide: import("../../interface.ts").Provider);
+  constructor($provide: ng.ProvideService);
   $provide: import("../../interface.ts").Provider;
   /**
    * @param {string|Record<string, ng.FilterFn>} name

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

@@ -0,0 +1,8 @@
+/**
+ * Sanitizer function that processes a URI string and optionally
+ * treats it as a media URL.
+ */
+export type SanitizerFn = (
+  uri: string | null | undefined,
+  isMediaUrl?: boolean,
+) => string | null | undefined;

package/@types/core/sanitize/sanitize-uri.d.ts

@@ -33,8 +33,11 @@ export class SanitizeUriProvider implements ServiceProvider {
     regexp?: RegExp | undefined,
   ): RegExp | SanitizeUriProvider;
   /**
-   * @returns {import("./interface").SanitizerFn}
+   * @returns {import("./interface.ts").SanitizerFn}
    */
-  $get(): any;
+  $get: (
+    | string
+    | (($window: ng.WindowService) => import("./interface.ts").SanitizerFn)
+  )[];
 }
 export type ServiceProvider = import("../../interface.ts").ServiceProvider;

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

@@ -5,10 +5,10 @@ export interface AsyncQueueTask {
   fn: (...args: any[]) => any;
   locals: Record<string, any>;
 }
-export type ListenerFunction = (newValue: any, originalTarget: object) => void;
+export type ListenerFn = (newValue?: any, originalTarget?: object) => void;
 export interface Listener {
   originalTarget: object;
-  listenerFn: ListenerFunction;
+  listenerFn: ListenerFn;
   watchFn: CompiledExpression;
   id: number;
   scopeId: number;

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

@@ -9,7 +9,13 @@ export function nextId(): number;
  *                                     or the original value if the target is not an object.
  */
 export function createScope(target?: any, context?: Scope): Scope;
+/**
+ * @param {any} target
+ * @returns {boolean}
+ */
+export function isUnsafeGlobal(target: any): boolean;
 export const $postUpdateQueue: any[];
+export let rootScope: any;
 export class RootScopeProvider {
   rootScope: Scope;
   $get: (
@@ -84,6 +90,7 @@ export class Scope {
   /** @type {boolean} */
   $$destroyed: boolean;
   scheduled: any[];
+  $scopename: any;
   /** @private */
   private propertyMap;
   /**
@@ -123,12 +130,12 @@ export class Scope {
    * function is invoked when changes to that property are detected.
    *
    * @param {string} watchProp - An expression to be watched in the context of this model.
-   * @param {import('./interface.ts').ListenerFunction} [listenerFn] - A function to execute when changes are detected on watched context.
+   * @param {ng.ListenerFn} [listenerFn] - A function to execute when changes are detected on watched context.
    * @param {boolean} [lazy] - A flag to indicate if the listener should be invoked immediately. Defaults to false.
    */
   $watch(
     watchProp: string,
-    listenerFn?: import("./interface.ts").ListenerFunction,
+    listenerFn?: ng.ListenerFn,
     lazy?: boolean,
   ): () => void;
   $new(childInstance: any): any;
@@ -176,5 +183,6 @@ export class Scope {
    * @returns {Scope|undefined}
    */
   $getById(id: string | number): Scope | undefined;
+  $searchByName(name: any): any;
   #private;
 }

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

@@ -1,3 +1,3 @@
-export const ngClassDirective: () => import("../../interface.ts").Directive;
-export const ngClassOddDirective: () => import("../../interface.ts").Directive;
-export const ngClassEvenDirective: () => import("../../interface.ts").Directive;
+export const ngClassDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassOddDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassEvenDirective: import("../../interface.ts").DirectiveFactory;