@angular-wave/angular.ts 0.0.49 → 0.0.50

package/src/core/parser/parse.js

@@ -1,22 +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} 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=): import('../../types').CompiledExpression} ParseService
+ * @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,
@@ -54,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
@@ -72,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(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,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,
@@ -126,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;
 
@@ -394,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,
@@ -423,7 +225,7 @@ function addWatchDelegate(parsedExpression) {
   return parsedExpression;
 }
 
-export function inputsWatchDelegate(
+function inputsWatchDelegate(
   scope,
   listener,
   objectEquality,
@@ -500,7 +302,7 @@ export function inputsWatchDelegate(
   );
 }
 
-export function oneTimeWatchDelegate(
+function oneTimeWatchDelegate(
   scope,
   listener,
   objectEquality,
@@ -545,7 +347,7 @@ export function oneTimeWatchDelegate(
   return unwatch;
 }
 
-export function chainInterceptors(first, second) {
+function chainInterceptors(first, second) {
   function chainedInterceptor(value) {
     return second(first(value));
   }
@@ -555,7 +357,6 @@ export function chainInterceptors(first, second) {
   return chainedInterceptor;
 }
 
-/** @private */
 function expressionInputDirtyCheck(
   newValue,
   oldValueOfValue,
@@ -588,7 +389,6 @@ function expressionInputDirtyCheck(
   );
 }
 
-/** @private */
 function isAllDefined(value) {
   let allDefined = true;
   forEach(value, (val) => {

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
 -

package/src/core/parser/parser.js

@@ -1,7 +1,17 @@
 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
@@ -10,18 +20,24 @@ export class Parser {
   /**
    *
    * @param {import('./lexer').Lexer} lexer
-   * @param {*} $filter
-   * @param {*} options
+   * @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);
@@ -29,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/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/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

@@ -12,7 +12,10 @@
  */
 
 /**
- * @typedef {Object|function(any, any=): any} CompiledExpression
+ * @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,