pdbe-molstar 3.5.0 → 3.7.0

package/lib/extensions/complexes/index.d.ts

@@ -0,0 +1,70 @@
+/** Helper functions to allow superposition of complexes */
+import { MinimizeRmsd } from 'molstar/lib/mol-math/linear-algebra/3d/minimize-rmsd';
+import { PDBeMolstarPlugin } from '../..';
+import { QueryParam } from '../../helpers';
+export * as Coloring from './coloring';
+/** Parameters to `loadComplexSuperposition` */
+export interface LoadComplexSuperpositionParams {
+    /** PDB identifier of complex structure */
+    pdbId: string;
+    /** Assembly identifier */
+    assemblyId: string;
+    /** Arbitrary string identifier to refer to the newly loaded structure later */
+    id?: string;
+    /** Duration of camera transition, in milliseconds. Default: 250. Do not use 0 (won't work because of bugs in Molstar), but you can use 1. */
+    animationDuration?: number;
+    /** Apply coloring to the base structure and newly loaded structure.
+     * 'subcomplex' = color the common components by unique entities (UniProt/Rfam accession); color remaining components by base color (gray).
+     * 'supercomplex' = color the common components by base color (gray); color additional components in the new structure (supercomplex) by unique entities. */
+    coloring?: 'subcomplex' | 'supercomplex' | undefined;
+    /** List of Uniprot/Rfam accessions in the base complex. Mandatory when `coloring` is not `undefined`. */
+    baseComponents?: string[];
+    /** List of Uniprot/Rfam accessions in the newly loaded complex. Mandatory when `coloring` is not `undefined`. */
+    otherComponents?: string[];
+    /** Base color for coloring "uninteresting" parts of structures (i.e. subcomplexes: additional components, supercomplexes: common components). Default: gray. */
+    coreColor?: string;
+    /** Color for coloring unmapped additional components for supercomplexes. */
+    unmappedColor?: string;
+    /** List of colors for coloring unique entities. */
+    componentColors?: string[];
+    /** Optional specification of which parts of the base complex structure belong to individual Uniprot/Rfam accessions (will be inferred from mmCIF atom_site if not provided).
+     * It is recommended to provide this for nucleic acids as they don't have mapping in atom_site. */
+    baseMappings?: {
+        [accession: string]: QueryParam[];
+    };
+    /** Optional specification of which parts of the other complex structure belong to individual Uniprot/Rfam accessions (will be inferred from mmCIF atom_site if not provided).
+     * It is recommended to provide this for nucleic acids as they don't have mapping in atom_site. */
+    otherMappings?: {
+        [accession: string]: QueryParam[];
+    };
+}
+/** Result type of `loadComplexSuperposition` */
+export interface LoadComplexSuperpositionResult {
+    /** Structure identifier of the newly loaded complex structure, to refer to this structure later */
+    id: string;
+    /** Superposition RMSD, number of aligned residues, and tranform; if superposition was successful */
+    superposition: SuperpositionResult | undefined;
+    /** Function that deletes the newly loaded complex structure */
+    delete: () => Promise<void>;
+}
+/** Temporary type until `nAlignedElements` gets into `MinimizeRmsd.Result` in core Molstar */
+export interface SuperpositionResult extends MinimizeRmsd.Result {
+    nAlignedElements: number;
+    method: 'uniprot-numbering' | 'sequence-alignment';
+    accession: string;
+}
+/** Load a structure, superpose onto the main structure based on Uniprot residue numbers (or seq alignment if numbers not available),
+ * and optionally apply coloring to show common/additional components.
+ *
+ * **Superposition method:**
+ * Complexes are superposed based on the largest common component (measured the by number of residues) with a UniProt mapping (taken from atom_site mmCIF category).
+ * In case there are no common components with Uniprot mapping, the largest common component with an Rfam mapping is used (taken from `baseMappings` and `otherMappings` parameters).
+ * Residue-residue correspondence is determined by UniProt residue numbers (for UniProt mappings) or by sequence alignment (for Rfam mappings).
+ *
+ * **Coloring - subcomplexes:**
+ * Common components are colored by entity; additional components are gray. Components in the subcomplex are slightly darkened.
+ *
+ * **Coloring - supercomplexes:**
+ * Common components are gray; mapped additional components are colored by entity; unmapped additional components are magenta. Components in the supercomplex are slightly darkened.
+ */
+export declare function loadComplexSuperposition(viewer: PDBeMolstarPlugin, params: LoadComplexSuperpositionParams): Promise<LoadComplexSuperpositionResult>;

