@angular-wave/angular.ts 0.0.46 → 0.0.48

package/src/core/parser/parse.spec.js

@@ -1,4 +1,5 @@
-import { AST, Lexer } from "./parse";
+import { AST } from "./ast";
+import { Lexer } from "./lexer";
 import {
   forEach,
   isFunction,
@@ -2366,7 +2367,6 @@ describe("parser", () => {
 
       it("should evaluate negation", () => {
         expect(scope.$eval("!false || true")).toEqual(!false || true);
-        // eslint-disable-next-line eqeqeq
         expect(scope.$eval("!11 == 10")).toEqual(!11 == 10);
         expect(scope.$eval("12/6/2")).toEqual(12 / 6 / 2);
       });

package/src/core/parser/parser.js

@@ -0,0 +1,39 @@
+import { AST } from "./ast";
+import { isLiteral, isConstant } from "./shared";
+import { ASTInterpreter } from "./interpreter";
+import { ASTCompiler } from "./compiler";
+
+/**
+ * @constructor
+ */
+export class Parser {
+  constructor(lexer, $filter, options) {
+    this.ast = new AST(lexer, options);
+    this.astCompiler = options.csp
+      ? new ASTInterpreter($filter)
+      : new ASTCompiler($filter);
+  }
+
+  parse(text) {
+    const { ast, oneTime } = this.getAst(text);
+    const fn = this.astCompiler.compile(ast);
+    fn.literal = isLiteral(ast);
+    fn.constant = isConstant(ast);
+    fn.oneTime = oneTime;
+    return fn;
+  }
+
+  getAst(exp) {
+    let oneTime = false;
+    exp = exp.trim();
+
+    if (exp.startsWith("::")) {
+      oneTime = true;
+      exp = exp.substring(2);
+    }
+    return {
+      ast: this.ast.ast(exp),
+      oneTime,
+    };
+  }
+}

package/src/core/parser/shared.js

@@ -0,0 +1,228 @@
+import { ASTType } from "./ast-type";
+import { forEach, isFunction } from "../../shared/utils";
+
+const objectValueOf = {}.constructor.prototype.valueOf;
+
+/**
+ * Converts parameter to  strings property name for use  as keys in an object.
+ * Any non-string object, including a number, is typecasted into a string via the toString method.
+ * {@link https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Property_accessors#Property_names}
+ *
+ * @param {!any} name
+ * @returns {string}
+ */
+export function getStringValue(name) {
+  return `${name}`;
+}
+
+/// //////////////////////////////////////
+
+export function ifDefined(v, d) {
+  return typeof v !== "undefined" ? v : d;
+}
+
+export function plusFn(l, r) {
+  if (typeof l === "undefined") return r;
+  if (typeof r === "undefined") return l;
+  return l + r;
+}
+
+export function isStateless($filter, filterName) {
+  const fn = $filter(filterName);
+  return !fn.$stateful;
+}
+
+export const PURITY_ABSOLUTE = 1;
+export const PURITY_RELATIVE = 2;
+
+// Detect nodes which could depend on non-shallow state of objects
+export function isPure(node, parentIsPure) {
+  switch (node.type) {
+    // Computed members might invoke a stateful toString()
+    case ASTType.MemberExpression:
+      if (node.computed) {
+        return false;
+      }
+      break;
+
+    // Unary always convert to primative
+    case ASTType.UnaryExpression:
+      return PURITY_ABSOLUTE;
+
+    // The binary + operator can invoke a stateful toString().
+    case ASTType.BinaryExpression:
+      return node.operator !== "+" ? PURITY_ABSOLUTE : false;
+
+    // Functions / filters probably read state from within objects
+    case ASTType.CallExpression:
+      return false;
+  }
+
+  return undefined === parentIsPure ? PURITY_RELATIVE : parentIsPure;
+}
+
+export function findConstantAndWatchExpressions(ast, $filter, parentIsPure) {
+  let allConstants;
+  let argsToWatch;
+  let isStatelessFilter;
+
+  const astIsPure = (ast.isPure = isPure(ast, parentIsPure));
+
+  switch (ast.type) {
+    case ASTType.Program:
+      allConstants = true;
+      /** @type {[any]} */ (ast.body).forEach((expr) => {
+        findConstantAndWatchExpressions(expr.expression, $filter, astIsPure);
+        allConstants = allConstants && expr.expression.constant;
+      });
+      ast.constant = allConstants;
+      break;
+    case ASTType.Literal:
+      ast.constant = true;
+      ast.toWatch = [];
+      break;
+    case ASTType.UnaryExpression:
+      findConstantAndWatchExpressions(ast.argument, $filter, astIsPure);
+      ast.constant = ast.argument.constant;
+      ast.toWatch = ast.argument.toWatch;
+      break;
+    case ASTType.BinaryExpression:
+      findConstantAndWatchExpressions(ast.left, $filter, astIsPure);
+      findConstantAndWatchExpressions(ast.right, $filter, astIsPure);
+      ast.constant = ast.left.constant && ast.right.constant;
+      ast.toWatch = ast.left.toWatch.concat(ast.right.toWatch);
+      break;
+    case ASTType.LogicalExpression:
+      findConstantAndWatchExpressions(ast.left, $filter, astIsPure);
+      findConstantAndWatchExpressions(ast.right, $filter, astIsPure);
+      ast.constant = ast.left.constant && ast.right.constant;
+      ast.toWatch = ast.constant ? [] : [ast];
+      break;
+    case ASTType.ConditionalExpression:
+      findConstantAndWatchExpressions(ast.test, $filter, astIsPure);
+      findConstantAndWatchExpressions(ast.alternate, $filter, astIsPure);
+      findConstantAndWatchExpressions(ast.consequent, $filter, astIsPure);
+      ast.constant =
+        ast.test.constant && ast.alternate.constant && ast.consequent.constant;
+      ast.toWatch = ast.constant ? [] : [ast];
+      break;
+    case ASTType.Identifier:
+      ast.constant = false;
+      ast.toWatch = [ast];
+      break;
+    case ASTType.MemberExpression:
+      findConstantAndWatchExpressions(ast.object, $filter, astIsPure);
+      if (ast.computed) {
+        findConstantAndWatchExpressions(ast.property, $filter, astIsPure);
+      }
+      ast.constant =
+        ast.object.constant && (!ast.computed || ast.property.constant);
+      ast.toWatch = ast.constant ? [] : [ast];
+      break;
+    case ASTType.CallExpression:
+      isStatelessFilter = ast.filter
+        ? isStateless($filter, ast.callee.name)
+        : false;
+      allConstants = isStatelessFilter;
+      argsToWatch = [];
+      forEach(ast.arguments, (expr) => {
+        findConstantAndWatchExpressions(expr, $filter, astIsPure);
+        allConstants = allConstants && expr.constant;
+        argsToWatch.push.apply(argsToWatch, expr.toWatch);
+      });
+      ast.constant = allConstants;
+      ast.toWatch = isStatelessFilter ? argsToWatch : [ast];
+      break;
+    case ASTType.AssignmentExpression:
+      findConstantAndWatchExpressions(ast.left, $filter, astIsPure);
+      findConstantAndWatchExpressions(ast.right, $filter, astIsPure);
+      ast.constant = ast.left.constant && ast.right.constant;
+      ast.toWatch = [ast];
+      break;
+    case ASTType.ArrayExpression:
+      allConstants = true;
+      argsToWatch = [];
+      forEach(ast.elements, (expr) => {
+        findConstantAndWatchExpressions(expr, $filter, astIsPure);
+        allConstants = allConstants && expr.constant;
+        argsToWatch.push.apply(argsToWatch, expr.toWatch);
+      });
+      ast.constant = allConstants;
+      ast.toWatch = argsToWatch;
+      break;
+    case ASTType.ObjectExpression:
+      allConstants = true;
+      argsToWatch = [];
+      forEach(ast.properties, (property) => {
+        findConstantAndWatchExpressions(property.value, $filter, astIsPure);
+        allConstants = allConstants && property.value.constant;
+        argsToWatch.push.apply(argsToWatch, property.value.toWatch);
+        if (property.computed) {
+          // `{[key]: value}` implicitly does `key.toString()` which may be non-pure
+          findConstantAndWatchExpressions(
+            property.key,
+            $filter,
+            /* parentIsPure= */ false,
+          );
+          allConstants = allConstants && property.key.constant;
+          argsToWatch.push.apply(argsToWatch, property.key.toWatch);
+        }
+      });
+      ast.constant = allConstants;
+      ast.toWatch = argsToWatch;
+      break;
+    case ASTType.ThisExpression:
+      ast.constant = false;
+      ast.toWatch = [];
+      break;
+    case ASTType.LocalsExpression:
+      ast.constant = false;
+      ast.toWatch = [];
+      break;
+  }
+}
+
+export function getInputs(body) {
+  if (body.length !== 1) return;
+  const lastExpression = body[0].expression;
+  const candidate = lastExpression.toWatch;
+  if (candidate.length !== 1) return candidate;
+  return candidate[0] !== lastExpression ? candidate : undefined;
+}
+
+export function isAssignable(ast) {
+  return (
+    ast.type === ASTType.Identifier || ast.type === ASTType.MemberExpression
+  );
+}
+
+export function assignableAST(ast) {
+  if (ast.body.length === 1 && isAssignable(ast.body[0].expression)) {
+    return {
+      type: ASTType.AssignmentExpression,
+      left: ast.body[0].expression,
+      right: { type: ASTType.NGValueParameter },
+      operator: "=",
+    };
+  }
+}
+
+export 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))
+  );
+}
+
+export function isConstant(ast) {
+  return ast.constant;
+}
+
+export function getValueOf(value) {
+  return isFunction(value.valueOf)
+    ? value.valueOf()
+    : objectValueOf.call(value);
+}

