@angular-wave/angular.ts 0.0.64 → 0.0.66

package/src/{injector.spec.js → core/di/injector.spec.js}

@@ -1,6 +1,6 @@
-import { Angular } from "./loader";
-import { createInjector } from "./injector";
-import { valueFn, extend } from "./shared/utils";
+import { Angular } from "../../loader";
+import { createInjector, annotate } from "./injector";
+import { valueFn, extend } from "../../shared/utils";
 
 describe("injector.modules", () => {
   beforeEach(() => {
@@ -13,10 +13,23 @@ describe("injector.modules", () => {
   });
 
   it("should have $injector", () => {
-    const $injector = createInjector();
+    const $injector = createInjector([]);
     expect($injector.get("$injector")).toBe($injector);
   });
 
+  it("should have modules property", () => {
+    const $injector = createInjector([]);
+    expect($injector.modules).toEqual({});
+  });
+
+  it("should have methods", () => {
+    const $injector = createInjector([]);
+    expect($injector.has).toBeDefined();
+    expect($injector.invoke).toBeDefined();
+    expect($injector.instantiate).toBeDefined();
+    expect($injector.get).toBeDefined();
+  });
+
   it("should have a false strictDi property", () => {
     const injector = createInjector([]);
     expect(injector.strictDi).toBe(false);
@@ -30,13 +43,15 @@ describe("injector.modules", () => {
 
   it("should provide useful message if no provider", () => {
     expect(() => {
-      createInjector([]).get("idontexist");
+      const injector = createInjector([]);
+      injector.get("idontexist");
     }).toThrowError(/Unknown provider/);
   });
 
   it("has a constant that has been registered to a module", () => {
     const module = angular.module("myModule", []);
     module.constant("aConstant", 42);
+
     const injector = createInjector(["myModule"]);
     expect(injector.has("aConstant")).toBe(true);
   });
@@ -108,6 +123,7 @@ describe("injector.modules", () => {
       log.push("initial");
     });
     const injector = createInjector(["initial"]);
+    expect(log).toEqual(["initial"]);
     log.push("created");
 
     angular
@@ -274,7 +290,7 @@ describe("injector.modules", () => {
     expect(injector.invoke(fn)).toBe(3);
   });
 
-  it("invokes an annotated class with dependency injection", () => {
+  it("invokes a class with static property with dependency injection", () => {
     const module = angular.module("myModule", []);
     module.constant("a", 1);
     module.constant("b", 2);
@@ -288,6 +304,20 @@ describe("injector.modules", () => {
     expect(injector.invoke(Foo).c).toBe(3);
   });
 
+  it("invokes an annotated class with dependency injection", () => {
+    const module = angular.module("myModule", []);
+    module.constant("a", 1);
+    module.constant("b", 2);
+    const injector = createInjector(["myModule"]);
+    class Foo {
+      constructor(a, b) {
+        this.c = a + b;
+      }
+    }
+    Foo.$inject = ["a", "b"];
+    expect(injector.invoke(Foo).c).toBe(3);
+  });
+
   it("does not accept non-strings as injection tokens", () => {
     const module = angular.module("myModule", []);
     module.constant("a", 1);
@@ -325,7 +355,7 @@ describe("injector.modules", () => {
         return one + this.two;
       },
     };
-    ~expect(injector.invoke(["a", obj.fn], obj)).toBe(3);
+    expect(injector.invoke(["a", obj.fn], obj)).toBe(3);
   });
 
   it("overrides dependencies with locals when invoking", () => {
@@ -372,12 +402,10 @@ describe("injector.modules", () => {
 });
 
 describe("annotate", () => {
-  let annotate;
   let injector;
   beforeEach(() => {
     window.angular = new Angular();
     injector = createInjector([]);
-    annotate = injector.annotate;
   });
 
   it("should return $inject", () => {
@@ -392,7 +420,6 @@ describe("annotate", () => {
 
   it("should create $inject", () => {
     const extraParams = () => {};
-    /* eslint-disable space-before-function-paren */
     // keep the multi-line to make sure we can handle it
     function $f_n0 /*
      */(
@@ -498,43 +525,43 @@ describe("annotate", () => {
     const injector = createInjector([]);
     const fn = () => {};
     fn.$inject = ["a", "b"];
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns the array-style annotations of a function", () => {
     const injector = createInjector([]);
     const fn = ["a", "b", () => {}];
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns the array-style annotations of a function", () => {
     const injector = createInjector([]);
     const fn = ["a", "b", () => {}];
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns annotations parsed from function args when not annotated", () => {
     const injector = createInjector([]);
     const fn = function (a, b) {};
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns annotations parsed from arrow args when not annotated", () => {
     const injector = createInjector([]);
     const fn = (a, b) => {};
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("strips comments from argument lists when parsing", () => {
     const injector = createInjector([]);
     const fn = function (a, /*b,*/ c) {};
-    expect(injector.annotate(fn)).toEqual(["a", "c"]);
+    expect(annotate(fn)).toEqual(["a", "c"]);
   });
 
   it("strips several comments from argument lists when parsing", () => {
     const injector = createInjector([]);
     const fn = function (a, /*b,*/ c /*, d*/) {};
-    expect(injector.annotate(fn)).toEqual(["a", "c"]);
+    expect(annotate(fn)).toEqual(["a", "c"]);
   });
 
   it("strips // comments from argument lists when parsing", () => {
@@ -543,19 +570,13 @@ describe("annotate", () => {
       a, //b,
       c,
     ) {};
-    expect(injector.annotate(fn)).toEqual(["a", "c"]);
+    expect(annotate(fn)).toEqual(["a", "c"]);
   });
 
   it("strips surrounding underscores from argument names when parsing", () => {
     const injector = createInjector([]);
     const fn = function (a, _b_, c_, _d, an_argument) {};
-    expect(injector.annotate(fn)).toEqual([
-      "a",
-      "b",
-      "c_",
-      "_d",
-      "an_argument",
-    ]);
+    expect(annotate(fn)).toEqual(["a", "b", "c_", "_d", "an_argument"]);
   });
 
   it("throws when using a non-annotated fn in strict mode", () => {
@@ -1909,7 +1930,8 @@ describe("decorator", () => {
       "ng",
       function ($provide) {
         $provide.decorator("$injector", function ($delegate) {
-          return extend({}, $delegate, {
+          // Don't forget the prototype
+          return extend(Object.create($delegate), $delegate, {
             get: function (val) {
               if (val === "key") {
                 return "value";
@@ -1920,7 +1942,6 @@ describe("decorator", () => {
         });
       },
     ]);
-
     expect(injector.get("key")).toBe("value");
     expect(injector.get("$http")).not.toBeUndefined();
   });
@@ -2232,9 +2253,7 @@ describe("protection modes", () => {
   });
 
   it("should prevent instance lookup in module", () => {
-    function instanceLookupInModule(name) {
-      throw new Error("FAIL");
-    }
+    function instanceLookupInModule(name) {}
     expect(() => {
       createInjector([
         function ($provide) {

package/src/core/di/injector.test.js

@@ -0,0 +1,12 @@
+import { test, expect } from "@playwright/test";
+
+const TEST_URL = "src/core/di/injector.html";
+
+test("unit tests contain no errors", async ({ page }) => {
+  await page.goto(TEST_URL);
+  await page.content();
+  await page.waitForTimeout(5000);
+  await expect(page.locator(".jasmine-overall-result")).toHaveText(
+    /0 failures/,
+  );
+});

package/src/core/di/internal-injector.js

@@ -0,0 +1,233 @@
+import { assertArgFn, minErr } from "../../shared/utils";
+import { INJECTOR_LITERAL } from "./ng-module";
+
+const ARROW_ARG = /^([^(]+?)=>/;
+const FN_ARGS = /^[^(]*\(\s*([^)]*)\)/m;
+const FN_ARG_SPLIT = /,/;
+const FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
+const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+const $injectorMinErr = minErr(INJECTOR_LITERAL);
+
+const providerSuffix = "Provider";
+const INSTANTIATING = "INSTANTIATING";
+
+export class ProviderInjector {
+  /**
+   *
+   * @param {Object} cache
+   * @param {boolean} strictDi
+   */
+  constructor(cache, strictDi) {
+    this.cache = cache;
+    this.strictDi = strictDi;
+    this.path = [];
+    this.providerCache = cache;
+    this.modules = undefined;
+  }
+
+  factory(caller) {
+    this.path.push(caller);
+    // prevents lookups to providers through get
+    throw $injectorMinErr(
+      "unpr",
+      "Unknown provider: {0}",
+      this.path.join(" <- "),
+    );
+  }
+
+  /**
+   *
+   * @param {String} serviceName
+   * @returns {any}
+   */
+  get(serviceName) {
+    if (Object.prototype.hasOwnProperty.call(this.cache, serviceName)) {
+      if (this.cache[serviceName] === INSTANTIATING) {
+        throw $injectorMinErr(
+          "cdep",
+          "Circular dependency found: {0}",
+          `${serviceName} <- ${this.path.join(" <- ")}`,
+        );
+      }
+      return this.cache[serviceName];
+    }
+
+    this.path.unshift(serviceName);
+    this.cache[serviceName] = INSTANTIATING;
+    try {
+      // this goes to line 60
+      this.cache[serviceName] = this.factory(serviceName);
+    } catch (err) {
+      // this is for the error handling being thrown by the providerCache multiple times
+      delete this.cache[serviceName];
+      throw err;
+    }
+    return this.cache[serviceName];
+  }
+
+  injectionArgs(fn, locals, serviceName) {
+    const args = [];
+    const $inject = annotate(fn, this.strictDi, serviceName);
+
+    for (let i = 0, { length } = $inject; i < length; i++) {
+      const key = $inject[i];
+      if (typeof key !== "string") {
+        throw $injectorMinErr(
+          "itkn",
+          "Incorrect injection token! Expected service name as string, got {0}",
+          key,
+        );
+      }
+      args.push(
+        locals && Object.prototype.hasOwnProperty.call(locals, key)
+          ? locals[key]
+          : this.get(key),
+      );
+    }
+    return args;
+  }
+
+  invoke(fn, self, locals, serviceName) {
+    if (typeof locals === "string") {
+      serviceName = locals;
+      locals = null;
+    }
+
+    const args = this.injectionArgs(fn, locals, serviceName);
+    if (Array.isArray(fn)) {
+      fn = fn[fn.length - 1];
+    }
+
+    if (isClass(fn)) {
+      args.unshift(null);
+      return new (Function.prototype.bind.apply(fn, args))();
+    } else {
+      return fn.apply(self, args);
+    }
+  }
+
+  instantiate(Type, locals, serviceName) {
+    // Check if Type is annotated and use just the given function at n-1 as parameter
+    // e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);
+    const ctor = Array.isArray(Type) ? Type[Type.length - 1] : Type;
+    const args = this.injectionArgs(Type, locals, serviceName);
+    // Empty object at position 0 is ignored for invocation with `new`, but required.
+    args.unshift(null);
+    return new (Function.prototype.bind.apply(ctor, args))();
+  }
+
+  /**
+   *
+   * @param {String} name
+   * @returns {boolean}
+   */
+  has(name) {
+    const hasProvider = Object.prototype.hasOwnProperty.call(
+      this.providerCache,
+      name + providerSuffix,
+    );
+    const hasCache = Object.prototype.hasOwnProperty.call(this.cache, name);
+    return hasProvider || hasCache;
+  }
+}
+
+// /**
+//  * @typedef {Object} LegacyInjectorService
+//  * @property {function(Function, boolean=): string[]} annotate - Annotate a function or an array of inline annotations.
+//  * @property {function(string, string=): any} get - Get a service by name.
+//  * @property {function(Function, any?): any} instantiate - Instantiate a type constructor with optional locals.
+//  * @property {function(import("../../types").Injectable<Function | ((...args: any[]) => any)>, any=, any=): any} invoke - Invoke a function with optional context and locals.
+//  * @property {function(Array<import("../../types").Module | string | import("../../types").Injectable<(...args: any[]) => void>>): void} [loadNewModules] - Add and load new modules to the injector.
+//  * @property {Object.<string, import("../../types").Module>} [modules] - A map of all the modules loaded into the injector.
+//  * @property {boolean} [strictDi] - Indicates if strict dependency injection is enforced.
+//  */
+
+export class InjectorService extends ProviderInjector {
+  constructor(cache, strictDi, providerInjector) {
+    super(cache, strictDi);
+    this.strictDi = strictDi;
+    this.providerInjector = providerInjector;
+    this.providerCache = providerInjector.cache;
+    this.modules = undefined;
+  }
+
+  factory(serviceName, caller) {
+    const provider = this.providerInjector.get(
+      serviceName + providerSuffix,
+      caller,
+    );
+    const res = this.invoke(provider.$get, provider, undefined, serviceName);
+    return res;
+  }
+
+  // Gets overridden
+  loadNewModules() {}
+}
+
+// Helpers
+
+/**
+ * @param {String} fn
+ * @returns {String}
+ */
+function stringifyFn(fn) {
+  return Function.prototype.toString.call(fn);
+}
+
+/**
+ * @param {String} fn
+ * @returns {Array<any>}
+ */
+function extractArgs(fn) {
+  const fnText = stringifyFn(fn).replace(STRIP_COMMENTS, "");
+  const args = fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
+  return args;
+}
+
+/**
+ * @param {String} func
+ * @returns {boolean}
+ */
+function isClass(func) {
+  return /^class\b/.test(stringifyFn(func));
+}
+
+/**
+ *
+ * @param {any} fn
+ * @param {boolean} strictDi
+ * @param {String} name
+ * @returns {Array<string>}
+ */
+function annotate(fn, strictDi, name) {
+  var $inject, argDecl, last;
+
+  if (typeof fn === "function") {
+    if (!($inject = fn.$inject)) {
+      $inject = [];
+      if (fn.length) {
+        if (strictDi) {
+          throw $injectorMinErr(
+            "strictdi",
+            "{0} is not using explicit annotation and cannot be invoked in strict mode",
+            name,
+          );
+        }
+        argDecl = extractArgs(/** @type {String} */ (fn));
+        argDecl[1].split(FN_ARG_SPLIT).forEach(function (arg) {
+          arg.replace(FN_ARG, function (all, underscore, name) {
+            $inject.push(name);
+          });
+        });
+      }
+      fn.$inject = $inject;
+    }
+  } else if (Array.isArray(fn)) {
+    last = /** @type {Array} */ (fn).length - 1;
+    assertArgFn(fn[last], "fn");
+    $inject = /** @type {Array} */ (fn).slice(0, last);
+  } else {
+    assertArgFn(fn, "fn", true);
+  }
+  return $inject;
+}

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

@@ -0,0 +1,18 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>AngularTS Test Runner</title>
+
+    <link rel="shortcut icon" type="image/png" href="/images/favicon.ico" />
+    <link rel="stylesheet" href="/jasmine/jasmine-5.1.2/jasmine.css" />
+    <script src="/jasmine/jasmine-5.1.2/jasmine.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/jasmine-html.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/boot0.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/boot1.js"></script>
+    <script type="module" src="/src/core/di/ng-module.spec.js"></script>
+  </head>
+  <body>
+    <div id="dummy"></div>
+  </body>
+</html>

package/src/core/{ng-module.js → di/ng-module.js}

@@ -1,7 +1,28 @@
-import { isFunction, isDefined, isObject, minErr } from "../shared/utils";
-
-const ngMinErr = minErr("ng");
-
+import {
+  isFunction,
+  isDefined,
+  isObject,
+  isString,
+  assert,
+} from "../../shared/utils";
+
+export const PROVIDE_LITERAL = "$provide";
+export const INJECTOR_LITERAL = "$injector";
+export const COMPILE_LITERAL = "$compileProvider";
+export const ANIMATION_LITERAL = "$animateProvider";
+export const FILTER_LITERAL = "$filterProvider";
+export const CONTROLLER_LITERAL = "$controllerProvider";
+
+/**
+ * Modules are collections of application configuration information for components:
+ * controllers, directives, filters, etc. They provide recipes for the injector
+ * to do the actual instantiation. A module itself has no behaviour but only state.
+ * A such, it acts as a data structure between the Angular instance and the injector service.
+ *
+ * Since this is an internal structure that is exposed only via the Angular instance,
+ * it contains no validation of the items it receives. It is up to the instantiator on
+ * modules to do the actual validation.
+ */
 export class NgModule {
   /**
    *
@@ -10,6 +31,8 @@ export class NgModule {
    * @param {Function} [configFn]
    */
   constructor(name, requires, configFn) {
+    assert(isString(name), "name required");
+    assert(Array.isArray(requires), "requires array required");
     /**
      * @type {string}
      * Name of the module.
@@ -21,16 +44,17 @@ export class NgModule {
      */
     this.requires = requires;
 
-    this.configFn = configFn;
-
-    /** @type {!Array.<Array.<*>>} */
-    this._invokeQueue = [];
+    /**
+     * Holds a collection of tasks, required to instantiate an angular component
+     * @type {!Array<Array<*>>}
+     */
+    this.invokeQueue = [];
 
-    /** @type {!Array.<any>} */
-    this._configBlocks = [];
+    /** @type {!Array<Array<*>>} */
+    this.configBlocks = [];
 
     /** @type {!Array.<Function>} */
-    this._runBlocks = [];
+    this.runBlocks = [];
 
     /** @type {Object} */
     this.infoState = {};
@@ -41,14 +65,12 @@ export class NgModule {
   }
 
   /**
-   *
    * @param {Object} value
    * @returns
    */
   info(value) {
     if (isDefined(value)) {
-      if (!isObject(value))
-        throw ngMinErr("aobj", "Argument '{0}' must be an object", "value");
+      assert(isObject(value), "module info value must be an object");
       this.infoState = value;
       return this;
     }
@@ -61,7 +83,7 @@ export class NgModule {
    * @returns {NgModule}
    */
   value(name, object) {
-    this._invokeQueue.push(["$provide", "value", [name, object]]);
+    this.invokeQueue.push([PROVIDE_LITERAL, "value", [name, object]]);
     return this;
   }
 
@@ -71,17 +93,22 @@ export class NgModule {
    * @returns {NgModule}
    */
   constant(name, object) {
-    this._invokeQueue.unshift(["$provide", "constant", [name, object]]);
+    this.invokeQueue.unshift([PROVIDE_LITERAL, "constant", [name, object]]);
     return this;
   }
 
+  /**
+   *
+   * @param {Function} configFn
+   * @returns {NgModule}
+   */
   config(configFn) {
-    this._configBlocks.push(["$injector", "invoke", [configFn]]);
+    this.configBlocks.push([INJECTOR_LITERAL, "invoke", [configFn]]);
     return this;
   }
 
   run(block) {
-    this._runBlocks.push(block);
+    this.runBlocks.push(block);
     return this;
   }
 
@@ -89,7 +116,7 @@ export class NgModule {
     if (options && isFunction(options)) {
       options.$$moduleName = name;
     }
-    this._invokeQueue.push(["$compileProvider", "component", [name, options]]);
+    this.invokeQueue.push([COMPILE_LITERAL, "component", [name, options]]);
     return this;
   }
 
@@ -97,7 +124,11 @@ export class NgModule {
     if (providerFunction && isFunction(providerFunction)) {
       providerFunction.$$moduleName = name;
     }
-    this._invokeQueue.push(["$provide", "factory", [name, providerFunction]]);
+    this.invokeQueue.push([
+      PROVIDE_LITERAL,
+      "factory",
+      [name, providerFunction],
+    ]);
     return this;
   }
 
@@ -105,7 +136,11 @@ export class NgModule {
     if (serviceFunction && isFunction(serviceFunction)) {
       serviceFunction.$$moduleName = name;
     }
-    this._invokeQueue.push(["$provide", "service", [name, serviceFunction]]);
+    this.invokeQueue.push([
+      PROVIDE_LITERAL,
+      "service",
+      [name, serviceFunction],
+    ]);
     return this;
   }
 
@@ -113,7 +148,7 @@ export class NgModule {
     if (providerType && isFunction(providerType)) {
       providerType.$$moduleName = name;
     }
-    this._invokeQueue.push(["$provide", "provider", [name, providerType]]);
+    this.invokeQueue.push([PROVIDE_LITERAL, "provider", [name, providerType]]);
     return this;
   }
 
@@ -121,7 +156,7 @@ export class NgModule {
     if (decorFn && isFunction(decorFn)) {
       decorFn.$$moduleName = name;
     }
-    this._configBlocks.push(["$provide", "decorator", [name, decorFn]]);
+    this.configBlocks.push([PROVIDE_LITERAL, "decorator", [name, decorFn]]);
     return this;
   }
 
@@ -129,8 +164,8 @@ export class NgModule {
     if (directiveFactory && isFunction(directiveFactory)) {
       directiveFactory.$$moduleName = name;
     }
-    this._invokeQueue.push([
-      "$compileProvider",
+    this.invokeQueue.push([
+      COMPILE_LITERAL,
       "directive",
       [name, directiveFactory],
     ]);
@@ -141,8 +176,8 @@ export class NgModule {
     if (animationFactory && isFunction(animationFactory)) {
       animationFactory.$$moduleName = name;
     }
-    this._invokeQueue.push([
-      "$animateProvider",
+    this.invokeQueue.push([
+      ANIMATION_LITERAL,
       "register",
       [name, animationFactory],
     ]);
@@ -153,7 +188,7 @@ export class NgModule {
     if (filterFn && isFunction(filterFn)) {
       filterFn.$$moduleName = name;
     }
-    this._invokeQueue.push(["$filterProvider", "register", [name, filterFn]]);
+    this.invokeQueue.push([FILTER_LITERAL, "register", [name, filterFn]]);
     return this;
   }
 
@@ -161,7 +196,7 @@ export class NgModule {
     if (ctlFn && isFunction(ctlFn)) {
       ctlFn.$$moduleName = name;
     }
-    this._invokeQueue.push(["$controllerProvider", "register", [name, ctlFn]]);
+    this.invokeQueue.push([CONTROLLER_LITERAL, "register", [name, ctlFn]]);
     return this;
   }
 }