@angular-wave/angular.ts 0.0.66 → 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.66",
+  "version": "0.0.67",
   "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/parser/parse.js

@@ -15,7 +15,7 @@ import { Parser } from "./parser";
  */
 
 /**
- * @typedef {function} CompiledExpressionFunction
+ * @typedef {Function} CompiledExpressionFunction
  * @param {import('../scope/scope').Scope} context - An object against which any expressions embedded in the strings are evaluated against (typically a scope object).
  * @param {object} [locals] - local variables context object, useful for overriding values in `context`.
  * @param {any} [assign]
@@ -81,7 +81,6 @@ export function $ParseProvider() {
         isIdentifierStart: isFunction(identStart) && identStart,
         isIdentifierContinue: isFunction(identContinue) && identContinue,
       };
-      $parse.$$getAst = $$getAst;
       return $parse;
 
       function $parse(exp, interceptorFn) {
@@ -111,16 +110,6 @@ export function $ParseProvider() {
         }
       }
 
-      /**
-       * @param {string} exp
-       * @returns {import("./ast").ASTNode}
-       */
-      function $$getAst(exp) {
-        var lexer = new Lexer($lexerOptions);
-        var parser = new Parser(lexer, $filter);
-        return parser.getAst(exp).ast;
-      }
-
       function addInterceptor(parsedExpression, interceptorFn) {
         if (!interceptorFn) return parsedExpression;