@angular-wave/angular.ts 0.0.49 → 0.0.50

package/types/core/parser/ast.d.ts

@@ -1,80 +1,39 @@
 /**
- * @param {import('./lexer').Lexer} lexer
- * @param {*} options
+ * @typedef {Object} ASTNode
+ * @property {string} type - The type of the AST node.
+ * @property {string} [name] - The name of the identifier.
+ * @property {string} [kind] - The kind of the property (e.g., 'init').
+ * @property {*} [value] - The value of the node if it is a literal.
+ * @property {ASTNode[]} [elements] - The elements of an array node.
+ * @property {ASTNode[]} [properties] - The properties of an object node.
+ * @property {ASTNode} [key] - The key of an object property.
+ * @property {ASTNode} [value] - The value of an object property.
+ * @property {ASTNode} [left] - The left-hand side of a binary expression.
+ * @property {ASTNode} [right] - The right-hand side of a binary expression.
+ * @property {ASTNode} [argument] - The argument of a unary expression.
+ * @property {ASTNode} [test] - The test expression of a conditional expression.
+ * @property {ASTNode} [alternate] - The alternate expression of a conditional expression.
+ * @property {ASTNode} [consequent] - The consequent expression of a conditional expression.
+ * @property {ASTNode[]} [body] - The body of a program or block statement.
+ * @property {ASTNode} [expression] - The expression of an expression statement.
+ * @property {ASTNode} [callee] - The callee of a call expression.
+ * @property {ASTNode[]} [arguments] - The arguments of a call expression.
+ * @property {boolean} [prefix] - Indicates if a unary operator is a prefix.
+ * @property {ASTNode} [object] - The object of a member expression.
+ * @property {ASTNode} [property] - The property of a member expression.
+ * @property {boolean} [computed] - Indicates if a member expression is computed.
+ * @property {string} [operator] - The operator of a binary or logical expression.
+ */
+/**
+ * @param {import('./lexer').Lexer} lexer - The lexer instance for tokenizing input
+ * @param {import("./parser").ParserOptions} options
  */
