@angular-wave/angular.ts 0.0.49 → 0.0.51

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

@@ -1,57 +1,211 @@
-export function ASTInterpreter($filter: any): void;
+/**
+ * @param {import("./ast").ASTNode} ast
+ * @returns {boolean}
+ */
+export function isAssignable(ast: import("./ast").ASTNode): boolean;
+export const PURITY_ABSOLUTE: 1;
+export const PURITY_RELATIVE: 2;
 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 {import("./parse").CompiledExpression}
+     */
+    compile(ast: import("./ast").ASTNode): import("./parse").CompiledExpression;
+    /**
+     * Recurses the AST nodes.
+     * @param {import("./ast").ASTNode} ast - The AST node.
+     * @param {Object} [context] - The context.
+     * @param {boolean|1} [create] - The create flag.
+     * @returns {import("./parse").CompiledExpressionFunction} The recursive function.
+     */
+    recurse(ast: import("./ast").ASTNode, context?: any, create?: boolean | 1): import("./parse").CompiledExpressionFunction;
+    /**
+     * 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) => 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|1} [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 | 1): 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|1} [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 | 1): 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|1} [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 | 1): Function;
 }
+export type DecoratedASTNode = import("./ast").ASTNode & {
+    isPure: boolean | number;
+    constant: boolean;
+    toWatch: any[];
+};

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

@@ -1,17 +1,17 @@
 /**
  * @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.
+ * @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 token produced by the lexer.
+ * Represents a token produced by the lexer, which will be used by the AST to construct an abstract syntax tree.
  * @typedef {Object} Token
- * @property {number} index Index of the token.
- * @property {string} text Text of the token.
- * @property {boolean} [identifier] Indicates if token is an identifier.
- * @property {boolean} [constant] Indicates if token is a constant.
- * @property {string|number} [value] Value of the token if it's a constant.
- * @property {boolean} [operator] Indicates if token is an operator.
+ * @property {number} index - Index of the token.
+ * @property {string} text - Text of the token.
+ * @property {boolean} [identifier] - Indicates if token is an identifier.
+ * @property {boolean} [constant] - Indicates if token is a constant.
+ * @property {string|number} [value] - Value of the token if it's a constant.
+ * @property {boolean} [operator] - Indicates if token is an operator.
  */
 /**
  * Represents a lexer that tokenizes input text. The Lexer takes the original expression string and returns an array of tokens parsed from that string.
@@ -20,7 +20,7 @@
 export class Lexer {
     /**
      * Creates an instance of Lexer.
-     * @param {LexerOptions} options Lexer options.
+     * @param {LexerOptions} options - Lexer options.
      */
     constructor(options: LexerOptions);
     /** @type {LexerOptions} */
@@ -99,6 +99,7 @@ export class Lexer {
     throwError(error: string, start?: number, end?: number): void;
     /**
      * Reads and tokenizes a number from the text.
+     * @return {void}
      */
     readNumber(): void;
     /**
@@ -110,44 +111,47 @@ export class Lexer {
      * @param {string} quote Quote character used for the string.
      */
     readString(quote: string): void;
+    /**
+     * @returns {string}
+     */
     handleUnicodeEscape(): string;
 }
 export type LexerOptions = {
     /**
-     * Custom function to determine if a character is a valid identifier start.
+     * - 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.
+     * - Custom function to determine if a character is a valid identifier continuation.
      */
     isIdentifierContinue?: (ch: string, codePoint: number) => boolean;
 };
 /**
- * Represents a token produced by the lexer.
+ * Represents a token produced by the lexer, which will be used by the AST to construct an abstract syntax tree.
  */
 export type Token = {
     /**
-     * Index of the token.
+     * - Index of the token.
      */
     index: number;
     /**
-     * Text of the token.
+     * - Text of the token.
      */
     text: string;
     /**
-     * Indicates if token is an identifier.
+     * - Indicates if token is an identifier.
      */
     identifier?: boolean;
     /**
-     * Indicates if token is a constant.
+     * - Indicates if token is a constant.
      */
     constant?: boolean;
     /**
-     * Value of the token if it's a constant.
+     * - Value of the token if it's a constant.
      */
     value?: string | number;
     /**
-     * Indicates if token is an operator.
+     * - Indicates if token is an operator.
      */
     operator?: boolean;
 };

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

