molstar 3.26.0 → 3.28.0

package/lib/commonjs/extensions/cellpack/model.js

@@ -798,7 +798,7 @@ exports.LoadCellPackModel = mol_state_1.StateAction.build({
                 case 0:
                     if (params.preset.adjustStyle) {
                         ctx.managers.interactivity.setProps({ granularity: 'chain' });
-                        ctx.managers.structure.component.setOptions(tslib_1.__assign(tslib_1.__assign({}, ctx.managers.structure.component.state.options), { visualQuality: 'custom', ignoreLight: true, showHydrogens: false }));
+                        ctx.managers.structure.component.setOptions(tslib_1.__assign(tslib_1.__assign({}, ctx.managers.structure.component.state.options), { visualQuality: 'custom', ignoreLight: true, hydrogens: 'hide-all' }));
                         (_a = ctx.canvas3d) === null || _a === void 0 ? void 0 : _a.setProps({
                             multiSample: { mode: 'off' },
                             cameraClipping: { far: false },
@@ -833,6 +833,7 @@ exports.LoadCellPackModel = mol_state_1.StateAction.build({
                                         scale: 1,
                                         threshold: 0.33,
                                         color: names_1.ColorNames.black,
+                                        includeTransparent: true,
                                     }
                                 }
                             }

package/lib/commonjs/extensions/dnatco/confal-pyramids/behavior.d.ts

@@ -10,6 +10,7 @@ import { StructureRepresentationPresetProvider } from '../../../mol-plugin-state
 import { ParamDefinition as PD } from '../../../mol-util/param-definition';
 export declare const DnatcoConfalPyramidsPreset: 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/meshes/choice.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+/**
+ * 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?: PD.Info): PD.Select<T>;
+    prettyName(value: T): string;
+}
+export declare namespace Choice {
+    type Values<T extends Choice<any, any>> = T extends Choice<infer R, any> ? R : any;
+}

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

@@ -0,0 +1,31 @@
+"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.Choice = void 0;
+var param_definition_1 = require("../../mol-util/param-definition");
+/**
+ * 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 param_definition_1.ParamDefinition.Select(defaultValue !== null && defaultValue !== void 0 ? defaultValue : this.defaultValue, this.options, info);
+    };
+    Choice.prototype.prettyName = function (value) {
+        return this.nameDict[value];
+    };
+    return Choice;
+}());
+exports.Choice = Choice;

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

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { MeshServerInfo } from './mesh-streaming/server-info';
+import { PluginUIContext } from '../../mol-plugin-ui/context';
+import { PluginContext } from '../../mol-plugin/context';
+import { StateObjectRef, StateObjectSelector } from '../../mol-state';
+import { Color } from '../../mol-util/color';
+export declare const DB_URL = "/db";
+export declare function runMeshExtensionExamples(plugin: PluginUIContext, db_url?: string): Promise<void>;
+/** Example for downloading multiple separate segments, each containing 1 mesh. */
+export declare function runMeshExample(plugin: PluginUIContext, segments: 'fg' | 'all', db_url?: string): Promise<void>;
+/** Example for downloading multiple separate segments, each containing 1 mesh. */
+export declare function runMeshExample2(plugin: PluginUIContext, segments: 'one' | 'few' | 'fg' | 'all'): Promise<void>;
+/** Example for downloading a single segment containing multiple meshes. */
+export declare function runMultimeshExample(plugin: PluginUIContext, segments: 'fg' | 'all', detailChoice: 'best' | 'worst', db_url?: string): Promise<void>;
+/** Download data and create state tree hierarchy down to visual representation. */
+export declare function createMeshFromUrl(plugin: PluginContext, meshDataUrl: string, segmentId: number, detail: number, collapseTree: boolean, color?: Color, parent?: StateObjectSelector | StateObjectRef, transparentIfBboxAbove?: number, name?: string, ownerId?: string): Promise<string>;
+export declare function runMeshStreamingExample(plugin: PluginUIContext, source?: MeshServerInfo.MeshSource, entryId?: string, serverUrl?: string, parent?: StateObjectSelector): Promise<void>;
+/** Example for downloading a protein structure and visualizing molecular surface. */
+export declare function runMolsurfaceExample(plugin: PluginUIContext): Promise<void>;
+/** Example for downloading an EMDB density data and visualizing isosurface. */
+export declare function runIsosurfaceExample(plugin: PluginUIContext, db_url?: string): Promise<void>;
+export declare function runCifMeshExample(plugin: PluginUIContext, api?: string, source?: MeshServerInfo.MeshSource, entryId?: string, segmentId?: number, detail?: number): Promise<void>;

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

@@ -0,0 +1,337 @@
+"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.runCifMeshExample = exports.runIsosurfaceExample = exports.runMolsurfaceExample = exports.runMeshStreamingExample = exports.createMeshFromUrl = exports.runMultimeshExample = exports.runMeshExample2 = exports.runMeshExample = exports.runMeshExtensionExamples = exports.DB_URL = void 0;
+var tslib_1 = require("tslib");
+/** Testing examples for using mesh-extension.ts. */
+var mesh_extension_1 = require("./mesh-extension");
+var MeshUtils = tslib_1.__importStar(require("./mesh-utils"));
+var transformers_1 = require("./mesh-streaming/transformers");
+var server_info_1 = require("./mesh-streaming/server-info");
+var color_1 = require("../../mol-util/color");
+var data_1 = require("../../mol-plugin-state/transforms/data");
+var transforms_1 = require("../../mol-plugin-state/transforms");
+var geometry_1 = require("../../mol-math/geometry");
+var representation_1 = require("../../mol-plugin-state/transforms/representation");
+var param_definition_1 = require("../../mol-util/param-definition");
+var structure_representation_params_1 = require("../../mol-plugin-state/helpers/structure-representation-params");
+var volume_1 = require("../../mol-model/volume");
+var volume_representation_params_1 = require("../../mol-plugin-state/helpers/volume-representation-params");
+var assets_1 = require("../../mol-util/assets");
+var cif_1 = require("../../mol-io/reader/cif");
+exports.DB_URL = '/db'; // local
+function runMeshExtensionExamples(plugin, db_url) {
+    if (db_url === void 0) { db_url = exports.DB_URL; }
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    console.time('TIME MESH EXAMPLES');
+                    // await runIsosurfaceExample(plugin, db_url);
+                    // await runMolsurfaceExample(plugin);
+                    // Focused Ion Beam-Scanning Electron Microscopy of mitochondrial reticulum in murine skeletal muscle: https://www.ebi.ac.uk/empiar/EMPIAR-10070/
+                    // await runMeshExample(plugin, 'all', db_url);
+                    // await runMeshExample(plugin, 'fg', db_url);
+                    // await runMultimeshExample(plugin, 'fg', 'worst', db_url);
+                    // await runCifMeshExample(plugin);
+                    // await runMeshExample2(plugin, 'fg');
+                    return [4 /*yield*/, runMeshStreamingExample(plugin)];
+                case 1:
+                    // await runIsosurfaceExample(plugin, db_url);
+                    // await runMolsurfaceExample(plugin);
+                    // Focused Ion Beam-Scanning Electron Microscopy of mitochondrial reticulum in murine skeletal muscle: https://www.ebi.ac.uk/empiar/EMPIAR-10070/
+                    // await runMeshExample(plugin, 'all', db_url);
+                    // await runMeshExample(plugin, 'fg', db_url);
+                    // await runMultimeshExample(plugin, 'fg', 'worst', db_url);
+                    // await runCifMeshExample(plugin);
+                    // await runMeshExample2(plugin, 'fg');
+                    _a.sent();
+                    console.timeEnd('TIME MESH EXAMPLES');
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.runMeshExtensionExamples = runMeshExtensionExamples;
+/** Example for downloading multiple separate segments, each containing 1 mesh. */
+function runMeshExample(plugin, segments, db_url) {
+    if (db_url === void 0) { db_url = exports.DB_URL; }
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var detail, segmentIds, _i, segmentIds_1, segmentId;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    detail = 2;
+                    segmentIds = (segments === 'all') ?
+                        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17] // segment-16 has no detail-2
+                        : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 17];
+                    _i = 0, segmentIds_1 = segmentIds;
+                    _a.label = 1;
+                case 1:
+                    if (!(_i < segmentIds_1.length)) return [3 /*break*/, 4];
+                    segmentId = segmentIds_1[_i];
+                    return [4 /*yield*/, createMeshFromUrl(plugin, "".concat(db_url, "/empiar-10070-mesh-rounded/segment-").concat(segmentId, "/detail-").concat(detail), segmentId, detail, true, undefined)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.runMeshExample = runMeshExample;
+/** Example for downloading multiple separate segments, each containing 1 mesh. */
+function runMeshExample2(plugin, segments) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var detail, segmentIds, _i, segmentIds_2, segmentId;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    detail = 1;
+                    segmentIds = (segments === 'one') ? [15]
+                        : (segments === 'few') ? [1, 4, 7, 10, 16]
+                            : (segments === 'all') ? [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17] // segment-16 has no detail-2
+                                : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 17];
+                    _i = 0, segmentIds_2 = segmentIds;
+                    _a.label = 1;
+                case 1:
+                    if (!(_i < segmentIds_2.length)) return [3 /*break*/, 4];
+                    segmentId = segmentIds_2[_i];
+                    return [4 /*yield*/, createMeshFromUrl(plugin, "http://localhost:9000/v2/empiar/empiar-10070/mesh_bcif/".concat(segmentId, "/").concat(detail), segmentId, detail, false, undefined)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.runMeshExample2 = runMeshExample2;
+/** Example for downloading a single segment containing multiple meshes. */
+function runMultimeshExample(plugin, segments, detailChoice, db_url) {
+    if (db_url === void 0) { db_url = exports.DB_URL; }
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var urlDetail, numDetail;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    urlDetail = (detailChoice === 'best') ? '2' : 'worst';
+                    numDetail = (detailChoice === 'best') ? 2 : 1000;
+                    return [4 /*yield*/, createMeshFromUrl(plugin, "".concat(db_url, "/empiar-10070-multimesh-rounded/segments-").concat(segments, "/detail-").concat(urlDetail), 0, numDetail, false, undefined)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.runMultimeshExample = runMultimeshExample;
+/** Download data and create state tree hierarchy down to visual representation. */
+function createMeshFromUrl(plugin, meshDataUrl, segmentId, detail, collapseTree, color, parent, transparentIfBboxAbove, name, ownerId) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var update, rawDataNodeRef, parsedDataNode, transparent, bbox;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    update = parent ? plugin.build().to(parent) : plugin.build().toRoot();
+                    rawDataNodeRef = update.apply(data_1.Download, { url: meshDataUrl, isBinary: true, label: "Downloaded Data ".concat(segmentId) }, { state: { isCollapsed: collapseTree } }).ref;
+                    return [4 /*yield*/, update.to(rawDataNodeRef)
+                            .apply(transforms_1.StateTransforms.Data.ParseCif)
+                            .apply(mesh_extension_1.ParseMeshlistTransformer, { label: undefined, segmentId: segmentId, segmentName: name !== null && name !== void 0 ? name : "Segment ".concat(segmentId), detail: detail, ownerId: ownerId }, {})
+                            .commit()];
+                case 1:
+                    parsedDataNode = _a.sent();
+                    transparent = false;
+                    if (transparentIfBboxAbove !== undefined && parsedDataNode.data) {
+                        bbox = mesh_extension_1.MeshlistData.bbox(parsedDataNode.data) || geometry_1.Box3D.zero();
+                        transparent = geometry_1.Box3D.volume(bbox) > transparentIfBboxAbove;
+                    }
+                    return [4 /*yield*/, plugin.build().to(parsedDataNode)
+                            .apply(mesh_extension_1.MeshShapeTransformer, { color: color })
+                            .apply(representation_1.ShapeRepresentation3D, { alpha: transparent ? transformers_1.BACKGROUND_OPACITY : transformers_1.FOREROUND_OPACITY }, { tags: ['mesh-segment-visual', "segment-".concat(segmentId)] })
+                            .commit()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, rawDataNodeRef];
+            }
+        });
+    });
+}
+exports.createMeshFromUrl = createMeshFromUrl;
+function runMeshStreamingExample(plugin, source, entryId, serverUrl, parent) {
+    if (source === void 0) { source = 'empiar'; }
+    if (entryId === void 0) { entryId = 'empiar-10070'; }
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var params;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    params = param_definition_1.ParamDefinition.getDefaultValues(server_info_1.MeshServerInfo.Params);
+                    if (serverUrl)
+                        params.serverUrl = serverUrl;
+                    params.source = source;
+                    params.entryId = entryId;
+                    return [4 /*yield*/, plugin.runTask(plugin.state.data.applyAction(transformers_1.InitMeshStreaming, params, parent === null || parent === void 0 ? void 0 : parent.ref), { useOverlay: false })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.runMeshStreamingExample = runMeshStreamingExample;
+/** Example for downloading a protein structure and visualizing molecular surface. */
+function runMolsurfaceExample(plugin) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var entryId, data, parsed, trajectory, model, structure, reprParams, repr;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    entryId = 'pdb-7etq';
+                    return [4 /*yield*/, plugin.builders.data.download({ url: 'https://www.ebi.ac.uk/pdbe/entry-files/download/7etq.bcif', isBinary: true }, { state: { isGhost: false } })];
+                case 1:
+                    data = _a.sent();
+                    console.log('formats:', plugin.dataFormats.list);
+                    return [4 /*yield*/, plugin.dataFormats.get('mmcif').parse(plugin, data, { entryId: entryId })];
+                case 2:
+                    parsed = _a.sent();
+                    trajectory = parsed.trajectory;
+                    console.log('parsed', parsed);
+                    console.log('trajectory', trajectory);
+                    return [4 /*yield*/, plugin.build().to(trajectory).apply(transforms_1.StateTransforms.Model.ModelFromTrajectory).commit()];
+                case 3:
+                    model = _a.sent();
+                    console.log('model:', model);
+                    return [4 /*yield*/, plugin.build().to(model).apply(transforms_1.StateTransforms.Model.StructureFromModel).commit()];
+                case 4:
+                    structure = _a.sent();
+                    console.log('structure:', structure);
+                    reprParams = (0, structure_representation_params_1.createStructureRepresentationParams)(plugin, undefined, { type: 'molecular-surface' });
+                    return [4 /*yield*/, plugin.build().to(structure).apply(transforms_1.StateTransforms.Representation.StructureRepresentation3D, reprParams).commit()];
+                case 5:
+                    repr = _a.sent();
+                    console.log('repr:', repr);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.runMolsurfaceExample = runMolsurfaceExample;
+/** Example for downloading an EMDB density data and visualizing isosurface. */
+function runIsosurfaceExample(plugin, db_url) {
+    var _a, _b;
+    if (db_url === void 0) { db_url = exports.DB_URL; }
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var entryId, isoLevel, root, data, parsed, volume, volumeData, volumeParams;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    entryId = 'emd-1832';
+                    isoLevel = 2.73;
+                    return [4 /*yield*/, plugin.build()];
+                case 1:
+                    root = _c.sent();
+                    return [4 /*yield*/, plugin.builders.data.download({ url: "".concat(db_url, "/emd-1832-box"), isBinary: true }, { state: { isGhost: false } })];
+                case 2:
+                    data = _c.sent();
+                    return [4 /*yield*/, plugin.dataFormats.get('dscif').parse(plugin, data, { entryId: entryId })];
+                case 3:
+                    parsed = _c.sent();
+                    volume = (_b = (_a = parsed.volumes) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : parsed.volume;
+                    volumeData = volume.cell.obj.data;
+                    console.log('data:', data);
+                    console.log('parsed:', parsed);
+                    console.log('volume:', volume);
+                    console.log('volumeData:', volumeData);
+                    return [4 /*yield*/, plugin.build()];
+                case 4:
+                    root = _c.sent();
+                    console.log('root:', root);
+                    console.log('to:', root.to(volume));
+                    console.log('toRoot:', root.toRoot());
+                    volumeParams = (0, volume_representation_params_1.createVolumeRepresentationParams)(plugin, volumeData, {
+                        type: 'isosurface',
+                        typeParams: {
+                            alpha: 0.5,
+                            isoValue: volume_1.Volume.adjustedIsoValue(volumeData, isoLevel, 'relative'),
+                            visuals: ['solid'],
+                            sizeFactor: 1,
+                        },
+                        color: 'uniform',
+                        colorParams: { value: (0, color_1.Color)(0x00aaaa) },
+                    });
+                    root.to(volume).apply(transforms_1.StateTransforms.Representation.VolumeRepresentation3D, volumeParams);
+                    volumeParams = (0, volume_representation_params_1.createVolumeRepresentationParams)(plugin, volumeData, {
+                        type: 'isosurface',
+                        typeParams: {
+                            alpha: 1.0,
+                            isoValue: volume_1.Volume.adjustedIsoValue(volumeData, isoLevel, 'relative'),
+                            visuals: ['wireframe'],
+                            sizeFactor: 1,
+                        },
+                        color: 'uniform',
+                        colorParams: { value: (0, color_1.Color)(0x8800aa) },
+                    });
+                    root.to(volume).apply(transforms_1.StateTransforms.Representation.VolumeRepresentation3D, volumeParams);
+                    return [4 /*yield*/, root.commit()];
+                case 5:
+                    _c.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.runIsosurfaceExample = runIsosurfaceExample;
+function runCifMeshExample(plugin, api, source, entryId, segmentId, detail) {
+    if (api === void 0) { api = 'http://localhost:9000/v2'; }
+    if (source === void 0) { source = 'empiar'; }
+    if (entryId === void 0) { entryId = 'empiar-10070'; }
+    if (segmentId === void 0) { segmentId = 1; }
+    if (detail === void 0) { detail = 10; }
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var url;
+        return tslib_1.__generator(this, function (_a) {
+            url = "".concat(api, "/").concat(source, "/").concat(entryId, "/mesh_bcif/").concat(segmentId, "/").concat(detail);
+            getMeshFromBcif(plugin, url);
+            return [2 /*return*/];
+        });
+    });
+}
+exports.runCifMeshExample = runCifMeshExample;
+function getMeshFromBcif(plugin, url) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var urlAsset, asset, parsed, mesh;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    urlAsset = assets_1.Asset.getUrlAsset(plugin.managers.asset, url);
+                    return [4 /*yield*/, plugin.runTask(plugin.managers.asset.resolve(urlAsset, 'binary'))];
+                case 1:
+                    asset = _a.sent();
+                    return [4 /*yield*/, plugin.runTask(cif_1.CIF.parseBinary(asset.data))];
+                case 2:
+                    parsed = _a.sent();
+                    if (parsed.isError) {
+                        plugin.log.error('VolumeStreaming, parsing CIF: ' + parsed.toString());
+                        return [2 /*return*/];
+                    }
+                    console.log('blocks:', parsed.result.blocks);
+                    return [4 /*yield*/, MeshUtils.meshFromCif(parsed.result)];
+                case 3:
+                    mesh = _a.sent();
+                    console.log(mesh);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}

package/lib/commonjs/extensions/meshes/mesh-cif-schema.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { Column, Database } from '../../mol-data/db';
+import { CifFrame } from '../../mol-io/reader/cif';
+export declare const Mesh_Data_Schema: {
+    mesh: {
+        id: Column.Schema.Int;
+    };
+    mesh_vertex: {
+        mesh_id: Column.Schema.Int;
+        vertex_id: Column.Schema.Int;
+        x: Column.Schema.Float;
+        y: Column.Schema.Float;
+        z: Column.Schema.Float;
+    };
+    /** Table of triangles, 3 rows per triangle */
+    mesh_triangle: {
+        mesh_id: Column.Schema.Int;
+        /** Indices of vertices within mesh */
+        vertex_id: Column.Schema.Int;
+    };
+};
+export type Mesh_Data_Schema = typeof Mesh_Data_Schema;
+export interface Mesh_Data_Database extends Database<Mesh_Data_Schema> {
+}
+export declare const CIF_schema_mesh: (frame: CifFrame) => Mesh_Data_Database;

package/lib/commonjs/extensions/meshes/mesh-cif-schema.js

@@ -0,0 +1,34 @@
+"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.CIF_schema_mesh = exports.Mesh_Data_Schema = void 0;
+var db_1 = require("../../mol-data/db");
+var schema_1 = require("../../mol-io/reader/cif/schema");
+var int = db_1.Column.Schema.int;
+var float = db_1.Column.Schema.float;
+// TODO in future, move to molstar/src/mol-io/reader/cif/schema/mesh.ts
+exports.Mesh_Data_Schema = {
+    mesh: {
+        id: int,
+    },
+    mesh_vertex: {
+        mesh_id: int,
+        vertex_id: int,
+        x: float,
+        y: float,
+        z: float,
+    },
+    /** Table of triangles, 3 rows per triangle */
+    mesh_triangle: {
+        mesh_id: int,
+        /** Indices of vertices within mesh */
+        vertex_id: int,
+    }
+};
+// TODO in future, move to molstar/src/mol-io/reader/cif.ts: CIF.schema.mesh
+var CIF_schema_mesh = function (frame) { return (0, schema_1.toDatabase)(exports.Mesh_Data_Schema, frame); };
+exports.CIF_schema_mesh = CIF_schema_mesh;

package/lib/commonjs/extensions/meshes/mesh-extension.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Adam Midlik <midlik@gmail.com>
+ */
+import { Mesh } from '../../mol-geo/geometry/mesh/mesh';
+import { CifFile } from '../../mol-io/reader/cif';
+import { Box3D } from '../../mol-math/geometry';
+import { Shape } from '../../mol-model/shape';
+import { PluginStateObject } from '../../mol-plugin-state/objects';
+import { StateTransformer } from '../../mol-state';
+import { Color } from '../../mol-util/color';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+export declare const VolsegTransform: StateTransformer.Builder.Root;
+/** Data type for `MeshlistStateObject` - list of meshes */
+export interface MeshlistData {
+    segmentId: number;
+    segmentName: string;
+    detail: number;
+    meshIds: number[];
+    mesh: Mesh;
+    /** Reference to the object which created this meshlist (e.g. `MeshStreaming.Behavior`) */
+    ownerId?: string;
+}
+export declare namespace MeshlistData {
+    function empty(): MeshlistData;
+    function fromCIF(data: CifFile, segmentId: number, segmentName: string, detail: number): Promise<MeshlistData>;
+    function stats(meshListData: MeshlistData): string;
+    function getShape(data: MeshlistData, color: Color): Shape<Mesh>;
+    function combineBBoxes(boxes: (Box3D | null)[]): Box3D | null;
+    function bbox(data: MeshlistData): Box3D | null;
+    function allVerticesUsed(data: MeshlistData): boolean;
+}
+declare const MeshlistStateObject_base: {
+    new (data: MeshlistData, props?: {
+        label: string;
+        description?: string | undefined;
+    } | undefined): {
+        id: import("../../mol-util/uuid").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: MeshlistData;
+    };
+    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: MeshlistData;
+    };
+};
+export declare class MeshlistStateObject extends MeshlistStateObject_base {
+}
+export declare const ParseMeshlistTransformer: StateTransformer<PluginStateObject.Format.Cif, MeshlistStateObject, PD.Normalize<{
+    label: string;
+    segmentId: number;
+    segmentName: string;
+    detail: number;
+    ownerId: string;
+}>>;
+export declare const MeshShapeTransformer: StateTransformer<MeshlistStateObject, PluginStateObject.Shape.Provider, PD.Normalize<{
+    color: Color | undefined;
+}>>;
+export {};