@tstdl/base 0.87.15 → 0.88.0-alpha2

package/injector/injector.js

@@ -1,527 +1,511 @@
-"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 injector_exports = {};
-__export(injector_exports, {
-  Injector: () => Injector
-});
-module.exports = __toCommonJS(injector_exports);
-var import_cancellation = require("../cancellation/index.js");
-var import_circular_buffer = require("../data-structures/circular-buffer.js");
-var import_multi_key_map = require("../data-structures/multi-key-map.js");
-var import_disposable = require("../disposable/disposable.js");
-var import_deferred_promise = require("../promise/deferred-promise.js");
-var import_registry = require("../reflection/registry.js");
-var import_array = require("../utils/array/array.js");
-var import_factory_map = require("../utils/factory-map.js");
-var import_forward_ref = require("../utils/object/forward-ref.js");
-var import_object = require("../utils/object/object.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_inject = require("./inject.js");
-var import_interfaces = require("./interfaces.js");
-var import_provider = require("./provider.js");
-var import_resolve_chain = require("./resolve-chain.js");
-var import_resolve_error = require("./resolve.error.js");
-var import_symbols = require("./symbols.js");
-var import_token = require("./token.js");
-class Injector {
-  static #globalRegistrations = /* @__PURE__ */ new Map();
-  #parent;
-  #children = [];
-  #disposeToken = new import_cancellation.CancellationToken();
-  #disposableStack = new AsyncDisposableStack();
-  #registrations = /* @__PURE__ */ new Map();
-  #injectorScopedResolutions = new import_multi_key_map.MultiKeyMap();
-  #addDisposeHandler;
-  name;
-  get disposed() {
-    return this.#disposableStack.disposed;
-  }
-  constructor(name, parent = null) {
-    this.name = name;
-    this.#parent = parent;
-    this.register(Injector, { useValue: this });
-    this.register(import_cancellation.CancellationSignal, { useValue: this.#disposeToken.signal });
-    this.#addDisposeHandler = (handler) => {
-      if ((0, import_disposable.isSyncOrAsyncDisposable)(handler)) {
-        this.#disposableStack.use(handler);
-      } else {
-        this.#disposableStack.defer(handler);
-      }
-    };
-    this.#disposableStack.defer(() => this.#registrations.clear());
-    this.#disposableStack.defer(() => this.#injectorScopedResolutions.clear());
-  }
-  /**
-   * Globally register a provider for a token
-   * @param token token to register
-   * @param provider provider used to resolve the token
-   * @param options registration options
-   */
-  static register(token, providers, options = {}) {
-    for (const provider of (0, import_array.toArray)(providers)) {
-      const registration = {
-        token,
-        provider,
-        options: { multi: (0, import_type_guards.isArray)(providers), ...options }
-      };
-      addRegistration(Injector.#globalRegistrations, registration);
-    }
-  }
-  /**
-   * Globally register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
-   * @param token token to register
-   * @param provider provider used to resolve the token
-   * @param options registration options
-   */
-  static registerSingleton(token, providers, options) {
-    Injector.register(token, providers, { ...options, lifecycle: "singleton" });
-  }
-  async dispose() {
-    this.#disposeToken.set();
-    await this.#disposableStack.disposeAsync();
-  }
-  async [Symbol.asyncDispose]() {
-    await this.dispose();
-  }
-  fork(name) {
-    const child = new Injector(name, this);
-    this.#children.push(child);
-    this.#disposableStack.use(child);
-    return child;
-  }
-  /**
-   * Register a provider for a token
-   * @param token token to register
-   * @param provider provider used to resolve the token
-   * @param options registration options
-   */
-  register(token, providers, options = {}) {
-    this.assertNotDisposed();
-    for (const provider of (0, import_array.toArray)(providers)) {
-      const registration = {
-        token,
-        provider,
-        options: { multi: (0, import_type_guards.isArray)(providers), ...options },
-        resolutions: /* @__PURE__ */ new Map()
-      };
-      addRegistration(this.#registrations, registration);
-    }
-  }
-  /**
-   * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
-   * @param token token to register
-   * @param provider provider used to resolve the token
-   * @param options registration options
-   */
-  registerSingleton(token, providers, options) {
-    this.register(token, providers, { ...options, lifecycle: "singleton" });
-  }
-  /**
-   * Check if token has a registered provider
-   * @param token token check
-   */
-  hasRegistration(token, options) {
-    const registration = this.tryGetRegistration(token, options);
-    return (0, import_type_guards.isDefined)(registration);
-  }
-  /**
-   * Try to get registration
-   * @param token token to get registration for
-   */
-  tryGetRegistration(token, options) {
-    if ((0, import_type_guards.isNull)(this.#parent) && !this.#registrations.has(token) && Injector.#globalRegistrations.has(token)) {
-      const globalRegistrations = (0, import_array.toArray)(Injector.#globalRegistrations.get(token));
-      for (const globalRegistration of globalRegistrations) {
-        this.register(globalRegistration.token, globalRegistration.provider, globalRegistration.options);
-      }
-    }
-    const ownRegistration = options?.skipSelf != true ? this.#registrations.get(token) : void 0;
-    if ((0, import_type_guards.isDefined)(ownRegistration)) {
-      return ownRegistration;
-    }
-    if (options?.onlySelf == true) {
-      return void 0;
-    }
-    return this.#parent?.tryGetRegistration(token);
-  }
-  /**
-   * Get registration
-   * @param token token to get registration for
-   */
-  getRegistration(token, options) {
-    const registration = this.tryGetRegistration(token, options);
-    if ((0, import_type_guards.isUndefined)(registration)) {
-      const tokenName = (0, import_token.getTokenName)(token);
-      throw new Error(`No provider for ${tokenName} registered.`);
-    }
-    return registration;
-  }
-  resolve(token, argument, options = {}) {
-    const context = newInternalResolveContext();
-    const value = this._resolve(token, argument, options, context, import_resolve_chain.ResolveChain.startWith(token));
-    postProcess(context);
-    context.$done.resolve();
-    return value;
-  }
-  resolveAll(token, argument, options = {}) {
-    const context = newInternalResolveContext();
-    const values = this._resolveAll(token, argument, options, context, import_resolve_chain.ResolveChain.startWith(token));
-    postProcess(context);
-    context.$done.resolve();
-    return values;
-  }
-  async resolveAsync(token, argument, options = {}) {
-    const context = newInternalResolveContext();
-    const value = this._resolve(token, argument, options, context, import_resolve_chain.ResolveChain.startWith(token));
-    await postProcessAsync(context);
-    context.$done.resolve();
-    return value;
-  }
-  async resolveAllAsync(token, argument, options = {}) {
-    const context = newInternalResolveContext();
-    const values = this._resolveAll(token, argument, options, context, import_resolve_chain.ResolveChain.startWith(token));
-    await postProcessAsync(context);
-    context.$done.resolve();
-    return values;
-  }
-  _resolve(token, argument, options, context, chain) {
-    this.assertNotDisposed();
-    if ((0, import_type_guards.isDefined)(options.forwardRef) && options.forwardRef != false) {
-      (0, import_type_guards.assert)(options.optional != true, "ForwardRef does not support optional without resolveAll/injectAll as undefined is not forwardable.");
-      const forwardRef = import_forward_ref.ForwardRef.create();
-      const forwardToken = (0, import_type_guards.isFunction)(options.forwardRef) ? options.forwardRef() : token;
-      context.forwardRefQueue.add(() => import_forward_ref.ForwardRef.setRef(forwardRef, this._resolve(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
-      context.forwardRefs.add(forwardRef);
-      return forwardRef;
-    }
-    if ((0, import_type_guards.isUndefined)(token)) {
-      throw new import_resolve_error.ResolveError("Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.", chain);
-    }
-    const registration = options.skipSelf == true ? void 0 : this.tryGetRegistration(token);
-    if ((0, import_type_guards.isUndefined)(registration)) {
-      if ((0, import_type_guards.isNotNull)(this.#parent) && options.onlySelf != true) {
-        return this.#parent._resolve(token, argument, { ...options, skipSelf: false }, context, chain);
-      }
-      if (options.optional == true) {
-        return void 0;
-      }
-      throw new import_resolve_error.ResolveError(`No provider for ${(0, import_token.getTokenName)(token)} registered.`, chain);
-    }
-    const singleRegistration = (0, import_type_guards.isArray)(registration) ? registration[0] : registration;
-    return this._resolveRegistration(singleRegistration, argument, options, context, chain);
-  }
-  _resolveAll(token, argument, options, context, chain) {
-    this.assertNotDisposed();
-    if ((0, import_type_guards.isDefined)(options.forwardRef) && options.forwardRef != false) {
-      const forwardRef = import_forward_ref.ForwardRef.create({ typeHint: options.forwardRefTypeHint });
-      const forwardToken = (0, import_type_guards.isFunction)(options.forwardRef) ? options.forwardRef() : token;
-      context.forwardRefQueue.add(() => import_forward_ref.ForwardRef.setRef(forwardRef, this._resolveAll(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
-      context.forwardRefs.add(forwardRef);
-      return forwardRef;
-    }
-    if ((0, import_type_guards.isUndefined)(token)) {
-      throw new import_resolve_error.ResolveError("Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.", chain);
-    }
-    const registration = options.skipSelf == true ? void 0 : this.tryGetRegistration(token);
-    if ((0, import_type_guards.isUndefined)(registration)) {
-      if ((0, import_type_guards.isNotNull)(this.#parent) && options.onlySelf != true) {
-        return this.#parent._resolveAll(token, argument, { ...options, skipSelf: false }, context, chain);
-      }
-      if (options.optional == true) {
-        return [];
-      }
-      throw new import_resolve_error.ResolveError(`No provider for ${(0, import_token.getTokenName)(token)} registered.`, chain);
-    }
-    const registrations = (0, import_type_guards.isArray)(registration) ? registration : [registration];
-    return registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
-  }
-  _resolveRegistration(registration, argument, options, context, chain) {
-    checkOverflow(chain, context);
-    const injectionContext = this.getInjectionContext(context, argument, chain);
-    const previousInjectionContext = (0, import_inject.setCurrentInjectionContext)(injectionContext);
-    const resolutionTag = Symbol();
-    try {
-      const token = registration.token;
-      const resolutionScoped = registration.options.lifecycle == "resolution";
-      const injectorScoped = registration.options.lifecycle == "injector";
-      const singletonScoped = registration.options.lifecycle == "singleton";
-      const resolveArgument = argument ?? registration.options.defaultArgument ?? registration.options.defaultArgumentProvider?.(this.getResolveContext(resolutionTag, context, chain));
-      const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument);
-      if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
-        return context.resolutionScopedResolutions.getFlat(token, argumentIdentity).value;
-      } else if (injectorScoped && this.#injectorScopedResolutions.hasFlat(token, argumentIdentity)) {
-        return this.#injectorScopedResolutions.getFlat(token, argumentIdentity).value;
-      } else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
-        return registration.resolutions.get(argumentIdentity);
-      }
-      const value = this._resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain);
-      const resolution = {
-        tag: resolutionTag,
-        registration,
-        value,
-        argument: injectionContext.argument,
-        afterResolveContext: this.getAfterResolveContext(resolutionTag, context),
-        chain
-      };
-      context.resolutions.push(resolution);
-      if (resolutionScoped) {
-        context.resolutionScopedResolutions.setFlat(token, argumentIdentity, resolution);
-      }
-      if (injectorScoped) {
-        this.#injectorScopedResolutions.setFlat(token, argumentIdentity, resolution);
-      }
-      if (singletonScoped) {
-        registration.resolutions.set(argumentIdentity, value);
-      }
-      return value;
-    } finally {
-      (0, import_inject.setCurrentInjectionContext)(previousInjectionContext);
-    }
-  }
-  _resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain) {
-    try {
-      setResolving(registration.token, context, chain);
-      const provider = registration.provider;
-      let result;
-      if ((0, import_provider.isClassProvider)(provider)) {
-        const typeMetadata = import_registry.reflectionRegistry.getMetadata(provider.useClass);
-        const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
-        injectionContext.argument = arg;
-        if (provider.useClass.length > 0 && ((0, import_type_guards.isUndefined)(typeMetadata) || !typeMetadata.data.has(import_symbols.injectableMetadataSymbol))) {
-          throw new import_resolve_error.ResolveError(`${provider.useClass.name} has constructor parameters but is not injectable.`, chain);
+import { CancellationSignal, CancellationToken } from '../cancellation/index.js';
+import { CircularBuffer } from '../data-structures/circular-buffer.js';
+import { MultiKeyMap } from '../data-structures/multi-key-map.js';
+import { isAsyncDisposable, isDisposable, isSyncOrAsyncDisposable } from '../disposable/disposable.js';
+import { DeferredPromise } from '../promise/deferred-promise.js';
+import { reflectionRegistry } from '../reflection/registry.js';
+import { toArray } from '../utils/array/array.js';
+import { FactoryMap } from '../utils/factory-map.js';
+import { ForwardRef } from '../utils/object/forward-ref.js';
+import { objectEntries } from '../utils/object/object.js';
+import { assert, isArray, isBoolean, isDefined, isFunction, isNotNull, isNull, isPromise, isUndefined } from '../utils/type-guards.js';
+import { setCurrentInjectionContext } from './inject.js';
+import { afterResolve } from './interfaces.js';
+import { isClassProvider, isFactoryProvider, isProviderWithInitializer, isTokenProvider, isValueProvider } from './provider.js';
+import { ResolveChain } from './resolve-chain.js';
+import { ResolveError } from './resolve.error.js';
+import { injectMetadataSymbol, injectableMetadataSymbol } from './symbols.js';
+import { getTokenName } from './token.js';
+export class Injector {
+    static #globalRegistrations = new Map();
+    #parent;
+    #children = [];
+    #disposeToken = new CancellationToken();
+    #disposableStack = new AsyncDisposableStack();
+    #registrations = new Map();
+    #injectorScopedResolutions = new MultiKeyMap();
+    #addDisposeHandler;
+    name;
+    get disposed() {
+        return this.#disposableStack.disposed;
+    }
+    constructor(name, parent = null) {
+        this.name = name;
+        this.#parent = parent;
+        this.register(Injector, { useValue: this });
+        this.register(CancellationSignal, { useValue: this.#disposeToken.signal });
+        this.#addDisposeHandler = (handler) => {
+            if (isSyncOrAsyncDisposable(handler)) {
+                this.#disposableStack.use(handler);
+            }
+            else {
+                this.#disposableStack.defer(handler);
+            }
+        };
+        this.#disposableStack.defer(() => this.#registrations.clear());
+        this.#disposableStack.defer(() => this.#injectorScopedResolutions.clear());
+    }
+    /**
+     * Globally register a provider for a token
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    static register(token, providers, options = {}) {
+        for (const provider of toArray(providers)) {
+            const registration = {
+                token,
+                provider,
+                options: { multi: isArray(providers), ...options }
+            };
+            addRegistration(Injector.#globalRegistrations, registration);
+        }
+    }
+    /**
+     * Globally register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    static registerSingleton(token, providers, options) {
+        Injector.register(token, providers, { ...options, lifecycle: 'singleton' });
+    }
+    async dispose() {
+        this.#disposeToken.set();
+        await this.#disposableStack.disposeAsync();
+    }
+    async [Symbol.asyncDispose]() {
+        await this.dispose();
+    }
+    fork(name) {
+        const child = new Injector(name, this);
+        this.#children.push(child);
+        this.#disposableStack.use(child);
+        return child;
+    }
+    /**
+     * Register a provider for a token
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    register(token, providers, options = {}) {
+        this.assertNotDisposed();
+        for (const provider of toArray(providers)) {
+            const registration = {
+                token,
+                provider,
+                options: { multi: isArray(providers), ...options },
+                resolutions: new Map()
+            };
+            addRegistration(this.#registrations, registration);
         }
-        const parameters = (typeMetadata?.parameters ?? []).map((metadata) => this.resolveClassInjection(resolutionTag, context, provider.useClass, metadata, arg, chain));
-        result = { value: new provider.useClass(...parameters) };
-      }
-      if ((0, import_provider.isValueProvider)(provider)) {
-        result = { value: provider.useValue };
-      }
-      if ((0, import_provider.isTokenProvider)(provider)) {
-        const innerToken = provider.useToken ?? provider.useTokenProvider();
-        const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
-        injectionContext.argument = arg;
-        if (provider.resolveAll == true) {
-          return this._resolveAll(innerToken, arg, options, context, chain.addToken(innerToken));
+    }
+    /**
+     * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    registerSingleton(token, providers, options) {
+        this.register(token, providers, { ...options, lifecycle: 'singleton' });
+    }
+    /**
+     * Check if token has a registered provider
+     * @param token token check
+     */
+    hasRegistration(token, options) {
+        const registration = this.tryGetRegistration(token, options);
+        return isDefined(registration);
+    }
+    /**
+     * Try to get registration
+     * @param token token to get registration for
+     */
+    tryGetRegistration(token, options) {
+        if (isNull(this.#parent) && !this.#registrations.has(token) && Injector.#globalRegistrations.has(token)) {
+            const globalRegistrations = toArray(Injector.#globalRegistrations.get(token));
+            for (const globalRegistration of globalRegistrations) {
+                this.register(globalRegistration.token, globalRegistration.provider, globalRegistration.options);
+            }
+        }
+        const ownRegistration = (options?.skipSelf != true) ? this.#registrations.get(token) : undefined;
+        if (isDefined(ownRegistration)) {
+            return ownRegistration;
+        }
+        if (options?.onlySelf == true) {
+            return undefined;
         }
-        result = { value: this._resolve(innerToken, arg, options, context, chain.addToken(innerToken)) };
-      }
-      if ((0, import_provider.isFactoryProvider)(provider)) {
-        const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
-        injectionContext.argument = arg;
+        return this.#parent?.tryGetRegistration(token);
+    }
+    /**
+     * Get registration
+     * @param token token to get registration for
+     */
+    getRegistration(token, options) {
+        const registration = this.tryGetRegistration(token, options);
+        if (isUndefined(registration)) {
+            const tokenName = getTokenName(token);
+            throw new Error(`No provider for ${tokenName} registered.`);
+        }
+        return registration;
+    }
+    resolve(token, argument, options = {}) {
+        const context = newInternalResolveContext();
+        const value = this._resolve(token, argument, options, context, ResolveChain.startWith(token));
+        postProcess(context);
+        context.$done.resolve();
+        return value;
+    }
+    resolveAll(token, argument, options = {}) {
+        const context = newInternalResolveContext();
+        const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(token));
+        postProcess(context);
+        context.$done.resolve();
+        return values;
+    }
+    async resolveAsync(token, argument, options = {}) {
+        const context = newInternalResolveContext();
+        const value = this._resolve(token, argument, options, context, ResolveChain.startWith(token));
+        await postProcessAsync(context);
+        context.$done.resolve();
+        return value;
+    }
+    async resolveAllAsync(token, argument, options = {}) {
+        const context = newInternalResolveContext();
+        const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(token));
+        await postProcessAsync(context);
+        context.$done.resolve();
+        return values;
+    }
+    _resolve(token, argument, options, context, chain) {
+        this.assertNotDisposed();
+        if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
+            assert(options.optional != true, 'ForwardRef does not support optional without resolveAll/injectAll as undefined is not forwardable.');
+            const forwardRef = ForwardRef.create();
+            const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
+            context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolve(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
+            context.forwardRefs.add(forwardRef);
+            return forwardRef;
+        }
+        if (isUndefined(token)) {
+            throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
+        }
+        const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
+        if (isUndefined(registration)) {
+            if (isNotNull(this.#parent) && (options.onlySelf != true)) {
+                return this.#parent._resolve(token, argument, { ...options, skipSelf: false }, context, chain);
+            }
+            if (options.optional == true) {
+                return undefined;
+            }
+            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+        }
+        const singleRegistration = isArray(registration) ? registration[0] : registration;
+        return this._resolveRegistration(singleRegistration, argument, options, context, chain);
+    }
+    _resolveAll(token, argument, options, context, chain) {
+        this.assertNotDisposed();
+        if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
+            const forwardRef = ForwardRef.create({ typeHint: options.forwardRefTypeHint });
+            const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
+            context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolveAll(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
+            context.forwardRefs.add(forwardRef);
+            return forwardRef;
+        }
+        if (isUndefined(token)) {
+            throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
+        }
+        const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
+        if (isUndefined(registration)) {
+            if (isNotNull(this.#parent) && (options.onlySelf != true)) {
+                return this.#parent._resolveAll(token, argument, { ...options, skipSelf: false }, context, chain);
+            }
+            if (options.optional == true) {
+                return [];
+            }
+            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+        }
+        const registrations = isArray(registration) ? registration : [registration];
+        return registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
+    }
+    _resolveRegistration(registration, argument, options, context, chain) {
+        checkOverflow(chain, context);
+        const injectionContext = this.getInjectionContext(context, argument, chain);
+        const previousInjectionContext = setCurrentInjectionContext(injectionContext);
+        const resolutionTag = Symbol(); // eslint-disable-line symbol-description
         try {
-          result = { value: provider.useFactory(arg, this.getResolveContext(resolutionTag, context, chain)) };
-        } catch (error) {
-          throw new import_resolve_error.ResolveError("Error in provider factory.", chain, error);
+            const token = registration.token;
+            const resolutionScoped = registration.options.lifecycle == 'resolution';
+            const injectorScoped = registration.options.lifecycle == 'injector';
+            const singletonScoped = registration.options.lifecycle == 'singleton';
+            const resolveArgument = argument ?? registration.options.defaultArgument ?? (registration.options.defaultArgumentProvider?.(this.getResolveContext(resolutionTag, context, chain)));
+            const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument);
+            if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
+                return context.resolutionScopedResolutions.getFlat(token, argumentIdentity).value;
+            }
+            else if (injectorScoped && this.#injectorScopedResolutions.hasFlat(token, argumentIdentity)) {
+                return this.#injectorScopedResolutions.getFlat(token, argumentIdentity).value;
+            }
+            else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
+                return registration.resolutions.get(argumentIdentity);
+            }
+            const value = this._resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain);
+            const resolution = {
+                tag: resolutionTag,
+                registration,
+                value,
+                argument: injectionContext.argument,
+                afterResolveContext: this.getAfterResolveContext(resolutionTag, context),
+                chain
+            };
+            context.resolutions.push(resolution);
+            if (resolutionScoped) {
+                context.resolutionScopedResolutions.setFlat(token, argumentIdentity, resolution);
+            }
+            if (injectorScoped) {
+                this.#injectorScopedResolutions.setFlat(token, argumentIdentity, resolution);
+            }
+            if (singletonScoped) {
+                registration.resolutions.set(argumentIdentity, value);
+            }
+            return value;
         }
-      }
-      if ((0, import_type_guards.isUndefined)(result)) {
-        throw new Error("Unsupported provider.");
-      }
-      if ((0, import_disposable.isDisposable)(result.value) || (0, import_disposable.isAsyncDisposable)(result.value)) {
-        this.#disposableStack.use(result.value);
-      }
-      return result.value;
-    } finally {
-      deleteResolving(registration.token, context);
-    }
-  }
-  resolveClassInjection(resolutionTag, context, constructor, metadata, resolveArgument, chain) {
-    const getChain = (injectToken2) => chain.addParameter(constructor, metadata.index, injectToken2);
-    const injectMetadata = metadata.data.tryGet(import_symbols.injectMetadataSymbol) ?? {};
-    const injectToken = injectMetadata.injectToken ?? metadata.type;
-    if ((0, import_type_guards.isDefined)(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || (0, import_type_guards.isDefined)(resolveArgument) || (0, import_type_guards.isUndefined)(injectToken))) {
-      return injectMetadata.injectArgumentMapper(resolveArgument);
-    }
-    const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken)));
-    const forwardRef = injectMetadata.forwardRef;
-    if ((0, import_type_guards.isDefined)(forwardRef)) {
-      context.forwardRefQueue.add(() => {
-        const forwardToken = (0, import_type_guards.isFunction)(forwardRef) ? forwardRef() : (0, import_type_guards.isBoolean)(forwardRef) ? injectToken : forwardRef;
-        if ((0, import_type_guards.isDefined)(injectMetadata.mapper)) {
-          throw new import_resolve_error.ResolveError("Cannot use inject mapper with forwardRef.", getChain(forwardToken));
+        finally {
+            setCurrentInjectionContext(previousInjectionContext);
+        }
+    }
+    _resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain) {
+        try {
+            setResolving(registration.token, context, chain);
+            const provider = registration.provider;
+            let result;
+            if (isClassProvider(provider)) {
+                const typeMetadata = reflectionRegistry.getMetadata(provider.useClass);
+                const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
+                injectionContext.argument = arg;
+                if ((provider.useClass.length > 0) && (isUndefined(typeMetadata) || !typeMetadata.data.has(injectableMetadataSymbol))) {
+                    throw new ResolveError(`${provider.useClass.name} has constructor parameters but is not injectable.`, chain);
+                }
+                const parameters = (typeMetadata?.parameters ?? []).map((metadata) => this.resolveClassInjection(resolutionTag, context, provider.useClass, metadata, arg, chain));
+                result = { value: new provider.useClass(...parameters) };
+            }
+            if (isValueProvider(provider)) {
+                result = { value: provider.useValue };
+            }
+            if (isTokenProvider(provider)) {
+                const innerToken = (provider.useToken ?? provider.useTokenProvider());
+                const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
+                injectionContext.argument = arg;
+                if (provider.resolveAll == true) {
+                    return this._resolveAll(innerToken, arg, options, context, chain.addToken(innerToken));
+                }
+                result = { value: this._resolve(innerToken, arg, options, context, chain.addToken(innerToken)) };
+            }
+            if (isFactoryProvider(provider)) {
+                const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
+                injectionContext.argument = arg;
+                try {
+                    result = { value: provider.useFactory(arg, this.getResolveContext(resolutionTag, context, chain)) };
+                }
+                catch (error) {
+                    throw new ResolveError('Error in provider factory.', chain, error);
+                }
+            }
+            if (isUndefined(result)) {
+                throw new Error('Unsupported provider.');
+            }
+            if (isDisposable(result.value) || isAsyncDisposable(result.value)) {
+                this.#disposableStack.use(result.value);
+            }
+            return result.value;
+        }
+        finally {
+            deleteResolving(registration.token, context);
+        }
+    }
+    resolveClassInjection(resolutionTag, context, constructor, metadata, resolveArgument, chain) {
+        const getChain = (injectToken) => chain.addParameter(constructor, metadata.index, injectToken);
+        const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
+        const injectToken = (injectMetadata.injectToken ?? metadata.type);
+        if (isDefined(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || isDefined(resolveArgument) || isUndefined(injectToken))) {
+            return injectMetadata.injectArgumentMapper(resolveArgument);
+        }
+        const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken)));
+        const forwardRef = injectMetadata.forwardRef;
+        if (isDefined(forwardRef)) {
+            context.forwardRefQueue.add(() => {
+                const forwardToken = isFunction(forwardRef) ? forwardRef() : isBoolean(forwardRef) ? injectToken : forwardRef;
+                if (isDefined(injectMetadata.mapper)) {
+                    throw new ResolveError('Cannot use inject mapper with forwardRef.', getChain(forwardToken));
+                }
+            });
+        }
+        const resolveFn = (injectMetadata.resolveAll == true) ? '_resolveAll' : '_resolve';
+        const resolved = this[resolveFn](injectToken, parameterResolveArgument, { optional: injectMetadata.optional, forwardRef, forwardRefTypeHint: injectMetadata.forwardRefTypeHint }, context, getChain(injectToken));
+        return isDefined(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved;
+    }
+    resolveInjection(token, argument, options, context, injectIndex, chain) {
+        return this._resolve(token, argument, options, context, chain.addInject(token, injectIndex));
+    }
+    async resolveInjectionAsync(token, argument, options, context, injectIndex, chain) {
+        const value = this.resolveInjection(token, argument, options, context, injectIndex, chain);
+        await context.$done;
+        return value;
+    }
+    resolveInjectionAll(token, argument, options, context, injectIndex, chain) {
+        return this._resolveAll(token, argument, options, context, chain.addInject(token, injectIndex));
+    }
+    async resolveInjectionAllAsync(token, argument, options, context, injectIndex, chain) {
+        const values = this.resolveInjectionAll(token, argument, options, context, injectIndex, chain);
+        await context.$done;
+        return values;
+    }
+    getResolveContext(resolutionTag, resolveContext, chain) {
+        const context = {
+            resolve: (token, argument, options) => this._resolve(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
+            resolveAll: (token, argument, options) => this._resolveAll(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
+            cancellationSignal: this.#disposeToken,
+            addDisposeHandler: this.#addDisposeHandler,
+            get data() {
+                return resolveContext.resolutionContextData.get(resolutionTag);
+            }
+        };
+        return context;
+    }
+    getAfterResolveContext(resolutionTag, resolveContext) {
+        const context = {
+            cancellationSignal: this.#disposeToken,
+            addDisposeHandler: this.#addDisposeHandler,
+            get data() {
+                return resolveContext.resolutionContextData.get(resolutionTag);
+            }
+        };
+        return context;
+    }
+    getInjectionContext(resolveContext, resolveArgument, chain) {
+        let injectIndex = 0;
+        const context = {
+            injector: this,
+            argument: resolveArgument,
+            inject: (token, argument, options) => this.resolveInjection(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
+            injectAll: (token, argument, options) => this.resolveInjectionAll(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
+            injectAsync: async (token, argument, options) => this.resolveInjectionAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
+            injectAllAsync: async (token, argument, options) => this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain)
+        };
+        return context;
+    }
+    assertNotDisposed() {
+        if (this.disposed) {
+            throw new Error('Injector is disposed.');
         }
-      });
-    }
-    const resolveFn = injectMetadata.resolveAll == true ? "_resolveAll" : "_resolve";
-    const resolved = this[resolveFn](injectToken, parameterResolveArgument, { optional: injectMetadata.optional, forwardRef, forwardRefTypeHint: injectMetadata.forwardRefTypeHint }, context, getChain(injectToken));
-    return (0, import_type_guards.isDefined)(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved;
-  }
-  resolveInjection(token, argument, options, context, injectIndex, chain) {
-    return this._resolve(token, argument, options, context, chain.addInject(token, injectIndex));
-  }
-  async resolveInjectionAsync(token, argument, options, context, injectIndex, chain) {
-    const value = this.resolveInjection(token, argument, options, context, injectIndex, chain);
-    await context.$done;
-    return value;
-  }
-  resolveInjectionAll(token, argument, options, context, injectIndex, chain) {
-    return this._resolveAll(token, argument, options, context, chain.addInject(token, injectIndex));
-  }
-  async resolveInjectionAllAsync(token, argument, options, context, injectIndex, chain) {
-    const values = this.resolveInjectionAll(token, argument, options, context, injectIndex, chain);
-    await context.$done;
-    return values;
-  }
-  getResolveContext(resolutionTag, resolveContext, chain) {
-    const context = {
-      resolve: (token, argument, options) => this._resolve(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
-      resolveAll: (token, argument, options) => this._resolveAll(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
-      cancellationSignal: this.#disposeToken,
-      addDisposeHandler: this.#addDisposeHandler,
-      get data() {
-        return resolveContext.resolutionContextData.get(resolutionTag);
-      }
-    };
-    return context;
-  }
-  getAfterResolveContext(resolutionTag, resolveContext) {
-    const context = {
-      cancellationSignal: this.#disposeToken,
-      addDisposeHandler: this.#addDisposeHandler,
-      get data() {
-        return resolveContext.resolutionContextData.get(resolutionTag);
-      }
-    };
-    return context;
-  }
-  getInjectionContext(resolveContext, resolveArgument, chain) {
-    let injectIndex = 0;
-    const context = {
-      injector: this,
-      argument: resolveArgument,
-      inject: (token, argument, options) => this.resolveInjection(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
-      injectAll: (token, argument, options) => this.resolveInjectionAll(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
-      injectAsync: async (token, argument, options) => this.resolveInjectionAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
-      injectAllAsync: async (token, argument, options) => this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain)
-    };
-    return context;
-  }
-  assertNotDisposed() {
-    if (this.disposed) {
-      throw new Error("Injector is disposed.");
     }
-  }
 }
 function addRegistration(registrations, registration) {
-  if ((0, import_provider.isClassProvider)(registration.provider)) {
-    const injectable = import_registry.reflectionRegistry.getMetadata(registration.provider.useClass)?.data.has(import_symbols.injectableMetadataSymbol) ?? false;
-    if (!injectable) {
-      throw new Error(`${registration.provider.useClass.name} is not injectable.`);
-    }
-  }
-  const multi = registration.options.multi ?? false;
-  const existingRegistration = registrations.get(registration.token);
-  const hasExistingRegistration = (0, import_type_guards.isDefined)(existingRegistration);
-  const existingIsMulti = hasExistingRegistration && (0, import_type_guards.isArray)(existingRegistration);
-  if (hasExistingRegistration && existingIsMulti != multi) {
-    throw new Error("Cannot mix multi and non-multi registrations.");
-  }
-  if (multi && existingIsMulti) {
-    existingRegistration.push(registration);
-  } else {
-    registrations.set(registration.token, multi ? [registration] : registration);
-  }
+    if (isClassProvider(registration.provider)) {
+        const injectable = reflectionRegistry.getMetadata(registration.provider.useClass)?.data.has(injectableMetadataSymbol) ?? false;
+        if (!injectable) {
+            throw new Error(`${registration.provider.useClass.name} is not injectable.`);
+        }
+    }
+    const multi = registration.options.multi ?? false;
+    const existingRegistration = registrations.get(registration.token);
+    const hasExistingRegistration = isDefined(existingRegistration);
+    const existingIsMulti = hasExistingRegistration && isArray(existingRegistration);
+    if (hasExistingRegistration && (existingIsMulti != multi)) {
+        throw new Error('Cannot mix multi and non-multi registrations.');
+    }
+    if (multi && existingIsMulti) {
+        existingRegistration.push(registration);
+    }
+    else {
+        registrations.set(registration.token, multi ? [registration] : registration);
+    }
 }
 function newInternalResolveContext() {
-  return {
-    resolves: 0,
-    resolving: /* @__PURE__ */ new Set(),
-    resolutionScopedResolutions: new import_multi_key_map.MultiKeyMap(),
-    resolutions: [],
-    resolutionContextData: new import_factory_map.FactoryMap(() => ({})),
-    forwardRefQueue: new import_circular_buffer.CircularBuffer(),
-    forwardRefs: /* @__PURE__ */ new Set(),
-    $done: new import_deferred_promise.DeferredPromise()
-  };
+    return {
+        resolves: 0,
+        resolving: new Set(),
+        resolutionScopedResolutions: new MultiKeyMap(),
+        resolutions: [],
+        resolutionContextData: new FactoryMap(() => ({})),
+        forwardRefQueue: new CircularBuffer(),
+        forwardRefs: new Set(),
+        $done: new DeferredPromise()
+    };
 }
 function postProcess(context) {
-  for (const fn of context.forwardRefQueue.consume()) {
-    fn();
-  }
-  derefForwardRefs(context);
-  for (const resolution of context.resolutions) {
-    if ((0, import_type_guards.isFunction)(resolution.value?.[import_interfaces.afterResolve])) {
-      const returnValue = resolution.value[import_interfaces.afterResolve](resolution.argument, resolution.afterResolveContext);
-      throwOnPromise(returnValue, "[afterResolve]", resolution.chain);
-    }
-    if ((0, import_provider.isProviderWithInitializer)(resolution.registration.provider)) {
-      const returnValue = resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
-      throwOnPromise(returnValue, "provider afterResolve handler", resolution.chain);
-    }
-    if ((0, import_type_guards.isDefined)(resolution.registration.options.afterResolve)) {
-      const returnValue = resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
-      throwOnPromise(returnValue, "registration afterResolve handler", resolution.chain);
-    }
-  }
+    for (const fn of context.forwardRefQueue.consume()) {
+        fn();
+    }
+    derefForwardRefs(context);
+    for (const resolution of context.resolutions) {
+        if (isFunction(resolution.value?.[afterResolve])) {
+            const returnValue = resolution.value[afterResolve](resolution.argument, resolution.afterResolveContext);
+            throwOnPromise(returnValue, '[afterResolve]', resolution.chain);
+        }
+        if (isProviderWithInitializer(resolution.registration.provider)) {
+            const returnValue = resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
+            throwOnPromise(returnValue, 'provider afterResolve handler', resolution.chain);
+        }
+        if (isDefined(resolution.registration.options.afterResolve)) {
+            const returnValue = resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
+            throwOnPromise(returnValue, 'registration afterResolve handler', resolution.chain);
+        }
+    }
 }
 async function postProcessAsync(context) {
-  for (const fn of context.forwardRefQueue.consume()) {
-    fn();
-  }
-  derefForwardRefs(context);
-  for (const resolution of context.resolutions) {
-    if ((0, import_type_guards.isFunction)(resolution.value?.[import_interfaces.afterResolve])) {
-      await resolution.value[import_interfaces.afterResolve](resolution.argument, resolution.afterResolveContext);
-    }
-    if ((0, import_provider.isProviderWithInitializer)(resolution.registration.provider)) {
-      await resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
+    for (const fn of context.forwardRefQueue.consume()) {
+        fn();
     }
-    if ((0, import_type_guards.isDefined)(resolution.registration.options.afterResolve)) {
-      await resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
+    derefForwardRefs(context);
+    for (const resolution of context.resolutions) {
+        if (isFunction(resolution.value?.[afterResolve])) {
+            await resolution.value[afterResolve](resolution.argument, resolution.afterResolveContext);
+        }
+        if (isProviderWithInitializer(resolution.registration.provider)) {
+            await resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
+        }
+        if (isDefined(resolution.registration.options.afterResolve)) {
+            await resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
+        }
     }
-  }
 }
 function resolveArgumentIdentity(registration, resolveArgument) {
-  if ((0, import_type_guards.isDefined)(registration.options.argumentIdentityProvider) && (registration.options.lifecycle == "resolution" || registration.options.lifecycle == "singleton")) {
-    return registration.options.argumentIdentityProvider(resolveArgument);
-  }
-  return resolveArgument;
+    if (isDefined(registration.options.argumentIdentityProvider) && ((registration.options.lifecycle == 'resolution') || (registration.options.lifecycle == 'singleton'))) {
+        return registration.options.argumentIdentityProvider(resolveArgument);
+    }
+    return resolveArgument;
 }
 function setResolving(token, context, chain) {
-  if (context.resolving.has(token)) {
-    throw new import_resolve_error.ResolveError("Circular dependency to itself detected. Please check your registrations and providers. ForwardRef might be a solution.", chain);
-  }
-  context.resolving.add(token);
+    if (context.resolving.has(token)) {
+        throw new ResolveError('Circular dependency to itself detected. Please check your registrations and providers. ForwardRef might be a solution.', chain);
+    }
+    context.resolving.add(token);
 }
 function deleteResolving(token, context) {
-  context.resolving.delete(token);
+    context.resolving.delete(token);
 }
 function throwOnPromise(value, type, chain) {
-  if ((0, import_type_guards.isPromise)(value)) {
-    throw new import_resolve_error.ResolveError(`Cannot evaluate async ${type} in synchronous resolve, use resolveAsync() instead.`, chain);
-  }
+    if (isPromise(value)) {
+        throw new ResolveError(`Cannot evaluate async ${type} in synchronous resolve, use resolveAsync() instead.`, chain);
+    }
 }
 function checkOverflow(chain, context) {
-  if (chain.length > 100 || ++context.resolves > 7500) {
-    throw new import_resolve_error.ResolveError("Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle or forwardRef instead.", chain);
-  }
+    if ((chain.length > 100) || (++context.resolves > 7500)) {
+        throw new ResolveError('Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle or forwardRef instead.', chain);
+    }
 }
 function derefForwardRefs(context) {
-  for (const resolution of context.resolutions.values()) {
-    if (!(typeof resolution.value == "object")) {
-      continue;
-    }
-    for (const [key, value] of (0, import_object.objectEntries)(resolution.value)) {
-      if (!context.forwardRefs.has(value)) {
-        continue;
-      }
-      resolution.value[key] = import_forward_ref.ForwardRef.deref(value);
+    for (const resolution of context.resolutions.values()) {
+        if (!(typeof resolution.value == 'object')) {
+            continue;
+        }
+        for (const [key, value] of objectEntries(resolution.value)) {
+            if (!context.forwardRefs.has(value)) {
+                continue;
+            }
+            resolution.value[key] = ForwardRef.deref(value);
+        }
     }
-  }
 }