@@ -1,23 +1,31 @@
+/**
+ * @typedef {Object} CompiledExpressionProps
+ * @property {boolean} literal - Indicates if the expression is a literal.
+ * @property {boolean} constant - Indicates if the expression is constant.
+ * @property {boolean} isPure
+ * @property {boolean} oneTime
+ * @property {any[]} inputs
+ * @property {function(any, any): any} assign - Assigns a value to a context. If value is not provided,
+ */
+/**
+ * @typedef {function } CompiledExpressionFunction
+ * @param {import('../scope/scope').Scope} context - An object against which any expressions embedded in the strings are evaluated against (typically a scope object).
+ * @param {object} [locals] - local variables context object, useful for overriding values in `context`.
+ * @param {any} [assign]
+ * @returns {any}
+ * undefined is gonna be used since the implementation
+ * does not check the parameter. Let's force a value for consistency. If consumer
+ * wants to undefine it, pass the undefined value explicitly.
+ */
+/**
+ * @typedef {CompiledExpressionFunction & CompiledExpressionProps} CompiledExpression
+ */
+/**
+ * @typedef {function(string|function(import('../scope/scope').Scope):any, function(any, import('../scope/scope').Scope, any):any=, boolean=): CompiledExpression} ParseService
+ */
 export function $ParseProvider(): void;
 export class $ParseProvider {
     /**
-     * @ngdoc method
-     * @name $parseProvider#addLiteral
-     * @description
-     *
-     * Configure $parse service to add literal values that will be present as literal at expressions.
-     *
-     * @param {string} literalName Token for the literal value. The literal name value must be a valid literal name.
-     * @param {*} literalValue Value for this literal. All literal values must be primitives or `undefined`.
-     *
-     **/
-    addLiteral: (literalName: string, literalValue: any) => void;
-    /**
-     * @ngdoc method
-     * @name $parseProvider#setIdentifierFns
-     *
-     * @description
-     *
      * Allows defining the set of characters that are allowed in AngularJS 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
@@ -31,38 +39,36 @@ export class $ParseProvider {
      * 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
+     * @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
+     * @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) | undefined, identifierContinue?: ((arg0: any) => boolean) | undefined) => this;
+    setIdentifierFns: (identifierStart?: (arg0: any) => boolean, identifierContinue?: (arg0: any) => boolean) => $ParseProvider;
     $get: (string | (($filter: any) => {
         (exp: any, interceptorFn: any): any;
-        $$getAst: (exp: any) => {
-            type: string;
-            body: {
-                type: string;
-                expression: any;
-            }[];
-        };
+        $$getAst: (exp: string) => import("./ast").ASTNode;
     }))[];
 }
-export function inputsWatchDelegate(scope: any, listener: any, objectEquality: any, parsedExpression: any): any;
-export function oneTimeWatchDelegate(scope: any, listener: any, objectEquality: any, parsedExpression: any): any;
-export function chainInterceptors(first: any, second: any): {
-    (value: any): any;
-    $stateful: any;
-    $$pure: any;
+export function constantWatchDelegate(scope: any, listener: any, objectEquality: any, parsedExpression: any): any;
+export type CompiledExpressionProps = {
+    /**
+     * - Indicates if the expression is a literal.
+     */
+    literal: boolean;
+    /**
+     * - Indicates if the expression is constant.
+     */
+    constant: boolean;
+    isPure: boolean;
+    oneTime: boolean;
+    inputs: any[];
+    /**
+     * - Assigns a value to a context. If value is not provided,
+     */
+    assign: (arg0: any, arg1: any) => any;
 };
-export const $parseMinErr: (arg0: string, ...arg1: any[]) => Error;
-export namespace literals {
-    let _true: boolean;
-    export { _true as true };
-    let _false: boolean;
-    export { _false as false };
-    let _null: any;
-    export { _null as null };
-    export let undefined: any;
-}
-export type ParseService = (arg0: string | ((arg0: import("../scope/scope").Scope) => any), arg1: ((arg0: any, arg1: import("../scope/scope").Scope, arg2: any) => any) | undefined, arg2: boolean | undefined) => import("../../types").CompiledExpression;
+export type CompiledExpressionFunction = Function;
+export type CompiledExpression = CompiledExpressionFunction & CompiledExpressionProps;
+export type ParseService = (arg0: string | ((arg0: import("../scope/scope").Scope) => any), arg1: ((arg0: any, arg1: import("../scope/scope").Scope, arg2: any) => any) | undefined, arg2: boolean | undefined) => CompiledExpression;

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

@@ -1,3 +1,8 @@
+/**
+ * @typedef {Object} ParsedAST
+ * @property {import("./ast").ASTNode} ast - AST representation of expression
+ * @property {boolean} oneTime - True if expression should be evaluated only once
+ */
 /**
  * @constructor
  */
@@ -5,24 +10,34 @@ export class Parser {
     /**
      *
      * @param {import('./lexer').Lexer} lexer
-     * @param {*} $filter
-     * @param {*} options
+     * @param {function(any):any} $filter
      */
-    constructor(lexer: import("./lexer").Lexer, $filter: any, options: any);
+    constructor(lexer: import("./lexer").Lexer, $filter: (arg0: any) => any);
+    /** @type {AST} */
     ast: AST;
-    astCompiler: ASTInterpreter | ASTCompiler;
-    parse(text: any): any;
-    getAst(exp: any): {
-        ast: {
-            type: string;
-            body: {
-                type: string;
-                expression: any;
-            }[];
-        };
-        oneTime: boolean;
-    };
+    /** @type {ASTInterpreter} */
+    astCompiler: ASTInterpreter;
+    /**
+     *
+     * @param {string} exp - Expression to be parsed
+     * @returns
+     */
+    parse(exp: string): import("./parse").CompiledExpression;
+    /**
+     * @param {string} exp - Expression to be parsed
+     * @returns {ParsedAST}
+     */
+    getAst(exp: string): ParsedAST;
 }
+export type ParsedAST = {
+    /**
+     * - AST representation of expression
+     */
+    ast: import("./ast").ASTNode;
+    /**
+     * - True if expression should be evaluated only once
+     */
+    oneTime: boolean;
+};
 import { AST } from "./ast";
 import { ASTInterpreter } from "./interpreter";
-import { ASTCompiler } from "./compiler";