molstar 3.3.1 → 3.4.0

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);
         }
     }

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

@@ -0,0 +1,73 @@
+/**
+ * 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 TopologyFormatCategory = "Topology";
+export { PsfProvider };
+declare const PsfProvider: {
+    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<{}>>>;
+    }>;
+};
+declare type PsfProvider = typeof PsfProvider;
+export { PrmtopProvider };
+declare const PrmtopProvider: {
+    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.Prmtop, import("../../mol-state/transformer").StateTransformer<import("../objects").PluginStateObject.Data.String, import("../objects").PluginStateObject.Format.Prmtop, 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.Prmtop, import("../objects").PluginStateObject.Molecule.Topology, import("../../mol-util/param-definition").ParamDefinition.Normalize<{}>>>;
+    }>;
+};
+declare type PrmtopProvider = typeof PrmtopProvider;
+export { TopProvider };
+declare const TopProvider: {
+    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.Top, import("../../mol-state/transformer").StateTransformer<import("../objects").PluginStateObject.Data.String, import("../objects").PluginStateObject.Format.Top, 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.Top, import("../objects").PluginStateObject.Molecule.Topology, import("../../mol-util/param-definition").ParamDefinition.Normalize<{}>>>;
+    }>;
+};
+declare type TopProvider = typeof TopProvider;
+export declare type TopologyProvider = PsfProvider;
+export declare const BuiltInTopologyFormats: readonly [readonly ["psf", {
+    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 ["prmtop", {
+    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.Prmtop, import("../../mol-state/transformer").StateTransformer<import("../objects").PluginStateObject.Data.String, import("../objects").PluginStateObject.Format.Prmtop, 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.Prmtop, import("../objects").PluginStateObject.Molecule.Topology, import("../../mol-util/param-definition").ParamDefinition.Normalize<{}>>>;
+    }>;
+}], readonly ["top", {
+    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.Top, import("../../mol-state/transformer").StateTransformer<import("../objects").PluginStateObject.Data.String, import("../objects").PluginStateObject.Format.Top, 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.Top, import("../objects").PluginStateObject.Molecule.Topology, import("../../mol-util/param-definition").ParamDefinition.Normalize<{}>>>;
+    }>;
+}]];
+export declare type BuiltInTopologyFormat = (typeof BuiltInTopologyFormats)[number][0];

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

@@ -0,0 +1,84 @@
+/**
+ * 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 { __awaiter, __generator } from "tslib";
+import { StateTransforms } from '../transforms';
+import { DataFormatProvider } from './provider';
+export var TopologyFormatCategory = 'Topology';
+export { PsfProvider };
+var PsfProvider = DataFormatProvider({
+    label: 'PSF',
+    description: 'PSF',
+    category: TopologyFormatCategory,
+    stringExtensions: ['psf'],
+    parse: function (plugin, data) { return __awaiter(void 0, void 0, void 0, function () {
+        var format, topology;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    format = plugin.state.data.build()
+                        .to(data)
+                        .apply(StateTransforms.Data.ParsePsf, {}, { state: { isGhost: true } });
+                    topology = format.apply(StateTransforms.Model.TopologyFromPsf);
+                    return [4 /*yield*/, format.commit()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, { format: format.selector, topology: topology.selector }];
+            }
+        });
+    }); }
+});
+export { PrmtopProvider };
+var PrmtopProvider = DataFormatProvider({
+    label: 'PRMTOP',
+    description: 'PRMTOP',
+    category: TopologyFormatCategory,
+    stringExtensions: ['prmtop', 'parm7'],
+    parse: function (plugin, data) { return __awaiter(void 0, void 0, void 0, function () {
+        var format, topology;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    format = plugin.state.data.build()
+                        .to(data)
+                        .apply(StateTransforms.Data.ParsePrmtop, {}, { state: { isGhost: true } });
+                    topology = format.apply(StateTransforms.Model.TopologyFromPrmtop);
+                    return [4 /*yield*/, format.commit()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, { format: format.selector, topology: topology.selector }];
+            }
+        });
+    }); }
+});
+export { TopProvider };
+var TopProvider = DataFormatProvider({
+    label: 'TOP',
+    description: 'TOP',
+    category: TopologyFormatCategory,
+    stringExtensions: ['top'],
+    parse: function (plugin, data) { return __awaiter(void 0, void 0, void 0, function () {
+        var format, topology;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    format = plugin.state.data.build()
+                        .to(data)
+                        .apply(StateTransforms.Data.ParseTop, {}, { state: { isGhost: true } });
+                    topology = format.apply(StateTransforms.Model.TopologyFromTop);
+                    return [4 /*yield*/, format.commit()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, { format: format.selector, topology: topology.selector }];
+            }
+        });
+    }); }
+});
+export var BuiltInTopologyFormats = [
+    ['psf', PsfProvider],
+    ['prmtop', PrmtopProvider],
+    ['top', TopProvider],
+];

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