package/lib/extensions/complexes/index.js

@@ -0,0 +1,99 @@
+"use strict";
+/** Helper functions to allow superposition of complexes */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Coloring = void 0;
+exports.loadComplexSuperposition = loadComplexSuperposition;
+const tslib_1 = require("tslib");
+const commands_1 = require("molstar/lib/mol-plugin/commands");
+const sleep_1 = require("molstar/lib/mol-util/sleep");
+const __1 = require("../..");
+const helpers_1 = require("../../helpers");
+const superposition_1 = require("../../superposition");
+const Coloring = tslib_1.__importStar(require("./coloring"));
+const superpose_by_biggest_chain_1 = require("./superpose-by-biggest-chain");
+const superpose_by_sequence_alignment_1 = require("./superpose-by-sequence-alignment");
+exports.Coloring = tslib_1.__importStar(require("./coloring"));
+/** Load a structure, superpose onto the main structure based on Uniprot residue numbers (or seq alignment if numbers not available),
+ * and optionally apply coloring to show common/additional components.
+ *
+ * **Superposition method:**
+ * Complexes are superposed based on the largest common component (measured the by number of residues) with a UniProt mapping (taken from atom_site mmCIF category).
+ * In case there are no common components with Uniprot mapping, the largest common component with an Rfam mapping is used (taken from `baseMappings` and `otherMappings` parameters).
+ * Residue-residue correspondence is determined by UniProt residue numbers (for UniProt mappings) or by sequence alignment (for Rfam mappings).
+ *
+ * **Coloring - subcomplexes:**
+ * Common components are colored by entity; additional components are gray. Components in the subcomplex are slightly darkened.
+ *
+ * **Coloring - supercomplexes:**
+ * Common components are gray; mapped additional components are colored by entity; unmapped additional components are magenta. Components in the supercomplex are slightly darkened.
+ */
+function loadComplexSuperposition(viewer, params) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const { pdbId, assemblyId, animationDuration = 250, coloring, baseComponents, otherComponents, baseMappings, otherMappings, coreColor, unmappedColor, componentColors } = params;
+        const baseStructId = __1.PDBeMolstarPlugin.MAIN_STRUCTURE_ID;
+        const otherStructId = (_a = params.id) !== null && _a !== void 0 ? _a : `${pdbId}_${assemblyId}`;
+        // Apply coloring to base structure
+        if (coloring) {
+            if (!baseComponents)
+                throw new Error('`baseComponents` is required when `coloring` is not `undefined`');
+            if (!otherComponents)
+                throw new Error('`otherComponents` is required when `coloring` is not `undefined`');
+        }
+        if (coloring === 'subcomplex') {
+            yield Coloring.colorSubcomplex(viewer, { baseStructId, baseComponents: baseComponents, otherComponents: otherComponents, baseMappings, otherMappings, coreColor, componentColors });
+        }
+        if (coloring === 'supercomplex') {
+            yield Coloring.colorSupercomplex(viewer, { baseStructId, baseComponents: baseComponents, otherComponents: otherComponents, baseMappings, otherMappings, coreColor, unmappedColor, componentColors });
+        }
+        // Load other structure
+        const otherStructUrl = (0, helpers_1.getStructureUrl)(viewer.initParams, { pdbId, queryType: 'full' });
+        yield viewer.load({ url: otherStructUrl, isBinary: viewer.initParams.encoding === 'bcif', assemblyId, id: otherStructId }, false);
+        yield viewer.visual.structureVisibility(otherStructId, false); // hide structure until superposition complete, to avoid flickering
+        const baseStruct = (_c = (_b = viewer.getStructure(baseStructId)) === null || _b === void 0 ? void 0 : _b.cell.obj) === null || _c === void 0 ? void 0 : _c.data;
+        if (!baseStruct)
+            throw new Error('Static structure not loaded');
+        const otherStruct = (_e = (_d = viewer.getStructure(otherStructId)) === null || _d === void 0 ? void 0 : _d.cell.obj) === null || _e === void 0 ? void 0 : _e.data;
+        if (!otherStruct)
+            throw new Error('Mobile structure not loaded');
+        // Superpose other structure on base structure
+        let superposition = (0, superpose_by_biggest_chain_1.superposeByBiggestCommonChain)(baseStruct, otherStruct, baseComponents, otherComponents);
+        if (!superposition) {
+            console.log(`UniProt-based superposition method failed, trying sequence alignment superposition (RNAs)`);
+            superposition = (0, superpose_by_sequence_alignment_1.superposeBySequenceAlignment)(baseStruct, otherStruct, baseMappings !== null && baseMappings !== void 0 ? baseMappings : {}, otherMappings !== null && otherMappings !== void 0 ? otherMappings : {});
+        }
+        if (superposition) {
+            yield (0, superposition_1.transform)(viewer.plugin, viewer.getStructure(otherStructId).cell, superposition.bTransform);
+        }
+        else {
+            console.log(`Sequence alignment superposition method failed, leaving unsuperposed`);
+        }
+        // Apply coloring to other structure
+        if (coloring === 'subcomplex') {
+            yield Coloring.colorSubcomplex(viewer, { otherStructId, baseComponents: baseComponents, otherComponents: otherComponents, baseMappings, otherMappings, coreColor, componentColors });
+        }
+        if (coloring === 'supercomplex') {
+            yield Coloring.colorSupercomplex(viewer, { otherStructId, baseComponents: baseComponents, otherComponents: otherComponents, baseMappings, otherMappings, coreColor, unmappedColor, componentColors });
+        }
+        // Adjust camera
+        const staticStructRef = viewer.getStructure(baseStructId);
+        const mobileStructRef = viewer.getStructure(otherStructId); // it is important to run this after superposition, to get correct coordinates for camera adjustment
+        // Wanted to use PluginCommands.Camera.Focus with viewer.plugin.canvas3d?.boundingSphere, but seems to not work properly, so using the following workaround:
+        yield commands_1.PluginCommands.Camera.FocusObject(viewer.plugin, {
+            targets: [
+                { targetRef: staticStructRef === null || staticStructRef === void 0 ? void 0 : staticStructRef.cell.transform.ref, extraRadius: 0.3 },
+                { targetRef: (_g = ((_f = mobileStructRef === null || mobileStructRef === void 0 ? void 0 : mobileStructRef.transform) !== null && _f !== void 0 ? _f : mobileStructRef)) === null || _g === void 0 ? void 0 : _g.cell.transform.ref, extraRadius: 0.3 },
+                // 0.3 is amount by which bounding sphere algorithm usually underestimates actual visible bounding sphere
+            ],
+            durationMs: animationDuration,
+        });
+        yield (0, sleep_1.sleep)(animationDuration); // wait until camera adjustment completed
+        // Reveal new structure
+        yield viewer.visual.structureVisibility(otherStructId, true);
+        return {
+            id: otherStructId,
+            superposition,
+            delete: () => viewer.deleteStructure(otherStructId),
+        };
+    });
+}

