@angular-wave/angular.ts 0.0.66 → 0.0.68

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

package/src/animations/animate-js.js

@@ -14,10 +14,10 @@ export function $$AnimateJsProvider($animateProvider) {
     "$injector",
     "$$AnimateRunner",
     /**
-     * 
-     * @param {import("../core/di/internal-injector").InjectorService} $injector 
-     * @param {*} $$AnimateRunner 
-     * @returns 
+     *
+     * @param {import("../core/di/internal-injector").InjectorService} $injector
+     * @param {*} $$AnimateRunner
+     * @returns
      */
     function ($injector, $$AnimateRunner) {
       const applyAnimationClasses = applyAnimationClassesFactory();

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/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");
@@ -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) {

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.
  *

package/src/core/di/injector.js

@@ -51,22 +51,17 @@ export function createInjector(modulesToLoad, strictDi = false) {
     strictDi,
   ));
 
-  const instanceCache = {};
-  const protoInstanceInjector = new InjectorService(
-    instanceCache,
-    strictDi,
-    providerInjector,
-  );
+  const protoInstanceInjector = new InjectorService(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);
   });
@@ -93,7 +88,9 @@ export function createInjector(modulesToLoad, strictDi = false) {
     assertNotHasOwnProperty(name, "service");
     let newProvider;
     if (isFunction(provider) || Array.isArray(provider)) {
-      newProvider = providerInjector.instantiate(provider);
+      newProvider = providerInjector.instantiate(
+        /** @type {Function} */ (provider),
+      );
     } else {
       newProvider = provider;
     }
@@ -142,8 +139,8 @@ export function createInjector(modulesToLoad, strictDi = false) {
 
   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) {
@@ -178,7 +175,7 @@ export function createInjector(modulesToLoad, strictDi = false) {
       try {
         if (isString(module)) {
           /** @type {import('./ng-module').NgModule} */
-          let moduleFn = window["angular"].module(module);
+          const moduleFn = window["angular"].module(module);
           instanceInjector.modules[/** @type {string } */ (module)] = moduleFn;
           runBlocks = runBlocks
             .concat(loadModules(moduleFn.requires))

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

@@ -9,33 +9,26 @@ const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
 const $injectorMinErr = minErr(INJECTOR_LITERAL);
 
 const providerSuffix = "Provider";
-const INSTANTIATING = "INSTANTIATING";
+const INSTANTIATING = true;
 
-export class ProviderInjector {
+class AbstractInjector {
   /**
-   *
-   * @param {Object} cache
-   * @param {boolean} strictDi
+   * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
    */
-  constructor(cache, strictDi) {
-    this.cache = cache;
+  constructor(strictDi) {
+    /**
+     * @type {Object<String, Function>}
+     */
+    this.cache = {};
+    /** @type {boolean} */
     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(" <- "),
-    );
+    /** @type {Object.<string, import("../../types").Module>} */
+    this.modules = {};
   }
 
   /**
+   * Get a service by name.
    *
    * @param {String} serviceName
    * @returns {any}
@@ -65,6 +58,14 @@ export class ProviderInjector {
     return this.cache[serviceName];
   }
 
+  /**
+   * Get the injection arguments for a function.
+   *
+   * @param {Function|Array} fn
+   * @param {Object} locals
+   * @param {String} serviceName
+   * @returns
+   */
   injectionArgs(fn, locals, serviceName) {
     const args = [];
     const $inject = annotate(fn, this.strictDi, serviceName);
@@ -87,81 +88,133 @@ export class ProviderInjector {
     return args;
   }
 
+  /**
+   * Invoke a function with optional context and locals.
+   *
+   * @param {Function|String|Array<any>} fn
+   * @param {*} [self]
+   * @param {Object} [locals]
+   * @param {String} [serviceName]
+   * @returns
+   */
   invoke(fn, self, locals, serviceName) {
     if (typeof locals === "string") {
       serviceName = locals;
       locals = null;
     }
 
-    const args = this.injectionArgs(fn, locals, serviceName);
+    const args = this.injectionArgs(
+      /** @type {Function} */ (fn),
+      locals,
+      serviceName,
+    );
     if (Array.isArray(fn)) {
       fn = fn[fn.length - 1];
     }
 
-    if (isClass(fn)) {
+    if (isClass(/** @type {String} */ (fn))) {
       args.unshift(null);
       return new (Function.prototype.bind.apply(fn, args))();
     } else {
-      return fn.apply(self, args);
+      return /** @type {Function} */ (fn).apply(self, args);
     }
   }
 
-  instantiate(Type, locals, serviceName) {
-    // Check if Type is annotated and use just the given function at n-1 as parameter
+  /**
+   * Instantiate a type constructor with optional locals.
+   * @param {Function|Array} type
+   * @param {*} [locals]
+   * @param {String} [serviceName]
+   */
+  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);
+    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}
+   * @abstract
    */
-  has(name) {
-    const hasProvider = Object.prototype.hasOwnProperty.call(
-      this.providerCache,
-      name + providerSuffix,
+  loadNewModules() {}
+
+  /**
+   * @abstract
+   * @param {String} _serviceName
+   */
+  factory(_serviceName) {
+    console.error(`Unhandled ${_serviceName}`);
+  }
+}
+
+/**
+ * Injector for providers
+ * @extends AbstractInjector
+ */
+export class ProviderInjector extends AbstractInjector {
+  /**
+   * @param {Object} cache
+   * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
+   */
+  constructor(cache, strictDi) {
+    super(strictDi);
+    this.cache = cache;
+  }
+
+  /**
+   * Factory method for creating services.
+   * @param {String} caller - The name of the caller requesting the service.
+   * @throws {Error} If the provider is unknown.
+   */
+  factory(caller) {
+    this.path.push(caller);
+    // prevents lookups to providers through get
+    throw $injectorMinErr(
+      "unpr",
+      "Unknown provider: {0}",
+      this.path.join(" <- "),
     );
-    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;
+/**
+ * Injector for factories and services
+ * @extends AbstractInjector
+ */
+export class InjectorService extends AbstractInjector {
+  /**
+   *
+   * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
+   * @param {ProviderInjector} providerInjector
+   */
+  constructor(strictDi, providerInjector) {
+    super(strictDi);
     this.providerInjector = providerInjector;
-    this.providerCache = providerInjector.cache;
-    this.modules = undefined;
+    this.modules = this.providerInjector.modules;
   }
 
-  factory(serviceName, caller) {
-    const provider = this.providerInjector.get(
-      serviceName + providerSuffix,
-      caller,
-    );
+  factory(serviceName) {
+    const provider = this.providerInjector.get(serviceName + providerSuffix);
     const res = this.invoke(provider.$get, provider, undefined, serviceName);
     return res;
   }
 
-  // Gets overridden
-  loadNewModules() {}
+  /**
+   *
+   * @param {String} name
+   * @returns {boolean}
+   */
+  has(name) {
+    const hasProvider = Object.prototype.hasOwnProperty.call(
+      this.providerInjector.cache,
+      name + providerSuffix,
+    );
+    const hasCache = Object.prototype.hasOwnProperty.call(this.cache, name);
+    return hasProvider || hasCache;
+  }
 }
 
 // Helpers
@@ -215,7 +268,7 @@ function annotate(fn, strictDi, name) {
         }
         argDecl = extractArgs(/** @type {String} */ (fn));
         argDecl[1].split(FN_ARG_SPLIT).forEach(function (arg) {
-          arg.replace(FN_ARG, function (all, underscore, name) {
+          arg.replace(FN_ARG, function (_all, _underscore, name) {
             $inject.push(name);
           });
         });

package/src/core/interval/interval-factory.js

@@ -6,7 +6,14 @@ export function $$IntervalFactoryProvider() {
     "$q",
     "$$q",
     "$rootScope",
-    // TODO Add types
+    /**
+     *
+     * @param {import('../../services/browser').Browser} $browser
+     * @param {*} $q
+     * @param {*} $$q
+     * @param {import('../scope/scope').Scope} $rootScope
+     * @returns
+     */
     function ($browser, $q, $$q, $rootScope) {
       return function intervalFactory(setIntervalFn, clearIntervalFn) {
         return function intervalFn(fn, delay, count, invokeApply) {

package/src/core/interval/interval.js

@@ -3,32 +3,47 @@ import { minErr } from "../../shared/utils";
 
 const $intervalMinErr = minErr("$interval");
 
+/**
+ * @typedef {number} IntervalId
+ * Interval ID which uniquely identifies the interval and can be used to cancel it
+ */
+
+/**
+ * @type {Map<IntervalId, import("../q/q").Deferred<any>>}
+ */
+const intervals = new Map();
+
 export function $IntervalProvider() {
   this.$get = [
     "$$intervalFactory",
     // TODO Add type
     function ($$intervalFactory) {
-      const intervals = {};
-      const setIntervalFn = function (tick, delay, deferred) {
+      /**
+       * @param {TimerHandler} tick
+       * @param {number} delay
+       * @param {import("../q/q").Deferred<any>} deferred
+       * @returns {IntervalId} - This method returns an interval ID which uniquely identifies the interval
+       */
+      function setIntervalFn(tick, delay, deferred) {
         const id = window.setInterval(tick, delay);
-        intervals[id] = deferred;
+        intervals.set(id, deferred);
         return id;
-      };
-      const clearIntervalFn = function (id) {
+      }
+
+      /**s
+       * @param {IntervalId} id
+       */
+      function clearIntervalFn(id) {
         window.clearInterval(id);
-        delete intervals[id];
-      };
+        intervals.delete(id);
+      }
 
       const interval = $$intervalFactory(setIntervalFn, clearIntervalFn);
 
       /**
-       * @ngdoc method
-       * @name $interval#cancel
-       *
-       * @description
        * Cancels a task associated with the `promise`.
        *
-       * @param {Promise=} promise returned by the `$interval` function.
+       * @param {!import("../q/q").QPromise<any>} promise returned by the `$interval` function.
        * @returns {boolean} Returns `true` if the task was successfully canceled.
        */
       interval.cancel = function (promise) {
@@ -41,13 +56,12 @@ export function $IntervalProvider() {
           );
         }
 
-        if (
-          !Object.prototype.hasOwnProperty.call(intervals, promise.$$intervalId)
-        )
+        if (!intervals.has(promise.$$intervalId)) {
           return false;
+        }
 
         const id = promise.$$intervalId;
-        const deferred = intervals[id];
+        const deferred = intervals.get(id);
 
         // Interval cancels should not report an unhandled promise.
         markQExceptionHandled(deferred.promise);