@angular-wave/angular.ts 0.0.49 → 0.0.51

package/src/core/parser/parser.js

@@ -1,7 +1,12 @@
 import { AST } from "./ast";
-import { isLiteral, isConstant } from "./shared";
+import { ASTType } from "./ast-type";
 import { ASTInterpreter } from "./interpreter";
-import { ASTCompiler } from "./compiler";
+
+/**
+ * @typedef {Object} ParsedAST
+ * @property {import("./ast").ASTNode} ast - AST representation of expression
+ * @property {boolean} oneTime - True if expression should be evaluated only once
+ */
 
 /**
  * @constructor
@@ -10,18 +15,23 @@ export class Parser {
   /**
    *
    * @param {import('./lexer').Lexer} lexer
-   * @param {*} $filter
-   * @param {*} options
+   * @param {function(any):any} $filter
    */
-  constructor(lexer, $filter, options) {
-    this.ast = new AST(lexer, options);
-    this.astCompiler = options.csp
-      ? new ASTInterpreter($filter)
-      : new ASTCompiler($filter);
+  constructor(lexer, $filter) {
+    /** @type {AST} */
+    this.ast = new AST(lexer);
+
+    /** @type {ASTInterpreter} */
+    this.astCompiler = new ASTInterpreter($filter);
   }
 
-  parse(text) {
-    const { ast, oneTime } = this.getAst(text);
+  /**
+   *
+   * @param {string} exp - Expression to be parsed
+   * @returns
+   */
+  parse(exp) {
+    const { ast, oneTime } = this.getAst(exp);
     const fn = this.astCompiler.compile(ast);
     fn.literal = isLiteral(ast);
     fn.constant = isConstant(ast);
@@ -29,6 +39,10 @@ export class Parser {
     return fn;
   }
 
+  /**
+   * @param {string} exp - Expression to be parsed
+   * @returns {ParsedAST}
+   */
   getAst(exp) {
     let oneTime = false;
     exp = exp.trim();
@@ -43,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/directive/csp.md

@@ -18,12 +18,6 @@
 -
 - The following default rules in CSP affect AngularJS:
 -
-- - The use of `eval()`, `Function(string)` and similar functions to dynamically create and execute
-- code from strings is forbidden. AngularJS makes use of this in the {@link $parse} service to
-- provide a 30% increase in the speed of evaluating AngularJS expressions. (This CSP rule can be
-- disabled with the CSP keyword `unsafe-eval`, but it is generally not recommended as it would
-- weaken the protections offered by CSP.)
--
 - - The use of inline resources, such as inline `<script>` and `<style>` elements, are forbidden.
 - This prevents apps from injecting custom styles directly into the document. AngularJS makes use of
 - this to include some CSS rules (e.g. {@link ngCloak} and {@link ngHide}). To make these
@@ -31,22 +25,6 @@
 - in your HTML manually. (This CSP rule can be disabled with the CSP keyword `unsafe-inline`, but
 - it is generally not recommended as it would weaken the protections offered by CSP.)
 -
-- If you do not provide `ngCsp` then AngularJS tries to autodetect if CSP is blocking dynamic code
-- creation from strings (e.g., `unsafe-eval` not specified in CSP header) and automatically
-- deactivates this feature in the {@link $parse} service. This autodetection, however, triggers a
-- CSP error to be logged in the console:
--
-- ```
-
-  ```
-
-- Refused to evaluate a string as JavaScript because 'unsafe-eval' is not an allowed source of
-- script in the following Content Security Policy directive: "default-src 'self'". Note that
-- 'script-src' was not explicitly set, so 'default-src' is used as a fallback.
-- ```
-
-  ```
-
 -
 - This error is harmless but annoying. To prevent the error from showing up, put the `ngCsp`
 - directive on an element of the HTML document that appears before the `<script>` tag that loads
@@ -59,7 +37,6 @@
 -
 - - no-inline-style: this stops AngularJS from injecting CSS styles into the DOM
 -
-- - no-unsafe-eval: this stops AngularJS from optimizing $parse with unsafe eval of strings
 -
 - You can use these values in the following combinations:
 -
@@ -72,9 +49,6 @@
 - styles and unsafe eval. E.g. `<body ng-csp>`. This is backwardly compatible with previous
 - versions of AngularJS.
 -
-- - Specifying only `no-unsafe-eval` tells AngularJS that we must not use eval, but that we can
-- inject inline styles. E.g. `<body ng-csp="no-unsafe-eval">`.
--
 - - Specifying only `no-inline-style` tells AngularJS that we must not inject styles, but that we can
 - run eval - no automatic check for unsafe eval will occur. E.g. `<body ng-csp="no-inline-style">`
 -

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/shared/jqlite/jqlite.js

@@ -366,7 +366,7 @@ JQLite.prototype.removeData = function (name) {
 /**
  * Gets or sets data on a parent element
  * @param {string} name
- * @param {any} value
+ * @param {any} [value]
  * @returns {JQLite|any}
  */
 JQLite.prototype.inheritedData = function (name, value) {
@@ -383,7 +383,7 @@ JQLite.prototype.inheritedData = function (name, value) {
 
 /**
  * Gets or sets innerHTML on the first element in JQLite collection
- * @param {string} value
+ * @param {string} [value]
  * @returns {JQLite|any|undefined}
  */
 JQLite.prototype.html = function (value) {

package/src/types.js

@@ -11,16 +11,6 @@
  * @template T
  */
 
-/**
- * @typedef {Object|function(any, any=): any} CompiledExpression
- * @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,86 +1,279 @@
 /**
- * @param {import('./lexer').Lexer} lexer
- * @param {*} options
+ * @typedef {Object} ASTNode
+ * @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.
+ * @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.
+ * @property {boolean} [filter]
+ */
+/** @type {Map<string,any>} */
+export const literals: Map<string, any>;
+/**
+ * @class
  */
-export function AST(lexer: import("./lexer").Lexer, options: any): void;
 export class AST {
     /**
-     * @param {import('./lexer').Lexer} lexer
-     * @param {*} options
+     * @param {import('./lexer').Lexer} lexer - The lexer instance for tokenizing input
      */
-    constructor(lexer: import("./lexer").Lexer, options: any);
+    constructor(lexer: import("./lexer").Lexer);
+    /** @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;
     selfReferential: {
         this: {
-            type: string;
+            type: 15;
         };
         $locals: {
-            type: string;
+            type: 16;
         };
     };
+    /**
+     * 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 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: number;
+    /**
+     * - 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;
+    filter?: boolean;
+};