pdbe-molstar 3.6.0 → 3.7.0

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),
+    }),
+});

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

@@ -0,0 +1,11 @@
+import { ColorTheme } from 'molstar/lib/mol-theme/color';
+import { ThemeDataContext } from 'molstar/lib/mol-theme/theme';
+import { ParamDefinition as PD } from 'molstar/lib/mol-util/param-definition';
+export declare namespace CustomSequenceColorTheme {
+    const Params: {};
+    type Params = typeof Params;
+    type Props = PD.Values<Params>;
+    function Theme(ctx: ThemeDataContext, props: Props): ColorTheme<Props>;
+    /** A thingy that is needed to register color theme "MVS Annotation" */
+    const Provider: ColorTheme.Provider<Params, 'custom-sequence-color'>;
+}

package/lib/sequence-color/color.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomSequenceColorTheme = void 0;
+const selector_1 = require("molstar/lib/extensions/mvs/components/selector");
+const structure_1 = require("molstar/lib/mol-model/structure");
+const color_1 = require("molstar/lib/mol-util/color");
+const param_definition_1 = require("molstar/lib/mol-util/param-definition");
+const prop_1 = require("./prop");
+/** Special color value meaning "no color assigned" */
+const NoColor = (0, color_1.Color)(-1);
+var CustomSequenceColorTheme;
+(function (CustomSequenceColorTheme) {
+    CustomSequenceColorTheme.Params = {};
+    function Theme(ctx, props) {
+        let color = () => NoColor;
+        if (ctx.structure && !ctx.structure.isEmpty) {
+            const colorData = prop_1.SequenceColorProperty.Provider.get(ctx.structure).value;
+            if (colorData && colorData.items.length > 0) {
+                color = location => structure_1.StructureElement.Location.is(location) ? sequenceColorForLocation(colorData, location) : NoColor;
+            }
+        }
+        return {
+            factory: Theme,
+            granularity: 'groupInstance',
+            color: color,
+            props: props,
+            description: 'Assigns colors based on custom structure property `SequenceColorProperty`.',
+        };
+    }
+    CustomSequenceColorTheme.Theme = Theme;
+    /** A thingy that is needed to register color theme "MVS Annotation" */
+    CustomSequenceColorTheme.Provider = {
+        name: 'custom-sequence-color',
+        label: 'Custom Sequence Color',
+        category: 'Miscellaneous',
+        factory: Theme,
+        getParams: ctx => CustomSequenceColorTheme.Params,
+        defaultValues: param_definition_1.ParamDefinition.getDefaultValues(CustomSequenceColorTheme.Params),
+        isApplicable: (ctx) => !!ctx.structure,
+    };
+})(CustomSequenceColorTheme || (exports.CustomSequenceColorTheme = CustomSequenceColorTheme = {}));
+function sequenceColorForLocation(colorData, location) {
+    var _a, _b;
+    var _c, _d, _e;
+    const unitCache = (_a = (_c = colorData.colorCache)[_d = location.unit.id]) !== null && _a !== void 0 ? _a : (_c[_d] = {});
+    return (_b = unitCache[_e = location.element]) !== null && _b !== void 0 ? _b : (unitCache[_e] = findSequenceColorForLocation(colorData, location));
+}
+function findSequenceColorForLocation(colorData, location) {
+    var _a;
+    for (let i = colorData.items.length - 1; i >= 0; i--) { // last color matters
+        const item = colorData.items[i];
+        const elements = (_a = item.elementSet) !== null && _a !== void 0 ? _a : (item.elementSet = selector_1.ElementSet.fromSelector(location.structure, item.selector));
+        if (selector_1.ElementSet.has(elements, location)) {
+            return item.color;
+        }
+    }
+    return NoColor;
+}

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

