molstar 3.0.1 → 3.0.2

package/lib/commonjs/mol-model-formats/structure/common/property.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatPropertyProvider = void 0;
+var FormatRegistry = /** @class */ (function () {
+    function FormatRegistry() {
+        this.map = new Map();
+        this.applicable = new Map();
+    }
+    FormatRegistry.prototype.add = function (kind, obtain, applicable) {
+        this.map.set(kind, obtain);
+        if (applicable)
+            this.applicable.set(kind, applicable);
+    };
+    FormatRegistry.prototype.remove = function (kind) {
+        this.map.delete(kind);
+        this.applicable.delete(kind);
+    };
+    FormatRegistry.prototype.get = function (kind) {
+        return this.map.get(kind);
+    };
+    FormatRegistry.prototype.isApplicable = function (model) {
+        var isApplicable = this.applicable.get(model.sourceData.kind);
+        return isApplicable ? isApplicable(model) : true;
+    };
+    return FormatRegistry;
+}());
+var FormatPropertyProvider;
+(function (FormatPropertyProvider) {
+    function create(descriptor) {
+        var name = descriptor.name;
+        var formatRegistry = new FormatRegistry();
+        return {
+            descriptor: descriptor,
+            formatRegistry: formatRegistry,
+            isApplicable: function (model) {
+                return formatRegistry.isApplicable(model);
+            },
+            get: function (model) {
+                if (model._staticPropertyData[name])
+                    return model._staticPropertyData[name];
+                if (model.customProperties.has(descriptor))
+                    return;
+                var obtain = formatRegistry.get(model.sourceData.kind);
+                if (!obtain)
+                    return;
+                model._staticPropertyData[name] = obtain(model);
+                model.customProperties.add(descriptor);
+                return model._staticPropertyData[name];
+            },
+            set: function (model, value) {
+                model._staticPropertyData[name] = value;
+            },
+            delete: function (model) {
+                delete model._staticPropertyData[name];
+            }
+        };
+    }
+    FormatPropertyProvider.create = create;
+})(FormatPropertyProvider || (FormatPropertyProvider = {}));
+exports.FormatPropertyProvider = FormatPropertyProvider;
+//# sourceMappingURL=property.js.map

package/lib/commonjs/mol-model-formats/structure/common/util.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+export declare const getChainId: (a: number) => string;

package/lib/commonjs/mol-model-formats/structure/common/util.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChainId = void 0;
+var memoize_1 = require("../../../mol-util/memoize");
+var ChainIdAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+function _getChainId(index) {
+    var n = ChainIdAlphabet.length;
+    var j = index;
+    var k = 0;
+    var chainId = ChainIdAlphabet[j % n];
+    while (j >= n) {
+        j = Math.floor(j / n);
+        chainId += ChainIdAlphabet[j % n];
+        k += 1;
+    }
+    if (k >= 5) {
+        console.warn('getChainId overflow');
+    }
+    return chainId;
+}
+exports.getChainId = (0, memoize_1.memoize1)(_getChainId);
+//# sourceMappingURL=util.js.map

