Options
All
  • Public
  • Public/Protected
  • All
Menu

Class ScopedContainer

A container that uses some parent container as a base, but can have other factories distinct from that parent.

If an instance is not found in this container, it will be resolved from the parent container.

However, if an instance IS found in this container, it will ALWAYS be resolved from this container, rather than the parent.

This can be used to create scope-specific containers that can still resolve the global dependencies, while keeping scope-specific dependencies separate.

example

The Request class from @extollo/lib is a ScopedContainer. It can resolve all dependencies that exist in the global Container, but it can also have request-specific services (like the Session) injected into it.

Hierarchy

Index

Constructors

constructor

Properties

Protected factories

factories: Collection<AbstractFactory<unknown>> = ...

Collection of factories registered with this container.

Protected instances

instances: Collection<InstanceRef> = ...

Collection of singleton instances produced by this container.

Private resolveParentScope

resolveParentScope: boolean = true

Protected staticOverrides

staticOverrides: Collection<{ base: StaticInstantiable<any>; override: StaticInstantiable<any> }> = ...

Collection of static-class overrides registered with this container.

Protected waitingLifecycleCallbacks

waitingLifecycleCallbacks: Collection<WeakRef<AwareOfContainerLifecycle>> = ...

Collection of created objects that should have lifecycle events called on them, if they still exist.

Protected waitingResolveCallbacks

waitingResolveCallbacks: Collection<{ callback: (t: unknown) => unknown; key: any }> = ...

Collection of callbacks waiting for a dependency key to be resolved.

Static Protected Optional makeHistory

makeHistory: Collection<any>

The 100 most recent dependency keys that were make'd. Used to help with debugging cyclic dependency errors.

Static Protected Optional makeStack

makeStack: Collection<any>

List of dependency keys currently being make'd as a reverse stack. This is used to detect dependency cycles.

Static Protected realizingContainer

realizingContainer: boolean = false

Set to true when we're realizing a container. Used to prevent infinite recursion when getContainer() is accidentally called from somewhere within the realizeContainer() call.

Methods

Protected checkForMakeCycles

  • checkForMakeCycles(): void
  • Check the makeStack for duplicates and throw an error if a dependency cycle is detected. This is used to prevent infinite mutual recursion when cyclic dependencies occur.

    Returns void

cloneTo

destroy

  • destroy(): void

getDependencies

getExistingInstance

  • getExistingInstance(key: any): any

getStaticOverride

hasInstance

  • hasInstance(key: any): boolean

hasKey

  • hasKey(key: any): boolean

hasStaticOverride

make

  • make<T>(target: any, ...parameters: any[]): T
  • Create an instance of the given target. The target can either be a DependencyKey registered with this container (in which case, the singleton value will be returned), or an instantiable class.

    If the instantiable class has the Injectable decorator, its injectable parameters will be automatically injected into the instance.

    Type parameters

    • T

    Parameters

    • target: any
    • Rest ...parameters: any[]

    Returns T

makeByStaticOverride

makeNew

  • makeNew<T>(key: any, ...parameters: any[]): T
  • Create a new instance of the dependency key using this container, ignoring any pre-existing instances in this container.

    Type parameters

    • T

    Parameters

    • key: any
    • Rest ...parameters: any[]

    Returns T

onResolve

  • onResolve<T>(key: any): Promise<T>
  • Get a Promise that resolves the first time the given dependency key is resolved by the application. If it has already been resolved, the Promise will resolve immediately.

    Type parameters

    • T

    Parameters

    • key: any

    Returns Promise<T>

Protected produceFactory

purge

register

registerFactory

registerNamed

registerProducer

registerSingleton

registerSingletonInstance

  • registerSingletonInstance<T>(staticClass: any, instance: T): ScopedContainer

registerStaticOverride

release

resolve

resolveAndCreate

  • resolveAndCreate(key: any, ...parameters: any[]): any
  • Resolve the dependency key. If a singleton value for that key already exists in this container, return that value. Otherwise, use the factory an given parameters to produce and return the value.

    Parameters

    • key: any
    • Rest ...parameters: any[]

    Returns any

withoutParentScopes

  • withoutParentScopes<T>(closure: () => T): T
  • Execute a closure on this container, disabling parent-resolution. Effectively, the closure will have access to this container as if it were NOT a scoped container, and only contained its factories.

    Type parameters

    • T

    Parameters

    • closure: () => T
        • (): T
        • Returns T

    Returns T

Static fromParent

Static getContainer

Static realizeContainer

  • realizeContainer<T>(container: T): T
Extollo Logo

extollo (v. latin) - to lift up, to elevate

Extollo is a free & libre application framework in TypeScript.