Class ModuleRegistry

packages/dockview-core/src/dockview/modules.ts:131–201

}

export class ModuleRegistry<THost> implements IDisposable {
    private readonly _modules = new Map<string, DockviewModule<any>>();
    private readonly _services: ServiceCollection = {};
    private readonly _initDisposables: IDisposable[] = [];

    get services(): ServiceCollection {
        return this._services;
    }

    register<H>(module: DockviewModule<H>): void {
        if (this._modules.has(module.moduleName)) {
            return;
        }
        if (module.dependsOn) {
            for (const dep of module.dependsOn) {
                this.register(dep);
            }
        }
        this._modules.set(module.moduleName, module);
    }

    initialize(host: THost): void {
        for (const module of this._modules.values()) {
            if (!module.services) {
                continue;
            }
            for (const [name, factory] of Object.entries(module.services)) {
                (this._services as Record<string, unknown>)[name] = (
                    factory as (h: THost) => unknown
                )(host);
            }
        }
    }

    postConstruct(host: THost): void {
        for (const module of this._modules.values()) {
            if (module.init) {
                this._initDisposables.push(
                    (
                        module.init as (
                            h: THost,
                            s: ServiceCollection
                        ) => IDisposable
                    )(host, this._services)
                );
            }
        }
    }

    has(moduleName: string): boolean {
        return this._modules.has(moduleName);
    }

    dispose(): void {
        // Tear down init() subscriptions first so they stop firing into
        // services that are about to be disposed.
        for (const disposable of this._initDisposables) {
            disposable.dispose();