drugflow-molstar 0.3.77 → 0.4.1

package/lib/superposition-focus-representation.js

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SuperpositionFocusRepresentation = exports.SuperpositionFocusRepresentationTags = void 0;
-var tslib_1 = require("tslib");
-var structure_1 = require("Molstar/mol-model/structure");
-var structure_representation_params_1 = require("Molstar/mol-plugin-state/helpers/structure-representation-params");
-var transforms_1 = require("Molstar/mol-plugin-state/transforms");
-var behavior_1 = require("Molstar/mol-plugin/behavior");
-var builder_1 = require("Molstar/mol-script/language/builder");
-var mol_state_1 = require("Molstar/mol-state");
-var param_definition_1 = require("Molstar/mol-util/param-definition");
-var commands_1 = require("Molstar/mol-plugin/commands");
-var loci_details_1 = require("./loci-details");
-var SuperpositionFocusRepresentationParams = function (plugin) {
-    var reprParams = transforms_1.StateTransforms.Representation.StructureRepresentation3D.definition.params(void 0, plugin);
+const structure_1 = require("Molstar/mol-model/structure");
+const structure_representation_params_1 = require("Molstar/mol-plugin-state/helpers/structure-representation-params");
+const transforms_1 = require("Molstar/mol-plugin-state/transforms");
+const behavior_1 = require("Molstar/mol-plugin/behavior");
+const builder_1 = require("Molstar/mol-script/language/builder");
+const mol_state_1 = require("Molstar/mol-state");
+const param_definition_1 = require("Molstar/mol-util/param-definition");
+const commands_1 = require("Molstar/mol-plugin/commands");
+const loci_details_1 = require("./loci-details");
+const SuperpositionFocusRepresentationParams = (plugin) => {
+    const reprParams = transforms_1.StateTransforms.Representation.StructureRepresentation3D.definition.params(void 0, plugin);
     return {
         expandRadius: param_definition_1.ParamDefinition.Numeric(5, { min: 1, max: 10, step: 1 }),
         surroundingsParams: param_definition_1.ParamDefinition.Group(reprParams, {
@@ -25,22 +24,14 @@ var SuperpositionFocusRepresentationTags;
 (function (SuperpositionFocusRepresentationTags) {
     SuperpositionFocusRepresentationTags["SurrSel"] = "superposition-focus-surr-sel";
     SuperpositionFocusRepresentationTags["SurrRepr"] = "superposition-focus-surr-repr";
-})(SuperpositionFocusRepresentationTags = exports.SuperpositionFocusRepresentationTags || (exports.SuperpositionFocusRepresentationTags = {}));
-var TagSet = new Set([SuperpositionFocusRepresentationTags.SurrSel, SuperpositionFocusRepresentationTags.SurrRepr]);
-var SuperpositionFocusRepresentationBehavior = /** @class */ (function (_super) {
-    tslib_1.__extends(SuperpositionFocusRepresentationBehavior, _super);
-    function SuperpositionFocusRepresentationBehavior() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(SuperpositionFocusRepresentationBehavior.prototype, "surrLabel", {
-        get: function () { return "[Focus] Surroundings (".concat(this.params.expandRadius, " \u00C5)"); },
-        enumerable: false,
-        configurable: true
-    });
-    SuperpositionFocusRepresentationBehavior.prototype.ensureShape = function (cell) {
-        var state = this.plugin.state.data, tree = state.tree;
-        var builder = state.build();
-        var refs = mol_state_1.StateSelection.findUniqueTagsInSubtree(tree, cell.transform.ref, TagSet);
+})(SuperpositionFocusRepresentationTags || (exports.SuperpositionFocusRepresentationTags = SuperpositionFocusRepresentationTags = {}));
+const TagSet = new Set([SuperpositionFocusRepresentationTags.SurrSel, SuperpositionFocusRepresentationTags.SurrRepr]);
+class SuperpositionFocusRepresentationBehavior extends behavior_1.PluginBehavior.WithSubscribers {
+    get surrLabel() { return `[Focus] Surroundings (${this.params.expandRadius} Å)`; }
+    ensureShape(cell) {
+        const state = this.plugin.state.data, tree = state.tree;
+        const builder = state.build();
+        const refs = mol_state_1.StateSelection.findUniqueTagsInSubtree(tree, cell.transform.ref, TagSet);
         // Selections
         if (!refs[SuperpositionFocusRepresentationTags.SurrSel]) {
             refs[SuperpositionFocusRepresentationTags.SurrSel] = builder
@@ -53,101 +44,72 @@ var SuperpositionFocusRepresentationBehavior = /** @class */ (function (_super)
                 .to(refs[SuperpositionFocusRepresentationTags.SurrSel])
                 .apply(transforms_1.StateTransforms.Representation.StructureRepresentation3D, this.params.surroundingsParams, { tags: SuperpositionFocusRepresentationTags.SurrRepr }).ref;
         }
-        return { state: state, builder: builder, refs: refs };
-    };
-    SuperpositionFocusRepresentationBehavior.prototype.clear = function (root) {
-        var state = this.plugin.state.data;
-        var surrs = state.select(mol_state_1.StateSelection.Generators.byRef(root).subtree().withTag(SuperpositionFocusRepresentationTags.SurrSel));
+        return { state, builder, refs };
+    }
+    clear(root) {
+        const state = this.plugin.state.data;
+        const surrs = state.select(mol_state_1.StateSelection.Generators.byRef(root).subtree().withTag(SuperpositionFocusRepresentationTags.SurrSel));
         if (surrs.length === 0)
             return;
-        var update = state.build();
-        var expression = builder_1.MolScriptBuilder.struct.generator.empty();
-        for (var _i = 0, surrs_1 = surrs; _i < surrs_1.length; _i++) {
-            var s = surrs_1[_i];
-            update.to(s).update(transforms_1.StateTransforms.Model.StructureSelectionFromExpression, function (old) { return (tslib_1.__assign(tslib_1.__assign({}, old), { expression: expression })); });
+        const update = state.build();
+        const expression = builder_1.MolScriptBuilder.struct.generator.empty();
+        for (const s of surrs) {
+            update.to(s).update(transforms_1.StateTransforms.Model.StructureSelectionFromExpression, old => ({ ...old, expression }));
         }
-        return commands_1.PluginCommands.State.Update(this.plugin, { state: state, tree: update, options: { doNotLogTiming: true, doNotUpdateCurrent: true } });
-    };
-    SuperpositionFocusRepresentationBehavior.prototype.focus = function (sourceLoci) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var parent, loci, residueLoci, residueBundle, target, surroundings, lociDeatils, _a, state, builder, refs;
-            var _this = this;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        parent = this.plugin.helpers.substructureParent.get(sourceLoci.structure);
-                        if (!parent || !parent.obj)
-                            return [2 /*return*/];
-                        loci = structure_1.StructureElement.Loci.remap(sourceLoci, parent.obj.data);
-                        residueLoci = structure_1.StructureElement.Loci.extendToWholeResidues(loci);
-                        residueBundle = structure_1.StructureElement.Bundle.fromLoci(residueLoci);
-                        target = structure_1.StructureElement.Bundle.toExpression(residueBundle);
-                        surroundings = builder_1.MolScriptBuilder.struct.modifier.includeSurroundings({
-                            0: target,
-                            radius: this.params.expandRadius,
-                            'as-whole-residues': true
-                        });
-                        lociDeatils = (0, loci_details_1.lociDetails)(sourceLoci);
-                        if (!lociDeatils) {
-                            surroundings = builder_1.MolScriptBuilder.struct.modifier.exceptBy({
-                                0: surroundings,
-                                by: target
-                            });
-                        }
-                        _a = this.ensureShape(parent), state = _a.state, builder = _a.builder, refs = _a.refs;
-                        builder.to(refs[SuperpositionFocusRepresentationTags.SurrSel]).update(transforms_1.StateTransforms.Model.StructureSelectionFromExpression, function (old) { return (tslib_1.__assign(tslib_1.__assign({}, old), { expression: surroundings, label: _this.surrLabel })); });
-                        return [4 /*yield*/, commands_1.PluginCommands.State.Update(this.plugin, { state: state, tree: builder, options: { doNotLogTiming: true, doNotUpdateCurrent: true } })];
-                    case 1:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
+        return commands_1.PluginCommands.State.Update(this.plugin, { state, tree: update, options: { doNotLogTiming: true, doNotUpdateCurrent: true } });
+    }
+    async focus(sourceLoci) {
+        const parent = this.plugin.helpers.substructureParent.get(sourceLoci.structure);
+        if (!parent || !parent.obj)
+            return;
+        const loci = structure_1.StructureElement.Loci.remap(sourceLoci, parent.obj.data);
+        const residueLoci = structure_1.StructureElement.Loci.extendToWholeResidues(loci);
+        const residueBundle = structure_1.StructureElement.Bundle.fromLoci(residueLoci);
+        const target = structure_1.StructureElement.Bundle.toExpression(residueBundle);
+        let surroundings = builder_1.MolScriptBuilder.struct.modifier.includeSurroundings({
+            0: target,
+            radius: this.params.expandRadius,
+            'as-whole-residues': true
         });
-    };
-    SuperpositionFocusRepresentationBehavior.prototype.register = function (ref) {
-        var _this = this;
-        this.subscribeObservable(this.plugin.managers.structure.focus.behaviors.current, function (entry) {
+        const lociDeatils = (0, loci_details_1.lociDetails)(sourceLoci);
+        if (!lociDeatils) {
+            surroundings = builder_1.MolScriptBuilder.struct.modifier.exceptBy({
+                0: surroundings,
+                by: target
+            });
+        }
+        const { state, builder, refs } = this.ensureShape(parent);
+        builder.to(refs[SuperpositionFocusRepresentationTags.SurrSel]).update(transforms_1.StateTransforms.Model.StructureSelectionFromExpression, old => ({ ...old, expression: surroundings, label: this.surrLabel }));
+        await commands_1.PluginCommands.State.Update(this.plugin, { state, tree: builder, options: { doNotLogTiming: true, doNotUpdateCurrent: true } });
+    }
+    register(ref) {
+        this.subscribeObservable(this.plugin.managers.structure.focus.behaviors.current, (entry) => {
             // if (entry) this.focus(entry.loci);
             // else this.clear(StateTransform.RootRef);
-            _this.clear(mol_state_1.StateTransform.RootRef);
+            this.clear(mol_state_1.StateTransform.RootRef);
             if (entry)
-                _this.focus(entry.loci);
-        });
-    };
-    SuperpositionFocusRepresentationBehavior.prototype.update = function (params) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var old, state, builder, all, _i, _a, repr;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        old = this.params;
-                        this.params = params;
-                        state = this.plugin.state.data;
-                        builder = state.build();
-                        all = mol_state_1.StateSelection.Generators.root.subtree();
-                        for (_i = 0, _a = state.select(all.withTag(SuperpositionFocusRepresentationTags.SurrRepr)); _i < _a.length; _i++) {
-                            repr = _a[_i];
-                            builder.to(repr).update(this.params.surroundingsParams);
-                        }
-                        return [4 /*yield*/, commands_1.PluginCommands.State.Update(this.plugin, { state: state, tree: builder, options: { doNotLogTiming: true, doNotUpdateCurrent: true } })];
-                    case 1:
-                        _b.sent();
-                        if (!(params.expandRadius !== old.expandRadius)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.clear(mol_state_1.StateTransform.RootRef)];
-                    case 2:
-                        _b.sent();
-                        _b.label = 3;
-                    case 3: return [2 /*return*/, true];
-                }
-            });
+                this.focus(entry.loci);
         });
-    };
-    return SuperpositionFocusRepresentationBehavior;
-}(behavior_1.PluginBehavior.WithSubscribers));
+    }
+    async update(params) {
+        const old = this.params;
+        this.params = params;
+        const state = this.plugin.state.data;
+        const builder = state.build();
+        const all = mol_state_1.StateSelection.Generators.root.subtree();
+        for (const repr of state.select(all.withTag(SuperpositionFocusRepresentationTags.SurrRepr))) {
+            builder.to(repr).update(this.params.surroundingsParams);
+        }
+        await commands_1.PluginCommands.State.Update(this.plugin, { state, tree: builder, options: { doNotLogTiming: true, doNotUpdateCurrent: true } });
+        if (params.expandRadius !== old.expandRadius)
+            await this.clear(mol_state_1.StateTransform.RootRef);
+        return true;
+    }
+}
 exports.SuperpositionFocusRepresentation = behavior_1.PluginBehavior.create({
     name: 'create-superposition-focus-representation',
     display: { name: 'Superposition Focus Representation' },
     category: 'interaction',
     ctor: SuperpositionFocusRepresentationBehavior,
-    params: function (_, plugin) { return SuperpositionFocusRepresentationParams(plugin); }
+    params: (_, plugin) => SuperpositionFocusRepresentationParams(plugin)
 });

