@angular-wave/angular.ts 0.15.0 → 0.15.2

package/@types/angular.d.ts

@@ -1,4 +1,7 @@
-export class Angular {
+export class Angular extends EventTarget {
+  constructor(submodule?: boolean);
+  /** @private @type {boolean} */
+  private _submodule;
   /** @private @type {!Array<string|any>} */
   private _bootsrappedModules;
   /** @public @type {ng.PubSubService} */

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

@@ -1,6 +1,25 @@
+/**
+ * @extends {Record<string, any>}
+ */
 export class Attributes {
   static $nonscope: boolean;
   /**
+   * Creates an Attributes instance.
+   *
+   * There are two construction modes:
+   *
+   * 1. **Fresh instance** (no `attributesToCopy`):
+   *    - Used when compiling a DOM element for the first time.
+   *    - Initializes a new `$attr` map to track normalized → DOM attribute names.
+   *
+   * 2. **Clone instance** (`attributesToCopy` provided):
+   *    - 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`).
+   *    - `$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
@@ -17,9 +36,13 @@ export class Attributes {
   _$animate: import("../../animations/interface.ts").AnimateService;
   _$exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
   _$sce: any;
+  /**
+   * 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.
+   */
   $attr: {};
   /** @type {import("../../shared/noderef.js").NodeRef} */
-  $nodeRef: import("../../shared/noderef.js").NodeRef;
+  _nodeRef: import("../../shared/noderef.js").NodeRef;
   /** @type {Node|Element} */
   get $$element(): Node | Element;
   /**
@@ -71,6 +94,7 @@ export class Attributes {
     attrName?: string | undefined,
   ): void;
   /**
+     * @template T
      * Observes an interpolated attribute.
      *
      * The observer function will be invoked once during the next `$digest` following
@@ -78,13 +102,13 @@ export class Attributes {
      * changes.
      *
      * @param {string} key Normalized key. (ie ngAttribute) .
-     * @param {any} fn Function that will be called whenever
+     * @param {(value?: T) => any} fn Function that will be called whenever
               the interpolated value of the attribute changes.
     *        See the {@link guide/interpolation#how-text-and-attribute-bindings-work Interpolation
     *        guide} for more info.
-    * @returns {function()} Returns a deregistration function for this observer.
+    * @returns {Function} Returns a deregistration function for this observer.
     */
-  $observe(key: string, fn: any): () => any;
+  $observe<T>(key: string, fn: (value?: T) => any): Function;
   $$observers: any;
   setSpecialAttr(element: any, attrName: any, value: any): void;
   /**

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

@@ -1,5 +1,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;
 /**
  * A function passed as the fifth argument to a `PublicLinkFn` link function.
  * It behaves like a linking function, with the `scope` argument automatically created
@@ -8,7 +10,8 @@ import type { NodeRef } from "../../shared/noderef.js";
  * The function returns the DOM content to be injected (transcluded) into the directive.
  */
 export type TranscludeFn = {
-  (clone?: Element | Node | ChildNode | NodeList | Node[], scope?: Scope): void;
+  (cb: TranscludeFnCb): void;
+  (scope: Scope, cb?: TranscludeFnCb): void;
   $$slots?: any;
 };
 /**
@@ -84,3 +87,4 @@ export type CompositeLinkFn = (
   $linkNode: NodeRef,
   parentBoundTranscludeFn?: Function,
 ) => void;
+export {};

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

@@ -0,0 +1,11 @@
+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>;
+}

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

@@ -53,4 +53,6 @@ export type ASTNode = {
   filter?: boolean;
   /** Indicates in node depends on non-shallow state of objects */
   isPure?: boolean;
+  /** Indicates the expression is a contant */
+  constant?: boolean;
 };

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

@@ -29,5 +29,8 @@ export class ParseProvider {
     identifierStart?: (arg0: any) => boolean,
     identifierContinue?: (arg0: any) => boolean,
   ) => ParseProvider;
-  $get: (string | (($filter: (any: any) => any) => any))[];
+  $get: (
+    | string
+    | (($filter: (any: any) => any) => import("./interface.ts").ParseService)
+  )[];
 }

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

@@ -10,3 +10,29 @@ export interface Listener {
   watchProp?: string;
   foreignListener?: ProxyConstructor;
 }
+export interface ScopeEvent {
+  /**
+   * the scope on which the event was $emit-ed or $broadcast-ed.
+   */
+  targetScope: 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;
+  /**
+   * name of the event.
+   */
+  name: string;
+  /**
+   * calling stopPropagation function will cancel further event propagation (available only for events that were $emit-ed).
+   */
+  stopPropagation?(): void;
+  /**
+   * calling preventDefault sets defaultPrevented flag to true.
+   */
+  preventDefault(): void;
+  /**
+   * true if preventDefault was called.
+   */
+  defaultPrevented: boolean;
+}

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

@@ -5,10 +5,10 @@
  *
  * @param {Object} target - The object to be wrapped in a proxy.
  * @param {Scope} [context] - The context for the handler, used to track listeners.
- * @returns {Scope} - A proxy that intercepts operations on the target object,
+ * @returns {Scope|Object} - A proxy that intercepts operations on the target object,
  *                                     or the original value if the target is not an object.
  */
-export function createScope(target?: any, context?: Scope): Scope;
+export function createScope(target?: any, context?: Scope): Scope | any;
 /**
  * @ignore
  * Checks if a target should be excluded from scope observability
@@ -19,13 +19,13 @@ export function isNonScope(target: any): boolean;
 /** @ignore @type {Function[]}*/
 export const $postUpdateQueue: Function[];
 export class RootScopeProvider {
-  rootScope: Scope;
+  rootScope: any;
   $get: (
     | string
     | ((
         exceptionHandler: ng.ExceptionHandlerService,
         parse: ng.ParseService,
-      ) => Scope)
+      ) => any)
   )[];
 }
 /**
@@ -45,22 +45,14 @@ export class Scope {
   context: Scope;
   /** @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<import('./interface.ts').Listener>>} Watch listeners from other proxies */
