@angular-wave/angular.ts 0.0.47 → 0.0.49

package/src/core/parser/parse.md

@@ -11,3 +11,60 @@
 // 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.
+-
+- ```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.
+- \*/
+
+/\*\*
+
+- @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/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,45 @@
+import { AST } from "./ast";
+import { isLiteral, isConstant } from "./shared";
+import { ASTInterpreter } from "./interpreter";
+import { ASTCompiler } from "./compiler";
+
+/**
+ * @constructor
+ */
+export class Parser {
+  /**
+   *
+   * @param {import('./lexer').Lexer} lexer
+   * @param {*} $filter
+   * @param {*} options
+   */
+  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/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", () => {

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,13 +45,17 @@ const $rootScopeMinErr = minErr("$rootScope");
 /** @type {AsyncQueueTask[]} */
 export const $$asyncQueue = [];
 export const $$postDigestQueue = [];
+
+/**
+ * @type {Function[]}
+ */
 export const $$applyAsyncQueue = [];
 let postDigestQueuePosition = 0;
 let lastDirtyWatch = null;
 let applyAsyncId = null;
 
 /** Services required by each scope instance */
-/** @type {angular.IParseService} */
+/** @type {import('../parser/parse').ParseService} */
 let $parse;
 /** @type {import('../../services/browser').Browser} */
 let $browser;
@@ -84,9 +88,9 @@ export class $RootScopeProvider {
     "$parse",
     "$browser",
     /**
-     * @param {angular.IParseService} parse
-     * @param {import('../services/browser').Browser} browser
-     * @param {angular.IExceptionHandlerService} exceptionHandler
+     * @param {import('../exception-handler').ErrorHandler} exceptionHandler
+     * @param {import('../parser/parse').ParseService} parse
+     * @param {import('../../services/browser').Browser} browser
      * @returns {Scope} root scope
      */
     function (exceptionHandler, parse, browser) {
@@ -144,7 +148,7 @@ export class Scope {
     this.$root = this;
 
     /**
-     * @type {[]}
+     * @type {Array<any>}
      */
     this.$$watchers = [];
 
@@ -259,7 +263,7 @@ export class Scope {
     if (isolate || parent !== this) {
       child.$on(
         "$destroy",
-        /** @param {angular.IAngularEvent} $event */
+        /** @param {any} $event */ //angular.IAngularEvent
         ($event) => {
           $event.currentScope.$$destroyed = true;
         },
@@ -436,10 +440,10 @@ export class Scope {
    *   values are examined for changes on every call to `$digest`.
    * - The `listener` is called whenever any expression in the `watchExpressions` array changes.
    *
-   * @param {Array.<string|Function(scope)>} watchExpressions Array of expressions that will be individually
+   * @param {Array.<string|((Scope)=>any)>} watchExpressions Array of expressions that will be individually
    * watched using {@link ng.$rootScope.Scope#$watch $watch()}
    *
-   * @param {function(newValues, oldValues, scope)} listener Callback called whenever the return value of any
+   * @param {function(any, any, Scope): any} listener Callback called whenever the return value of any
    *    expression in `watchExpressions` changes
    *    The `newValues` array contains the current values of the `watchExpressions`, with the indexes matching
    *    those of `watchExpression`
@@ -529,12 +533,12 @@ export class Scope {
    *
    *
    *
-   * @param {string|function(scope)} obj Evaluated as {@link guide/expression expression}. The
+   * @param {string|function(Scope):any} obj Evaluated as {@link guide/expression expression}. The
    *    expression value should evaluate to an object or an array which is observed on each
    *    {@link ng.$rootScope.Scope#$digest $digest} cycle. Any shallow change within the
    *    collection will trigger a call to the `listener`.
    *
-   * @param {function(newCollection, oldCollection, scope)} listener a callback function called
+   * @param {function(any[], any[], Scope):any} listener a callback function called
    *    when a change is detected.
    *    - The `newCollection` object is the newly modified data obtained from the `obj` expression
    *    - The `oldCollection` object is a copy of the former collection data.
@@ -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;
     }
   }
 
@@ -1301,7 +1309,7 @@ export class Scope {
    *   - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
    *
    * @param {string} name Event name to listen on.
-   * @param {function(angular.IAngularEvent): any} listener Function to call when the event is emitted.
+   * @param {function(any): any} listener Function to call when the event is emitted witn angular.IAngularEvent
    * @returns {function()} Returns a deregistration function for this listener.
    */
   $on(name, listener) {
@@ -1311,6 +1319,7 @@ export class Scope {
     }
     namedListeners.push(listener);
 
+    /** @type {Scope} */
     let current = this;
     do {
       current.$$listenerCount[name] = (current.$$listenerCount[name] ?? 0) + 1;
@@ -1381,6 +1390,7 @@ export class Scope {
   $emit(name, ...args) {
     const empty = [];
     let namedListeners;
+    /** @type {Scope} */
     let scope = this;
     let stopPropagation = false;
     const event = {
@@ -1421,7 +1431,7 @@ export class Scope {
         break;
       }
       // traverse upwards
-      scope = scope.$parent;
+      scope = /** @type {Scope} */ scope.$parent;
     } while (scope);
 
     event.currentScope = null;
@@ -1452,8 +1462,10 @@ export class Scope {
    */
   $broadcast(name, ...args) {
     const target = this;
+    /** @type {Scope} */
     let current = target;
 
+    /** @type {Scope} */
     let next = target;
     const event = {
       name,

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,