@tstdl/base 0.85.15 → 0.85.17

package/injector/injector.js

@@ -0,0 +1,454 @@
+"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_circular_buffer = require("../data-structures/circular-buffer.js");
+var import_multi_key_map = require("../data-structures/multi-key-map.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_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;
+  #registrations = /* @__PURE__ */ new Map();
+  #injectorScopedResolutions = new import_multi_key_map.MultiKeyMap();
+  name;
+  constructor(name, parent = null) {
+    this.name = name;
+    this.#parent = parent;
+    this.register(Injector, { useValue: this });
+  }
+  /**
+   * 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, provider, options = {}) {
+    const registration = {
+      token,
+      provider,
+      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, provider, options) {
+    Injector.register(token, provider, { ...options, lifecycle: "singleton" });
+  }
+  fork(name) {
+    return new Injector(name, this);
+  }
+  /**
+   * 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, provider, options = {}) {
+    const registration = {
+      token,
+      provider,
+      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, provider, options) {
+    this.register(token, provider, { ...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) {
+    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) {
+    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);
+    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(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(registration, resolveArgument, options, context, chain);
+      const resolution = { registration, value, argument, 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(registration, resolveArgument, options, context, chain) {
+    try {
+      setResolving(registration.token, context, chain);
+      const provider = registration.provider;
+      if ((0, import_provider.isClassProvider)(provider)) {
+        const typeMetadata = import_registry.reflectionRegistry.getMetadata(provider.useClass);
+        const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
+        if (provider.useClass.length > 0 && ((0, import_type_guards.isUndefined)(typeMetadata) || !typeMetadata.data.has(import_symbols.injectMetadataSymbol))) {
+          throw new import_resolve_error.ResolveError(`${provider.useClass.name} has constructor parameters but is not injectable.`, chain);
+        }
+        const parameters = (typeMetadata?.parameters ?? []).map((metadata) => this.resolveClassInjection(context, provider.useClass, metadata, arg, chain));
+        return new provider.useClass(...parameters);
+      }
+      if ((0, import_provider.isValueProvider)(provider)) {
+        return provider.useValue;
+      }
+      if ((0, import_provider.isTokenProvider)(provider)) {
+        const innerToken = provider.useToken ?? provider.useTokenProvider();
+        const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
+        return this._resolve(innerToken, arg, options, context, chain.addToken(innerToken));
+      }
+      if ((0, import_provider.isFactoryProvider)(provider)) {
+        try {
+          return provider.useFactory(resolveArgument, this.getResolveContext(context, chain));
+        } catch (error) {
+          throw new import_resolve_error.ResolveError("Error in factory.", chain, error);
+        }
+      }
+      throw new Error("Unsupported provider.");
+    } finally {
+      deleteResolving(registration.token, context);
+    }
+  }
+  resolveClassInjection(context, constructor, metadata, resolveArgument, chain) {
+    const getChain = (injectToken2) => chain.addParameter(constructor, metadata.index, injectToken2).addToken(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(context, getChain(injectToken)));
+    if ((0, import_type_guards.isDefined)(injectMetadata.forwardRefToken)) {
+      const forwardRef = import_forward_ref.ForwardRef.create();
+      const forwardRefToken = injectMetadata.forwardRefToken;
+      context.forwardRefQueue.add(() => {
+        const forwardToken = (0, import_type_guards.isFunction)(forwardRefToken) ? forwardRefToken() : forwardRefToken;
+        if ((0, import_type_guards.isDefined)(injectMetadata.mapper)) {
+          throw new import_resolve_error.ResolveError("Cannot use inject mapper with forwardRef.", getChain(forwardToken));
+        }
+        const resolved2 = this._resolve(forwardToken, parameterResolveArgument, { optional: injectMetadata.optional }, context, getChain(forwardToken));
+        import_forward_ref.ForwardRef.setRef(forwardRef, resolved2);
+      });
+      context.forwardRefs.add(forwardRef);
+      return forwardRef;
+    }
+    const resolved = this._resolve(injectToken, parameterResolveArgument, { optional: injectMetadata.optional }, context, getChain(injectToken));
+    return (0, import_type_guards.isDefined)(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved;
+  }
+  resolveInjection(token, argument, options, context, chain) {
+    if ((0, import_type_guards.isDefined)(options.forwardRef)) {
+      const forwardRef = import_forward_ref.ForwardRef.create();
+      context.forwardRefQueue.add(() => {
+        const resolved = this._resolve(token, argument, options, context, chain.addToken(token));
+        import_forward_ref.ForwardRef.setRef(forwardRef, resolved);
+      });
+      context.forwardRefs.add(forwardRef);
+      return forwardRef;
+    }
+    return this._resolve(token, argument, options, context, chain.addToken(token));
+  }
+  async resolveInjectionAsync(token, argument, options, context, chain) {
+    const value = this.resolveInjection(token, argument, options, context, chain);
+    await context.$done;
+    return value;
+  }
+  resolveInjectionAll(token, argument, options, context, chain) {
+    if ((0, import_type_guards.isDefined)(options.forwardRef)) {
+      const forwardRef = import_forward_ref.ForwardRef.create();
+      context.forwardRefQueue.add(() => {
+        const resolved = this._resolveAll(token, argument, options, context, chain.addToken(token));
+        import_forward_ref.ForwardRef.setRef(forwardRef, resolved);
+      });
+      context.forwardRefs.add(forwardRef);
+      return forwardRef;
+    }
+    return this._resolveAll(token, argument, options, context, chain.addToken(token));
+  }
+  async resolveInjectionAllAsync(token, argument, options, context, chain) {
+    const values = this.resolveInjectionAll(token, argument, options, context, chain);
+    await context.$done;
+    return values;
+  }
+  getResolveContext(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))
+    };
+    return context;
+  }
+  getInjectionContext(resolveContext, resolveArgument, chain) {
+    const context = {
+      argument: resolveArgument,
+      inject: (token, argument, options) => this.resolveInjection(token, argument, options ?? {}, resolveContext, chain),
+      injectAll: (token, argument, options) => this.resolveInjectionAll(token, argument, options ?? {}, resolveContext, chain),
+      injectAsync: async (token, argument, options) => this.resolveInjectionAsync(token, argument, options ?? {}, resolveContext, chain),
+      injectAllAsync: async (token, argument, options) => this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, chain)
+    };
+    return context;
+  }
+}
+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);
+  }
+}
+function newInternalResolveContext() {
+  return {
+    resolves: 0,
+    resolving: /* @__PURE__ */ new Set(),
+    resolutionScopedResolutions: new import_multi_key_map.MultiKeyMap(),
+    resolutions: [],
+    forwardRefQueue: new import_circular_buffer.CircularBuffer(),
+    forwardRefs: /* @__PURE__ */ new Set(),
+    $done: new import_deferred_promise.DeferredPromise()
+  };
+}
+function postProcess(context) {
+  for (const fn of context.forwardRefQueue.consume()) {
+    fn();
+  }
+  derefForwardRefs(context);
+  for (let i = context.resolutions.length - 1; i >= 0; i--) {
+    const resolution = context.resolutions[i];
+    if ((0, import_type_guards.isFunction)(resolution.value?.[import_interfaces.afterResolve])) {
+      const returnValue = resolution.value[import_interfaces.afterResolve](resolution.argument);
+      throwOnPromise(returnValue, "[afterResolve]", resolution.chain);
+    }
+    if ((0, import_provider.isProviderWithInitializer)(resolution.registration.provider)) {
+      const returnValue = resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument);
+      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);
+      throwOnPromise(returnValue, "registration afterResolve handler", resolution.chain);
+    }
+  }
+}
+async function postProcessAsync(context) {
+  for (const fn of context.forwardRefQueue.consume()) {
+    fn();
+  }
+  derefForwardRefs(context);
+  for (let i = context.resolutions.length - 1; i >= 0; i--) {
+    const resolution = context.resolutions[i];
+    if ((0, import_type_guards.isFunction)(resolution.value?.[import_interfaces.afterResolve])) {
+      await resolution.value[import_interfaces.afterResolve](resolution.argument);
+    }
+    if ((0, import_provider.isProviderWithInitializer)(resolution.registration.provider)) {
+      await resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument);
+    }
+    if ((0, import_type_guards.isDefined)(resolution.registration.options.afterResolve)) {
+      await resolution.registration.options.afterResolve(resolution.value, resolution.argument);
+    }
+  }
+}
+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;
+}
+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);
+}
+function deleteResolving(token, context) {
+  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);
+  }
+}
+function checkOverflow(chain, context) {
+  if (chain.length > 750 || ++context.resolves > 750) {
+    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);
+  }
+}
+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);
+    }
+  }
+}

