@angular-wave/angular.ts 0.15.0 → 0.15.1

package/@types/angular.d.ts

@@ -1,4 +1,4 @@
-export class Angular {
+export class Angular extends EventTarget {
   /** @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/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

@@ -64,6 +64,22 @@ export function hiddenInputBrowserCacheDirective(): ng.Directive;
  * @returns {ng.Directive}
  */
 export function ngValueDirective(): ng.Directive;
+/**
+ * @param {Date} date
+ * @param {any} timezone
+ * @param {undefined} [reverse]
+ */
+export function convertTimezoneToLocal(
+  date: Date,
+  timezone: any,
+  reverse?: undefined,
+): Date;
+/**
+ * @param {any} timezone
+ * @param {number} [fallback]
+ * @returns {number}
+ */
+export function timezoneToOffset(timezone: any, fallback?: number): number;
 export const ISO_DATE_REGEXP: RegExp;
 export const URL_REGEXP: RegExp;
 export const EMAIL_REGEXP: RegExp;

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,9 @@ export namespace ngShowDirective {
   let $inject: string[];
 }
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngHideDirective(
-  $animate: any,
-): import("../../interface.ts").Directive;
+export function ngHideDirective($animate: any): 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.
  */

package/@types/namespace.d.ts

@@ -5,6 +5,7 @@ import { Scope as TScope } from "./core/scope/scope.js";
 import {
   ListenerFn as TListenerFn,
   Listener as TListener,
+  ScopeEvent as TScopeEvent,
 } from "./core/scope/interface.ts";
 import { NgModule as TNgModule } from "./core/di/ng-module/ng-module.js";
 import { InjectorService as TInjectorService } from "./core/di/internal-injector.js";
@@ -107,6 +108,10 @@ import { StateObject as TStateObject } from "./router/state/state-object.js";
 import { StateRegistryProvider as TStateRegistryProvider } from "./router/state/state-registry.js";
 import { ViewScrollService as TViewScrollService } from "./router/scroll/interface.ts";
 import { HookRegistry } from "./router/transition/interface.ts";
+import {
+  SCEService as TSCEService,
+  SCEDelegateService as TSCEDelegateService,
+} from "./services/sce/interface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
@@ -166,6 +171,8 @@ declare global {
     type RouterService = TRouterProvider;
     type StateService = TStateProvider;
     type StateRegistryService = TStateRegistryProvider;
+    type SCEService = TSCEService;
+    type SCEDelegateService = TSCEDelegateService;
     type SseService = TSseService;
     type SseConfig = TSseConfig;
     type TransitionService = TransitionProvider & HookRegistry;
@@ -179,7 +186,7 @@ declare global {
     type Listener = TListener;
     type DocumentService = Document;
     type WindowService = Window;
-    type AngularServie = Angular;
+    type AngularService = Angular;
     type WorkerConfig = TWorkerConfig;
     type WorkerConnection = TWorkerConnection;
     type Injectable<
@@ -206,5 +213,6 @@ declare global {
     type AnchorScrollFunction = TAnchorScrollFunction;
     type AnchorScrollObject = TAnchorScrollObject;
     type InjectionTokens = typeof PublicInjectionTokens;
+    type ScopeEvent = TScopeEvent;
   }
 }

package/@types/router/router.d.ts

@@ -16,15 +16,17 @@ export class RouterProvider {
   /**
    * @type {number}
    */
-  lastStartedTransitionId: number;
+  _lastStartedTransitionId: number;
   /**
    * @type {Queue<import("./transition/transition.js").Transition>}
    */
-  transitionHistory: Queue<import("./transition/transition.js").Transition>;
+  _transitionHistory: Queue<import("./transition/transition.js").Transition>;
   /**
    * @type {Queue<import("./transition/transition.js").Transition>}
    */
-  successfulTransitions: Queue<import("./transition/transition.js").Transition>;
+  _successfulTransitions: Queue<
+    import("./transition/transition.js").Transition
+  >;
   /**
    * @type {import("./state/interface.ts").StateDeclaration|undefined}
    */

package/@types/router/scroll/interface.d.ts

@@ -1,3 +1,3 @@
 export type ViewScrollService =
   | ng.AnchorScrollService
-  | ((el: Element) => void | Promise<void>);
+  | ((element: Element) => void);

package/@types/router/state/interface.d.ts

@@ -14,7 +14,9 @@ import {
 } from "../resolve/interface.ts";
 import { Resolvable } from "../resolve/resolvable.js";
 import { TargetState } from "./target-state.js";
+import { Glob } from "../glob/glob.js";
 export type StateOrName = string | StateDeclaration | StateObject;
+export type StateStore = Record<string, StateObject | BuiltStateDeclaration>;
 export interface TransitionPromise extends Promise<StateObject> {
   transition: Transition;
 }
@@ -826,6 +828,9 @@ export type BuiltStateDeclaration = StateDeclaration & {
   parent?: BuiltStateDeclaration | null;
   /** Optional inherited data */
   data?: any;
+  _stateObjectCache?: {
+    nameGlob: Glob;
+  } | null;
 };
 /**
  * The return type of a [[StateDeclaration.lazyLoad]] function

package/@types/router/state/state-builder.d.ts

@@ -58,18 +58,22 @@ export function resolvablesBuilder(
 export class StateBuilder {
   /**
    * @param {import('./state-matcher.js').StateMatcher} matcher
-   * @param urlService
+   * @param {ng.UrlService} urlService
    */
   constructor(
     matcher: import("./state-matcher.js").StateMatcher,
-    urlService: any,
+    urlService: ng.UrlService,
   );
-  matcher: import("./state-matcher.js").StateMatcher;
-  $injector: any;
-  builders: {
+  _matcher: import("./state-matcher.js").StateMatcher;
+  _$injector: any;
+  _builders: {
     name: ((state: any) => any)[];
     self: (typeof selfBuilder)[];
-    parent: ((state: any) => any)[];
+    parent: ((
+      state: any,
+    ) =>
+      | import("./state-object.js").StateObject
+      | import("./interface.ts").BuiltStateDeclaration)[];
     data: (typeof dataBuilder)[];
     url: ((stateObject: any) => any)[];
     navigable: ((state: any) => any)[];

package/@types/router/state/state-matcher.d.ts

@@ -1,7 +1,15 @@
 export class StateMatcher {
-  constructor(_states: any);
-  _states: any;
+  /** @param {import("./interface.ts").StateStore} states */
+  constructor(states: import("./interface.ts").StateStore);
+  /** @type {import("./interface.ts").StateStore} */
+  _states: import("./interface.ts").StateStore;
   isRelative(stateName: any): boolean;
-  find(stateOrName: any, base: any, matchGlob?: boolean): any;
+  find(
+    stateOrName: any,
+    base: any,
+    matchGlob?: boolean,
+  ):
+    | import("./state-object.js").StateObject
+    | import("./interface.ts").BuiltStateDeclaration;
   resolvePath(name: any, base: any): string;
 }