molstar 3.26.0 → 3.28.0

package/lib/commonjs/extensions/meshes/metadata.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { Color } from '../../mol-util/color';
+export interface Metadata {
+    grid: {
+        general: {
+            details: string;
+        };
+        volumes: Volumes;
+        segmentation_lattices: SegmentationLattices;
+        segmentation_meshes: SegmentationMeshes;
+    };
+    annotation: Annotation;
+}
+export interface Volumes {
+    volume_downsamplings: number[];
+    voxel_size: {
+        [downsampling: number]: Vector3;
+    };
+    origin: Vector3;
+    grid_dimensions: Vector3;
+    sampled_grid_dimensions: {
+        [downsampling: number]: Vector3;
+    };
+    mean: {
+        [downsampling: number]: number;
+    };
+    std: {
+        [downsampling: number]: number;
+    };
+    min: {
+        [downsampling: number]: number;
+    };
+    max: {
+        [downsampling: number]: number;
+    };
+    volume_force_dtype: string;
+}
+export interface SegmentationLattices {
+    segmentation_lattice_ids: number[];
+    segmentation_downsamplings: {
+        [lattice: number]: number[];
+    };
+}
+export interface Annotation {
+    name: string;
+    details: string;
+    segment_list: Segment[];
+}
+export interface Segment {
+    id: number;
+    colour: number[];
+    biological_annotation: BiologicalAnnotation;
+}
+export interface BiologicalAnnotation {
+    name: string;
+    external_references: {
+        id: number;
+        resource: string;
+        accession: string;
+        label: string;
+        description: string;
+    }[];
+}
+export interface SegmentationMeshes {
+    mesh_component_numbers: {
+        segment_ids?: {
+            [segId: number]: {
+                detail_lvls: {
+                    [detail: number]: {
+                        mesh_ids: {
+                            [meshId: number]: {
+                                num_triangles: number;
+                                num_vertices: number;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    detail_lvl_to_fraction: {
+        [lvl: number]: number;
+    };
+}
+type Vector3 = [number, number, number];
+export declare namespace Metadata {
+    function meshSegments(metadata: Metadata): number[];
+    function meshSegmentDetails(metadata: Metadata, segmentId: number): number[];
+    /** Get the worst available detail level that is not worse than preferredDetail.
+     * If preferredDetail is null, get the worst detail level overall.
+     * (worse = greater number) */
+    function getSufficientDetail(metadata: Metadata, segmentId: number, preferredDetail: number | null): number;
+    function annotationsBySegment(metadata: Metadata): {
+        [id: number]: Segment;
+    };
+    function dropSegments(metadata: Metadata, segments: number[]): void;
+    function namesAndColorsBySegment(metadata: Metadata): {
+        [id: number]: {
+            name: string;
+            color: Color;
+        };
+    };
+}
+export {};

package/lib/commonjs/extensions/meshes/metadata.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Metadata = void 0;
+var color_1 = require("../../mol-util/color");
+var Metadata;
+(function (Metadata) {
+    function meshSegments(metadata) {
+        var segmentIds = metadata.grid.segmentation_meshes.mesh_component_numbers.segment_ids;
+        if (segmentIds === undefined)
+            return [];
+        return Object.keys(segmentIds).map(function (s) { return parseInt(s); });
+    }
+    Metadata.meshSegments = meshSegments;
+    function meshSegmentDetails(metadata, segmentId) {
+        var segmentIds = metadata.grid.segmentation_meshes.mesh_component_numbers.segment_ids;
+        if (segmentIds === undefined)
+            return [];
+        var details = segmentIds[segmentId].detail_lvls;
+        return Object.keys(details).map(function (s) { return parseInt(s); });
+    }
+    Metadata.meshSegmentDetails = meshSegmentDetails;
+    /** Get the worst available detail level that is not worse than preferredDetail.
+     * If preferredDetail is null, get the worst detail level overall.
+     * (worse = greater number) */
+    function getSufficientDetail(metadata, segmentId, preferredDetail) {
+        var availDetails = meshSegmentDetails(metadata, segmentId);
+        if (preferredDetail !== null) {
+            availDetails = availDetails.filter(function (det) { return det <= preferredDetail; });
+        }
+        return Math.max.apply(Math, availDetails);
+    }
+    Metadata.getSufficientDetail = getSufficientDetail;
+    function annotationsBySegment(metadata) {
+        var result = {};
+        for (var _i = 0, _a = metadata.annotation.segment_list; _i < _a.length; _i++) {
+            var segment = _a[_i];
+            if (segment.id in result) {
+                throw new Error("Duplicate segment annotation for segment ".concat(segment.id));
+            }
+            result[segment.id] = segment;
+        }
+        return result;
+    }
+    Metadata.annotationsBySegment = annotationsBySegment;
+    function dropSegments(metadata, segments) {
+        if (metadata.grid.segmentation_meshes.mesh_component_numbers.segment_ids === undefined)
+            return;
+        var dropSet = new Set(segments);
+        metadata.annotation.segment_list = metadata.annotation.segment_list.filter(function (seg) { return !dropSet.has(seg.id); });
+        for (var _i = 0, segments_1 = segments; _i < segments_1.length; _i++) {
+            var seg = segments_1[_i];
+            delete metadata.grid.segmentation_meshes.mesh_component_numbers.segment_ids[seg];
+        }
+    }
+    Metadata.dropSegments = dropSegments;
+    function namesAndColorsBySegment(metadata) {
+        var result = {};
+        for (var _i = 0, _a = metadata.annotation.segment_list; _i < _a.length; _i++) {
+            var segment = _a[_i];
+            if (segment.id in result)
+                throw new Error("Duplicate segment annotation for segment ".concat(segment.id));
+            result[segment.id] = { name: segment.biological_annotation.name, color: color_1.Color.fromNormalizedArray(segment.colour, 0) };
+        }
+        return result;
+    }
+    Metadata.namesAndColorsBySegment = namesAndColorsBySegment;
+})(Metadata = exports.Metadata || (exports.Metadata = {}));

package/lib/commonjs/extensions/model-archive/quality-assessment/behavior.d.ts

@@ -12,6 +12,7 @@ export declare const MAQualityAssessment: import("../../../mol-state/transformer
 }>;
 export declare const QualityAssessmentPLDDTPreset: StructureRepresentationPresetProvider<{
     ignoreHydrogens: boolean | undefined;
+    ignoreHydrogensVariant: "all" | "non-polar" | undefined;
     ignoreLight: boolean | undefined;
     quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined;
     theme: PD.Normalize<{
@@ -43,6 +44,7 @@ export declare const QualityAssessmentPLDDTPreset: StructureRepresentationPreset
 }>;
 export declare const QualityAssessmentQmeanPreset: StructureRepresentationPresetProvider<{
     ignoreHydrogens: boolean | undefined;
+    ignoreHydrogensVariant: "all" | "non-polar" | undefined;
     ignoreLight: boolean | undefined;
     quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined;
     theme: PD.Normalize<{

package/lib/commonjs/extensions/model-archive/quality-assessment/prop.d.ts

@@ -2,6 +2,7 @@
  * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author David Sehnal <david.sehnal@gmail.com>
  */
 import { ParamDefinition as PD } from '../../../mol-util/param-definition';
 import { CustomProperty } from '../../../mol-model-props/common/custom-property';

package/lib/commonjs/extensions/model-archive/quality-assessment/prop.js

@@ -3,6 +3,7 @@
  * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author David Sehnal <david.sehnal@gmail.com>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QualityAssessmentProvider = exports.QualityAssessmentParams = exports.QualityAssessment = void 0;
@@ -44,7 +45,7 @@ var QualityAssessment;
     QualityAssessment.isApplicable = isApplicable;
     function obtain(ctx, model, props) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, ma_qa_metric, ma_qa_metric_local, model_id, label_asym_id, label_seq_id, metric_id, metric_value, index, localMetrics, localNames, i, il, name_1, i, il, labelAsymId, entityIndex, rI, name_2;
+            var _a, ma_qa_metric, ma_qa_metric_local, model_id, label_asym_id, label_seq_id, metric_id, metric_value, index, localMetrics, localNames, i, il, name_1, residueKey, i, il, labelAsymId, entityIndex, rI, name_2;
             return tslib_1.__generator(this, function (_b) {
                 if (!model || !mmcif_1.MmcifFormat.is(model.sourceData))
                     return [2 /*return*/, Empty];
@@ -64,14 +65,25 @@ var QualityAssessment;
                     localMetrics.set(name_1, new Map());
                     localNames.set(ma_qa_metric.id.value(i), name_1);
                 }
+                residueKey = {
+                    label_entity_id: '',
+                    label_asym_id: '',
+                    label_seq_id: 0,
+                    pdbx_PDB_ins_code: undefined,
+                };
                 for (i = 0, il = ma_qa_metric_local._rowCount; i < il; i++) {
                     if (model_id.value(i) !== model.modelNum)
                         continue;
                     labelAsymId = label_asym_id.value(i);
                     entityIndex = index.findEntity(labelAsymId);
-                    rI = index.findResidue(model.entities.data.id.value(entityIndex), labelAsymId, label_seq_id.value(i));
-                    name_2 = localNames.get(metric_id.value(i));
-                    localMetrics.get(name_2).set(rI, metric_value.value(i));
+                    residueKey.label_entity_id = model.entities.data.id.value(entityIndex);
+                    residueKey.label_asym_id = labelAsymId;
+                    residueKey.label_seq_id = label_seq_id.value(i);
+                    rI = index.findResidueLabel(residueKey);
+                    if (rI >= 0) {
+                        name_2 = localNames.get(metric_id.value(i));
+                        localMetrics.get(name_2).set(rI, metric_value.value(i));
+                    }
                 }
                 return [2 /*return*/, {
                         value: {

package/lib/commonjs/extensions/rcsb/assembly-symmetry/behavior.d.ts

@@ -45,13 +45,14 @@ declare const AssemblySymmetry3D: StateTransformer<PluginStateObject.Molecule.St
 }>>;
 export declare const AssemblySymmetryPresetParams: {
     ignoreHydrogens: PD.Base<boolean | undefined>;
+    ignoreHydrogensVariant: PD.Base<"all" | "non-polar" | undefined>;
     ignoreLight: PD.Base<boolean | undefined>;
     quality: PD.Base<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined>;
     theme: PD.Base<PD.Normalize<{
-        globalName: "uniform" | "occupancy" | "element-index" | "element-symbol" | "hydrophobicity" | "shape-group" | "uncertainty" | "carbohydrate-symbol" | "chain-id" | "operator-name" | "entity-id" | "entity-source" | "model-index" | "structure-index" | "molecule-type" | "polymer-id" | "polymer-index" | "residue-name" | "secondary-structure" | "sequence-id" | "unit-index" | "illustrative" | "trajectory-index" | "operator-hkl" | "partial-charge" | "atom-id" | "volume-value" | "external-volume" | undefined;
+        globalName: "uniform" | "occupancy" | "element-index" | "element-symbol" | "hydrophobicity" | "shape-group" | "uncertainty" | "carbohydrate-symbol" | "chain-id" | "operator-name" | "entity-id" | "entity-source" | "model-index" | "structure-index" | "molecule-type" | "polymer-id" | "polymer-index" | "residue-name" | "secondary-structure" | "sequence-id" | "unit-index" | "illustrative" | "trajectory-index" | "operator-hkl" | "partial-charge" | "atom-id" | "volume-value" | "volume-segment" | "external-volume" | undefined;
         globalColorParams: any;
         carbonColor: "element-symbol" | "chain-id" | "operator-name" | undefined;
-        symmetryColor: "uniform" | "occupancy" | "element-index" | "element-symbol" | "hydrophobicity" | "shape-group" | "uncertainty" | "carbohydrate-symbol" | "chain-id" | "operator-name" | "entity-id" | "entity-source" | "model-index" | "structure-index" | "molecule-type" | "polymer-id" | "polymer-index" | "residue-name" | "secondary-structure" | "sequence-id" | "unit-index" | "illustrative" | "trajectory-index" | "operator-hkl" | "partial-charge" | "atom-id" | "volume-value" | "external-volume" | undefined;
+        symmetryColor: "uniform" | "occupancy" | "element-index" | "element-symbol" | "hydrophobicity" | "shape-group" | "uncertainty" | "carbohydrate-symbol" | "chain-id" | "operator-name" | "entity-id" | "entity-source" | "model-index" | "structure-index" | "molecule-type" | "polymer-id" | "polymer-index" | "residue-name" | "secondary-structure" | "sequence-id" | "unit-index" | "illustrative" | "trajectory-index" | "operator-hkl" | "partial-charge" | "atom-id" | "volume-value" | "volume-segment" | "external-volume" | undefined;
         symmetryColorParams: any;
         focus: PD.Normalize<{
             name: any;
@@ -61,6 +62,7 @@ export declare const AssemblySymmetryPresetParams: {
 };
 export declare const AssemblySymmetryPreset: StructureRepresentationPresetProvider<{
     ignoreHydrogens: boolean | undefined;
+    ignoreHydrogensVariant: "all" | "non-polar" | undefined;
     ignoreLight: boolean | undefined;
     quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined;
     theme: PD.Normalize<{

package/lib/commonjs/extensions/rcsb/validation-report/behavior.d.ts

@@ -12,6 +12,7 @@ export declare const RCSBValidationReport: import("../../../mol-state/transforme
 }>;
 export declare const ValidationReportGeometryQualityPreset: StructureRepresentationPresetProvider<{
     ignoreHydrogens: boolean | undefined;
+    ignoreHydrogensVariant: "all" | "non-polar" | undefined;
     ignoreLight: boolean | undefined;
     quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined;
     theme: PD.Normalize<{
@@ -51,6 +52,7 @@ export declare const ValidationReportGeometryQualityPreset: StructureRepresentat
 }>;
 export declare const ValidationReportDensityFitPreset: StructureRepresentationPresetProvider<{
     ignoreHydrogens: boolean | undefined;
+    ignoreHydrogensVariant: "all" | "non-polar" | undefined;
     ignoreLight: boolean | undefined;
     quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined;
     theme: PD.Normalize<{
@@ -82,6 +84,7 @@ export declare const ValidationReportDensityFitPreset: StructureRepresentationPr
 }>;
 export declare const ValidationReportRandomCoilIndexPreset: StructureRepresentationPresetProvider<{
     ignoreHydrogens: boolean | undefined;
+    ignoreHydrogensVariant: "all" | "non-polar" | undefined;
     ignoreLight: boolean | undefined;
     quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined;
     theme: PD.Normalize<{

package/lib/commonjs/extensions/volumes-and-segmentations/entry-meshes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { Segment } from './volseg-api/data';
+import { VolsegEntryData } from './entry-root';
+export declare class VolsegMeshSegmentationData {
+    private entryData;
+    constructor(rootData: VolsegEntryData);
+    loadSegmentation(): Promise<void>;
+    updateOpacity(opacity: number): Promise<import("../../mol-state").StateObjectSelector<import("../../mol-state/object").StateObject<any, import("../../mol-state/object").StateObject.Type<any>>, import("../../mol-state/transformer").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>>>;
+    highlightSegment(segment: Segment): Promise<void>;
+    selectSegment(segment?: number): Promise<void>;
+    /** Make visible the specified set of mesh segments */
+    showSegments(segments: number[]): Promise<void>;
+}

package/lib/commonjs/extensions/volumes-and-segmentations/entry-meshes.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VolsegMeshSegmentationData = void 0;
+var tslib_1 = require("tslib");
+var misc_1 = require("../../mol-plugin-state/transforms/misc");
+var representation_1 = require("../../mol-plugin-state/transforms/representation");
+var state_1 = require("../../mol-plugin/behavior/static/state");
+var commands_1 = require("../../mol-plugin/commands");
+var color_1 = require("../../mol-util/color");
+var names_1 = require("../../mol-util/color/names");
+var examples_1 = require("../meshes/examples");
+var behavior_1 = require("../meshes/mesh-streaming/behavior");
+var DEFAULT_MESH_DETAIL = 5; // null means worst
+var VolsegMeshSegmentationData = /** @class */ (function () {
+    function VolsegMeshSegmentationData(rootData) {
+        this.entryData = rootData;
+    }
+    VolsegMeshSegmentationData.prototype.loadSegmentation = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var hasMeshes;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        hasMeshes = this.entryData.metadata.meshSegmentIds.length > 0;
+                        if (!hasMeshes) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.showSegments(this.entryData.metadata.allSegmentIds)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegMeshSegmentationData.prototype.updateOpacity = function (opacity) {
+        var visuals = this.entryData.findNodesByTags('mesh-segment-visual');
+        var update = this.entryData.newUpdate();
+        for (var _i = 0, visuals_1 = visuals; _i < visuals_1.length; _i++) {
+            var visual = visuals_1[_i];
+            update.to(visual).update(representation_1.ShapeRepresentation3D, function (p) { p.alpha = opacity; });
+        }
+        return update.commit();
+    };
+    VolsegMeshSegmentationData.prototype.highlightSegment = function (segment) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var visuals, _i, visuals_2, visual;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        visuals = this.entryData.findNodesByTags('mesh-segment-visual', "segment-".concat(segment.id));
+                        _i = 0, visuals_2 = visuals;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < visuals_2.length)) return [3 /*break*/, 4];
+                        visual = visuals_2[_i];
+                        return [4 /*yield*/, commands_1.PluginCommands.Interactivity.Object.Highlight(this.entryData.plugin, { state: this.entryData.plugin.state.data, ref: visual.transform.ref })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VolsegMeshSegmentationData.prototype.selectSegment = function (segment) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var visuals, reprNode, loci;
+            return tslib_1.__generator(this, function (_b) {
+                if (segment === undefined || segment < 0)
+                    return [2 /*return*/];
+                visuals = this.entryData.findNodesByTags('mesh-segment-visual', "segment-".concat(segment));
+                reprNode = (_a = visuals[0]) === null || _a === void 0 ? void 0 : _a.obj;
+                if (!reprNode)
+                    return [2 /*return*/];
+                loci = reprNode.data.repr.getAllLoci()[0];
+                if (!loci)
+                    return [2 /*return*/];
+                this.entryData.plugin.managers.interactivity.lociSelects.select({ loci: loci, repr: reprNode.data.repr }, false);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /** Make visible the specified set of mesh segments */
+    VolsegMeshSegmentationData.prototype.showSegments = function (segments) {
+        var _a, _b, _c, _d;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var segmentsToShow, visuals, _i, visuals_3, visual, theTag, id, visibility, segmentsToCreate, group, newGroupNode, totalVolume, awaiting, _e, segmentsToCreate_1, seg, segment, detail, color, url, label, meshPromise, _f, awaiting_1, promise;
+            return tslib_1.__generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        segmentsToShow = new Set(segments);
+                        visuals = this.entryData.findNodesByTags('mesh-segment-visual');
+                        for (_i = 0, visuals_3 = visuals; _i < visuals_3.length; _i++) {
+                            visual = visuals_3[_i];
+                            theTag = (_b = (_a = visual.obj) === null || _a === void 0 ? void 0 : _a.tags) === null || _b === void 0 ? void 0 : _b.find(function (tag) { return tag.startsWith('segment-'); });
+                            if (!theTag)
+                                continue;
+                            id = parseInt(theTag.split('-')[1]);
+                            visibility = segmentsToShow.has(id);
+                            (0, state_1.setSubtreeVisibility)(this.entryData.plugin.state.data, visual.transform.ref, !visibility); // true means hide, ¯\_(ツ)_/¯
+                            segmentsToShow.delete(id);
+                        }
+                        segmentsToCreate = this.entryData.metadata.meshSegmentIds.filter(function (seg) { return segmentsToShow.has(seg); });
+                        if (segmentsToCreate.length === 0)
+                            return [2 /*return*/];
+                        group = (_c = this.entryData.findNodesByTags('mesh-segmentation-group')[0]) === null || _c === void 0 ? void 0 : _c.transform.ref;
+                        if (!!group) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.entryData.newUpdate().apply(misc_1.CreateGroup, { label: 'Segmentation', description: 'Mesh' }, { tags: ['mesh-segmentation-group'], state: { isCollapsed: true } }).commit()];
+                    case 1:
+                        newGroupNode = _g.sent();
+                        group = newGroupNode.ref;
+                        _g.label = 2;
+                    case 2:
+                        totalVolume = this.entryData.metadata.gridTotalVolume;
+                        awaiting = [];
+                        for (_e = 0, segmentsToCreate_1 = segmentsToCreate; _e < segmentsToCreate_1.length; _e++) {
+                            seg = segmentsToCreate_1[_e];
+                            segment = this.entryData.metadata.getSegment(seg);
+                            if (!segment)
+                                continue;
+                            detail = this.entryData.metadata.getSufficientMeshDetail(seg, DEFAULT_MESH_DETAIL);
+                            color = segment.colour.length >= 3 ? color_1.Color.fromNormalizedArray(segment.colour, 0) : names_1.ColorNames.gray;
+                            url = this.entryData.api.meshUrl_Bcif(this.entryData.source, this.entryData.entryId, seg, detail);
+                            label = (_d = segment.biological_annotation.name) !== null && _d !== void 0 ? _d : "Segment ".concat(seg);
+                            meshPromise = (0, examples_1.createMeshFromUrl)(this.entryData.plugin, url, seg, detail, true, color, group, behavior_1.BACKGROUND_SEGMENT_VOLUME_THRESHOLD * totalVolume, "<b>".concat(label, "</b>"), this.entryData.ref);
+                            awaiting.push(meshPromise);
+                        }
+                        _f = 0, awaiting_1 = awaiting;
+                        _g.label = 3;
+                    case 3:
+                        if (!(_f < awaiting_1.length)) return [3 /*break*/, 6];
+                        promise = awaiting_1[_f];
+                        return [4 /*yield*/, promise];
+                    case 4:
+                        _g.sent();
+                        _g.label = 5;
+                    case 5:
+                        _f++;
+                        return [3 /*break*/, 3];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return VolsegMeshSegmentationData;
+}());
+exports.VolsegMeshSegmentationData = VolsegMeshSegmentationData;

package/lib/commonjs/extensions/volumes-and-segmentations/entry-models.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { VolsegEntryData } from './entry-root';
+export declare class VolsegModelData {
+    private entryData;
+    constructor(rootData: VolsegEntryData);
+    private loadPdb;
+    showPdbs(pdbIds: string[]): Promise<void>;
+}

package/lib/commonjs/extensions/volumes-and-segmentations/entry-models.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VolsegModelData = void 0;
+var tslib_1 = require("tslib");
+var data_1 = require("../../mol-plugin-state/transforms/data");
+var misc_1 = require("../../mol-plugin-state/transforms/misc");
+var model_1 = require("../../mol-plugin-state/transforms/model");
+var state_1 = require("../../mol-plugin/behavior/static/state");
+var VolsegModelData = /** @class */ (function () {
+    function VolsegModelData(rootData) {
+        this.entryData = rootData;
+    }
+    VolsegModelData.prototype.loadPdb = function (pdbId, parent) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var url, dataNode, cifNode, trajectoryNode;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = "https://www.ebi.ac.uk/pdbe/entry-files/download/".concat(pdbId, ".bcif");
+                        return [4 /*yield*/, this.entryData.plugin.build().to(parent).apply(data_1.Download, { url: url, isBinary: true }, { tags: ['fitted-model-data', "pdbid-".concat(pdbId)] }).commit()];
+                    case 1:
+                        dataNode = _a.sent();
+                        return [4 /*yield*/, this.entryData.plugin.build().to(dataNode).apply(data_1.ParseCif).commit()];
+                    case 2:
+                        cifNode = _a.sent();
+                        return [4 /*yield*/, this.entryData.plugin.build().to(cifNode).apply(model_1.TrajectoryFromMmCif).commit()];
+                    case 3:
+                        trajectoryNode = _a.sent();
+                        return [4 /*yield*/, this.entryData.plugin.builders.structure.hierarchy.applyPreset(trajectoryNode, 'default', { representationPreset: 'polymer-cartoon' })];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/, dataNode];
+                }
+            });
+        });
+    };
+    VolsegModelData.prototype.showPdbs = function (pdbIds) {
+        var _a, _b, _c;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var segmentsToShow, visuals, _i, visuals_1, visual, theTag, id, visibility, segmentsToCreate, group, newGroupNode, awaiting, _d, segmentsToCreate_1, pdbId, _e, awaiting_1, promise;
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        segmentsToShow = new Set(pdbIds);
+                        visuals = this.entryData.findNodesByTags('fitted-model-data');
+                        for (_i = 0, visuals_1 = visuals; _i < visuals_1.length; _i++) {
+                            visual = visuals_1[_i];
+                            theTag = (_b = (_a = visual.obj) === null || _a === void 0 ? void 0 : _a.tags) === null || _b === void 0 ? void 0 : _b.find(function (tag) { return tag.startsWith('pdbid-'); });
+                            if (!theTag)
+                                continue;
+                            id = theTag.split('-')[1];
+                            visibility = segmentsToShow.has(id);
+                            (0, state_1.setSubtreeVisibility)(this.entryData.plugin.state.data, visual.transform.ref, !visibility); // true means hide, ¯\_(ツ)_/¯
+                            segmentsToShow.delete(id);
+                        }
+                        segmentsToCreate = Array.from(segmentsToShow);
+                        if (segmentsToCreate.length === 0)
+                            return [2 /*return*/];
+                        group = (_c = this.entryData.findNodesByTags('fitted-models-group')[0]) === null || _c === void 0 ? void 0 : _c.transform.ref;
+                        if (!!group) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.entryData.newUpdate().apply(misc_1.CreateGroup, { label: 'Fitted Models' }, { tags: ['fitted-models-group'], state: { isCollapsed: true } }).commit()];
+                    case 1:
+                        newGroupNode = _f.sent();
+                        group = newGroupNode.ref;
+                        _f.label = 2;
+                    case 2:
+                        awaiting = [];
+                        for (_d = 0, segmentsToCreate_1 = segmentsToCreate; _d < segmentsToCreate_1.length; _d++) {
+                            pdbId = segmentsToCreate_1[_d];
+                            awaiting.push(this.loadPdb(pdbId, group));
+                        }
+                        _e = 0, awaiting_1 = awaiting;
+                        _f.label = 3;
+                    case 3:
+                        if (!(_e < awaiting_1.length)) return [3 /*break*/, 6];
+                        promise = awaiting_1[_e];
+                        return [4 /*yield*/, promise];
+                    case 4:
+                        _f.sent();
+                        _f.label = 5;
+                    case 5:
+                        _e++;
+                        return [3 /*break*/, 3];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return VolsegModelData;
+}());
+exports.VolsegModelData = VolsegModelData;