package/injector/interfaces.d.ts

@@ -0,0 +1,14 @@
+import type { Type } from '../types.js';
+import type { InjectionToken } from './token.js';
+export declare const resolveArgumentType: unique symbol;
+export declare const afterResolve: unique symbol;
+export type ResolveArgumentType = typeof resolveArgumentType;
+export type ResolveArgument<T, Fallback = undefined> = (T extends Resolvable<infer U> ? U : T extends Type<Resolvable<infer U>> ? U : T extends InjectionToken<infer U, infer A> ? ResolveArgument<U, A> : Fallback) | undefined;
+export interface Resolvable<A = unknown> {
+    /**
+     * type of resolve argument
+     * @deprecated only used for type inference
+     */
+    readonly [resolveArgumentType]: A;
+    [afterResolve]?(argument: A): void | Promise<void>;
+}

package/injector/interfaces.js

@@ -0,0 +1,26 @@
+"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 interfaces_exports = {};
+__export(interfaces_exports, {
+  afterResolve: () => afterResolve,
+  resolveArgumentType: () => resolveArgumentType
+});
+module.exports = __toCommonJS(interfaces_exports);
+const resolveArgumentType = Symbol("resolveArgumentType");
+const afterResolve = Symbol("after resolve");

package/injector/provider.d.ts

@@ -0,0 +1,44 @@
+import type { Constructor, TypedOmit } from '../types.js';
+import type { ResolveArgument } from './interfaces.js';
+import type { InjectionToken } from './token.js';
+import type { ResolveContext } from './types.js';
+export type Factory<T, A = any> = (argument: ResolveArgument<T, A>, context: ResolveContext) => T;
+export type ProviderWithArgument<T, A> = {
+    defaultArgument?: ResolveArgument<T, A>;
+    defaultArgumentProvider?: () => ResolveArgument<T, A>;
+};
+export type ProviderWithInitializer<T, A> = {
+    afterResolve?: (value: T, argument: A) => void | Promise<void>;
+};
+export type Provider<T = any, A = any> = ClassProvider<T> | ValueProvider<T> | TokenProvider<T, A> | FactoryProvider<T, A>;
+export type ClassProvider<T = any, A = any> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A> & {
+    useClass: Constructor<T>;
+};
+export type ValueProvider<T = any> = {
+    useValue: T;
+};
+export type TokenProvider<T = any, A = any> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A> & ({
+    useToken: InjectionToken<T, A>;
+    useTokenProvider?: undefined;
+} | {
+    useToken?: undefined;
+    useTokenProvider: () => InjectionToken<T, A>;
+});
+export type FactoryProvider<T = any, A = unknown> = {
+    useFactory: Factory<T, A>;
+};
+export declare function classProvider<T, A>(constructor: Constructor<T>, options?: TypedOmit<ClassProvider<T, A>, 'useClass'>): ClassProvider<T, A>;
+export declare function valueProvider<T>(value: T, options?: TypedOmit<ValueProvider<T>, 'useValue'>): ValueProvider<T>;
+export declare function tokenProvider<T, A>(token: InjectionToken<T, A>, options?: TypedOmit<TokenProvider<T>, 'useToken' | 'useTokenProvider'>): TokenProvider<T>;
+export declare function factoryProvider<T, A>(factory: Factory<T, A>, options?: TypedOmit<FactoryProvider<T, A>, 'useFactory'>): FactoryProvider<T, A>;
+export declare function isClassProvider<T, A>(value: Provider<T, A>): value is ClassProvider<T, A>;
+export declare function isClassProvider<T, A>(value: unknown): value is ClassProvider<T, A>;
+export declare function isValueProvider<T>(value: Provider<T>): value is ValueProvider<T>;
+export declare function isValueProvider<T>(value: unknown): value is ValueProvider<T>;
+export declare function isTokenProvider<T, A>(value: Provider<T, A>): value is TokenProvider<T, A>;
+export declare function isTokenProvider<T, A>(value: unknown): value is TokenProvider<T, A>;
+export declare function isFactoryProvider<T, A>(value: Provider<T, A>): value is FactoryProvider<T, A>;
+export declare function isFactoryProvider<T, A>(value: unknown): value is FactoryProvider<T, A>;
+export declare function isProvider<T, A>(value: Provider<T, A>): value is Provider<T, A>;
+export declare function isProvider<T, A>(value: unknown): value is Provider<T, A>;
+export declare function isProviderWithInitializer<T, A>(value: Provider<T, A>): value is Extract<Provider<T, A>, ProviderWithInitializer<T, A>>;

