@angular-wave/angular.ts 0.0.50 → 0.0.51

package/src/core/parser/parser.js

@@ -1,5 +1,5 @@
 import { AST } from "./ast";
-import { isLiteral, isConstant } from "./shared";
+import { ASTType } from "./ast-type";
 import { ASTInterpreter } from "./interpreter";
 
 /**
@@ -8,11 +8,6 @@ import { ASTInterpreter } from "./interpreter";
  * @property {boolean} oneTime - True if expression should be evaluated only once
  */
 
-/**
- * @typedef {Object} ParserOptions
- * @property {function(string):any} literals
- */
-
 /**
  * @constructor
  */
@@ -21,11 +16,10 @@ export class Parser {
    *
    * @param {import('./lexer').Lexer} lexer
    * @param {function(any):any} $filter
-   * @param {ParserOptions} options
    */
-  constructor(lexer, $filter, options) {
+  constructor(lexer, $filter) {
     /** @type {AST} */
-    this.ast = new AST(lexer, options);
+    this.ast = new AST(lexer);
 
     /** @type {ASTInterpreter} */
     this.astCompiler = new ASTInterpreter($filter);
@@ -63,3 +57,17 @@ export class Parser {
     };
   }
 }
+
+function isLiteral(ast) {
+  return (
+    ast.body.length === 0 ||
+    (ast.body.length === 1 &&
+      (ast.body[0].expression.type === ASTType.Literal ||
+        ast.body[0].expression.type === ASTType.ArrayExpression ||
+        ast.body[0].expression.type === ASTType.ObjectExpression))
+  );
+}
+
+function isConstant(ast) {
+  return ast.constant;
+}

package/src/loader.js

@@ -112,6 +112,9 @@ export class Angular {
 
     /** @type {errorHandlingConfig} */
     this.errorHandlingConfig = errorHandlingConfig;
+
+    /** @type {Function} */
+    this.doBootstrap;
   }
 
   /**
@@ -171,13 +174,14 @@ export class Angular {
  * * `strictDi` - disable automatic function annotation for the application. This is meant to
  *   assist in finding bugs which break minified code. Defaults to `false`.
  *
- * @returns {angular.auto.IInjectorService} Returns the newly created injector for this app.
+ * @returns {any} InjectorService - Returns the newly created injector for this app.
  */
   bootstrap(element, modules, config) {
     config = config || {
       debugInfoEnabled: false,
       strictDi: false,
     };
+
     this.doBootstrap = function () {
       // @ts-ignore
       element = JQLite(element);

package/src/types.js

@@ -11,19 +11,6 @@
  * @template T
  */
 
-/**
- * @typedef {function} CompiledExpression
- * @param {import('./core/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`.
- * @returns {any}
- * @property {boolean} literal - Indicates if the expression is a literal.
- * @property {boolean} constant - Indicates if the expression is constant.
- * @property {function(any, any): any} assign - Assigns a value to a context. If value is not provided,
- * 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 {Object} ComponentOptions
  * @description Component definition object (a simplified directive definition object)

package/types/animations/shared.d.ts

@@ -41,7 +41,7 @@ export let TRANSITIONEND_EVENT: any;
 export let ANIMATION_PROP: any;
 export let ANIMATIONEND_EVENT: any;
 export const DURATION_KEY: "Duration";
-export const PROPERTY_KEY: "Property";
+export const PROPERTY_KEY: 13;
 export const DELAY_KEY: "Delay";
 export const TIMING_KEY: "TimingFunction";
 export const ANIMATION_ITERATION_COUNT_KEY: "IterationCount";

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

@@ -1,20 +1,24 @@
-export type ASTType = ("Program" | "ExpressionStatement" | "AssignmentExpression" | "ConditionalExpression" | "LogicalExpression" | "BinaryExpression" | "UnaryExpression" | "CallExpression" | "MemberExpression" | "Identifier" | "Literal" | "ArrayExpression" | "Property" | "ObjectExpression" | "ThisExpression" | "LocalsExpression" | "NGValueParameter");
-export namespace ASTType {
-    let Program: string;
-    let ExpressionStatement: string;
-    let AssignmentExpression: string;
-    let ConditionalExpression: string;
-    let LogicalExpression: string;
-    let BinaryExpression: string;
-    let UnaryExpression: string;
-    let CallExpression: string;
-    let MemberExpression: string;
-    let Identifier: string;
-    let Literal: string;
-    let ArrayExpression: string;
-    let Property: string;
-    let ObjectExpression: string;
-    let ThisExpression: string;
-    let LocalsExpression: string;
-    let NGValueParameter: string;
-}
+export type ASTType = number;
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const ASTType: Readonly<{
+    Program: 1;
+    ExpressionStatement: 2;
+    AssignmentExpression: 3;
+    ConditionalExpression: 4;
+    LogicalExpression: 5;
+    BinaryExpression: 6;
+    UnaryExpression: 7;
+    CallExpression: 8;
+    MemberExpression: 9;
+    Identifier: 10;
+    Literal: 11;
+    ArrayExpression: 12;
+    Property: 13;
+    ObjectExpression: 14;
+    ThisExpression: 15;
+    LocalsExpression: 16;
+    NGValueParameter: 17;
+}>;

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

@@ -1,6 +1,6 @@
 /**
  * @typedef {Object} ASTNode
- * @property {string} type - The type of the AST node.
+ * @property {number} 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.
@@ -23,23 +23,26 @@
  * @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.
+ * @property {boolean} [filter]
  */
+/** @type {Map<string,any>} */
+export const literals: Map<string, any>;
 /**
- * @param {import('./lexer').Lexer} lexer - The lexer instance for tokenizing input
- * @param {import("./parser").ParserOptions} options
+ * @class
  */
 export class AST {
-    constructor(lexer: any, options: any);
+    /**
+     * @param {import('./lexer').Lexer} lexer - The lexer instance for tokenizing input
+     */
+    constructor(lexer: import("./lexer").Lexer);
     /** @type {import('./lexer').Lexer} */
     lexer: import("./lexer").Lexer;
-    /** @type  {import("./parser").ParserOptions} */
-    options: import("./parser").ParserOptions;
     selfReferential: {
         this: {
-            type: string;
+            type: 15;
         };
         $locals: {
-            type: string;
+            type: 16;
         };
     };
     /**
@@ -65,11 +68,6 @@ export class AST {
      * @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.
@@ -192,7 +190,7 @@ export type ASTNode = {
     /**
      * - The type of the AST node.
      */
-    type: string;
+    type: number;
     /**
      * - The name of the identifier.
      */
@@ -277,4 +275,5 @@ export type ASTNode = {
      * - The operator of a binary or logical expression.
      */
     operator?: string;
+    filter?: boolean;
 };

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

@@ -1,3 +1,10 @@
+/**
+ * @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 {
     /**
      * @param {function(any):any} $filter
@@ -7,17 +14,17 @@ export class ASTInterpreter {
     /**
      * Compiles the AST into a function.
      * @param {import("./ast").ASTNode} ast - The AST to compile.
-     * @returns
+     * @returns {import("./parse").CompiledExpression}
      */
-    compile(ast: import("./ast").ASTNode): any;
+    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|number} [create] - The create flag.
-     * @returns {function} The recursive function.
+     * @param {boolean|1} [create] - The create flag.
+     * @returns {import("./parse").CompiledExpressionFunction} The recursive function.
      */
-    recurse(ast: import("./ast").ASTNode, context?: any, create?: boolean | number): Function;
+    recurse(ast: import("./ast").ASTNode, context?: any, create?: boolean | 1): import("./parse").CompiledExpressionFunction;
     /**
      * Unary plus operation.
      * @param {function} argument - The argument function.
@@ -63,7 +70,7 @@ export class ASTInterpreter {
      * @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 | {
+    "binary/"(left: any, right: any, context: any): (scope: any, locals: any, assign: any) => number | {
         value: number;
     };
     /**
@@ -174,33 +181,31 @@ export class ASTInterpreter {
      * 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.
+     * @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): Function;
+    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} [create] - Whether to create the member if it does not exist.
+     * @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): Function;
+    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} [create] - Whether to create the member if it does not exist.
+     * @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): 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;
+    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

@@ -4,7 +4,7 @@
  * @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.
@@ -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,6 +111,9 @@ export class Lexer {
      * @param {string} quote Quote character used for the string.
      */
     readString(quote: string): void;
+    /**
+     * @returns {string}
+     */
     handleUnicodeEscape(): string;
 }
 export type LexerOptions = {
@@ -123,7 +127,7 @@ export type LexerOptions = {
     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 = {
     /**

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

@@ -1,17 +1,30 @@
+/**
+ * @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;
     /**
      * 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
@@ -39,30 +52,23 @@ export class $ParseProvider {
     }))[];
 }
 export function constantWatchDelegate(scope: any, listener: any, objectEquality: any, parsedExpression: any): any;
-/**
- * @typedef {function} CompiledExpression
- * @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`.
- * @returns {any}
- * @property {boolean} literal - Indicates if the expression is a literal.
- * @property {boolean} constant - Indicates if the expression is constant.
- * @property {function(any, any): any} assign - Assigns a value to a context. If value is not provided,
- * 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 {function(string|function(import('../scope/scope').Scope):any, function(any, import('../scope/scope').Scope, any):any=, boolean=): CompiledExpression} ParseService
- */
-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 CompiledExpression = Function;
+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 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

@@ -3,10 +3,6 @@
  * @property {import("./ast").ASTNode} ast - AST representation of expression
  * @property {boolean} oneTime - True if expression should be evaluated only once
  */
-/**
- * @typedef {Object} ParserOptions
- * @property {function(string):any} literals
- */
 /**
  * @constructor
  */
@@ -15,9 +11,8 @@ export class Parser {
      *
      * @param {import('./lexer').Lexer} lexer
      * @param {function(any):any} $filter
-     * @param {ParserOptions} options
      */
-    constructor(lexer: import("./lexer").Lexer, $filter: (arg0: any) => any, options: ParserOptions);
+    constructor(lexer: import("./lexer").Lexer, $filter: (arg0: any) => any);
     /** @type {AST} */
     ast: AST;
     /** @type {ASTInterpreter} */
@@ -27,7 +22,7 @@ export class Parser {
      * @param {string} exp - Expression to be parsed
      * @returns
      */
-    parse(exp: string): any;
+    parse(exp: string): import("./parse").CompiledExpression;
     /**
      * @param {string} exp - Expression to be parsed
      * @returns {ParsedAST}
@@ -44,8 +39,5 @@ export type ParsedAST = {
      */
     oneTime: boolean;
 };
-export type ParserOptions = {
-    literals: (arg0: string) => any;
-};
 import { AST } from "./ast";
 import { ASTInterpreter } from "./interpreter";