@angular-wave/angular.ts 0.0.47 → 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/class/class.js

@@ -1,7 +1,6 @@
 import { forEach, isObject, isString } from "../../shared/utils";
 
 function classDirective(name, selector) {
-  // eslint-disable-next-line no-param-reassign
   name = `ngClass${name}`;
   var indexWatchExpression;
 
@@ -24,7 +23,6 @@ function classDirective(name, selector) {
         if (name !== "ngClass") {
           if (!indexWatchExpression) {
             indexWatchExpression = $parse("$index", function moduloTwo($index) {
-              // eslint-disable-next-line no-bitwise
               return $index & 1;
             });
           }

package/src/directive/form/form.js

@@ -244,7 +244,6 @@ FormController.prototype = {
     forEach(
       this.$pending,
       function (value, name) {
-        // eslint-disable-next-line no-invalid-this
         this.$setValidity(name, null, control);
       },
       this,
@@ -252,7 +251,6 @@ FormController.prototype = {
     forEach(
       this.$error,
       function (value, name) {
-        // eslint-disable-next-line no-invalid-this
         this.$setValidity(name, null, control);
       },
       this,
@@ -260,7 +258,6 @@ FormController.prototype = {
     forEach(
       this.$$success,
       function (value, name) {
-        // eslint-disable-next-line no-invalid-this
         this.$setValidity(name, null, control);
       },
       this,

package/src/directive/include/include.js

@@ -49,7 +49,7 @@ export const ngIncludeDirective = [
               $anchorScroll();
             }
           };
-          // eslint-disable-next-line no-plusplus
+
           const thisChangeId = ++changeCounter;
           if (src) {
             // set the 2nd param to true to ignore the template request error so that the inner

package/src/directive/include/include.spec.js

@@ -381,7 +381,6 @@ describe("ngInclude", () => {
       await wait(100);
       const child = element.find("rect");
       expect(child.length).toBe(2);
-      //   // eslint-disable-next-line no-undef
       expect(child[0] instanceof SVGRectElement).toBe(true);
     });
 

package/src/directive/input/input.js

@@ -34,7 +34,7 @@ export const ISO_DATE_REGEXP =
 //                 1111111111111111 222   333333    44444        55555555555555555555555     666     77777777     8888888     999
 export const URL_REGEXP =
   /^[a-z][a-z\d.+-]*:\/*(?:[^:@]+(?::[^@]+)?@)?(?:[^\s:/?#]+|\[[a-f\d:]+])(?::\d+)?(?:\/[^?#]*)?(?:\?[^#]*)?(?:#.*)?$/i;
-// eslint-disable-next-line max-len
+
 export const EMAIL_REGEXP =
   /^(?=.{1,254}$)(?=.{1,64}@)[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+(\.[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+)*@[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/;
 const NUMBER_REGEXP = /^\s*(-|\+)?(\d+|(\d*(\.\d*)))([eE][+-]?\d+)?\s*$/;
@@ -1144,7 +1144,6 @@ export function isNumberInteger(num) {
   // See http://stackoverflow.com/questions/14636536/how-to-check-if-a-variable-is-an-integer-in-javascript#14794066
   // (minus the assumption that `num` is a number)
 
-  // eslint-disable-next-line no-bitwise
   return (num | 0) === num;
 }
 

package/src/directive/model/model.js

@@ -328,7 +328,6 @@ NgModelController.prototype = {
    * @returns {boolean} True if `value` is "empty".
    */
   $isEmpty(value) {
-    // eslint-disable-next-line no-self-compare
     return (
       isUndefined(value) || value === "" || value === null || value !== value
     );
@@ -771,7 +770,6 @@ NgModelController.prototype = {
         try {
           listener();
         } catch (e) {
-          // eslint-disable-next-line no-invalid-this
           this.$$exceptionHandler(e);
         }
       },
@@ -1082,7 +1080,7 @@ function setupModelWatcher(ctrl) {
     if (
       modelValue !== ctrl.$modelValue &&
       // checks for NaN is needed to allow setting the model to NaN when there's an asyncValidator
-      // eslint-disable-next-line no-self-compare
+
       (ctrl.$modelValue === ctrl.$modelValue || modelValue === modelValue)
     ) {
       ctrl.$$setModelValue(modelValue);

package/src/directive/model/model.spec.js

@@ -1173,7 +1173,6 @@ describe("ngModel", () => {
       });
 
       it("should be possible to extend Object prototype and still be able to do form validation", () => {
-        // eslint-disable-next-line no-extend-native
         Object.prototype.someThing = function () {};
         const element = $compile(
           '<form name="myForm">' +

package/src/directive/repeat/repeat.spec.js

@@ -129,7 +129,6 @@ describe("ngRepeat", () => {
 
   it("should iterate over an array-like class", () => {
     function Collection() {}
-    // eslint-disable-next-line no-array-constructor
     Collection.prototype = new Array();
     Collection.prototype.length = 0;
 
@@ -296,7 +295,6 @@ describe("ngRepeat", () => {
           "</ul>",
       )(scope);
 
-      // eslint-disable-next-line no-extend-native
       Array.prototype.extraProperty = "should be ignored";
       // INIT
       scope.items = [true, true, true];

package/src/exts/aria/aria.js

@@ -128,7 +128,6 @@ export function initAriaModule() {
 
                 function getRadioReaction() {
                   // Strict comparison would cause a BC
-                  // eslint-disable-next-line eqeqeq
                   elem[0].setAttribute(
                     "aria-checked",
                     (attr.value == ngModel.$viewValue).toString(),

package/src/filters/filter.spec.js

@@ -434,7 +434,6 @@ describe("Filter: filter", () => {
   });
 
   it("should not be affected by `Object.prototype` when using a string expression", () => {
-    // eslint-disable-next-line no-extend-native
     Object.prototype.someProp = "oo";
 
     const items = [

package/src/injector.js

@@ -275,7 +275,7 @@ export function createInjector(modulesToLoad, strictDi) {
           // unlike those of Chrome and IE
           // So if stack doesn't contain message, we create a new string that contains both.
           // Since error.stack is read-only in Safari, I'm overriding e and not e.stack here.
-          // eslint-disable-next-line no-ex-assign
+
           e = `${e.message}\n${e.stack}`;
         }
         throw $injectorMinErr(

package/src/injector.spec.js

@@ -461,21 +461,17 @@ describe("annotate", () => {
 
   describe("es6", () => {
     it("should be possible to annotate shorthand methods", () => {
-      // eslint-disable-next-line no-eval
       expect(annotate(eval("({ fn(x) { return; } })").fn)).toEqual(["x"]);
     });
 
     it("should create $inject for arrow functions", () => {
-      // eslint-disable-next-line no-eval
       expect(annotate(eval("(a, b) => a"))).toEqual(["a", "b"]);
     });
     it("should create $inject for arrow functions with no parenthesis", () => {
-      // eslint-disable-next-line no-eval
       expect(annotate(eval("a => a"))).toEqual(["a"]);
     });
 
     it("should take args before first arrow", () => {
-      // eslint-disable-next-line no-eval
       expect(annotate(eval("a => b => b"))).toEqual(["a"]);
     });
 
@@ -492,7 +488,6 @@ describe("annotate", () => {
         "class/* Test */{}",
         "class /* Test */ {}",
       ].forEach((classDefinition) => {
-        // eslint-disable-next-line no-eval
         const Clazz = eval(`(${classDefinition})`);
         const instance = injector.invoke(Clazz);
 

package/src/loader.js

@@ -174,7 +174,6 @@ export class Angular {
  * @returns {angular.auto.IInjectorService} Returns the newly created injector for this app.
  */
   bootstrap(element, modules, config) {
-    // eslint-disable-next-line no-param-reassign
     config = config || {
       debugInfoEnabled: false,
       strictDi: false,
@@ -333,7 +332,6 @@ export class Angular {
     }
 
     function ensure(obj, name, factory) {
-      // eslint-disable-next-line no-return-assign, no-param-reassign
       return obj[name] || (obj[name] = factory());
     }
 
@@ -357,7 +355,6 @@ export class Angular {
       /** @type {!Array.<Function>} */
       const runBlocks = [];
 
-      // eslint-disable-next-line no-use-before-define
       const config = invokeLater("$injector", "invoke", "push", configBlocks);
 
       /** @type {import('./types').Module} */
@@ -883,7 +880,6 @@ export function setupModuleLoader(window) {
   const $injectorMinErr = minErr("$injector");
 
   function ensure(obj, name, factory) {
-    // eslint-disable-next-line no-return-assign
     return obj[name] || (obj[name] = factory());
   }
 
@@ -974,7 +970,6 @@ export function setupModuleLoader(window) {
         /** @type {!Array.<Function>} */
         const runBlocks = [];
 
-        // eslint-disable-next-line no-use-before-define
         const config = invokeLater("$injector", "invoke", "push", configBlocks);
 
         /** @type {import('./types').Module} */

package/src/services/cookie-reader.js

@@ -43,7 +43,6 @@ export function $$CookieReader($document) {
       cookieArray = lastCookieString.split("; ");
       lastCookies = {};
 
-      // eslint-disable-next-line no-plusplus
       for (i = 0; i < cookieArray.length; i++) {
         cookie = cookieArray[i];
         index = cookie.indexOf("=");

package/src/services/http/http.spec.js

@@ -2417,7 +2417,6 @@ describe("$http", function () {
 //         it("should ignore Blob objects", () => {
 //           if (!window.Blob) return;
 
-//           // eslint-disable-next-line no-undef
 //           const blob = new Blob(["blob!"], { type: "text/plain" });
 
 //           $httpBackend.expect("POST", "/url", "[object Blob]").respond("");
@@ -2427,7 +2426,6 @@ describe("$http", function () {
 //         it("should ignore FormData objects", () => {
 //           if (!window.FormData) return;
 
-//           // eslint-disable-next-line no-undef
 //           const formData = new FormData();
 //           formData.append("angular", "is great");