{"version":3,"sources":["jsdelivr-header.js","/npm/@sigi/di@2.13.1/src/type.ts","/npm/@sigi/di@2.13.1/src/injector-provider.ts","/npm/@sigi/di@2.13.1/src/provider.ts","/npm/@sigi/di@2.13.1/src/injector.ts","/npm/@sigi/di@2.13.1/src/root-injector.ts","/npm/@sigi/di@2.13.1/src/injectable.ts","/npm/@sigi/di@2.13.1/src/inject.ts","/npm/@sigi/di@2.13.1/src/testbed.ts"],"names":[],"mappings":"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","file":"/npm/@sigi/di@2.13.1/dist/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@sigi/di@2.13.1/dist/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","export class InjectionToken<T> {\n  // @internal\n  readonly _phantom?: T\n\n  constructor(private readonly desc: string) {}\n\n  toString() {\n    return this.desc\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport interface Type<T = Record<string, unknown>> extends Function {\n  new (...args: any[]): T\n}\n\nexport interface ValueProvider<T> {\n  /**\n   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).\n   */\n  provide: Token<T>\n  /**\n   * The value to inject.\n   */\n  useValue: T\n}\n\nexport interface FactoryProvider<T, Deps extends Array<Token<any>> = any[]> {\n  /**\n   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).\n   */\n  provide: Token<T>\n  /**\n   * A function to invoke to create a value for this `token`. The function is invoked with\n   * resolved values of `token`s in the `deps` field.\n   */\n  useFactory: (...args: Deps) => T\n  /**\n   * A list of `token`s which need to be resolved by the injector. The list of values is then\n   * used as arguments to the `useFactory` function.\n   */\n  deps?: Deps\n}\n\nexport interface ClassProvider<T> {\n  /**\n   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).\n   */\n  provide: Token<T>\n  /**\n   * Class to instantiate for the `token`.\n   */\n  useClass: Type<T>\n}\n\nexport interface ExistingProvider<T> {\n  /**\n   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).\n   */\n  provide: Token<T>\n  /**\n   * Existing `token` to return. (equivalent to `injector.get(useExisting)`)\n   */\n  useExisting: Token<T>\n}\n\nexport type Token<T = unknown> = Type<T> | InjectionToken<T>\n\nexport type Provider<T = unknown> =\n  | Type<T>\n  | ValueProvider<T>\n  | ClassProvider<T>\n  | ExistingProvider<T>\n  | FactoryProvider<T>\n","import { InjectionToken, Provider, Token } from './type'\n\nexport class ReflectiveProvider<T> {\n  name: string\n\n  token: Token<T>\n\n  constructor(public readonly provider: Provider<T>) {\n    if (typeof provider === 'function') {\n      this.name = provider.name\n      this.token = provider\n    } else {\n      this.name = provider.provide instanceof InjectionToken ? provider.provide.toString() : provider.provide.name\n      this.token = provider.provide\n    }\n  }\n\n  toString() {\n    return this.name\n  }\n}\n","import { Token, Provider, ValueProvider, Type } from './type'\n\nexport class InjectionProvider {\n  private readonly providersMap = new Map<Token<unknown>, Provider<unknown>>()\n\n  addProvider<T extends Provider<any>>(provider: T): T {\n    this.providersMap.set((provider as ValueProvider<T>).provide ?? (provider as Type<T>), provider)\n    return provider\n  }\n\n  findProviderByToken<T>(token: Token<T>): Provider<T> | null {\n    if (!this.providersMap.has(token)) {\n      return null\n    }\n    return this.providersMap.get(token)! as Provider<T>\n  }\n}\n","import { ReflectiveProvider } from './injector-provider'\nimport { InjectionProvider } from './provider'\nimport { Provider, ValueProvider, ClassProvider, FactoryProvider, Token, Type, InjectionToken } from './type'\n\nexport class Injector {\n  readonly provider = new InjectionProvider()\n\n  protected readonly resolvedProviders = new Map<ReflectiveProvider<unknown>, unknown>()\n  protected readonly providersCache = new Map<Provider, ReflectiveProvider<unknown>>()\n\n  constructor(protected readonly parent: Injector | null = null) {}\n\n  addProvider<T extends Provider<any>>(provider: T): T {\n    return this.provider.addProvider(provider)\n  }\n\n  addProviders(providers: Provider[]) {\n    for (const provider of providers) {\n      this.provider.addProvider(provider)\n    }\n    return this\n  }\n\n  getInstance<T>(provider: Provider<T>): T {\n    return this.getInstanceInternal(provider, true)\n  }\n\n  resolveAndInstantiate<T>(provider: Provider<T>): T {\n    return this.getInstanceInternal(provider, false)\n  }\n\n  createChild(providers: Provider<unknown>[]): Injector {\n    const childInjector = new Injector(this)\n    childInjector.addProviders(providers)\n    return childInjector\n  }\n\n  private resolveReflectiveProvider<T>(provider: Provider<T>): ReflectiveProvider<T> | null {\n    let reflectiveProvider: ReflectiveProvider<T> | null = null\n    if (this.provider.findProviderByToken((provider as ValueProvider<T>).provide ?? provider)) {\n      if (this.providersCache.has(provider)) {\n        return this.providersCache.get(provider) as ReflectiveProvider<T>\n      }\n      reflectiveProvider = new ReflectiveProvider(provider)\n      this.providersCache.set(provider, reflectiveProvider)\n    }\n    return reflectiveProvider\n  }\n\n  private getInstanceInternal<T>(provider: Provider<T>, useCache: boolean): T {\n    let injector: Injector | null = this\n    let instance: T | null = null\n    let reflectiveProvider: ReflectiveProvider<T> | null = null\n    const deps = this.findDeps(provider)\n    while (injector) {\n      reflectiveProvider = injector.resolveReflectiveProvider(provider)\n      if (!reflectiveProvider) {\n        injector = injector.parent\n        continue\n      }\n      if (injector.resolvedProviders.has(reflectiveProvider)) {\n        if (deps) {\n          if (useCache && (injector === this || this.checkDependenciesClean(injector, deps))) {\n            instance = injector.resolvedProviders.get(reflectiveProvider) as T\n          } else {\n            instance = this.resolveByReflectiveProvider(reflectiveProvider, useCache, this)\n            if (useCache) {\n              this.provider.addProvider(provider)\n              this.providersCache.set(provider, reflectiveProvider)\n              this.resolvedProviders.set(reflectiveProvider, instance)\n            }\n          }\n        } else {\n          instance = useCache\n            ? (injector.resolvedProviders.get(reflectiveProvider) as T)\n            : this.resolveByReflectiveProvider(reflectiveProvider, false, this)\n        }\n        break\n      }\n      instance = injector.resolveByReflectiveProvider(reflectiveProvider, useCache, this)\n      if (instance) {\n        if (useCache) {\n          this.provider.addProvider(provider)\n          this.providersCache.set(provider, reflectiveProvider)\n          this.resolvedProviders.set(reflectiveProvider!, instance)\n        }\n        break\n      }\n      injector = injector.parent\n    }\n    if (!instance) {\n      reflectiveProvider = new ReflectiveProvider(provider)\n      throw new TypeError(`No provider for ${reflectiveProvider.name}!`)\n    }\n    return instance\n  }\n\n  private resolveByReflectiveProvider<T>(\n    reflectiveProvider: ReflectiveProvider<T>,\n    useCache = true,\n    leaf = this,\n  ): T | null {\n    let instance: T | null = null\n    const { provider, name } = reflectiveProvider\n    if (typeof provider === 'function') {\n      const deps: Array<Type<unknown> | InjectionToken<T>> = Reflect.getMetadata('design:paramtypes', provider) ?? []\n      const depsInstance = deps.map((dep) => leaf.getInstanceInternal(leaf.findExisting(dep), useCache))\n      instance = new provider(...depsInstance)\n    } else if ('useValue' in provider) {\n      instance = provider.useValue\n    } else if ('useClass' in provider) {\n      instance = leaf.getInstanceInternal(provider.useClass, useCache)\n    } else if ('useFactory' in provider) {\n      let deps: unknown[] = []\n      if (provider.deps) {\n        deps = provider.deps!.map((dep) => leaf.getInstanceInternal(leaf.findExisting(dep), useCache))\n      }\n      instance = provider.useFactory(...deps)\n    } else if ('useExisting' in provider) {\n      instance = leaf.getInstanceInternal(this.findExisting(provider.useExisting), useCache)\n    }\n    if (!instance) {\n      throw new TypeError(`Can not resolve ${name}, it's not a valid provider`)\n    }\n    return instance\n  }\n\n  private findExisting<T>(token: Token<T>): Provider<T> {\n    let provider: Provider<T> | null = null\n    let injector: Injector | null = this\n    while (injector) {\n      provider = injector.provider.findProviderByToken(token)\n      if (provider) {\n        break\n      }\n      injector = injector.parent\n    }\n\n    if (!provider) {\n      throw new TypeError(`No provider for ${(token as Type<T>).name ?? token.toString()}`)\n    }\n    return provider\n  }\n\n  private findDeps<T>(provider: Provider<T>): Token<unknown>[] | null | undefined {\n    return typeof provider === 'function'\n      ? Reflect.getMetadata('design:paramtypes', provider)\n      : (provider as ClassProvider<T>).useClass\n        ? Reflect.getMetadata('design:paramtypes', (provider as ClassProvider<T>).useClass)\n        : (provider as FactoryProvider<T>).deps\n          ? (provider as FactoryProvider<T>).deps\n          : null\n  }\n\n  private checkDependenciesClean(leaf: Injector, deps: Token<unknown>[]): boolean {\n    return deps.every((dep) => {\n      const depInLeaf = leaf.findExisting(dep)\n      const depInRoot = this.findExisting(dep)\n      const isEqual = depInLeaf === depInRoot\n      const deps = this.findDeps(depInLeaf)\n      if (deps) {\n        return this.checkDependenciesClean(leaf, deps) && isEqual\n      }\n      return isEqual\n    })\n  }\n}\n","import { Injector } from './injector'\nimport { InjectionProvider } from './provider'\n\nexport class RootInjector extends Injector {\n  provider = new InjectionProvider()\n\n  reset() {\n    this.provider = new InjectionProvider()\n    this.providersCache.clear()\n    this.resolvedProviders.clear()\n  }\n}\n\nexport const rootInjector = new RootInjector()\n","import { rootInjector } from './root-injector'\nimport { Provider } from './type'\n\nexport interface InjectableOptions {\n  providers: Provider[]\n}\n\nexport function Injectable(options?: InjectableOptions) {\n  return function (target: any) {\n    rootInjector.addProvider({\n      useClass: target,\n      provide: target,\n    })\n    for (const provider of options?.providers ?? []) {\n      rootInjector.addProvider(provider)\n    }\n    return target\n  }\n}\n","import { Type, InjectionToken } from './type'\n\nexport function Inject<T>(token: Type<T> | InjectionToken<T>) {\n  return function <U>(target: Type<U>, _key: string | symbol | undefined, paramIndex: number) {\n    const deps = Reflect.getMetadata('design:paramtypes', target) as any[]\n    deps[paramIndex] = token\n  }\n}\n","import { Injector } from './injector'\nimport { rootInjector } from './root-injector'\nimport { Type, InjectionToken, Provider, Token, ValueProvider } from './type'\n\nexport class Test<M extends AbstractTestModule> {\n  static createTestingModule<M extends AbstractTestModule>(overrideConfig?: {\n    TestModule?: Type<M>\n    providers?: Provider[]\n  }) {\n    return new Test<M>(\n      overrideConfig?.providers ? overrideConfig.providers : [],\n      overrideConfig?.TestModule ? overrideConfig.TestModule : (TestModule as any),\n    )\n  }\n\n  readonly providersMap = new Map<Token<unknown>, Provider>()\n\n  private constructor(\n    providers: Provider[],\n    private readonly TestModule: Type<M>,\n  ) {\n    for (const provider of providers) {\n      this.providersMap.set((provider as ValueProvider<unknown>).provide ?? provider, provider)\n    }\n  }\n\n  overrideProvider<T>(token: Token<T>): MockProvider<T, M> {\n    return new MockProvider(this, token)\n  }\n\n  compile() {\n    const childInjector = rootInjector.createChild(Array.from(this.providersMap.values()))\n    return new this.TestModule(childInjector)\n  }\n}\n\nexport class MockProvider<T, M extends AbstractTestModule> {\n  constructor(\n    private readonly test: Test<M>,\n    private readonly token: Type<T> | InjectionToken<T>,\n  ) {}\n\n  useClass(value: Type<T>) {\n    this.test.providersMap.set(this.token, { provide: this.token, useClass: value })\n    return this.test\n  }\n\n  useValue(value: T) {\n    this.test.providersMap.set(this.token, { provide: this.token, useValue: value })\n    return this.test\n  }\n\n  useFactory(value: (...args: any[]) => any) {\n    this.test.providersMap.set(this.token, { provide: this.token, useFactory: value })\n    return this.test\n  }\n}\n\nexport abstract class AbstractTestModule {\n  abstract getInstance<T>(provider: Provider<T>): T\n}\n\nexport class TestModule implements AbstractTestModule {\n  constructor(private readonly injector: Injector) {}\n\n  getInstance<T>(token: Provider<T>): T {\n    return this.injector.getInstance(token)\n  }\n}\n"]}