@angular-wave/angular.ts 0.0.48 → 0.0.50

package/src/core/parser/parse.js

@@ -1,62 +1,27 @@
-import {
-  csp,
-  forEach,
-  isDefined,
-  isFunction,
-  minErr,
-} from "../../shared/utils";
+import { forEach, isDefined, isFunction, minErr } from "../../shared/utils";
 import { getValueOf, PURITY_RELATIVE } from "./shared";
 import { Lexer } from "./lexer";
 import { Parser } from "./parser";
 
-export const $parseMinErr = minErr("$parse");
-
-/// ////////////////////////////////
-
 /**
- * @typedef {function(string|function(import('../scope/scope').Scope):any, function(any, Scope, any):any=, boolean=): import('../../types').CompiledExpression} ParseService
+ * @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.
  */
 
 /**
- * @ngdoc service
- * @name $parse
- * @kind function
- *
- * @description
- *
- * Converts AngularJS {@link guide/expression expression} into a function.
- *
- * ```js
- *   let getter = $parse('user.name');
- *   let setter = getter.assign;
- *   let context = {user:{name:'AngularJS'}};
- *   let locals = {user:{name:'local'}};
- *
- *   expect(getter(context)).toEqual('AngularJS');
- *   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:
- *
- *    * `context` – `{object}` – an object against which any expressions embedded in the strings
- *      are evaluated against (typically a scope object).
- *    * `locals` – `{object=}` – local variables context object, useful for overriding values in
- *      `context`.
- *
- *    The returned function also has the following properties:
- *      * `literal` – `{boolean}` – whether the expression's top-level node is a JavaScript
- *        literal.
- *      * `constant` – `{boolean}` – whether the expression is made entirely of JavaScript
- *        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.
- *
+ * @typedef {function(string|function(import('../scope/scope').Scope):any, function(any, import('../scope/scope').Scope, any):any=, boolean=): CompiledExpression} ParseService
  */
 
