@angular-wave/angular.ts 0.9.4 → 0.9.6

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

@@ -1,12 +0,0 @@
-import { test, expect } from "@playwright/test";
-
-const TEST_URL = "src/core/di/injector.html?random=false";
-
-test("unit tests contain no errors", async ({ page }) => {
-  await page.goto(TEST_URL);
-  await page.content();
-  await page.waitForTimeout(1000);
-  await expect(page.locator(".jasmine-overall-result")).toHaveText(
-    / 0 failures/,
-  );
-});

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

@@ -1,286 +0,0 @@
-import { assertArgFn, hasOwn, minErr } from "../../shared/utils.js";
-import { INJECTOR_LITERAL } from "./ng-module";
-
-const ARROW_ARG = /^([^(]+?)=>/;
-const FN_ARGS = /^[^(]*\(\s*([^)]*)\)/m;
-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;
-    /** @type {string[]} */
-    this.path = [];
-    /** @type {Object.<string, import("./ng-module.js").NgModule>} */
-    this.modules = {};
-  }
-
-  /**
-   * Get a service by name.
-   *
-   * @param {string} serviceName
-   * @returns {any}
-   */
-  get(serviceName) {
-    if (hasOwn(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.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 && hasOwn(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 {Function} */ (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
-   * @returns {any}
-   */
-  factory(_serviceName) {
-    console.error(`Unhandled ${_serviceName}`);
-  }
-}
-
-/**
- * Injector for providers
- */
-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(" <- "),
-    );
-  }
-
-  loadNewModules() {}
-}
-
-/**
- * Injector for factories and services
- */
-export class InjectorService extends AbstractInjector {
-  /**
-   * @param {ProviderInjector} providerInjector
-   * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
-   */
-  constructor(providerInjector, strictDi) {
-    super(strictDi);
-
-    /** @type {ProviderInjector} */
-    this.providerInjector = providerInjector;
-    /** @type {Object.<string, import("./ng-module.js").NgModule>} */
-    this.modules = providerInjector.modules;
-  }
-
-  /**
-   * @param {string} serviceName
-   * @returns {*}
-   */
-  factory(serviceName) {
-    const provider = this.providerInjector.get(serviceName + providerSuffix);
-    return this.invoke(provider.$get, provider, undefined, serviceName);
-  }
-
-  /**
-   *
-   * @param {string} name
-   * @returns {boolean}
-   */
-  has(name) {
-    const hasProvider = hasOwn(
-      this.providerInjector.cache,
-      name + providerSuffix,
-    );
-    const hasCache = hasOwn(this.cache, name);
-    return hasProvider || hasCache;
-  }
-}
-
-// Helpers
-
-/**
- * @param {Function} fn
- * @returns {string}
- */
-function stringifyFn(fn) {
-  return Function.prototype.toString.call(fn);
-}
-
-/**
- * @param {Function} fn
- * @returns {Array<any>}
- */
-function extractArgs(fn) {
-  const fnText = stringifyFn(fn).replace(STRIP_COMMENTS, "");
-  return fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
-}
-
-/**
- * @param {Function} 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) {
-  let $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(fn);
-        argDecl[1].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/di/ng-module.html

@@ -1,19 +0,0 @@
-<!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.css" />
-    <link rel="stylesheet" href="/public/jasmine-helper.css" />
-    <script src="/jasmine/jasmine.js"></script>
-    <script src="/jasmine/jasmine-html.js"></script>
-    <script src="/jasmine/boot0.js"></script>
-    <script src="/jasmine/boot1.js"></script>
-    <script type="module" src="/src/core/di/ng-module.spec.js"></script>
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>

package/src/core/di/ng-module.js

@@ -1,229 +0,0 @@
-import { $injectTokens as $t } from "../../injection-tokens.js";
-import { isFunction, isString, assert } from "../../shared/utils.js";
-
-/** @private */
-export const INJECTOR_LITERAL = "$injector";
-/** @private */
-export const COMPILE_LITERAL = "$compileProvider";
-/** @private */
-export const ANIMATION_LITERAL = "$animateProvider";
-/** @private */
-export const FILTER_LITERAL = "$filterProvider";
-/** @private */
-export const CONTROLLER_LITERAL = "$controllerProvider";
-
-/**
- * Modules are collections of application configuration information for components:
- * controllers, directives, filters, etc. They provide recipes for the injector
- * to do the actual instantiation. A module itself has no behaviour but only state.
- * A such, it acts as a data structure between the Angular instance and the injector service.
- *
- * Since this is an internal structure that is exposed only via the Angular instance,
- * it contains no validation of the items it receives. It is up to the instantiator on
- * modules to do the actual validation.
- */
-export class NgModule {
-  /**
-   * @param {string} name - Name of the module
-   * @param {Array<string>} requires - List of modules which the injector will load before the current module
-   * @param {import("../../interface.js").Injectable<any>} [configFn]
-   */
-  constructor(name, requires, configFn) {
-    assert(isString(name), "name required");
-    assert(Array.isArray(requires), "requires array required");
-    /**
-     * Name of the current module.
-     * @type {string}
-     */
-    this.name = name;
-
-    /**
-     * Array of module names that this module depends on.
-     * @type {string[]}
-     */
-    this.requires = requires;
-
-    /**
-     * Holds a collection of tasks, required to instantiate an angular component
-     * @type {!Array<Array<*>>}
-     */
-    this.invokeQueue = [];
-
-    /** @type {!Array<Array<*>>} */
-    this.configBlocks = [];
-
-    /** @type {!Array.<import("../../interface.js").Injectable<any>>} */
-    this.runBlocks = [];
-
-    if (configFn) {
-      this.config(configFn);
-    }
-
-    this.services = [];
-  }
-
-  /**
-   * @param {string} name
-   * @param {any} object
-   * @returns {NgModule}
-   */
-  value(name, object) {
-    this.invokeQueue.push([$t.$provide, "value", [name, object]]);
-    return this;
-  }
-
-  /**
-   * @param {string} name
-   * @param {any} object
-   * @returns {NgModule}
-   */
-  constant(name, object) {
-    this.invokeQueue.unshift([$t.$provide, "constant", [name, object]]);
-    return this;
-  }
-
-  /**
-   *
-   * @param {import("../../interface.ts").Injectable<any>} configFn
-   * @returns {NgModule}
-   */
-  config(configFn) {
-    this.configBlocks.push([INJECTOR_LITERAL, "invoke", [configFn]]);
-    return this;
-  }
-
-  /**
-   * @param {import("../../interface.ts").Injectable<any>} block
-   * @returns {NgModule}
-   */
-  run(block) {
-    this.runBlocks.push(block);
-    return this;
-  }
-
-  /**
-   * @param {string} name
-   * @param {import("../../interface.ts").Component} options
-   * @returns {NgModule}
-   */
-  component(name, options) {
-    if (options && isFunction(options)) {
-      options["$$moduleName"] = name;
-    }
-    this.invokeQueue.push([COMPILE_LITERAL, "component", [name, options]]);
-    return this;
-  }
-
-  /**
-   * @param {string} name
-   * @param {import("../../interface.ts").Injectable<any>} providerFunction
-   * @returns {NgModule}
-   */
-  factory(name, providerFunction) {
-    if (providerFunction && isFunction(providerFunction)) {
-      providerFunction["$$moduleName"] = name;
-    }
-    this.invokeQueue.push([$t.$provide, "factory", [name, providerFunction]]);
-    return this;
-  }
-
-  /**
-   * @param {string} name
-   * @param {import("../../interface.ts").Injectable<any>} serviceFunction
-   * @returns {NgModule}
-   */
-  service(name, serviceFunction) {
-    if (serviceFunction && isFunction(serviceFunction)) {
-      serviceFunction["$$moduleName"] = name;
-    }
-    this.services.push(name);
-    this.invokeQueue.push([$t.$provide, "service", [name, serviceFunction]]);
-    return this;
-  }
-
-  /**
-   * @param {string} name
-   * @param {import("../../interface.ts").Injectable<any>} providerType
-   * @returns {NgModule}
-   */
-  provider(name, providerType) {
-    if (providerType && isFunction(providerType)) {
-      providerType["$$moduleName"] = name;
-    }
-    this.invokeQueue.push([$t.$provide, "provider", [name, providerType]]);
-    return this;
-  }
-
-  /**
-   * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} decorFn
-   * @returns {NgModule}
-   */
-  decorator(name, decorFn) {
-    if (decorFn && isFunction(decorFn)) {
-      decorFn["$$moduleName"] = name;
-    }
-    this.configBlocks.push([$t.$provide, "decorator", [name, decorFn]]);
-    return this;
-  }
-
-  /**
-   * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} directiveFactory
-   * @returns {NgModule}
-   */
-  directive(name, directiveFactory) {
-    if (directiveFactory && isFunction(directiveFactory)) {
-      directiveFactory["$$moduleName"] = name;
-    }
-    this.invokeQueue.push([
-      COMPILE_LITERAL,
-      "directive",
-      [name, directiveFactory],
-    ]);
-    return this;
-  }
-
-  /**
-   * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} animationFactory
-   * @returns {NgModule}
-   */
-  animation(name, animationFactory) {
-    if (animationFactory && isFunction(animationFactory)) {
-      animationFactory["$$moduleName"] = name;
-    }
-    this.invokeQueue.push([
-      ANIMATION_LITERAL,
-      "register",
-      [name, animationFactory],
-    ]);
-    return this;
-  }
-
-  /**
-   * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} filterFn
-   * @return {NgModule}
-   */
-  filter(name, filterFn) {
-    if (filterFn && isFunction(filterFn)) {
-      filterFn["$$moduleName"] = name;
-    }
-    this.invokeQueue.push([FILTER_LITERAL, "register", [name, filterFn]]);
-    return this;
-  }
-
-  /**
-   * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} ctlFn
-   * @returns {NgModule}
-   */
-  controller(name, ctlFn) {
-    if (ctlFn && isFunction(ctlFn)) {
-      ctlFn["$$moduleName"] = name;
-    }
-    this.invokeQueue.push([CONTROLLER_LITERAL, "register", [name, ctlFn]]);
-    return this;
-  }
-}