package/lib/commonjs/mol-model-formats/structure/cube.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trajectoryFromCube = void 0;
+var tslib_1 = require("tslib");
+var db_1 = require("../../mol-data/db");
+var types_1 = require("../../mol-model/structure/model/types");
+var mol_task_1 = require("../../mol-task");
+var parser_1 = require("./basic/parser");
+var schema_1 = require("./basic/schema");
+var component_1 = require("./common/component");
+var entity_1 = require("./common/entity");
+function getModels(cube, ctx) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var atoms, MOL, A, type_symbol, seq_id, atom_site, entityBuilder, componentBuilder, basics;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    atoms = cube.atoms;
+                    MOL = db_1.Column.ofConst('MOL', cube.atoms.count, db_1.Column.Schema.str);
+                    A = db_1.Column.ofConst('A', cube.atoms.count, db_1.Column.Schema.str);
+                    type_symbol = db_1.Column.ofArray({ array: db_1.Column.mapToArray(atoms.number, function (n) { return (0, types_1.getElementFromAtomicNumber)(n); }), schema: db_1.Column.Schema.Aliased(db_1.Column.Schema.str) });
+                    seq_id = db_1.Column.ofConst(1, atoms.count, db_1.Column.Schema.int);
+                    atom_site = db_1.Table.ofPartialColumns(schema_1.BasicSchema.atom_site, {
+                        auth_asym_id: A,
+                        auth_atom_id: type_symbol,
+                        auth_comp_id: MOL,
+                        auth_seq_id: seq_id,
+                        Cartn_x: db_1.Column.asArrayColumn(atoms.x, Float32Array),
+                        Cartn_y: db_1.Column.asArrayColumn(atoms.y, Float32Array),
+                        Cartn_z: db_1.Column.asArrayColumn(atoms.z, Float32Array),
+                        id: db_1.Column.range(0, atoms.count - 1),
+                        label_asym_id: A,
+                        label_atom_id: type_symbol,
+                        label_comp_id: MOL,
+                        label_seq_id: seq_id,
+                        label_entity_id: db_1.Column.ofConst('1', atoms.count, db_1.Column.Schema.str),
+                        occupancy: db_1.Column.ofConst(1, atoms.count, db_1.Column.Schema.float),
+                        type_symbol: type_symbol,
+                        pdbx_PDB_model_num: db_1.Column.ofConst(1, atoms.count, db_1.Column.Schema.int),
+                    }, atoms.count);
+                    entityBuilder = new entity_1.EntityBuilder();
+                    entityBuilder.setNames([['MOL', 'Unknown Entity']]);
+                    entityBuilder.getEntityId('MOL', 0 /* Unknown */, 'A');
+                    componentBuilder = new component_1.ComponentBuilder(seq_id, type_symbol);
+                    componentBuilder.setNames([['MOL', 'Unknown Molecule']]);
+                    componentBuilder.add('MOL', 0);
+                    basics = (0, schema_1.createBasic)({
+                        entity: entityBuilder.getEntityTable(),
+                        chem_comp: componentBuilder.getChemCompTable(),
+                        atom_site: atom_site
+                    });
+                    return [4 /*yield*/, (0, parser_1.createModels)(basics, MolFormat.create(cube), ctx)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+var MolFormat;
+(function (MolFormat) {
+    function is(x) {
+        return (x === null || x === void 0 ? void 0 : x.kind) === 'cube';
+    }
+    MolFormat.is = is;
+    function create(cube) {
+        return { kind: 'cube', name: cube.header.comment1, data: cube };
+    }
+    MolFormat.create = create;
+})(MolFormat || (MolFormat = {}));
+function trajectoryFromCube(cube) {
+    return mol_task_1.Task.create('Parse Cube', function (ctx) { return getModels(cube, ctx); });
+}
+exports.trajectoryFromCube = trajectoryFromCube;
+//# sourceMappingURL=cube.js.map

package/lib/commonjs/mol-model-formats/structure/dcd.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Task } from '../../mol-task';
+import { DcdFile } from '../../mol-io/reader/dcd/parser';
+import { Coordinates } from '../../mol-model/structure/coordinates';
+export declare function coordinatesFromDcd(dcdFile: DcdFile): Task<Coordinates>;

