@angular-wave/angular.ts 0.0.64 → 0.0.66

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.64",
+  "version": "0.0.66",
   "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

@@ -26,7 +26,7 @@ import {
 } from "./shared/utils";
 import { dealoc, JQLite, startingTag } from "./shared/jqlite/jqlite";
 import { Angular } from "./loader";
-import { createInjector } from "./injector";
+import { createInjector } from "./core/di/injector";
 
 describe("angular", () => {
   let element, document, module, injector, $rootScope, $compile;

package/src/animations/animate-js.js

@@ -13,6 +13,12 @@ export function $$AnimateJsProvider($animateProvider) {
   this.$get = [
     "$injector",
     "$$AnimateRunner",
+    /**
+     * 
+     * @param {import("../core/di/internal-injector").InjectorService} $injector 
+     * @param {*} $$AnimateRunner 
+     * @returns 
+     */
     function ($injector, $$AnimateRunner) {
       const applyAnimationClasses = applyAnimationClassesFactory();
       // $animateJs(element, 'enter');

package/src/animations/animation.js

@@ -38,7 +38,7 @@ export function $$AnimationProvider() {
     /**
      *
      * @param {*} $rootScope
-     * @param {*} $injector
+     * @param {import("../core/di/internal-injector").InjectorService} $injector
      * @param {*} $$AnimateRunner
      * @param {import("./raf-scheduler").RafScheduler} $$rAFScheduler
      * @param {*} $$animateCache

package/src/binding.spec.js

@@ -1,6 +1,6 @@
 import { JQLite, dealoc } from "./shared/jqlite/jqlite";
 import { Angular } from "./loader";
-import { createInjector } from "./injector";
+import { createInjector } from "./core/di/injector";
 import { browserTrigger } from "./shared/test-utils";
 
 describe("binding", () => {

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

@@ -2,7 +2,7 @@ import { dealoc, JQLite } from "../../shared/jqlite/jqlite";
 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", () => {

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

@@ -1,5 +1,5 @@
 import { Angular } from "../../loader";
-import { createInjector } from "../../injector";
+import { createInjector } from "../di/injector";
 
 describe("$cacheFactory", () => {
   let $cacheFactory;

package/src/core/compile/compile.js

@@ -233,7 +233,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
           "$exceptionHandler",
           /**
            *
-           * @param {*} $injector
+           * @param {import("../../core/di/internal-injector").InjectorService} $injector
            * @param {import('../exception-handler').ErrorHandler} $exceptionHandler
            * @returns
            */
@@ -619,6 +619,18 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
     "$rootScope",
     "$sce",
     "$animate",
+    /**
+     * @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @param {*} $interpolate
+     * @param {*} $exceptionHandler
+     * @param {*} $templateRequest
+     * @param {*} $parse
+     * @param {*} $controller
+     * @param {*} $rootScope
+     * @param {*} $sce
+     * @param {*} $animate
+     * @returns
+     */
     function (
       $injector,
       $interpolate,

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

@@ -1,5 +1,5 @@
 import { Angular } from "../../loader";
-import { createInjector } from "../../injector";
+import { createInjector } from "../di/injector";
 import { dealoc, JQLite, getOrSetCacheData } from "../../shared/jqlite/jqlite";
 import {
   forEach,
@@ -11094,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" +
@@ -17386,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.js

@@ -63,6 +63,11 @@ export function $ControllerProvider() {
 
   this.$get = [
     "$injector",
+    /**
+     *
+     *  @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @returns
+     */
     function ($injector) {
       /**
        * @ngdoc service

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

@@ -1,5 +1,5 @@
 import { Angular } from "../../loader";
-import { createInjector } from "../../injector";
+import { createInjector } from "../di/injector";
 
 describe("$controller", () => {
   let $controllerProvider;

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

@@ -1,5 +1,5 @@
 import { Angular } from "../loader";
-import { createInjector } from "../injector";
+import { createInjector } from "./di/injector";
 
 describe("$$cookieReader", () => {
   let $$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/core/di/injector.js

@@ -0,0 +1,299 @@
+import {
+  assertArgFn,
+  minErr,
+  isFunction,
+  isString,
+  isUndefined,
+  assertArg,
+  assertNotHasOwnProperty,
+  isObject,
+  assert,
+} from "../../shared/utils";
+import { INJECTOR_LITERAL } from "./ng-module";
+import { ProviderInjector, InjectorService } from "./internal-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_LITERAL);
+
+const providerSuffix = "Provider";
+/** @type {String[]} Used only for error reporting of circular dependencies*/
+export const path = [];
+
+/**
+ *
+ * @param {Array<String|Function>} modulesToLoad
+ * @param {boolean} [strictDi]
+ * @returns {InjectorService}
+ */
+export function createInjector(modulesToLoad, strictDi = false) {
+  assert(Array.isArray(modulesToLoad), "modules required");
+
+  /** @type {Map<String|Function, boolean>} */
+  const loadedModules = new Map(); // Keep track of loaded modules to avoid circular dependencies
+
+  const providerCache = {
+    $provide: {
+      provider: supportObject(provider),
+      factory: supportObject(factory),
+      service: supportObject(service),
+      value: supportObject(value),
+      constant: supportObject(constant),
+      decorator,
+    },
+  };
+
+  const providerInjector = (providerCache.$injector = new ProviderInjector(
+    providerCache,
+    strictDi,
+  ));
+
+  const instanceCache = {};
+  const protoInstanceInjector = new InjectorService(
+    instanceCache,
+    strictDi,
+    providerInjector,
+  );
+
+  providerCache.$injectorProvider = {
+    // $injectionProvider return instance injector
+    $get: () => protoInstanceInjector,
+  };
+  let instanceInjector = protoInstanceInjector;
+  instanceInjector.modules = providerInjector.modules = {};
+  const runBlocks = loadModules(modulesToLoad);
+  instanceInjector = protoInstanceInjector.get(INJECTOR_LITERAL);
+  instanceInjector.strictDi = strictDi;
+  runBlocks.forEach((fn) => {
+    if (fn) instanceInjector.invoke(fn);
+  });
+
+  instanceInjector.loadNewModules = function (mods) {
+    loadModules(mods).forEach((fn) => {
+      if (fn) instanceInjector.invoke(fn);
+    });
+  };
+
+  return instanceInjector;
+
+  ////////////////////////////////////
+  // $provider
+  ////////////////////////////////////
+
+  /**
+   *
+   * @param {string} name
+   * @param {import('../../types').ServiceProvider} provider
+   * @returns
+   */
+  function provider(name, provider) {
+    assertNotHasOwnProperty(name, "service");
+    let newProvider;
+    if (isFunction(provider) || Array.isArray(provider)) {
+      newProvider = providerInjector.instantiate(provider);
+    } else {
+      newProvider = provider;
+    }
+    if (!newProvider.$get) {
+      throw $injectorMinErr(
+        "pget",
+        "Provider '{0}' must define $get factory method.",
+        name,
+      );
+    }
+    providerCache[name + providerSuffix] = newProvider;
+    return newProvider;
+  }
+
+  function factory(name, factoryFn) {
+    return provider(name, {
+      $get: () => {
+        const result = instanceInjector.invoke(factoryFn, this);
+        if (isUndefined(result)) {
+          throw $injectorMinErr(
+            "undef",
+            "Provider '{0}' must return a value from $get factory method.",
+            name,
+          );
+        }
+        return result;
+      },
+    });
+  }
+
+  function service(name, constructor) {
+    return factory(name, [
+      INJECTOR_LITERAL,
+      ($injector) => $injector.instantiate(constructor),
+    ]);
+  }
+
+  /**
+   * @param {String} name
+   * @param {any} val
+   * @returns {import('../../types').ServiceProvider}
+   */
+  function value(name, val) {
+    return (providerCache[name + providerSuffix] = { $get: () => val });
+  }
+
+  function constant(name, value) {
+    assertNotHasOwnProperty(name, "constant");
+    providerCache[name] = value;
+    instanceCache[name] = value;
+  }
+
+  function decorator(serviceName, decorFn) {
+    const origProvider = providerInjector.get(serviceName + providerSuffix);
+    const origGet = origProvider.$get;
+
+    origProvider.$get = function () {
+      const origInstance = instanceInjector.invoke(origGet, origProvider);
+      return instanceInjector.invoke(decorFn, null, {
+        $delegate: origInstance,
+      });
+    };
+  }
+
+  /**
+   *
+   * @param {Array<String|Function>} modulesToLoad
+   * @returns
+   */
+  function loadModules(modulesToLoad) {
+    assertArg(
+      isUndefined(modulesToLoad) || Array.isArray(modulesToLoad),
+      "modulesToLoad",
+      "not an array",
+    );
+    let runBlocks = [];
+
+    modulesToLoad.forEach((module) => {
+      if (loadedModules.get(module)) return;
+      loadedModules.set(module, true);
+
+      try {
+        if (isString(module)) {
+          /** @type {import('./ng-module').NgModule} */
+          let moduleFn = window["angular"].module(module);
+          instanceInjector.modules[/** @type {string } */ (module)] = moduleFn;
+          runBlocks = runBlocks
+            .concat(loadModules(moduleFn.requires))
+            .concat(moduleFn.runBlocks);
+
+          const invokeQueue = moduleFn.invokeQueue.concat(
+            moduleFn.configBlocks,
+          );
+          invokeQueue.forEach((invokeArgs) => {
+            const provider = providerInjector.get(invokeArgs[0]);
+            provider[invokeArgs[1]].apply(provider, invokeArgs[2]);
+          });
+        } else if (isFunction(module)) {
+          runBlocks.push(providerInjector.invoke(module));
+        } else if (Array.isArray(module)) {
+          runBlocks.push(providerInjector.invoke(module));
+        } else {
+          assertArgFn(module, "module");
+        }
+      } catch (e) {
+        if (Array.isArray(module)) {
+          module = module[module.length - 1];
+        }
+        if (e.message && e.stack && e.stack.indexOf(e.message) === -1) {
+          // Safari & FF's stack traces don't contain error.message content
+          // unlike those of Chrome and IE
+          // 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.message = `${e.message}\n${e.stack}`;
+        }
+        throw $injectorMinErr(
+          "modulerr",
+          "Failed to instantiate module {0} due to:\n{1}",
+          module,
+          e.stack || e.message || e,
+        );
+      }
+    });
+    return runBlocks;
+  }
+}
+
+// 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 {any} fn
+ * @param {boolean} [strictDi]
+ * @param {String} [name]
+ * @returns {Array<string>}
+ */
+export 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;
+}
+
+/**
+ * @param {function(string, any):any} delegate
+ * @returns
+ */
+function supportObject(delegate) {
+  return function (key, value) {
+    if (isObject(key)) {
+      Object.entries(key).forEach(([k, v]) => {
+        delegate(k, v);
+      });
+    } else {
+      return delegate(key, value);
+    }
+  };
+}

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

@@ -250,7 +250,7 @@
 - }
 -
 - // Then
-- expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
+- expect(annotate(MyController)).toEqual(['$scope', '$route']);
 - ```
 
   ```
@@ -277,7 +277,7 @@
 - MyController['$inject'] = ['$scope', '$route'];
 -
 - // Then
-- expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
+- expect(annotate(MyController)).toEqual(['$scope', '$route']);
 - ```
 
   ```
@@ -311,7 +311,7 @@
 - }]);
 -
 - // Therefore
-- expect(injector.annotate(
+- expect(annotate(
 -      ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])
 - ).toEqual(['$compile', '$rootScope']);
 - ```