@angular-wave/angular.ts 0.9.9 → 0.10.0

package/@types/angular.d.ts

@@ -118,14 +118,14 @@ export class Angular {
    * @param {string} name The name of the module to create or retrieve.
    * @param {Array.<string>} [requires] If specified then new module is being created. If
    *        unspecified then the module is being retrieved for further configuration.
-   * @param {import("./interface.js").Injectable<any>} [configFn] Optional configuration function for the module that gets
+   * @param {import("./interface.ts").Injectable<any>} [configFn] Optional configuration function for the module that gets
    *        passed to {@link NgModule.config NgModule.config()}.
    * @returns {NgModule} A newly registered module.
    */
   module(
     name: string,
     requires?: Array<string>,
-    configFn?: import("./interface.js").Injectable<any>,
+    configFn?: import("./interface.ts").Injectable<any>,
   ): NgModule;
 }
 import { getController } from "./shared/dom.js";

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

@@ -4,7 +4,7 @@ export class AnimateJsProvider {
   $get: (
     | string
     | ((
-        $injector: any,
+        $injector: ng.InjectorService,
         $$AnimateRunner: any,
       ) => (
         element: any,

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

@@ -19,7 +19,6 @@ export class AnimateQueueProvider {
         off(event: any, container: any, callback: any, ...args: any[]): void;
         pin(element: any, parentElement: any): void;
         push(element: any, event: any, options: any, domOperation: any): any;
-        enabled(element: any, bool: any, ...args: any[]): any;
       })
   )[];
 }

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

@@ -1,9 +1,7 @@
 /**
- * @returns {import('../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngAnimateSwapDirective(
-  $animate: any,
-): import("../interface.ts").Directive;
+export function ngAnimateSwapDirective($animate: any): ng.Directive;
 export namespace ngAnimateSwapDirective {
   let $inject: string[];
 }

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

@@ -291,14 +291,14 @@ export class AnimateProvider {
          *
          * @param {Element} element - the element which will be inserted into the DOM
          * @param {Element} parent - the parent element which will append the element as a child (so long as the after element is not present)
-         * @param {Element} after - after the sibling element after which the element will be appended
+         * @param {Element} [after] - after the sibling element after which the element will be appended
          * @param {AnimationOptions} [options] - an optional collection of options/styles that will be applied to the element.
          * @returns {import('./animate-runner.js').AnimateRunner} the animation runner
          */
         enter(
           element: Element,
           parent: Element,
-          after: Element,
+          after?: Element,
           options?: AnimationOptions,
         ): import("./animate-runner.js").AnimateRunner;
         /**

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

@@ -1,6 +1,6 @@
 /**
- * @typedef {import('./interface.js').RafScheduler} RafScheduler
- * @typedef {import('../interface.js').ServiceProvider} ServiceProvider
+ * @typedef {import('./interface.ts').RafScheduler} RafScheduler
+ * @typedef {import('../interface.ts').ServiceProvider} ServiceProvider
  */
 /**
  * Service provider that creates a requestAnimationFrame-based scheduler.
@@ -33,5 +33,5 @@ export class RafSchedulerProvider {
    */
   $get(): RafScheduler;
 }
-export type RafScheduler = import("./interface.js").RafScheduler;
-export type ServiceProvider = import("../interface.js").ServiceProvider;
+export type RafScheduler = import("./interface.ts").RafScheduler;
+export type ServiceProvider = import("../interface.ts").ServiceProvider;

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

@@ -24,8 +24,36 @@ export function applyAnimationClassesFactory(): (
 ) => void;
 export function prepareAnimationOptions(options: any): any;
 export function applyAnimationStyles(element: any, options: any): void;
