@inversifyjs/container/lib/container/services/Container.js

InversifyJs container

import { ActivationsService, bindingScopeValues, BindingService, DeactivationsService, PlanResultCacheService, } from '@inversifyjs/core';
import { BindingManager } from './BindingManager.js';
import { ContainerModuleManager } from './ContainerModuleManager.js';
import { DeactivationParamsManager } from './DeactivationParamsManager.js';
import { PlanParamsOperationsManager } from './PlanParamsOperationsManager.js';
import { PlanResultCacheManager } from './PlanResultCacheManager.js';
import { PluginManager } from './PluginManager.js';
import { ServiceReferenceManager } from './ServiceReferenceManager.js';
import { ServiceResolutionManager } from './ServiceResolutionManager.js';
import { SnapshotManager } from './SnapshotManager.js';
const DEFAULT_DEFAULT_SCOPE = bindingScopeValues.Transient;
export class Container {
    #bindingManager;
    #containerModuleManager;
    #pluginManager;
    #serviceReferenceManager;
    #serviceResolutionManager;
    #snapshotManager;
    constructor(options) {
        const autobind = options?.autobind ?? false;
        const defaultScope = options?.defaultScope ?? DEFAULT_DEFAULT_SCOPE;
        this.#serviceReferenceManager = this.#buildServiceReferenceManager(options, autobind, defaultScope);
        const planParamsOperationsManager = new PlanParamsOperationsManager(this.#serviceReferenceManager);
        const planResultCacheManager = new PlanResultCacheManager(planParamsOperationsManager, this.#serviceReferenceManager);
        const deactivationParamsManager = new DeactivationParamsManager(this.#serviceReferenceManager);
        this.#bindingManager = new BindingManager(deactivationParamsManager.deactivationParams, defaultScope, planResultCacheManager, this.#serviceReferenceManager);
        this.#containerModuleManager = new ContainerModuleManager(this.#bindingManager, deactivationParamsManager.deactivationParams, defaultScope, planResultCacheManager, this.#serviceReferenceManager);
        this.#serviceResolutionManager = new ServiceResolutionManager(planParamsOperationsManager, this.#serviceReferenceManager, autobind, defaultScope);
        this.#pluginManager = new PluginManager(this, this.#serviceReferenceManager, this.#serviceResolutionManager);
        this.#snapshotManager = new SnapshotManager(this.#serviceReferenceManager);
    }
    bind(serviceIdentifier) {
        return this.#bindingManager.bind(serviceIdentifier);
    }
    get(serviceIdentifier, options) {
        return this.#serviceResolutionManager.get(serviceIdentifier, options);
    }
    getAll(serviceIdentifier, options) {
        return this.#serviceResolutionManager.getAll(serviceIdentifier, options);
    }
    async getAllAsync(serviceIdentifier, options) {
        return this.#serviceResolutionManager.getAllAsync(serviceIdentifier, options);
    }
    async getAsync(serviceIdentifier, options) {
        return this.#serviceResolutionManager.getAsync(serviceIdentifier, options);
    }
    isBound(serviceIdentifier, options) {
        return this.#bindingManager.isBound(serviceIdentifier, options);
    }
    isCurrentBound(serviceIdentifier, options) {
        return this.#bindingManager.isCurrentBound(serviceIdentifier, options);
    }
    async loadAsync(...modules) {
        return this.#containerModuleManager.loadAsync(...modules);
    }
    load(...modules) {
        this.#containerModuleManager.load(...modules);
    }
    onActivation(serviceIdentifier, activation) {
        this.#serviceReferenceManager.activationService.add(activation, {
            serviceId: serviceIdentifier,
        });
    }
    onDeactivation(serviceIdentifier, deactivation) {
        this.#serviceReferenceManager.deactivationService.add(deactivation, {
            serviceId: serviceIdentifier,
        });
    }
    register(pluginConstructor) {
        this.#pluginManager.register(this, pluginConstructor);
    }
    restore() {
        this.#snapshotManager.restore();
    }
    async rebindAsync(serviceIdentifier) {
        return this.#bindingManager.rebindAsync(serviceIdentifier);
    }
    rebind(serviceIdentifier) {
        return this.#bindingManager.rebind(serviceIdentifier);
    }
    snapshot() {
        this.#snapshotManager.snapshot();
    }
    async unbindAsync(identifier) {
        await this.#bindingManager.unbindAsync(identifier);
    }
    async unbindAllAsync() {
        await this.#bindingManager.unbindAllAsync();
    }
    unbindAll() {
        this.#bindingManager.unbindAll();
    }
    unbind(identifier) {
        this.#bindingManager.unbind(identifier);
    }
    async unloadAsync(...modules) {
        return this.#containerModuleManager.unloadAsync(...modules);
    }
    unload(...modules) {
        this.#containerModuleManager.unload(...modules);
    }
    #buildAutobindOptions(autobind, defaultScope) {
        if (autobind) {
            return { scope: defaultScope };
        }
        return undefined;
    }
    #buildServiceReferenceManager(options, autobind, defaultScope) {
        const autobindOptions = this.#buildAutobindOptions(autobind, defaultScope);
        if (options?.parent === undefined) {
            return new ServiceReferenceManager(ActivationsService.build(() => undefined), BindingService.build(() => undefined, autobindOptions), DeactivationsService.build(() => undefined), new PlanResultCacheService());
        }
        const planResultCacheService = new PlanResultCacheService();
        const parent = options.parent;
        parent.#serviceReferenceManager.planResultCacheService.subscribe(planResultCacheService);
        return new ServiceReferenceManager(ActivationsService.build(() => parent.#serviceReferenceManager.activationService), BindingService.build(() => parent.#serviceReferenceManager.bindingService, autobindOptions), DeactivationsService.build(() => parent.#serviceReferenceManager.deactivationService), planResultCacheService);
    }
}
//# sourceMappingURL=Container.js.map