-export function AST(lexer: import("./lexer").Lexer, options: any): void;
 export class AST {
-    /**
-     * @param {import('./lexer').Lexer} lexer
-     * @param {*} options
-     */
-    constructor(lexer: import("./lexer").Lexer, options: any);
+    constructor(lexer: any, options: any);
+    /** @type {import('./lexer').Lexer} */
     lexer: import("./lexer").Lexer;
-    options: any;
-    ast(text: any): {
-        type: string;
-        body: {
-            type: string;
-            expression: any;
-        }[];
-    };
-    text: any;
-    tokens: import("./lexer").Token[];
-    program(): {
-        type: string;
-        body: {
-            type: string;
-            expression: any;
-        }[];
-    };
-    expressionStatement(): {
-        type: string;
-        expression: any;
-    };
-    filterChain(): any;
-    expression(): any;
-    assignment(): any;
-    ternary(): any;
-    logicalOR(): any;
-    logicalAND(): any;
-    equality(): any;
-    relational(): any;
-    additive(): any;
-    multiplicative(): any;
-    unary(): any;
-    primary(): any;
-    filter(baseExpression: any): {
-        type: string;
-        callee: {
-            type: string;
-            name: any;
-        };
-        arguments: any[];
-        filter: boolean;
-    };
-    parseArguments(): any;
-    identifier(): {
-        type: string;
-        name: any;
-    };
-    constant(): {
-        type: string;
-        value: any;
-    };
-    arrayDeclaration(): any;
-    object(): {
-        type: string;
-        properties: {
-            type: string;
-            kind: string;
-        }[];
-    };
-    throwError(msg: any, token: any): never;
-    consume(e1: any): false | import("./lexer").Token;
-    peekToken(): import("./lexer").Token;
-    peek(e1: any, e2: any, e3: any, e4: any): false | import("./lexer").Token;
-    peekAhead(i: any, e1: any, e2: any, e3: any, e4: any): false | import("./lexer").Token;
-    expect(e1: any, e2: any, e3: any, e4: any): false | import("./lexer").Token;
+    /** @type  {import("./parser").ParserOptions} */
+    options: import("./parser").ParserOptions;
     selfReferential: {
         this: {
             type: string;
@@ -83,4 +42,239 @@ export class AST {
             type: string;
         };
     };
+    /**
+     * Parses the input text and generates an AST.
+     * @param {string} text - The input text to parse.
+     * @returns {ASTNode} The root node of the AST.
+     */
+    ast(text: string): ASTNode;
+    text: string;
+    tokens: import("./lexer").Token[];
+    /**
+     * Parses a program.
+     * @returns {ASTNode} The program node.
+     */
+    program(): ASTNode;
+    /**
+     * Parses an expression statement.
+     * @returns {ASTNode} The expression statement node.
+     */
+    expressionStatement(): ASTNode;
+    /**
+     * Parses a filter chain.
+     * @returns {ASTNode} The filter chain node.
+     */
+    filterChain(): ASTNode;
+    /**
+     * Parses an expression.
+     * @returns {ASTNode} The expression node.
+     */
+    expression(): ASTNode;
+    /**
+     * Parses an assignment expression.
+     * @returns {ASTNode} The assignment expression node.
+     */
+    assignment(): ASTNode;
+    /**
+     * Parses a ternary expression.
+     * @returns {ASTNode} The ternary expression node.
+     */
+    ternary(): ASTNode;
+    /**
+     * Parses a logical OR expression.
+     * @returns {ASTNode} The logical OR expression node.
+     */
+    logicalOR(): ASTNode;
+    /**
+     * Parses a logical AND expression.
+     * @returns {ASTNode} The logical AND expression node.
+     */
+    logicalAND(): ASTNode;
+    /**
+     * Parses an equality expression.
+     * @returns {ASTNode} The equality expression node.
+     */
+    equality(): ASTNode;
+    /**
+     * Parses a relational expression.
+     * @returns {ASTNode} The relational expression node.
+     */
+    relational(): ASTNode;
+    /**
+     * Parses an additive expression.
+     * @returns {ASTNode} The additive expression node.
+     */
+    additive(): ASTNode;
+    /**
+     * Parses a multiplicative expression.
+     * @returns {ASTNode} The multiplicative expression node.
+     */
+    multiplicative(): ASTNode;
+    /**
+     * Parses a unary expression.
+     * @returns {ASTNode} The unary expression node.
+     */
+    unary(): ASTNode;
+    /**
+     * Parses a primary expression.
+     * @returns {ASTNode} The primary expression node.
+     */
+    primary(): ASTNode;
+    /**
+     * Parses a filter.
+     * @param {ASTNode} baseExpression - The base expression to apply the filter to.
+     * @returns {ASTNode} The filter node.
+     */
+    filter(baseExpression: ASTNode): ASTNode;
+    /**
+     * Parses function arguments.
+     * @returns {ASTNode[]} The arguments array.
+     */
+    parseArguments(): ASTNode[];
+    /**
+     * Parses an identifier.
+     * @returns {ASTNode} The identifier node.
+     */
+    identifier(): ASTNode;
+    /**
+     * Parses a constant.
+     * @returns {ASTNode} The constant node.
+     */
+    constant(): ASTNode;
+    /**
+     * Parses an array declaration.
+     * @returns {ASTNode} The array declaration node.
+     */
+    arrayDeclaration(): ASTNode;
+    /**
+     * Parses an object.
+     * @returns {ASTNode} The object node.
+     */
+    object(): ASTNode;
+    /**
+     * Throws a syntax error.
+     * @param {string} msg - The error message.
+     * @param {import("./lexer").Token} [token] - The token that caused the error.
+     */
+    throwError(msg: string, token?: import("./lexer").Token): void;
+    /**
+     * Consumes a token if it matches the expected type.
+     * @param {string} [e1] - The expected token type.
+     * @returns {import("./lexer").Token} The consumed token.
+     */
+    consume(e1?: string): import("./lexer").Token;
+    /**
+     * Returns the next token without consuming it.
+     * @returns {import("./lexer").Token} The next token.
+     */
+    peekToken(): import("./lexer").Token;
+    /**
+     * Checks if the next token matches any of the expected types.
+     * @param {...string} [expected] - The expected token types.
+     * @returns {import('./lexer').Token|boolean} The next token if it matches, otherwise false.
+     */
+    peek(...expected?: string[]): import("./lexer").Token | boolean;
+    /**
+     * Checks if the token at the specified index matches any of the expected types.
+     * @param {number} i - The index to check.
+     * @param {...string} [expected] - The expected token types.
+     * @returns {import("./lexer").Token|boolean} The token at the specified index if it matches, otherwise false.
+     */
+    peekAhead(i: number, ...expected?: string[]): import("./lexer").Token | boolean;
+    /**
+     * Consumes the next token if it matches any of the expected types.
+     * @param {...string} [expected] - The expected token types.
+     * @returns {import("./lexer").Token|boolean} The consumed token if it matches, otherwise false.
+     */
+    expect(...expected?: string[]): import("./lexer").Token | boolean;
 }
+export type ASTNode = {
+    /**
+     * - The type of the AST node.
+     */
+    type: string;
+    /**
+     * - The name of the identifier.
+     */
+    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.
+     */
+    left?: ASTNode;
+    /**
+     * - The right-hand side of a binary expression.
+     */
+    right?: ASTNode;
+    /**
+     * - The argument of a unary expression.
+     */
+    argument?: ASTNode;
+    /**
+     * - The test expression of a conditional expression.
+     */
+    test?: ASTNode;
+    /**
+     * - The alternate expression of a conditional expression.
+     */
+    alternate?: ASTNode;
+    /**
+     * - The consequent expression of a conditional expression.
+     */
+    consequent?: ASTNode;
+    /**
+     * - The body of a program or block statement.
+     */
+    body?: ASTNode[];
+    /**
+     * - The expression of an expression statement.
+     */
+    expression?: ASTNode;
+    /**
+     * - The callee of a call expression.
+     */
+    callee?: ASTNode;
+    /**
+     * - The arguments of a call expression.
+     */
+    arguments?: ASTNode[];
+    /**
+     * - Indicates if a unary operator is a prefix.
+     */
+    prefix?: boolean;
+    /**
+     * - The object of a member expression.
+     */
+    object?: ASTNode;
+    /**
+     * - The property of a member expression.
+     */
+    property?: ASTNode;
+    /**
+     * - Indicates if a member expression is computed.
+     */
+    computed?: boolean;
+    /**
+     * - The operator of a binary or logical expression.
+     */
+    operator?: string;
+};

package/types/core/parser/interpreter.d.ts

@@ -1,57 +1,206 @@
-export function ASTInterpreter($filter: any): void;
 export class ASTInterpreter {
-    constructor($filter: any);
-    $filter: any;
-    compile(ast: any): any;
-    recurse(ast: any, context: any, create: any): any;
-    "unary+": (argument: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
-    "unary-": (argument: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
-    "unary!": (argument: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
-        value: boolean;
-    };
-    "binary+": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
-    "binary-": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => number | {
-        value: number;
-    };
-    "binary*": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => number | {
-        value: number;
-    };
-    "binary/": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => number | {
-        value: number;
-    };
-    "binary%": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => number | {
+    /**
+     * @param {function(any):any} $filter
+     */
+    constructor($filter: (arg0: any) => any);
+    $filter: (arg0: any) => any;
+    /**
+     * Compiles the AST into a function.
+     * @param {import("./ast").ASTNode} ast - The AST to compile.
+     * @returns
+     */
+    compile(ast: import("./ast").ASTNode): any;
+    /**
+     * Recurses the AST nodes.
+     * @param {import("./ast").ASTNode} ast - The AST node.
+     * @param {Object} [context] - The context.
+     * @param {boolean|number} [create] - The create flag.
+     * @returns {function} The recursive function.
+     */
+    recurse(ast: import("./ast").ASTNode, context?: any, create?: boolean | number): Function;
+    /**
+     * Unary plus operation.
+     * @param {function} argument - The argument function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The unary plus function.
+     */
+    "unary+"(argument: Function, context?: any): Function;
+    /**
+     * Unary minus operation.
+     * @param {function} argument - The argument function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The unary minus function.
+     */
+    "unary-"(argument: Function, context?: any): Function;
+    /**
+     * Unary negation operation.
+     * @param {function} argument - The argument function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The unary negation function.
+     */
+    "unary!"(argument: Function, context?: any): Function;
+    /**
+     * Binary plus operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary plus function.
+     */
+    "binary+"(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary minus operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary minus function.
+     */
+    "binary-"(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary multiplication operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary multiplication function.
+     */
+    "binary*"(left: Function, right: Function, context?: any): Function;
+    "binary/"(left: any, right: any, context: any): (scope: any, locals: any, assign: any, inputs: any) => number | {
         value: number;
     };
-    "binary===": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
-        value: boolean;
-    };
-    "binary!==": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
-        value: boolean;
-    };
-    "binary==": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
-        value: boolean;
-    };
-    "binary!=": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
-        value: boolean;
-    };
-    "binary<": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
-        value: boolean;
-    };
-    "binary>": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
-        value: boolean;
-    };
-    "binary<=": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
-        value: boolean;
-    };
-    "binary>=": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
-        value: boolean;
-    };
-    "binary&&": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
-    "binary||": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
-    "ternary?:": (test: any, alternate: any, consequent: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
-    value(value: any, context: any): () => any;
-    identifier(name: any, context: any, create: any): (scope: any, locals: any) => any;
-    computedMember(left: any, right: any, context: any, create: any): (scope: any, locals: any, assign: any, inputs: any) => any;
-    nonComputedMember(left: any, right: any, context: any, create: any): (scope: any, locals: any, assign: any, inputs: any) => any;
-    inputs(input: any, watchId: any): (scope: any, value: any, locals: any, inputs: any) => any;
+    /**
+     * Binary division operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary division function.
+     */
+    "binary%"(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary strict equality operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary strict equality function.
+     */
+    "binary==="(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary strict inequality operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary strict inequality function.
+     */
+    "binary!=="(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary equality operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary equality function.
+     */
+    "binary=="(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary inequality operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary inequality function.
+     */
+    "binary!="(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary less-than operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary less-than function.
+     */
+    "binary<"(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary greater-than operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary greater-than function.
+     */
+    "binary>"(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary less-than-or-equal-to operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary less-than-or-equal-to function.
+     */
+    "binary<="(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary greater-than-or-equal-to operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary greater-than-or-equal-to function.
+     */
+    "binary>="(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary logical AND operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary logical AND function.
+     */
+    "binary&&"(left: Function, right: Function, context?: any): Function;
+    /**
+     * Binary logical OR operation.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The binary logical OR function.
+     */
+    "binary||"(left: Function, right: Function, context?: any): Function;
+    /**
+     * Ternary conditional operation.
+     * @param {function} test - The test function.
+     * @param {function} alternate - The alternate function.
+     * @param {function} consequent - The consequent function.
+     * @param {Object} [context] - The context.
+     * @returns {function} The ternary conditional function.
+     */
+    "ternary?:"(test: Function, alternate: Function, consequent: Function, context?: any): Function;
+    /**
+     * Returns the value of a literal.
+     * @param {*} value - The literal value.
+     * @param {Object} [context] - The context.
+     * @returns {function} The function returning the literal value.
+     */
+    value(value: any, context?: any): Function;
+    /**
+     * Returns the value of an identifier.
+     * @param {string} name - The identifier name.
+     * @param {Object} [context] - The context.
+     * @param {boolean} [create] - Whether to create the identifier if it does not exist.
+     * @returns {function} The function returning the identifier value.
+     */
+    identifier(name: string, context?: any, create?: boolean): Function;
+    /**
+     * Returns the value of a computed member expression.
+     * @param {function} left - The left operand function.
+     * @param {function} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @param {boolean} [create] - Whether to create the member if it does not exist.
+     * @returns {function} The function returning the computed member value.
+     */
+    computedMember(left: Function, right: Function, context?: any, create?: boolean): Function;
+    /**
+     * Returns the value of a non-computed member expression.
+     * @param {function} left - The left operand function.
+     * @param {string} right - The right operand function.
+     * @param {Object} [context] - The context.
+     * @param {boolean} [create] - Whether to create the member if it does not exist.
+     * @returns {function} The function returning the non-computed member value.
+     */
+    nonComputedMember(left: Function, right: string, context?: any, create?: boolean): Function;
+    /**
+     * Returns the value of an input expression.
+     * @param {function} input - The input function.
+     * @param {number} watchId - The watch identifier.
+     * @returns {function} The function returning the input value.
+     */
+    inputs(input: Function, watchId: number): Function;
 }