molstar 3.2.0 → 3.4.0

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,4 +410,169 @@ export var AddTrajectory = StateAction.build({
         }); }).runInContext(taskCtx);
     });
 });
-//# sourceMappingURL=structure.js.map
+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.');
@@ -159,4 +160,3 @@ export var AssignColorVolume = StateAction.build({
     var ref = _a.ref, params = _a.params, state = _a.state;
     return plugin.build().to(ref).apply(StateTransforms.Volume.AssignColorVolume, { ref: params.ref }, { dependsOn: [params.ref] }).commit();
 });
-//# sourceMappingURL=volume.js.map

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

@@ -11,4 +11,3 @@ export var StateActions = {
     Volume: Volume,
     DataFormat: DataFormat
 };
-//# sourceMappingURL=actions.js.map

package/lib/mol-plugin-state/animation/built-in/assembly-unwind.js

@@ -109,4 +109,3 @@ export var AnimateAssemblyUnwind = PluginStateAnimation.create({
         });
     }
 });
-//# sourceMappingURL=assembly-unwind.js.map

package/lib/mol-plugin-state/animation/built-in/camera-rock.js

@@ -56,4 +56,3 @@ export var AnimateCameraRock = PluginStateAnimation.create({
         });
     }
 });
-//# sourceMappingURL=camera-rock.js.map

package/lib/mol-plugin-state/animation/built-in/camera-spin.js

@@ -55,4 +55,3 @@ export var AnimateCameraSpin = PluginStateAnimation.create({
         });
     }
 });
-//# sourceMappingURL=camera-spin.js.map

package/lib/mol-plugin-state/animation/built-in/explode-units.js

@@ -80,4 +80,3 @@ export var AnimateUnitsExplode = PluginStateAnimation.create({
         });
     }
 });
-//# sourceMappingURL=explode-units.js.map

package/lib/mol-plugin-state/animation/built-in/model-index.js

@@ -166,4 +166,3 @@ export var AnimateModelIndex = PluginStateAnimation.create({
         });
     }
 });
-//# sourceMappingURL=model-index.js.map

package/lib/mol-plugin-state/animation/built-in/spin-structure.js

@@ -83,4 +83,3 @@ export var AnimateStructureSpin = PluginStateAnimation.create({
         });
     }
 });
-//# sourceMappingURL=spin-structure.js.map

package/lib/mol-plugin-state/animation/built-in/state-interpolation.js

@@ -75,4 +75,3 @@ export var AnimateStateInterpolation = PluginStateAnimation.create({
         });
     }
 });
-//# sourceMappingURL=state-interpolation.js.map

package/lib/mol-plugin-state/animation/built-in/state-snapshots.js

@@ -91,4 +91,3 @@ export var AnimateStateSnapshots = PluginStateAnimation.create({
         });
     }
 });
-//# sourceMappingURL=state-snapshots.js.map

package/lib/mol-plugin-state/animation/helpers.js

@@ -78,4 +78,3 @@ export function spinStructure(structure, unitTransforms, t, axis, origin) {
         unitTransforms.setTransform(_t, u);
     }
 }
-//# sourceMappingURL=helpers.js.map

package/lib/mol-plugin-state/animation/model.js

@@ -20,4 +20,3 @@ var PluginStateAnimation;
     }
     PluginStateAnimation.getDuration = getDuration;
 })(PluginStateAnimation || (PluginStateAnimation = {}));
-//# sourceMappingURL=model.js.map

package/lib/mol-plugin-state/builder/data.js

@@ -47,4 +47,3 @@ var DataBuilder = /** @class */ (function () {
     return DataBuilder;
 }());
 export { DataBuilder };
-//# sourceMappingURL=data.js.map

package/lib/mol-plugin-state/builder/preset-provider.js

@@ -4,4 +4,3 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 export {};
-//# sourceMappingURL=preset-provider.js.map

package/lib/mol-plugin-state/builder/structure/hierarchy-preset.js

@@ -284,4 +284,3 @@ export var PresetTrajectoryHierarchy = {
     supercell: supercell,
     crystalContacts: crystalContacts,
 };