package/lib/extensions/complexes/superpose-by-biggest-chain.d.ts

@@ -0,0 +1,15 @@
+import { Structure } from 'molstar/lib/mol-model/structure';
+import { SuperpositionResult } from './index';
+/** Superpose structures based on the largest common component (measured the by number of residues) with a UniProt mapping (taken from atom_site mmCIF category).
+ * Residue-residue correspondence is determined by UniProt residue numbers.
+ * This differs from UniProt-based superposition in core Molstar (`alignAndSuperposeWithSIFTSMapping`) which takes all components (regardless of their spacial arrangement). */
+export declare function superposeByBiggestCommonChain(structA: Structure, structB: Structure, allowedComponentsA: string[] | undefined, allowedComponentsB: string[] | undefined): SuperpositionResult | undefined;
+export interface SortedAccessionsAndUnits<T extends object = object> {
+    accessions: string[];
+    units: {
+        [accession: string]: ({
+            unitId: string;
+            size: number;
+        } & T)[];
+    };
+}

package/lib/extensions/complexes/superpose-by-biggest-chain.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.superposeByBiggestCommonChain = superposeByBiggestCommonChain;
+const minimize_rmsd_1 = require("molstar/lib/mol-math/linear-algebra/3d/minimize-rmsd");
+const mmcif_1 = require("molstar/lib/mol-model-formats/structure/mmcif");
+/** Superpose structures based on the largest common component (measured the by number of residues) with a UniProt mapping (taken from atom_site mmCIF category).
+ * Residue-residue correspondence is determined by UniProt residue numbers.
+ * This differs from UniProt-based superposition in core Molstar (`alignAndSuperposeWithSIFTSMapping`) which takes all components (regardless of their spacial arrangement). */
+function superposeByBiggestCommonChain(structA, structB, allowedComponentsA, allowedComponentsB) {
+    const indexA = extractUniprotIndex(structA, allowedComponentsA);
+    const indexB = extractUniprotIndex(structB, allowedComponentsB);
+    const bestMatch = bestUniprotMatch(indexA, indexB);
+    if (!bestMatch) {
+        return undefined;
+    }
+    const unitA = structA.unitMap.get(Number(bestMatch.unitA));
+    const unitB = structB.unitMap.get(Number(bestMatch.unitB));
+    const unitIndexA = indexA[bestMatch.accession][bestMatch.unitA];
+    const unitIndexB = indexB[bestMatch.accession][bestMatch.unitB];
+    const positionsA = minimize_rmsd_1.MinimizeRmsd.Positions.empty(bestMatch.nMatchedElements);
+    const positionsB = minimize_rmsd_1.MinimizeRmsd.Positions.empty(bestMatch.nMatchedElements);
+    let i = 0;
+    for (const unpNum in unitIndexA.atomMap) {
+        const iAtomB = unitIndexB.atomMap[unpNum];
+        if (iAtomB === undefined)
+            continue;
+        const iAtomA = unitIndexA.atomMap[unpNum];
+        positionsA.x[i] = unitA.conformation.coordinates.x[iAtomA];
+        positionsA.y[i] = unitA.conformation.coordinates.y[iAtomA];
+        positionsA.z[i] = unitA.conformation.coordinates.z[iAtomA];
+        positionsB.x[i] = unitB.conformation.coordinates.x[iAtomB];
+        positionsB.y[i] = unitB.conformation.coordinates.y[iAtomB];
+        positionsB.z[i] = unitB.conformation.coordinates.z[iAtomB];
+        i++;
+    }
+    const superposition = minimize_rmsd_1.MinimizeRmsd.compute({ a: positionsA, b: positionsB });
+    if (!isNaN(superposition.rmsd)) {
+        return Object.assign(Object.assign({}, superposition), { nAlignedElements: bestMatch.nMatchedElements, method: 'uniprot-numbering', accession: bestMatch.accession });
+        // TODO remove explicit nAlignedElements, once in core Molstar
+    }
+    else {
+        return undefined;
+    }
+}
+function extractUniprotIndex(structure, allowedAccessions) {
+    var _a, _b, _c;
+    var _d, _e;
+    const allowedAccessionsSet = allowedAccessions ? new Set(allowedAccessions) : undefined;
+    const seenUnitInvariantIds = new Set();
+    const out = {};
+    for (const unit of structure.units) {
+        if (seenUnitInvariantIds.has(unit.invariantId))
+            continue;
+        else
+            seenUnitInvariantIds.add(unit.invariantId);
+        const src = structure.model.sourceData;
+        if (!mmcif_1.MmcifFormat.is(src))
+            throw new Error('Source data must be mmCIF/BCIF');
+        const h = unit.model.atomicHierarchy;
+        const { pdbx_sifts_xref_db_acc, pdbx_sifts_xref_db_name, pdbx_sifts_xref_db_num } = src.data.db.atom_site;
+        const atoms = unit.polymerElements;
+        const nAtoms = atoms.length;
+        for (let i = 0; i < nAtoms; i++) {
+            const iAtom = atoms[i];
+            const srcIAtom = h.atomSourceIndex.value(iAtom);
+            const dbName = pdbx_sifts_xref_db_name.value(srcIAtom);
+            if (dbName !== 'UNP')
+                continue;
+            const dbAcc = pdbx_sifts_xref_db_acc.value(srcIAtom);
+            if (allowedAccessionsSet && !allowedAccessionsSet.has(dbAcc))
+                continue;
+            const dbNum = pdbx_sifts_xref_db_num.value(srcIAtom);
+            const structMapping = (_a = out[dbAcc]) !== null && _a !== void 0 ? _a : (out[dbAcc] = {});
+            const chainMapping = (_b = structMapping[_d = unit.id]) !== null && _b !== void 0 ? _b : (structMapping[_d] = {
+                label_asym_id: h.chains.label_asym_id.value(h.chainAtomSegments.index[atoms[0]]),
+                auth_asym_id: h.chains.auth_asym_id.value(h.chainAtomSegments.index[atoms[0]]),
+                atomMap: {},
+            });
+            (_c = (_e = chainMapping.atomMap)[dbNum]) !== null && _c !== void 0 ? _c : (_e[dbNum] = iAtom);
+        }
+    }
+    return out;
+}
+/** Sort units for each accession by decreasing size and sort accessions by decreasing biggest unit size. */
+function sortAccessionsAndUnits(uniprotIndex) {
+    const unitsByAccession = {};
+    for (const accession in uniprotIndex) {
+        const unitIds = uniprotIndex[accession];
+        const units = [];
+        for (const unitId in unitIds) {
+            const size = Object.keys(unitIds[unitId].atomMap).length;
+            units.push({ unitId, size });
+        }
+        units.sort((a, b) => b.size - a.size);
+        unitsByAccession[accession] = units;
+    }
+    return {
+        /** Accessions sorted by decreasing biggest unit size */
+        accessions: Object.keys(unitsByAccession).sort((a, b) => unitsByAccession[b][0].size - unitsByAccession[a][0].size),
+        /** Units per accession, sorted by decreasing unit size */
+        units: unitsByAccession,
+    };
+}
+function bestUniprotMatch(a, b) {
+    const sortedA = sortAccessionsAndUnits(a);
+    const sortedB = sortAccessionsAndUnits(b);
+    let bestMatch = undefined;
+    let bestScore = 0;
+    for (const accession of sortedA.accessions) {
+        const unitsA = sortedA.units[accession];
+        const unitsB = sortedB.units[accession];
+        if (!unitsB)
+            continue;
+        for (const ua of unitsA) {
+            if (ua.size <= bestScore)
+                break;
+            const unitA = a[accession][ua.unitId];
+            for (const ub of unitsB) {
+                if (ub.size <= bestScore || ua.size <= bestScore)
+                    break;
+                const unitB = b[accession][ub.unitId];
+                const score = objectKeyOverlap(unitA.atomMap, unitB.atomMap);
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestMatch = { accession, unitA: ua.unitId, unitB: ub.unitId, nMatchedElements: score };
+                }
+            }
+        }
+    }
+    return bestMatch;
+}
+/** Return number of keys common to objects `a` and `b` */
+function objectKeyOverlap(a, b) {
+    let overlap = 0;
+    for (const key in a) {
+        if (key in b) {
+            overlap++;
+        }
+    }
+    return overlap;
+}

