@angular-wave/angular.ts 0.15.1 → 0.16.0

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;

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

@@ -7,10 +7,11 @@ export const PURITY_ABSOLUTE: 1;
 export const PURITY_RELATIVE: 2;
 export class ASTInterpreter {
   /**
-   * @param {function(any):any} $filter
+   * @param {ng.FilterService} $filter
    */
-  constructor($filter: (arg0: any) => any);
-  _$filter: (arg0: any) => any;
+  constructor($filter: ng.FilterService);
+  /** @type {ng.FilterService} */
+  _$filter: ng.FilterService;
   /**
    * Compiles the AST into a function.
    * @param {import("./ast/ast.js").ASTNode} ast - The AST to compile.

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

@@ -1,28 +1,16 @@
-/**
- * @typedef {Object} LexerOptions
- * @property {(ch: string, codePoint: number) => boolean} [isIdentifierStart] - Custom function to determine if a character is a valid identifier start.
- * @property {(ch: string, codePoint: number) => boolean} [isIdentifierContinue] - Custom function to determine if a character is a valid identifier continuation.
- */
 /**
  * Represents a lexer that tokenizes input text. The Lexer takes the original expression string and returns an array of tokens parsed from that string.
  * For example, the string "a + b" would result in tokens for a, +, and b.
  */
 export class Lexer {
-  /**
-   * Creates an instance of Lexer.
-   * @param {LexerOptions} options - Lexer options.
-   */
-  constructor(options: LexerOptions);
-  /** @type {LexerOptions} */
-  _options: LexerOptions;
+  _text: string;
+  _index: number;
   /**
    * Tokenizes the input text.
    * @param {string} text Input text to lex.
    * @returns {Array<Token>} Array of tokens.
    */
   _lex(text: string): Array<Token>;
-  _text: string;
-  _index: number;
   /** @type {Array<Token>} */
   _tokens: Array<Token>;
   /**
@@ -62,12 +50,6 @@ export class Lexer {
    * @returns {boolean} True if character is a valid identifier continuation, false otherwise.
    */
   _isIdentifierContinue(ch: string): boolean;
-  /**
-   * Converts a character to its Unicode code point.
-   * @param {string} ch Character to convert.
-   * @returns {number} Unicode code point.
-   */
-  _codePointAt(ch: string): number;
   /**
    * Peeks at the next multicharacter sequence in the text.
    * @returns {string} Next multicharacter sequence.
@@ -107,13 +89,3 @@ export class Lexer {
   _handleUnicodeEscape(): string;
 }
 export type Token = import("./token.ts").Token;
-export type LexerOptions = {
-  /**
-   * - Custom function to determine if a character is a valid identifier start.
-   */
-  isIdentifierStart?: (ch: string, codePoint: number) => boolean;
-  /**
-   * - Custom function to determine if a character is a valid identifier continuation.
-   */
-  isIdentifierContinue?: (ch: string, codePoint: number) => boolean;
-};

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

@@ -1,36 +1,3 @@
-export function constantWatchDelegate(
-  scope: any,
-  listener: any,
-  objectEquality: any,
-  parsedExpression: any,
-): any;
 export class ParseProvider {
-  /**
-   * Allows defining the set of characters that are allowed in AngularTS expressions. The function
-   * `identifierStart` will get called to know if a given character is a valid character to be the
-   * first character for an identifier. The function `identifierContinue` will get called to know if
-   * a given character is a valid character to be a follow-up identifier character. The functions
-   * `identifierStart` and `identifierContinue` will receive as arguments the single character to be
-   * identifier and the character code point. These arguments will be `string` and `numeric`. Keep in
-   * mind that the `string` parameter can be two characters long depending on the character
-   * representation. It is expected for the function to return `true` or `false`, whether that
-   * character is allowed or not.
-   *
-   * Since this function will be called extensively, keep the implementation of these functions fast,
-   * as the performance of these functions have a direct impact on the expressions parsing speed.
-   *
-   * @param {function(any):boolean} [identifierStart] The function that will decide whether the given character is
-   *   a valid identifier start character.
-   * @param {function(any):boolean} [identifierContinue] The function that will decide whether the given character is
-   *   a valid identifier continue character.
-   * @returns {ParseProvider}
-   */
-  setIdentifierFns: (
-    identifierStart?: (arg0: any) => boolean,
-    identifierContinue?: (arg0: any) => boolean,
-  ) => ParseProvider;
-  $get: (
-    | string
-    | (($filter: (any: any) => any) => import("./interface.ts").ParseService)
-  )[];
+  $get: (string | (($filter: ng.FilterService) => ng.ParseService))[];
 }

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

@@ -1,7 +1,3 @@
-/**
- * @typedef {Object} ParsedAST
- * @property {import("../ast/ast-node.d.ts").ASTNode} ast - AST representation of expression
- */
 /**
  * @constructor
  */
@@ -9,11 +5,11 @@ export class Parser {
   /**
    *
    * @param {import('../lexer/lexer.js').Lexer} lexer
-   * @param {function(any):any} $filter
+   * @param {ng.FilterService} $filter
    */
   constructor(
     lexer: import("../lexer/lexer.js").Lexer,
-    $filter: (arg0: any) => any,
+    $filter: ng.FilterService,
   );
   /** @type {AST} */
   _ast: AST;
@@ -24,13 +20,6 @@ export class Parser {
    * @returns {import("../interface.ts").CompiledExpression}
    */
   _parse(exp: string): import("../interface.ts").CompiledExpression;
-  #private;
 }
-export type ParsedAST = {
-  /**
-   * - AST representation of expression
-   */
-  ast: import("../ast/ast-node.d.ts").ASTNode;
-};
 import { AST } from "../ast/ast.js";
 import { ASTInterpreter } from "../interpreter.js";

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

@@ -1,9 +1,9 @@
 /** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider */
 /**
  * Private service to sanitize uris for links and images. Used by $compile.
- * @implements {ServiceProvider}
+ * @extends {ServiceProvider}
  */
-export class SanitizeUriProvider implements ServiceProvider {
+export class SanitizeUriProvider {
   /**
    * @private
    * @type {RegExp}

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

@@ -1,5 +1,6 @@
 import type { CompiledExpression } from "../parse/interface.ts";
 export type ListenerFn = (newValue?: any, originalTarget?: object) => void;
+export type NonScope = string[] | boolean | undefined;
 export interface Listener {
   originalTarget: any;
   listenerFn: ListenerFn;

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

@@ -3,29 +3,33 @@
  * Creates a deep proxy for the target object, intercepting property changes
  * and recursively applying proxies to nested objects.
  *
- * @param {Object} target - The object to be wrapped in a proxy.
+ * @param {Object & {$nonscope?: import("./interface.ts").NonScope} & Record<string, any>} 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 & {
+    $nonscope?: import("./interface.ts").NonScope;
+  } & Record<string, any>,
+  context?: Scope,
+): Scope | any;
 /**
- * @ignore
  * Checks if a target should be excluded from scope observability
  * @param {any} target
  * @returns {boolean}
  */
 export function isNonScope(target: any): boolean;
-/** @ignore @type {Function[]}*/
+/** @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 +49,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,13 +78,14 @@ 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;
+  /** @type {Record<any, any>} */
+  propertyMap: Record<any, any>;
   /**
    * Intercepts and handles property assignments on the target object. If a new value is
    * an object, it will be recursively proxied.

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

@@ -62,7 +62,7 @@ export const PENDING_CLASS: "ng-pending";
  *  - `week`
  *  - `month`
  *
- * @description
+ *
  * `FormController` keeps track of all its controls and nested forms as well as the state of them,
  * such as being valid/invalid or dirty/pristine.
  *
@@ -101,13 +101,13 @@ export class FormController {
   $invalid: boolean;
   $submitted: boolean;
   /** @type {FormController|Object} */
-  $$parentForm: FormController | any;
-  $$element: Element;
-  $$animate: import("../../animations/interface.ts").AnimateService;
+  _parentForm: FormController | any;
+  _element: Element;
+  _animate: import("../../animations/interface.ts").AnimateService;
   $error: {};
-  $$success: {};
+  _success: {};
   $pending: any;
-  $$classCache: {};
+  _classCache: {};
   $target: {};
   /**
    * Rollback all form controls pending updates to the `$modelValue`.
@@ -237,41 +237,9 @@ export class FormController {
 }
 export const formDirective: (
   | string
-  | (($parse: any) => {
-      name: string;
-      restrict: string;
-      require: string[];
-      controller: typeof FormController;
-      compile: (
-        formElement: any,
-        attr: any,
-      ) => {
-        pre: (
-          scope: any,
-          formElementParam: any,
-          attrParam: any,
-          ctrls: any,
-        ) => void;
-      };
-    })
+  | (($parse: ng.ParseService) => ng.Directive)
 )[];
 export const ngFormDirective: (
   | string
-  | (($parse: any) => {
-      name: string;
-      restrict: string;
-      require: string[];
-      controller: typeof FormController;
-      compile: (
-        formElement: any,
-        attr: any,
-      ) => {
-        pre: (
-          scope: any,
-          formElementParam: any,
-          attrParam: any,
-          ctrls: any,
-        ) => void;
-      };
-    })
+  | (($parse: ng.ParseService) => 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,41 +33,21 @@ 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}
  */
 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/model/model.d.ts

@@ -71,7 +71,7 @@ export class NgModelController {
   /** @type {any} The value in the model that the control is bound to. */
   $modelValue: any;
   /** @type {any} */
-  $$rawModelValue: any;
+  _rawModelValue: any;
   /** @type {import("./interface.ts").ModelValidators} */
   $validators: import("./interface.ts").ModelValidators;
   /** @type {import("./interface.ts").AsyncModelValidators} */
@@ -95,10 +95,10 @@ export class NgModelController {
   /** @type {boolean} */
   $invalid: boolean;
   $error: {};
-  $$success: {};
+  _success: {};
   $pending: any;
   $name: string;
-  $$parentForm: {
+  _parentForm: {
     $nonscope: boolean;
     $addControl: Function;
     $getControls: () => any[];
@@ -113,7 +113,7 @@ export class NgModelController {
     _setSubmitted: Function;
   };
   $options: {
-    $$options: import("../model-options/model-options.js").ModelOptionsConfig;
+    _options: import("../model-options/model-options.js").ModelOptionsConfig;
     getOption(name: string):
       | string
       | boolean
@@ -123,8 +123,8 @@ export class NgModelController {
         };
     createChild(options: ModelOptionsConfig): /*elided*/ any;
   };
-  $$updateEvents: string;
-  $$updateEventHandler(ev: any): void;
+  _updateEvents: string;
+  _updateEventHandler(ev: any): void;
   _parsedNgModel: import("../../core/parse/interface.ts").CompiledExpression;
   _parsedNgModelAssign: (context: any, value: any) => any;
   /**
@@ -135,26 +135,26 @@ export class NgModelController {
     | import("../../core/parse/interface.ts").CompiledExpression
     | ((arg0: ng.Scope) => any);
   _ngModelSet: (context: any, value: any) => any;
-  $$pendingDebounce: number;
-  $$parserValid: boolean;
+  _pendingDebounce: number;
+  _parserValid: boolean;
   /** @type {string} */
-  $$parserName: string;
+  _parserName: string;
   /** @type {number} */
-  $$currentValidationRunId: number;
+  _currentValidationRunId: number;
   /** @type {ng.Scope} */
-  $$scope: ng.Scope;
-  $$attr: ng.Attributes;
-  $$element: Element;
-  $$animate: import("../../animations/interface.ts").AnimateService;
-  $$parse: import("../../core/parse/interface.ts").ParseService;
-  $$exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
-  $$hasNativeValidators: boolean;
-  $$classCache: {};
-  $$eventRemovers: Set<any>;
+  _scope: ng.Scope;
+  _attr: ng.Attributes;
+  _element: Element;
+  _animate: import("../../animations/interface.ts").AnimateService;
+  _parse: import("../../core/parse/interface.ts").ParseService;
+  _exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
+  _hasNativeValidators: boolean;
+  _classCache: {};
+  _eventRemovers: Set<any>;
   set(object: any, property: any): void;
   unset(object: any, property: any): void;
   $setValidity(validationErrorKey: any, state: any): void;
-  $$initGetterSetters(): void;
+  _initGetterSetters(): void;
   /**
    * Called when the view needs to be updated. It is expected that the user of the ng-model
    * directive will implement this method.
@@ -187,7 +187,7 @@ export class NgModelController {
    * @returns {boolean} True if `value` is "empty".
    */
   $isEmpty(value: any): boolean;
-  $$updateEmptyClasses(value: any): void;
+  _updateEmptyClasses(value: any): void;
   /**
    * Sets the control to its pristine state.
    *
@@ -316,7 +316,7 @@ export class NgModelController {
    * `$modelValue`, i.e. either the last parsed value or the last value set from the scope.
    */
   $validate(): void;
-  $$runValidators(modelValue: any, viewValue: any, doneCallback: any): void;
+  _runValidators(modelValue: any, viewValue: any, doneCallback: any): void;
   /**
    * Commit a pending update to the `$modelValue`.
    *
@@ -325,9 +325,9 @@ export class NgModelController {
    * usually handles calling this in response to input events.
    */
   $commitViewValue(): void;
-  $$lastCommittedViewValue: any;
-  $$parseAndValidate(): void;
-  $$writeModelToScope(): void;
+  _lastCommittedViewValue: any;
+  _parseAndValidate(): void;
+  _writeModelToScope(): void;
   /**
    * Update the view value.
    *
@@ -376,7 +376,7 @@ export class NgModelController {
    * @param {string} [trigger] Event that triggered the update.
    */
   $setViewValue(value: any, trigger?: string): void;
-  $$debounceViewValueCommit(trigger: any): void;
+  _debounceViewValueCommit(trigger: any): void;
   /**
    *
    * Override the current model options settings programmatically.
@@ -513,11 +513,15 @@ export class NgModelController {
   /**
    * This method is called internally to run the $formatters on the $modelValue
    */
-  $$format(): any;
+  _format(): any;
   /**
+   * @ignore
    * This method is called internally when the bound scope value changes.
    */
-  $$setModelValue(modelValue: any): void;
-  $$removeAllEventListeners(): void;
-  $$setUpdateOnEvents(): void;
+  _setModelValue(modelValue: any): void;
+  /**
+   * @ignore
+   */
+  _removeAllEventListeners(): void;
+  _setUpdateOnEvents(): void;
 }

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

@@ -27,7 +27,6 @@ export type ModelOptionsConfig = {
   updateOnDefault?: boolean;
 };
 /**
- * @description
  * A container for the options set by the {@link ngModelOptions} directive
  */
 declare class ModelOptions {
@@ -37,7 +36,7 @@ declare class ModelOptions {
    */
   constructor(options: ModelOptionsConfig);
   /** @type {ModelOptionsConfig} */
-  $$options: ModelOptionsConfig;
+  _options: ModelOptionsConfig;
   /**
    * Returns the value of the given option
    * @param {string} name the name of the option to retrieve

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

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