package/src/core/q/q.spec.js

@@ -811,7 +811,6 @@ describe("all", function () {
     });
 
     it("should support the instanceof operator", () => {
-      // eslint-disable-next-line new-cap
       let promise = $q(() => {});
       expect(promise instanceof $q).toBe(true);
       promise = new $q(() => {});

package/src/core/sce/sce.js

@@ -46,12 +46,9 @@ export const SCE_CONTEXTS = {
 // http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1021
 // Prereq: s is a string.
 export function escapeForRegexp(s) {
-  return (
-    s
-      .replace(/([-()[\]{}+?*.$^|,:#<!\\])/g, "\\$1")
-      // eslint-disable-next-line no-control-regex
-      .replace(/\x08/g, "\\x08")
-  );
+  return s
+    .replace(/([-()[\]{}+?*.$^|,:#<!\\])/g, "\\$1")
+    .replace(/\x08/g, "\\x08");
 }
 
 export function adjustMatcher(matcher) {

package/src/core/scope/scope.js

@@ -45,6 +45,10 @@ const $rootScopeMinErr = minErr("$rootScope");
 /** @type {AsyncQueueTask[]} */
 export const $$asyncQueue = [];
 export const $$postDigestQueue = [];
+
+/**
+ * @type {Function[]}
+ */
 export const $$applyAsyncQueue = [];
 let postDigestQueuePosition = 0;
 let lastDirtyWatch = null;
@@ -84,9 +88,9 @@ export class $RootScopeProvider {
     "$parse",
     "$browser",
     /**
+     * @param {import('../exception-handler').ErrorHandler} exceptionHandler
      * @param {angular.IParseService} parse
-     * @param {import('../services/browser').Browser} browser
-     * @param {angular.IExceptionHandlerService} exceptionHandler
+     * @param {import('../../services/browser').Browser} browser
      * @returns {Scope} root scope
      */
     function (exceptionHandler, parse, browser) {
@@ -606,7 +610,6 @@ export class Scope {
           oldItem = oldValue[i];
           newItem = newValue[i];
 
-          // eslint-disable-next-line no-self-compare
           bothNaN = oldItem !== oldItem && newItem !== newItem;
           if (!bothNaN && oldItem !== newItem) {
             changeDetected++;
@@ -629,7 +632,6 @@ export class Scope {
             oldItem = oldValue[key];
 
             if (key in oldValue) {
-              // eslint-disable-next-line no-self-compare
               bothNaN = oldItem !== oldItem && newItem !== newItem;
               if (!bothNaN && oldItem !== newItem) {
                 changeDetected++;
@@ -1238,13 +1240,19 @@ export class Scope {
     } catch (e) {
       $exceptionHandler(e);
     } finally {
-      try {
-        this.$root.$digest();
-      } catch (e) {
-        $exceptionHandler(e);
-        // eslint-disable-next-line no-unsafe-finally
-        throw e;
-      }
+      this.retry();
+    }
+  }
+
+  /**
+   * @private
+   */
+  retry() {
+    try {
+      this.$root.$digest();
+    } catch (e) {
+      $exceptionHandler(e);
+      throw e;
     }
   }
 

package/src/core/task-tracker-factory.js

@@ -1,5 +1,4 @@
 export function $$TaskTrackerFactoryProvider() {
-  // eslint-disable-next-line no-use-before-define
   this.$get = [
     "$log",
     /** @param {import('../services/log').LogService} log */

package/src/directive/attrs/attrs.js

@@ -1,194 +1,13 @@
 import { BOOLEAN_ATTR } from "../../shared/jqlite/jqlite";
-import { forEach, directiveNormalize } from "../../shared/utils";
+import { directiveNormalize } from "../../shared/utils";
 import { ALIASED_ATTR } from "../../shared/constants";
 
-/**
- * @ngdoc directive
- * @name ngHref
- * @restrict A
- * @priority 99
- *
- * @description
- * Using AngularJS markup like `{{hash}}` in an href attribute will
- * make the link go to the wrong URL if the user clicks it before
- * AngularJS has a chance to replace the `{{hash}}` markup with its
- * value. Until AngularJS replaces the markup the link will be broken
- * and will most likely return a 404 error. The `ngHref` directive
- * solves this problem.
- *
- * The wrong way to write it:
- * ```html
- * <a href="http://www.gravatar.com/avatar/{{hash}}">link1</a>
- * ```
- *
- * The correct way to write it:
- * ```html
- * <a ng-href="http://www.gravatar.com/avatar/{{hash}}">link1</a>
- * ```
- *
- * @element A
- * @param {template} ngHref any string which can contain `{{}}` markup.
- *
- */
-
 export const REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
-/**
- * @ngdoc directive
- * @name ngSrc
- * @restrict A
- * @priority 99
- *
- * @description
- * Using AngularJS markup like `{{hash}}` in a `src` attribute doesn't
- * work right: The browser will fetch from the URL with the literal
- * text `{{hash}}` until AngularJS replaces the expression inside
- * `{{hash}}`. The `ngSrc` directive solves this problem.
- *
- * The buggy way to write it:
- * ```html
- * <img src="http://www.gravatar.com/avatar/{{hash}}" alt="Description"/>
- * ```
- *
- * The correct way to write it:
- * ```html
- * <img ng-src="http://www.gravatar.com/avatar/{{hash}}" alt="Description" />
- * ```
- *
- * @element IMG
- * @param {template} ngSrc any string which can contain `{{}}` markup.
- */
-
-/**
- * @ngdoc directive
- * @name ngSrcset
- * @restrict A
- * @priority 99
- *
- * @description
- * Using AngularJS markup like `{{hash}}` in a `srcset` attribute doesn't
- * work right: The browser will fetch from the URL with the literal
- * text `{{hash}}` until AngularJS replaces the expression inside
- * `{{hash}}`. The `ngSrcset` directive solves this problem.
- *
- * The buggy way to write it:
- * ```html
- * <img srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description"/>
- * ```
- *
- * The correct way to write it:
- * ```html
- * <img ng-srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description" />
- * ```
- *
- * @element IMG
- * @param {template} ngSrcset any string which can contain `{{}}` markup.
- */
-
-/**
- * @ngdoc directive
- * @name ngDisabled
- * @restrict A
- * @priority 100
- *
- * @description
- *
- * This directive sets the `disabled` attribute on the element (typically a form control,
- * e.g. `input`, `button`, `select` etc.) if the
- * {@link guide/expression expression} inside `ngDisabled` evaluates to truthy.
- *
- * A special directive is necessary because we cannot use interpolation inside the `disabled`
- * attribute. See the {@link guide/interpolation interpolation guide} for more info.
- *
- * @param {string} ngDisabled If the {@link guide/expression expression} is truthy,
- *     then the `disabled` attribute will be set on the element
- */
-
-/**
- * @ngdoc directive
- * @name ngChecked
- * @restrict A
- * @priority 100
- *
- * @description
- * Sets the `checked` attribute on the element, if the expression inside `ngChecked` is truthy.
- *
- * Note that this directive should not be used together with {@link ngModel `ngModel`},
- * as this can lead to unexpected behavior.
- *
- * A special directive is necessary because we cannot use interpolation inside the `checked`
- * attribute. See the {@link guide/interpolation interpolation guide} for more info.
- *
- * @element INPUT
- * @param {string} ngChecked If the {@link guide/expression expression} is truthy,
- *     then the `checked` attribute will be set on the element
- */
-
-/**
- *
- * @description
- *
- * Sets the `readonly` attribute on the element, if the expression inside `ngReadonly` is truthy.
- * Note that `readonly` applies only to `input` elements with specific types. [See the input docs on
- * MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly) for more information.
- *
- * A special directive is necessary because we cannot use interpolation inside the `readonly`
- * attribute. See the {@link guide/interpolation interpolation guide} for more info.
- * @element INPUT
- * @param {string} ngReadonly If the {@link guide/expression expression} is truthy,
- *     then special attribute "readonly" will be set on the element
- */
-
-/**
- * @ngdoc directive
- * @name ngSelected
- * @restrict A
- * @priority 100
- *
- * @description
- *
- * Sets the `selected` attribute on the element, if the expression inside `ngSelected` is truthy.
- *
- * A special directive is necessary because we cannot use interpolation inside the `selected`
- * attribute. See the {@link guide/interpolation interpolation guide} for more info.
- *
- * <div class="alert alert-warning">
- *   **Note:** `ngSelected` does not interact with the `select` and `ngModel` directives, it only
- *   sets the `selected` attribute on the element. If you are using `ngModel` on the select, you
- *   should not use `ngSelected` on the options, as `ngModel` will set the select value and
- *   selected options.
- * </div>
- * @element OPTION
- * @param {string} ngSelected If the {@link guide/expression expression} is truthy,
- *     then special attribute "selected" will be set on the element
- */
-
-/**
- * @ngdoc directive
- * @name ngOpen
- * @restrict A
- * @priority 100
- *
- * @description
- *
- * Sets the `open` attribute on the element, if the expression inside `ngOpen` is truthy.
- *
- * A special directive is necessary because we cannot use interpolation inside the `open`
- * attribute. See the {@link guide/interpolation interpolation guide} for more info.
- *
- * ## A note about browser compatibility
- *
- * Internet Explorer and Edge do not support the `details` element, it is
- * recommended to use {@link ng.ngShow} and {@link ng.ngHide} instead.
- *
- * @element DETAILS
- * @param {string} ngOpen If the {@link guide/expression expression} is truthy,
- *     then special attribute "open" will be set on the element
- */
 
 export const ngAttributeAliasDirectives = {};
 
 // boolean attrs are evaluated
-forEach(BOOLEAN_ATTR, (propName, attrName) => {
+Object.entries(BOOLEAN_ATTR).forEach(([attrName, propName]) => {
   // binding to multiple is not supported
   if (propName === "multiple") return;
 
@@ -220,7 +39,7 @@ forEach(BOOLEAN_ATTR, (propName, attrName) => {
 });
 
 // aliased input attrs are evaluated
-forEach(ALIASED_ATTR, (htmlAttr, ngAttr) => {
+Object.entries(ALIASED_ATTR).forEach(([ngAttr]) => {
   ngAttributeAliasDirectives[ngAttr] = function () {
     return {
       priority: 100,
@@ -244,7 +63,7 @@ forEach(ALIASED_ATTR, (htmlAttr, ngAttr) => {
 });
 
 // ng-src, ng-srcset, ng-href are interpolated
-forEach(["src", "srcset", "href"], (attrName) => {
+["src", "srcset", "href"].forEach((attrName) => {
   const normalized = directiveNormalize(`ng-${attrName}`);
   ngAttributeAliasDirectives[normalized] = [
     "$sce",