-//# sourceMappingURL=hierarchy-preset.js.map

package/lib/mol-plugin-state/builder/structure/hierarchy.js

@@ -108,4 +108,3 @@ var TrajectoryHierarchyBuilder = /** @class */ (function () {
     return TrajectoryHierarchyBuilder;
 }());
 export { TrajectoryHierarchyBuilder };
-//# sourceMappingURL=hierarchy.js.map

package/lib/mol-plugin-state/builder/structure/representation-preset.js

@@ -183,9 +183,9 @@ var polymerAndLigand = StructureRepresentationPresetProvider({
                             nonStandard: builder.buildRepresentation(update, components.nonStandard, { type: 'ball-and-stick', typeParams: typeParams, color: color, colorParams: ballAndStickColor }, { tag: 'non-standard' }),
                             branchedBallAndStick: builder.buildRepresentation(update, components.branched, { type: 'ball-and-stick', typeParams: __assign(__assign({}, typeParams), { alpha: 0.3 }), color: color, colorParams: ballAndStickColor }, { tag: 'branched-ball-and-stick' }),
                             branchedSnfg3d: builder.buildRepresentation(update, components.branched, { type: 'carbohydrate', typeParams: typeParams, color: color }, { tag: 'branched-snfg-3d' }),
-                            water: builder.buildRepresentation(update, components.water, { type: waterType, typeParams: __assign(__assign({}, typeParams), { alpha: 0.6 }), color: color, colorParams: { carbonColor: { name: 'element-symbol', params: {} } } }, { tag: 'water' }),
+                            water: builder.buildRepresentation(update, components.water, { type: waterType, typeParams: __assign(__assign({}, typeParams), { alpha: 0.6, visuals: waterType === 'line' ? ['intra-bond', 'element-point'] : undefined }), color: color, colorParams: { carbonColor: { name: 'element-symbol', params: {} } } }, { tag: 'water' }),
                             ion: builder.buildRepresentation(update, components.ion, { type: 'ball-and-stick', typeParams: typeParams, color: color, colorParams: { carbonColor: { name: 'element-symbol', params: {} } } }, { tag: 'ion' }),
-                            lipid: builder.buildRepresentation(update, components.lipid, { type: lipidType, typeParams: __assign(__assign({}, typeParams), { alpha: 0.6 }), color: color, colorParams: { carbonColor: { name: 'element-symbol', params: {} } } }, { tag: 'lipid' }),
+                            lipid: builder.buildRepresentation(update, components.lipid, { type: lipidType, typeParams: __assign(__assign({}, typeParams), { alpha: 0.6, visuals: lipidType === 'line' ? ['intra-bond'] : undefined }), color: color, colorParams: { carbonColor: { name: 'element-symbol', params: {} } } }, { tag: 'lipid' }),
                             coarse: builder.buildRepresentation(update, components.coarse, { type: 'spacefill', typeParams: typeParams, color: color || 'chain-id' }, { tag: 'coarse' })
                         };
                         return [4 /*yield*/, update.commit({ revertOnError: false })];
@@ -494,4 +494,3 @@ export var PresetStructureRepresentations = {
     'coarse-surface': coarseSurface,
     illustrative: illustrative,
 };
-//# sourceMappingURL=representation-preset.js.map

package/lib/mol-plugin-state/builder/structure/representation.js

@@ -150,4 +150,3 @@ var StructureRepresentationBuilder = /** @class */ (function () {
     return StructureRepresentationBuilder;
 }());
 export { StructureRepresentationBuilder };
-//# sourceMappingURL=representation.js.map

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

@@ -202,4 +202,3 @@ var StructureBuilder = /** @class */ (function () {
     return StructureBuilder;
 }());
 export { StructureBuilder };
-//# sourceMappingURL=structure.js.map

package/lib/mol-plugin-state/component.js

@@ -77,4 +77,3 @@ var StatefulPluginComponent = /** @class */ (function (_super) {
     return StatefulPluginComponent;
 }(PluginComponent));
 export { StatefulPluginComponent };
-//# sourceMappingURL=component.js.map

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],
+];

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

