@angular-wave/angular.ts 0.15.2 → 0.16.1

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

@@ -1,25 +1,29 @@
 import { ASTType } from "../ast-type.js";
-/**
- * Represents a node in an Abstract Syntax Tree (AST).
- */
-export type ASTNode = {
+/** The kind of an object property */
+export type PropertyKind = "init" | "get" | "set";
+/** Base properties for all AST nodes */
+interface BaseNode {
   /** The type of the AST node. */
   type: ASTType;
-  /** The name of the identifier, if applicable. */
-  name?: string;
-  /** The kind of the property (e.g., 'init'). */
-  kind?: string;
-  /** The value of the node if it is a literal. */
-  value?: any;
-  /** The elements of an array node. */
-  elements?: ASTNode[];
-  /** The properties of an object node. */
-  properties?: ASTNode[];
-  /** The key of an object property. */
-  key?: ASTNode;
-  /** The left-hand side of a binary expression. */
+  /** Indicates whether the node depends on non-shallow state. */
+  isPure?: boolean;
+  /** Indicates whether the expression is a constant. */
+  constant?: boolean;
+}
+/** A node that contains a list of statements, e.g., Program or BlockStatement */
+export interface BodyNode extends BaseNode {
+  /** The body of the program or block. Always present; empty if no statements. */
+  body: ASTNode[];
+  /** Optional list of expressions to observe for changes (Angular-specific). */
+  toWatch: ASTNode[];
+}
+/** Expression nodes, e.g., BinaryExpression, UnaryExpression, ConditionalExpression, CallExpression, MemberExpression */
+export interface ExpressionNode extends BaseNode {
+  /** The single expression contained by an ExpressionStatement. */
+  expression?: ASTNode;
+  /** The left-hand side of a binary or logical expression. */
   left?: ASTNode;
-  /** The right-hand side of a binary expression. */
+  /** The right-hand side of a binary or logical expression. */
   right?: ASTNode;
   /** The argument of a unary expression. */
   argument?: ASTNode;
@@ -29,30 +33,63 @@ export type ASTNode = {
   alternate?: ASTNode;
   /** The consequent expression of a conditional expression. */
   consequent?: ASTNode;
-  /** The body of a program or block statement. */
-  body?: ASTNode[];
-  /** A list of expressions to observe in a program or block statement. */
-  toWatch?: ASTNode[];
-  /** The expression of an expression statement. */
-  expression?: ASTNode;
-  /** The callee of a call expression. */
+  /** The callee of a function or method call expression. */
   callee?: ASTNode;
-  /** The arguments of a call expression. */
+  /** The arguments of a function or method call expression. */
   arguments?: ASTNode[];
-  /** Indicates if a unary operator is a prefix. */
-  prefix?: boolean;
-  /** The object of a member expression. */
+  /** The object of a member expression (e.g., `obj` in `obj.prop`). */
   object?: ASTNode;
-  /** The property of a member expression. */
+  /** The property of a member expression (e.g., `prop` in `obj.prop`). */
   property?: ASTNode;
-  /** Indicates if a member expression is computed. */
+  /** Indicates if the member expression is computed (`obj[prop]` vs `obj.prop`). */
   computed?: boolean;
-  /** The operator of a binary or logical expression. */
+  /** The operator of a binary or logical expression, e.g., "+", "*", "&&". */
   operator?: string;
-  /** Indicates if the expression should be filtered. */
+  /** Indicates if the expression should be filtered (Angular-specific). */
   filter?: boolean;
-  /** Indicates in node depends on non-shallow state of objects */
-  isPure?: boolean;
-  /** Indicates the expression is a contant */
-  constant?: boolean;
-};
+  /** Indicates if the unary operator is a prefix, e.g., `++i` vs `i++`. */
+  prefix?: boolean;
+}
+/** Leaf node representing a literal or identifier */
+export interface LiteralNode extends BaseNode {
+  /** The value of a literal node, e.g., number, string, boolean. */
+  value?: any;
+  /** The name of an identifier node. */
+  name?: string;
+}
+/** Node representing an array literal */
+export interface ArrayNode extends BaseNode {
+  /** The elements of the array. */
+  elements: ASTNode[];
+}
+/** Node representing an object literal */
+export interface ObjectNode extends BaseNode {
+  /** The properties of the object. */
+  properties: ASTNode[];
+}
+/** Node representing a single property of an object literal */
+export interface ObjectPropertyNode extends BaseNode {
+  /** Property kind (only "init" is used in Angular expressions) */
+  kind: "init";
+  /** Property key: identifier, literal, or expression */
+  key: ASTNode;
+  /** Property value expression */
+  value: ASTNode;
+  /** Whether the property key is computed (`{ [expr]: value }`) */
+  computed: boolean;
+}
+/** Statement node that wraps an expression */
+export interface ExpressionStatementNode extends BaseNode {
+  /** The expression contained in this statement. */
+  expression: ASTNode;
+}
+/** The union type covering all AST nodes */
+export type ASTNode =
+  | BodyNode
+  | ExpressionNode
+  | LiteralNode
+  | ArrayNode
+  | ObjectNode
+  | ObjectPropertyNode
+  | ExpressionStatementNode;
+export {};

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

@@ -1,6 +1,3 @@
-/**
- * @class
- */
 export class AST {
   /**
    * @param {import('../lexer/lexer.js').Lexer} lexer - The lexer instance for tokenizing input
@@ -8,14 +5,8 @@ export class AST {
   constructor(lexer: import("../lexer/lexer.js").Lexer);
   /** @type {import('../lexer/lexer.js').Lexer} */
   _lexer: import("../lexer/lexer.js").Lexer;
-  _selfReferential: {
-    this: {
-      type: number;
-    };
-    $locals: {
-      type: number;
-    };
-  };
+  /** @type {Record<string, any>} */
+  _selfReferential: Record<string, any>;
   _index: number;
   /**
    * Parses the input text and generates an AST.
@@ -124,9 +115,9 @@ export class AST {
   /**
    * Throws a syntax error.
    * @param {string} msg - The error message.
-   * @param {import("../lexer/lexer.js").Token} [token] - The token that caused the error.
+   * @param {import("../lexer/lexer.js").Token} token - The token that caused the error.
    */
-  _throwError(msg: string, token?: import("../lexer/lexer.js").Token): void;
+  _throwError(msg: string, token: import("../lexer/lexer.js").Token): void;
   /**
    * Consumes a token if it matches the expected type.
    * @param {string} [e1] - The expected token type.
@@ -140,13 +131,13 @@ export class AST {
   _peekToken(): import("../lexer/lexer.js").Token;
   /**
    * Checks if the next token matches any of the expected types.
-   * @param {...string} [expected] - The expected token types.
+   * @param {...string} expected - The expected token types.
    * @returns {import('../lexer/lexer.js').Token|boolean} The next token if it matches, otherwise false.
    */
   _peek(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
   /**
    * Consumes the next token if it matches any of the expected types.
-   * @param {...string} [expected] - The expected token types.
+   * @param {...string} expected - The expected token types.
    * @returns {import("../lexer/lexer.js").Token|boolean} The consumed token if it matches, otherwise false.
    */
   _expect(...expected: string[]): import("../lexer/lexer.js").Token | boolean;

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

@@ -16,5 +16,5 @@ export namespace ASTType {
   let _ObjectExpression: number;
   let _ThisExpression: number;
   let _LocalsExpression: number;
-  let NGValueParameter: number;
+  let _NGValueParameter: number;
 }

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

@@ -1,40 +1,25 @@
-import type { DecoratedASTNode } from "./interpreter.js";
 import type { Scope } from "../scope/scope.js";
+import { BodyNode } from "./ast/ast-node.ts";
 /**
  * Describes metadata and behavior for a compiled AngularTS expression.
  */
 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: BodyNode;
   /** 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

@@ -3,22 +3,30 @@
  * @returns {boolean}
  */
 export function isAssignable(ast: any): boolean;
+/** @typedef {import("./ast/ast-node.ts").ASTNode} ASTNode */
+/** @typedef {import("./ast/ast-node.ts").BodyNode} BodyNode */
+/** @typedef {import("./ast/ast-node.ts").ExpressionNode} ExpressionNode */
+/** @typedef {import("./ast/ast-node.ts").ArrayNode} ArrayNode */
+/** @typedef {import("./ast/ast-node.ts").LiteralNode} LiteralNode */
+/** @typedef {import("./ast/ast-node.ts").ObjectNode} ObjectNode */
+/** @typedef {import("./ast/ast-node.ts").ObjectPropertyNode} ObjectPropertyNode */
+/** @typedef {import("./interface.ts").CompiledExpression} CompiledExpression */
+/** @typedef {import("./interface.ts").CompiledExpressionFunction} CompiledExpressionFunction */
 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.
-   * @returns {import("./interface.ts").CompiledExpression}
+   * @param {ASTNode} ast - The AST to compile.
+   * @returns {CompiledExpression}
    */
-  compile(
-    ast: import("./ast/ast.js").ASTNode,
-  ): import("./interface.ts").CompiledExpression;
+  compile(ast: ASTNode): CompiledExpression;
   /**
    * Unary plus operation.
    * @param {function} argument - The argument function.
@@ -217,8 +225,13 @@ export class ASTInterpreter {
   ): Function;
   #private;
 }
-export type DecoratedASTNode = any & {
-  isPure: boolean | number;
-  constant: boolean;
-  toWatch: any[];
-};
+export type ASTNode = import("./ast/ast-node.ts").ASTNode;
+export type BodyNode = import("./ast/ast-node.ts").BodyNode;
+export type ExpressionNode = import("./ast/ast-node.ts").ExpressionNode;
+export type ArrayNode = import("./ast/ast-node.ts").ArrayNode;
+export type LiteralNode = import("./ast/ast-node.ts").LiteralNode;
+export type ObjectNode = import("./ast/ast-node.ts").ObjectNode;
+export type ObjectPropertyNode = import("./ast/ast-node.ts").ObjectPropertyNode;
+export type CompiledExpression = import("./interface.ts").CompiledExpression;
+export type CompiledExpressionFunction =
+  import("./interface.ts").CompiledExpressionFunction;

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,20 +3,24 @@
  * 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|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 | any;
+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: any;
@@ -80,7 +84,8 @@ export class Scope {
   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.
@@ -177,3 +182,10 @@ export class Scope {
   $searchByName(name: string): ng.Scope | undefined;
   #private;
 }
+export type ExpressionNode = import("../parse/ast/ast-node.ts").ExpressionNode;
+export type LiteralNode = import("../parse/ast/ast-node.ts").LiteralNode;
+export type BodyNode = import("../parse/ast/ast-node.ts").BodyNode;
+export type ArrayNode = import("../parse/ast/ast-node.ts").ArrayNode;
+export type ObjectNode = import("../parse/ast/ast-node.ts").ObjectNode;
+export type ObjectPropertyNode =
+  import("../parse/ast/ast-node.ts").ObjectPropertyNode;

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)
 )[];