@angular-wave/angular.ts 0.0.50 → 0.0.51

package/src/core/parser/lexer.js

@@ -1,5 +1,6 @@
-import { $parseMinErr } from "./parse";
-import { isDefined } from "../../shared/utils";
+import { isDefined, minErr } from "../../shared/utils";
+
+const $parseMinErr = minErr("$parse");
 
 const ESCAPE = {
   n: "\n",
@@ -22,7 +23,7 @@ const OPERATORS = new Set(
  */
 
 /**
- * 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.
@@ -66,7 +67,10 @@ export class Lexer {
         (ch === "." && this.isNumber(/** @type {string} */ (this.peek())))
       ) {
         this.readNumber();
-      } else if (this.isIdentifierStart(this.peekMultichar())) {
+      } else if (
+        this.isIdentifierStart &&
+        this.isIdentifierStart(this.peekMultichar())
+      ) {
         this.readIdent();
       } else if (this.is(ch, "(){}[].,;:?")) {
         this.tokens.push({ index: this.index, text: ch });
@@ -132,14 +136,8 @@ export class Lexer {
    * @returns {boolean} True if character is whitespace, false otherwise.
    */
   isWhitespace(ch) {
-    // IE treats non-breaking space as \u00A0
     return (
-      ch === " " ||
-      ch === "\r" ||
-      ch === "\t" ||
-      ch === "\n" ||
-      ch === "\v" ||
-      ch === "\u00A0"
+      ch === " " || ch === "\r" || ch === "\t" || ch === "\n" || ch === "\v"
     );
   }
 
@@ -179,7 +177,6 @@ export class Lexer {
    */
   codePointAt(ch) {
     if (ch.length === 1) return ch.charCodeAt(0);
-
     return (ch.charCodeAt(0) << 10) + ch.charCodeAt(1) - 0x35fdc00;
   }
 
@@ -230,6 +227,7 @@ export class Lexer {
 
   /**
    * Reads and tokenizes a number from the text.
+   * @return {void}
    */
   readNumber() {
     let number = "";
@@ -277,7 +275,7 @@ export class Lexer {
     this.index += this.peekMultichar().length;
     while (this.index < this.text.length) {
       const ch = this.peekMultichar();
-      if (!this.isIdentifierContinue(ch)) {
+      if (this.isIdentifierContinue && !this.isIdentifierContinue(ch)) {
         break;
       }
       this.index += ch.length;
@@ -333,6 +331,9 @@ export class Lexer {
     this.throwError("Unterminated quote", start);
   }
 
+  /**
+   * @returns {string}
+   */
   handleUnicodeEscape() {
     const hex = this.text.substring(this.index + 1, this.index + 5);
     if (!hex.match(/[\da-f]{4}/i)) {

package/src/core/parser/parse.js

@@ -1,63 +1,46 @@
-import { forEach, isDefined, isFunction, minErr } from "../../shared/utils";
-import { getValueOf, PURITY_RELATIVE } from "./shared";
+import { forEach, isDefined, isFunction } from "../../shared/utils";
+import { PURITY_RELATIVE } from "./interpreter";
 import { Lexer } from "./lexer";
 import { Parser } from "./parser";
 
 /**
- * @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}
+ * @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 {function(string|function(import('../scope/scope').Scope):any, function(any, import('../scope/scope').Scope, any):any=, boolean=): CompiledExpression} ParseService
+ * @typedef {CompiledExpressionFunction & CompiledExpressionProps} CompiledExpression
  */
 
-export const $parseMinErr = minErr("$parse");
-
-export const literals = {
-  true: true,
-  false: false,
-  null: null,
-  undefined,
-};
+/**
+ * @typedef {function(string|function(import('../scope/scope').Scope):any, function(any, import('../scope/scope').Scope, any):any=, boolean=): CompiledExpression} ParseService
+ */
 
 export function $ParseProvider() {
   const cache = Object.create(null);
-  const literals = {
-    true: true,
-    false: false,
-    null: null,
-    undefined: undefined,
-  };
+
   /** @type {function(any):boolean?} */
   var identStart;
 
   /** @type {function(any):boolean?} */
   var identContinue;
 
-  /**
-   * @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`.
-   *
-   **/
-  this.addLiteral = function (literalName, literalValue) {
-    literals[literalName] = literalValue;
-  };
-
   /**
    * 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
@@ -87,8 +70,8 @@ export function $ParseProvider() {
   this.$get = [
     "$filter",
     function ($filter) {
-      var $parseOptions = {
-        literals: structuredClone(literals),
+      /** @type {import("./lexer").LexerOptions} */
+      var $lexerOptions = {
         isIdentifierStart: isFunction(identStart) && identStart,
         isIdentifierContinue: isFunction(identContinue) && identContinue,
       };
@@ -106,11 +89,8 @@ export function $ParseProvider() {
             parsedExpression = cache[cacheKey];
 
             if (!parsedExpression) {
-              var lexer = new Lexer({
-                isIdentifierContinue: $parseOptions.isIdentifierContinue,
-                isIdentifierStart: $parseOptions.isIdentifierStart,
-              });
-              var parser = new Parser(lexer, $filter, $parseOptions);
+              var lexer = new Lexer($lexerOptions);
+              var parser = new Parser(lexer, $filter);
               parsedExpression = parser.parse(exp);
 
               cache[cacheKey] = addWatchDelegate(parsedExpression);
@@ -130,8 +110,8 @@ export function $ParseProvider() {
        * @returns {import("./ast").ASTNode}
        */
       function $$getAst(exp) {
-        var lexer = new Lexer($parseOptions);
-        var parser = new Parser(lexer, $filter, $parseOptions);
+        var lexer = new Lexer($lexerOptions);
+        var parser = new Parser(lexer, $filter);
         return parser.getAst(exp).ast;
       }
 
@@ -396,3 +376,9 @@ function isAllDefined(value) {
   });
   return allDefined;
 }
+
+function getValueOf(value) {
+  return isFunction(value.valueOf)
+    ? value.valueOf()
+    : {}.constructor.prototype.valueOf.call(value);
+}