-export function applyAnimationFromStyles(element: any, options: any): void;
-export function applyAnimationToStyles(element: any, options: any): void;
+/**
+ * Applies initial animation styles to a DOM element.
+ *
+ * This function sets the element's inline styles using the properties
+ * 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.
+ */
+export function applyAnimationFromStyles(
+  element: HTMLElement,
+  options: {
+    from?: Partial<CSSStyleDeclaration> | null;
+  },
+): void;
+/**
+ * Applies final animation styles to a DOM element.
+ *
+ * This function sets the element's inline styles using the properties
+ * 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.
+ */
+export function applyAnimationToStyles(
+  element: HTMLElement,
+  options: {
+    to?: Partial<CSSStyleDeclaration> | null;
+  },
+): void;
 export function mergeAnimationDetails(
   element: any,
   oldAnimation: any,

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

@@ -1,20 +1,17 @@
-/**
- * @implements {Record<string, any>}
- */
-export class Attributes implements Record<string, any> {
+export class Attributes {
   static $nonscope: boolean;
   /**
-   * @param {import('../scope/scope.js').Scope} $rootScope
+   * @param {ng.Scope} $rootScope
    * @param {*} $animate
-   * @param {import("../../services/exception/exception-handler.js").ErrorHandler} $exceptionHandler
+   * @param {ng.ExceptionHandlerService} $exceptionHandler
    * @param {*} $sce
    * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
    * @param {Object} [attributesToCopy]
    */
   constructor(
-    $rootScope: import("../scope/scope.js").Scope,
+    $rootScope: ng.Scope,
     $animate: any,
-    $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
+    $exceptionHandler: ng.ExceptionHandlerService,
     $sce: any,
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any,

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

@@ -2,11 +2,11 @@ export const DirectiveSuffix: "Directive";
 export class CompileProvider {
   static $inject: string[];
   /**
-   * @param {import('../../interface.js').Provider} $provide
+   * @param {import('../../interface.ts').Provider} $provide
    * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $$sanitizeUriProvider
    */
   constructor(
-    $provide: import("../../interface.js").Provider,
+    $provide: import("../../interface.ts").Provider,
     $$sanitizeUriProvider: import("../sanitize/sanitize-uri.js").SanitizeUriProvider,
   );
   /**
@@ -26,7 +26,7 @@ export class CompileProvider {
   /**
    * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
    *    or an object map of components where the keys are the names and the values are the component definition objects.
-   * @param {import("../../interface.js").Component} options Component definition object (a simplified
+   * @param {import("../../interface.ts").Component} options Component definition object (a simplified
    *    {directive definition object}),
    *    with the following properties (all optional):
    *
@@ -69,7 +69,7 @@ export class CompileProvider {
    */
   component: (
     name: string | any,
-    options: import("../../interface.js").Component,
+    options: import("../../interface.ts").Component,
   ) => CompileProvider;
   /**
    * Retrieves or overrides the default regular expression that is used for determining trusted safe

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

@@ -35,7 +35,7 @@ export class ControllerProvider {
     | string
     | ((
         $injector: import("../../core/di/internal-injector.js").InjectorService,
-      ) => import("./interface.js").ControllerService)
+      ) => import("./interface.ts").ControllerService)
   )[];
   /**
    * Adds an identifier to the controller instance in the given locals' scope.

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

@@ -22,12 +22,12 @@ 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 {import("../../interface.js").Injectable<any>} [configFn]
+   * @param {import("../../interface.ts").Injectable<any>} [configFn]
    */
   constructor(
     name: string,
     requires: Array<string>,
-    configFn?: import("../../interface.js").Injectable<any>,
+    configFn?: import("../../interface.ts").Injectable<any>,
   );
   /**
    * Name of the current module.
@@ -46,8 +46,8 @@ export class NgModule {
   invokeQueue: Array<Array<any>>;
   /** @type {!Array<Array<*>>} */
   configBlocks: Array<Array<any>>;
-  /** @type {!Array.<import("../../interface.js").Injectable<any>>} */
-  runBlocks: Array<import("../../interface.js").Injectable<any>>;
+  /** @type {!Array.<import("../../interface.ts").Injectable<any>>} */
+  runBlocks: Array<import("../../interface.ts").Injectable<any>>;
   services: any[];
   /**
    * @param {string} name
@@ -110,47 +110,47 @@ export class NgModule {
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} decorFn
+   * @param {import("../../interface.ts").Injectable<any>} decorFn
    * @returns {NgModule}
    */
   decorator(
     name: string,
-    decorFn: import("../../interface.js").Injectable<any>,
+    decorFn: import("../../interface.ts").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} directiveFactory
+   * @param {import("../../interface.ts").Injectable<any>} directiveFactory
    * @returns {NgModule}
    */
   directive(
     name: string,
-    directiveFactory: import("../../interface.js").Injectable<any>,
+    directiveFactory: import("../../interface.ts").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} animationFactory
+   * @param {import("../../interface.ts").Injectable<any>} animationFactory
    * @returns {NgModule}
    */
   animation(
     name: string,
-    animationFactory: import("../../interface.js").Injectable<any>,
+    animationFactory: import("../../interface.ts").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} filterFn
+   * @param {import("../../interface.ts").Injectable<any>} filterFn
    * @return {NgModule}
    */
   filter(
     name: string,
-    filterFn: import("../../interface.js").Injectable<any>,
+    filterFn: import("../../interface.ts").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} ctlFn
+   * @param {import("../../interface.ts").Injectable<any>} ctlFn
    * @returns {NgModule}
    */
   controller(
     name: string,
-    ctlFn: import("../../interface.js").Injectable<any>,
+    ctlFn: import("../../interface.ts").Injectable<any>,
   ): NgModule;
 }

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

@@ -0,0 +1,18 @@
+import type { CompiledExpression } from "../parse/interface.ts";
+import { Scope } from "./scope.js";
+export interface AsyncQueueTask {
+  handler: Scope;
+  fn: (...args: any[]) => any;
+  locals: Record<string, any>;
+}
+export type ListenerFunction = (newValue: any, originalTarget: object) => void;
+export interface Listener {
+  originalTarget: object;
+  listenerFn: ListenerFunction;
+  watchFn: CompiledExpression;
+  id: number;
+  scopeId: number;
+  property: string[];
+  watchProp?: string;
+  foreignListener?: ProxyConstructor;
+}

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

@@ -9,42 +9,17 @@ export function nextId(): number;
  *                                     or the original value if the target is not an object.
  */
 export function createScope(target?: any, context?: Scope): Scope;
-/**
- * @typedef {Object} AsyncQueueTask
- * @property {Scope} handler
- * @property {Function} fn
- * @property {Object} locals
- */
 export const $postUpdateQueue: any[];
 export class RootScopeProvider {
   rootScope: Scope;
   $get: (
     | string
     | ((
-        exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
-        parse: import("../parse/interface.ts").ParseService,
+        exceptionHandler: ng.ExceptionHandlerService,
+        parse: ng.ParseService,
       ) => Scope)
   )[];
 }
-/**
- * Listener function definition.
- * @typedef {Object} Listener
- * @property {Object} originalTarget - The original target object.
- * @property {ListenerFunction} listenerFn - The function invoked when changes are detected.
- * @property {import("../parse/interface.ts").CompiledExpression} watchFn
- * @property {number} id - Deregistration id
- * @property {number} scopeId - The scope that created the Listener
- * @property {string[]} property
- * @property {string} [watchProp] - The original property to watch if different from observed key
- * @property {Proxy} [foreignListener]
- *
- */
-/**
- * Listener function type.
- * @callback ListenerFunction
- * @param {*} newValue - The new value of the changed property.
- * @param {Object} originalTarget - The original target object.
- */
 /**
  * Decorator for excluding objects from scope observability
  */
@@ -64,12 +39,12 @@ export class Scope {
    */
   constructor(context?: Scope, parent?: Scope);
   context: Scope;
-  /** @type {Map<string, Array<Listener>>} Watch listeners */
-  watchers: Map<string, Array<Listener>>;
+  /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners */
+  watchers: Map<string, Array<import("./interface.ts").Listener>>;
   /** @type {Map<String, Function[]>} Event listeners */
   $$listeners: Map<string, Function[]>;
-  /** @type {Map<string, Array<Listener>>} Watch listeners from other proxies */
-  foreignListeners: Map<string, Array<Listener>>;
+  /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
+  foreignListeners: Map<string, Array<import("./interface.ts").Listener>>;
   /** @type {Set<ProxyConstructor>} */
   foreignProxies: Set<ProxyConstructor>;
   /** @type {WeakMap<Object, Array<string>>} */
@@ -103,12 +78,14 @@ export class Scope {
    */
   $root: Scope;
   $parent: Scope;
-  /** @type {AsyncQueueTask[]} */
-  $$asyncQueue: AsyncQueueTask[];
+  /** @type {import('./interface.ts').AsyncQueueTask[]} */
+  $$asyncQueue: import("./interface.ts").AsyncQueueTask[];
   filters: any[];
   /** @type {boolean} */
   $$destroyed: boolean;
   scheduled: any[];
+  /** @private */
+  private propertyMap;
   /**
    * Intercepts and handles property assignments on the target object. If a new value is
    * an object, it will be recursively proxied.
@@ -140,56 +117,34 @@ export class Scope {
     property: string | number | symbol,
     proxy: ProxyConstructor,
   ): any;
-  propertyMap: {
-    $watch: any;
-    $new: any;
-    $newIsolate: any;
-    $destroy: any;
-    $eval: any;
-    $apply: any;
-    $postUpdate: any;
-    $isRoot: any;
-    $target: any;
-    $proxy: any;
-    $on: any;
-    $emit: any;
-    $broadcast: any;
-    $transcluded: any;
-    $handler: Scope;
-    $parent: Scope;
-    $root: Scope;
-    $children: Scope[];
-    $id: number;
-    $merge: any;
-    $getById: any;
-  };
   deleteProperty(target: any, property: any): boolean;
   /**
    * Registers a watcher for a property along with a listener function. The listener
    * 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 {ListenerFunction} [listenerFn] - A function to execute when changes are detected on watched context.
+   * @param {import('./interface.ts').ListenerFunction} [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?: ListenerFunction,
+    listenerFn?: import("./interface.ts").ListenerFunction,
     lazy?: boolean,
   ): () => void;
   $new(childInstance: any): any;
   $newIsolate(instance: any): any;
   $transcluded(parentInstance: any): any;
+  deregisterForeignKey(key: any, id: any): boolean;
   $eval(expr: any, locals: any): any;
   /**
    * @param {Object} newTarget
    */
   $merge(newTarget: any): void;
   /**
-   * @param {import('../../interface.js').Expression} expr
+   * @param {import('../../interface.ts').Expression} expr
    * @returns {any}
    */
-  $apply(expr: import("../../interface.js").Expression): any;
+  $apply(expr: import("../../interface.ts").Expression): any;
   /**
    * @param {string} name
    * @param {Function} listener
@@ -213,6 +168,7 @@ export class Scope {
    */
   $postUpdate(fn: Function): void;
   $destroy(): void;
+  $flushQueue(): void;
   /**
    * Searches the scope instance
    *
@@ -222,40 +178,3 @@ export class Scope {
   $getById(id: string | number): Scope | undefined;
   #private;
 }
-export type AsyncQueueTask = {
-  handler: Scope;
-  fn: Function;
-  locals: any;
-};
-/**
- * Listener function definition.
- */
-export type Listener = {
-  /**
-   * - The original target object.
-   */
-  originalTarget: any;
-  /**
-   * - The function invoked when changes are detected.
-   */
-  listenerFn: ListenerFunction;
-  watchFn: import("../parse/interface.ts").CompiledExpression;
-  /**
-   * - Deregistration id
-   */
-  id: number;
-  /**
-   * - The scope that created the Listener
-   */
-  scopeId: number;
-  property: string[];
-  /**
-   * - The original property to watch if different from observed key
-   */
-  watchProp?: string;
-  foreignListener?: ProxyConstructor;
-};
-/**
- * Listener function type.
- */
-export type ListenerFunction = (newValue: any, originalTarget: any) => any;

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

@@ -36,21 +36,19 @@ export namespace ngShowAriaDirective {
   let $inject_1: string[];
   export { $inject_1 as $inject };
 }
-export function ngMessagesAriaDirective(): {
-  restrict: string;
-  require: string;
-  link(_scope: any, elem: any, attr: any): void;
-};
+/**
+ * @return {ng.Directive}
+ */
+export function ngMessagesAriaDirective(): ng.Directive;
+/**
+ * @param $aria
+ * @param {ng.ParseService} $parse
+ * @return {ng.Directive}
+ */
 export function ngClickAriaDirective(
   $aria: any,
-  $parse: any,
-): {
-  restrict: string;
-  compile(
-    _elem: any,
-    attr: any,
-  ): (scope: any, elem: Element, attr: any) => void;
-};
+  $parse: ng.ParseService,
+): ng.Directive;
 export namespace ngClickAriaDirective {
   let $inject_2: string[];
   export { $inject_2 as $inject };

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

@@ -1,8 +1,8 @@
 export const REGEX_STRING_REGEXP: RegExp;
 /**
- * @type {Record<string, import("../../interface.js").DirectiveFactory>}
+ * @type {Record<string, import("../../interface.ts").DirectiveFactory>}
  */
 export const ngAttributeAliasDirectives: Record<
   string,
-  import("../../interface.js").DirectiveFactory
+  import("../../interface.ts").DirectiveFactory
 >;

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

@@ -2,7 +2,6 @@
  *
  * @param {ng.ParseService} $parse
  * @param {ng.ExceptionHandlerService} $exceptionHandler
- * @param {ng.WindowService} $window
  * @param {string} directiveName
  * @param {string} eventName
  * @returns {ng.Directive}
@@ -10,7 +9,6 @@
 export function createEventDirective(
   $parse: ng.ParseService,
   $exceptionHandler: ng.ExceptionHandlerService,
-  $window: ng.WindowService,
   directiveName: string,
   eventName: string,
 ): ng.Directive;

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

@@ -1,29 +1,12 @@
-/**
- * @typedef {"click" | "change" | "submit"} EventType
- */
 /**
  * Selects DOM event to listen for based on the element type.
  *
  * @param {Element} element - The DOM element to inspect.
- * @returns {EventType} The name of the event to listen for.
- */
-export function getEventNameForElement(element: Element): EventType;
-/**
- * Handles DOM manipulation based on a swap strategy and server-rendered HTML.
- *
- * @param {string} html - The HTML string returned from the server.
- * @param {import("./interface.ts").SwapModeType} swap
- * @param {Element} target - The target DOM element to apply the swap to.
- * @param {ng.Scope} scope
- * @param {ng.CompileService} $compile
+ * @returns {"click" | "change" | "submit"} The name of the event to listen for.
  */
-export function handleSwapResponse(
-  html: string,
-  swap: import("./interface.ts").SwapModeType,
-  target: Element,
-  scope: ng.Scope,
-  $compile: ng.CompileService,
-): void;
+export function getEventNameForElement(
+  element: Element,
+): "click" | "change" | "submit";
 /**
  * Creates an HTTP directive factory that supports GET, DELETE, POST, PUT.
  *
@@ -45,4 +28,3 @@ export const ngPostDirective: ng.DirectiveFactory;
 export const ngPutDirective: ng.DirectiveFactory;
 /** @type {ng.DirectiveFactory} */
 export const ngSseDirective: ng.DirectiveFactory;
-export type EventType = "click" | "change" | "submit";

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

@@ -1,10 +1,8 @@
 /**
  * @param {*}  $animate
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
-export function ngIfDirective(
-  $animate: any,
-): import("../../interface.ts").Directive;
+export function ngIfDirective($animate: any): ng.Directive;
 export namespace ngIfDirective {
   let $inject: string[];
 }

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

@@ -4,14 +4,14 @@
  * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
  * @param {*} $animate
  * @param {import('../../services/exception/interface.ts').ErrorHandler} $exceptionHandler
- * @returns {import('../../interface.js').Directive}
+ * @returns {import('../../interface.ts').Directive}
  */
 export function ngIncludeDirective(
   $templateRequest: any,
   $anchorScroll: import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction,
   $animate: any,
   $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler,
-): import("../../interface.js").Directive;
+): import("../../interface.ts").Directive;
 export namespace ngIncludeDirective {
   let $inject: string[];
 }

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

@@ -20,13 +20,13 @@ export namespace ngMessagesIncludeDirective {
 }
 export const ngMessageDirective: (
   any: any,
-) => import("../../interface.js").Directive;
+) => import("../../interface.ts").Directive;
 export const ngMessageExpDirective: (
   any: any,
-) => import("../../interface.js").Directive;
+) => import("../../interface.ts").Directive;
 export const ngMessageDefaultDirective: (
   any: any,
-) => import("../../interface.js").Directive;
+) => import("../../interface.ts").Directive;
 declare class NgMessageCtrl {
   /**
    * @param {Element} $element

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

@@ -1,9 +1,6 @@
 /**
  * @param {string} source - the name of the attribute to be observed
  * @param {string} prop - the scope property to be updated with attribute value
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
-export function ngObserveDirective(
-  source: string,
-  prop: string,
-): import("../../interface.ts").Directive;
+export function ngObserveDirective(source: string, prop: string): ng.Directive;