@angular-wave/angular.ts 0.16.0 → 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

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

@@ -1,5 +1,5 @@
-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.
  */
@@ -11,7 +11,7 @@ export interface CompiledExpressionProps {
   /** Optional flag for pure expressions. */
   _isPure?: boolean;
   /** AST node decorated with metadata. */
-  _decoratedNode: DecoratedASTNode;
+  _decoratedNode: BodyNode;
   /** Expression inputs; may be an array or a function. */
   _inputs?: any[] | Function;
   /**

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

@@ -3,6 +3,15 @@
  * @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 {
@@ -14,12 +23,10 @@ export class ASTInterpreter {
   _$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.
@@ -218,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/scope/scope.d.ts

@@ -182,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;