@@ -25,4 +25,3 @@ export function guessCifVariant(info, data) {
     }
     return -1;
 }
-//# sourceMappingURL=provider.js.map

package/lib/mol-plugin-state/formats/registry.d.ts

@@ -1,5 +1,5 @@
 /**
- * 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>
  * @author David Sehnal <david.sehnal@gmail.com>
@@ -13,10 +13,10 @@ export declare class DataFormatRegistry {
     private _extensions;
     private _binaryExtensions;
     private _options;
-    get types(): [string, string][];
+    get types(): [name: string, label: string][];
     get extensions(): Set<string>;
     get binaryExtensions(): Set<string>;
-    get options(): [string, string, string][];
+    get options(): [name: string, label: string, category: string][];
     constructor();
     private _clear;
     add(name: string, provider: DataFormatProvider): void;

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

@@ -1,5 +1,5 @@
 /**
- * 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>
  * @author David Sehnal <david.sehnal@gmail.com>
@@ -7,7 +7,8 @@
 import { BuiltInTrajectoryFormats } from './trajectory';
 import { BuiltInVolumeFormats } from './volume';
 import { BuiltInShapeFormats } from './shape';
-import { BuiltInStructureFormats } from './structure';
+import { BuiltInTopologyFormats } from './topology';
+import { BuiltInCoordinatesFormats } from './coordinates';
 var DataFormatRegistry = /** @class */ (function () {
     function DataFormatRegistry() {
         this._list = [];
@@ -19,16 +20,20 @@ var DataFormatRegistry = /** @class */ (function () {
             var _a = BuiltInVolumeFormats_1[_i], id = _a[0], p = _a[1];
             this.add(id, p);
         }
-        for (var _b = 0, BuiltInStructureFormats_1 = BuiltInStructureFormats; _b < BuiltInStructureFormats_1.length; _b++) {
-            var _c = BuiltInStructureFormats_1[_b], id = _c[0], p = _c[1];
+        for (var _b = 0, BuiltInTopologyFormats_1 = BuiltInTopologyFormats; _b < BuiltInTopologyFormats_1.length; _b++) {
+            var _c = BuiltInTopologyFormats_1[_b], id = _c[0], p = _c[1];
             this.add(id, p);
         }
-        for (var _d = 0, BuiltInShapeFormats_1 = BuiltInShapeFormats; _d < BuiltInShapeFormats_1.length; _d++) {
-            var _e = BuiltInShapeFormats_1[_d], id = _e[0], p = _e[1];
+        for (var _d = 0, BuiltInCoordinatesFormats_1 = BuiltInCoordinatesFormats; _d < BuiltInCoordinatesFormats_1.length; _d++) {
+            var _e = BuiltInCoordinatesFormats_1[_d], id = _e[0], p = _e[1];
             this.add(id, p);
         }
-        for (var _f = 0, BuiltInTrajectoryFormats_1 = BuiltInTrajectoryFormats; _f < BuiltInTrajectoryFormats_1.length; _f++) {
-            var _g = BuiltInTrajectoryFormats_1[_f], id = _g[0], p = _g[1];
+        for (var _f = 0, BuiltInShapeFormats_1 = BuiltInShapeFormats; _f < BuiltInShapeFormats_1.length; _f++) {
+            var _g = BuiltInShapeFormats_1[_f], id = _g[0], p = _g[1];
+            this.add(id, p);
+        }
+        for (var _h = 0, BuiltInTrajectoryFormats_1 = BuiltInTrajectoryFormats; _h < BuiltInTrajectoryFormats_1.length; _h++) {
+            var _j = BuiltInTrajectoryFormats_1[_h], id = _j[0], p = _j[1];
             this.add(id, p);
         }
     }
@@ -134,4 +139,3 @@ var DataFormatRegistry = /** @class */ (function () {
     return DataFormatRegistry;
 }());
 export { DataFormatRegistry };
-//# sourceMappingURL=registry.js.map

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

@@ -39,4 +39,3 @@ export var PlyProvider = DataFormatProvider({
 export var BuiltInShapeFormats = [
     ['ply', PlyProvider],
 ];
-//# sourceMappingURL=shape.js.map