@angular-wave/angular.ts 0.7.7 → 0.8.0

package/src/core/di/ng-module.js

@@ -1,10 +1,15 @@
-import { $injectTokens } from "../../injection-tokens.js";
+import { $injectTokens as $t } from "../../injection-tokens.js";
 import { isFunction, isString, assert } from "../../shared/utils.js";
 
+/** @private */
 export const INJECTOR_LITERAL = "$injector";
+/** @private */
 export const COMPILE_LITERAL = "$compileProvider";
+/** @private */
 export const ANIMATION_LITERAL = "$animateProvider";
+/** @private */
 export const FILTER_LITERAL = "$filterProvider";
+/** @private */
 export const CONTROLLER_LITERAL = "$controllerProvider";
 
 /**
@@ -61,7 +66,7 @@ export class NgModule {
    * @returns {NgModule}
    */
   value(name, object) {
-    this.invokeQueue.push([$injectTokens.$provide, "value", [name, object]]);
+    this.invokeQueue.push([$t.$provide, "value", [name, object]]);
     return this;
   }
 
@@ -71,11 +76,7 @@ export class NgModule {
    * @returns {NgModule}
    */
   constant(name, object) {
-    this.invokeQueue.unshift([
-      $injectTokens.$provide,
-      "constant",
-      [name, object],
-    ]);
+    this.invokeQueue.unshift([$t.$provide, "constant", [name, object]]);
     return this;
   }
 
@@ -120,11 +121,7 @@ export class NgModule {
     if (providerFunction && isFunction(providerFunction)) {
       providerFunction.$$moduleName = name;
     }
-    this.invokeQueue.push([
-      $injectTokens.$provide,
-      "factory",
-      [name, providerFunction],
-    ]);
+    this.invokeQueue.push([$t.$provide, "factory", [name, providerFunction]]);
     return this;
   }
 
@@ -137,11 +134,7 @@ export class NgModule {
     if (serviceFunction && isFunction(serviceFunction)) {
       serviceFunction.$$moduleName = name;
     }
-    this.invokeQueue.push([
-      $injectTokens.$provide,
-      "service",
-      [name, serviceFunction],
-    ]);
+    this.invokeQueue.push([$t.$provide, "service", [name, serviceFunction]]);
     return this;
   }
 
@@ -154,11 +147,7 @@ export class NgModule {
     if (providerType && isFunction(providerType)) {
       providerType.$$moduleName = name;
     }
-    this.invokeQueue.push([
-      $injectTokens.$provide,
-      "provider",
-      [name, providerType],
-    ]);
+    this.invokeQueue.push([$t.$provide, "provider", [name, providerType]]);
     return this;
   }
 
@@ -171,11 +160,7 @@ export class NgModule {
     if (decorFn && isFunction(decorFn)) {
       decorFn.$$moduleName = name;
     }
-    this.configBlocks.push([
-      $injectTokens.$provide,
-      "decorator",
-      [name, decorFn],
-    ]);
+    this.configBlocks.push([$t.$provide, "decorator", [name, decorFn]]);
     return this;
   }
 

package/src/core/filter/filter.js

@@ -1,3 +1,4 @@
+import { $injectTokens as $t } from "../../injection-tokens.js";
 import { isObject } from "../../shared/utils.js";
 import { filterFilter } from "../../filters/filter.js";
 import { jsonFilter } from "../../filters/filters.js";
@@ -8,48 +9,47 @@ import {
   $IsStateFilter,
 } from "../../router/state-filters.js";
 
-FilterProvider.$inject = ["$provide"];
+const SUFFIX = "Filter";
 
-/**
- * @param {import('../../interface.ts').Provider} $provide
- */
-export function FilterProvider($provide) {
-  const suffix = "Filter";
+export class FilterProvider {
+  /* @ignore */ static $inject = [$t.$provide];
+
+  /**
+   * @param {import('../../interface.ts').Provider} $provide
+   */
+  constructor($provide) {
+    this.$provide = $provide;
+    this.register({
+      filter: filterFilter,
+      json: jsonFilter,
+      limitTo: limitToFilter,
+      orderBy: orderByFilter,
+      isState: $IsStateFilter,
+      includedByState: $IncludedByStateFilter,
+    });
+  }
 
   /**
    * @param {string|Record<string, import('../../interface.ts').FilterFactory>} name
-   * @param {import('../../interface.ts').FilterFactory} factory
-   * @return {import('../../interface.ts').ServiceProvider}
+   * @param {import('../../interface.ts').FilterFactory} [factory]
+   * @return {import('../../interface.ts').Provider}
    */
-  function register(name, factory) {
+  register(name, factory) {
     if (isObject(name)) {
       const filters = {};
       Object.entries(name).forEach(([key, filter]) => {
-        filters[key] = register(key, filter);
+        filters[key] = this.register(key, filter);
       });
     }
-    return $provide.factory(name + suffix, factory);
+    return this.$provide.factory(name + SUFFIX, factory);
   }
 
-  this.register = register;
-
-  this.$get = [
-    "$injector",
+  $get = [
+    $t.$injector,
     /**
      * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
-     * @returns
+     * @returns {import('../../interface.ts').FilterFn}
      */
-    function ($injector) {
-      return function (name) {
-        return $injector.get(name + suffix);
-      };
-    },
+    ($injector) => (/** @type {string} */ name) => $injector.get(name + SUFFIX),
   ];
-
-  register("filter", filterFilter);
-  register("json", jsonFilter);
-  register("limitTo", limitToFilter);
-  register("orderBy", orderByFilter);
-  register("isState", $IsStateFilter);
-  register("includedByState", $IncludedByStateFilter);
 }

package/src/core/filter/filter.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createInjector } from "../di/injector.js";
 
 describe("filter", function () {

package/src/core/filter/filter.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/core/filter/filter.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/core/interpolate/interpolate.js

@@ -1,9 +1,9 @@
 import {
-  minErr,
+  extend,
   isDefined,
   isUndefined,
+  minErr,
   stringify,
-  extend,
 } from "../../shared/utils.js";
 import { constantWatchDelegate } from "../parse/parse.js";
 
@@ -322,8 +322,7 @@ export class InterpolateProvider {
                       let j = 0;
                       for (; j < ii; j++) {
                         let fn = parseFns[j];
-                        let res = fn(context);
-                        vals[j] = res;
+                        vals[j] = fn(context);
                       }
                       cb(compute(vals));
                     });
@@ -332,8 +331,7 @@ export class InterpolateProvider {
                   values[i] = parseFns[i](context);
                 }
 
-                let res = compute(values);
-                return res;
+                return compute(values);
               } catch (err) {
                 interr(text, err);
               }

package/src/core/interpolate/interpolate.spec.js

@@ -1,5 +1,5 @@
 import { createInjector } from "../di/injector.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { wait } from "../../shared/test-utils.js";
 
 describe("$interpolate", () => {

package/src/core/interpolate/interpolate.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/core/interpolate/interpolate.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/core/parse/ast/ast.spec.js

@@ -2,7 +2,7 @@ import { AST } from "./ast.js";
 import { Lexer } from "../lexer/lexer.js";
 import { createInjector } from "../../di/injector.js";
 import { ASTType } from "../ast-type.js";
-import { Angular } from "../../../loader.js";
+import { Angular } from "../../../angular.js";
 
 describe("ast", () => {
   let $rootScope;

package/src/core/parse/ast/ast.test.js

@@ -3,7 +3,7 @@ import { test, expect } from "@playwright/test";
 test("lexer unit tests contain no errors", async ({ page }) => {
   await page.goto("src/core/parse/ast/ast.html");
   await page.content();
-  await page.waitForTimeout(100);
+  await page.waitForTimeout(3000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/core/parse/interpreter.js

@@ -137,7 +137,7 @@ export class ASTInterpreter {
         if (ast.filter) right = this.$filter(ast.callee.name);
         if (!ast.filter) right = this.recurse(ast.callee, true);
         return ast.filter
-          ? function (scope, locals, assign) {
+          ? (scope, locals, assign) => {
               const values = [];
               for (let i = 0; i < args.length; ++i) {
                 const res = args[i](scope, locals, assign);
@@ -150,7 +150,7 @@ export class ASTInterpreter {
                 ? { context: undefined, name: undefined, value }
                 : value;
             }
-          : function (scope, locals, assign) {
+          : (scope, locals, assign) => {
               const rhs = right(scope, locals, assign);
               let value;
               if (rhs.value != null && isFunction(rhs.value)) {
@@ -166,7 +166,7 @@ export class ASTInterpreter {
       case ASTType.AssignmentExpression:
         left = this.recurse(ast.left, true, 1);
         right = this.recurse(ast.right);
-        return function (scope, locals, assign) {
+        return (scope, locals, assign) => {
           const lhs = left(scope, locals, assign);
           const rhs = right(scope, locals, assign);
           lhs.context[lhs.name] = rhs;
@@ -177,7 +177,7 @@ export class ASTInterpreter {
         ast.elements.forEach((expr) => {
           args.push(self.recurse(expr));
         });
-        return function (scope, locals, assign) {
+        return (scope, locals, assign) => {
           const value = [];
           for (let i = 0; i < args.length; ++i) {
             value.push(args[i](scope, locals, assign));
@@ -204,7 +204,7 @@ export class ASTInterpreter {
             });
           }
         });
-        return function (scope, locals, assign) {
+        return (scope, locals, assign) => {
           const value = {};
           for (let i = 0; i < args.length; ++i) {
             if (args[i].computed) {
@@ -220,17 +220,12 @@ export class ASTInterpreter {
           return context ? { value } : value;
         };
       case ASTType.ThisExpression:
-        return function (scope) {
-          return context ? { value: scope } : scope;
-        };
+        return (scope) => (context ? { value: scope } : scope);
       case ASTType.LocalsExpression:
-        return function (scope, locals) {
-          return context ? { value: locals } : locals;
-        };
+        return (scope, locals) => (context ? { value: locals } : locals);
       case ASTType.NGValueParameter:
-        return function (scope, locals, assign) {
-          return context ? { value: assign } : assign;
-        };
+        return (scope, locals, assign) =>
+          context ? { value: assign } : assign;
     }
   }
 
@@ -241,7 +236,7 @@ export class ASTInterpreter {
    * @returns {function} The unary plus function.
    */
   "unary+"(argument, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       let arg = argument(scope, locals, assign);
       if (isDefined(arg)) {
         arg = +arg;
@@ -259,7 +254,7 @@ export class ASTInterpreter {
    * @returns {function} The unary minus function.
    */
   "unary-"(argument, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       let arg = argument(scope, locals, assign);
       if (isDefined(arg)) {
         arg = -arg;
@@ -277,7 +272,7 @@ export class ASTInterpreter {
    * @returns {function} The unary negation function.
    */
   "unary!"(argument, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = !argument(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -291,7 +286,7 @@ export class ASTInterpreter {
    * @returns {function} The binary plus function.
    */
   "binary+"(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const lhs = left(scope, locals, assign);
       const rhs = right(scope, locals, assign);
       const arg = plusFn(lhs, rhs);
@@ -307,7 +302,7 @@ export class ASTInterpreter {
    * @returns {function} The binary minus function.
    */
   "binary-"(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const lhs = left(scope, locals, assign);
       const rhs = right(scope, locals, assign);
       const arg = (isDefined(lhs) ? lhs : 0) - (isDefined(rhs) ? rhs : 0);
@@ -323,14 +318,14 @@ export class ASTInterpreter {
    * @returns {function} The binary multiplication function.
    */
   "binary*"(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) * right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
 
   "binary/"(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) / right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -344,7 +339,7 @@ export class ASTInterpreter {
    * @returns {function} The binary division function.
    */
   "binary%"(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) % right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -358,7 +353,7 @@ export class ASTInterpreter {
    * @returns {function} The binary strict equality function.
    */
   "binary==="(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) === right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -372,7 +367,7 @@ export class ASTInterpreter {
    * @returns {function} The binary strict inequality function.
    */
   "binary!=="(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) !== right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -386,7 +381,7 @@ export class ASTInterpreter {
    * @returns {function} The binary equality function.
    */
   "binary=="(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) == right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -400,7 +395,7 @@ export class ASTInterpreter {
    * @returns {function} The binary inequality function.
    */
   "binary!="(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) != right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -414,7 +409,7 @@ export class ASTInterpreter {
    * @returns {function} The binary less-than function.
    */
   "binary<"(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) < right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -428,7 +423,7 @@ export class ASTInterpreter {
    * @returns {function} The binary greater-than function.
    */
   "binary>"(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) > right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -442,7 +437,7 @@ export class ASTInterpreter {
    * @returns {function} The binary less-than-or-equal-to function.
    */
   "binary<="(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) <= right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -456,7 +451,7 @@ export class ASTInterpreter {
    * @returns {function} The binary greater-than-or-equal-to function.
    */
   "binary>="(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) >= right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -483,7 +478,7 @@ export class ASTInterpreter {
    * @returns {function} The binary logical OR function.
    */
   "binary||"(left, right, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = left(scope, locals, assign) || right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
@@ -498,7 +493,7 @@ export class ASTInterpreter {
    * @returns {function} The ternary conditional function.
    */
   "ternary?:"(test, alternate, consequent, context) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const arg = test(scope, locals, assign)
         ? alternate(scope, locals, assign)
         : consequent(scope, locals, assign);
@@ -513,9 +508,8 @@ export class ASTInterpreter {
    * @returns {import("./interface.ts").CompiledExpressionFunction} The function returning the literal value.
    */
   value(value, context) {
-    return function () {
-      return context ? { context: undefined, name: undefined, value } : value;
-    };
+    return () =>
+      context ? { context: undefined, name: undefined, value } : value;
   }
 
   /**
@@ -526,7 +520,7 @@ export class ASTInterpreter {
    * @returns {import("./interface.ts").CompiledExpressionFunction} The function returning the identifier value.
    */
   identifier(name, context, create) {
-    return function (scope, locals) {
+    return (scope, locals) => {
       const base = locals && name in locals ? locals : scope;
       if (create && create !== 1 && base && base[name] == null) {
         base[name] = {};
@@ -551,7 +545,7 @@ export class ASTInterpreter {
    * @returns {function} The function returning the computed member value.
    */
   computedMember(left, right, context, create) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const lhs = left(scope, locals, assign);
       let rhs;
       let value;
@@ -581,7 +575,7 @@ export class ASTInterpreter {
    * @returns {function} The function returning the non-computed member value.
    */
   nonComputedMember(left, right, context, create) {
-    return function (scope, locals, assign) {
+    return (scope, locals, assign) => {
       const lhs = left(scope, locals, assign);
       if (create && create !== 1) {
         if (lhs && lhs[right] == null) {

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

@@ -1,5 +1,5 @@
 import { Lexer } from "./lexer";
-import { Angular } from "../../../loader.js";
+import { Angular } from "../../../angular.js";
 import { createInjector } from "../../di/injector.js";
 
 describe("lexer", () => {