package/lib/extensions/complexes/superpose-by-sequence-alignment.d.ts

@@ -0,0 +1,10 @@
+import { Structure } from 'molstar/lib/mol-model/structure';
+import { QueryParam } from '../../helpers';
+import { SuperpositionResult } from './index';
+/** Superpose structures based on the largest common component (measured the by number of residues), components being defined by `mappingsA` and `mappingsB`.
+ * Residue-residue correspondence is determined by sequence alignment. */
+export declare function superposeBySequenceAlignment(structA: Structure, structB: Structure, mappingsA: {
+    [accession: string]: QueryParam[];
+}, mappingsB: {
+    [accession: string]: QueryParam[];
+}): SuperpositionResult | undefined;

package/lib/extensions/complexes/superpose-by-sequence-alignment.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.superposeBySequenceAlignment = superposeBySequenceAlignment;
+const int_1 = require("molstar/lib/mol-data/int");
+const minimize_rmsd_1 = require("molstar/lib/mol-math/linear-algebra/3d/minimize-rmsd");
+const alignment_1 = require("molstar/lib/mol-model/sequence/alignment/alignment");
+const structure_1 = require("molstar/lib/mol-model/structure");
+const superposition_1 = require("molstar/lib/mol-model/structure/structure/util/superposition");
+const helpers_1 = require("../../helpers");
+/** Superpose structures based on the largest common component (measured the by number of residues), components being defined by `mappingsA` and `mappingsB`.
+ * Residue-residue correspondence is determined by sequence alignment. */
+function superposeBySequenceAlignment(structA, structB, mappingsA, mappingsB) {
+    const sortedA = sortAccessionsAndUnits(structA, mappingsA);
+    const sortedB = sortAccessionsAndUnits(structB, mappingsB);
+    const bestMatch = bestMappingMatch(sortedA, sortedB);
+    if (!bestMatch) {
+        return undefined;
+    }
+    const accession = bestMatch.accession;
+    const lociA = helpers_1.QueryHelper.getInteractivityLoci(mappingsA[accession], structA);
+    const lociB = helpers_1.QueryHelper.getInteractivityLoci(mappingsB[accession], structB);
+    const superposition = alignAndSuperpose(lociA, lociB);
+    if (!isNaN(superposition.rmsd)) {
+        return Object.assign(Object.assign({}, superposition), { method: 'sequence-alignment', accession: bestMatch.accession });
+    }
+    else {
+        return undefined;
+    }
+}
+/** Sort units for each accession by decreasing size and sort accessions by decreasing biggest unit size. */
+function sortAccessionsAndUnits(struct, mappings) {
+    const unitsByAccession = {};
+    for (const accession in mappings) {
+        const loci = helpers_1.QueryHelper.getInteractivityLoci(mappings[accession], struct);
+        const units = [];
+        for (const u of loci.elements) {
+            const unitId = u.unit.id.toString();
+            const elements = [];
+            int_1.OrderedSet.forEach(u.indices, elementUnitIndex => {
+                const elementIndex = u.unit.elements[elementUnitIndex];
+                if (int_1.SortedArray.has(u.unit.polymerElements, elementIndex))
+                    elements.push(elementIndex);
+            });
+            units.push({ unitId, size: elements.length, elements: int_1.SortedArray.ofSortedArray(elements) });
+        }
+        units.sort((a, b) => b.size - a.size);
+        unitsByAccession[accession] = units;
+    }
+    return {
+        /** Accessions sorted by decreasing biggest unit size */
+        accessions: Object.keys(unitsByAccession).sort((a, b) => unitsByAccession[b][0].size - unitsByAccession[a][0].size),
+        /** Units per accession, sorted by decreasing unit size */
+        units: unitsByAccession,
+    };
+}
+function bestMappingMatch(sortedA, sortedB) {
+    let bestMatch = undefined;
+    let bestScore = 0;
+    for (const accession of sortedA.accessions) {
+        const unitsA = sortedA.units[accession];
+        const unitsB = sortedB.units[accession];
+        if (!unitsB)
+            continue;
+        for (const ua of unitsA) {
+            if (ua.size <= bestScore)
+                break;
+            for (const ub of unitsB) {
+                if (ub.size <= bestScore || ua.size <= bestScore)
+                    break;
+                const score = Math.min(ua.size, ub.size);
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestMatch = { accession, unitA: ua.unitId, unitB: ub.unitId, elementsA: ua.elements, elementsB: ub.elements, nMatchedElements: score };
+                }
+            }
+        }
+    }
+    return bestMatch;
+}
+const reProtein = /(polypeptide|cyclic-pseudo-peptide)/i;
+function alignAndSuperpose(lociA, lociB) {
+    const location = structure_1.StructureElement.Loci.getFirstLocation(lociA);
+    const subtype = structure_1.StructureProperties.entity.subtype(location);
+    const substMatrix = subtype.match(reProtein) ? 'blosum62' : 'default';
+    const { matchedA, matchedB } = computeAlignment(lociA.elements[0], lociB.elements[0], { substMatrix });
+    const n = int_1.OrderedSet.size(matchedA.indices);
+    const coordsA = (0, superposition_1.getPositionTable)(structure_1.StructureElement.Loci(lociA.structure, [matchedA]), n);
+    const coordsB = (0, superposition_1.getPositionTable)(structure_1.StructureElement.Loci(lociB.structure, [matchedB]), n);
+    const superposition = minimize_rmsd_1.MinimizeRmsd.compute({ a: coordsA, b: coordsB });
+    return Object.assign(Object.assign({}, superposition), { nAlignedElements: n });
+    // TODO remove explicit nAlignedElements, once in core Molstar
+}
+function computeAlignment(a, b, options = {}) {
+    const seqA = getSequenceFromLoci(a);
+    const seqB = getSequenceFromLoci(b);
+    const { aliA, aliB, score } = (0, alignment_1.align)(seqA.sequence.map(getOneLetterCode), seqB.sequence.map(getOneLetterCode), options);
+    const indicesA = [];
+    const indicesB = [];
+    let seqIdxA = 0, seqIdxB = 0;
+    for (let i = 0, n = aliA.length; i < n; ++i) {
+        if (aliA[i] !== '-' && aliB[i] !== '-') {
+            indicesA.push(seqA.unitElements[seqIdxA]);
+            indicesB.push(seqB.unitElements[seqIdxB]);
+        }
+        if (aliA[i] !== '-')
+            seqIdxA += 1;
+        if (aliB[i] !== '-')
+            seqIdxB += 1;
+    }
+    return {
+        matchedA: { unit: a.unit, indices: int_1.OrderedSet.ofSortedArray(indicesA) },
+        matchedB: { unit: b.unit, indices: int_1.OrderedSet.ofSortedArray(indicesB) },
+        score,
+    };
+}
+/** Extract sequence and array of corresponding trace atoms. */
+function getSequenceFromLoci(loci) {
+    const { unit, indices } = loci;
+    const unitElements = [];
+    const sequence = [];
+    int_1.OrderedSet.forEach(indices, elementUnitIndex => {
+        const elementIndex = unit.elements[elementUnitIndex];
+        if (int_1.OrderedSet.has(unit.polymerElements, elementIndex)) {
+            unitElements.push(elementUnitIndex);
+            const compId = unit.model.atomicHierarchy.atoms.label_comp_id.value(elementIndex);
+            sequence.push(compId);
+        }
+    });
+    return { sequence, unitElements };
+}
+function getOneLetterCode(compId) {
+    var _a;
+    return (_a = OneLetterCodes[compId]) !== null && _a !== void 0 ? _a : 'X';
+}
+// Copied from Molstar
+const OneLetterCodes = {
+    'HIS': 'H',
+    'ARG': 'R',
+    'LYS': 'K',
+    'ILE': 'I',
+    'PHE': 'F',
+    'LEU': 'L',
+    'TRP': 'W',
+    'ALA': 'A',
+    'MET': 'M',
+    'PRO': 'P',
+    'CYS': 'C',
+    'ASN': 'N',
+    'VAL': 'V',
+    'GLY': 'G',
+    'SER': 'S',
+    'GLN': 'Q',
+    'TYR': 'Y',
+    'ASP': 'D',
+    'GLU': 'E',
+    'THR': 'T',
+    'SEC': 'U', // as per IUPAC definition
+    'PYL': 'O', // as per IUPAC definition
+    // charmm ff
+    'HSD': 'H', 'HSE': 'H', 'HSP': 'H',
+    'LSN': 'K',
+    'ASPP': 'D',
+    'GLUP': 'E',
+    // amber ff
+    'HID': 'H', 'HIE': 'H', 'HIP': 'H',
+    'LYN': 'K',
+    'ASH': 'D',
+    'GLH': 'E',
+    // DNA
+    'DA': 'A',
+    'DC': 'C',
+    'DG': 'G',
+    'DT': 'T',
+    'DU': 'U',
+    // RNA
+    'A': 'A',
+    'C': 'C',
+    'G': 'G',
+    'T': 'T',
+    'U': 'U',
+};

