undecorated-di/dist/index.cjs.map

Type-safe, straightforward dependency injection for TypeScript without annotations or reflect-metadata.

{"version":3,"sources":["../src/index.ts","../src/classes/bound-function.ts","../src/classes/constant.ts","../src/classes/dependency-graph-node.ts","../src/classes/injected-class.ts","../src/errors/circular-dependency-error.ts","../src/errors/duplicate-key-error.ts","../src/errors/missing-dependency-error.ts","../src/errors/missing-injectable-error.ts","../src/errors/uninitialized-property-access-error.ts","../src/classes/singleton-placeholder.ts","../src/classes/container.ts","../src/classes/container-builder.ts","../src/classes/key.ts","../src/classes/keys.ts","../src/functions/bind.ts","../src/functions/inject.ts"],"sourcesContent":["export { Keys, ContainerBuilder } from \"./classes\";\nexport { bind, inject } from \"./functions\";\n","import type { InjectableOrBindable, ResolvedDependencies } from \"../types\";\nimport type { Key } from \"./key\";\n\nexport class BoundFunction<\n  T extends (...args: any[]) => any,\n  U extends readonly Key[],\n  V extends (\n    ...args: [...ResolvedDependencies<U>, ...Parameters<T>]\n  ) => ReturnType<T>,\n> {\n  public readonly dependencies: U;\n  private key: Key<string, T>;\n  private bindable: InjectableOrBindable<V, U>;\n\n  public constructor(\n    key: Key<string, T>,\n    bindable: InjectableOrBindable<V, U>\n  ) {\n    this.key = key;\n    this.bindable = bindable;\n    this.dependencies = bindable.__dependencies__;\n  }\n\n  public resolve(resolvedDependencies: ResolvedDependencies<U>) {\n    return this.key.asType(\n      this.bindable.bind(this.bindable, ...resolvedDependencies)\n    );\n  }\n}\n","export class Constant<V> {\n  constructor(private readonly value: V) {}\n\n  public resolve() {\n    return this.value;\n  }\n}\n","export class DependencyGraphNode<K> {\n  keyName: K;\n  isSingleton: boolean;\n  parent?: DependencyGraphNode<any>;\n\n  constructor(\n    keyName: K,\n    isSingleton: boolean,\n    parent?: DependencyGraphNode<any>\n  ) {\n    this.keyName = keyName;\n    this.isSingleton = isSingleton;\n    this.parent = parent;\n  }\n}\n","import type {\n  Constructor,\n  InjectableOrBindable,\n  ParamsToKeys,\n  ResolvedDependencies,\n} from \"../types\";\nimport type { Key } from \"./key\";\n\nexport class InjectedClass<\n  T,\n  U extends Constructor<T>,\n  V extends ParamsToKeys<ConstructorParameters<U>>,\n> {\n  public readonly dependencies: V;\n  public readonly isSingleton: boolean;\n  private injectable: InjectableOrBindable<U, V>;\n  private key: Key<string, T>;\n\n  public constructor(\n    key: Key<string, T>,\n    injectable: InjectableOrBindable<U, V>,\n    isSingleton: boolean\n  ) {\n    this.key = key;\n    this.injectable = injectable;\n    this.dependencies = injectable.__dependencies__;\n    this.isSingleton = isSingleton;\n  }\n\n  public resolve(resolvedDependencies: ResolvedDependencies<V>) {\n    return this.key.asType(new this.injectable(...resolvedDependencies));\n  }\n}\n","export class CircularDependencyError extends Error {\n  name = \"CircularDependencyError\";\n\n  constructor(keyName: string) {\n    super(\n      `A circular dependency was found when resolving \"${keyName}.\" All members of a dependency cycle must be singletons.`\n    );\n  }\n}\n","export class DuplicateKeyError extends Error {\n  name = \"DuplicateKeyError\";\n\n  public constructor(keyName: string) {\n    super(`\"${keyName}\" is already assigned.`);\n  }\n}\n","import type { DependencyGraphNode } from \"../classes\";\n\nexport class MissingDependencyError extends Error {\n  name = \"MissingDependencyError\";\n\n  constructor(node: DependencyGraphNode<string>) {\n    super(MissingDependencyError.getMessage(node));\n  }\n\n  private static getMessage(node: DependencyGraphNode<string>) {\n    return `Service with key ${\n      node.keyName\n    } not found. Dependency graph is ${this.buildDependencyGraph(node)}.`;\n  }\n\n  private static buildDependencyGraph(node: DependencyGraphNode<string>) {\n    const serviceKeys: Array<any> = [];\n    serviceKeys.push(node.keyName);\n    while (node.parent) {\n      node = node.parent;\n      serviceKeys.push(node.keyName);\n    }\n    serviceKeys.reverse();\n    return serviceKeys.join(\"-->\");\n  }\n}\n","export class MissingInjectableError extends Error {\n  name = \"MissingInjectableError\";\n\n  constructor(keyName: string) {\n    super(\n      `Injectable with key name \"${keyName}\" not found. Was it registered?`\n    );\n  }\n}\n","export class UninitializedPropertyAccessError extends Error {\n  name = \"UninitializedPropertyAccessed\";\n\n  constructor() {\n    super(\n      \"A singleton that is part of a dependency cycle accessed a property of another member of that cycle in its constructor before the cycle could be resolved.\"\n    );\n  }\n}\n","import { UninitializedPropertyAccessError } from \"../errors\";\n\nexport class SingletonPlaceholder<SingletonType extends Object> {\n  instance?: SingletonType;\n  proxy: SingletonType;\n\n  constructor() {\n    const self = this;\n    this.proxy = new Proxy({} as SingletonType, {\n      get(_target, prop) {\n        if (!self.instance) {\n          throw new UninitializedPropertyAccessError();\n        }\n        return Reflect.get(self.instance, prop);\n      },\n      set(_target, prop, newValue) {\n        if (!self.instance) {\n          throw new UninitializedPropertyAccessError();\n        }\n        return Reflect.set(self.instance, prop, newValue);\n      },\n      getPrototypeOf(_target) {\n        if (!self.instance) {\n          throw new UninitializedPropertyAccessError();\n        }\n        return Reflect.getPrototypeOf(self.instance);\n      },\n      setPrototypeOf(_target, proto) {\n        if (!self.instance) {\n          throw new UninitializedPropertyAccessError();\n        }\n        return Reflect.setPrototypeOf(self.instance, proto);\n      },\n      defineProperty(_target, prop, descriptor) {\n        if (!self.instance) {\n          throw new UninitializedPropertyAccessError();\n        }\n        return Reflect.defineProperty(self.instance, prop, descriptor);\n      },\n      deleteProperty(_target, prop) {\n        if (!self.instance) {\n          throw new UninitializedPropertyAccessError();\n        }\n        return Reflect.deleteProperty(self.instance, prop);\n      },\n      getOwnPropertyDescriptor(_target, prop) {\n        if (!self.instance) {\n          throw new UninitializedPropertyAccessError();\n        }\n        return Reflect.getOwnPropertyDescriptor(self.instance, prop);\n      },\n      has(_target, prop) {\n        if (!self.instance) {\n          throw new UninitializedPropertyAccessError();\n        }\n        return Reflect.has(self.instance, prop);\n      },\n      ownKeys(_target) {\n        if (!self.instance) {\n          throw new UninitializedPropertyAccessError();\n        }\n        return Reflect.ownKeys(self.instance);\n      },\n      isExtensible(target) {\n        if (!self.instance) {\n          throw new UninitializedPropertyAccessError();\n        }\n        if (!Reflect.isExtensible(self.instance)) {\n          Reflect.preventExtensions(target);\n        }\n        return Reflect.isExtensible(target);\n      },\n      preventExtensions(target) {\n        if (!self.instance) {\n          throw new UninitializedPropertyAccessError();\n        }\n        Reflect.preventExtensions(self.instance);\n        return Reflect.preventExtensions(target);\n      },\n    });\n  }\n}\n","import { DependencyGraphNode } from \"./dependency-graph-node\";\nimport { InjectedClass } from \"./injected-class\";\nimport { Constant } from \"./constant\";\nimport { SingletonPlaceholder } from \"./singleton-placeholder\";\nimport {\n  CircularDependencyError,\n  MissingInjectableError,\n  MissingDependencyError,\n} from \"../errors\";\nimport type { Key } from \"./key\";\nimport type { Injectable } from \"../interfaces\";\n\ntype Singletons<T extends Record<string, Injectable>> = {\n  [K in keyof T]+?: ReturnType<T[K][\"resolve\"]>;\n};\n\ntype SingletonPlaceholders<T extends Record<string, Injectable>> = {\n  [K in keyof T]+?: Array<SingletonPlaceholder<ReturnType<T[K][\"resolve\"]>>>;\n};\n\nexport class Container<T extends Record<string, Injectable>> {\n  private resolvedInjectables = new Set<string>();\n  private singletons: Singletons<T> = {};\n  private singletonPlaceholders: SingletonPlaceholders<T> = {};\n\n  constructor(public readonly injectables: T) {}\n\n  public get<K extends keyof T & string>(\n    key: Key<K, ReturnType<T[K][\"resolve\"]>>\n  ): ReturnType<T[K][\"resolve\"]> {\n    const dependencyGraphNode = new DependencyGraphNode<K>(\n      key.name,\n      this.isSingleton(key.name)\n    );\n\n    return this.resolveWithDependencyGraph(dependencyGraphNode);\n  }\n\n  private resolveWithDependencyGraph<K extends keyof T & string>(\n    node: DependencyGraphNode<K>\n  ): ReturnType<T[K][\"resolve\"]> {\n    const singleton = this.singletons[node.keyName];\n    if (singleton) return singleton;\n\n    const injectable = this.injectables[node.keyName];\n\n    if (!injectable) {\n      if (!node.parent) {\n        throw new MissingInjectableError(node.keyName);\n      } else {\n        throw new MissingDependencyError(node);\n      }\n    }\n\n    if (injectable instanceof Constant) {\n      return injectable.resolve();\n    }\n\n    if (\n      !this.wasPreviouslyResolved(node.keyName) &&\n      this.completesSingletonOnlyDependencyCycle(node)\n    ) {\n      if (!(node.keyName in this.singletonPlaceholders)) {\n        this.singletonPlaceholders[node.keyName] = [];\n      }\n\n      const placeholder = new SingletonPlaceholder<\n        ReturnType<T[K][\"resolve\"]>\n      >();\n\n      this.singletonPlaceholders[node.keyName]!.push(placeholder);\n      return placeholder.proxy;\n    }\n\n    const resolvedDependencies = (injectable as any).dependencies.map(\n      (dependency: Key<keyof T & string>) => {\n        const childNode = new DependencyGraphNode(\n          dependency.name,\n          this.isSingleton(dependency.name),\n          node\n        );\n        return this.resolveWithDependencyGraph(childNode);\n      }\n    );\n\n    const instance =\n      this.injectables[node.keyName].resolve(resolvedDependencies);\n\n    if (node.isSingleton) {\n      this.singletons[node.keyName] = instance;\n      if (node.keyName in this.singletonPlaceholders) {\n        const placeholders = this.singletonPlaceholders[node.keyName] as Array<\n          SingletonPlaceholder<ReturnType<T[K][\"resolve\"]>>\n        >;\n\n        placeholders.forEach((placeholder) => {\n          placeholder.instance = instance;\n        });\n\n        delete this.singletonPlaceholders[node.keyName];\n      }\n    }\n\n    this.flagResolved(node.keyName);\n\n    return instance;\n  }\n\n  private isSingleton<K extends keyof this[\"injectables\"] & string>(\n    keyName: K\n  ): boolean {\n    const injectable = this.injectables[keyName];\n    return injectable instanceof InjectedClass && injectable.isSingleton;\n  }\n\n  private wasPreviouslyResolved(keyName: string) {\n    return this.resolvedInjectables.has(keyName);\n  }\n\n  private completesSingletonOnlyDependencyCycle<K extends keyof T & string>(\n    node: DependencyGraphNode<K>\n  ) {\n    const { keyName } = node;\n    let containsOnlySingletons = node.isSingleton;\n\n    while (node.parent) {\n      node = node.parent;\n      if (!node.isSingleton) containsOnlySingletons = false;\n      if (node.keyName === keyName) {\n        if (!containsOnlySingletons) {\n          throw new CircularDependencyError(keyName);\n        }\n\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  private flagResolved(keyName: string) {\n    this.resolvedInjectables.add(keyName);\n  }\n}\n","import { Container } from \"./container\";\nimport { InjectedClass } from \"./injected-class\";\nimport { BoundFunction } from \"./bound-function\";\nimport { Constant } from \"./constant\";\nimport { DuplicateKeyError } from \"../errors\";\nimport type { Key } from \"./key\";\nimport type { Injectable } from \"../interfaces\";\nimport type {\n  Constructor,\n  InjectableOrBindable,\n  ParamsToKeys,\n  ResolvedDependencies,\n} from \"../types\";\n\nexport class ContainerBuilder<T extends Record<string, Injectable>> {\n  private constructor(public readonly injectables: T) {}\n\n  public static createBuilder() {\n    return new ContainerBuilder({});\n  }\n\n  public registerClass<\n    T extends string,\n    S,\n    U extends Constructor<S>,\n    V extends ParamsToKeys<ConstructorParameters<U>>,\n  >(key: Key<T, S>, injectable: InjectableOrBindable<U, V>) {\n    const injectableClass = new InjectedClass(key, injectable, false);\n    return this.register<T, typeof injectableClass>(key.name, injectableClass);\n  }\n\n  public registerSingleton<\n    T extends string,\n    S,\n    U extends Constructor<S>,\n    V extends ParamsToKeys<ConstructorParameters<U>>,\n  >(key: Key<T, S>, injectable: InjectableOrBindable<U, V>) {\n    const singleton = new InjectedClass(key, injectable, true);\n    return this.register<T, typeof singleton>(key.name, singleton);\n  }\n\n  public registerFunction<\n    T extends string,\n    S extends (...args: any[]) => any,\n    U extends readonly Key[],\n    V extends (\n      ...args: [...ResolvedDependencies<U>, ...Parameters<S>]\n    ) => ReturnType<ReturnType<S>>,\n  >(key: Key<T, S>, bindable: InjectableOrBindable<V, U>) {\n    const boundFunc = new BoundFunction(key, bindable);\n    return this.register<T, typeof boundFunc>(key.name, boundFunc);\n  }\n\n  public registerConstant<T extends string, V>(key: Key<T, V>, value: V) {\n    const constant = new Constant(value);\n    return this.register<T, typeof constant>(key.name, constant);\n  }\n\n  public build() {\n    return new Container(this.injectables);\n  }\n\n  private register<T extends string, V extends Injectable>(\n    keyName: T,\n    injectable: V\n  ) {\n    if (keyName in this.injectables) {\n      throw new DuplicateKeyError(keyName);\n    }\n\n    const injectables = {\n      ...this.injectables,\n      [keyName]: injectable,\n    } as this[\"injectables\"] & {\n      [K in T]: V;\n    };\n\n    return new ContainerBuilder(injectables);\n  }\n}\n","export class Key<T extends string = string, V = any> {\n  constructor(public readonly name: T) {}\n\n  asType(implementation: any) {\n    return implementation as V;\n  }\n}\n","import { DuplicateKeyError } from \"../errors\";\nimport { Key } from \"./key\";\n\ntype ForTypeReturnType<\n  S extends string,\n  T extends Record<string, Key>,\n  U,\n> = Keys<T & { [K in S]: Key<S, U> }>;\n\ntype ForType<S extends string, T extends Record<string, Key>> = {\n  forType: <U>() => ForTypeReturnType<S, T, U>;\n};\n\nexport class Keys<T extends Record<string, Key>> {\n  private constructor(public readonly keys: T) {}\n\n  public static createKeys() {\n    return new Keys({});\n  }\n\n  public addKey<S extends string>(name: S): ForType<S, this[\"keys\"]> {\n    if (name in this.keys) {\n      throw new DuplicateKeyError(name);\n    }\n\n    return {\n      forType: <U>() => {\n        const keys = {\n          ...this.keys,\n          [name]: new Key<S, U>(name),\n        };\n\n        return new Keys(keys);\n      },\n    } as ForType<S, this[\"keys\"]>;\n  }\n}\n","import type { InjectableOrBindable, ParamsToKeys, Subset } from \"../types\";\n\nexport function bind<\n  T extends (...args: any[]) => any,\n  V extends ParamsToKeys<Subset<Parameters<T>>>,\n>(func: T, deps: V) {\n  const bound = ((...args: Parameters<T>) =>\n    func(...args)) as InjectableOrBindable<T, V>;\n  bound.__dependencies__ = deps;\n  return bound;\n}\n","import type { Constructor, InjectableOrBindable, ParamsToKeys } from \"../types\";\n\nexport function inject<\n  T,\n  U extends Constructor<T>,\n  V extends ParamsToKeys<ConstructorParameters<U>>,\n>(cls: U, dependencies: V) {\n  const injected = cls as InjectableOrBindable<U, V>;\n  injected.__dependencies__ = dependencies;\n  return injected;\n}\n"],"mappings":"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","names":["index_exports","__export","ContainerBuilder","Keys","bind","inject","__toCommonJS","BoundFunction","key","bindable","resolvedDependencies","Constant","value","DependencyGraphNode","keyName","isSingleton","parent","InjectedClass","key","injectable","isSingleton","resolvedDependencies","CircularDependencyError","keyName","DuplicateKeyError","keyName","MissingDependencyError","_MissingDependencyError","node","serviceKeys","MissingInjectableError","keyName","UninitializedPropertyAccessError","SingletonPlaceholder","self","_target","prop","UninitializedPropertyAccessError","newValue","proto","descriptor","target","Container","injectables","key","dependencyGraphNode","DependencyGraphNode","node","singleton","injectable","MissingDependencyError","MissingInjectableError","Constant","placeholder","SingletonPlaceholder","resolvedDependencies","dependency","childNode","instance","keyName","InjectedClass","containsOnlySingletons","CircularDependencyError","ContainerBuilder","_ContainerBuilder","injectables","key","injectable","injectableClass","InjectedClass","singleton","bindable","boundFunc","BoundFunction","value","constant","Constant","Container","keyName","DuplicateKeyError","__spreadProps","__spreadValues","Key","name","implementation","Keys","_Keys","keys","name","DuplicateKeyError","__spreadProps","__spreadValues","Key","bind","func","deps","bound","args","inject","cls","dependencies","injected"]}