@tstdl/base 0.87.13 → 0.88.0-alpha1

package/injector/inject.js

@@ -1,118 +1,119 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var inject_exports = {};
-__export(inject_exports, {
-  assertInInjectionContext: () => assertInInjectionContext,
-  getCurrentInjectionContext: () => getCurrentInjectionContext,
-  getCurrentInjector: () => getCurrentInjector,
-  inject: () => inject,
-  injectAll: () => injectAll,
-  injectAllAsync: () => injectAllAsync,
-  injectArgument: () => injectArgument,
-  injectAsync: () => injectAsync,
-  injectMany: () => injectMany,
-  injectManyAsync: () => injectManyAsync,
-  isInInjectionContext: () => isInInjectionContext,
-  runInInjectionContext: () => runInInjectionContext,
-  setCurrentInjectionContext: () => setCurrentInjectionContext
-});
-module.exports = __toCommonJS(inject_exports);
-var import_map = require("../utils/async-iterable-helpers/map.js");
-var import_to_array = require("../utils/async-iterable-helpers/to-array.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_injector = require("./injector.js");
+import { mapAsync } from '../utils/async-iterable-helpers/map.js';
+import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
+import { assertDefined, isArray, isNotNull } from '../utils/type-guards.js';
+import { Injector } from './injector.js';
 let currentInjectionContext = null;
-function inject(token, argument, options) {
-  assertInInjectionContext(inject);
-  return currentInjectionContext.inject(token, argument, options);
+export function inject(token, argument, options) {
+    assertInInjectionContext(inject);
+    return currentInjectionContext.inject(token, argument, options);
 }
-function injectMany(...tokens) {
-  assertInInjectionContext(inject);
-  return tokens.map((item) => (0, import_type_guards.isArray)(item) ? currentInjectionContext.inject(item[0], item[1], item[2]) : currentInjectionContext.inject(item));
+/**
+ * Resolves tokens using the {@link Injector} of the current injection context
+ *
+ * @param token tokens to resolve
+ */
+export function injectMany(...tokens) {
+    assertInInjectionContext(inject);
+    return tokens.map((item) => (isArray(item) ? currentInjectionContext.inject(item[0], item[1], item[2]) : currentInjectionContext.inject(item)));
 }
-async function injectAsync(token, argument, options) {
-  assertInInjectionContext(inject);
-  return currentInjectionContext.injectAsync(token, argument, options);
+export async function injectAsync(token, argument, options) {
+    assertInInjectionContext(inject);
+    return currentInjectionContext.injectAsync(token, argument, options);
 }
-async function injectManyAsync(...tokens) {
-  assertInInjectionContext(inject);
-  return (0, import_to_array.toArrayAsync)((0, import_map.mapAsync)(tokens, async (item) => (0, import_type_guards.isArray)(item) ? currentInjectionContext.injectAsync(item[0], item[1], item[2]) : currentInjectionContext.injectAsync(item)));
+/**
+ * Resolves tokens using the {@link Injector} of the current injection context
+ *
+ * @param token tokens to resolve
+ */
+export async function injectManyAsync(...tokens) {
+    assertInInjectionContext(inject);
+    return toArrayAsync(mapAsync(tokens, async (item) => (isArray(item) ? currentInjectionContext.injectAsync(item[0], item[1], item[2]) : currentInjectionContext.injectAsync(item))));
 }
-function injectAll(token, argument, options) {
-  assertInInjectionContext(injectAll);
-  return currentInjectionContext.injectAll(token, argument, options);
+/**
+ * Resolves a token using the {@link Injector} of the current injection context
+ *
+ * @param token token to resolve
+ * @param argument argument to resolve token with
+ * @param options resolve options
+ */
+export function injectAll(token, argument, options) {
+    assertInInjectionContext(injectAll);
+    return currentInjectionContext.injectAll(token, argument, options);
 }
-async function injectAllAsync(token, argument, options) {
-  assertInInjectionContext(injectAll);
-  return currentInjectionContext.injectAllAsync(token, argument, options);
+/**
+ * Resolves a token using the {@link Injector} of the current injection context
+ *
+ * @param token token to resolve
+ * @param argument argument to resolve token with
+ * @param options resolve options
+ */
+export async function injectAllAsync(token, argument, options) {
+    assertInInjectionContext(injectAll);
+    return currentInjectionContext.injectAllAsync(token, argument, options);
 }
-function injectArgument(_this, options) {
-  assertInInjectionContext(injectArgument);
-  const argument = currentInjectionContext.argument;
-  if (options?.optional != true) {
-    (0, import_type_guards.assertDefined)(argument, "No resolve argument available in current injection context.");
-  }
-  return argument;
+/**
+ * Injects the resolve argument from the current resolution
+ * @param _this can be used for type infer by simply passing `this`. Requires class to implement {@link Resolvable}.
+ * @returns
+ */
+export function injectArgument(_this, options) {
+    assertInInjectionContext(injectArgument);
+    const argument = currentInjectionContext.argument;
+    if (options?.optional != true) {
+        assertDefined(argument, 'No resolve argument available in current injection context.');
+    }
+    return argument;
 }
-function getCurrentInjectionContext(required = false) {
-  if (required) {
-    assertInInjectionContext(getCurrentInjector);
-  }
-  return currentInjectionContext;
+export function getCurrentInjectionContext(required = false) {
+    if (required) {
+        assertInInjectionContext(getCurrentInjector);
+    }
+    return currentInjectionContext;
 }
-function getCurrentInjector(required = false) {
-  return getCurrentInjectionContext(required)?.injector ?? null;
+export function getCurrentInjector(required = false) {
+    return getCurrentInjectionContext(required)?.injector ?? null;
 }
-function setCurrentInjectionContext(context) {
-  const previous = currentInjectionContext;
-  currentInjectionContext = context;
-  return previous;
+export function setCurrentInjectionContext(context) {
+    const previous = currentInjectionContext;
+    currentInjectionContext = context;
+    return previous;
 }
-function runInInjectionContext(injectorOrContext, fn) {
-  const context = injectorOrContext instanceof import_injector.Injector ? {
-    injector: injectorOrContext,
-    argument: void 0,
-    inject(token, argument, options) {
-      return injectorOrContext.resolve(token, argument, options);
-    },
-    injectAll(token, argument, options) {
-      return injectorOrContext.resolveAll(token, argument, options);
-    },
-    async injectAsync(token, argument, options) {
-      return injectorOrContext.resolveAsync(token, argument, options);
-    },
-    async injectAllAsync(token, argument, options) {
-      return injectorOrContext.resolveAllAsync(token, argument, options);
+/**
+ * Runs the given function in the context of the given {@link InjectionContext}.
+ *
+ * @param context the injection context which will satisfy calls to {@link inject} while `fn` is executing
+ * @param fn the closure to be run in the context of `injector`
+ * @returns the return value of the function, if any
+ */
+export function runInInjectionContext(injectorOrContext, fn) {
+    const context = injectorOrContext instanceof Injector
+        ? {
+            injector: injectorOrContext,
+            argument: undefined,
+            inject(token, argument, options) { return injectorOrContext.resolve(token, argument, options); },
+            injectAll(token, argument, options) { return injectorOrContext.resolveAll(token, argument, options); },
+            async injectAsync(token, argument, options) { return injectorOrContext.resolveAsync(token, argument, options); },
+            async injectAllAsync(token, argument, options) { return injectorOrContext.resolveAllAsync(token, argument, options); }
+        }
+        : injectorOrContext;
+    const previousContext = setCurrentInjectionContext(context);
+    try {
+        return fn();
+    }
+    finally {
+        setCurrentInjectionContext(previousContext);
     }
-  } : injectorOrContext;
-  const previousContext = setCurrentInjectionContext(context);
-  try {
-    return fn();
-  } finally {
-    setCurrentInjectionContext(previousContext);
-  }
 }
-function isInInjectionContext() {
-  return (0, import_type_guards.isNotNull)(currentInjectionContext);
+export function isInInjectionContext() {
+    return isNotNull(currentInjectionContext);
 }
-function assertInInjectionContext(debugFn) {
-  if (!isInInjectionContext()) {
-    throw new Error(`${debugFn.name}() can only be used within an injection context such as a constructor, a factory function, a field initializer, or a function used with \`runInInjectionContext\``);
-  }
+/**
+ * Asserts that the current stack frame is within an injection context and has access to {@link inject}.
+ *
+ * @param debugFn a reference to the function making the assertion (used for the error message).
+ */
+export function assertInInjectionContext(debugFn) {
+    if (!isInInjectionContext()) {
+        throw new Error(`${debugFn.name}() can only be used within an injection context such as a constructor, a factory function, a field initializer, or a function used with \`runInInjectionContext\``);
+    }
 }