molstar 3.3.0 → 3.5.0

package/lib/mol-plugin-state/actions/file.js

@@ -1,9 +1,9 @@
 /**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-import { __awaiter, __generator } from "tslib";
+import { __awaiter, __generator, __spreadArray } from "tslib";
 import { StateAction } from '../../mol-state';
 import { Task } from '../../mol-task';
 import { Asset } from '../../mol-util/assets';
@@ -11,6 +11,41 @@ import { getFileInfo } from '../../mol-util/file-info';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { unzip } from '../../mol-util/zip/zip';
 import { PluginStateObject } from '../objects';
+function processFile(file, plugin, format, visuals) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var info, isBinary, data, provider, parsed;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    info = getFileInfo(file.file);
+                    isBinary = plugin.dataFormats.binaryExtensions.has(info.ext);
+                    return [4 /*yield*/, plugin.builders.data.readFile({ file: file, isBinary: isBinary })];
+                case 1:
+                    data = (_c.sent()).data;
+                    provider = format === 'auto'
+                        ? plugin.dataFormats.auto(info, (_a = data.cell) === null || _a === void 0 ? void 0 : _a.obj)
+                        : plugin.dataFormats.get(format);
+                    if (!!provider) return [3 /*break*/, 3];
+                    plugin.log.warn("OpenFiles: could not find data provider for '".concat(info.ext, "'"));
+                    return [4 /*yield*/, plugin.state.data.build().delete(data).commit()];
+                case 2:
+                    _c.sent();
+                    return [2 /*return*/];
+                case 3: return [4 /*yield*/, provider.parse(plugin, data)];
+                case 4:
+                    parsed = _c.sent();
+                    if (!visuals) return [3 /*break*/, 6];
+                    return [4 /*yield*/, ((_b = provider.visuals) === null || _b === void 0 ? void 0 : _b.call(provider, plugin, parsed))];
+                case 5:
+                    _c.sent();
+                    _c.label = 6;
+                case 6: return [2 /*return*/];
+            }
+        });
+    });
+}
+;
 export var OpenFiles = StateAction.build({
     display: { name: 'Open Files', description: 'Load one or more files and optionally create default visuals' },
     from: PluginStateObject.Root,
@@ -33,7 +68,7 @@ export var OpenFiles = StateAction.build({
                 case 0:
                     plugin.behaviors.layout.leftPanelTabName.next('data');
                     return [4 /*yield*/, state.transaction(function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var processFile, _i, _a, file, zippedFiles, _b, _c, _d, _e, _f, fn, filedata, asset, e_1;
+                            var _i, _a, file, zippedFiles, _b, _c, _d, _e, _f, fn, filedata, asset, format, e_1;
                             return __generator(this, function (_g) {
                                 switch (_g.label) {
                                     case 0:
@@ -41,36 +76,6 @@ export var OpenFiles = StateAction.build({
                                             plugin.log.error('No file(s) selected');
                                             return [2 /*return*/];
                                         }
-                                        processFile = function (file) { return __awaiter(void 0, void 0, void 0, function () {
-                                            var info, isBinary, data, provider, parsed;
-                                            var _a, _b;
-                                            return __generator(this, function (_c) {
-                                                switch (_c.label) {
-                                                    case 0:
-                                                        info = getFileInfo(file.file);
-                                                        isBinary = plugin.dataFormats.binaryExtensions.has(info.ext);
-                                                        return [4 /*yield*/, plugin.builders.data.readFile({ file: file, isBinary: isBinary })];
-                                                    case 1:
-                                                        data = (_c.sent()).data;
-                                                        provider = params.format.name === 'auto'
-                                                            ? plugin.dataFormats.auto(info, (_a = data.cell) === null || _a === void 0 ? void 0 : _a.obj)
-                                                            : plugin.dataFormats.get(params.format.params);
-                                                        if (!provider) {
-                                                            plugin.log.warn("OpenFiles: could not find data provider for '".concat(info.name, ".").concat(info.ext, "'"));
-                                                            return [2 /*return*/];
-                                                        }
-                                                        return [4 /*yield*/, provider.parse(plugin, data)];
-                                                    case 2:
-                                                        parsed = _c.sent();
-                                                        if (!params.visuals) return [3 /*break*/, 4];
-                                                        return [4 /*yield*/, ((_b = provider.visuals) === null || _b === void 0 ? void 0 : _b.call(provider, plugin, parsed))];
-                                                    case 3:
-                                                        _c.sent();
-                                                        _c.label = 4;
-                                                    case 4: return [2 /*return*/];
-                                                }
-                                            });
-                                        }); };
                                         _i = 0, _a = params.files;
                                         _g.label = 1;
                                     case 1:
@@ -91,8 +96,10 @@ export var OpenFiles = StateAction.build({
                                     case 5:
                                         if (!(_d < _e.length)) return [3 /*break*/, 8];
                                         _f = _e[_d], fn = _f[0], filedata = _f[1];
+                                        if (!(filedata instanceof Uint8Array) || filedata.length === 0)
+                                            return [3 /*break*/, 7];
                                         asset = Asset.File(new File([filedata], fn));
-                                        return [4 /*yield*/, processFile(asset)];
+                                        return [4 /*yield*/, processFile(asset, plugin, 'auto', params.visuals)];
                                     case 6:
                                         _g.sent();
                                         _g.label = 7;
@@ -100,7 +107,9 @@ export var OpenFiles = StateAction.build({
                                         _d++;
                                         return [3 /*break*/, 5];
                                     case 8: return [3 /*break*/, 11];
-                                    case 9: return [4 /*yield*/, processFile(file)];
+                                    case 9:
+                                        format = params.format.name === 'auto' ? 'auto' : params.format.params;
+                                        return [4 /*yield*/, processFile(file, plugin, format, params.visuals)];
                                     case 10:
                                         _g.sent();
                                         _g.label = 11;
@@ -128,7 +137,7 @@ export var DownloadFile = StateAction.build({
     display: { name: 'Download File', description: 'Load one or more file from an URL' },
     from: PluginStateObject.Root,
     params: function (a, ctx) {
-        var options = ctx.dataFormats.options;
+        var options = __spreadArray(__spreadArray([], ctx.dataFormats.options, true), [['zip', 'Zip']], false);
         return {
             url: PD.Url(''),
             format: PD.Select(options[0][0], options),
@@ -144,35 +153,59 @@ export var DownloadFile = StateAction.build({
                 case 0:
                     plugin.behaviors.layout.leftPanelTabName.next('data');
                     return [4 /*yield*/, state.transaction(function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var provider, data, parsed, e_2;
-                            var _a;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
+                            var data, zippedFiles, _i, _a, _b, fn, filedata, asset, provider, data, parsed, e_2;
+                            var _c, _d;
+                            return __generator(this, function (_e) {
+                                switch (_e.label) {
                                     case 0:
-                                        _b.trys.push([0, 5, , 6]);
+                                        _e.trys.push([0, 12, , 13]);
+                                        if (!(params.format === 'zip')) return [3 /*break*/, 7];
+                                        return [4 /*yield*/, plugin.builders.data.download({ url: params.url, isBinary: true })];
+                                    case 1:
+                                        data = _e.sent();
+                                        return [4 /*yield*/, unzip(taskCtx, ((_c = data.obj) === null || _c === void 0 ? void 0 : _c.data).buffer)];
+                                    case 2:
+                                        zippedFiles = _e.sent();
+                                        _i = 0, _a = Object.entries(zippedFiles);
+                                        _e.label = 3;
+                                    case 3:
+                                        if (!(_i < _a.length)) return [3 /*break*/, 6];
+                                        _b = _a[_i], fn = _b[0], filedata = _b[1];
+                                        if (!(filedata instanceof Uint8Array) || filedata.length === 0)
+                                            return [3 /*break*/, 5];
+                                        asset = Asset.File(new File([filedata], fn));
+                                        return [4 /*yield*/, processFile(asset, plugin, 'auto', params.visuals)];
+                                    case 4:
+                                        _e.sent();
+                                        _e.label = 5;
+                                    case 5:
+                                        _i++;
+                                        return [3 /*break*/, 3];
+                                    case 6: return [3 /*break*/, 11];
+                                    case 7:
                                         provider = plugin.dataFormats.get(params.format);
                                         if (!provider) {
                                             plugin.log.warn("DownloadFile: could not find data provider for '".concat(params.format, "'"));
                                             return [2 /*return*/];
                                         }
                                         return [4 /*yield*/, plugin.builders.data.download({ url: params.url, isBinary: params.isBinary })];
-                                    case 1:
-                                        data = _b.sent();
+                                    case 8:
+                                        data = _e.sent();
                                         return [4 /*yield*/, provider.parse(plugin, data)];
-                                    case 2:
-                                        parsed = _b.sent();
-                                        if (!params.visuals) return [3 /*break*/, 4];
-                                        return [4 /*yield*/, ((_a = provider.visuals) === null || _a === void 0 ? void 0 : _a.call(provider, plugin, parsed))];
-                                    case 3:
-                                        _b.sent();
-                                        _b.label = 4;
-                                    case 4: return [3 /*break*/, 6];
-                                    case 5:
-                                        e_2 = _b.sent();
+                                    case 9:
+                                        parsed = _e.sent();
+                                        if (!params.visuals) return [3 /*break*/, 11];
+                                        return [4 /*yield*/, ((_d = provider.visuals) === null || _d === void 0 ? void 0 : _d.call(provider, plugin, parsed))];
+                                    case 10:
+                                        _e.sent();
+                                        _e.label = 11;
+                                    case 11: return [3 /*break*/, 13];
+                                    case 12:
+                                        e_2 = _e.sent();
                                         console.error(e_2);
                                         plugin.log.error("Error downloading '".concat(typeof params.url === 'string' ? params.url : params.url.url, "'"));
-                                        return [3 /*break*/, 6];
-                                    case 6: return [2 /*return*/];
+                                        return [3 /*break*/, 13];
+                                    case 13: return [2 /*return*/];
                                 }
                             });
                         }); }).runInContext(taskCtx)];

package/lib/mol-plugin-state/actions/structure.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -9,7 +9,7 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { PluginStateObject } from '../objects';
 export declare const PdbDownloadProvider: {
     rcsb: PD.Group<PD.Normalize<{
-        encoding: "bcif" | "cif";
+        encoding: "cif" | "bcif";
     }>>;
     pdbe: PD.Group<PD.Normalize<{
         variant: "updated" | "updated-bcif" | "updtaed-bcif" | "archival";
@@ -65,3 +65,12 @@ export declare const AddTrajectory: StateAction<PluginStateObject.Root, void, PD
     model: string;
     coordinates: string;
 }>>;
+export declare const LoadTrajectory: StateAction<PluginStateObject.Root, void, PD.Normalize<{
+    source: PD.NamedParams<PD.Normalize<{
+        model: any;
+        coordinates: any;
+    }>, "url"> | PD.NamedParams<PD.Normalize<{
+        model: any;
+        coordinates: any;
+    }>, "file">;
+}>>;

package/lib/mol-plugin-state/actions/structure.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -9,15 +9,17 @@ import { StateAction, StateSelection } from '../../mol-state';
 import { Task } from '../../mol-task';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { PresetStructureRepresentations, StructureRepresentationPresetProvider } from '../builder/structure/representation-preset';
-import { BuiltInTrajectoryFormats } from '../formats/trajectory';
+import { BuiltInTrajectoryFormats, TrajectoryFormatCategory } from '../formats/trajectory';
 import { RootStructureDefinition } from '../helpers/root-structure';
 import { PluginStateObject } from '../objects';
 import { StateTransforms } from '../transforms';
-import { CustomModelProperties, CustomStructureProperties, TrajectoryFromModelAndCoordinates } from '../transforms/model';
+import { CustomModelProperties, CustomStructureProperties, ModelFromTrajectory, TrajectoryFromModelAndCoordinates } from '../transforms/model';
 import { Asset } from '../../mol-util/assets';
 import { PluginConfig } from '../../mol-plugin/config';
 import { getFileInfo } from '../../mol-util/file-info';
 import { assertUnreachable } from '../../mol-util/type-helpers';
+import { TopologyFormatCategory } from '../formats/topology';
+import { CoordinatesFormatCategory } from '../formats/coordinates';
 var DownloadModelRepresentationOptions = function (plugin) {
     var representationDefault = plugin.config.get(PluginConfig.Structure.DefaultRepresentationPreset) || PresetStructureRepresentations.auto.id;
     return PD.Group({
@@ -168,7 +170,9 @@ var DownloadStructure = StateAction.build({
                     asTrajectory = !!src.params.options.asTrajectory;
                     format = 'mol';
                     return [3 /*break*/, 15];
-                case 14: throw new Error("".concat(src.name, " not supported."));
+                case 14:
+                    assertUnreachable(src);
+                    _b.label = 15;
                 case 15:
                     representationPreset = params.source.params.options.representation || plugin.config.get(PluginConfig.Structure.DefaultRepresentationPreset) || PresetStructureRepresentations.auto.id;
                     showUnitcell = representationPreset !== PresetStructureRepresentations.empty.id;
@@ -406,3 +410,169 @@ export var AddTrajectory = StateAction.build({
         }); }).runInContext(taskCtx);
     });
 });
+export var LoadTrajectory = StateAction.build({
+    display: { name: 'Load Trajectory', description: 'Load trajectory of model/topology and coordinates from URL or file.' },
+    from: PluginStateObject.Root,
+    params: function (a, ctx) {
+        var options = ctx.dataFormats.options;
+        var modelOptions = options.filter(function (o) { return o[2] === TrajectoryFormatCategory || o[2] === TopologyFormatCategory; });
+        var coordinatesOptions = options.filter(function (o) { return o[2] === CoordinatesFormatCategory; });
+        var modelExts = [];
+        var coordinatesExts = [];
+        for (var _i = 0, _a = ctx.dataFormats.list; _i < _a.length; _i++) {
+            var provider = _a[_i].provider;
+            if (provider.category === TrajectoryFormatCategory || provider.category === TopologyFormatCategory) {
+                if (provider.binaryExtensions)
+                    modelExts.push.apply(modelExts, provider.binaryExtensions);
+                if (provider.stringExtensions)
+                    modelExts.push.apply(modelExts, provider.stringExtensions);
+            }
+            else if (provider.category === CoordinatesFormatCategory) {
+                if (provider.binaryExtensions)
+                    coordinatesExts.push.apply(coordinatesExts, provider.binaryExtensions);
+                if (provider.stringExtensions)
+                    coordinatesExts.push.apply(coordinatesExts, provider.stringExtensions);
+            }
+        }
+        return {
+            source: PD.MappedStatic('file', {
+                url: PD.Group({
+                    model: PD.Group({
+                        url: PD.Url(''),
+                        format: PD.Select(modelOptions[0][0], modelOptions),
+                        isBinary: PD.Boolean(false),
+                    }, { isExpanded: true }),
+                    coordinates: PD.Group({
+                        url: PD.Url(''),
+                        format: PD.Select(coordinatesOptions[0][0], coordinatesOptions),
+                    }, { isExpanded: true })
+                }, { isFlat: true }),
+                file: PD.Group({
+                    model: PD.File({ accept: modelExts.map(function (e) { return ".".concat(e); }).join(','), label: 'Model' }),
+                    coordinates: PD.File({ accept: coordinatesExts.map(function (e) { return ".".concat(e); }).join(','), label: 'Coordinates' }),
+                }, { isFlat: true }),
+            }, { options: [['url', 'URL'], ['file', 'File']] })
+        };
+    }
+})(function (_a, ctx) {
+    var params = _a.params, state = _a.state;
+    return Task.create('Load Trajectory', function (taskCtx) {
+        return state.transaction(function () { return __awaiter(void 0, void 0, void 0, function () {
+            var s, processUrl, processFile, modelParsed, _a, model, coordinates, _b, dependsOn, traj, structure, e_1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        s = params.source;
+                        if (s.name === 'file' && (s.params.model === null || s.params.coordinates === null)) {
+                            ctx.log.error('No file(s) selected');
+                            return [2 /*return*/];
+                        }
+                        if (s.name === 'url' && (!s.params.model || !s.params.coordinates)) {
+                            ctx.log.error('No URL(s) given');
+                            return [2 /*return*/];
+                        }
+                        processUrl = function (url, format, isBinary) { return __awaiter(void 0, void 0, void 0, function () {
+                            var data, provider;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, ctx.builders.data.download({ url: url, isBinary: isBinary })];
+                                    case 1:
+                                        data = _a.sent();
+                                        provider = ctx.dataFormats.get(format);
+                                        if (!provider) {
+                                            ctx.log.warn("LoadTrajectory: could not find data provider for '".concat(format, "'"));
+                                            return [2 /*return*/];
+                                        }
+                                        return [2 /*return*/, provider.parse(ctx, data)];
+                                }
+                            });
+                        }); };
+                        processFile = function (file) { return __awaiter(void 0, void 0, void 0, function () {
+                            var info, isBinary, data, provider;
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        if (!file)
+                                            throw new Error('No file selected');
+                                        info = getFileInfo(file.file);
+                                        isBinary = ctx.dataFormats.binaryExtensions.has(info.ext);
+                                        return [4 /*yield*/, ctx.builders.data.readFile({ file: file, isBinary: isBinary })];
+                                    case 1:
+                                        data = (_b.sent()).data;
+                                        provider = ctx.dataFormats.auto(info, (_a = data.cell) === null || _a === void 0 ? void 0 : _a.obj);
+                                        if (!!provider) return [3 /*break*/, 3];
+                                        ctx.log.warn("LoadTrajectory: could not find data provider for '".concat(info.ext, "'"));
+                                        return [4 /*yield*/, ctx.state.data.build().delete(data).commit()];
+                                    case 2:
+                                        _b.sent();
+                                        return [2 /*return*/];
+                                    case 3: return [2 /*return*/, provider.parse(ctx, data)];
+                                }
+                            });
+                        }); };
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 16, , 17]);
+                        if (!(s.name === 'url')) return [3 /*break*/, 3];
+                        return [4 /*yield*/, processUrl(s.params.model.url, s.params.model.format, s.params.model.isBinary)];
+                    case 2:
+                        _a = _c.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, processFile(s.params.model)];
+                    case 4:
+                        _a = _c.sent();
+                        _c.label = 5;
+                    case 5:
+                        modelParsed = _a;
+                        model = void 0;
+                        if (!('trajectory' in modelParsed)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, state.build().to(modelParsed.trajectory)
+                                .apply(ModelFromTrajectory, { modelIndex: 0 })
+                                .commit()];
+                    case 6:
+                        model = _c.sent();
+                        return [3 /*break*/, 8];
+                    case 7:
+                        model = modelParsed.topology;
+                        _c.label = 8;
+                    case 8:
+                        if (!(s.name === 'url')) return [3 /*break*/, 10];
+                        return [4 /*yield*/, processUrl(s.params.coordinates.url, s.params.coordinates.format, true)];
+                    case 9:
+                        _b = _c.sent();
+                        return [3 /*break*/, 12];
+                    case 10: return [4 /*yield*/, processFile(s.params.coordinates)];
+                    case 11:
+                        _b = _c.sent();
+                        _c.label = 12;
+                    case 12:
+                        coordinates = _b;
+                        dependsOn = [model.ref, coordinates.ref];
+                        traj = state.build().toRoot()
+                            .apply(TrajectoryFromModelAndCoordinates, {
+                            modelRef: model.ref,
+                            coordinatesRef: coordinates.ref
+                        }, { dependsOn: dependsOn })
+                            .apply(StateTransforms.Model.ModelFromTrajectory, { modelIndex: 0 });
+                        return [4 /*yield*/, state.updateTree(traj).runInContext(taskCtx)];
+                    case 13:
+                        _c.sent();
+                        return [4 /*yield*/, ctx.builders.structure.createStructure(traj.selector)];
+                    case 14:
+                        structure = _c.sent();
+                        return [4 /*yield*/, ctx.builders.structure.representation.applyPreset(structure, 'auto')];
+                    case 15:
+                        _c.sent();
+                        return [3 /*break*/, 17];
+                    case 16:
+                        e_1 = _c.sent();
+                        console.error(e_1);
+                        ctx.log.error("Error loading trajectory");
+                        return [3 /*break*/, 17];
+                    case 17: return [2 /*return*/];
+                }
+            });
+        }); }).runInContext(taskCtx);
+    });
+});

package/lib/mol-plugin-state/actions/volume.js

@@ -12,6 +12,7 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { PluginStateObject } from '../objects';
 import { Asset } from '../../mol-util/assets';
 import { StateTransforms } from '../transforms';
+import { assertUnreachable } from '../../mol-util/type-helpers';
 export { DownloadDensity };
 var DownloadDensity = StateAction.build({
     from: PluginStateObject.Root,
@@ -106,7 +107,7 @@ var DownloadDensity = StateAction.build({
                                 label: "RCSB PDB X-ray Density Server: ".concat(src.params.provider.id)
                             };
                             break;
-                        default: throw new Error("".concat(src.name, " not supported."));
+                        default: assertUnreachable(src);
                     }
                     return [4 /*yield*/, plugin.builders.data.download(downloadParams)];
                 case 1:
@@ -128,7 +129,7 @@ var DownloadDensity = StateAction.build({
                             entryId = src.params.provider.id;
                             provider = plugin.dataFormats.get('dscif');
                             break;
-                        default: throw new Error("".concat(src.name, " not supported."));
+                        default: assertUnreachable(src);
                     }
                     if (!provider) {
                         plugin.log.warn('DownloadDensity: Format provider not found.');

package/lib/mol-plugin-state/formats/{structure.d.ts → coordinates.d.ts}

@@ -1,44 +1,48 @@
 /**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export declare const StructureFormatCategory = "Structure";
-export declare const PsfProvider: {
+export declare const CoordinatesFormatCategory = "Coordinates";
+export { DcdProvider };
+declare const DcdProvider: {
     label: string;
     description: string;
     category: string;
-    stringExtensions: string[];
-    parse: (plugin: import("../../mol-plugin/context").PluginContext, data: import("../../mol-state").StateObjectRef<import("../objects").PluginStateObject.Data.String | import("../objects").PluginStateObject.Data.Binary>) => Promise<{
-        format: import("../../mol-state").StateObjectSelector<import("../objects").PluginStateObject.Format.Psf, import("../../mol-state/transformer").StateTransformer<import("../objects").PluginStateObject.Data.String, import("../objects").PluginStateObject.Format.Psf, import("../../mol-util/param-definition").ParamDefinition.Normalize<{}>>>;
-        topology: import("../../mol-state").StateObjectSelector<import("../objects").PluginStateObject.Molecule.Topology, import("../../mol-state/transformer").StateTransformer<import("../objects").PluginStateObject.Format.Psf, import("../objects").PluginStateObject.Molecule.Topology, import("../../mol-util/param-definition").ParamDefinition.Normalize<{}>>>;
-    }>;
+    binaryExtensions: string[];
+    parse: (plugin: import("../../mol-plugin/context").PluginContext, data: import("../../mol-state").StateObjectRef<import("../objects").PluginStateObject.Data.String | import("../objects").PluginStateObject.Data.Binary>) => Promise<import("../../mol-state").StateObjectSelector<import("../objects").PluginStateObject.Molecule.Coordinates, 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>>>;
 };
-export declare const DcdProvider: {
+declare type DcdProvider = typeof DcdProvider;
+export { XtcProvider };
+declare const XtcProvider: {
     label: string;
     description: string;
     category: string;
     binaryExtensions: string[];
     parse: (plugin: import("../../mol-plugin/context").PluginContext, data: import("../../mol-state").StateObjectRef<import("../objects").PluginStateObject.Data.String | import("../objects").PluginStateObject.Data.Binary>) => Promise<import("../../mol-state").StateObjectSelector<import("../objects").PluginStateObject.Molecule.Coordinates, 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>>>;
 };
-export declare const XtcProvider: {
+declare type XtcProvider = typeof XtcProvider;
+export { TrrProvider };
+declare const TrrProvider: {
     label: string;
     description: string;
     category: string;
     binaryExtensions: string[];
     parse: (plugin: import("../../mol-plugin/context").PluginContext, data: import("../../mol-state").StateObjectRef<import("../objects").PluginStateObject.Data.String | import("../objects").PluginStateObject.Data.Binary>) => Promise<import("../../mol-state").StateObjectSelector<import("../objects").PluginStateObject.Molecule.Coordinates, 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>>>;
 };
-export declare const BuiltInStructureFormats: readonly [readonly ["psf", {
+declare type TrrProvider = typeof TrrProvider;
+export { NctrajProvider };
+declare const NctrajProvider: {
     label: string;
     description: string;
     category: string;
-    stringExtensions: string[];
-    parse: (plugin: import("../../mol-plugin/context").PluginContext, data: import("../../mol-state").StateObjectRef<import("../objects").PluginStateObject.Data.String | import("../objects").PluginStateObject.Data.Binary>) => Promise<{
-        format: import("../../mol-state").StateObjectSelector<import("../objects").PluginStateObject.Format.Psf, import("../../mol-state/transformer").StateTransformer<import("../objects").PluginStateObject.Data.String, import("../objects").PluginStateObject.Format.Psf, import("../../mol-util/param-definition").ParamDefinition.Normalize<{}>>>;
-        topology: import("../../mol-state").StateObjectSelector<import("../objects").PluginStateObject.Molecule.Topology, import("../../mol-state/transformer").StateTransformer<import("../objects").PluginStateObject.Format.Psf, import("../objects").PluginStateObject.Molecule.Topology, import("../../mol-util/param-definition").ParamDefinition.Normalize<{}>>>;
-    }>;
-}], readonly ["dcd", {
+    binaryExtensions: string[];
+    parse: (plugin: import("../../mol-plugin/context").PluginContext, data: import("../../mol-state").StateObjectRef<import("../objects").PluginStateObject.Data.String | import("../objects").PluginStateObject.Data.Binary>) => Promise<import("../../mol-state").StateObjectSelector<import("../objects").PluginStateObject.Molecule.Coordinates, 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>>>;
+};
+declare type NctrajProvider = typeof NctrajProvider;
+export declare type CoordinatesProvider = DcdProvider | XtcProvider | TrrProvider;
+export declare const BuiltInCoordinatesFormats: readonly [readonly ["dcd", {
     label: string;
     description: string;
     category: string;
@@ -50,5 +54,17 @@ export declare const BuiltInStructureFormats: readonly [readonly ["psf", {
     category: string;
     binaryExtensions: string[];
     parse: (plugin: import("../../mol-plugin/context").PluginContext, data: import("../../mol-state").StateObjectRef<import("../objects").PluginStateObject.Data.String | import("../objects").PluginStateObject.Data.Binary>) => Promise<import("../../mol-state").StateObjectSelector<import("../objects").PluginStateObject.Molecule.Coordinates, 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>>>;
+}], readonly ["trr", {
+    label: string;
+    description: string;
+    category: string;
+    binaryExtensions: string[];
+    parse: (plugin: import("../../mol-plugin/context").PluginContext, data: import("../../mol-state").StateObjectRef<import("../objects").PluginStateObject.Data.String | import("../objects").PluginStateObject.Data.Binary>) => Promise<import("../../mol-state").StateObjectSelector<import("../objects").PluginStateObject.Molecule.Coordinates, 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>>>;
+}], readonly ["nctraj", {
+    label: string;
+    description: string;
+    category: string;
+    binaryExtensions: string[];
+    parse: (plugin: import("../../mol-plugin/context").PluginContext, data: import("../../mol-state").StateObjectRef<import("../objects").PluginStateObject.Data.String | import("../objects").PluginStateObject.Data.Binary>) => Promise<import("../../mol-state").StateObjectSelector<import("../objects").PluginStateObject.Molecule.Coordinates, 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>>>;
 }]];
-export declare type BuildInStructureFormat = (typeof BuiltInStructureFormats)[number][0];
+export declare type BuiltInCoordinatesFormat = (typeof BuiltInCoordinatesFormats)[number][0];

package/lib/mol-plugin-state/formats/coordinates.js

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { StateTransforms } from '../transforms';
+import { DataFormatProvider } from './provider';
+export var CoordinatesFormatCategory = 'Coordinates';
+export { DcdProvider };
+var DcdProvider = DataFormatProvider({
+    label: 'DCD',
+    description: 'DCD',
+    category: CoordinatesFormatCategory,
+    binaryExtensions: ['dcd'],
+    parse: function (plugin, data) {
+        var coordinates = plugin.state.data.build()
+            .to(data)
+            .apply(StateTransforms.Model.CoordinatesFromDcd);
+        return coordinates.commit();
+    }
+});
+export { XtcProvider };
+var XtcProvider = DataFormatProvider({
+    label: 'XTC',
+    description: 'XTC',
+    category: CoordinatesFormatCategory,
+    binaryExtensions: ['xtc'],
+    parse: function (plugin, data) {
+        var coordinates = plugin.state.data.build()
+            .to(data)
+            .apply(StateTransforms.Model.CoordinatesFromXtc);
+        return coordinates.commit();
+    }
+});
+export { TrrProvider };
+var TrrProvider = DataFormatProvider({
+    label: 'TRR',
+    description: 'TRR',
+    category: CoordinatesFormatCategory,
+    binaryExtensions: ['trr'],
+    parse: function (plugin, data) {
+        var coordinates = plugin.state.data.build()
+            .to(data)
+            .apply(StateTransforms.Model.CoordinatesFromTrr);
+        return coordinates.commit();
+    }
+});
+export { NctrajProvider };
+var NctrajProvider = DataFormatProvider({
+    label: 'NCTRAJ',
+    description: 'NCTRAJ',
+    category: CoordinatesFormatCategory,
+    binaryExtensions: ['nc', 'nctraj'],
+    parse: function (plugin, data) {
+        var coordinates = plugin.state.data.build()
+            .to(data)
+            .apply(StateTransforms.Model.CoordinatesFromNctraj);
+        return coordinates.commit();
+    }
+});
+export var BuiltInCoordinatesFormats = [
+    ['dcd', DcdProvider],
+    ['xtc', XtcProvider],
+    ['trr', TrrProvider],
+    ['nctraj', NctrajProvider],
+];