@jbrowse/core/assemblyManager/assemblyManager.js

JBrowse 2 core libraries used by plugins

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const mobx_1 = require("mobx");
const mobx_state_tree_1 = require("mobx-state-tree");
const configuration_1 = require("../configuration");
const util_1 = require("../util");
const assembly_1 = __importDefault(require("./assembly"));
function assemblyManagerFactory(conf, pm) {
    return mobx_state_tree_1.types
        .model({
        assemblies: mobx_state_tree_1.types.array((0, assembly_1.default)(conf, pm)),
    })
        .views(self => ({
        get assemblyNameMap() {
            const obj = {};
            for (const assembly of self.assemblies) {
                for (const name of assembly.allAliases) {
                    obj[name] = assembly;
                }
            }
            return obj;
        },
    }))
        .views(self => ({
        getCanonicalAssemblyName(asmName) {
            var _a;
            return (_a = self.assemblyNameMap[asmName]) === null || _a === void 0 ? void 0 : _a.name;
        },
        get(asmName) {
            if (asmName) {
                const assembly = self.assemblyNameMap[asmName];
                if (assembly) {
                    return assembly;
                }
                else if (!this.assemblyNamesList.includes(asmName)) {
                    pm.evaluateExtensionPoint('Core-handleUnrecognizedAssembly', undefined, {
                        assemblyName: asmName,
                        session: (0, mobx_state_tree_1.getParent)(self).session,
                    });
                }
            }
            return undefined;
        },
        get assemblyNamesList() {
            return this.assemblyList.map(asm => asm.name);
        },
        get assemblyList() {
            const { jbrowse: { assemblies }, session: { sessionAssemblies = [], temporaryAssemblies = [] } = {}, } = (0, mobx_state_tree_1.getParent)(self);
            return [
                ...assemblies,
                ...sessionAssemblies,
                ...temporaryAssemblies,
            ];
        },
        get rpcManager() {
            return (0, mobx_state_tree_1.getParent)(self).rpcManager;
        },
    }))
        .views(self => ({
        async waitForAssembly(assemblyName) {
            if (!assemblyName) {
                throw new Error('no assembly name supplied to waitForAssembly');
            }
            let assembly = self.get(assemblyName);
            if (!assembly) {
                try {
                    await (0, util_1.when)(() => Boolean(self.get(assemblyName)), {
                        timeout: 10000,
                    });
                    assembly = self.get(assemblyName);
                }
                catch (e) {
                }
            }
            if (!assembly) {
                return undefined;
            }
            await assembly.load();
            await (0, util_1.when)(() => !!(assembly.regions && assembly.refNameAliases) || !!assembly.error);
            if (assembly.error) {
                throw assembly.error;
            }
            return assembly;
        },
        async getRefNameMapForAdapter(adapterConf, assemblyName, opts) {
            if (assemblyName) {
                const asm = await this.waitForAssembly(assemblyName);
                return asm === null || asm === void 0 ? void 0 : asm.getRefNameMapForAdapter(adapterConf, opts);
            }
            return {};
        },
        async getReverseRefNameMapForAdapter(adapterConf, assemblyName, opts) {
            if (assemblyName) {
                const asm = await this.waitForAssembly(assemblyName);
                return asm === null || asm === void 0 ? void 0 : asm.getReverseRefNameMapForAdapter(adapterConf, opts);
            }
            return {};
        },
        isValidRefName(refName, assemblyName) {
            const assembly = self.get(assemblyName);
            if (assembly) {
                return assembly.isValidRefName(refName);
            }
            throw new Error(`Failed to look up refName:${refName} on assemblyName:${assemblyName} (assembly does not exist)`);
        },
    }))
        .actions(self => ({
        afterAttach() {
            (0, mobx_state_tree_1.addDisposer)(self, (0, mobx_1.reaction)(() => self.assemblyList, assemblyConfs => {
                for (const asm of self.assemblies) {
                    if (!asm.configuration) {
                        this.removeAssembly(asm);
                    }
                }
                for (const conf of assemblyConfs) {
                    const name = (0, configuration_1.readConfObject)(conf, 'name');
                    if (!self.assemblies.some(a => a.name === name)) {
                        this.addAssembly(conf);
                    }
                }
            }, { fireImmediately: true, name: 'assemblyManagerAfterAttach' }));
        },
        removeAssembly(asm) {
            self.assemblies.remove(asm);
        },
        addAssembly(configuration) {
            self.assemblies.push({ configuration });
        },
    }));
}
exports.default = assemblyManagerFactory;