pdbe-molstar 3.6.0 → 3.7.1

package/lib/extensions/complexes/index.js

@@ -3,9 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Coloring = void 0;
 exports.loadComplexSuperposition = loadComplexSuperposition;
-exports.superposeStructuresByMolstarDefault = superposeStructuresByMolstarDefault;
 const tslib_1 = require("tslib");
-const superposition_sifts_mapping_1 = require("molstar/lib/mol-model/structure/structure/util/superposition-sifts-mapping");
 const commands_1 = require("molstar/lib/mol-plugin/commands");
 const sleep_1 = require("molstar/lib/mol-util/sleep");
 const __1 = require("../..");
@@ -13,12 +11,26 @@ 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, and optionally apply coloring to show common/additional components. */
+/** 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, method = 'biggest-matched-chain' } = params;
+        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
@@ -45,12 +57,17 @@ function loadComplexSuperposition(viewer, params) {
         if (!otherStruct)
             throw new Error('Mobile structure not loaded');
         // Superpose other structure on base structure
-        const { status, superposition } = method === 'biggest-matched-chain' ?
-            (0, superpose_by_biggest_chain_1.superposeStructuresByBiggestCommonChain)(baseStruct, otherStruct, baseComponents, otherComponents)
-            : superposeStructuresByMolstarDefault(baseStruct, otherStruct);
+        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 });
@@ -74,50 +91,9 @@ function loadComplexSuperposition(viewer, params) {
         // Reveal new structure
         yield viewer.visual.structureVisibility(otherStructId, true);
         return {
-            /** Structure identifier of the newly loaded complex structure, to refer to this structure later */
             id: otherStructId,
-            /** Status of pairwise superposition ('success' / 'zero-overlap' / 'failed') */
-            status,
-            /** Superposition RMSD and tranform (if status is 'success') */
             superposition,
-            /** Function that deletes the newly loaded complex structure */
             delete: () => viewer.deleteStructure(otherStructId),
         };
     });
 }
-/** Superpose mobile structure onto static structure, based on Uniprot residue numbers. */
-function superposeStructuresByMolstarDefault(staticStruct, mobileStruct) {
-    var _a;
-    const aln = (0, superposition_sifts_mapping_1.alignAndSuperposeWithSIFTSMapping)([staticStruct, mobileStruct], { traceOnly: true });
-    const superposition = (_a = aln.entries.find(e => e.pivot === 0 && e.other === 1)) === null || _a === void 0 ? void 0 : _a.transform;
-    if (superposition) {
-        return { status: 'success', superposition: Object.assign(Object.assign({}, superposition), { nAlignedElements: Number.NaN }) };
-    }
-    else if (aln.zeroOverlapPairs.find(e => e[0] === 0 && e[1] === 1)) {
-        return { status: 'zero-overlap', superposition: undefined };
-    }
-    else {
-        return { status: 'failed', superposition: undefined };
-    }
-}
-/*
-Coloring - subcomplexes:
-- base common -> by entity, lighter
-- base additional -> gray, lighter
-- sub common -> by entity, darker
-- sub additional -> gray, darker (these are all unmapped components, includes antibodies and ligands)
-
--> Colors can be assigned based on base complex and applied to subcomplex
-
-Coloring - supercomplexes:
-- base common -> gray, lighter
-- base additional -> unmapped color, lighter (these are all unmapped components, includes antibodies and ligands)
-- super common -> gray, darker
-- super additional mapped -> by entity, darker
-- super additional unmapped -> unmapped color, darker
-
--> Colors can be assigned based on supercomplex complex, consistency between supercomplexes is probably not necessary
-
--> For both subcomplexes and supercomplexes, colors could be assigned based on UniprotID hash -> database-wide consistency but complexes with similar-color components will occur
-
-*/

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

@@ -1,17 +1,15 @@
-import { MinimizeRmsd } from 'molstar/lib/mol-math/linear-algebra/3d/minimize-rmsd';
 import { Structure } from 'molstar/lib/mol-model/structure';
-export type SuperpositionResult = {
-    status: 'success';
-    superposition: MinimizeRmsd.Result & {
-        nAlignedElements: number;
+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)[];
     };
-} | {
-    status: 'zero-overlap';
-    superposition: undefined;
-} | {
-    status: 'failed';
-    superposition: undefined;
-};
-/** Status of pairwise superposition (success = superposed, zero-overlap = failed to superpose because the two structures have no matchable elements, failed = failed to superpose for other reasons) */
-export type SuperpositionStatus = SuperpositionResult['status'];
-export declare function superposeStructuresByBiggestCommonChain(structA: Structure, structB: Structure, allowedComponentsA: string[] | undefined, allowedComponentsB: string[] | undefined): SuperpositionResult;
+}

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

