molstar 3.26.0 → 3.28.0

package/lib/extensions/volumes-and-segmentations/external-api.js

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { __awaiter, __generator } from "tslib";
+import { splitEntryId } from './helpers';
+/** Try to get author-defined contour value for isosurface from EMDB API. Return relative value 1.0, if not applicable or fails.  */
+export function tryGetIsovalue(entryId) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var split, response, json, contours, theContour, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    split = splitEntryId(entryId);
+                    if (!(split.source === 'emdb')) return [3 /*break*/, 5];
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, fetch("https://www.ebi.ac.uk/emdb/api/entry/map/".concat(split.entryNumber))];
+                case 2:
+                    response = _d.sent();
+                    return [4 /*yield*/, response.json()];
+                case 3:
+                    json = _d.sent();
+                    contours = (_b = (_a = json === null || json === void 0 ? void 0 : json.map) === null || _a === void 0 ? void 0 : _a.contour_list) === null || _b === void 0 ? void 0 : _b.contour;
+                    if (contours && contours.length > 0) {
+                        theContour = contours.find(function (c) { return c.primary; }) || contours[0];
+                        if (theContour.level === undefined)
+                            throw new Error('EMDB API response missing contour level.');
+                        return [2 /*return*/, { kind: 'absolute', value: theContour.level }];
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    _c = _d.sent();
+                    return [3 /*break*/, 5];
+                case 5: return [2 /*return*/, undefined];
+            }
+        });
+    });
+}
+export function getPdbIdsForEmdbEntry(entryId) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function () {
+        var split, result, apiUrl, response, json, jsonEntry, _i, jsonEntry_1, record, pdbs, ex_1;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    split = splitEntryId(entryId);
+                    result = [];
+                    if (!(split.source === 'emdb')) return [3 /*break*/, 6];
+                    entryId = entryId.toUpperCase();
+                    apiUrl = "https://www.ebi.ac.uk/pdbe/api/emdb/entry/fitted/".concat(entryId);
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 5, , 6]);
+                    return [4 /*yield*/, fetch(apiUrl)];
+                case 2:
+                    response = _d.sent();
+                    if (!response.ok) return [3 /*break*/, 4];
+                    return [4 /*yield*/, response.json()];
+                case 3:
+                    json = _d.sent();
+                    jsonEntry = (_a = json[entryId]) !== null && _a !== void 0 ? _a : [];
+                    for (_i = 0, jsonEntry_1 = jsonEntry; _i < jsonEntry_1.length; _i++) {
+                        record = jsonEntry_1[_i];
+                        pdbs = (_c = (_b = record === null || record === void 0 ? void 0 : record.fitted_emdb_id_list) === null || _b === void 0 ? void 0 : _b.pdb_id) !== null && _c !== void 0 ? _c : [];
+                        result.push.apply(result, pdbs);
+                    }
+                    _d.label = 4;
+                case 4: return [3 /*break*/, 6];
+                case 5:
+                    ex_1 = _d.sent();
+                    return [3 /*break*/, 6];
+                case 6: return [2 /*return*/, result];
+            }
+        });
+    });
+}

package/lib/extensions/volumes-and-segmentations/global-state.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { BehaviorSubject } from 'rxjs';
+import { PluginStateObject } from '../../mol-plugin-state/objects';
+import { PluginBehavior } from '../../mol-plugin/behavior';
+import { PluginContext } from '../../mol-plugin/context';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+export declare const VolsegGlobalStateParams: {
+    tryUseGpu: PD.BooleanParam;
+    selectionMode: PD.BooleanParam;
+};
+export type VolsegGlobalStateParamValues = PD.Values<typeof VolsegGlobalStateParams>;
+declare const VolsegGlobalState_base: {
+    new (data: VolsegGlobalStateData, props?: {
+        label: string;
+        description?: string | undefined;
+    } | undefined): {
+        id: import("../../mol-util/uuid").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: VolsegGlobalStateData;
+    };
+    type: PluginStateObject.TypeInfo;
+    is(obj?: import("../../mol-state/object").StateObject<any, import("../../mol-state/object").StateObject.Type<any>> | undefined): obj is {
+        id: import("../../mol-util/uuid").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: VolsegGlobalStateData;
+    };
+};
+export declare class VolsegGlobalState extends VolsegGlobalState_base {
+}
+export declare class VolsegGlobalStateData extends PluginBehavior.WithSubscribers<VolsegGlobalStateParamValues> {
+    private ref;
+    currentState: BehaviorSubject<PD.Values<{
+        tryUseGpu: PD.BooleanParam;
+        selectionMode: PD.BooleanParam;
+    }>>;
+    constructor(plugin: PluginContext, params: VolsegGlobalStateParamValues);
+    register(ref: string): void;
+    unregister(): void;
+    isRegistered(): boolean;
+    updateState(plugin: PluginContext, state: Partial<VolsegGlobalStateParamValues>): Promise<void>;
+    static getGlobalState(plugin: PluginContext): VolsegGlobalStateParamValues | undefined;
+}
+export {};

