@angular-wave/angular.ts 0.7.8 → 0.8.1

package/src/core/parse/parse.js

@@ -3,173 +3,177 @@ import { PURITY_RELATIVE } from "./interpreter.js";
 import { Lexer } from "./lexer/lexer.js";
 import { Parser } from "./parser/parser.js";
 
-export function ParseProvider() {
-  const cache = Object.create(null);
-
-  /** @type {function(any):boolean?} */
-  let identStart;
-
-  /** @type {function(any):boolean?} */
-  let identContinue;
-
-  /**
-   * Allows defining the set of characters that are allowed in AngularTS 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
-   * a given character is a valid character to be a follow-up identifier character. The functions
-   * `identifierStart` and `identifierContinue` will receive as arguments the single character to be
-   * identifier and the character code point. These arguments will be `string` and `numeric`. Keep in
-   * mind that the `string` parameter can be two characters long depending on the character
-   * representation. It is expected for the function to return `true` or `false`, whether that
-   * character is allowed or not.
-   *
-   * 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
-   *   a valid identifier start character.
-   * @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;
-    identContinue = identifierContinue;
-    return this;
-  };
-
-  this.$get = [
-    "$filter",
+export class ParseProvider {
+  constructor() {
+    const cache = Object.create(null);
+
+    /** @type {function(any):boolean?} */
+    let identStart;
+
+    /** @type {function(any):boolean?} */
+    let identContinue;
+
     /**
+     * Allows defining the set of characters that are allowed in AngularTS 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
+     * a given character is a valid character to be a follow-up identifier character. The functions
+     * `identifierStart` and `identifierContinue` will receive as arguments the single character to be
+     * identifier and the character code point. These arguments will be `string` and `numeric`. Keep in
+     * mind that the `string` parameter can be two characters long depending on the character
+     * representation. It is expected for the function to return `true` or `false`, whether that
+     * character is allowed or not.
      *
-     * @param {(any) => any} $filter
-     * @returns {import('./interface').ParseService}
+     * 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
+     *   a valid identifier start character.
+     * @param {function(any):boolean} [identifierContinue] The function that will decide whether the given character is
+     *   a valid identifier continue character.
+     * @returns {ParseProvider}
      */
-    function ($filter) {
-      /** @type {import("./lexer/lexer.js").LexerOptions} */
-      const $lexerOptions = {
-        isIdentifierStart: isFunction(identStart) && identStart,
-        isIdentifierContinue: isFunction(identContinue) && identContinue,
-      };
-      return $parse;
-
+    this.setIdentifierFns = function (identifierStart, identifierContinue) {
+      identStart = identifierStart;
+      identContinue = identifierContinue;
+      return this;
+    };
+
+    this.$get = [
+      "$filter",
       /**
-       * @param {string} exp
-       * @param interceptorFn
-       * @returns any
+       *
+       * @param {(any) => any} $filter
+       * @returns {import('./interface').ParseService}
        */
-      function $parse(exp, interceptorFn) {
-        let parsedExpression, cacheKey;
+      function ($filter) {
+        /** @type {import("./lexer/lexer.js").LexerOptions} */
+        const $lexerOptions = {
+          isIdentifierStart: isFunction(identStart) && identStart,
+          isIdentifierContinue: isFunction(identContinue) && identContinue,
+        };
+        return $parse;
 
-        switch (typeof exp) {
-          case "string":
-            exp = exp.trim();
-            cacheKey = exp;
+        /**
+         * @param {string} exp
+         * @param interceptorFn
+         * @returns any
+         */
+        function $parse(exp, interceptorFn) {
+          let parsedExpression, cacheKey;
 
-            parsedExpression = cache[cacheKey];
+          switch (typeof exp) {
+            case "string":
+              exp = exp.trim();
+              cacheKey = exp;
 
-            if (!parsedExpression) {
-              const lexer = new Lexer($lexerOptions);
-              const parser = new Parser(lexer, $filter);
-              parsedExpression = parser.parse(exp);
+              parsedExpression = cache[cacheKey];
 
-              cache[cacheKey] = addWatchDelegate(parsedExpression);
-            }
-            return addInterceptor(parsedExpression, interceptorFn);
+              if (!parsedExpression) {
+                const lexer = new Lexer($lexerOptions);
+                const parser = new Parser(lexer, $filter);
+                parsedExpression = parser.parse(exp);
 
-          case "function":
-            return addInterceptor(exp, interceptorFn);
+                cache[cacheKey] = addWatchDelegate(parsedExpression);
+              }
+              return addInterceptor(parsedExpression, interceptorFn);
 
-          default:
-            return addInterceptor(() => {}, interceptorFn);
-        }
-      }
+            case "function":
+              return addInterceptor(exp, interceptorFn);
 
-      /**
-       * @param {Function} parsedExpression
-       * @param interceptorFn
-       * @returns {import('./interface').CompiledExpression|*}
-       */
-      function addInterceptor(parsedExpression, interceptorFn) {
-        if (!interceptorFn) return parsedExpression;
-
-        // Extract any existing interceptors out of the parsedExpression
-        // to ensure the original parsedExpression is always the $$intercepted
-        // @ts-ignore
-        if (parsedExpression.$$interceptor) {
-          interceptorFn = chainInterceptors(
-            // @ts-ignore
-            parsedExpression.$$interceptor,
-            interceptorFn,
-          );
-          // @ts-ignore
-          parsedExpression = parsedExpression.$$intercepted;
+            default:
+              return addInterceptor(() => {}, interceptorFn);
+          }
         }
 
-        let useInputs = false;
+        /**
+         * @param {Function} parsedExpression
+         * @param interceptorFn
+         * @returns {import('./interface').CompiledExpression|*}
+         */
+        function addInterceptor(parsedExpression, interceptorFn) {
+          if (!interceptorFn) {
+            return parsedExpression;
+          }
 
-        const fn = function interceptedExpression(
-          scope,
-          locals,
-          assign,
-          inputs,
-        ) {
-          const value =
-            useInputs && inputs
-              ? inputs[0]
-              : parsedExpression(scope, locals, assign, inputs);
-          // Do not invoke for getters
-          if (scope?.getter) {
-            return;
+          // Extract any existing interceptors out of the parsedExpression
+          // to ensure the original parsedExpression is always the $$intercepted
+          // @ts-ignore
+          if (parsedExpression.$$interceptor) {
+            interceptorFn = chainInterceptors(
+              // @ts-ignore
+              parsedExpression.$$interceptor,
+              interceptorFn,
+            );
+            // @ts-ignore
+            parsedExpression = parsedExpression.$$intercepted;
           }
-          const res = isFunction(value) ? value() : value;
-          return interceptorFn(isProxy(res) ? res.$target : res);
-        };
 
-        // Maintain references to the interceptor/intercepted
-        fn.$$intercepted = parsedExpression;
-        fn.$$interceptor = interceptorFn;
-
-        // Propagate the literal/oneTime/constant attributes
-        // @ts-ignore
-        fn.literal = parsedExpression.literal;
-        // @ts-ignore
-        fn.oneTime = parsedExpression.oneTime;
-        // @ts-ignore
-        fn.constant = parsedExpression.constant;
-        // @ts-ignore
-        fn.decoratedNode = parsedExpression.decoratedNode;
-
-        // Treat the interceptor like filters.
-        // If it is not $stateful then only watch its inputs.
-        // If the expression itself has no inputs then use the full expression as an input.
-        if (!interceptorFn.$stateful) {
+          let useInputs = false;
+
+          const fn = function interceptedExpression(
+            scope,
+            locals,
+            assign,
+            inputs,
+          ) {
+            const value =
+              useInputs && inputs
+                ? inputs[0]
+                : parsedExpression(scope, locals, assign, inputs);
+            // Do not invoke for getters
+            if (scope?.getter) {
+              return;
+            }
+            const res = isFunction(value) ? value() : value;
+            return interceptorFn(isProxy(res) ? res.$target : res);
+          };
+
+          // Maintain references to the interceptor/intercepted
+          fn.$$intercepted = parsedExpression;
+          fn.$$interceptor = interceptorFn;
+
+          // Propagate the literal/oneTime/constant attributes
           // @ts-ignore
-          useInputs = !parsedExpression.inputs;
+          fn.literal = parsedExpression.literal;
           // @ts-ignore
-          fn.inputs = parsedExpression.inputs
-            ? // @ts-ignore
-              parsedExpression.inputs
-            : [parsedExpression];
-
-          if (!interceptorFn.$$pure) {
-            fn.inputs = fn.inputs.map(function (e) {
-              // Remove the isPure flag of inputs when it is not absolute because they are now wrapped in a
-              // non-pure interceptor function.
-              if (e.isPure === PURITY_RELATIVE) {
-                return function depurifier(s) {
-                  return e(s);
-                };
-              }
-              return e;
-            });
+          fn.oneTime = parsedExpression.oneTime;
+          // @ts-ignore
+          fn.constant = parsedExpression.constant;
+          // @ts-ignore
+          fn.decoratedNode = parsedExpression.decoratedNode;
+
+          // Treat the interceptor like filters.
+          // If it is not $stateful then only watch its inputs.
+          // If the expression itself has no inputs then use the full expression as an input.
+          if (!interceptorFn.$stateful) {
+            // @ts-ignore
+            useInputs = !parsedExpression.inputs;
+            // @ts-ignore
+            fn.inputs = parsedExpression.inputs
+              ? // @ts-ignore
+                parsedExpression.inputs
+              : [parsedExpression];
+
+            if (!interceptorFn.$$pure) {
+              fn.inputs = fn.inputs.map(function (e) {
+                // Remove the isPure flag of inputs when it is not absolute because they are now wrapped in a
+                // non-pure interceptor function.
+                if (e.isPure === PURITY_RELATIVE) {
+                  return function depurifier(s) {
+                    return e(s);
+                  };
+                }
+                return e;
+              });
+            }
           }
-        }
 
-        return addWatchDelegate(fn);
-      }
-    },
-  ];
+          return addWatchDelegate(fn);
+        }
+      },
+    ];
+  }
 }
 
 export function constantWatchDelegate(

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

@@ -1,6 +1,6 @@
 import { isFunction, csp } from "../../shared/utils.js";
 import { createInjector } from "../di/injector.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { wait } from "../../shared/test-utils.js";
 
 describe("parser", () => {
@@ -94,11 +94,11 @@ describe("parser", () => {
         expect(scope.$eval("1<=1")).toBeTruthy();
         expect(scope.$eval("1>2")).toEqual(1 > 2);
         expect(scope.$eval("2>=1")).toEqual(2 >= 1);
-        expect(scope.$eval("true==2<3")).toEqual(2 < 3 == true);
-        expect(scope.$eval("true===2<3")).toEqual(2 < 3 === true);
+        expect(scope.$eval("true==2<3")).toEqual(2 < 3);
+        expect(scope.$eval("true===2<3")).toEqual(2 < 3);
 
         expect(scope.$eval("true===3===3")).toEqual((true === 3) === 3);
-        expect(scope.$eval("3===3===true")).toEqual((3 === 3) === true);
+        expect(scope.$eval("3===3===true")).toEqual(true);
         expect(scope.$eval("3 >= 3 > 2")).toEqual(3 >= 3 > 2);
       });
 
@@ -106,16 +106,16 @@ describe("parser", () => {
         expect(scope.$eval("0&&2")).toEqual(0 && 2);
         expect(scope.$eval("0||2")).toEqual(0 || 2);
         expect(scope.$eval("0||1&&2")).toEqual(0 || (1 && 2));
-        expect(scope.$eval("true&&a")).toEqual(true && undefined);
-        expect(scope.$eval("true&&a()")).toEqual(true && undefined);
-        expect(scope.$eval("true&&a()()")).toEqual(true && undefined);
-        expect(scope.$eval("true&&a.b")).toEqual(true && undefined);
-        expect(scope.$eval("true&&a.b.c")).toEqual(true && undefined);
-        expect(scope.$eval("false||a")).toEqual(false || undefined);
-        expect(scope.$eval("false||a()")).toEqual(false || undefined);
-        expect(scope.$eval("false||a()()")).toEqual(false || undefined);
-        expect(scope.$eval("false||a.b")).toEqual(false || undefined);
-        expect(scope.$eval("false||a.b.c")).toEqual(false || undefined);
+        expect(scope.$eval("true&&a")).toEqual(undefined);
+        expect(scope.$eval("true&&a()")).toEqual(undefined);
+        expect(scope.$eval("true&&a()()")).toEqual(undefined);
+        expect(scope.$eval("true&&a.b")).toEqual(undefined);
+        expect(scope.$eval("true&&a.b.c")).toEqual(undefined);
+        expect(scope.$eval("false||a")).toEqual(undefined);
+        expect(scope.$eval("false||a()")).toEqual(undefined);
+        expect(scope.$eval("false||a()()")).toEqual(undefined);
+        expect(scope.$eval("false||a.b")).toEqual(undefined);
+        expect(scope.$eval("false||a.b.c")).toEqual(undefined);
       });
 
       it("should parse ternary", () => {
@@ -278,10 +278,11 @@ describe("parser", () => {
 
       [2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 42, 99].forEach((pathLength) => {
         it(`should resolve nested paths of length ${pathLength}`, () => {
+          let i;
           // Create a nested object {x2: {x3: {x4: ... {x[n]: 42} ... }}}.
           let obj = 42;
           const locals = {};
-          for (var i = pathLength; i >= 2; i--) {
+          for (i = pathLength; i >= 2; i--) {
             const newObj = {};
             newObj[`x${i}`] = obj;
             obj = newObj;
@@ -613,7 +614,7 @@ describe("parser", () => {
       });
 
       it("should evaluate negation", () => {
-        expect(scope.$eval("!false || true")).toEqual(!false || true);
+        expect(scope.$eval("!false || true")).toEqual(true);
         expect(scope.$eval("!11 == 10")).toEqual(!11 == 10);
         expect(scope.$eval("12/6/2")).toEqual(12 / 6 / 2);
       });
@@ -1786,37 +1787,36 @@ describe("parser", () => {
       });
 
       [0, false, "", NaN].forEach((falsyValue) => {
-        "should not overwrite $prop scope properties when assigning",
-          () => {
-            let scope;
-
-            scope = { a: falsyValue, c: falsyValue };
-            tryParseAndIgnoreException("a.b = 1");
-            tryParseAndIgnoreException('c["d"] = 2');
-            expect(scope).toEqual({ a: falsyValue, c: falsyValue });
-
-            scope = { a: { b: falsyValue, c: falsyValue } };
-            tryParseAndIgnoreException("a.b.c = 1");
-            tryParseAndIgnoreException('a.c["d"] = 2');
-            expect(scope).toEqual({ a: { b: falsyValue, c: falsyValue } });
-
-            // Helpers
-            //
-            // Normally assigning property on a primitive should throw exception in strict mode
-            // and silently fail in non-strict mode, IE seems to always have the non-strict-mode behavior,
-            // so if we try to use 'expect(() => {$parse('a.b=1')({a:false});).toThrow()' for testing
-            // the test will fail in case of IE because it will not throw exception, and if we just use
-            // '$parse('a.b=1')({a:false})' the test will fail because it will throw exception in case of Chrome
-            // so we use tryParseAndIgnoreException helper to catch the exception silently for all cases.
-            //
-            function tryParseAndIgnoreException(expression) {
-              try {
-                $parse(expression)(scope);
-              } catch (error) {
-                /* ignore exception */
-              }
+        it("should not overwrite $prop scope properties when assigning", () => {
+          let scope;
+
+          scope = { a: falsyValue, c: falsyValue };
+          tryParseAndIgnoreException("a.b = 1");
+          tryParseAndIgnoreException('c["d"] = 2');
+          expect(scope).toEqual({ a: falsyValue, c: falsyValue });
+
+          scope = { a: { b: falsyValue, c: falsyValue } };
+          tryParseAndIgnoreException("a.b.c = 1");
+          tryParseAndIgnoreException('a.c["d"] = 2');
+          expect(scope).toEqual({ a: { b: falsyValue, c: falsyValue } });
+
+          // Helpers
+          //
+          // Normally assigning property on a primitive should throw exception in strict mode
+          // and silently fail in non-strict mode, IE seems to always have the non-strict-mode behavior,
+          // so if we try to use 'expect(() => {$parse('a.b=1')({a:false});).toThrow()' for testing
+          // the test will fail in case of IE because it will not throw exception, and if we just use
+          // '$parse('a.b=1')({a:false})' the test will fail because it will throw exception in case of Chrome
+          // so we use tryParseAndIgnoreException helper to catch the exception silently for all cases.
+          //
+          function tryParseAndIgnoreException(expression) {
+            try {
+              $parse(expression)(scope);
+            } catch (error) {
+              /* ignore exception */
             }
-          };
+          }
+        });
       });
     });
 

package/src/core/prop.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../loader.js";
+import { Angular } from "../angular.js";
 import { createInjector } from "./di/injector.js";
 import { dealoc } from "../shared/dom.js";
 import { wait } from "../shared/test-utils.js";

package/src/core/root-element.spec.js

@@ -1,5 +1,5 @@
 import { createElementFromHTML, dealoc } from "../shared/dom.js";
-import { Angular } from "../loader.js";
+import { Angular } from "../angular.js";
 
 describe("$rootElement", () => {
   let angular = new Angular();

package/src/core/scope/scope.js

@@ -1,16 +1,16 @@
 import {
-  isUndefined,
-  nextUid,
-  isObject,
-  concat,
-  isFunction,
   assert,
-  isString,
+  concat,
+  hasOwn,
   isDefined,
+  isFunction,
   isNull,
+  isObject,
   isProxy,
   isProxySymbol,
-  hasOwn,
+  isString,
+  isUndefined,
+  nextUid,
 } from "../../shared/utils.js";
 import { ASTType } from "../parse/ast-type.js";
 
@@ -97,7 +97,7 @@ export function createScope(target = {}, context) {
               Array.isArray(target.$nonscope) &&
               target.$nonscope.includes(key))
           ) {
-            continue;
+            /* empty */
           } else {
             target[key] = createScope(target[key], proxy.$handler);
           }
@@ -577,6 +577,7 @@ export class Scope {
 
   /**
    * @param {Listener[]} listeners
+   * @param {Function} filter
    */
   #scheduleListener(listeners, filter = (val) => val) {
     Promise.resolve().then(() => {
@@ -1231,8 +1232,7 @@ export class Scope {
 function calculateWatcherCount(model) {
   const childIds = collectChildIds(model).add(model.$id);
 
-  /** @type {number} */
-  const count = Array.from(model.watchers.values()).reduce(
+  return Array.from(model.watchers.values()).reduce(
     (count, watcherArray) =>
       count +
       watcherArray.reduce(
@@ -1242,7 +1242,6 @@ function calculateWatcherCount(model) {
       ),
     0,
   );
-  return count;
 }
 
 /**

package/src/core/scope/scope.spec.js

@@ -1,8 +1,8 @@
 import { wait } from "../../shared/test-utils.js";
 import { $postUpdateQueue, createScope } from "./scope.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createInjector } from "../di/injector.js";
-import { isDefined, sliceArgs, isProxy } from "../../shared/utils.js";
+import { isDefined, isProxy, sliceArgs } from "../../shared/utils.js";
 
 describe("Scope", () => {
   let scope;
@@ -1729,8 +1729,7 @@ describe("Scope", () => {
     describe("watching other proxies", () => {
       it("should register a foreign proxies ", async () => {
         let scope1 = createScope();
-        let scope2 = createScope({ b: 2 });
-        scope1.service = scope2;
+        scope1.service = createScope({ b: 2 });
         expect(scope1.$handler.foreignProxies.size).toEqual(1);
       });
 

package/src/directive/aria/aria.spec.js

@@ -1,5 +1,5 @@
 import { createInjector } from "../../core/di/injector.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { dealoc, getController } from "../../shared/dom.js";
 import { browserTrigger, wait } from "../../shared/test-utils.js";
 

package/src/directive/aria/aria.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/directive/aria/aria.html";
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
+  await page.waitForTimeout(1000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/directive/attrs/attrs.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createInjector } from "../../core/di/injector.js";
 import { dealoc } from "../../shared/dom.js";
 import { wait } from "../../shared/test-utils.js";

package/src/directive/attrs/attrs.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/directive/attrs/attrs.html";
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
+  await page.waitForTimeout(1000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/directive/attrs/boolean.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createInjector } from "../../core/di/injector.js";
 import { dealoc } from "../../shared/dom.js";
 import { wait } from "../../shared/test-utils.js";

package/src/directive/attrs/boolean.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/directive/attrs/boolean.html";
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
+  await page.waitForTimeout(3000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/directive/attrs/element-style.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createInjector } from "../../core/di/injector.js";
 import { createElementFromHTML, dealoc } from "../../shared/dom.js";
 import { wait } from "../../shared/test-utils.js";

package/src/directive/attrs/element-style.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/directive/attrs/element-style.html";
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
+  await page.waitForTimeout(3000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/directive/attrs/src.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createInjector } from "../../core/di/injector.js";
 import { wait } from "../../shared/test-utils.js";
 

package/src/directive/attrs/src.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/directive/attrs/src.html";
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
+  await page.waitForTimeout(1000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );