123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412
import DependencyContainer from "./types/dependency-container.ts";import {  isClassProvider,  isFactoryProvider,  isNormalToken,  isTokenProvider,  isValueProvider,} from "./providers/index.ts";import Provider, { isProvider } from "./providers/provider.ts";import FactoryProvider from "./providers/factory-provider.ts";import InjectionToken, { isConstructorToken, isTokenDescriptor, TokenDescriptor } from "./providers/injection-token.ts";import TokenProvider from "./providers/token-provider.ts";import ValueProvider from "./providers/value-provider.ts";import ClassProvider from "./providers/class-provider.ts";import RegistrationOptions from "./types/registration-options.ts";import constructor from "./types/constructor.ts";import Registry from "./registry.ts";import Lifecycle from "./types/lifecycle.ts";import ResolutionContext from "./resolution-context.ts";import { formatErrorCtor } from "./error-helpers.ts";import { DelayedConstructor } from "./lazy-helpers.ts";
export type Registration<T = any> = {  provider: Provider<T>;  options: RegistrationOptions;  instance?: T;};
export type ParamInfo = TokenDescriptor | InjectionToken<any>;
export const typeInfo = new Map<constructor<any>, ParamInfo[]>();
/** Dependency Container */class InternalDependencyContainer implements DependencyContainer {  private _registry = new Registry();
  public constructor(private parent?: InternalDependencyContainer) {}
  /**   * Register a dependency provider.   *   * @param provider {Provider} The dependency provider   */  public register<T>(    token: InjectionToken<T>,    provider: ValueProvider<T>,  ): InternalDependencyContainer;  public register<T>(    token: InjectionToken<T>,    provider: FactoryProvider<T>,  ): InternalDependencyContainer;  public register<T>(    token: InjectionToken<T>,    provider: TokenProvider<T>,    options?: RegistrationOptions,  ): InternalDependencyContainer;  public register<T>(    token: InjectionToken<T>,    provider: ClassProvider<T>,    options?: RegistrationOptions,  ): InternalDependencyContainer;  public register<T>(    token: InjectionToken<T>,    provider: constructor<T>,    options?: RegistrationOptions,  ): InternalDependencyContainer;  public register<T>(    token: InjectionToken<T>,    providerOrConstructor: Provider<T> | constructor<T>,    options: RegistrationOptions = { lifecycle: Lifecycle.Transient },  ): InternalDependencyContainer {    let provider: Provider<T>;
    if (!isProvider(providerOrConstructor)) {      provider = { useClass: providerOrConstructor };    } else {      provider = providerOrConstructor;    }
    if (      options.lifecycle === Lifecycle.Singleton ||      options.lifecycle == Lifecycle.ContainerScoped ||      options.lifecycle == Lifecycle.ResolutionScoped    ) {      if (isValueProvider(provider) || isFactoryProvider(provider)) {        throw new Error(          `Cannot use lifecycle "${Lifecycle[options.lifecycle]}" with ValueProviders or FactoryProviders`,        );      }    }
    this._registry.set(token, { provider, options });
    return this;  }
  /**   * Uses only set immmediataly   * onlu uses in Alosaur   * @param token   * @param provider   */  public registerValue<T>(    token: InjectionToken<T>,    provider: ValueProvider<T>,  ): InternalDependencyContainer {    this._registry.set(      token,      { provider, options: { lifecycle: Lifecycle.Transient } },    );    return this;  }
  public registerType<T>(    from: InjectionToken<T>,    to: InjectionToken<T>,  ): InternalDependencyContainer {    if (isNormalToken(to)) {      return this.register(from, {        useToken: to,      });    }
    return this.register(from, {      useClass: to,    });  }
  public registerInstance<T>(    token: InjectionToken<T>,    instance: T,  ): InternalDependencyContainer {    return this.register(token, {      useValue: instance,    });  }
  public registerSingleton<T>(    from: InjectionToken<T>,    to: InjectionToken<T>,  ): InternalDependencyContainer;  public registerSingleton<T>(    token: constructor<T>,    to?: constructor<any>,  ): InternalDependencyContainer;  public registerSingleton<T>(    from: InjectionToken<T>,    to?: InjectionToken<T>,  ): InternalDependencyContainer {    if (isNormalToken(from)) {      if (isNormalToken(to)) {        return this.register(          from,          {            useToken: to,          },          { lifecycle: Lifecycle.Singleton },        );      } else if (to) {        return this.register(          from,          {            useClass: to,          },          { lifecycle: Lifecycle.Singleton },        );      }
      throw new Error(        'Cannot register a type name as a singleton without a "to" token',      );    }
    let useClass = from;    if (to && !isNormalToken(to)) {      useClass = to;    }
    return this.register(      from,      {        useClass,      },      { lifecycle: Lifecycle.Singleton },    );  }
  public resolve<T>(    token: InjectionToken<T>,    context: ResolutionContext = new ResolutionContext(),  ): T {    const registration = this.getRegistration(token);
    if (!registration && isNormalToken(token)) {      throw new Error(        `Attempted to resolve unregistered dependency token: "${token.toString()}"`,      );    }
    if (registration) {      return this.resolveRegistration(registration, context);    }
    // No registration for this token, but since it's a constructor, return an instance    if (isConstructorToken(token)) {      return this.construct(token, context);    }    throw new Error(      "Attempted to construct an undefined constructor. Could mean a circular dependency problem. Try using `delay` function.",    );  }
  private resolveRegistration<T>(    registration: Registration,    context: ResolutionContext,  ): T {    // If we have already resolved this scoped dependency, return it    if (      registration.options.lifecycle === Lifecycle.ResolutionScoped &&      context.scopedResolutions.has(registration)    ) {      return context.scopedResolutions.get(registration);    }
    const isSingleton = registration.options.lifecycle === Lifecycle.Singleton;    const isContainerScoped = registration.options.lifecycle === Lifecycle.ContainerScoped;
    const returnInstance = isSingleton || isContainerScoped;
    let resolved: T;
    if (isValueProvider(registration.provider)) {      resolved = registration.provider.useValue;    } else if (isTokenProvider(registration.provider)) {      resolved = returnInstance        ? registration.instance ||          (registration.instance = this.resolve(            registration.provider.useToken,            context,          ))        : this.resolve(registration.provider.useToken, context);    } else if (isClassProvider(registration.provider)) {      resolved = returnInstance        ? registration.instance ||          (registration.instance = this.construct(            registration.provider.useClass,            context,          ))        : this.construct(registration.provider.useClass, context);    } else if (isFactoryProvider(registration.provider)) {      resolved = registration.provider.useFactory(this);    } else {      resolved = this.construct(registration.provider, context);    }
    // If this is a scoped dependency, store resolved instance in context    if (registration.options.lifecycle === Lifecycle.ResolutionScoped) {      context.scopedResolutions.set(registration, resolved);    }
    return resolved;  }
  public resolveAll<T>(    token: InjectionToken<T>,    context: ResolutionContext = new ResolutionContext(),  ): T[] {    const registrations = this.getAllRegistrations(token);
    if (!registrations && isNormalToken(token)) {      throw new Error(        `Attempted to resolve unregistered dependency token: "${token.toString()}"`,      );    }
    if (registrations) {      return registrations.map((item) => this.resolveRegistration<T>(item, context));    }
    // No registration for this token, but since it's a constructor, return an instance    return [this.construct(token as constructor<T>, context)];  }
  public isRegistered<T>(token: InjectionToken<T>, recursive = false): boolean {    return (      this._registry.has(token) ||      (recursive &&        (this.parent || false) &&        this.parent.isRegistered(token, true))    );  }
  public reset(): void {    this._registry.clear();  }
  public clearInstances(): void {    for (const [token, registrations] of this._registry.entries()) {      this._registry.setAll(        token,        registrations          // Clear ValueProvider registrations          .filter((registration) => !isValueProvider(registration.provider))          // Clear instances          .map((registration) => {            registration.instance = undefined;            return registration;          }),      );    }  }
  public createChildContainer(): DependencyContainer {    const childContainer = new InternalDependencyContainer(this);
    for (const [token, registrations] of this._registry.entries()) {      // If there are any ContainerScoped registrations, we need to copy      // ALL registrations to the child container, if we were to copy just      // the ContainerScoped registrations, we would lose access to the others      if (        registrations.some(          ({ options }) => options.lifecycle === Lifecycle.ContainerScoped,        )      ) {        childContainer._registry.setAll(          token,          registrations.map<Registration>((registration) => {            if (registration.options.lifecycle === Lifecycle.ContainerScoped) {              return {                provider: registration.provider,                options: registration.options,              };            }
            return registration;          }),        );      }    }
    return childContainer;  }
  private getRegistration<T>(token: InjectionToken<T>): Registration | null {    if (this.isRegistered(token)) {      return this._registry.get(token)!;    }
    if (this.parent) {      return this.parent.getRegistration(token);    }
    return null;  }
  private getAllRegistrations<T>(    token: InjectionToken<T>,  ): Registration[] | null {    if (this.isRegistered(token)) {      return this._registry.getAll(token);    }
    if (this.parent) {      return this.parent.getAllRegistrations(token);    }
    return null;  }
  private construct<T>(    ctor: constructor<T> | DelayedConstructor<T>,    context: ResolutionContext,  ): T {    if (ctor instanceof DelayedConstructor) {      return ctor.createProxy((target: constructor<T>) => this.resolve(target, context));    }
    if (ctor.length === 0) {      return new ctor();    }
    const paramInfo = typeInfo.get(ctor);
    if (!paramInfo || paramInfo.length === 0) {      throw new Error(`TypeInfo not known for "${ctor.name}"`);    }
    const params = paramInfo.map(this.resolveParams(context, ctor));
    return new ctor(...params);  }
  private resolveParams<T>(context: ResolutionContext, ctor: constructor<T>) {    return (param: ParamInfo, idx: number) => {      try {        if (isTokenDescriptor(param)) {          return param.multiple ? this.resolveAll(param.token) : this.resolve(param.token, context);        }        return this.resolve(param, context);      } catch (e) {        throw new Error(formatErrorCtor(ctor, idx, e));      }    };  }}
export { InternalDependencyContainer };
export const instance: DependencyContainer = new InternalDependencyContainer();
export default instance;