-  foreignListeners: Map<string, Array<import("./interface.ts").Listener>>;
-  /** @type {Set<Proxy<ng.Scope>>} */
-  foreignProxies: Set<ProxyConstructor>;
-  /** @type {WeakMap<Object, Array<string>>} */
-  objectListeners: WeakMap<any, Array<string>>;
-  /** @type {Map<Function, {oldValue: any, fn: Function}>} */
-  functionListeners: Map<
-    Function,
-    {
-      oldValue: any;
-      fn: Function;
-    }
-  >;
+  /** @private @type {Map<String, Function[]>} Event listeners */
+  private _listeners;
+  /** @private @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
+  private _foreignListeners;
+  /** @private @type {Set<Proxy<ng.Scope>>} */
+  private _foreignProxies;
+  /** @private @type {WeakMap<Object, Array<string>>} */
+  private _objectListeners;
   /** @type {Proxy<Scope>} Current proxy being operated on */
   $proxy: ProxyConstructor;
   /** @type {Scope} The actual proxy */
@@ -82,10 +74,10 @@ export class Scope {
    */
   $root: Scope;
   $parent: Scope;
-  filters: any[];
-  /** @type {boolean} */
-  $$destroyed: boolean;
-  scheduled: any[];
+  /** @ignore @type {boolean} */
+  _destroyed: boolean;
+  /** @private @type {import("./interface.ts").Listener[]} A list of scheduled Event listeners */
+  private _scheduled;
   $scopename: any;
   /** @private */
   private propertyMap;

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

@@ -3,16 +3,14 @@
  */
 export function ngBindDirective(): ng.Directive;
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngBindTemplateDirective(): import("../../interface.ts").Directive;
+export function ngBindTemplateDirective(): ng.Directive;
 /**
- * @param {import('../../core/parse/interface.ts').ParseService} $parse
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.ParseService} $parse
+ * @returns {ng.Directive}
  */
-export function ngBindHtmlDirective(
-  $parse: import("../../core/parse/interface.ts").ParseService,
-): import("../../interface.ts").Directive;
+export function ngBindHtmlDirective($parse: ng.ParseService): ng.Directive;
 export namespace ngBindHtmlDirective {
   let $inject: string[];
 }

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

@@ -4,26 +4,26 @@ export function setupValidity(instance: any): void;
  *   $nonscope: boolean,
  *   $addControl: Function,
  *   $getControls: () => any[],
- *   $$renameControl: Function,
+ *   _renameControl: Function,
  *   $removeControl: Function,
  *   $setValidity: Function | ((key: any, isValid: boolean, control: any) => any),
  *   $setDirty: Function,
  *   $setPristine: Function,
  *   $setSubmitted: Function,
- *   $$setSubmitted: Function
+ *   _setSubmitted: Function
  * }}
  */
 export const nullFormCtrl: {
   $nonscope: boolean;
   $addControl: Function;
   $getControls: () => any[];
-  $$renameControl: Function;
+  _renameControl: Function;
   $removeControl: Function;
   $setValidity: Function | ((key: any, isValid: boolean, control: any) => any);
   $setDirty: Function;
   $setPristine: Function;
   $setSubmitted: Function;
-  $$setSubmitted: Function;
+  _setSubmitted: Function;
 };
 export const PENDING_CLASS: "ng-pending";
 /**
@@ -87,7 +87,7 @@ export class FormController {
     $animate: ng.AnimateService,
     $interpolate: ng.InterpolateService,
   );
-  $$controls: any[];
+  _controls: any[];
   $name: string;
   /**
    * @property {boolean} $dirty True if user has already interacted with the form.
@@ -108,6 +108,7 @@ export class FormController {
   $$success: {};
   $pending: any;
   $$classCache: {};
+  $target: {};
   /**
    * Rollback all form controls pending updates to the `$modelValue`.
    *
@@ -154,9 +155,10 @@ export class FormController {
    * Likewise, adding a control to, or removing a control from the form is not reflected
    * in the shallow copy. That means you should get a fresh copy from `$getControls()` every time
    * you need access to the controls.
+   * @returns {ReadonlyArray<FormController>}
    */