+export const $parseMinErr = minErr("$parse");
+
 export const literals = {
   true: true,
   false: false,
@@ -64,15 +29,6 @@ export const literals = {
   undefined,
 };
 
-/**
- * @ngdoc provider
- * @name $parseProvider
- *
- *
- * @description
- * `$parseProvider` can be used for configuring the default behavior of the {@link ng.$parse $parse}
- *  service.
- */
 export function $ParseProvider() {
   const cache = Object.create(null);
   const literals = {
@@ -81,7 +37,11 @@ export function $ParseProvider() {
     null: null,
     undefined: undefined,
   };
-  var identStart, identContinue;
+  /** @type {function(any):boolean?} */
+  var identStart;
+
+  /** @type {function(any):boolean?} */
+  var identContinue;
 
   /**
    * @ngdoc method
@@ -99,11 +59,6 @@ export function $ParseProvider() {
   };
 
   /**
-   * @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
@@ -117,10 +72,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=} 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=} 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;
@@ -131,9 +87,7 @@ export function $ParseProvider() {
   this.$get = [
     "$filter",
     function ($filter) {
-      var noUnsafeEval = csp().noUnsafeEval;
       var $parseOptions = {
-        csp: noUnsafeEval,
         literals: structuredClone(literals),
         isIdentifierStart: isFunction(identStart) && identStart,
         isIdentifierContinue: isFunction(identContinue) && identContinue,
@@ -152,7 +106,10 @@ export function $ParseProvider() {
             parsedExpression = cache[cacheKey];
 
             if (!parsedExpression) {
-              var lexer = new Lexer($parseOptions);
+              var lexer = new Lexer({
+                isIdentifierContinue: $parseOptions.isIdentifierContinue,
+                isIdentifierStart: $parseOptions.isIdentifierStart,
+              });
               var parser = new Parser(lexer, $filter, $parseOptions);
               parsedExpression = parser.parse(exp);
 
@@ -168,213 +125,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);
         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;
 
@@ -436,16 +196,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,
@@ -465,7 +225,7 @@ function addWatchDelegate(parsedExpression) {
   return parsedExpression;
 }
 
-export function inputsWatchDelegate(
+function inputsWatchDelegate(
   scope,
   listener,
   objectEquality,
@@ -542,7 +302,7 @@ export function inputsWatchDelegate(
   );
 }
 
-export function oneTimeWatchDelegate(
+function oneTimeWatchDelegate(
   scope,
   listener,
   objectEquality,
@@ -587,7 +347,7 @@ export function oneTimeWatchDelegate(
   return unwatch;
 }
 
-export function chainInterceptors(first, second) {
+function chainInterceptors(first, second) {
   function chainedInterceptor(value) {
     return second(first(value));
   }
@@ -597,7 +357,7 @@ export function chainInterceptors(first, second) {
   return chainedInterceptor;
 }
 
-export function expressionInputDirtyCheck(
+function expressionInputDirtyCheck(
   newValue,
   oldValueOfValue,
   compareObjectIdentity,
@@ -629,7 +389,7 @@ export function expressionInputDirtyCheck(
   );
 }
 
-export function isAllDefined(value) {
+function isAllDefined(value) {
   let allDefined = true;
   forEach(value, (val) => {
     if (!isDefined(val)) allDefined = false;

package/src/core/parser/parse.md

@@ -11,3 +11,47 @@
 // content then it is possible that your application contains a security vulnerability to an XSS style attack.
 //
 // See https://docs.angularjs.org/guide/security
+
+/\*\*
+
+- @ngdoc service
+- @name $parse
+- @kind function
+-
+- @description
+-
+- Converts AngularJS {@link guide/expression expression} into a function.
+-
+- let getter = $parse('user.name');
+- let setter = getter.assign;
+- let context = {user:{name:'AngularJS'}};
+- let locals = {user:{name:'local'}};
+-
+- expect(getter(context)).toEqual('AngularJS');
+- 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:
+-
+- - `context` – `{object}` – an object against which any expressions embedded in the strings
+-      are evaluated against (typically a scope object).
+- - `locals` – `{object=}` – local variables context object, useful for overriding values in
+-      `context`.
+-
+- The returned function also has the following properties:
+-      * `literal` – `{boolean}` – whether the expression's top-level node is a JavaScript
+-        literal.
+-      * `constant` – `{boolean}` – whether the expression is made entirely of JavaScript
+-        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
+-
+-
+- @description
+- `$parseProvider` can be used for configuring the default behavior of the {@link ng.$parse $parse}
+- service.
+  \*/

package/src/core/parser/parser.js

@@ -1,21 +1,43 @@
 import { AST } from "./ast";
 import { isLiteral, isConstant } from "./shared";
 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
+ */
+
+/**
+ * @typedef {Object} ParserOptions
+ * @property {function(string):any} literals
+ */
 
 /**
  * @constructor
  */
 export class Parser {
+  /**
+   *
+   * @param {import('./lexer').Lexer} lexer
+   * @param {function(any):any} $filter
+   * @param {ParserOptions} options
+   */
   constructor(lexer, $filter, options) {
+    /** @type {AST} */
     this.ast = new AST(lexer, options);
-    this.astCompiler = options.csp
-      ? new ASTInterpreter($filter)
-      : new ASTCompiler($filter);
+
+    /** @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);
@@ -23,6 +45,10 @@ export class Parser {
     return fn;
   }
 
+  /**
+   * @param {string} exp - Expression to be parsed
+   * @returns {ParsedAST}
+   */
   getAst(exp) {
     let oneTime = false;
     exp = exp.trim();

package/src/core/parser/shared.js

@@ -61,6 +61,12 @@ export function isPure(node, parentIsPure) {
   return undefined === parentIsPure ? PURITY_RELATIVE : parentIsPure;
 }
 
+/**
+ * Decorates ast with constant, toWatch, and isPure properties
+ * @param {import("./ast").ASTNode} ast
+ * @param {function(any):any} $filter
+ * @param {*} parentIsPure
+ */
 export function findConstantAndWatchExpressions(ast, $filter, parentIsPure) {
   let allConstants;
   let argsToWatch;
@@ -71,7 +77,7 @@ export function findConstantAndWatchExpressions(ast, $filter, parentIsPure) {
   switch (ast.type) {
     case ASTType.Program:
       allConstants = true;
-      /** @type {[any]} */ (ast.body).forEach((expr) => {
+      /** @type {[import("./ast").ASTNode]} */ (ast.body).forEach((expr) => {
         findConstantAndWatchExpressions(expr.expression, $filter, astIsPure);
         allConstants = allConstants && expr.expression.constant;
       });

package/src/core/prop.spec.js

@@ -119,7 +119,7 @@ describe("ngProp*", () => {
   it("should work with different prefixes", () => {
     $rootScope.name = "Misko";
     const element = $compile(
-      '<span ng:prop:test="name" ng-Prop-test2="name" ng_Prop_test3="name"></span>',
+      '<span ng-prop-test="name" ng-Prop-test2="name" ng-Prop-test3="name"></span>',
     )($rootScope);
     expect(element[0].test).toBe("Misko");
     expect(element[0].test2).toBe("Misko");
@@ -138,7 +138,7 @@ describe("ngProp*", () => {
   it("should work if they are prefixed with x- or data- and different prefixes", () => {
     $rootScope.name = "Misko";
     const element = $compile(
-      '<span data-ng-prop-test2="name" ng-prop-test3="name" data-ng:prop-test4="name" ' +
+      '<span data-ng-prop-test2="name" ng-prop-test3="name" data-ng-prop-test4="name" ' +
         'ng-prop-test5="name" ng-prop-test6="name"></span>',
     )($rootScope);
     expect(element[0].test2).toBe("Misko");
@@ -179,7 +179,7 @@ describe("ngProp*", () => {
       }),
     );
     $compile(
-      '<div attr-exposer ng-prop-title="12" ng-prop-super-title="34" ng-prop-my-camel_title="56">',
+      '<div attr-exposer ng-prop-title="12" ng-prop-super-title="34" ng-prop-my-camel-title="56">',
     )($rootScope);
 
     expect(attrs.title).toBeUndefined();
@@ -195,7 +195,7 @@ describe("ngProp*", () => {
     expect(attrs.myCamelTitle).toBeUndefined();
     expect(attrs.$attr.myCamelTitle).toBeUndefined();
     expect(attrs.ngPropMyCamelTitle).toBe("56");
-    expect(attrs.$attr.ngPropMyCamelTitle).toBe("ng-prop-my-camel_title");
+    expect(attrs.$attr.ngPropMyCamelTitle).toBe("ng-prop-my-camel-title");
   });
 
   it("should not conflict with (ng-attr-)attribute mappings of the same name", () => {