package/lib/commonjs/mol-model-formats/structure/dcd.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coordinatesFromDcd = void 0;
+var tslib_1 = require("tslib");
+var mol_task_1 = require("../../mol-task");
+var coordinates_1 = require("../../mol-model/structure/coordinates");
+var linear_algebra_1 = require("../../mol-math/linear-algebra");
+var misc_1 = require("../../mol-math/misc");
+var cell_1 = require("../../mol-math/geometry/spacegroup/cell");
+var common_1 = require("../../mol-math/linear-algebra/3d/common");
+var charmmTimeUnitFactor = 20.45482949774598;
+function coordinatesFromDcd(dcdFile) {
+    var _this = this;
+    return mol_task_1.Task.create('Parse DCD', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+        var header, deltaTime, offsetTime, frames, i, il, dcdFrame, frame, c;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ctx.update('Converting to coordinates')];
+                case 1:
+                    _a.sent();
+                    header = dcdFile.header;
+                    deltaTime = header.DELTA
+                        ? (0, coordinates_1.Time)(header.DELTA * charmmTimeUnitFactor, 'ps')
+                        : (0, coordinates_1.Time)(1, 'step');
+                    offsetTime = header.ISTART >= 1
+                        ? (0, coordinates_1.Time)((header.ISTART - 1) * deltaTime.value, deltaTime.unit)
+                        : (0, coordinates_1.Time)(0, deltaTime.unit);
+                    frames = [];
+                    for (i = 0, il = dcdFile.frames.length; i < il; ++i) {
+                        dcdFrame = dcdFile.frames[i];
+                        frame = {
+                            elementCount: dcdFrame.elementCount,
+                            time: (0, coordinates_1.Time)(offsetTime.value + deltaTime.value * i, deltaTime.unit),
+                            x: dcdFrame.x,
+                            y: dcdFrame.y,
+                            z: dcdFrame.z,
+                            xyzOrdering: { isIdentity: true }
+                        };
+                        if (dcdFrame.cell) {
+                            c = dcdFrame.cell;
+                            if (c[1] >= -1 && c[1] <= 1 && c[3] >= -1 && c[3] <= 1 && c[4] >= -1 && c[4] <= 1) {
+                                frame.cell = cell_1.Cell.create(linear_algebra_1.Vec3.create(c[0], c[2], c[5]), linear_algebra_1.Vec3.create((0, misc_1.degToRad)(90 - Math.asin(c[1]) * 90 / misc_1.halfPI), (0, misc_1.degToRad)(90 - Math.asin(c[3]) * 90 / misc_1.halfPI), (0, misc_1.degToRad)(90 - Math.asin(c[4]) * 90 / misc_1.halfPI)));
+                            }
+                            else if (c[0] < 0 || c[1] < 0 || c[2] < 0 || c[3] < 0 || c[4] < 0 || c[5] < 0 ||
+                                c[3] > 180 || c[4] > 180 || c[5] > 180) {
+                                frame.cell = cell_1.Cell.fromBasis(linear_algebra_1.Vec3.create(c[0], c[1], c[3]), linear_algebra_1.Vec3.create(c[1], c[2], c[4]), linear_algebra_1.Vec3.create(c[3], c[4], c[5]));
+                            }
+                            else {
+                                frame.cell = cell_1.Cell.create(linear_algebra_1.Vec3.create(c[0], c[2], c[5]), 
+                                // interpret angles very close to 0 as 90 deg
+                                linear_algebra_1.Vec3.create((0, misc_1.degToRad)((0, common_1.equalEps)(c[1], 0, common_1.EPSILON) ? 90 : c[1]), (0, misc_1.degToRad)((0, common_1.equalEps)(c[3], 0, common_1.EPSILON) ? 90 : c[3]), (0, misc_1.degToRad)((0, common_1.equalEps)(c[4], 0, common_1.EPSILON) ? 90 : c[4])));
+                            }
+                        }
+                        frames.push(frame);
+                    }
+                    return [2 /*return*/, coordinates_1.Coordinates.create(frames, deltaTime, offsetTime)];
+            }
+        });
+    }); });
+}
+exports.coordinatesFromDcd = coordinatesFromDcd;
+//# sourceMappingURL=dcd.js.map