-  $getControls(): any;
-  $$renameControl(control: any, newName: any): void;
+  $getControls(): ReadonlyArray<FormController>;
+  _renameControl(control: any, newName: any): void;
   /**
    * Deregister a control from the form.
    *
@@ -166,8 +168,9 @@ export class FormController {
    * form. `$dirty`, `$submitted` states will not be changed, because the expected behavior can be
    * different from case to case. For example, removing the only `$dirty` control from a form may or
    * may not mean that the form is still `$dirty`.
+   * @param {FormController } control
    */
-  $removeControl(control: any): void;
+  $removeControl(control: FormController): void;
   /**
    * Sets the form to a dirty state.
    *
@@ -203,7 +206,7 @@ export class FormController {
    * parent forms of the form.
    */
   $setSubmitted(): void;
-  $$setSubmitted(): void;
+  _setSubmitted(): void;
   set(object: any, property: any, controller: any): void;
   unset(object: any, property: any, controller: any): void;
   /**

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

@@ -1,4 +1,4 @@
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngInitDirective(): import("../../interface.ts").Directive;
+export function ngInitDirective(): ng.Directive;

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

@@ -1,20 +1,9 @@
-export function weekParser(isoWeek: any, existingDate: any): any;
-export function createDateParser(
-  regexp: any,
-  mapping: any,
-): (iso: any, previousDate: any) => any;
-export function createDateInputType(
-  type: any,
-  regexp: any,
-  parseDate: any,
-): (
-  scope: any,
-  element: any,
-  attr: any,
-  ctrl: any,
-  $filter: any,
-  $parse: any,
-) => void;
+/**
+ * @param {string} type
+ * @param {RegExp} regexp
+ * @returns {*}
+ */
+export function createStringDateInputType(type: string, regexp: RegExp): any;
 export function badInputChecker(
   scope: any,
   element: any,
@@ -35,7 +24,6 @@ export function numberInputType(
   element: any,
   attr: any,
   ctrl: any,
-  $filter: any,
   $parse: any,
 ): void;
 export function rangeInputType(
@@ -45,21 +33,17 @@ export function rangeInputType(
   ctrl: any,
 ): void;
 /**
- * @param {ng.FilterFactory} $filter
  * @param {ng.ParseService} $parse
  * @returns {ng.Directive}
  */
-export function inputDirective(
-  $filter: ng.FilterFactory,
-  $parse: ng.ParseService,
-): ng.Directive;
+export function inputDirective($parse: ng.ParseService): ng.Directive;
 export namespace inputDirective {
   let $inject: string[];
 }
 /**
  * @returns {ng.Directive}
  */
-export function hiddenInputBrowserCacheDirective(): ng.Directive;
+export function hiddenInputDirective(): ng.Directive;
 /**
  * @returns {ng.Directive}
  */

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

@@ -0,0 +1,4 @@
+/**
+ * @returns {ng.Directive}
+ */
+export function ngListenerDirective(): ng.Directive;

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

@@ -0,0 +1,18 @@
+export interface ModelValidators {
+  /**
+   * viewValue is any because it can be an object that is called in the view like $viewValue.name:$viewValue.subName
+   */
+  [index: string]: (modelValue: any, viewValue: any) => boolean;
+}
+export interface AsyncModelValidators {
+  [index: string]: (modelValue: any, viewValue: any) => Promise<any>;
+}
+export interface ModelParser {
+  (value: any): any;
+}
+export interface ModelFormatter {
+  (value: any): any;
+}
+export interface ModelViewChangeListener {
+  (): void;
+}

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

@@ -72,16 +72,16 @@ export class NgModelController {
   $modelValue: any;
   /** @type {any} */
   $$rawModelValue: any;
-  /** @type {any} */
-  $validators: any;
-  /** @type {any} */
-  $asyncValidators: any;
-  /** @type {Array<any>} */
-  $parsers: Array<any>;
-  /** @type {Array<any>} */
-  $formatters: Array<any>;
-  /** @type {Array<any>} */
-  $viewChangeListeners: Array<any>;
+  /** @type {import("./interface.ts").ModelValidators} */
+  $validators: import("./interface.ts").ModelValidators;
+  /** @type {import("./interface.ts").AsyncModelValidators} */
+  $asyncValidators: import("./interface.ts").AsyncModelValidators;
+  /** @type {Array<import("./interface.ts").ModelParser>} */
+  $parsers: Array<import("./interface.ts").ModelParser>;
+  /** @type {Array<import("./interface.ts").ModelFormatter>} */
+  $formatters: Array<import("./interface.ts").ModelFormatter>;
+  /** @type {Array<import("./interface.ts").ModelViewChangeListener>} */
+  $viewChangeListeners: Array<import("./interface.ts").ModelViewChangeListener>;
   /** @type {boolean} */
   $untouched: boolean;
   /** @type {boolean} */
@@ -102,7 +102,7 @@ export class NgModelController {
     $nonscope: boolean;
     $addControl: Function;
     $getControls: () => any[];
-    $$renameControl: Function;
+    _renameControl: Function;
     $removeControl: Function;
     $setValidity:
       | Function
@@ -110,7 +110,7 @@ export class NgModelController {
     $setDirty: Function;
     $setPristine: Function;
     $setSubmitted: Function;
-    $$setSubmitted: Function;
+    _setSubmitted: Function;
   };
   $options: {
     $$options: import("../model-options/model-options.js").ModelOptionsConfig;
@@ -125,16 +125,16 @@ export class NgModelController {
   };
   $$updateEvents: string;
   $$updateEventHandler(ev: any): void;
-  $$parsedNgModel: import("../../core/parse/interface.ts").CompiledExpression;
-  $$parsedNgModelAssign: (context: any, value: any) => any;
+  _parsedNgModel: import("../../core/parse/interface.ts").CompiledExpression;
+  _parsedNgModelAssign: (context: any, value: any) => any;
   /**
    * @type {import("../../core/parse/interface.ts").CompiledExpression |
    *        (function(ng.Scope): any)}
    */
-  $$ngModelGet:
+  _ngModelGet:
     | import("../../core/parse/interface.ts").CompiledExpression
     | ((arg0: ng.Scope) => any);
-  $$ngModelSet: (context: any, value: any) => any;
+  _ngModelSet: (context: any, value: any) => any;
   $$pendingDebounce: number;
   $$parserValid: boolean;
   /** @type {string} */
@@ -398,10 +398,12 @@ export class NgModelController {
    * **Note:** it is not possible to override the `getterSetter` option.
    * </div>
    *
-   * @param {Object} options a hash of settings to override the previous options
+   * @param {import("../../interface.ts").NgModelOptions} options a hash of settings to override the previous options
    *
    */
-  $overrideModelOptions(options: any): void;
+  $overrideModelOptions(
+    options: import("../../interface.ts").NgModelOptions,
+  ): void;
   /**
      * Runs the model -> view pipeline on the current
      * {@link ngModel.NgModelController#$modelValue $modelValue}.

package/@types/directive/non-bindable/non-bindable.d.ts

@@ -1,4 +1,4 @@
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngNonBindableDirective(): import("../../interface.ts").Directive;
+export function ngNonBindableDirective(): ng.Directive;

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

@@ -1,7 +1,7 @@
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function selectDirective(): import("../../interface.ts").Directive;
+export function selectDirective(): ng.Directive;
 /**
  * @param {ng.InterpolateService} $interpolate
  * @returns {ng.Directive}

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

@@ -1,12 +1,12 @@
 /**
  * @param {ng.ParseService} $parse
  * @param {ng.LogService} $log
- * @returns {import('interface.ts').Directive}
+ * @returns {ng.Directive}
  */
 export function ngSetterDirective(
   $parse: ng.ParseService,
   $log: ng.LogService,
-): any;
+): ng.Directive;
 export namespace ngSetterDirective {
   let $inject: string[];
 }

package/@types/directive/show-hide/show-hide.d.ts

@@ -7,11 +7,10 @@ export namespace ngShowDirective {
   let $inject: string[];
 }
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.AnimateService} $animate
+ * @returns {ng.Directive}
  */
-export function ngHideDirective(
-  $animate: any,
-): import("../../interface.ts").Directive;
+export function ngHideDirective($animate: ng.AnimateService): ng.Directive;
 export namespace ngHideDirective {
   let $inject_1: string[];
   export { $inject_1 as $inject };

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

@@ -7,10 +7,10 @@ export namespace ngSwitchDirective {
   let $inject: string[];
 }
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngSwitchWhenDirective(): import("../../interface.ts").Directive;
+export function ngSwitchWhenDirective(): ng.Directive;
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngSwitchDefaultDirective(): import("../../interface.ts").Directive;
+export function ngSwitchDefaultDirective(): ng.Directive;

package/@types/interface.d.ts

@@ -1,6 +1,9 @@
 import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
 import { NgModelController } from "./directive/model/model.js";
+export interface Constructor<T = any> {
+  new (...args: any[]): T;
+}
 export declare const PublicInjectionTokens: {
   readonly $angular: "$angular";
   readonly $attrs: "$attrs";
@@ -376,7 +379,7 @@ export interface DirectivePrePost {
  * A link function executed during directive linking.
  */
 export type DirectiveLinkFn<T> = (
-  scope: Scope,
+  scope: ng.Scope,
   element: HTMLElement,
   attrs: ng.Attributes,
   controller?: TController<T>,
@@ -462,6 +465,24 @@ export type CloneAttachFunction = (
   clonedElement?: Element,
   scope?: Scope,
 ) => any;
+export interface TemplateLinkingFunction {
+  (
+    scope: ng.Scope,
+    cloneAttachFn?: CloneAttachFunction,
+    options?: TemplateLinkingFunctionOptions,
+  ): Element;
+}
+export interface TemplateLinkingFunctionOptions {
+  parentBoundTranscludeFn?: TranscludeFunctionObject | undefined;
+  transcludeControllers?:
+    | {
+        [controller: string]: {
+          instance: Controller;
+        };
+      }
+    | undefined;
+  futureParentElement?: Element | undefined;
+}
 /**
  * Configuration for ngModel behavior.
  */