package/lib/helpers.d.ts

@@ -1,9 +1,12 @@
 import { ComponentExpressionT } from 'molstar/lib/extensions/mvs/tree/mvs/param-types';
+import { Mat3, Mat4 } from 'molstar/lib/mol-math/linear-algebra';
 import { Model, Structure } from 'molstar/lib/mol-model/structure';
 import { BuiltInTrajectoryFormat } from 'molstar/lib/mol-plugin-state/formats/trajectory';
 import { StructureRef } from 'molstar/lib/mol-plugin-state/manager/structure/hierarchy-state';
+import { InitVolumeStreaming } from 'molstar/lib/mol-plugin/behavior/dynamic/volume-streaming/transformers';
 import { PluginConfigItem } from 'molstar/lib/mol-plugin/config';
 import { PluginContext } from 'molstar/lib/mol-plugin/context';
+import { PluginLayoutStateProps } from 'molstar/lib/mol-plugin/layout';
 import { Expression } from 'molstar/lib/mol-script/language/expression';
 import { Overpaint } from 'molstar/lib/mol-theme/overpaint';
 import { Color } from 'molstar/lib/mol-util/color';
@@ -20,9 +23,15 @@ export interface LoadParams {
     id?: string;
 }
 export interface MapParams {
+    /** Volume streaming view type (`'off' | 'box' | 'selection-box' | 'camera-target' | 'cell' | 'auto'`) */
+    defaultView?: PDBeVolumes.InitVolumeStreamingProps['defaultView'];
+    /** Style for EM map */
     'em'?: MapStyle;
+    /** Style for X-ray 2Fo-Fc map */
     '2fo-fc'?: MapStyle;
+    /** Style for X-ray Fo-Fc(+ve) map */
     'fo-fc(+ve)'?: MapStyle;
+    /** Style for X-ray Fo-Fc(-ve) map */
     'fo-fc(-ve)'?: MapStyle;
 }
 interface MapStyle {
@@ -30,7 +39,8 @@ interface MapStyle {
     wireframe?: boolean;
 }
 export declare namespace PDBeVolumes {
-    function mapParams(defaultParams: any, mapParams?: MapParams, ref?: string | number): any;
+    type InitVolumeStreamingProps = ReturnType<(typeof InitVolumeStreaming)['createDefaultParams']>;
+    function mapParams(defaultParams: InitVolumeStreamingProps, mapParams?: MapParams): InitVolumeStreamingProps;
     function displayUsibilityMessage(plugin: PluginContext): void;
     function toggle(plugin: PluginContext): void;
 }
@@ -86,6 +96,8 @@ export interface QueryParam {
     uniprot_residue_number?: number;
     start_uniprot_residue_number?: number;
     end_uniprot_residue_number?: number;
+    /** List of element type symbols (e.g. ['C', 'N', 'FE']) */
+    type_symbol?: string[];
 }
 export declare function queryParamsToMvsComponentExpressions(params: QueryParam[]): ComponentExpressionT[];
 export declare namespace QueryHelper {
@@ -192,4 +204,6 @@ export declare namespace PluginConfigUtils {
     /** Retrieve config values for items in `configItems` from the current plugin config */
     function getConfigValues<T extends object>(plugin: PluginContext | undefined, configItems: ConfigFor<T>, defaults: T): T;
 }
+export declare function pluginLayoutStateFromInitParams(initParams: InitParams): PluginLayoutStateProps;
+export declare function getRotationMat4(view: 'front' | 'back' | 'right' | 'left' | 'top' | 'bottom' | Mat3): Mat4;
 export {};