@@ -1,8 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.superposeStructuresByBiggestCommonChain = superposeStructuresByBiggestCommonChain;
+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;
@@ -42,9 +81,29 @@ function extractUniprotIndex(structure, allowedAccessions) {
     }
     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 = sortAccessionAndChains(a);
-    const sortedB = sortAccessionAndChains(b);
+    const sortedA = sortAccessionsAndUnits(a);
+    const sortedB = sortAccessionsAndUnits(b);
     let bestMatch = undefined;
     let bestScore = 0;
     for (const accession of sortedA.accessions) {
@@ -70,26 +129,6 @@ function bestUniprotMatch(a, b) {
     }
     return bestMatch;
 }
-/** Sort units for each accession by decreasing size and sort accessions by decreasing biggest unit size. */
-function sortAccessionAndChains(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,
-    };
-}
 /** Return number of keys common to objects `a` and `b` */
 function objectKeyOverlap(a, b) {
     let overlap = 0;
@@ -100,36 +139,3 @@ function objectKeyOverlap(a, b) {
     }
     return overlap;
 }
-function superposeStructuresByBiggestCommonChain(structA, structB, allowedComponentsA, allowedComponentsB) {
-    const indexA = extractUniprotIndex(structA, allowedComponentsA);
-    const indexB = extractUniprotIndex(structB, allowedComponentsB);
-    const bestMatch = bestUniprotMatch(indexA, indexB);
-    if (!bestMatch) {
-        return { status: 'zero-overlap', superposition: 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 { status: 'failed', superposition: undefined };
-    }
-    return { status: 'success', superposition: Object.assign(Object.assign({}, superposition), { nAlignedElements: bestMatch.nMatchedElements }) };
-}

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

@@ -3,6 +3,7 @@ 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';
@@ -22,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 {
@@ -32,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;
 }
@@ -88,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 {

package/lib/helpers.js

@@ -34,9 +34,12 @@ const sleep_1 = require("molstar/lib/mol-util/sleep");
 const sifts_mapping_1 = require("./sifts-mapping");
 var PDBeVolumes;
 (function (PDBeVolumes) {
-    function mapParams(defaultParams, mapParams, ref) {
+    function mapParams(defaultParams, mapParams) {
         const pdbeParams = Object.assign({}, defaultParams);
-        pdbeParams.options.behaviorRef = 'volume-streaming' + '' + Math.floor(Math.random() * Math.floor(100));
+        if (mapParams === null || mapParams === void 0 ? void 0 : mapParams.defaultView) {
+            pdbeParams.defaultView = mapParams.defaultView;
+        }
+        pdbeParams.options.behaviorRef = `volume-streaming${Math.floor(Math.random() * 100)}`;
         pdbeParams.options.emContourProvider = 'pdbe';
         pdbeParams.options.serverUrl = 'https://www.ebi.ac.uk/pdbe/volume-server';
         const MAIN_MAP_DEFAULTS = { opacity: 0.49, wireframe: false };
@@ -152,7 +155,7 @@ var LigandView;
     LigandView.branchedQuery = branchedQuery;
 })(LigandView || (exports.LigandView = LigandView = {}));
 function queryParamsToMvsComponentExpressions(params) {
-    const broadcasted = broadcast(params, ['atoms', 'atom_id']);
+    const broadcasted = broadcast(params, ['atoms', 'atom_id', 'type_symbol']);
     return broadcasted.map(item => {
         var _a;
         return ({
@@ -168,7 +171,7 @@ function queryParamsToMvsComponentExpressions(params) {
             end_auth_seq_id: item.end_auth_residue_number,
             label_atom_id: item.atoms,
             auth_atom_id: undefined,
-            type_symbol: undefined,
+            type_symbol: item.type_symbol,
             atom_id: item.atom_id,
             atom_index: undefined,
             label_comp_id: item.label_comp_id,
@@ -282,6 +285,9 @@ var QueryHelper;
             if (param.atom_id) {
                 predicates.atom.push(l => param.atom_id.includes(structure_1.StructureProperties.atom.id(l.element)));
             }
+            if (param.type_symbol) {
+                predicates.atom.push(l => param.type_symbol.includes(structure_1.StructureProperties.atom.type_symbol(l.element)));
+            }
             selections.push({
                 entityTest: predicateConjunction(predicates.entity),
                 chainTest: predicateConjunction(predicates.chain),
@@ -289,7 +295,7 @@ var QueryHelper;
                 atomTest: predicateConjunction(predicates.atom),
             });
         }
-        const atmGroupsQueries = selections.map(selection => structure_1.Queries.generators.atoms(selection));
+        const atmGroupsQueries = selections.map(selection => structure_1.Queries.modifiers.union(structure_1.Queries.generators.atoms(selection)));
         return structure_1.Queries.combinators.merge(atmGroupsQueries);
     }
     QueryHelper.getQueryObject = getQueryObject;

package/lib/plugin-custom-state.d.ts

@@ -1,4 +1,3 @@
-import { SymmetryOperator } from 'molstar/lib/mol-math/geometry';
 import { Mat4 } from 'molstar/lib/mol-math/linear-algebra';
 import { PluginContext } from 'molstar/lib/mol-plugin/context';
 import { StateSelection, StateTransform } from 'molstar/lib/mol-state';
@@ -55,7 +54,6 @@ export interface PluginCustomState {
             visibility: boolean[];
             transforms: Mat4[];
             rmsds: string[][];
-            coordinateSystems: (SymmetryOperator | undefined)[];
         };
     };
     superpositionError?: string;

package/lib/sequence-color/behavior.d.ts

@@ -0,0 +1,5 @@
+import { PluginBehavior } from 'molstar/lib/mol-plugin/behavior';
+/** Allows coloring residues in sequence panel */
+export declare const SequenceColor: import("molstar/lib/mol-state").StateTransformer<PluginBehavior.Category, PluginBehavior.Behavior, {
+    autoAttach: boolean;
+}>;

package/lib/sequence-color/behavior.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequenceColor = void 0;
+const model_1 = require("molstar/lib/mol-plugin-state/transforms/model");
+const context_1 = require("molstar/lib/mol-plugin-ui/context");
+const behavior_1 = require("molstar/lib/mol-plugin/behavior");
+const param_definition_1 = require("molstar/lib/mol-util/param-definition");
+const rxjs_1 = require("rxjs");
+const color_1 = require("./color");
+const prop_1 = require("./prop");
+/** Allows coloring residues in sequence panel */
+exports.SequenceColor = behavior_1.PluginBehavior.create({
+    name: 'sequence-color',
+    category: 'misc',
+    display: {
+        name: 'Sequence Color',
+        description: 'Sequence Color extension, allows assigning custom residue colors to be shown in the sequence panel, based on a custom structure property',
+    },
+    ctor: class extends behavior_1.PluginBehavior.Handler {
+        register() {
+            var _a, _b;
+            this.ctx.customStructureProperties.register(prop_1.SequenceColorProperty.Provider, this.params.autoAttach);
+            if (this.ctx instanceof context_1.PluginUIContext) {
+                const customUIState = (_a = this.ctx.customUIState) !== null && _a !== void 0 ? _a : {}; // TODO remove this hack once `customUIState` is available in core Molstar
+                const theme = (_b = customUIState.experimentalSequenceColorTheme) !== null && _b !== void 0 ? _b : (customUIState.experimentalSequenceColorTheme = new rxjs_1.BehaviorSubject(undefined));
+                this.sub = this.ctx.state.events.cell.stateUpdated.subscribe(s => {
+                    if (s.cell.transform.transformer === model_1.CustomStructureProperties) {
+                        theme.next(color_1.CustomSequenceColorTheme.Provider);
+                    }
+                });
+            }
+        }
+        update(p) {
+            const updated = this.params.autoAttach !== p.autoAttach;
+            this.params.autoAttach = p.autoAttach;
+            this.ctx.customStructureProperties.setDefaultAutoAttach(prop_1.SequenceColorProperty.Provider.descriptor.name, this.params.autoAttach);
+            return updated;
+        }
+        unregister() {
+            var _a, _b;
+            this.ctx.customStructureProperties.unregister(prop_1.SequenceColorProperty.Provider.descriptor.name);
+            (_a = this.sub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+            this.sub = undefined;
+            if (this.ctx instanceof context_1.PluginUIContext) {
+                const customUIState = (_b = this.ctx.customUIState) !== null && _b !== void 0 ? _b : {}; // TODO remove this hack once `customUIState` is available in core Molstar
+                const theme = customUIState.experimentalSequenceColorTheme;
+                theme === null || theme === void 0 ? void 0 : theme.next(undefined);
+            }
+        }
+    },
+    params: () => ({
+        autoAttach: param_definition_1.ParamDefinition.Boolean(true),
+    }),
+});