@@ -11,6 +11,7 @@ import { PluginStateObject as SO } from '../objects';
 import { StructureSelectionQueries } from './structure-selection-query';
 import { StateTransformer, StateObject } from '../../mol-state';
 import { Script } from '../../mol-script/script';
+import { assertUnreachable } from '../../mol-util/type-helpers';
 export var StaticStructureComponentTypes = [
     'all',
     'polymer',
@@ -86,7 +87,7 @@ export function createStructureComponent(a, params, cache) {
                     query = StructureSelectionQueries.coarse.query;
                     label = 'Coarse';
                     break;
-                default: throw new Error("".concat(params.type, " is a not valid complex element."));
+                default: assertUnreachable(params.type);
             }
             var result = query(new QueryContext(a));
             component = Sel.unionStructure(result);

package/lib/mol-plugin-state/manager/snapshots.js

@@ -262,7 +262,7 @@ var PluginStateSnapshotManager = /** @class */ (function (_super) {
     };
     PluginStateSnapshotManager.prototype.open = function (file) {
         return __awaiter(this, void 0, void 0, function () {
-            var fn, data, snapshot, data, assets_1, stateFile, stateData, file_1, json, _a, _b, _i, json_1, _c, id, asset, snapshot, e_1;
+            var fn, data, snapshot, data, assetData_1, stateFile, stateData, file_1, json, _a, _b, _i, json_1, _c, id, asset, snapshot, e_1;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
@@ -286,12 +286,12 @@ var PluginStateSnapshotManager = /** @class */ (function (_super) {
                     case 2: return [4 /*yield*/, this.plugin.runTask(readFromFile(file, 'zip'))];
                     case 3:
                         data = _d.sent();
-                        assets_1 = Object.create(null);
+                        assetData_1 = Object.create(null);
                         objectForEach(data, function (v, k) {
                             if (k === 'state.json' || k === 'assets.json')
                                 return;
                             var name = k.substring(k.indexOf('/') + 1);
-                            assets_1[name] = new File([v], name);
+                            assetData_1[name] = v;
                         });
                         stateFile = new File([data['state.json']], 'state.json');
                         return [4 /*yield*/, this.plugin.runTask(readFromFile(stateFile, 'string'))];
@@ -305,7 +305,7 @@ var PluginStateSnapshotManager = /** @class */ (function (_super) {
                         json = _b.apply(_a, [_d.sent()]);
                         for (_i = 0, json_1 = json; _i < json_1.length; _i++) {
                             _c = json_1[_i], id = _c[0], asset = _c[1];
-                            this.plugin.managers.asset.set(asset, assets_1[id]);
+                            this.plugin.managers.asset.set(asset, new File([assetData_1[id]], asset.name));
                         }
                         _d.label = 6;
                     case 6:

package/lib/mol-plugin-state/objects.d.ts

@@ -1,5 +1,5 @@
 /**
- * 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>
@@ -23,6 +23,8 @@ import { CubeFile } from '../mol-io/reader/cube/parser';
 import { DxFile } from '../mol-io/reader/dx/parser';
 import { Color } from '../mol-util/color/color';
 import { Asset } from '../mol-util/assets';
+import { PrmtopFile } from '../mol-io/reader/prmtop/parser';
+import { TopFile } from '../mol-io/reader/top/parser';
 export declare type TypeClass = 'root' | 'data' | 'prop';
 export declare namespace PluginStateObject {
     export type Any = StateObject<any, TypeInfo>;
@@ -313,6 +315,50 @@ export declare namespace PluginStateObject {
         };
         export class Psf extends Psf_base {
         }
+        const Prmtop_base: {
+            new (data: PrmtopFile, props?: {
+                label: string;
+                description?: string | undefined;
+            } | undefined): {
+                id: import("../mol-util/uuid").UUID;
+                type: TypeInfo;
+                label: string;
+                description?: string | undefined;
+                data: PrmtopFile;
+            };
+            type: TypeInfo;
+            is(obj?: StateObject<any, StateObject.Type<any>> | undefined): obj is {
+                id: import("../mol-util/uuid").UUID;
+                type: TypeInfo;
+                label: string;
+                description?: string | undefined;
+                data: PrmtopFile;
+            };
+        };
+        export class Prmtop extends Prmtop_base {
+        }
+        const Top_base: {
+            new (data: TopFile, props?: {
+                label: string;
+                description?: string | undefined;
+            } | undefined): {
+                id: import("../mol-util/uuid").UUID;
+                type: TypeInfo;
+                label: string;
+                description?: string | undefined;
+                data: TopFile;
+            };
+            type: TypeInfo;
+            is(obj?: StateObject<any, StateObject.Type<any>> | undefined): obj is {
+                id: import("../mol-util/uuid").UUID;
+                type: TypeInfo;
+                label: string;
+                description?: string | undefined;
+                data: TopFile;
+            };
+        };
+        export class Top extends Top_base {
+        }
         const Ply_base: {
             new (data: PlyFile, props?: {
                 label: string;

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

@@ -1,5 +1,5 @@
 /**
- * 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>
@@ -102,6 +102,22 @@ export var PluginStateObject;
             return Psf;
         }(PluginStateObject.Create({ name: 'PSF File', typeClass: 'Data' })));
         Format.Psf = Psf;
+        var Prmtop = /** @class */ (function (_super) {
+            __extends(Prmtop, _super);
+            function Prmtop() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            return Prmtop;
+        }(PluginStateObject.Create({ name: 'PRMTOP File', typeClass: 'Data' })));
+        Format.Prmtop = Prmtop;
+        var Top = /** @class */ (function (_super) {
+            __extends(Top, _super);
+            function Top() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            return Top;
+        }(PluginStateObject.Create({ name: 'TOP File', typeClass: 'Data' })));
+        Format.Top = Top;
         var Ply = /** @class */ (function (_super) {
             __extends(Ply, _super);
             function Ply() {

package/lib/mol-plugin-state/transforms/data.d.ts

@@ -16,6 +16,8 @@ export { ParseBlob };
 export { ParseCif };
 export { ParseCube };
 export { ParsePsf };
+export { ParsePrmtop };
+export { ParseTop };
 export { ParsePly };
 export { ParseCcp4 };
 export { ParseDsn6 };
@@ -64,6 +66,10 @@ declare type ParseCube = typeof ParseCube;
 declare const ParseCube: StateTransformer<SO.Data.String, SO.Format.Cube, PD.Normalize<{}>>;
 declare type ParsePsf = typeof ParsePsf;
 declare const ParsePsf: StateTransformer<SO.Data.String, SO.Format.Psf, PD.Normalize<{}>>;
+declare type ParsePrmtop = typeof ParsePrmtop;
+declare const ParsePrmtop: StateTransformer<SO.Data.String, SO.Format.Prmtop, PD.Normalize<{}>>;
+declare type ParseTop = typeof ParseTop;
+declare const ParseTop: StateTransformer<SO.Data.String, SO.Format.Top, PD.Normalize<{}>>;
 declare type ParsePly = typeof ParsePly;
 declare const ParsePly: StateTransformer<SO.Data.String, SO.Format.Ply, PD.Normalize<{}>>;
 declare type ParseCcp4 = typeof ParseCcp4;

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

@@ -19,6 +19,9 @@ import { Asset } from '../../mol-util/assets';
 import { parseCube } from '../../mol-io/reader/cube/parser';
 import { parseDx } from '../../mol-io/reader/dx/parser';
 import { ColorNames } from '../../mol-util/color/names';
+import { assertUnreachable } from '../../mol-util/type-helpers';
+import { parsePrmtop } from '../../mol-io/reader/prmtop/parser';
+import { parseTop } from '../../mol-io/reader/top/parser';
 export { Download };
 export { DownloadBlob };
 export { RawData };
@@ -27,6 +30,8 @@ export { ParseBlob };
 export { ParseCif };
 export { ParseCube };
 export { ParsePsf };
+export { ParsePrmtop };
+export { ParseTop };
 export { ParsePly };
 export { ParseCcp4 };
 export { ParseDsn6 };
@@ -67,9 +72,9 @@ var Download = PluginStateTransform.BuiltIn({
         }); });
     },
     dispose: function (_a) {
-        var _b, _c;
+        var _b;
         var cache = _a.cache;
-        (_c = (_b = cache) === null || _b === void 0 ? void 0 : _b.asset) === null || _c === void 0 ? void 0 : _c.dispose();
+        (_b = cache === null || cache === void 0 ? void 0 : cache.asset) === null || _b === void 0 ? void 0 : _b.dispose();
     },
     update: function (_a) {
         var oldParams = _a.oldParams, newParams = _a.newParams, b = _a.b;
@@ -128,13 +133,12 @@ var DownloadBlob = PluginStateTransform.BuiltIn({
         }); });
     },
     dispose: function (_a, plugin) {
-        var _b;
         var cache = _a.cache;
-        var assets = (_b = cache) === null || _b === void 0 ? void 0 : _b.assets;
+        var assets = cache === null || cache === void 0 ? void 0 : cache.assets;
         if (!assets)
             return;
-        for (var _c = 0, assets_1 = assets; _c < assets_1.length; _c++) {
-            var a = assets_1[_c];
+        for (var _b = 0, assets_1 = assets; _b < assets_1.length; _b++) {
+            var a = assets_1[_b];
             a.dispose();
         }
     }
@@ -177,7 +181,7 @@ var RawData = PluginStateTransform.BuiltIn({
                     return [2 /*return*/, new SO.Data.Binary(p.data, { label: p.label ? p.label : 'Binary' })];
                 }
                 else {
-                    throw new Error('Supplied binary data must be a plain array, ArrayBuffer, or Uint8Array.');
+                    assertUnreachable(p.data);
                 }
                 return [2 /*return*/];
             });
@@ -253,9 +257,9 @@ var ReadFile = PluginStateTransform.BuiltIn({
         }); });
     },
     dispose: function (_a) {
-        var _b, _c;
+        var _b;
         var cache = _a.cache;
-        (_c = (_b = cache) === null || _b === void 0 ? void 0 : _b.asset) === null || _c === void 0 ? void 0 : _c.dispose();
+        (_b = cache === null || cache === void 0 ? void 0 : cache.asset) === null || _b === void 0 ? void 0 : _b.dispose();
     },
     update: function (_a) {
         var _b;
@@ -399,6 +403,54 @@ var ParsePsf = PluginStateTransform.BuiltIn({
         }); });
     }
 });