@@ -0,0 +1,38 @@
+import { ElementSet, Selector } from 'molstar/lib/extensions/mvs/components/selector';
+import { CustomStructureProperty } from 'molstar/lib/mol-model-props/common/custom-structure-property';
+import { ElementIndex } from 'molstar/lib/mol-model/structure';
+import { Color } from 'molstar/lib/mol-util/color';
+import { ParamDefinition as PD } from 'molstar/lib/mol-util/param-definition';
+export declare namespace SequenceColorProperty {
+    /** Parameter definition for custom structure property `SequenceColorProperty` */
+    type Params = typeof Params;
+    const Params: {
+        colors: PD.ObjectList<PD.Normalize<{
+            color: Color;
+            selector: PD.NamedParams<"all" | "polymer" | "water" | "branched" | "ligand" | "ion" | "lipid" | "protein" | "nucleic" | "non-standard" | "coarse", "static"> | PD.NamedParams<import("molstar/lib/mol-script/script").Script, "script"> | PD.NamedParams<import("molstar/lib/mol-script/language/expression").Expression, "expression"> | PD.NamedParams<import("molstar/lib/mol-model/structure/structure/element/bundle").Bundle, "bundle"> | PD.NamedParams<PD.Normalize<{
+                annotationId: string;
+                fieldName: string;
+                fieldValues: PD.NamedParams<PD.Normalize<unknown>, "all"> | PD.NamedParams<PD.Normalize<{
+                    value: any;
+                }>[], "selected">;
+            }>, "annotation">;
+        }>>;
+    };
+    /** Parameter values of custom structure property `SequenceColorProperty` */
+    type Props = PD.Values<Params>;
+    /** Values of custom structure property `SequenceColorProperty` */
+    interface Data {
+        items: {
+            selector: Selector;
+            color: Color;
+            elementSet?: ElementSet;
+        }[];
+        colorCache: {
+            [unitId: number]: {
+                [elemIdx: ElementIndex]: Color;
+            };
+        };
+    }
+    /** Provider for custom structure property `SequenceColorProperty` */
+    const Provider: CustomStructureProperty.Provider<Params, Data>;
+}

package/lib/sequence-color/prop.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequenceColorProperty = void 0;
+const tslib_1 = require("tslib");
+const selector_1 = require("molstar/lib/extensions/mvs/components/selector");
+const custom_structure_property_1 = require("molstar/lib/mol-model-props/common/custom-structure-property");
+const custom_property_1 = require("molstar/lib/mol-model/custom-property");
+const color_1 = require("molstar/lib/mol-util/color");
+const names_1 = require("molstar/lib/mol-util/color/names");
+const param_definition_1 = require("molstar/lib/mol-util/param-definition");
+var SequenceColorProperty;
+(function (SequenceColorProperty) {
+    SequenceColorProperty.Params = {
+        colors: param_definition_1.ParamDefinition.ObjectList({
+            color: param_definition_1.ParamDefinition.Color(names_1.ColorNames.grey, { description: 'Color to apply to a substructure' }),
+            selector: selector_1.SelectorParams,
+        }, obj => color_1.Color.toHexStyle(obj.color), { description: 'List of substructure-color assignments' }),
+    };
+    /** Provider for custom structure property `SequenceColorProperty` */
+    SequenceColorProperty.Provider = custom_structure_property_1.CustomStructureProperty.createProvider({
+        label: 'Sequence Color',
+        descriptor: (0, custom_property_1.CustomPropertyDescriptor)({
+            name: 'sequence-color',
+        }),
+        type: 'root',
+        defaultParams: SequenceColorProperty.Params,
+        getParams: (data) => SequenceColorProperty.Params,
+        isApplicable: (data) => data.root === data,
+        obtain: (ctx, data, props) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const fullProps = Object.assign(Object.assign({}, param_definition_1.ParamDefinition.getDefaultValues(SequenceColorProperty.Params)), props);
+            const items = fullProps.colors.map(t => ({
+                selector: t.selector,
+                color: t.color,
+            }));
+            return { value: { items, colorCache: {} } };
+        }),
+    });
+})(SequenceColorProperty || (exports.SequenceColorProperty = SequenceColorProperty = {}));

package/lib/superposition.d.ts

@@ -8,8 +8,8 @@ import { ClusterMember } from './plugin-custom-state';
 export declare const SuperpositionColorPalette: ColorListEntry[];
 export declare function getNextColor(plugin: PluginContext, segmentIndex: number): ColorListEntry;
 export declare function initSuperposition(plugin: PluginContext, completeSubject?: Subject<boolean>): Promise<void>;
-export declare function loadAfStructure(plugin: PluginContext): Promise<string | false>;
-export declare function superposeAf(plugin: PluginContext, traceOnly: boolean, segmentIndex?: number): Promise<true | undefined>;
+export declare function loadAfStructure(plugin: PluginContext): Promise<string | undefined>;
+export declare function superposeAf(plugin: PluginContext, traceOnly: boolean): Promise<boolean>;
 export declare function renderSuperposition(plugin: PluginContext, segmentIndex: number, entryList: ClusterMember[]): Promise<void>;
 /** Apply tranformation to a structure. Only use once per structure, combining multiple transformations is not implemented. */
 export declare function transform(plugin: PluginContext, s: StateObjectRef<PSO.Molecule.Structure>, matrix: Mat4): Promise<StateObjectSelector<PSO.Molecule.Structure, import("molstar/lib/mol-state").StateTransformer<import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>>, import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>>, any>>>;