package/lib/extensions/volumes-and-segmentations/global-state.js

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { __awaiter, __extends, __generator } from "tslib";
+import { BehaviorSubject } from 'rxjs';
+import { PluginStateObject } from '../../mol-plugin-state/objects';
+import { PluginBehavior } from '../../mol-plugin/behavior';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { VolsegEntry } from './entry-root';
+import { isDefined } from './helpers';
+export var VolsegGlobalStateParams = {
+    tryUseGpu: PD.Boolean(true, { description: 'Attempt using GPU for faster rendering. \nCaution: with some hardware setups, this might render some objects incorrectly or not at all.' }),
+    selectionMode: PD.Boolean(true, { description: 'Allow selecting/deselecting a segment by clicking on it.' }),
+};
+var VolsegGlobalState = /** @class */ (function (_super) {
+    __extends(VolsegGlobalState, _super);
+    function VolsegGlobalState() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return VolsegGlobalState;
+}(PluginStateObject.CreateBehavior({ name: 'Vol & Seg Global State' })));
+export { VolsegGlobalState };
+var VolsegGlobalStateData = /** @class */ (function (_super) {
+    __extends(VolsegGlobalStateData, _super);
+    function VolsegGlobalStateData(plugin, params) {
+        var _this = _super.call(this, plugin, params) || this;
+        _this.currentState = new BehaviorSubject(PD.getDefaultValues(VolsegGlobalStateParams));
+        _this.currentState.next(params);
+        return _this;
+    }
+    VolsegGlobalStateData.prototype.register = function (ref) {
+        this.ref = ref;
+    };
+    VolsegGlobalStateData.prototype.unregister = function () {
+        this.ref = '';
+    };
+    VolsegGlobalStateData.prototype.isRegistered = function () {
+        return this.ref !== '';
+    };
+    VolsegGlobalStateData.prototype.updateState = function (plugin, state) {
+        return __awaiter(this, void 0, void 0, function () {
+            var oldState, promises, allEntries, _i, allEntries_1, entry, _a, allEntries_2, entry;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        oldState = this.currentState.value;
+                        promises = [];
+                        allEntries = plugin.state.data.selectQ(function (q) { return q.ofType(VolsegEntry); }).map(function (cell) { var _a; return (_a = cell.obj) === null || _a === void 0 ? void 0 : _a.data; }).filter(isDefined);
+                        if (state.tryUseGpu !== undefined && state.tryUseGpu !== oldState.tryUseGpu) {
+                            for (_i = 0, allEntries_1 = allEntries; _i < allEntries_1.length; _i++) {
+                                entry = allEntries_1[_i];
+                                promises.push(entry.setTryUseGpu(state.tryUseGpu));
+                            }
+                        }
+                        if (state.selectionMode !== undefined && state.selectionMode !== oldState.selectionMode) {
+                            for (_a = 0, allEntries_2 = allEntries; _a < allEntries_2.length; _a++) {
+                                entry = allEntries_2[_a];
+                                promises.push(entry.setSelectionMode(state.selectionMode));
+                            }
+                        }
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1:
+                        _b.sent();
+                        return [4 /*yield*/, plugin.build().to(this.ref).update(state).commit()];
+                    case 2:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegGlobalStateData.getGlobalState = function (plugin) {
+        var _a, _b;
+        return (_b = (_a = plugin.state.data.selectQ(function (q) { return q.ofType(VolsegGlobalState); })[0]) === null || _a === void 0 ? void 0 : _a.obj) === null || _b === void 0 ? void 0 : _b.data.currentState.value;
+    };
+    return VolsegGlobalStateData;
+}(PluginBehavior.WithSubscribers));
+export { VolsegGlobalStateData };

package/lib/extensions/volumes-and-segmentations/helpers.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { Volume } from '../../mol-model/volume';
+import { PluginStateObject } from '../../mol-plugin-state/objects';
+import { StateBuilder, StateObjectSelector, StateTransformer } from '../../mol-state';
+import { ParamDefinition } from '../../mol-util/param-definition';
+import { Source } from './entry-root';
+/** Split entry ID (e.g. 'emd-1832') into source ('emdb') and number ('1832') */
+export declare function splitEntryId(entryId: string): {
+    source: "emdb" | "empiar" | "idr";
+    entryNumber: string;
+};
+/** Create entry ID (e.g. 'emd-1832') for a combination of source ('emdb') and number ('1832') */
+export declare function createEntryId(source: Source, entryNumber: string | number): string;
+/**
+ * Represents a set of values to choose from, with a default value. Example:
+ * ```
+ * export const MyChoice = new Choice({ yes: 'I agree', no: 'Nope' }, 'yes');
+ * export type MyChoiceType = Choice.Values<typeof MyChoice>; // 'yes'|'no'
+ * ```
+ */
+export declare class Choice<T extends string, D extends T> {
+    readonly defaultValue: D;
+    readonly options: [T, string][];
+    private readonly nameDict;
+    constructor(opts: {
+        [value in T]: string;
+    }, defaultValue: D);
+    PDSelect(defaultValue?: T, info?: ParamDefinition.Info): ParamDefinition.Select<T>;
+    prettyName(value: T): string;
+    get values(): T[];
+}
+export declare namespace Choice {
+    type Values<T extends Choice<any, any>> = T extends Choice<infer R, any> ? R : any;
+}
+export declare function isDefined<T>(x: T | undefined): x is T;
+export declare class NodeManager {
+    private nodes;
+    constructor();
+    private static nodeExists;
+    getNode(key: string): StateObjectSelector | undefined;
+    getNodes(): StateObjectSelector[];
+    deleteAllNodes(update: StateBuilder.Root): void;
+    hideAllNodes(): void;
+    showNode(key: string, factory: () => StateObjectSelector | Promise<StateObjectSelector>, forceVisible?: boolean): Promise<StateObjectSelector<import("../../mol-state/object").StateObject<any, import("../../mol-state/object").StateObject.Type<any>>, StateTransformer<import("../../mol-state/object").StateObject<any, import("../../mol-state/object").StateObject.Type<any>>, import("../../mol-state/object").StateObject<any, import("../../mol-state/object").StateObject.Type<any>>, any>>>;
+}
+export declare const CreateVolume: StateTransformer<PluginStateObject.Root, PluginStateObject.Volume.Data, ParamDefinition.Normalize<{
+    label: string;
+    description: string;
+    volume: Volume;
+}>>;
+export declare function applyEllipsis(name: string, max_chars?: number): string;
+export declare function lazyGetter<T>(getter: () => T, errorIfUndefined?: string): () => T;

package/lib/extensions/volumes-and-segmentations/helpers.js

@@ -0,0 +1,163 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { __awaiter, __generator } from "tslib";
+import { PluginStateObject } from '../../mol-plugin-state/objects';
+import { setSubtreeVisibility } from '../../mol-plugin/behavior/static/state';
+import { StateTransformer } from '../../mol-state';
+import { ParamDefinition } from '../../mol-util/param-definition';
+/** Split entry ID (e.g. 'emd-1832') into source ('emdb') and number ('1832') */
+export function splitEntryId(entryId) {
+    var _a;
+    var PREFIX_TO_SOURCE = { 'emd': 'emdb' };
+    var _b = entryId.split('-'), prefix = _b[0], entry = _b[1];
+    return {
+        source: (_a = PREFIX_TO_SOURCE[prefix]) !== null && _a !== void 0 ? _a : prefix,
+        entryNumber: entry
+    };
+}
+/** Create entry ID (e.g. 'emd-1832') for a combination of source ('emdb') and number ('1832') */
+export function createEntryId(source, entryNumber) {
+    var _a;
+    var SOURCE_TO_PREFIX = { 'emdb': 'emd' };
+    var prefix = (_a = SOURCE_TO_PREFIX[source]) !== null && _a !== void 0 ? _a : source;
+    return "".concat(prefix, "-").concat(entryNumber);
+}
+/**
+ * Represents a set of values to choose from, with a default value. Example:
+ * ```
+ * export const MyChoice = new Choice({ yes: 'I agree', no: 'Nope' }, 'yes');
+ * export type MyChoiceType = Choice.Values<typeof MyChoice>; // 'yes'|'no'
+ * ```
+ */
+var Choice = /** @class */ (function () {
+    function Choice(opts, defaultValue) {
+        this.defaultValue = defaultValue;
+        this.options = Object.keys(opts).map(function (k) { return [k, opts[k]]; });
+        this.nameDict = opts;
+    }
+    Choice.prototype.PDSelect = function (defaultValue, info) {
+        return ParamDefinition.Select(defaultValue !== null && defaultValue !== void 0 ? defaultValue : this.defaultValue, this.options, info);
+    };
+    Choice.prototype.prettyName = function (value) {
+        return this.nameDict[value];
+    };
+    Object.defineProperty(Choice.prototype, "values", {
+        get: function () {
+            return this.options.map(function (_a) {
+                var value = _a[0], pretty = _a[1];
+                return value;
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Choice;
+}());
+export { Choice };
+export function isDefined(x) {
+    return x !== undefined;
+}
+var NodeManager = /** @class */ (function () {
+    function NodeManager() {
+        this.nodes = {};
+    }
+    NodeManager.nodeExists = function (node) {
+        try {
+            return node.checkValid();
+        }
+        catch (_a) {
+            return false;
+        }
+    };
+    NodeManager.prototype.getNode = function (key) {
+        var node = this.nodes[key];
+        if (node && !NodeManager.nodeExists(node)) {
+            delete this.nodes[key];
+            return undefined;
+        }
+        return node;
+    };
+    NodeManager.prototype.getNodes = function () {
+        var _this = this;
+        return Object.keys(this.nodes).map(function (key) { return _this.getNode(key); }).filter(function (node) { return node; });
+    };
+    NodeManager.prototype.deleteAllNodes = function (update) {
+        for (var _i = 0, _a = this.getNodes(); _i < _a.length; _i++) {
+            var node = _a[_i];
+            update.delete(node);
+        }
+        this.nodes = {};
+    };
+    NodeManager.prototype.hideAllNodes = function () {
+        for (var _i = 0, _a = this.getNodes(); _i < _a.length; _i++) {
+            var node = _a[_i];
+            setSubtreeVisibility(node.state, node.ref, true); // hide
+        }
+    };
+    NodeManager.prototype.showNode = function (key, factory, forceVisible) {
+        if (forceVisible === void 0) { forceVisible = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var node;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(key);
+                        if (!node) return [3 /*break*/, 1];
+                        if (forceVisible) {
+                            setSubtreeVisibility(node.state, node.ref, false); // show
+                        }
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, factory()];
+                    case 2:
+                        node = _a.sent();
+                        this.nodes[key] = node;
+                        _a.label = 3;
+                    case 3: return [2 /*return*/, node];
+                }
+            });
+        });
+    };
+    return NodeManager;
+}());
+export { NodeManager };
+var CreateTransformer = StateTransformer.builderFactory('volseg');
+export var CreateVolume = CreateTransformer({
+    name: 'create-transformer',
+    from: PluginStateObject.Root,
+    to: PluginStateObject.Volume.Data,
+    params: {
+        label: ParamDefinition.Text('Volume', { isHidden: true }),
+        description: ParamDefinition.Text('', { isHidden: true }),
+        volume: ParamDefinition.Value(undefined, { isHidden: true }),
+    }
+})({
+    apply: function (_a) {
+        var params = _a.params;
+        return new PluginStateObject.Volume.Data(params.volume, { label: params.label, description: params.description });
+    }
+});
+export function applyEllipsis(name, max_chars) {
+    if (max_chars === void 0) { max_chars = 60; }
+    if (name.length <= max_chars)
+        return name;
+    var beginning = name.substring(0, max_chars);
+    var lastSpace = beginning.lastIndexOf(' ');
+    if (lastSpace === -1)
+        return beginning + '...';
+    if (lastSpace > 0 && ',;.'.includes(name.charAt(lastSpace - 1)))
+        lastSpace--;
+    return name.substring(0, lastSpace) + '...';
+}
+export function lazyGetter(getter, errorIfUndefined) {
+    var value = undefined;
+    return function () {
+        if (value === undefined)
+            value = getter();
+        if (errorIfUndefined && value === undefined)
+            throw new Error(errorIfUndefined);
+        return value;
+    };
+}

package/lib/extensions/volumes-and-segmentations/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { PluginStateObject as SO } from '../../mol-plugin-state/objects';
+import { PluginBehavior } from '../../mol-plugin/behavior';
+import { PluginConfigItem } from '../../mol-plugin/config';
+import { StateAction } from '../../mol-state';
+export declare const VolsegVolumeServerConfig: {
+    DefaultServer: PluginConfigItem<string>;
+};
+export declare const Volseg: import("../../mol-state/transformer").StateTransformer<PluginBehavior.Category, PluginBehavior.Behavior, {
+    autoAttach: boolean;
+    showTooltip: boolean;
+}>;
+export declare const LoadVolseg: StateAction<SO.Root, void, import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+    serverUrl: string;
+    source: import("../../mol-util/param-definition").ParamDefinition.NamedParams<unknown, string>;
+}>>;

package/lib/extensions/volumes-and-segmentations/index.js

@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { __awaiter, __extends, __generator } from "tslib";
+import { PluginStateObject as SO } from '../../mol-plugin-state/objects';
+import { PluginBehavior } from '../../mol-plugin/behavior';
+import { PluginConfigItem } from '../../mol-plugin/config';
+import { StateAction } from '../../mol-state';
+import { Task } from '../../mol-task';
+import { DEFAULT_VOLSEG_SERVER, VolumeApiV2 } from './volseg-api/api';
+import { VolsegEntryData, VolsegEntryParamValues, createLoadVolsegParams } from './entry-root';
+import { VolsegGlobalState } from './global-state';
+import { createEntryId } from './helpers';
+import { VolsegEntryFromRoot, VolsegGlobalStateFromRoot, VolsegStateFromEntry } from './transformers';
+import { VolsegUI } from './ui';
+var DEBUGGING = window.location.hostname === 'localhost';
+export var VolsegVolumeServerConfig = {
+    // DefaultServer: new PluginConfigItem('volseg-volume-server', DEFAULT_VOLUME_SERVER_V2),
+    DefaultServer: new PluginConfigItem('volseg-volume-server', DEBUGGING ? 'http://localhost:9000/v2' : DEFAULT_VOLSEG_SERVER),
+};
+export var Volseg = PluginBehavior.create({
+    name: 'volseg',
+    category: 'misc',
+    display: {
+        name: 'Volseg',
+        description: 'Volseg'
+    },
+    ctor: /** @class */ (function (_super) {
+        __extends(class_1, _super);
+        function class_1() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        class_1.prototype.register = function () {
+            this.ctx.state.data.actions.add(LoadVolseg);
+            this.ctx.customStructureControls.set('volseg', VolsegUI);
+            this.initializeEntryLists(); // do not await
+            var entries = new Map();
+            this.subscribeObservable(this.ctx.state.data.events.cell.created, function (o) {
+                if (o.cell.obj instanceof VolsegEntryData)
+                    entries.set(o.ref, o.cell.obj);
+            });
+            this.subscribeObservable(this.ctx.state.data.events.cell.removed, function (o) {
+                if (entries.has(o.ref)) {
+                    entries.get(o.ref).dispose();
+                    entries.delete(o.ref);
+                }
+            });
+        };
+        class_1.prototype.unregister = function () {
+            this.ctx.state.data.actions.remove(LoadVolseg);
+            this.ctx.customStructureControls.delete('volseg');
+        };
+        class_1.prototype.initializeEntryLists = function () {
+            var _a;
+            return __awaiter(this, void 0, void 0, function () {
+                var apiUrl, api, entryLists;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            apiUrl = (_a = this.ctx.config.get(VolsegVolumeServerConfig.DefaultServer)) !== null && _a !== void 0 ? _a : DEFAULT_VOLSEG_SERVER;
+                            api = new VolumeApiV2(apiUrl);
+                            return [4 /*yield*/, api.getEntryList(Math.pow(10, 6))];
+                        case 1:
+                            entryLists = _b.sent();
+                            Object.values(entryLists).forEach(function (l) { return l.sort(); });
+                            this.ctx.customState.volsegAvailableEntries = entryLists;
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return class_1;
+    }(PluginBehavior.Handler))
+});
+export var LoadVolseg = StateAction.build({
+    display: { name: 'Load Volume & Segmentation' },
+    from: SO.Root,
+    params: function (a, plugin) {
+        var res = createLoadVolsegParams(plugin, plugin.customState.volsegAvailableEntries);
+        return res;
+    },
+})(function (_a, ctx) {
+    var params = _a.params, state = _a.state;
+    return Task.create('Loading Volume & Segmentation', function (taskCtx) {
+        return state.transaction(function () { return __awaiter(void 0, void 0, void 0, function () {
+            var entryParams, globalStateNode, entryNode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        entryParams = VolsegEntryParamValues.fromLoadVolsegParamValues(params);
+                        if (entryParams.entryId.trim().length === 0) {
+                            alert('Must specify Entry Id!');
+                            throw new Error('Specify Entry Id');
+                        }
+                        if (!entryParams.entryId.includes('-')) {
+                            // add source prefix if the user omitted it (e.g. 1832 -> emd-1832)
+                            entryParams.entryId = createEntryId(entryParams.source, entryParams.entryId);
+                        }
+                        ctx.behaviors.layout.leftPanelTabName.next('data');
+                        globalStateNode = ctx.state.data.selectQ(function (q) { return q.ofType(VolsegGlobalState); })[0];
+                        if (!!globalStateNode) return [3 /*break*/, 2];
+                        return [4 /*yield*/, state.build().toRoot().apply(VolsegGlobalStateFromRoot, {}, { state: { isGhost: !DEBUGGING } }).commit()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, state.build().toRoot().apply(VolsegEntryFromRoot, entryParams).commit()];
+                    case 3:
+                        entryNode = _a.sent();
+                        return [4 /*yield*/, state.build().to(entryNode).apply(VolsegStateFromEntry, {}, { state: { isGhost: !DEBUGGING } }).commit()];
+                    case 4:
+                        _a.sent();
+                        if (!entryNode.data) return [3 /*break*/, 7];
+                        return [4 /*yield*/, entryNode.data.loadVolume()];
+                    case 5:
+                        _a.sent();
+                        return [4 /*yield*/, entryNode.data.loadSegmentations()];
+                    case 6:
+                        _a.sent();
+                        _a.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); }).runInContext(taskCtx);
+    });
+});

package/lib/extensions/volumes-and-segmentations/transformers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { PluginStateObject } from '../../mol-plugin-state/objects';
+import { StateTransformer } from '../../mol-state';
+import { VolsegEntry } from './entry-root';
+import { VolsegState } from './entry-state';
+import { VolsegGlobalState } from './global-state';
+export declare const VolsegEntryFromRoot: StateTransformer<PluginStateObject.Root, VolsegEntry, import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+    serverUrl: string;
+    source: "emdb" | "empiar" | "idr";
+    entryId: string;
+}>>;
+export declare const VolsegStateFromEntry: StateTransformer<VolsegEntry, VolsegState, import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+    volumeType: "off" | "direct-volume" | "isosurface";
+    volumeIsovalueKind: string;
+    volumeIsovalueValue: number;
+    volumeOpacity: number;
+    segmentOpacity: number;
+    selectedSegment: number;
+    visibleSegments: import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+        segmentId: any;
+    }>[];
+    visibleModels: import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+        pdbId: any;
+    }>[];
+}>>;
+export declare const VolsegGlobalStateFromRoot: StateTransformer<PluginStateObject.Root, VolsegGlobalState, import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+    tryUseGpu: boolean;
+    selectionMode: boolean;
+}>>;