package/injector/provider.js

@@ -0,0 +1,64 @@
+"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 provider_exports = {};
+__export(provider_exports, {
+  classProvider: () => classProvider,
+  factoryProvider: () => factoryProvider,
+  isClassProvider: () => isClassProvider,
+  isFactoryProvider: () => isFactoryProvider,
+  isProvider: () => isProvider,
+  isProviderWithInitializer: () => isProviderWithInitializer,
+  isTokenProvider: () => isTokenProvider,
+  isValueProvider: () => isValueProvider,
+  tokenProvider: () => tokenProvider,
+  valueProvider: () => valueProvider
+});
+module.exports = __toCommonJS(provider_exports);
+var import_object = require("../utils/object/object.js");
+var import_type_guards = require("../utils/type-guards.js");
+function classProvider(constructor, options) {
+  return { useClass: constructor, ...options };
+}
+function valueProvider(value, options) {
+  return { useValue: value, ...options };
+}
+function tokenProvider(token, options) {
+  return { useToken: token, ...options };
+}
+function factoryProvider(factory, options) {
+  return { useFactory: factory, ...options };
+}
+function isClassProvider(value) {
+  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "useClass");
+}
+function isValueProvider(value) {
+  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "useValue");
+}
+function isTokenProvider(value) {
+  return (0, import_type_guards.isObject)(value) && ((0, import_object.hasOwnProperty)(value, "useToken") || (0, import_object.hasOwnProperty)(value, "useTokenProvider"));
+}
+function isFactoryProvider(value) {
+  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "useFactory");
+}
+function isProvider(value) {
+  return isClassProvider(value) || isValueProvider(value) || isTokenProvider(value) || isFactoryProvider(value);
+}
+function isProviderWithInitializer(value) {
+  return (0, import_type_guards.isFunction)(value.afterResolve);
+}

package/injector/resolve-chain.d.ts

@@ -0,0 +1,31 @@
+import type { AbstractConstructor } from '../types.js';
+import type { InjectionToken } from './token.js';
+export type ResolveChainNodeBase<Type extends string> = {
+    type: Type;
+};
+export type ResolveChainNode = ResolveChainNodeBase<'token'> & {
+    token: InjectionToken;
+} | ResolveChainNodeBase<'inject'> & {
+    token: InjectionToken;
+    index: number;
+} | ResolveChainNodeBase<'parameter'> & {
+    constructor: AbstractConstructor;
+    index: number;
+    token: InjectionToken;
+} | ResolveChainNodeBase<'property'> & {
+    constructor: AbstractConstructor;
+    property: PropertyKey;
+    token: InjectionToken;
+};
+export declare class ResolveChain {
+    readonly nodes: readonly ResolveChainNode[];
+    get length(): number;
+    constructor(nodes?: ResolveChainNode[]);
+    static startWith(token: InjectionToken): ResolveChain;
+    addToken(token: InjectionToken): ResolveChain;
+    addInject(token: InjectionToken, index: number): ResolveChain;
+    addParameter(constructor: AbstractConstructor, index: number, token: InjectionToken): ResolveChain;
+    addProperty(constructor: AbstractConstructor, property: PropertyKey, token: InjectionToken): ResolveChain;
+    format(truncate?: number): string;
+    truncate(tokenCount: number): ResolveChain;
+}