@angular-wave/angular.ts 0.0.63 → 0.0.65

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

@@ -1,11 +1,10 @@
-import { setupModuleLoader } from "./loader";
+import { Angular } from "../../loader";
 import { createInjector } from "./injector";
-import { publishExternalAPI } from "./public";
-import { valueFn, extend } from "./shared/utils";
+import { valueFn, extend } from "../../shared/utils";
 
 describe("injector.modules", () => {
   beforeEach(() => {
-    publishExternalAPI();
+    window.angular = new Angular();
   });
 
   it("can be created", () => {
@@ -14,7 +13,7 @@ describe("injector.modules", () => {
   });
 
   it("should have $injector", () => {
-    const $injector = createInjector();
+    const $injector = createInjector([]);
     expect($injector.get("$injector")).toBe($injector);
   });
 
@@ -275,7 +274,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);
@@ -289,6 +288,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);
@@ -326,7 +339,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", () => {
@@ -376,7 +389,7 @@ describe("annotate", () => {
   let annotate;
   let injector;
   beforeEach(() => {
-    setupModuleLoader(window);
+    window.angular = new Angular();
     injector = createInjector([]);
     annotate = injector.annotate;
   });
@@ -393,7 +406,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 /*
      */(
@@ -672,7 +684,7 @@ describe("annotate", () => {
 });
 
 describe("provider", () => {
-  beforeEach(() => setupModuleLoader(window));
+  beforeEach(() => (window.angular = new Angular()));
 
   it("allows registering a provider and uses its $get", () => {
     const module = angular.module("myModule", []);
@@ -974,7 +986,7 @@ describe("provider", () => {
 });
 
 describe("$provide", () => {
-  beforeEach(() => setupModuleLoader(window));
+  beforeEach(() => (window.angular = new Angular()));
 
   it("should inject providers", () => {
     const module = angular.module("myModule", []);
@@ -1018,7 +1030,7 @@ describe("$provide", () => {
 });
 
 describe("config/run", () => {
-  beforeEach(() => setupModuleLoader(window));
+  beforeEach(() => (window.angular = new Angular()));
 
   it("runs config blocks when the injector is created", () => {
     const module = angular.module("myModule", []);
@@ -1093,7 +1105,7 @@ describe("config/run", () => {
 });
 
 describe("function modules", () => {
-  beforeEach(() => setupModuleLoader(window));
+  beforeEach(() => (window.angular = new Angular()));
 
   it("runs a function module dependency as a config block", () => {
     const functionModule = ($provide) => {
@@ -1141,7 +1153,7 @@ describe("function modules", () => {
 });
 
 describe("factories", () => {
-  beforeEach(() => setupModuleLoader(window));
+  beforeEach(() => (window.angular = new Angular()));
 
   it("allows registering a factory", function () {
     var module = angular.module("myModule", []);
@@ -1201,7 +1213,7 @@ describe("factories", () => {
 });
 
 describe("values", () => {
-  beforeEach(() => setupModuleLoader(window));
+  beforeEach(() => (window.angular = new Angular()));
 
   it("allows registering a value", function () {
     var module = angular.module("myModule", []);
@@ -1228,7 +1240,7 @@ describe("values", () => {
 });
 
 describe("services", () => {
-  beforeEach(() => setupModuleLoader(window));
+  beforeEach(() => (window.angular = new Angular()));
 
   it("allows registering a service", function () {
     var module = angular.module("myModule", []);
@@ -1280,7 +1292,7 @@ describe("services", () => {
 });
 
 describe("decorators", () => {
-  beforeEach(() => setupModuleLoader(window));
+  beforeEach(() => (window.angular = new Angular()));
 
   it("allows changing an instance using a decorator", function () {
     var module = angular.module("myModule", []);
@@ -1331,19 +1343,20 @@ describe("decorators", () => {
 });
 
 describe("controllers", () => {
-  beforeEach(() => setupModuleLoader(window));
+  beforeEach(() => (window.angular = new Angular()));
 
   it("should provide the caller name for controllers", () => {
-    angular.module("myModule", []).controller("myCtrl", (idontexist) => {});
+    window.angular
+      .module("myModule", [])
+      .controller("myCtrl", (idontexist) => {});
     expect(() => {
       createInjector(["myModule"]).get("$controller");
     }).toThrowError(/Unknown provider/);
   });
 
   it("should be able to register a controller from a new module", () => {
-    publishExternalAPI();
     const injector = createInjector(["ng"]);
-    angular
+    window.angular
       .module("a", [])
       .controller("aController", function Controller($scope) {
         $scope.test = "b";
@@ -1358,12 +1371,11 @@ describe("controllers", () => {
 });
 
 describe("filters", () => {
-  beforeEach(() => setupModuleLoader(window));
+  beforeEach(() => (window.angular = new Angular()));
 
   it("should be able to register a filter from a new module", () => {
-    publishExternalAPI();
     const injector = createInjector(["ng"]);
-    angular.module("a", []).filter(
+    window.angular.module("a", []).filter(
       "aFilter",
       () =>
         function (input) {
@@ -1379,12 +1391,12 @@ describe("filters", () => {
 
 describe("directive", () => {
   beforeEach(() => {
-    publishExternalAPI();
+    window.angular = new Angular();
   });
 
   it("should be able to register a directive from a new module", () => {
     const injector = createInjector(["ng"]);
-    angular
+    window.angular
       .module("a", [])
       .directive("aDirective", () => ({ template: "test directive" }));
     injector.loadNewModules(["a"]);
@@ -1398,7 +1410,7 @@ describe("directive", () => {
 
   it("should be able to register a directive from a new module", () => {
     const injector = createInjector(["ng"]);
-    angular
+    window.angular
       .module("a", [])
       .directive("aDirective", () => ({ template: "test directive" }));
     injector.loadNewModules(["a"]);
@@ -1413,7 +1425,7 @@ describe("directive", () => {
 
 it("should define module", () => {
   let log = "";
-  const injector = createInjector([
+  createInjector([
     function ($provide) {
       $provide.value("value", "value;");
       $provide.factory("fn", valueFn("function;"));
@@ -1432,7 +1444,7 @@ it("should define module", () => {
 
 describe("module", () => {
   beforeEach(() => {
-    publishExternalAPI();
+    window.angular = new Angular();
   });
 
   it("should provide $injector even when no module is requested", () => {
@@ -1485,9 +1497,7 @@ describe("module", () => {
   it("should error on invalid module name", () => {
     expect(() => {
       createInjector(["IDontExist"], true);
-    }).toThrowError(
-      /\[\$injector:nomod] Module 'IDontExist' is not available! You either misspelled the module name or forgot to load it/,
-    );
+    }).toThrowError(/nomod/);
   });
 
   it("should load dependant modules only once", () => {
@@ -1770,7 +1780,7 @@ describe("decorator", () => {
 
   beforeEach(() => {
     log = [];
-    publishExternalAPI();
+    window.angular = new Angular();
   });
 
   it("should be called with the original instance", () => {
@@ -2253,7 +2263,7 @@ describe("strict-di injector", () => {
   let module;
   let $injector;
   beforeEach(() => {
-    publishExternalAPI();
+    window.angular = new Angular();
     module = angular.module("test1", []);
     $injector = createInjector(["test1"], true);
   });

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/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/di/ng-module.js

@@ -0,0 +1,202 @@
+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 {
+  /**
+   *
+   * @param {String} name - Name of the module
+   * @param {Array<String>} requires - List of modules which the injector will load before the current module
+   * @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.
+     */
+    this.name = name;
+    /**
+     * Holds the list of modules which the injector will load before the current module is
+     * loaded.
+     */
+    this.requires = requires;
+
+    /**
+     * Holds a collection of tasks, required to instantiate an angular component
+     * @type {!Array<Array<*>>}
+     */
+    this.invokeQueue = [];
+
+    /** @type {!Array<Array<*>>} */
+    this.configBlocks = [];
+
+    /** @type {!Array.<Function>} */
+    this.runBlocks = [];
+
+    /** @type {Object} */
+    this.infoState = {};
+
+    if (configFn) {
+      this.config(configFn);
+    }
+  }
+
+  /**
+   * @param {Object} value
+   * @returns
+   */
+  info(value) {
+    if (isDefined(value)) {
+      assert(isObject(value), "module info value must be an object");
+      this.infoState = value;
+      return this;
+    }
+    return this.infoState;
+  }
+
+  /**
+   * @param {String} name
+   * @param {any} object
+   * @returns {NgModule}
+   */
+  value(name, object) {
+    this.invokeQueue.push([PROVIDE_LITERAL, "value", [name, object]]);
+    return this;
+  }
+
+  /**
+   * @param {String} name
+   * @param {any} object
+   * @returns {NgModule}
+   */
+  constant(name, object) {
+    this.invokeQueue.unshift([PROVIDE_LITERAL, "constant", [name, object]]);
+    return this;
+  }
+
+  /**
+   *
+   * @param {Function} configFn
+   * @returns {NgModule}
+   */
+  config(configFn) {
+    this.configBlocks.push([INJECTOR_LITERAL, "invoke", [configFn]]);
+    return this;
+  }
+
+  run(block) {
+    this.runBlocks.push(block);
+    return this;
+  }
+
+  component(name, options) {
+    if (options && isFunction(options)) {
+      options.$$moduleName = name;
+    }
+    this.invokeQueue.push([COMPILE_LITERAL, "component", [name, options]]);
+    return this;
+  }
+
+  factory(name, providerFunction) {
+    if (providerFunction && isFunction(providerFunction)) {
+      providerFunction.$$moduleName = name;
+    }
+    this.invokeQueue.push([
+      PROVIDE_LITERAL,
+      "factory",
+      [name, providerFunction],
+    ]);
+    return this;
+  }
+
+  service(name, serviceFunction) {
+    if (serviceFunction && isFunction(serviceFunction)) {
+      serviceFunction.$$moduleName = name;
+    }
+    this.invokeQueue.push([
+      PROVIDE_LITERAL,
+      "service",
+      [name, serviceFunction],
+    ]);
+    return this;
+  }
+
+  provider(name, providerType) {
+    if (providerType && isFunction(providerType)) {
+      providerType.$$moduleName = name;
+    }
+    this.invokeQueue.push([PROVIDE_LITERAL, "provider", [name, providerType]]);
+    return this;
+  }
+
+  decorator(name, decorFn) {
+    if (decorFn && isFunction(decorFn)) {
+      decorFn.$$moduleName = name;
+    }
+    this.configBlocks.push([PROVIDE_LITERAL, "decorator", [name, decorFn]]);
+    return this;
+  }
+
+  directive(name, directiveFactory) {
+    if (directiveFactory && isFunction(directiveFactory)) {
+      directiveFactory.$$moduleName = name;
+    }
+    this.invokeQueue.push([
+      COMPILE_LITERAL,
+      "directive",
+      [name, directiveFactory],
+    ]);
+    return this;
+  }
+
+  animation(name, animationFactory) {
+    if (animationFactory && isFunction(animationFactory)) {
+      animationFactory.$$moduleName = name;
+    }
+    this.invokeQueue.push([
+      ANIMATION_LITERAL,
+      "register",
+      [name, animationFactory],
+    ]);
+    return this;
+  }
+
+  filter(name, filterFn) {
+    if (filterFn && isFunction(filterFn)) {
+      filterFn.$$moduleName = name;
+    }
+    this.invokeQueue.push([FILTER_LITERAL, "register", [name, filterFn]]);
+    return this;
+  }
+
+  controller(name, ctlFn) {
+    if (ctlFn && isFunction(ctlFn)) {
+      ctlFn.$$moduleName = name;
+    }
+    this.invokeQueue.push([CONTROLLER_LITERAL, "register", [name, ctlFn]]);
+    return this;
+  }
+}