@lakutata/core/build/base/Container.d.ts

Lakutata Framework Core

import { AsyncContainerModule, Container as InversifyContainer } from 'inversify';
import { IConstructor } from '../interfaces/IConstructor';
import { Module } from './abstracts/Module';
import { Component } from './abstracts/Component';
import { Plugin } from './Plugin';
import { BaseObject } from './BaseObject';
export declare class Container<TObject extends BaseObject = BaseObject, TPlugin extends Plugin = Plugin, TModule extends Module = Module, TComponent extends Component = Component> {
    private readonly eventEmitter;
    private readonly rootIoC;
    private readonly pluginIoC;
    private readonly objectIoC;
    private readonly componentIoC;
    private readonly moduleIoC;
    private readonly metadataReader;
    private readonly moduleMap;
    private readonly moduleBindingMap;
    private readonly componentMap;
    private readonly componentBindingMap;
    private readonly isInitializedSymbol;
    constructor();
    setParent(parentContainer: Container): void;
    protected bindAsync<T>(ioc: InversifyContainer, map: Map<IConstructor<T>, AsyncContainerModule[]>, bindingMap: Map<any, any>, constructor: IConstructor<T>, identifier: string | IConstructor<T>, initializerFunction: (this: T) => Promise<void>): void;
    bindPlugin(pluginConstructor: IConstructor<TPlugin>, identifier: string, config: object): void;
    bindObject(objectConstructor: IConstructor<TObject>, config?: object): void;
    bindModule(moduleConstructor: IConstructor<TModule>, config?: object, identifier?: string, callback?: () => void): void;
    bindComponent(componentConstructor: IConstructor<TComponent>, identifier: string, config?: object): void;
    getPlugin<TPlugin>(identifier: string): TPlugin;
    getObject<TObject>(objectConstructor: IConstructor<TObject>): TObject;
    hasObject(objectConstructor: IConstructor<TObject>): boolean;
    unbindObject(objectConstructor: IConstructor<TObject>): void;
    getModule<TModule>(identifier: string | IConstructor<TModule>): TModule;
    getComponent<TComponent>(identifier: string): TComponent;
    protected loadAsync<T>(ioc: InversifyContainer, map: Map<IConstructor<T>, AsyncContainerModule[]>, bindingMap: Map<any, any>): Promise<void>;
    loadModules(): Promise<void>;
    loadComponents(): Promise<void>;
    initialize(callbacks?: {
        componentsLoaded?: () => Promise<void>;
        modulesLoaded?: () => Promise<void>;
    }): Promise<void>;
    on(event: 'componentLoaded', listener: (componentId: string, componentConstructor: IConstructor<TComponent>, loadTime: number, subModuleId?: string) => void): this;
    on(event: 'moduleLoaded', listener: (moduleId: string, moduleConstructor: IConstructor<TModule>, loadTime: number, subModuleId?: string) => void): this;
    on(event: string, listener: (...args: any[]) => void): this;
}