@angular-wave/angular.ts 0.0.49 → 0.0.51

package/src/core/parser/lexer.js

@@ -1,6 +1,6 @@
-import { $parseMinErr } from "./parse";
+import { isDefined, minErr } from "../../shared/utils";
 
-import { isDefined } from "../../shared/utils";
+const $parseMinErr = minErr("$parse");
 
 const ESCAPE = {
   n: "\n",
@@ -18,19 +18,19 @@ const OPERATORS = new Set(
 
 /**
  * @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.
  */
 
 /**
@@ -40,7 +40,7 @@ const OPERATORS = new Set(
 export class Lexer {
   /**
    * Creates an instance of Lexer.
-   * @param {LexerOptions} options Lexer options.
+   * @param {LexerOptions} options - Lexer options.
    */
   constructor(options) {
     /** @type {LexerOptions} */
@@ -67,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 });
@@ -133,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"
     );
   }
 
@@ -180,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;
   }
 
@@ -231,6 +227,7 @@ export class Lexer {
 
   /**
    * Reads and tokenizes a number from the text.
+   * @return {void}
    */
   readNumber() {
     let number = "";
@@ -278,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;
@@ -334,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,37 +1,40 @@
-import {
-  csp,
-  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";
 
-export const $parseMinErr = minErr("$parse");
+/**
+ * @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=): import('../../types').CompiledExpression} ParseService
+ * @typedef {CompiledExpressionFunction & CompiledExpressionProps} CompiledExpression
  */
 
-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;
 
@@ -39,26 +42,6 @@ export function $ParseProvider() {
   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;
-  };
-
-  /**
-   * @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
@@ -72,10 +55,11 @@ export function $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}
    */
   this.setIdentifierFns = function (identifierStart, identifierContinue) {
     identStart = identifierStart;
@@ -86,10 +70,8 @@ export function $ParseProvider() {
   this.$get = [
     "$filter",
     function ($filter) {
-      var noUnsafeEval = csp().noUnsafeEval;
-      var $parseOptions = {
-        csp: noUnsafeEval,
-        literals: structuredClone(literals),
+      /** @type {import("./lexer").LexerOptions} */
+      var $lexerOptions = {
         isIdentifierStart: isFunction(identStart) && identStart,
         isIdentifierContinue: isFunction(identContinue) && identContinue,
       };
@@ -107,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);
@@ -126,213 +105,16 @@ export function $ParseProvider() {
         }
       }
 
+      /**
+       * @param {string} exp
+       * @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;
       }
 
-      function expressionInputDirtyCheck(
-        newValue,
-        oldValueOfValue,
-        compareObjectIdentity,
-      ) {
-        if (newValue == null || oldValueOfValue == null) {
-          // null/undefined
-          return newValue === oldValueOfValue;
-        }
-
-        if (typeof newValue === "object") {
-          // attempt to convert the value to a primitive type
-          // TODO(docs): add a note to docs that by implementing valueOf even objects and arrays can
-          //             be cheaply dirty-checked
-          newValue = getValueOf(newValue);
-
-          if (typeof newValue === "object" && !compareObjectIdentity) {
-            // objects/arrays are not supported - deep-watching them would be too expensive
-            return false;
-          }
-
-          // fall-through to the primitive equality check
-        }
-
-        //Primitive or NaN
-
-        return (
-          newValue === oldValueOfValue ||
-          (newValue !== newValue && oldValueOfValue !== oldValueOfValue)
-        );
-      }
-
-      function inputsWatchDelegate(
-        scope,
-        listener,
-        objectEquality,
-        parsedExpression,
-      ) {
-        var inputExpressions = parsedExpression.inputs;
-        var lastResult;
-
-        if (inputExpressions.length === 1) {
-          var oldInputValueOf = expressionInputDirtyCheck; // init to something unique so that equals check fails
-          inputExpressions = inputExpressions[0];
-          return scope.$watch(
-            function expressionInputWatch(scope) {
-              var newInputValue = inputExpressions(scope);
-              if (
-                !expressionInputDirtyCheck(
-                  newInputValue,
-                  oldInputValueOf,
-                  inputExpressions.isPure,
-                )
-              ) {
-                lastResult = parsedExpression(scope, undefined, undefined, [
-                  newInputValue,
-                ]);
-                oldInputValueOf = newInputValue && getValueOf(newInputValue);
-              }
-              return lastResult;
-            },
-            listener,
-            objectEquality,
-          );
-        }
-
-        var oldInputValueOfValues = [];
-        var oldInputValues = [];
-        for (var i = 0, ii = inputExpressions.length; i < ii; i++) {
-          oldInputValueOfValues[i] = expressionInputDirtyCheck; // init to something unique so that equals check fails
-          oldInputValues[i] = null;
-        }
-
-        return scope.$watch(
-          function expressionInputsWatch(scope) {
-            var changed = false;
-
-            for (var i = 0, ii = inputExpressions.length; i < ii; i++) {
-              var newInputValue = inputExpressions[i](scope);
-              if (
-                changed ||
-                (changed = !expressionInputDirtyCheck(
-                  newInputValue,
-                  oldInputValueOfValues[i],
-                  inputExpressions[i].isPure,
-                ))
-              ) {
-                oldInputValues[i] = newInputValue;
-                oldInputValueOfValues[i] =
-                  newInputValue && getValueOf(newInputValue);
-              }
-            }
-
-            if (changed) {
-              lastResult = parsedExpression(
-                scope,
-                undefined,
-                undefined,
-                oldInputValues,
-              );
-            }
-
-            return lastResult;
-          },
-          listener,
-          objectEquality,
-        );
-      }
-
-      function oneTimeWatchDelegate(
-        scope,
-        listener,
-        objectEquality,
-        parsedExpression,
-      ) {
-        var isDone = parsedExpression.literal ? isAllDefined : isDefined;
-        var unwatch, lastValue;
-
-        var exp = parsedExpression.$$intercepted || parsedExpression;
-        var post = parsedExpression.$$interceptor || ((x) => x);
-
-        var useInputs = parsedExpression.inputs && !exp.inputs;
-
-        // Propagate the literal/inputs/constant attributes
-        // ... but not oneTime since we are handling it
-        oneTimeWatch.literal = parsedExpression.literal;
-        oneTimeWatch.constant = parsedExpression.constant;
-        oneTimeWatch.inputs = parsedExpression.inputs;
-
-        // Allow other delegates to run on this wrapped expression
-        addWatchDelegate(oneTimeWatch);
-
-        unwatch = scope.$watch(oneTimeWatch, listener, objectEquality);
-
-        return unwatch;
-
-        function unwatchIfDone() {
-          if (isDone(lastValue)) {
-            unwatch();
-          }
-        }
-
-        function oneTimeWatch(scope, locals, assign, inputs) {
-          lastValue =
-            useInputs && inputs
-              ? inputs[0]
-              : exp(scope, locals, assign, inputs);
-          if (isDone(lastValue)) {
-            scope.$$postDigest(unwatchIfDone);
-          }
-          return post(lastValue);
-        }
-      }
-
-      function isAllDefined(value) {
-        var allDefined = true;
-        forEach(value, function (val) {
-          if (!isDefined(val)) allDefined = false;
-        });
-        return allDefined;
-      }
-
-      function constantWatchDelegate(
-        scope,
-        listener,
-        objectEquality,
-        parsedExpression,
-      ) {
-        var unwatch = scope.$watch(
-          function constantWatch(scope) {
-            unwatch();
-            return parsedExpression(scope);
-          },
-          listener,
-          objectEquality,
-        );
-        return unwatch;
-      }
-
-      function addWatchDelegate(parsedExpression) {
-        if (parsedExpression.constant) {
-          parsedExpression.$$watchDelegate = constantWatchDelegate;
-        } else if (parsedExpression.oneTime) {
-          parsedExpression.$$watchDelegate = oneTimeWatchDelegate;
-        } else if (parsedExpression.inputs) {
-          parsedExpression.$$watchDelegate = inputsWatchDelegate;
-        }
-
-        return parsedExpression;
-      }
-
-      function chainInterceptors(first, second) {
-        function chainedInterceptor(value) {
-          return second(first(value));
-        }
-        chainedInterceptor.$stateful = first.$stateful || second.$stateful;
-        chainedInterceptor.$$pure = first.$$pure && second.$$pure;
-
-        return chainedInterceptor;
-      }
-
       function addInterceptor(parsedExpression, interceptorFn) {
         if (!interceptorFn) return parsedExpression;
 
@@ -394,16 +176,16 @@ export function $ParseProvider() {
   ];
 }
 
-function constantWatchDelegate(
+export function constantWatchDelegate(
   scope,
   listener,
   objectEquality,
   parsedExpression,
 ) {
   const unwatch = scope.$watch(
-    ($scope) => {
+    () => {
       unwatch();
-      return parsedExpression($scope);
+      return parsedExpression(scope);
     },
     listener,
     objectEquality,
@@ -423,7 +205,7 @@ function addWatchDelegate(parsedExpression) {
   return parsedExpression;
 }
 
-export function inputsWatchDelegate(
+function inputsWatchDelegate(
   scope,
   listener,
   objectEquality,
@@ -500,7 +282,7 @@ export function inputsWatchDelegate(
   );
 }
 
-export function oneTimeWatchDelegate(
+function oneTimeWatchDelegate(
   scope,
   listener,
   objectEquality,
@@ -545,7 +327,7 @@ export function oneTimeWatchDelegate(
   return unwatch;
 }
 
-export function chainInterceptors(first, second) {
+function chainInterceptors(first, second) {
   function chainedInterceptor(value) {
     return second(first(value));
   }
@@ -555,7 +337,6 @@ export function chainInterceptors(first, second) {
   return chainedInterceptor;
 }
 
-/** @private */
 function expressionInputDirtyCheck(
   newValue,
   oldValueOfValue,
@@ -588,7 +369,6 @@ function expressionInputDirtyCheck(
   );
 }
 
-/** @private */
 function isAllDefined(value) {
   let allDefined = true;
   forEach(value, (val) => {
@@ -596,3 +376,9 @@ function isAllDefined(value) {
   });
   return allDefined;
 }
+
+function getValueOf(value) {
+  return isFunction(value.valueOf)
+    ? value.valueOf()
+    : {}.constructor.prototype.valueOf.call(value);
+}

package/src/core/parser/parse.md

@@ -22,10 +22,6 @@
 -
 - Converts AngularJS {@link guide/expression expression} into a function.
 -
-- ```js
-
-  ```
-
 - let getter = $parse('user.name');
 - let setter = getter.assign;
 - let context = {user:{name:'AngularJS'}};
@@ -35,11 +31,6 @@
 - setter(context, 'newValue');
 - expect(context.user.name).toEqual('newValue');
 - expect(getter(context, locals)).toEqual('local');
-- ```
-
-  ```
-
--
 -
 - @param {string} expression String expression to compile.
 - @returns {function(context, locals)} a function which represents the compiled expression:
@@ -56,10 +47,6 @@
 -        constant literals.
 -      * `assign` – `{?function(context, value)}` – if the expression is assignable, this will be
 -        set to a function to change its value on the given context.
-- \*/
-
-/\*\*
-
 - @ngdoc provider
 - @name $parseProvider
 -