drugflow-molstar 0.1.0

package/lib/subscribe-events.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeToComponentEvents = void 0;
+function subscribeToComponentEvents(wrapperCtx) {
+    document.addEventListener('PDB.interactions.click', function (e) {
+        if (typeof e.detail !== 'undefined') {
+            var data = e.detail.interacting_nodes ? { data: e.detail.interacting_nodes } : { data: [e.detail.selected_node] };
+            data.data[0]['focus'] = true;
+            wrapperCtx.visual.select(data);
+        }
+    });
+    document.addEventListener('PDB.interactions.mouseover', function (e) {
+        if (typeof e.detail !== 'undefined') {
+            var data = e.detail.interacting_nodes ? { data: e.detail.interacting_nodes } : { data: [e.detail.selected_node] };
+            wrapperCtx.visual.highlight(data);
+        }
+    });
+    document.addEventListener('PDB.interactions.mouseout', function (e) {
+        wrapperCtx.visual.clearHighlight();
+    });
+    document.addEventListener('PDB.topologyViewer.click', function (e) {
+        if (typeof e.eventData !== 'undefined') {
+            // Create query object from event data
+            var highlightQuery = {
+                entity_id: e.eventData.entityId,
+                struct_asym_id: e.eventData.structAsymId,
+                start_residue_number: e.eventData.residueNumber,
+                end_residue_number: e.eventData.residueNumber,
+                sideChain: true,
+                focus: true
+            };
+            // Call highlightAnnotation
+            wrapperCtx.visual.select({ data: [highlightQuery] });
+        }
+    });
+    document.addEventListener('PDB.topologyViewer.mouseover', function (e) {
+        if (typeof e.eventData !== 'undefined') {
+            // Abort if entryid do not match or viewer type is unipdb
+            // if(e.eventData.entryId != scope.pdbId) return;
+            // Create query object from event data
+            var highlightQuery = {
+                entity_id: e.eventData.entityId,
+                struct_asym_id: e.eventData.structAsymId,
+                start_residue_number: e.eventData.residueNumber,
+                end_residue_number: e.eventData.residueNumber
+            };
+            // Call highlightAnnotation
+            wrapperCtx.visual.highlight({ data: [highlightQuery] });
+        }
+    });
+    document.addEventListener('PDB.topologyViewer.mouseout', function (e) {
+        wrapperCtx.visual.clearHighlight();
+    });
+    document.addEventListener('protvista-mouseover', function (e) {
+        if (typeof e.detail !== 'undefined') {
+            var highlightQuery = undefined;
+            // Create query object from event data
+            if (e.detail.start && e.detail.end) {
+                highlightQuery = {
+                    start_residue_number: parseInt(e.detail.start),
+                    end_residue_number: parseInt(e.detail.end)
+                };
+            }
+            if (e.detail.feature && e.detail.feature.entityId)
+                highlightQuery['entity_id'] = e.detail.feature.entityId + '';
+            if (e.detail.feature && e.detail.feature.bestChainId)
+                highlightQuery['struct_asym_id'] = e.detail.feature.bestChainId;
+            if (e.detail.feature && e.detail.feature.chainId)
+                highlightQuery['struct_asym_id'] = e.detail.feature.chainId;
+            if (highlightQuery)
+                wrapperCtx.visual.highlight({ data: [highlightQuery] });
+        }
+    });
+    document.addEventListener('protvista-mouseout', function (e) {
+        wrapperCtx.visual.clearHighlight();
+    });
+    document.addEventListener('protvista-click', function (e) {
+        if (typeof e.detail !== 'undefined') {
+            var showInteraction = false;
+            var highlightQuery = undefined;
+            // Create query object from event data
+            if (e.detail.start && e.detail.end) {
+                highlightQuery = {
+                    start_residue_number: parseInt(e.detail.start),
+                    end_residue_number: parseInt(e.detail.end)
+                };
+            }
+            if (e.detail.feature && e.detail.feature.entityId)
+                highlightQuery['entity_id'] = e.detail.feature.entityId + '';
+            if (e.detail.feature && e.detail.feature.bestChainId)
+                highlightQuery['struct_asym_id'] = e.detail.feature.bestChainId;
+            if (e.detail.feature && e.detail.feature.chainId)
+                highlightQuery['struct_asym_id'] = e.detail.feature.chainId;
+            if (e.detail.feature && e.detail.feature.accession && e.detail.feature.accession.split(' ')[0] === 'Chain' || e.detail.feature.tooltipContent === 'Ligand binding site') {
+                showInteraction = true;
+            }
+            if (e.detail.start === e.detail.end)
+                showInteraction = true;
+            if (highlightQuery) {
+                if (showInteraction) {
+                    highlightQuery['sideChain'] = true;
+                }
+                else {
+                    var selColor = undefined;
+                    if (e.detail.trackIndex > -1 && e.detail.feature.locations && e.detail.feature.locations[0].fragments[e.detail.trackIndex].color)
+                        selColor = e.detail.feature.locations[0].fragments[e.detail.trackIndex].color;
+                    if (typeof selColor == 'undefined' && e.detail.feature.color)
+                        selColor = e.detail.feature.color;
+                    if (typeof selColor == 'undefined' && e.detail.color)
+                        selColor = e.detail.color;
+                    if (typeof selColor == 'undefined') {
+                        selColor = { r: 65, g: 96, b: 91 };
+                    }
+                    else {
+                        var isRgb = /rgb/g;
+                        if (isRgb.test(selColor)) {
+                            var rgbArr = selColor.substring(4, selColor.length - 1).split(',');
+                            selColor = { r: rgbArr[0], g: rgbArr[1], b: rgbArr[2] };
+                        }
+                    }
+                    highlightQuery['color'] = selColor;
+                }
+                highlightQuery['focus'] = true;
+                wrapperCtx.visual.select({ data: [highlightQuery] });
+            }
+        }
+    });
+    var elementTypeArrForRange = ['uniprot', 'pfam', 'cath', 'scop', 'strand', 'helice'];
+    var elementTypeArrForSingle = ['chain', 'quality', 'quality_outlier', 'binding site', 'alternate conformer'];
+    document.addEventListener('PDB.seqViewer.click', function (e) {
+        if (typeof e.eventData !== 'undefined') {
+            // Abort if entryid and entityid do not match or viewer type is unipdb
+            // if(e.eventData.entryId != scope.pdbId) return;
+            if (typeof e.eventData.elementData !== 'undefined' && elementTypeArrForSingle.indexOf(e.eventData.elementData.elementType) > -1) {
+                // Create query object from event data
+                var highlightQuery = {
+                    entity_id: e.eventData.entityId,
+                    struct_asym_id: e.eventData.elementData.pathData.struct_asym_id,
+                    start_residue_number: e.eventData.residueNumber,
+                    end_residue_number: e.eventData.residueNumber,
+                    sideChain: true,
+                    focus: true
+                };
+                // Call highlightAnnotation
+                wrapperCtx.visual.select({ data: [highlightQuery] });
+            }
+            else if (typeof e.eventData.elementData !== 'undefined' && elementTypeArrForRange.indexOf(e.eventData.elementData.elementType) > -1) {
+                var seqColorArray = e.eventData.elementData.color;
+                // Create query object from event data
+                var highlightQuery = {
+                    entity_id: e.eventData.entityId,
+                    struct_asym_id: e.eventData.elementData.pathData.struct_asym_id,
+                    start_residue_number: e.eventData.elementData.pathData.start.residue_number,
+                    end_residue_number: e.eventData.elementData.pathData.end.residue_number,
+                    color: { r: seqColorArray[0], g: seqColorArray[1], b: seqColorArray[2] },
+                    focus: true
+                };
+                wrapperCtx.visual.select({ data: [highlightQuery] });
+            }
+        }
+    });
+    document.addEventListener('PDB.seqViewer.mouseover', function (e) {
+        if (typeof e.eventData !== 'undefined') {
+            // Abort if entryid and entityid do not match or viewer type is unipdb
+            // if(e.eventData.entryId != scope.pdbId) return;
+            if (typeof e.eventData.elementData !== 'undefined' && elementTypeArrForSingle.indexOf(e.eventData.elementData.elementType) > -1) {
+                // Create query object from event data
+                var highlightQuery = {
+                    entity_id: e.eventData.entityId,
+                    struct_asym_id: e.eventData.elementData.pathData.struct_asym_id,
+                    start_residue_number: e.eventData.residueNumber,
+                    end_residue_number: e.eventData.residueNumber,
+                    focus: true
+                };
+                wrapperCtx.visual.select({ data: [highlightQuery] });
+            }
+            else if (typeof e.eventData.elementData !== 'undefined' && elementTypeArrForRange.indexOf(e.eventData.elementData.elementType) > -1) {
+                // Create query object from event data
+                var highlightQuery = {
+                    entity_id: e.eventData.entityId,
+                    struct_asym_id: e.eventData.elementData.pathData.struct_asym_id,
+                    start_residue_number: e.eventData.elementData.pathData.start.residue_number,
+                    end_residue_number: e.eventData.elementData.pathData.end.residue_number
+                };
+                // Call highlightAnnotation
+                wrapperCtx.visual.highlight({ data: [highlightQuery] });
+            }
+        }
+    });
+    document.addEventListener('PDB.seqViewer.mouseout', function (e) {
+        wrapperCtx.visual.clearHighlight();
+    });
+}
+exports.subscribeToComponentEvents = subscribeToComponentEvents;