package/lib/commonjs/mol-model-formats/structure/gro.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trajectoryFromGRO = exports.GroFormat = void 0;
+var tslib_1 = require("tslib");
+var mol_task_1 = require("../../mol-task");
+var db_1 = require("../../mol-data/db");
+var util_1 = require("./util");
+var types_1 = require("../../mol-model/structure/model/types");
+var component_1 = require("./common/component");
+var util_2 = require("./common/util");
+var entity_1 = require("./common/entity");
+var schema_1 = require("./basic/schema");
+var parser_1 = require("./basic/parser");
+var trajectory_1 = require("../../mol-model/structure/trajectory");
+function getBasic(atoms, modelNum) {
+    var auth_atom_id = atoms.atomName;
+    var auth_comp_id = atoms.residueName;
+    var entityIds = new Array(atoms.count);
+    var asymIds = new Array(atoms.count);
+    var seqIds = new Uint32Array(atoms.count);
+    var ids = new Uint32Array(atoms.count);
+    var entityBuilder = new entity_1.EntityBuilder();
+    var componentBuilder = new component_1.ComponentBuilder(atoms.residueNumber, atoms.atomName);
+    var currentEntityId = '';
+    var currentAsymIndex = 0;
+    var currentAsymId = '';
+    var currentSeqId = 0;
+    var prevMoleculeType = 0 /* Unknown */;
+    var prevResidueNumber = -1;
+    for (var i = 0, il = atoms.count; i < il; ++i) {
+        var residueNumber = atoms.residueNumber.value(i);
+        if (residueNumber !== prevResidueNumber) {
+            var compId = atoms.residueName.value(i);
+            var moleculeType = (0, types_1.getMoleculeType)(componentBuilder.add(compId, i).type, compId);
+            if (moleculeType !== prevMoleculeType || (residueNumber !== prevResidueNumber + 1 && !(
+            // gro format allows only for 5 character residueNumbers, handle overflow here
+            prevResidueNumber === 99999 && residueNumber === 0))) {
+                currentAsymId = (0, util_2.getChainId)(currentAsymIndex);
+                currentAsymIndex += 1;
+                currentSeqId = 0;
+            }
+            currentEntityId = entityBuilder.getEntityId(compId, moleculeType, currentAsymId);
+            currentSeqId += 1;
+            prevResidueNumber = residueNumber;
+            prevMoleculeType = moleculeType;
+        }
+        entityIds[i] = currentEntityId;
+        asymIds[i] = currentAsymId;
+        seqIds[i] = currentSeqId;
+        ids[i] = i;
+    }
+    var auth_asym_id = db_1.Column.ofStringArray(asymIds);
+    var atom_site = db_1.Table.ofPartialColumns(schema_1.BasicSchema.atom_site, {
+        auth_asym_id: auth_asym_id,
+        auth_atom_id: auth_atom_id,
+        auth_comp_id: auth_comp_id,
+        auth_seq_id: atoms.residueNumber,
+        Cartn_x: db_1.Column.ofFloatArray(db_1.Column.mapToArray(atoms.x, function (x) { return x * 10; }, Float32Array)),
+        Cartn_y: db_1.Column.ofFloatArray(db_1.Column.mapToArray(atoms.y, function (y) { return y * 10; }, Float32Array)),
+        Cartn_z: db_1.Column.ofFloatArray(db_1.Column.mapToArray(atoms.z, function (z) { return z * 10; }, Float32Array)),
+        id: db_1.Column.ofIntArray(ids),
+        label_asym_id: auth_asym_id,
+        label_atom_id: auth_atom_id,
+        label_comp_id: auth_comp_id,
+        label_seq_id: db_1.Column.ofIntArray(seqIds),
+        label_entity_id: db_1.Column.ofStringArray(entityIds),
+        occupancy: db_1.Column.ofConst(1, atoms.count, db_1.Column.Schema.float),
+        type_symbol: db_1.Column.ofStringArray(db_1.Column.mapToArray(atoms.atomName, function (s) { return (0, util_1.guessElementSymbolString)(s); })),
+        pdbx_PDB_model_num: db_1.Column.ofConst(modelNum, atoms.count, db_1.Column.Schema.int),
+    }, atoms.count);
+    return (0, schema_1.createBasic)({
+        entity: entityBuilder.getEntityTable(),
+        chem_comp: componentBuilder.getChemCompTable(),
+        atom_site: atom_site
+    });
+}
+var GroFormat;
+(function (GroFormat) {
+    function is(x) {
+        return (x === null || x === void 0 ? void 0 : x.kind) === 'gro';
+    }
+    GroFormat.is = is;
+    function fromGro(gro) {
+        return { kind: 'gro', name: gro.structures[0].header.title, data: gro };
+    }
+    GroFormat.fromGro = fromGro;
+})(GroFormat || (GroFormat = {}));
+exports.GroFormat = GroFormat;
+// TODO reuse static model parts when hierarchy is identical
+//      need to pass all gro.structures as one table into createModels
+function trajectoryFromGRO(gro) {
+    var _this = this;
+    return mol_task_1.Task.create('Parse GRO', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+        var format, models, i, il, basic, m;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    format = GroFormat.fromGro(gro);
+                    models = [];
+                    i = 0, il = gro.structures.length;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < il)) return [3 /*break*/, 4];
+                    basic = getBasic(gro.structures[i].atoms, i + 1);
+                    return [4 /*yield*/, (0, parser_1.createModels)(basic, format, ctx)];
+                case 2:
+                    m = _a.sent();
+                    if (m.frameCount === 1) {
+                        models.push(m.representative);
+                    }
+                    _a.label = 3;
+                case 3:
+                    ++i;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, new trajectory_1.ArrayTrajectory(models)];
+            }
+        });
+    }); });
+}
+exports.trajectoryFromGRO = trajectoryFromGRO;
+//# sourceMappingURL=gro.js.map

