@angular-wave/angular.ts 0.0.65 → 0.0.67

package/src/core/di/injector.spec.js

@@ -1,5 +1,5 @@
 import { Angular } from "../../loader";
-import { createInjector } from "./injector";
+import { createInjector, annotate } from "./injector";
 import { valueFn, extend } from "../../shared/utils";
 
 describe("injector.modules", () => {
@@ -17,6 +17,19 @@ describe("injector.modules", () => {
     expect($injector.get("$injector")).toBe($injector);
   });
 
+  it("should have modules property", () => {
+    const $injector = createInjector([]);
+    expect($injector.modules).toEqual({});
+  });
+
+  it("should have methods", () => {
+    const $injector = createInjector([]);
+    expect($injector.has).toBeDefined();
+    expect($injector.invoke).toBeDefined();
+    expect($injector.instantiate).toBeDefined();
+    expect($injector.get).toBeDefined();
+  });
+
   it("should have a false strictDi property", () => {
     const injector = createInjector([]);
     expect(injector.strictDi).toBe(false);
@@ -30,13 +43,15 @@ describe("injector.modules", () => {
 
   it("should provide useful message if no provider", () => {
     expect(() => {
-      createInjector([]).get("idontexist");
+      const injector = createInjector([]);
+      injector.get("idontexist");
     }).toThrowError(/Unknown provider/);
   });
 
   it("has a constant that has been registered to a module", () => {
     const module = angular.module("myModule", []);
     module.constant("aConstant", 42);
+
     const injector = createInjector(["myModule"]);
     expect(injector.has("aConstant")).toBe(true);
   });
@@ -108,6 +123,7 @@ describe("injector.modules", () => {
       log.push("initial");
     });
     const injector = createInjector(["initial"]);
+    expect(log).toEqual(["initial"]);
     log.push("created");
 
     angular
@@ -386,12 +402,10 @@ describe("injector.modules", () => {
 });
 
 describe("annotate", () => {
-  let annotate;
   let injector;
   beforeEach(() => {
     window.angular = new Angular();
     injector = createInjector([]);
-    annotate = injector.annotate;
   });
 
   it("should return $inject", () => {
@@ -511,43 +525,43 @@ describe("annotate", () => {
     const injector = createInjector([]);
     const fn = () => {};
     fn.$inject = ["a", "b"];
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns the array-style annotations of a function", () => {
     const injector = createInjector([]);
     const fn = ["a", "b", () => {}];
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns the array-style annotations of a function", () => {
     const injector = createInjector([]);
     const fn = ["a", "b", () => {}];
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns annotations parsed from function args when not annotated", () => {
     const injector = createInjector([]);
     const fn = function (a, b) {};
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns annotations parsed from arrow args when not annotated", () => {
     const injector = createInjector([]);
     const fn = (a, b) => {};
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("strips comments from argument lists when parsing", () => {
     const injector = createInjector([]);
     const fn = function (a, /*b,*/ c) {};
-    expect(injector.annotate(fn)).toEqual(["a", "c"]);
+    expect(annotate(fn)).toEqual(["a", "c"]);
   });
 
   it("strips several comments from argument lists when parsing", () => {
     const injector = createInjector([]);
     const fn = function (a, /*b,*/ c /*, d*/) {};
-    expect(injector.annotate(fn)).toEqual(["a", "c"]);
+    expect(annotate(fn)).toEqual(["a", "c"]);
   });
 
   it("strips // comments from argument lists when parsing", () => {
@@ -556,19 +570,13 @@ describe("annotate", () => {
       a, //b,
       c,
     ) {};
-    expect(injector.annotate(fn)).toEqual(["a", "c"]);
+    expect(annotate(fn)).toEqual(["a", "c"]);
   });
 
   it("strips surrounding underscores from argument names when parsing", () => {
     const injector = createInjector([]);
     const fn = function (a, _b_, c_, _d, an_argument) {};
-    expect(injector.annotate(fn)).toEqual([
-      "a",
-      "b",
-      "c_",
-      "_d",
-      "an_argument",
-    ]);
+    expect(annotate(fn)).toEqual(["a", "b", "c_", "_d", "an_argument"]);
   });
 
   it("throws when using a non-annotated fn in strict mode", () => {
@@ -1922,7 +1930,8 @@ describe("decorator", () => {
       "ng",
       function ($provide) {
         $provide.decorator("$injector", function ($delegate) {
-          return extend({}, $delegate, {
+          // Don't forget the prototype
+          return extend(Object.create($delegate), $delegate, {
             get: function (val) {
               if (val === "key") {
                 return "value";
@@ -1933,7 +1942,6 @@ describe("decorator", () => {
         });
       },
     ]);
-
     expect(injector.get("key")).toBe("value");
     expect(injector.get("$http")).not.toBeUndefined();
   });
@@ -2245,9 +2253,7 @@ describe("protection modes", () => {
   });
 
   it("should prevent instance lookup in module", () => {
-    function instanceLookupInModule(name) {
-      throw new Error("FAIL");
-    }
+    function instanceLookupInModule(name) {}
     expect(() => {
       createInjector([
         function ($provide) {

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

@@ -0,0 +1,286 @@
+import { assertArgFn, minErr } from "../../shared/utils";
+import { INJECTOR_LITERAL } from "./ng-module";
+
+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";
+const INSTANTIATING = true;
+
+class AbstractInjector {
+  /**
+   * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
+   */
+  constructor(strictDi) {
+    /**
+     * @type {Object<String, Function>}
+     */
+    this.cache = {};
+    /** @type {boolean} */
+    this.strictDi = strictDi;
+    this.path = [];
+    /** @type {Object.<string, import("../../types").Module>} */
+    this.modules = {};
+  }
+
+  /**
+   * Get a service by name.
+   *
+   * @param {String} serviceName
+   * @returns {any}
+   */
+  get(serviceName) {
+    if (Object.prototype.hasOwnProperty.call(this.cache, serviceName)) {
+      if (this.cache[serviceName] === INSTANTIATING) {
+        throw $injectorMinErr(
+          "cdep",
+          "Circular dependency found: {0}",
+          `${serviceName} <- ${this.path.join(" <- ")}`,
+        );
+      }
+      return this.cache[serviceName];
+    }
+
+    this.path.unshift(serviceName);
+    this.cache[serviceName] = INSTANTIATING;
+    try {
+      // this goes to line 60
+      this.cache[serviceName] = this.factory(serviceName);
+    } catch (err) {
+      // this is for the error handling being thrown by the providerCache multiple times
+      delete this.cache[serviceName];
+      throw err;
+    }
+    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);
+
+    for (let i = 0, { length } = $inject; i < length; i++) {
+      const key = $inject[i];
+      if (typeof key !== "string") {
+        throw $injectorMinErr(
+          "itkn",
+          "Incorrect injection token! Expected service name as string, got {0}",
+          key,
+        );
+      }
+      args.push(
+        locals && Object.prototype.hasOwnProperty.call(locals, key)
+          ? locals[key]
+          : this.get(key),
+      );
+    }
+    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(
+      /** @type {Function} */ (fn),
+      locals,
+      serviceName,
+    );
+    if (Array.isArray(fn)) {
+      fn = fn[fn.length - 1];
+    }
+
+    if (isClass(/** @type {String} */ (fn))) {
+      args.unshift(null);
+      return new (Function.prototype.bind.apply(fn, args))();
+    } else {
+      return /** @type {Function} */ (fn).apply(self, args);
+    }
+  }
+
+  /**
+   * 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);
+    // Empty object at position 0 is ignored for invocation with `new`, but required.
+    args.unshift(null);
+    return new (Function.prototype.bind.apply(ctor, args))();
+  }
+
+  /**
+   * @abstract
+   */
+  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(" <- "),
+    );
+  }
+}
+
+/**
+ * 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.modules = this.providerInjector.modules;
+  }
+
+  factory(serviceName) {
+    const provider = this.providerInjector.get(serviceName + providerSuffix);
+    const res = this.invoke(provider.$get, provider, undefined, serviceName);
+    return res;
+  }
+
+  /**
+   *
+   * @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
+
+/**
+ * @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 {String} func
+ * @returns {boolean}
+ */
+function isClass(func) {
+  return /^class\b/.test(stringifyFn(func));
+}
+
+/**
+ *
+ * @param {any} fn
+ * @param {boolean} strictDi
+ * @param {String} name
+ * @returns {Array<string>}
+ */
+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;
+}

package/src/core/filter/filter.js

@@ -22,6 +22,11 @@ export function $FilterProvider($provide) {
 
   this.$get = [
     "$injector",
+    /**
+     *
+     * @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @returns
+     */
     function ($injector) {
       return function (name) {
         return $injector.get(name + suffix);

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;