package/lib/superposition-export.d.ts

@@ -0,0 +1,4 @@
+import { PluginContext } from 'Molstar/mol-plugin/context';
+export declare function superpositionExportHierarchy(plugin: PluginContext, options?: {
+    format?: 'cif' | 'bcif';
+}): Promise<void>;

package/lib/superposition-export.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.superpositionExportHierarchy = void 0;
+var tslib_1 = require("tslib");
+var utf8_1 = require("Molstar/mol-io/common/utf8");
+var structure_1 = require("Molstar/mol-model/structure");
+var mol_task_1 = require("Molstar/mol-task");
+var date_1 = require("Molstar/mol-util/date");
+var download_1 = require("Molstar/mol-util/download");
+var zip_1 = require("Molstar/mol-util/zip/zip");
+var commands_1 = require("Molstar/mol-plugin/commands");
+function superpositionExportHierarchy(plugin, options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var e_1;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, plugin.runTask(_superpositionExportHierarchy(plugin, options), { useOverlay: true })];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    e_1 = _a.sent();
+                    console.error(e_1);
+                    plugin.log.error("Model export failed. See console for details.");
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.superpositionExportHierarchy = superpositionExportHierarchy;
+function _superpositionExportHierarchy(plugin, options) {
+    var _this = this;
+    return mol_task_1.Task.create('Export', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var format, customState, superpositionState, segmentIndex, files, entryMap, structures, _i, structures_1, molId, modelRef, isStrHidden, _s, _a, _b, strComp, s, name_1, zipData, _c, files_1, _d, fn, data, bytes, buffer;
+        var _e, _f, _g, _h, _j, _k, _l, _m;
+        return tslib_1.__generator(this, function (_o) {
+            switch (_o.label) {
+                case 0: return [4 /*yield*/, ctx.update({ message: 'Exporting...', isIndeterminate: true, canAbort: false })];
+                case 1:
+                    _o.sent();
+                    format = (_e = options === null || options === void 0 ? void 0 : options.format) !== null && _e !== void 0 ? _e : 'cif';
+                    customState = plugin.customState;
+                    superpositionState = customState.superpositionState;
+                    segmentIndex = superpositionState.activeSegment - 1;
+                    files = [];
+                    entryMap = new Map();
+                    structures = superpositionState.loadedStructs[segmentIndex].slice();
+                    if (superpositionState.alphafold.ref)
+                        structures.push("AF-".concat(customState.initParams.moleculeId));
+                    _i = 0, structures_1 = structures;
+                    _o.label = 2;
+                case 2:
+                    if (!(_i < structures_1.length)) return [3 /*break*/, 7];
+                    molId = structures_1[_i];
+                    modelRef = superpositionState.models[molId];
+                    if (!modelRef)
+                        return [3 /*break*/, 6];
+                    isStrHidden = false;
+                    _s = plugin.managers.structure.hierarchy.current.refs.get(modelRef);
+                    if (_s.cell.state.isHidden)
+                        isStrHidden = true;
+                    for (_a = 0, _b = _s.components; _a < _b.length; _a++) {
+                        strComp = _b[_a];
+                        if (strComp.cell.state.isHidden)
+                            isStrHidden = true;
+                    }
+                    if (isStrHidden)
+                        return [3 /*break*/, 6];
+                    s = (_h = (_g = (_f = _s.transform) === null || _f === void 0 ? void 0 : _f.cell.obj) === null || _g === void 0 ? void 0 : _g.data) !== null && _h !== void 0 ? _h : (_j = _s.cell.obj) === null || _j === void 0 ? void 0 : _j.data;
+                    if (!s)
+                        return [3 /*break*/, 6];
+                    if (s.models.length > 1) {
+                        plugin.log.warn("[Export] Skipping ".concat((_k = _s.cell.obj) === null || _k === void 0 ? void 0 : _k.label, ": Multimodel exports not supported."));
+                        return [3 /*break*/, 6];
+                    }
+                    if (s.units.some(function (u) { return !structure_1.Unit.isAtomic(u); })) {
+                        plugin.log.warn("[Export] Skipping ".concat((_l = _s.cell.obj) === null || _l === void 0 ? void 0 : _l.label, ": Non-atomic model exports not supported."));
+                        return [3 /*break*/, 6];
+                    }
+                    name_1 = entryMap.has(s.model.entryId)
+                        ? "".concat(s.model.entryId, "_").concat(entryMap.get(s.model.entryId) + 1, ".").concat(format)
+                        : "".concat(s.model.entryId, ".").concat(format);
+                    entryMap.set(s.model.entryId, ((_m = entryMap.get(s.model.entryId)) !== null && _m !== void 0 ? _m : 0) + 1);
+                    return [4 /*yield*/, ctx.update({ message: "Exporting ".concat(s.model.entryId, "..."), isIndeterminate: true, canAbort: false })];
+                case 3:
+                    _o.sent();
+                    if (!(s.elementCount > 100000)) return [3 /*break*/, 5];
+                    // Give UI chance to update, only needed for larger structures.
+                    return [4 /*yield*/, new Promise(function (res) { return setTimeout(res, 50); })];
+                case 4:
+                    // Give UI chance to update, only needed for larger structures.
+                    _o.sent();
+                    _o.label = 5;
+                case 5:
+                    try {
+                        files.push([name_1, (0, structure_1.to_mmCIF)(s.model.entryId, s, format === 'bcif', { copyAllCategories: true })]);
+                    }
+                    catch (e) {
+                        if (format === 'cif' && s.elementCount > 2000000) {
+                            plugin.log.warn("[Export] The structure might be too big to be exported as Text CIF, consider using the BinaryCIF format instead.");
+                        }
+                        throw e;
+                    }
+                    _o.label = 6;
+                case 6:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 7:
+                    if (files.length === 0) {
+                        commands_1.PluginCommands.Toast.Show(plugin, {
+                            title: 'Export Models',
+                            message: 'No visible structure in the 3D view to export!',
+                            key: 'superposition-toast-1',
+                            timeoutMs: 7000
+                        });
+                        return [2 /*return*/];
+                    }
+                    if (!(files.length === 1)) return [3 /*break*/, 8];
+                    (0, download_1.download)(new Blob([files[0][1]]), files[0][0]);
+                    return [3 /*break*/, 11];
+                case 8:
+                    if (!(files.length > 1)) return [3 /*break*/, 11];
+                    zipData = {};
+                    for (_c = 0, files_1 = files; _c < files_1.length; _c++) {
+                        _d = files_1[_c], fn = _d[0], data = _d[1];
+                        if (data instanceof Uint8Array) {
+                            zipData[fn] = data;
+                        }
+                        else {
+                            bytes = new Uint8Array((0, utf8_1.utf8ByteCount)(data));
+                            (0, utf8_1.utf8Write)(bytes, 0, data);
+                            zipData[fn] = bytes;
+                        }
+                    }
+                    return [4 /*yield*/, ctx.update({ message: "Compressing Data...", isIndeterminate: true, canAbort: false })];
+                case 9:
+                    _o.sent();
+                    return [4 /*yield*/, (0, zip_1.zip)(ctx, zipData)];
+                case 10:
+                    buffer = _o.sent();
+                    (0, download_1.download)(new Blob([new Uint8Array(buffer, 0, buffer.byteLength)]), "structures_".concat((0, date_1.getFormattedTime)(), ".zip"));
+                    _o.label = 11;
+                case 11:
+                    plugin.log.info("[Export] Done.");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+}

package/lib/superposition-focus-representation.d.ts

@@ -0,0 +1,16 @@
+import { PluginBehavior } from 'Molstar/mol-plugin/behavior';
+import { ParamDefinition as PD } from 'Molstar/mol-util/param-definition';
+import { PluginContext } from 'Molstar/mol-plugin/context';
+declare const SuperpositionFocusRepresentationParams: (plugin: PluginContext) => {
+    expandRadius: PD.Numeric;
+    surroundingsParams: PD.Group<PD.Normalize<{
+        [x: string]: any;
+    }>>;
+};
+declare type SuperpositionFocusRepresentationProps = PD.ValuesFor<ReturnType<typeof SuperpositionFocusRepresentationParams>>;
+export declare enum SuperpositionFocusRepresentationTags {
+    SurrSel = "superposition-focus-surr-sel",
+    SurrRepr = "superposition-focus-surr-repr"
+}
+export declare const SuperpositionFocusRepresentation: import("molstar/lib/mol-state/transformer").StateTransformer<PluginBehavior.Category, PluginBehavior.Behavior, SuperpositionFocusRepresentationProps>;
+export {};

package/lib/superposition-focus-representation.js

@@ -0,0 +1,153 @@
+"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);
+    return {
+        expandRadius: param_definition_1.ParamDefinition.Numeric(5, { min: 1, max: 10, step: 1 }),
+        surroundingsParams: param_definition_1.ParamDefinition.Group(reprParams, {
+            label: 'Surroundings',
+            customDefault: (0, structure_representation_params_1.createStructureRepresentationParams)(plugin, void 0, { type: 'ball-and-stick', size: 'physical', typeParams: { sizeFactor: 0.16 }, sizeParams: { scale: 0.3 } })
+        })
+    };
+};
+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);
+        // Selections
+        if (!refs[SuperpositionFocusRepresentationTags.SurrSel]) {
+            refs[SuperpositionFocusRepresentationTags.SurrSel] = builder
+                .to(cell)
+                .apply(transforms_1.StateTransforms.Model.StructureSelectionFromExpression, { expression: builder_1.MolScriptBuilder.struct.generator.empty(), label: this.surrLabel }, { tags: SuperpositionFocusRepresentationTags.SurrSel }).ref;
+        }
+        // Representations
+        if (!refs[SuperpositionFocusRepresentationTags.SurrRepr]) {
+            refs[SuperpositionFocusRepresentationTags.SurrRepr] = builder
+                .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));
+        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 })); });
+        }
+        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*/];
+                }
+            });
+        });
+    };
+    SuperpositionFocusRepresentationBehavior.prototype.register = function (ref) {
+        var _this = this;
+        this.subscribeObservable(this.plugin.managers.structure.focus.behaviors.current, function (entry) {
+            // if (entry) this.focus(entry.loci);
+            // else this.clear(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];
+                }
+            });
+        });
+    };
+    return SuperpositionFocusRepresentationBehavior;
+}(behavior_1.PluginBehavior.WithSubscribers));
+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); }
+});

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

@@ -0,0 +1,22 @@
+import { MinimizeRmsd } from 'Molstar/mol-math/linear-algebra/3d/minimize-rmsd';
+import { ElementIndex, ResidueIndex } from 'Molstar/mol-model/structure/model/indexing';
+import { StructureElement } from 'Molstar/mol-model/structure/structure/element';
+import { Structure } from 'Molstar/mol-model/structure';
+import { Unit } from 'Molstar/mol-model/structure/structure/unit';
+export interface AlignmentResultEntry {
+    transform: MinimizeRmsd.Result;
+    pivot: number;
+    other: number;
+}
+export interface AlignmentResult {
+    entries: AlignmentResultEntry[];
+    zeroOverlapPairs: [number, number][];
+    failedPairs: [number, number][];
+}
+declare 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;
+    applyTestIndex?: number[];
+}): AlignmentResult;
+export {};