@angular-wave/angular.ts 0.0.63 → 0.0.65

package/package.json

@@ -2,7 +2,7 @@
   "name": "@angular-wave/angular.ts",
   "description": "A modern, optimized and typesafe version of AngularJS",
   "license": "MIT",
-  "version": "0.0.63",
+  "version": "0.0.65",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

package/public/jasmine/jasmine-5.1.2/jasmine-html.js

@@ -21,7 +21,6 @@ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
-// eslint-disable-next-line no-var
 var jasmineRequire = window.jasmineRequire || require("./jasmine.js");
 
 jasmineRequire.html = function (j$) {

package/src/angular.spec.js

@@ -25,17 +25,14 @@ import {
   snakeCase,
 } from "./shared/utils";
 import { dealoc, JQLite, startingTag } from "./shared/jqlite/jqlite";
-import { Angular, angularInit } from "./loader";
-import { publishExternalAPI } from "./public";
-import { createInjector } from "./injector";
+import { Angular } from "./loader";
+import { createInjector } from "./core/di/injector";
 
 describe("angular", () => {
   let element, document, module, injector, $rootScope, $compile;
 
   beforeEach(() => {
     window.angular = new Angular();
-    publishExternalAPI();
-    createInjector();
     module = window.angular.module("defaultModule", ["ng"]);
     injector = createInjector(["ng", "defaultModule"]);
     $rootScope = injector.get("$rootScope");
@@ -1572,7 +1569,7 @@ describe("angular", () => {
     });
   });
 
-  describe("angularInit", () => {
+  describe("angular.init", () => {
     let bootstrapSpy;
     let element;
 
@@ -1594,7 +1591,7 @@ describe("angular", () => {
     });
 
     it("should do nothing when not found", () => {
-      angularInit(element);
+      window.angular.init(element);
       expect(bootstrapSpy).not.toHaveBeenCalled();
     });
 
@@ -1602,7 +1599,7 @@ describe("angular", () => {
       window.angular.module("ABC", []);
       const appElement = JQLite('<div ng-app="ABC"></div>')[0];
 
-      angularInit(appElement);
+      window.angular.init(appElement);
       expect(bootstrapSpy).toHaveBeenCalled();
     });
 
@@ -1610,27 +1607,27 @@ describe("angular", () => {
       window.angular.module("ABC", []);
       const appElement = JQLite('<div ng-app="ABC"></div>')[0];
       element.querySelector["[ng-app]"] = appElement;
-      angularInit(element);
+      window.angular.init(element);
       expect(bootstrapSpy).toHaveBeenCalled();
     });
 
     it("should bootstrap anonymously", () => {
       const appElement = JQLite("<div ng-app></div>")[0];
       element.querySelector["[ng-app]"] = appElement;
-      angularInit(element);
+      window.angular.init(element);
       expect(bootstrapSpy).toHaveBeenCalled();
     });
 
     it("should bootstrap if the annotation is on the root element", () => {
       const appElement = JQLite('<div ng-app=""></div>')[0];
-      angularInit(appElement);
+      window.angular.init(appElement);
       expect(bootstrapSpy).toHaveBeenCalled();
     });
 
     it("should complain if app module cannot be found", () => {
       const appElement = JQLite('<div ng-app="doesntexist"></div>')[0];
       expect(() => {
-        angularInit(appElement);
+        window.angular.init(appElement);
       }).toThrowError(/modulerr/);
     });
 
@@ -1656,7 +1653,7 @@ describe("angular", () => {
 
     it("should bootstrap in strict mode when ng-strict-di attribute is specified", () => {
       const appElement = JQLite('<div ng-app="" ng-strict-di></div>');
-      angularInit(JQLite("<div></div>").append(appElement[0])[0]);
+      window.angular.init(JQLite("<div></div>").append(appElement[0])[0]);
       expect(bootstrapSpy).toHaveBeenCalled();
       expect(bootstrapSpy.calls.mostRecent().args[2].strictDi).toBe(true);
 
@@ -1868,14 +1865,12 @@ describe("angular", () => {
   });
 
   describe("bootstrap", () => {
-    let module, injector, $rootScope, $compile;
+    let module, injector, $rootScope, $compile, angular;
 
     beforeEach(() => {
-      window.angular = new Angular();
-      publishExternalAPI();
-      createInjector();
-      module = window.angular.module("defaultModule", ["ng"]);
-      injector = createInjector(["ng", "defaultModule"]);
+      angular = new Angular();
+      module = angular.module("defaultModule", ["ng"]);
+      injector = createInjector(["defaultModule"]);
       $rootScope = injector.get("$rootScope");
       $compile = injector.get("$compile");
     });

package/src/animations/module.js

@@ -9,8 +9,8 @@ import { $$AnimateCssDriverProvider } from "./animate-css-driver";
 import { $$AnimateJsProvider } from "./animate-js";
 import { $$AnimateJsDriverProvider } from "./animate-js-driver";
 
-export function initAnimateModule() {
-  window["angular"]
+export function initAnimateModule(angular) {
+  angular
     .module("ngAnimate", [])
     .directive("ngAnimateSwap", ngAnimateSwapDirective)
     .directive("ngAnimateChildren", $$AnimateChildrenDirective)

package/src/binding.spec.js

@@ -1,10 +1,11 @@
 import { JQLite, dealoc } from "./shared/jqlite/jqlite";
-import { publishExternalAPI } from "./public";
-import { createInjector } from "./injector";
+import { Angular } from "./loader";
+import { createInjector } from "./core/di/injector";
 import { browserTrigger } from "./shared/test-utils";
 
 describe("binding", () => {
   let element,
+    myModule,
     $injector,
     $rootScope,
     $compile,
@@ -17,12 +18,14 @@ describe("binding", () => {
 
   beforeEach(function () {
     errors = [];
-    publishExternalAPI().decorator("$exceptionHandler", function () {
+    window.angular = new Angular();
+    myModule = window.angular.module("myModule", ["ng"]);
+    myModule.decorator("$exceptionHandler", function () {
       return (exception, cause) => {
         errors.push(exception.message);
       };
     });
-    $injector = createInjector(["ng"]);
+    $injector = createInjector(["myModule"]);
     $rootScope = $injector.get("$rootScope");
     $compile = $injector.get("$compile");
     $exceptionHandler = $injector.get("$exceptionHandler");

package/src/core/animate/animate.spec.js

@@ -1,9 +1,8 @@
 import { dealoc, JQLite } from "../../shared/jqlite/jqlite";
-import { publishExternalAPI } from "../../public";
 import { Angular } from "../../loader";
 import { isObject } from "../../shared/utils";
 import { isFunction } from "../../shared/utils";
-import { createInjector } from "../../injector";
+import { createInjector } from "../di/injector";
 
 describe("$animate", () => {
   describe("without animation", () => {
@@ -18,7 +17,6 @@ describe("$animate", () => {
 
     beforeEach(() => {
       window.angular = new Angular();
-      publishExternalAPI();
       defaultModule = window.angular.module("defaultModule", ["ng"]);
       injector = window.angular.bootstrap(dummy, ["defaultModule"]);
       injector.invoke(
@@ -268,7 +266,7 @@ describe("$animate", () => {
       it("$prop() should operate using a native DOM element", () => {
         const captureSpy = jasmine.createSpy();
         dealoc(dummy);
-        publishExternalAPI();
+        window.angular = new Angular();
         defaultModule = window.angular
           .module("defaultModule", ["ng"])
           .value("$$animateQueue", {

package/src/core/cache/cache-factory.spec.js

@@ -1,11 +1,11 @@
-import { publishExternalAPI } from "../../public";
-import { createInjector } from "../../injector";
+import { Angular } from "../../loader";
+import { createInjector } from "../di/injector";
 
 describe("$cacheFactory", () => {
   let $cacheFactory;
 
   beforeEach(() => {
-    publishExternalAPI();
+    window.angular = new Angular();
     createInjector(["ng"]).invoke((_$cacheFactory_) => {
       $cacheFactory = _$cacheFactory_;
     });

package/src/core/compile/compile.spec.js

@@ -1,5 +1,5 @@
-import { publishExternalAPI } from "../../public";
-import { createInjector } from "../../injector";
+import { Angular } from "../../loader";
+import { createInjector } from "../di/injector";
 import { dealoc, JQLite, getOrSetCacheData } from "../../shared/jqlite/jqlite";
 import {
   forEach,
@@ -59,7 +59,7 @@ describe("$compile", () => {
 
   beforeEach(() => {
     log = [];
-    publishExternalAPI();
+    window.angular = new Angular();
     module = window.angular.module("test1", ["ng"]);
     defaultModule = window.angular.module("defaultModule", ["ng"]);
     myModule = window.angular.module("myModule", ["ng"]);
@@ -6403,12 +6403,14 @@ describe("$compile", () => {
 
         describe("replace and not exactly one root element", () => {
           beforeEach(() => {
-            publishExternalAPI().decorator("$exceptionHandler", () => {
-              return (exception) => {
-                throw new Error(exception.message);
-              };
-            });
-            module = window.angular.module("test1", ["ng"]);
+            window.angular = new Angular();
+            module = window.angular
+              .module("test1", ["ng"])
+              .decorator("$exceptionHandler", () => {
+                return (exception) => {
+                  throw new Error(exception.message);
+                };
+              });
             module.directive("template", () => ({
               replace: true,
               templateUrl: "template.html",
@@ -6756,61 +6758,66 @@ describe("$compile", () => {
 
       beforeEach(() => {
         log = [];
-        publishExternalAPI().decorator("$exceptionHandler", () => {
-          return (exception, cause) => {
-            log.push(exception.message);
-          };
-        });
-        module = window.angular.module("test1", ["ng"]);
+
+        window.angular = new Angular();
+        module = window.angular
+          .module("test1", ["ng"])
+          .decorator("$exceptionHandler", () => {
+            return (exception) => {
+              log.push(exception.message);
+            };
+          });
+
         ["", "a", "b"].forEach((name) => {
-          module.directive(`scope${name.toUpperCase()}`, () => ({
-            scope: true,
-            restrict: "A",
-            compile() {
-              return {
-                pre(scope, element) {
+          module
+            .directive(`scope${name.toUpperCase()}`, () => ({
+              scope: true,
+              restrict: "A",
+              compile() {
+                return {
+                  pre(scope) {
+                    log.push(scope.$id);
+                  },
+                };
+              },
+            }))
+            .directive(`iscope${name.toUpperCase()}`, () => ({
+              scope: {},
+              restrict: "A",
+              compile() {
+                return function (scope) {
+                  iscope = scope;
                   log.push(scope.$id);
-                },
-              };
-            },
-          }));
-          module.directive(`iscope${name.toUpperCase()}`, () => ({
-            scope: {},
-            restrict: "A",
-            compile() {
-              return function (scope, element) {
-                iscope = scope;
-                log.push(scope.$id);
-              };
-            },
-          }));
-          module.directive(`tscope${name.toUpperCase()}`, () => ({
-            scope: true,
-            restrict: "A",
-            templateUrl: "tscope.html",
-            compile() {
-              return function (scope, element) {
-                log.push(scope.$id);
-              };
-            },
-          }));
-          module.directive(`stscope${name.toUpperCase()}`, () => ({
-            scope: true,
-            restrict: "A",
-            template: "<span></span>",
-            compile() {
-              return function (scope, element) {
-                log.push(scope.$id);
-              };
-            },
-          }));
+                };
+              },
+            }))
+            .directive(`tscope${name.toUpperCase()}`, () => ({
+              scope: true,
+              restrict: "A",
+              templateUrl: "tscope.html",
+              compile() {
+                return function (scope) {
+                  log.push(scope.$id);
+                };
+              },
+            }))
+            .directive(`stscope${name.toUpperCase()}`, () => ({
+              scope: true,
+              restrict: "A",
+              template: "<span></span>",
+              compile() {
+                return function (scope) {
+                  log.push(scope.$id);
+                };
+              },
+            }));
           module.directive(`trscope${name.toUpperCase()}`, () => ({
             scope: true,
             replace: true,
             restrict: "A",
             templateUrl: "trscope.html",
             compile() {
-              return function (scope, element) {
+              return function (scope) {
                 log.push(scope.$id);
               };
             },
@@ -6820,7 +6827,7 @@ describe("$compile", () => {
             restrict: "A",
             templateUrl: "tiscope.html",
             compile() {
-              return function (scope, element) {
+              return function (scope) {
                 iscope = scope;
                 log.push(scope.$id);
               };
@@ -6831,7 +6838,7 @@ describe("$compile", () => {
             restrict: "A",
             template: "<span></span>",
             compile() {
-              return function (scope, element) {
+              return function (scope) {
                 iscope = scope;
                 log.push(scope.$id);
               };
@@ -11087,7 +11094,6 @@ describe("$compile", () => {
 
       it("should eventually expose isolate scope variables on ES6 class controller with controllerAs when bindToController is true", () => {
         var controllerCalled = false;
-        // eslint-disable-next-line no-eval
         var Controller = eval(
           "(\n" +
             "class Foo {\n" +
@@ -17379,7 +17385,7 @@ describe("$compile", () => {
         $customAnnotation: "XXX",
       });
       initInjector("test1");
-      expect(myModule._invokeQueue.pop().pop()[1]).toEqual(
+      expect(myModule.invokeQueue.pop().pop()[1]).toEqual(
         jasmine.objectContaining({
           $canActivate: "canActivate",
           $routeConfig: "routeConfig",

package/src/core/controller/controller.spec.js

@@ -1,12 +1,12 @@
-import { publishExternalAPI } from "../../public";
-import { createInjector } from "../../injector";
+import { Angular } from "../../loader";
+import { createInjector } from "../di/injector";
 
 describe("$controller", () => {
   let $controllerProvider;
   let $controller;
 
   beforeEach(() => {
-    publishExternalAPI();
+    window.angular = new Angular();
     createInjector([
       "ng",
       function (_$controllerProvider_) {

package/src/core/cookie-reader.spec.js

@@ -1,5 +1,5 @@
-import { publishExternalAPI } from "../public";
-import { createInjector } from "../injector";
+import { Angular } from "../loader";
+import { createInjector } from "./di/injector";
 
 describe("$$cookieReader", () => {
   let $$cookieReader;
@@ -27,7 +27,7 @@ describe("$$cookieReader", () => {
       deleteAllCookies();
       expect(document.cookie).toEqual("");
 
-      publishExternalAPI();
+      window.angular = new Angular();
       var injector = createInjector(["ng"]);
       $$cookieReader = injector.get("$$cookieReader");
     });

package/src/core/di/injector.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/injector.spec.js"></script>
+  </head>
+  <body>
+    <div id="dummy"></div>
+  </body>
+</html>

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

@@ -9,17 +9,16 @@ import {
   assertArg,
   valueFn,
   assertNotHasOwnProperty,
-  reverseParams,
   isObject,
-  isDefined,
-} from "./shared/utils";
+  assert,
+} from "../../shared/utils";
 
-var ARROW_ARG = /^([^(]+?)=>/;
-var FN_ARGS = /^[^(]*\(\s*([^)]*)\)/m;
-var FN_ARG_SPLIT = /,/;
-var FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
-var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
-var $injectorMinErr = minErr("$injector");
+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");
 
 function stringifyFn(fn) {
   return Function.prototype.toString.call(fn);
@@ -82,18 +81,19 @@ const INSTANTIATING = {};
 
 /**
  *
- * @param {*} modulesToLoad
- * @param {*} strictDi
- * @returns {import("./types").InjectorService}
+ * @param {Array<String|Function>} modulesToLoad
+ * @param {boolean} [strictDi]
+ * @returns {import("../../types").InjectorService}
  */
-export function createInjector(modulesToLoad, strictDi) {
-  if (isDefined(strictDi) && !isBoolean(strictDi)) {
-    throw $injectorMinErr("strictDi must be boolean");
-  }
-  strictDi = !!strictDi;
-
+export function createInjector(modulesToLoad, strictDi = false) {
+  assert(Array.isArray(modulesToLoad), "modules required");
+  assert(isBoolean(strictDi));
+  /** @type {Array<string>} */
   const path = [];
-  const loadedModules = new Map();
+
+  /** @type {Map<String|Function, boolean>} */
+  const loadedModules = new Map(); // Keep track of loaded modules to avoid circular dependencies
+
   const providerCache = {
     $provide: {
       provider: supportObject(provider),
@@ -105,21 +105,22 @@ export function createInjector(modulesToLoad, strictDi) {
     },
   };
 
-  const providerInjector = (providerCache.$injector = createInternalInjector(
+  providerCache.$injector = createInternalInjector(
     providerCache,
-    function (serviceName, caller) {
+    function (caller) {
       if (isString(caller)) {
         path.push(caller);
       }
       throw $injectorMinErr("unpr", "Unknown provider: {0}", path.join(" <- "));
     },
-  ));
+  );
+
   const instanceCache = {};
 
   let protoInstanceInjector = createInternalInjector(
     instanceCache,
     (serviceName, caller) => {
-      const provider = providerInjector.get(
+      const provider = providerCache.$injector.get(
         serviceName + providerSuffix,
         caller,
       );
@@ -136,8 +137,9 @@ export function createInjector(modulesToLoad, strictDi) {
     $get: valueFn(protoInstanceInjector),
   };
   let instanceInjector = protoInstanceInjector;
-  instanceInjector.modules = providerInjector.modules = Object.create(null);
-  var runBlocks = loadModules(modulesToLoad);
+  instanceInjector.modules = providerCache.$injector.modules =
+    Object.create(null);
+  const runBlocks = loadModules(modulesToLoad);
   instanceInjector = protoInstanceInjector.get("$injector");
   instanceInjector.strictDi = strictDi;
   runBlocks.forEach((fn) => {
@@ -159,26 +161,28 @@ export function createInjector(modulesToLoad, strictDi) {
   function supportObject(delegate) {
     return function (key, value) {
       if (isObject(key)) {
-        forEach(key, reverseParams(delegate));
+        Object.entries(key).forEach(([k, v]) => {
+          delegate(k, v);
+        });
       } else {
         return delegate(key, value);
       }
     };
   }
 
-  function provider(name, provider_) {
+  function provider(name, provider) {
     assertNotHasOwnProperty(name, "service");
-    if (isFunction(provider_) || Array.isArray(provider_)) {
-      provider_ = providerInjector.instantiate(provider_);
+    if (isFunction(provider) || Array.isArray(provider)) {
+      provider = providerCache.$injector.instantiate(provider);
     }
-    if (!provider_.$get) {
+    if (!provider.$get) {
       throw $injectorMinErr(
         "pget",
         "Provider '{0}' must define $get factory method.",
         name,
       );
     }
-    return (providerCache[name + providerSuffix] = provider_);
+    return (providerCache[name + providerSuffix] = provider);
   }
 
   function enforceReturnValue(name, factory) {
@@ -221,7 +225,9 @@ export function createInjector(modulesToLoad, strictDi) {
   }
 
   function decorator(serviceName, decorFn) {
-    const origProvider = providerInjector.get(serviceName + providerSuffix);
+    const origProvider = providerCache.$injector.get(
+      serviceName + providerSuffix,
+    );
     const orig$get = origProvider.$get;
 
     origProvider.$get = function () {
@@ -235,6 +241,11 @@ export function createInjector(modulesToLoad, strictDi) {
   ////////////////////////////////////
   // Module Loading
   ////////////////////////////////////
+  /**
+   *
+   * @param {Array<String|Function>} modulesToLoad
+   * @returns
+   */
   function loadModules(modulesToLoad) {
     assertArg(
       isUndefined(modulesToLoad) || Array.isArray(modulesToLoad),
@@ -242,34 +253,36 @@ export function createInjector(modulesToLoad, strictDi) {
       "not an array",
     );
     let runBlocks = [];
-    let moduleFn;
-    forEach(modulesToLoad, (module) => {
+
+    modulesToLoad.forEach((module) => {
       if (loadedModules.get(module)) return;
       loadedModules.set(module, true);
 
+      /**
+       *
+       * @param {Array<Array<any>>} queue
+       */
       function runInvokeQueue(queue) {
         queue.forEach((invokeArgs) => {
-          const provider = providerInjector.get(invokeArgs[0]);
+          const provider = providerCache.$injector.get(invokeArgs[0]);
           provider[invokeArgs[1]].apply(provider, invokeArgs[2]);
         });
       }
 
       try {
         if (isString(module)) {
-          moduleFn = window["angular"].module(module);
+          /** @type {import('./ng-module').NgModule} */
+          let moduleFn = window["angular"].module(module);
           instanceInjector.modules[module] = moduleFn;
           runBlocks = runBlocks
             .concat(loadModules(moduleFn.requires))
-            // @ts-ignore
-            .concat(moduleFn._runBlocks);
-          // @ts-ignore
-          runInvokeQueue(moduleFn._invokeQueue);
-          // @ts-ignore
-          runInvokeQueue(moduleFn._configBlocks);
+            .concat(moduleFn.runBlocks);
+          runInvokeQueue(moduleFn.invokeQueue);
+          runInvokeQueue(moduleFn.configBlocks);
         } else if (isFunction(module)) {
-          runBlocks.push(providerInjector.invoke(module));
+          runBlocks.push(providerCache.$injector.invoke(module));
         } else if (Array.isArray(module)) {
-          runBlocks.push(providerInjector.invoke(module));
+          runBlocks.push(providerCache.$injector.invoke(module));
         } else {
           assertArgFn(module, "module");
         }
@@ -283,7 +296,7 @@ export function createInjector(modulesToLoad, strictDi) {
           // So if stack doesn't contain message, we create a new string that contains both.
           // Since error.stack is read-only in Safari, I'm overriding e and not e.stack here.
 
-          e = `${e.message}\n${e.stack}`;
+          e.message = `${e.message}\n${e.stack}`;
         }
         throw $injectorMinErr(
           "modulerr",