package/lib/commonjs/mol-model-formats/structure/mmcif.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Copyright (c) 2017-2021 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>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trajectoryFromMmCIF = exports.MmcifFormat = void 0;
+var mol_task_1 = require("../../mol-task");
+var cif_1 = require("../../mol-io/reader/cif");
+var parser_1 = require("./basic/parser");
+var symmetry_1 = require("./property/symmetry");
+var secondary_structure_1 = require("./property/secondary-structure");
+var db_1 = require("../../mol-data/db");
+var anisotropic_1 = require("./property/anisotropic");
+var chem_comp_1 = require("./property/bonds/chem_comp");
+var struct_conn_1 = require("./property/bonds/struct_conn");
+var global_transform_1 = require("../../mol-model/structure/model/properties/global-transform");
+function modelSymmetryFromMmcif(model) {
+    if (!MmcifFormat.is(model.sourceData))
+        return;
+    return symmetry_1.ModelSymmetry.fromData(model.sourceData.data.db);
+}
+symmetry_1.ModelSymmetry.Provider.formatRegistry.add('mmCIF', modelSymmetryFromMmcif);
+function secondaryStructureFromMmcif(model) {
+    if (!MmcifFormat.is(model.sourceData))
+        return;
+    var _a = model.sourceData.data.db, struct_conf = _a.struct_conf, struct_sheet_range = _a.struct_sheet_range;
+    return secondary_structure_1.ModelSecondaryStructure.fromStruct(struct_conf, struct_sheet_range, model.atomicHierarchy);
+}
+secondary_structure_1.ModelSecondaryStructure.Provider.formatRegistry.add('mmCIF', secondaryStructureFromMmcif);
+function atomSiteAnisotropFromMmcif(model) {
+    if (!MmcifFormat.is(model.sourceData))
+        return;
+    var atom_site_anisotrop = model.sourceData.data.db.atom_site_anisotrop;
+    var data = db_1.Table.ofColumns(anisotropic_1.AtomSiteAnisotrop.Schema, atom_site_anisotrop);
+    var elementToAnsiotrop = anisotropic_1.AtomSiteAnisotrop.getElementToAnsiotrop(model.atomicConformation.atomId, atom_site_anisotrop.id);
+    return { data: data, elementToAnsiotrop: elementToAnsiotrop };
+}
+function atomSiteAnisotropApplicableMmcif(model) {
+    if (!MmcifFormat.is(model.sourceData))
+        return false;
+    return model.sourceData.data.db.atom_site_anisotrop.U.isDefined;
+}
+anisotropic_1.AtomSiteAnisotrop.Provider.formatRegistry.add('mmCIF', atomSiteAnisotropFromMmcif, atomSiteAnisotropApplicableMmcif);
+function componentBondFromMmcif(model) {
+    if (!MmcifFormat.is(model.sourceData))
+        return;
+    var chem_comp_bond = model.sourceData.data.db.chem_comp_bond;
+    if (chem_comp_bond._rowCount === 0)
+        return;
+    return {
+        data: chem_comp_bond,
+        entries: chem_comp_1.ComponentBond.getEntriesFromChemCompBond(chem_comp_bond)
+    };
+}
+chem_comp_1.ComponentBond.Provider.formatRegistry.add('mmCIF', componentBondFromMmcif);
+function structConnFromMmcif(model) {
+    if (!MmcifFormat.is(model.sourceData))
+        return;
+    var struct_conn = model.sourceData.data.db.struct_conn;
+    if (struct_conn._rowCount === 0)
+        return;
+    var entries = struct_conn_1.StructConn.getEntriesFromStructConn(struct_conn, model);
+    return {
+        data: struct_conn,
+        byAtomIndex: struct_conn_1.StructConn.getAtomIndexFromEntries(entries),
+        entries: entries,
+    };
+}
+struct_conn_1.StructConn.Provider.formatRegistry.add('mmCIF', structConnFromMmcif);
+global_transform_1.GlobalModelTransformInfo.Provider.formatRegistry.add('mmCIF', global_transform_1.GlobalModelTransformInfo.fromMmCif, global_transform_1.GlobalModelTransformInfo.hasData);
+var MmcifFormat;
+(function (MmcifFormat) {
+    function is(x) {
+        return (x === null || x === void 0 ? void 0 : x.kind) === 'mmCIF';
+    }
+    MmcifFormat.is = is;
+    function fromFrame(frame, db, source) {
+        if (!db)
+            db = cif_1.CIF.schema.mmCIF(frame);
+        return { kind: 'mmCIF', name: db._name, data: { db: db, frame: frame, source: source } };
+    }
+    MmcifFormat.fromFrame = fromFrame;
+})(MmcifFormat || (MmcifFormat = {}));
+exports.MmcifFormat = MmcifFormat;
+function trajectoryFromMmCIF(frame) {
+    var format = MmcifFormat.fromFrame(frame);
+    return mol_task_1.Task.create('Create mmCIF Model', function (ctx) { return (0, parser_1.createModels)(format.data.db, format, ctx); });
+}
+exports.trajectoryFromMmCIF = trajectoryFromMmCIF;
+//# sourceMappingURL=mmcif.js.map