package/lib/superposition-sifts-mapping.d.ts

@@ -13,7 +13,7 @@ export interface AlignmentResult {
     zeroOverlapPairs: [number, number][];
     failedPairs: [number, number][];
 }
-declare type IncludeResidueTest = (traceElementOrFirstAtom: StructureElement.Location<Unit.Atomic>, residueIndex: ResidueIndex, startIndex: ElementIndex, endIndex: ElementIndex) => boolean;
+type IncludeResidueTest = (traceElementOrFirstAtom: StructureElement.Location<Unit.Atomic>, residueIndex: ResidueIndex, startIndex: ElementIndex, endIndex: ElementIndex) => boolean;
 export declare function alignAndSuperposeWithSIFTSMapping(structures: Structure[], options?: {
     traceOnly?: boolean;
     includeResidueTest?: IncludeResidueTest;

package/lib/superposition-sifts-mapping.js

@@ -1,58 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.alignAndSuperposeWithSIFTSMapping = void 0;
-var int_1 = require("Molstar/mol-data/int");
-var minimize_rmsd_1 = require("Molstar/mol-math/linear-algebra/3d/minimize-rmsd");
-var sifts_mapping_1 = require("./sifts-mapping");
-var element_1 = require("Molstar/mol-model/structure/structure/element");
+const int_1 = require("Molstar/mol-data/int");
+const minimize_rmsd_1 = require("Molstar/mol-math/linear-algebra/3d/minimize-rmsd");
+const sifts_mapping_1 = require("./sifts-mapping");
+const element_1 = require("Molstar/mol-model/structure/structure/element");
 function alignAndSuperposeWithSIFTSMapping(structures, options) {
-    var _a, _b;
-    var indexMap = new Map();
-    for (var i = 0; i < structures.length; i++) {
-        var includeResidueTest = (_a = options === null || options === void 0 ? void 0 : options.includeResidueTest) !== null && _a !== void 0 ? _a : _includeAllResidues;
-        if ((options === null || options === void 0 ? void 0 : options.applyTestIndex) && !options.applyTestIndex.includes(i))
+    const indexMap = new Map();
+    for (let i = 0; i < structures.length; i++) {
+        let includeResidueTest = options?.includeResidueTest ?? _includeAllResidues;
+        if (options?.applyTestIndex && !options.applyTestIndex.includes(i))
             includeResidueTest = _includeAllResidues;
-        buildIndex(structures[i], indexMap, i, (_b = options === null || options === void 0 ? void 0 : options.traceOnly) !== null && _b !== void 0 ? _b : true, includeResidueTest);
+        buildIndex(structures[i], indexMap, i, options?.traceOnly ?? true, includeResidueTest);
     }
-    var index = Array.from(indexMap.values());
+    const index = Array.from(indexMap.values());
     // TODO: support non-first structure pivots
-    var pairs = findPairs(structures.length, index);
-    var zeroOverlapPairs = [];
-    var failedPairs = [];
-    var entries = [];
-    for (var _i = 0, pairs_1 = pairs; _i < pairs_1.length; _i++) {
-        var p = pairs_1[_i];
+    const pairs = findPairs(structures.length, index);
+    const zeroOverlapPairs = [];
+    const failedPairs = [];
+    const entries = [];
+    for (const p of pairs) {
         if (p.count === 0) {
             zeroOverlapPairs.push([p.i, p.j]);
         }
         else {
-            var _c = getPositionTables(index, p.i, p.j, p.count), a = _c[0], b = _c[1];
-            var transform = minimize_rmsd_1.MinimizeRmsd.compute({ a: a, b: b });
+            const [a, b] = getPositionTables(index, p.i, p.j, p.count);
+            const transform = minimize_rmsd_1.MinimizeRmsd.compute({ a, b });
             if (Number.isNaN(transform.rmsd)) {
                 failedPairs.push([p.i, p.j]);
             }
             else {
-                entries.push({ transform: transform, pivot: p.i, other: p.j });
+                entries.push({ transform, pivot: p.i, other: p.j });
             }
         }
     }
-    return { entries: entries, zeroOverlapPairs: zeroOverlapPairs, failedPairs: failedPairs };
+    return { entries, zeroOverlapPairs, failedPairs };
 }
 exports.alignAndSuperposeWithSIFTSMapping = alignAndSuperposeWithSIFTSMapping;
 function getPositionTables(index, pivot, other, N) {
-    var xs = minimize_rmsd_1.MinimizeRmsd.Positions.empty(N);
-    var ys = minimize_rmsd_1.MinimizeRmsd.Positions.empty(N);
-    var o = 0;
-    for (var _i = 0, index_1 = index; _i < index_1.length; _i++) {
-        var pivots = index_1[_i].pivots;
-        var a = pivots[pivot];
-        var b = pivots[other];
+    const xs = minimize_rmsd_1.MinimizeRmsd.Positions.empty(N);
+    const ys = minimize_rmsd_1.MinimizeRmsd.Positions.empty(N);
+    let o = 0;
+    for (const { pivots } of index) {
+        const a = pivots[pivot];
+        const b = pivots[other];
         if (!a || !b)
             continue;
-        var l = Math.min(a[2] - a[1], b[2] - b[1]);
+        const l = Math.min(a[2] - a[1], b[2] - b[1]);
         // TODO: check if residue types match?
-        for (var i = 0; i < l; i++) {
-            var eI = (a[1] + i);
+        for (let i = 0; i < l; i++) {
+            let eI = (a[1] + i);
             xs.x[o] = a[0].conformation.x(eI);
             xs.y[o] = a[0].conformation.y(eI);
             xs.z[o] = a[0].conformation.z(eI);
@@ -66,29 +63,28 @@ function getPositionTables(index, pivot, other, N) {
     return [xs, ys];
 }
 function findPairs(N, index) {
-    var pairwiseCounts = [];
-    for (var i = 0; i < N; i++) {
+    const pairwiseCounts = [];
+    for (let i = 0; i < N; i++) {
         pairwiseCounts[i] = [];
-        for (var j = 0; j < N; j++)
+        for (let j = 0; j < N; j++)
             pairwiseCounts[i][j] = 0;
     }
-    for (var _i = 0, index_2 = index; _i < index_2.length; _i++) {
-        var pivots = index_2[_i].pivots;
-        for (var i = 0; i < N; i++) {
+    for (const { pivots } of index) {
+        for (let i = 0; i < N; i++) {
             if (!pivots[i])
                 continue;
-            var lI = pivots[i][2] - pivots[i][1];
-            for (var j = i + 1; j < N; j++) {
+            const lI = pivots[i][2] - pivots[i][1];
+            for (let j = i + 1; j < N; j++) {
                 if (!pivots[j])
                     continue;
-                var lJ = pivots[j][2] - pivots[j][1];
+                const lJ = pivots[j][2] - pivots[j][1];
                 pairwiseCounts[i][j] = pairwiseCounts[i][j] + Math.min(lI, lJ);
             }
         }
     }
-    var ret = [];
-    for (var j = 1; j < N; j++) {
-        ret[j - 1] = { i: 0, j: j, count: pairwiseCounts[0][j] };
+    const ret = [];
+    for (let j = 1; j < N; j++) {
+        ret[j - 1] = { i: 0, j, count: pairwiseCounts[0][j] };
     }
     // TODO: support non-first structure pivots
     // for (let i = 0; i < N - 1; i++) {
@@ -105,31 +101,29 @@ function findPairs(N, index) {
 }
 function _includeAllResidues() { return true; }
 function buildIndex(structure, index, sI, traceOnly, includeTest) {
-    var _a;
-    var loc = element_1.StructureElement.Location.create(structure);
-    for (var _i = 0, _b = structure.units; _i < _b.length; _i++) {
-        var unit = _b[_i];
-        if (unit.kind !== 0 /* Atomic */)
+    const loc = element_1.StructureElement.Location.create(structure);
+    for (const unit of structure.units) {
+        if (unit.kind !== 0 /* Unit.Kind.Atomic */)
             continue;
-        var elements = unit.elements, model = unit.model;
+        const { elements, model } = unit;
         loc.unit = unit;
-        var map = sifts_mapping_1.SIFTSMapping.Provider.get(model).value;
+        const map = sifts_mapping_1.SIFTSMapping.Provider.get(model).value;
         if (!map)
             return;
-        var dbName = map.dbName, accession = map.accession, num = map.num;
-        var chainsIt = int_1.Segmentation.transientSegments(unit.model.atomicHierarchy.chainAtomSegments, elements);
-        var residuesIt = int_1.Segmentation.transientSegments(unit.model.atomicHierarchy.residueAtomSegments, elements);
-        var traceElementIndex = unit.model.atomicHierarchy.derived.residue.traceElementIndex;
+        const { dbName, accession, num } = map;
+        const chainsIt = int_1.Segmentation.transientSegments(unit.model.atomicHierarchy.chainAtomSegments, elements);
+        const residuesIt = int_1.Segmentation.transientSegments(unit.model.atomicHierarchy.residueAtomSegments, elements);
+        const traceElementIndex = unit.model.atomicHierarchy.derived.residue.traceElementIndex;
         while (chainsIt.hasNext) {
-            var chainSegment = chainsIt.move();
+            const chainSegment = chainsIt.move();
             residuesIt.setSegment(chainSegment);
             while (residuesIt.hasNext) {
-                var residueSegment = residuesIt.move();
-                var rI = residueSegment.index;
+                const residueSegment = residuesIt.move();
+                const rI = residueSegment.index;
                 if (!dbName[rI])
                     continue;
-                var traceElement = traceElementIndex[rI];
-                var start = void 0, end = void 0;
+                const traceElement = traceElementIndex[rI];
+                let start, end;
                 if (traceOnly) {
                     start = traceElement;
                     if (start === -1)
@@ -143,12 +137,12 @@ function buildIndex(structure, index, sI, traceOnly, includeTest) {
                 loc.element = (traceElement >= 0 ? traceElement : start);
                 if (!includeTest(loc, rI, start, end))
                     continue;
-                var key = "".concat(dbName[rI], "-").concat(accession[rI].split('-')[0], "-").concat(num[rI]);
+                const key = `${dbName[rI]}-${accession[rI].split('-')[0]}-${num[rI]}`;
                 if (!index.has(key)) {
-                    index.set(key, { key: key, pivots: (_a = {}, _a[sI] = [unit, start, end], _a) });
+                    index.set(key, { key, pivots: { [sI]: [unit, start, end] } });
                 }
                 else {
-                    var entry = index.get(key);
+                    const entry = index.get(key);
                     if (!entry.pivots[sI]) {
                         entry.pivots[sI] = [unit, start, end];
                     }

package/lib/superposition.d.ts

@@ -1,13 +1,13 @@
 import { Mat4 } from 'Molstar/mol-math/linear-algebra';
 import { PluginContext } from 'Molstar/mol-plugin/context';
-declare type ClusterRec = {
+type ClusterRec = {
     pdb_id: string;
     auth_asym_id: string;
     struct_asym_id: string;
     entity_id: string;
     is_representative: boolean;
 };
-export declare type SuperpositionData = {
+export type SuperpositionData = {
     data: ClusterRec[];
     matrix: Mat4[];
 };