+var ParsePrmtop = PluginStateTransform.BuiltIn({
+    name: 'parse-prmtop',
+    display: { name: 'Parse PRMTOP', description: 'Parse PRMTOP from String data' },
+    from: [SO.Data.String],
+    to: SO.Format.Prmtop
+})({
+    apply: function (_a) {
+        var _this = this;
+        var a = _a.a;
+        return Task.create('Parse PRMTOP', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
+            var parsed;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, parsePrmtop(a.data).runInContext(ctx)];
+                    case 1:
+                        parsed = _a.sent();
+                        if (parsed.isError)
+                            throw new Error(parsed.message);
+                        return [2 /*return*/, new SO.Format.Prmtop(parsed.result)];
+                }
+            });
+        }); });
+    }
+});
+var ParseTop = PluginStateTransform.BuiltIn({
+    name: 'parse-top',
+    display: { name: 'Parse TOP', description: 'Parse TOP from String data' },
+    from: [SO.Data.String],
+    to: SO.Format.Top
+})({
+    apply: function (_a) {
+        var _this = this;
+        var a = _a.a;
+        return Task.create('Parse TOP', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
+            var parsed;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, parseTop(a.data).runInContext(ctx)];
+                    case 1:
+                        parsed = _a.sent();
+                        if (parsed.isError)
+                            throw new Error(parsed.message);
+                        return [2 /*return*/, new SO.Format.Top(parsed.result)];
+                }
+            });
+        }); });
+    }
+});
 var ParsePly = PluginStateTransform.BuiltIn({
     name: 'parse-ply',
     display: { name: 'Parse PLY', description: 'Parse PLY from String data' },

package/lib/mol-plugin-state/transforms/model.d.ts

@@ -1,5 +1,5 @@
 /**
- * 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>
@@ -12,7 +12,11 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { PluginStateObject as SO } from '../objects';
 export { CoordinatesFromDcd };
 export { CoordinatesFromXtc };
+export { CoordinatesFromTrr };
+export { CoordinatesFromNctraj };
 export { TopologyFromPsf };
+export { TopologyFromPrmtop };
+export { TopologyFromTop };
 export { TrajectoryFromModelAndCoordinates };
 export { TrajectoryFromBlob };
 export { TrajectoryFromMmCif };
@@ -39,10 +43,18 @@ export { CustomStructureProperties };
 export { ShapeFromPly };
 declare type CoordinatesFromDcd = typeof CoordinatesFromDcd;
 declare const CoordinatesFromDcd: StateTransformer<SO.Data.Binary, SO.Molecule.Coordinates, PD.Normalize<{}>>;
-declare type CoordinatesFromXtc = typeof CoordinatesFromDcd;
+declare type CoordinatesFromXtc = typeof CoordinatesFromXtc;
 declare const CoordinatesFromXtc: StateTransformer<SO.Data.Binary, SO.Molecule.Coordinates, PD.Normalize<{}>>;
+declare type CoordinatesFromTrr = typeof CoordinatesFromTrr;
+declare const CoordinatesFromTrr: StateTransformer<SO.Data.Binary, SO.Molecule.Coordinates, PD.Normalize<{}>>;
+declare type CoordinatesFromNctraj = typeof CoordinatesFromNctraj;
+declare const CoordinatesFromNctraj: StateTransformer<SO.Data.Binary, SO.Molecule.Coordinates, PD.Normalize<{}>>;
 declare type TopologyFromPsf = typeof TopologyFromPsf;
 declare const TopologyFromPsf: StateTransformer<SO.Format.Psf, SO.Molecule.Topology, PD.Normalize<{}>>;
+declare type TopologyFromPrmtop = typeof TopologyFromPrmtop;
+declare const TopologyFromPrmtop: StateTransformer<SO.Format.Prmtop, SO.Molecule.Topology, PD.Normalize<{}>>;
+declare type TopologyFromTop = typeof TopologyFromTop;
+declare const TopologyFromTop: StateTransformer<SO.Format.Top, SO.Molecule.Topology, PD.Normalize<{}>>;
 declare type TrajectoryFromModelAndCoordinates = typeof TrajectoryFromModelAndCoordinates;
 declare const TrajectoryFromModelAndCoordinates: StateTransformer<SO.Root, SO.Molecule.Trajectory, PD.Normalize<{
     modelRef: string;