Class Container<P>

Deprecated

Creates a child container. The child inherits all provided types and scopes from this container, but no changes to the child will affect this container.

Example

 const myContainer = Container.create()
   .provide(User, MyScope, Inject.construct(User, NameKey, IdKey))

 const mySubcomponent = myContainer.createSubcomponent(
   (ct, name: string, id: string) => ct
     .addScope(MyScope)
     .provideInstance(NameKey, name)
     .provideInstance(IdKey, id)
 )

 const childContainer = mySubcomponent('Alice', '123')

 const user = childContainer.request(User)
Copy

Adds the given Scopes to this container. Any dependencies with this scope will be instantiated when first requested and memoized within this container.

Applies the given Modules or Items to this container. All scopes and dependencies provided with the modules will be applied to this container.

Example

Apply Module object:

const MyModule = Module(ct => ct
  .provide(FooService, () => new FooService())
  .provide(BarService, () => new BarService())
)

const myContainer = Container.create().apply(MyModule)

const [fooService, barService] = myContainer.request([FooService, BarService])
Copy

Example

Apply function:

const myContainer = Container.create().apply(ct => ct
  .provide(FooService, () => new FooService())
  .provide(BarService, () => new BarService())
)

const [fooService, barService] = myContainer.request([FooService, BarService])
Copy

Example

Use apply to merge modules:

const FooModule = Module(ct => ct
  .provide(FooService, () => new FooService())
)
const BarModule = Module(ct => ct
  .provide(FooService, () => new FooService())
)
const MyModule = Module(ct => ct
  .provide(BazService,
    Inject.construct(BazService, FooService, BarService))
  .apply(FooModule, BarModule)
)

const myContainer = Container.create().apply(MyModule)

const [fooService, barService] = myContainer.request([FooService, BarService])
Copy

Binds the resolved value of src to key. In other words, when key is requested, src will be used to provide the value. Equivalent to provide(key, Inject.from(src))

Specifies how to resolve the target type of the given key or class.

Example

Provide the TypeKey NameKey with a function returning a string:

myContainer.provide(NameKey, () => 'Alice')
Copy

Provide the TypeKey IdKey within the Scope MyScope, so the function is only called once per container with MyScope

myContainer.provide(IdKey, MyScope, () => '123')
Copy

Provide an instance of User using a dependency object and a function.

The dependency object can be an object with DependencyKey properties, like so:

myContainer.provide(User, {
  name: NameKey,
  id: IdKey,
}, ({ name, id }) => new User(name, user))
Copy

Provide User using a ComputedKey, {@link Inject.construct}

myContainer.provide(User, Inject.construct(User, NameKey, IdKey))
Copy

Specifies how to asynchronously resolve the target type of the given key or class. The signature is the same as provide, except that a Promise to the target type can be provided. The provided type cannot be directly requested through request. It can, however be requested through requestAsync or by using key.Async().

Example

myContainer.provideAsync(
 NameKey,
 { NameService }, async ({ NameService }) => await NameService.getName(),
)
Copy

Provides an instance of the target type for the given key or class.

Given a FactoryKey or similar, return the result of the factory function after applying args.

Given a FactoryKey or similar, asynchronously return the result of the factory function after applying args.

It is safe to call method when some dependencies cannot be resolved synchronously.

Calls the given function with the requested dependencies and returns its output.

Asynchronously calls the given function with the requested dependencies and returns its output.

It is safe to call method when some dependencies cannot be resolved synchronously.

Requests the dependency specified by the given key, statically checking that the dependency is safe to request.

Asynchronously requests the dependency specified by the given key, statically checking that the dependency is safe to request.

It is safe to call method when some dependencies cannot be resolved synchronously.

Asynchronously requests the dependency specified by the given key, without statically checking that the dependency is safe to request.

Throws

InjectError when not all transitive dependencies are met

Requests the dependency specified by the given key, without statically checking that the dependency is safe to request.

Throws

InjectError when not all transitive dependencies are met

Creates a new Container instance.