package/lib/commonjs/mol-model-formats/structure/mol.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Copyright (c) 2019-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>
+ * @author Panagiotis Tourlas <panagiot_tourlov@hotmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trajectoryFromMol = exports.MolFormat = exports.getMolModels = void 0;
+var tslib_1 = require("tslib");
+var db_1 = require("../../mol-data/db");
+var parser_1 = require("../../mol-io/reader/mol/parser");
+var mol_task_1 = require("../../mol-task");
+var parser_2 = require("./basic/parser");
+var schema_1 = require("./basic/schema");
+var component_1 = require("./common/component");
+var entity_1 = require("./common/entity");
+var index_pair_1 = require("./property/bonds/index-pair");
+function getMolModels(mol, format, ctx) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var atoms, bonds, formalCharges, MOL, A, type_symbol, seq_id, computedFormalCharges, i, i, atom_site, entityBuilder, componentBuilder, basics, models, indexA, indexB, order, pairBonds;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    atoms = mol.atoms, bonds = mol.bonds, formalCharges = mol.formalCharges;
+                    MOL = db_1.Column.ofConst('MOL', mol.atoms.count, db_1.Column.Schema.str);
+                    A = db_1.Column.ofConst('A', mol.atoms.count, db_1.Column.Schema.str);
+                    type_symbol = db_1.Column.asArrayColumn(atoms.type_symbol);
+                    seq_id = db_1.Column.ofConst(1, atoms.count, db_1.Column.Schema.int);
+                    computedFormalCharges = new Int32Array(mol.atoms.count);
+                    if (formalCharges.atomIdx.rowCount > 0) {
+                        for (i = 0; i < formalCharges.atomIdx.rowCount; i++) {
+                            computedFormalCharges[formalCharges.atomIdx.value(i) - 1] = formalCharges.charge.value(i);
+                        }
+                    }
+                    else {
+                        for (i = 0; i < mol.atoms.count; i++) {
+                            computedFormalCharges[i] = (0, parser_1.formalChargeMapper)(atoms.formal_charge.value(i));
+                        }
+                    }
+                    atom_site = db_1.Table.ofPartialColumns(schema_1.BasicSchema.atom_site, {
+                        auth_asym_id: A,
+                        auth_atom_id: type_symbol,
+                        auth_comp_id: MOL,
+                        auth_seq_id: seq_id,
+                        Cartn_x: db_1.Column.asArrayColumn(atoms.x, Float32Array),
+                        Cartn_y: db_1.Column.asArrayColumn(atoms.y, Float32Array),
+                        Cartn_z: db_1.Column.asArrayColumn(atoms.z, Float32Array),
+                        id: db_1.Column.range(0, atoms.count - 1),
+                        label_asym_id: A,
+                        label_atom_id: type_symbol,
+                        label_comp_id: MOL,
+                        label_seq_id: seq_id,
+                        label_entity_id: db_1.Column.ofConst('1', atoms.count, db_1.Column.Schema.str),
+                        occupancy: db_1.Column.ofConst(1, atoms.count, db_1.Column.Schema.float),
+                        type_symbol: type_symbol,
+                        pdbx_PDB_model_num: db_1.Column.ofConst(1, atoms.count, db_1.Column.Schema.int),
+                        pdbx_formal_charge: db_1.Column.ofIntArray(computedFormalCharges)
+                    }, atoms.count);
+                    entityBuilder = new entity_1.EntityBuilder();
+                    entityBuilder.setNames([['MOL', 'Unknown Entity']]);
+                    entityBuilder.getEntityId('MOL', 0 /* Unknown */, 'A');
+                    componentBuilder = new component_1.ComponentBuilder(seq_id, type_symbol);
+                    componentBuilder.setNames([['MOL', 'Unknown Molecule']]);
+                    componentBuilder.add('MOL', 0);
+                    basics = (0, schema_1.createBasic)({
+                        entity: entityBuilder.getEntityTable(),
+                        chem_comp: componentBuilder.getChemCompTable(),
+                        atom_site: atom_site
+                    });
+                    return [4 /*yield*/, (0, parser_2.createModels)(basics, format !== null && format !== void 0 ? format : MolFormat.create(mol), ctx)];
+                case 1:
+                    models = _a.sent();
+                    if (models.frameCount > 0) {
+                        indexA = db_1.Column.ofIntArray(db_1.Column.mapToArray(bonds.atomIdxA, function (x) { return x - 1; }, Int32Array));
+                        indexB = db_1.Column.ofIntArray(db_1.Column.mapToArray(bonds.atomIdxB, function (x) { return x - 1; }, Int32Array));
+                        order = db_1.Column.asArrayColumn(bonds.order, Int32Array);
+                        pairBonds = index_pair_1.IndexPairBonds.fromData({ pairs: { indexA: indexA, indexB: indexB, order: order }, count: atoms.count });
+                        index_pair_1.IndexPairBonds.Provider.set(models.representative, pairBonds);
+                    }
+                    return [2 /*return*/, models];
+            }
+        });
+    });
+}
+exports.getMolModels = getMolModels;
+var MolFormat;
+(function (MolFormat) {
+    function is(x) {
+        return (x === null || x === void 0 ? void 0 : x.kind) === 'mol';
+    }
+    MolFormat.is = is;
+    function create(mol) {
+        return { kind: 'mol', name: mol.title, data: mol };
+    }
+    MolFormat.create = create;
+})(MolFormat || (MolFormat = {}));
+exports.MolFormat = MolFormat;
+function trajectoryFromMol(mol) {
+    return mol_task_1.Task.create('Parse MOL', function (ctx) { return getMolModels(mol, void 0, ctx); });
+}
+exports.trajectoryFromMol = trajectoryFromMol;
+//# sourceMappingURL=mol.js.map