@angular-wave/angular.ts 0.0.65 → 0.0.67

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.65",
+  "version": "0.0.67",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

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/animate-swap.js

@@ -1,4 +1,7 @@
 ngAnimateSwapDirective.$inject = ["$animate"];
+/**
+ * @returns {import('../types').Directive}
+ */
 export function ngAnimateSwapDirective($animate) {
   return {
     restrict: "A",

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/core/compile/compile.js

@@ -218,7 +218,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
    *    are the factories.
    * @param {Function|Array} directiveFactory An injectable directive factory function. See the
    *    {@link guide/directive directive guide} and the {@link $compile compile API} for more info.
-   * @returns {ng.ICompileProvider} Self for chaining.
+   * @returns {$CompileProvider} Self for chaining.
    */
   this.directive = function registerDirective(name, directiveFactory) {
     assertArg(name, "name");
@@ -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
            */
@@ -442,7 +442,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
    * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
    *
    * @param {RegExp=} regexp New regexp to trust urls with.
-   * @returns {RegExp|ng.ICompileProvider} Current RegExp if called without value or self for
+   * @returns {RegExp|$CompileProvider} Current RegExp if called without value or self for
    *    chaining otherwise.
    */
   this.aHrefSanitizationTrustedUrlList = function (regexp) {
@@ -470,7 +470,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
    * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
    *
    * @param {RegExp=} regexp New regexp to trust urls with.
-   * @returns {RegExp|ng.ICompileProvider} Current RegExp if called without value or self for
+   * @returns {RegExp|$CompileProvider} Current RegExp if called without value or self for
    *    chaining otherwise.
    */
   this.imgSrcSanitizationTrustedUrlList = function (regexp) {
@@ -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/controller/controller.js

@@ -21,11 +21,6 @@ export function identifierForController(controller, ident) {
 }
 
 /**
- * @ngdoc provider
- * @name $controllerProvider
- *
- *
- * @description
  * The {@link ng.$controller $controller service} is used by AngularJS to create new
  * controllers.
  *
@@ -63,6 +58,11 @@ export function $ControllerProvider() {
 
   this.$get = [
     "$injector",
+    /**
+     *
+     *  @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @returns
+     */
     function ($injector) {
       /**
        * @ngdoc service

package/src/core/di/injector.js

@@ -1,95 +1,36 @@
 import {
   assertArgFn,
   minErr,
-  forEach,
   isFunction,
   isString,
-  isBoolean,
   isUndefined,
   assertArg,
-  valueFn,
   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");
-
-function stringifyFn(fn) {
-  return Function.prototype.toString.call(fn);
-}
-
-function extractArgs(fn) {
-  var fnText = stringifyFn(fn).replace(STRIP_COMMENTS, ""),
-    args = fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
-  return args;
-}
-
-function anonFn(fn) {
-  // For anonymous functions, showing at the very least the function signature can help in
-  // debugging.
-  var args = extractArgs(fn);
-  if (args) {
-    return "function(" + (args[1] || "").replace(/[\s\r\n]+/, " ") + ")";
-  }
-  return "fn";
-}
-
-function annotate(fn, strictDi, name) {
-  var $inject, argDecl, last;
-
-  if (typeof fn === "function") {
-    if (!($inject = fn.$inject)) {
-      $inject = [];
-      if (fn.length) {
-        if (strictDi) {
-          if (!isString(name) || !name) {
-            name = fn.name || anonFn(fn);
-          }
-          throw $injectorMinErr(
-            "strictdi",
-            "{0} is not using explicit annotation and cannot be invoked in strict mode",
-            name,
-          );
-        }
-        argDecl = extractArgs(fn);
-        forEach(argDecl[1].split(FN_ARG_SPLIT), function (arg) {
-          arg.replace(FN_ARG, function (all, underscore, name) {
-            $inject.push(name);
-          });
-        });
-      }
-      fn.$inject = $inject;
-    }
-  } else if (Array.isArray(fn)) {
-    last = fn.length - 1;
-    assertArgFn(fn[last], "fn");
-    $inject = fn.slice(0, last);
-  } else {
-    assertArgFn(fn, "fn", true);
-  }
-  return $inject;
-}
+const $injectorMinErr = minErr(INJECTOR_LITERAL);
 
 const providerSuffix = "Provider";
-const INSTANTIATING = {};
+/** @type {String[]} Used only for error reporting of circular dependencies*/
+export const path = [];
 
 /**
  *
  * @param {Array<String|Function>} modulesToLoad
  * @param {boolean} [strictDi]
- * @returns {import("../../types").InjectorService}
+ * @returns {InjectorService}
  */
 export function createInjector(modulesToLoad, strictDi = false) {
   assert(Array.isArray(modulesToLoad), "modules required");
-  assert(isBoolean(strictDi));
-  /** @type {Array<string>} */
-  const path = [];
 
   /** @type {Map<String|Function, boolean>} */
   const loadedModules = new Map(); // Keep track of loaded modules to avoid circular dependencies
@@ -105,43 +46,22 @@ export function createInjector(modulesToLoad, strictDi = false) {
     },
   };
 
-  providerCache.$injector = createInternalInjector(
+  const providerInjector = (providerCache.$injector = new ProviderInjector(
     providerCache,
-    function (caller) {
-      if (isString(caller)) {
-        path.push(caller);
-      }
-      throw $injectorMinErr("unpr", "Unknown provider: {0}", path.join(" <- "));
-    },
-  );
+    strictDi,
+  ));
 
-  const instanceCache = {};
-
-  let protoInstanceInjector = createInternalInjector(
-    instanceCache,
-    (serviceName, caller) => {
-      const provider = providerCache.$injector.get(
-        serviceName + providerSuffix,
-        caller,
-      );
-      return instanceInjector.invoke(
-        provider.$get,
-        provider,
-        undefined,
-        serviceName,
-      );
-    },
-  );
+  const protoInstanceInjector = new InjectorService(strictDi, providerInjector);
 
-  providerCache["$injector" + providerSuffix] = {
-    $get: valueFn(protoInstanceInjector),
+  providerCache.$injectorProvider = {
+    // $injectionProvider return instance injector
+    $get: () => protoInstanceInjector,
   };
+
   let instanceInjector = protoInstanceInjector;
-  instanceInjector.modules = providerCache.$injector.modules =
-    Object.create(null);
   const runBlocks = loadModules(modulesToLoad);
-  instanceInjector = protoInstanceInjector.get("$injector");
-  instanceInjector.strictDi = strictDi;
+  instanceInjector = protoInstanceInjector.get(INJECTOR_LITERAL);
+
   runBlocks.forEach((fn) => {
     if (fn) instanceInjector.invoke(fn);
   });
@@ -158,89 +78,83 @@ export function createInjector(modulesToLoad, strictDi = false) {
   // $provider
   ////////////////////////////////////
 
-  function supportObject(delegate) {
-    return function (key, value) {
-      if (isObject(key)) {
-        Object.entries(key).forEach(([k, v]) => {
-          delegate(k, v);
-        });
-      } else {
-        return delegate(key, value);
-      }
-    };
-  }
-
+  /**
+   *
+   * @param {string} name
+   * @param {import('../../types').ServiceProvider} provider
+   * @returns
+   */
   function provider(name, provider) {
     assertNotHasOwnProperty(name, "service");
+    let newProvider;
     if (isFunction(provider) || Array.isArray(provider)) {
-      provider = providerCache.$injector.instantiate(provider);
+      newProvider = providerInjector.instantiate(
+        /** @type {Function} */ (provider),
+      );
+    } else {
+      newProvider = provider;
     }
-    if (!provider.$get) {
+    if (!newProvider.$get) {
       throw $injectorMinErr(
         "pget",
         "Provider '{0}' must define $get factory method.",
         name,
       );
     }
-    return (providerCache[name + providerSuffix] = provider);
+    providerCache[name + providerSuffix] = newProvider;
+    return newProvider;
   }
 
-  function enforceReturnValue(name, factory) {
-    return function enforcedReturnValue() {
-      const result = instanceInjector.invoke(factory, this);
-      if (isUndefined(result)) {
-        throw $injectorMinErr(
-          "undef",
-          "Provider '{0}' must return a value from $get factory method.",
-          name,
-        );
-      }
-      return result;
-    };
-  }
-
-  function factory(name, factoryFn, enforce) {
+  function factory(name, factoryFn) {
     return provider(name, {
-      $get: enforce !== false ? enforceReturnValue(name, factoryFn) : factoryFn,
+      $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",
-      function ($injector) {
-        return $injector.instantiate(constructor);
-      },
+      INJECTOR_LITERAL,
+      ($injector) => $injector.instantiate(constructor),
     ]);
   }
 
+  /**
+   * @param {String} name
+   * @param {any} val
+   * @returns {import('../../types').ServiceProvider}
+   */
   function value(name, val) {
-    return factory(name, valueFn(val), false);
+    return (providerCache[name + providerSuffix] = { $get: () => val });
   }
 
   function constant(name, value) {
     assertNotHasOwnProperty(name, "constant");
-    providerCache[name] = value;
-    instanceCache[name] = value;
+    providerInjector.cache[name] = value;
+    protoInstanceInjector.cache[name] = value;
   }
 
   function decorator(serviceName, decorFn) {
-    const origProvider = providerCache.$injector.get(
-      serviceName + providerSuffix,
-    );
-    const orig$get = origProvider.$get;
+    const origProvider = providerInjector.get(serviceName + providerSuffix);
+    const origGet = origProvider.$get;
 
     origProvider.$get = function () {
-      const origInstance = instanceInjector.invoke(orig$get, origProvider);
+      const origInstance = instanceInjector.invoke(origGet, origProvider);
       return instanceInjector.invoke(decorFn, null, {
         $delegate: origInstance,
       });
     };
   }
 
-  ////////////////////////////////////
-  // Module Loading
-  ////////////////////////////////////
   /**
    *
    * @param {Array<String|Function>} modulesToLoad
@@ -258,31 +172,26 @@ export function createInjector(modulesToLoad, strictDi = false) {
       if (loadedModules.get(module)) return;
       loadedModules.set(module, true);
 
-      /**
-       *
-       * @param {Array<Array<any>>} queue
-       */
-      function runInvokeQueue(queue) {
-        queue.forEach((invokeArgs) => {
-          const provider = providerCache.$injector.get(invokeArgs[0]);
-          provider[invokeArgs[1]].apply(provider, invokeArgs[2]);
-        });
-      }
-
       try {
         if (isString(module)) {
           /** @type {import('./ng-module').NgModule} */
-          let moduleFn = window["angular"].module(module);
-          instanceInjector.modules[module] = moduleFn;
+          const moduleFn = window["angular"].module(module);
+          instanceInjector.modules[/** @type {string } */ (module)] = moduleFn;
           runBlocks = runBlocks
             .concat(loadModules(moduleFn.requires))
             .concat(moduleFn.runBlocks);
-          runInvokeQueue(moduleFn.invokeQueue);
-          runInvokeQueue(moduleFn.configBlocks);
+
+          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(providerCache.$injector.invoke(module));
+          runBlocks.push(providerInjector.invoke(module));
         } else if (Array.isArray(module)) {
-          runBlocks.push(providerCache.$injector.invoke(module));
+          runBlocks.push(providerInjector.invoke(module));
         } else {
           assertArgFn(module, "module");
         }
@@ -308,115 +217,80 @@ export function createInjector(modulesToLoad, strictDi = false) {
     });
     return runBlocks;
   }
+}
 
-  ////////////////////////////////////
-  // internal Injector
-  ////////////////////////////////////
+// Helpers
 
-  function createInternalInjector(cache, factory) {
-    function get(serviceName, caller) {
-      if (Object.prototype.hasOwnProperty.call(cache, serviceName)) {
-        if (cache[serviceName] === INSTANTIATING) {
-          throw $injectorMinErr(
-            "cdep",
-            "Circular dependency found: {0}",
-            `${serviceName} <- ${path.join(" <- ")}`,
-          );
-        }
-        return cache[serviceName];
-      }
-      try {
-        path.unshift(serviceName);
-        cache[serviceName] = INSTANTIATING;
-        cache[serviceName] = factory(serviceName, caller);
-        return cache[serviceName];
-      } catch (err) {
-        if (cache[serviceName] === INSTANTIATING) {
-          delete cache[serviceName];
-        }
-        throw err;
-      } finally {
-        path.shift();
-      }
-    }
+/**
+ * @param {String} fn
+ * @returns {String}
+ */
+function stringifyFn(fn) {
+  return Function.prototype.toString.call(fn);
+}
 
-    function injectionArgs(fn, locals, serviceName) {
-      const args = [];
-      const $inject = annotate(fn, strictDi, serviceName);
+/**
+ * @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;
 
-      for (let i = 0, { length } = $inject; i < length; i++) {
-        const key = $inject[i];
-        if (typeof key !== "string") {
+  if (typeof fn === "function") {
+    if (!($inject = fn.$inject)) {
+      $inject = [];
+      if (fn.length) {
+        if (strictDi) {
           throw $injectorMinErr(
-            "itkn",
-            "Incorrect injection token! Expected service name as string, got {0}",
-            key,
+            "strictdi",
+            "{0} is not using explicit annotation and cannot be invoked in strict mode",
+            name,
           );
         }
-        args.push(
-          locals && Object.prototype.hasOwnProperty.call(locals, key)
-            ? locals[key]
-            : get(key, serviceName),
-        );
-      }
-      return args;
-    }
-
-    function isClass(func) {
-      let result = func.$$ngIsClass;
-      if (!isBoolean(result)) {
-        result = func.$$ngIsClass = /^class\b/.test(stringifyFn(func));
-      }
-      return result;
-    }
-
-    function invoke(fn, self, locals, serviceName) {
-      if (typeof locals === "string") {
-        serviceName = locals;
-        locals = null;
-      }
-
-      const args = injectionArgs(fn, locals, serviceName);
-      if (Array.isArray(fn)) {
-        fn = fn[fn.length - 1];
-      }
-
-      if (!isClass(fn)) {
-        // http://jsperf.com/angularjs-invoke-apply-vs-switch
-        // #5388
-        return fn.apply(self, args);
+        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);
+          });
+        });
       }
-      args.unshift(null);
-      return new (Function.prototype.bind.apply(fn, args))();
-    }
-
-    function 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 = 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))();
-    }
-
-    function has(name) {
-      const hasProvider = Object.prototype.hasOwnProperty.call(
-        providerCache,
-        name + providerSuffix,
-      );
-      const hasCache = Object.prototype.hasOwnProperty.call(cache, name);
-      return hasProvider || hasCache;
+      fn.$inject = $inject;
     }
-
-    return {
-      invoke,
-      instantiate,
-      get,
-      annotate,
-      has,
-    };
+  } 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;
 }
 
-createInjector.$$annotate = annotate;
+/**
+ * @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/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']);
 - ```