drugflow-molstar 0.1.0

package/lib/helpers.d.ts

@@ -0,0 +1,80 @@
+import { PluginContext } from 'Molstar/mol-plugin/context';
+import Expression from 'Molstar/mol-script/language/expression';
+import { BuiltInTrajectoryFormat } from 'Molstar/mol-plugin-state/formats/trajectory';
+import { Model } from 'Molstar/mol-model/structure';
+export declare type SupportedFormats = 'mmcif' | 'bcif' | 'cif' | 'pdb' | 'sdf';
+export declare type LoadParams = {
+    url: string;
+    format?: BuiltInTrajectoryFormat;
+    assemblyId?: string;
+    isHetView?: boolean;
+    isBinary?: boolean;
+};
+export declare namespace PDBeVolumes {
+    function mapParams(defaultParams: any, mapParams: any, ref?: string | number): any;
+    function displayUsibilityMessage(plugin: PluginContext): void;
+    function toggle(plugin: PluginContext): void;
+}
+export declare namespace AlphafoldView {
+    function getLociByPLDDT(score: number, contextData: any): import("molstar/lib/mol-model/structure/structure/element/loci").Loci;
+}
+export declare type LigandQueryParam = {
+    label_comp_id_list?: any;
+    auth_asym_id?: string;
+    struct_asym_id?: string;
+    label_comp_id?: string;
+    auth_seq_id?: number;
+    show_all?: boolean;
+};
+export declare namespace LigandView {
+    function query(ligandViewParams: LigandQueryParam): {
+        core: Expression.Expression;
+        surroundings: Expression.Expression;
+    };
+    function branchedQuery(params: any): {
+        core: Expression.Expression;
+        surroundings: Expression.Expression;
+    };
+}
+export declare type QueryParam = {
+    auth_seq_id?: number;
+    entity_id?: string;
+    auth_asym_id?: string;
+    struct_asym_id?: string;
+    residue_number?: number;
+    start_residue_number?: number;
+    end_residue_number?: number;
+    auth_residue_number?: number;
+    auth_ins_code_id?: string;
+    start_auth_residue_number?: number;
+    start_auth_ins_code_id?: string;
+    end_auth_residue_number?: number;
+    end_auth_ins_code_id?: string;
+    atoms?: string[];
+    label_comp_id?: string;
+    color?: any;
+    sideChain?: boolean;
+    representation?: string;
+    representationColor?: any;
+    focus?: boolean;
+    tooltip?: string;
+    start?: any;
+    end?: any;
+    atom_id?: number[];
+    uniprot_accession?: string;
+    uniprot_residue_number?: number;
+    start_uniprot_residue_number?: number;
+    end_uniprot_residue_number?: number;
+};
+export declare namespace QueryHelper {
+    function getQueryObject(params: QueryParam[], contextData: any): Expression.Expression;
+    function getInteractivityLoci(params: any, contextData: any): import("molstar/lib/mol-model/structure/structure/element/loci").Loci;
+    function getHetLoci(queryExp: Expression.Expression, contextData: any): import("molstar/lib/mol-model/structure/structure/element/loci").Loci;
+}
+export interface ModelInfo {
+    hetNames: string[];
+    carbEntityCount: number;
+}
+export declare namespace ModelInfo {
+    function get(model: Model, structures: any): Promise<ModelInfo>;
+}

package/lib/helpers.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelInfo = exports.QueryHelper = exports.LigandView = exports.AlphafoldView = exports.PDBeVolumes = void 0;
+var tslib_1 = require("tslib");
+var commands_1 = require("Molstar/mol-plugin/commands");
+var builder_1 = require("Molstar/mol-script/language/builder");
+var mol_state_1 = require("Molstar/mol-state");
+var structure_1 = require("Molstar/mol-model/structure");
+var transformers_1 = require("Molstar/mol-plugin/behavior/dynamic/volume-streaming/transformers");
+var compiler_1 = require("Molstar/mol-script/runtime/query/compiler");
+var structure_2 = require("Molstar/mol-model/structure");
+var sifts_mapping_1 = require("./sifts-mapping");
+var query_1 = require("Molstar/mol-model/structure/query/query");
+var prop_1 = require("Molstar/extensions/model-archive/quality-assessment/prop");
+var PDBeVolumes;
+(function (PDBeVolumes) {
+    function mapParams(defaultParams, mapParams, ref) {
+        var pdbeParams = tslib_1.__assign({}, defaultParams);
+        pdbeParams.options.behaviorRef = 'volume-streaming' + '' + Math.floor(Math.random() * Math.floor(100));
+        pdbeParams.options.emContourProvider = 'pdbe';
+        pdbeParams.options.serverUrl = 'https://www.ebi.ac.uk/pdbe/volume-server';
+        pdbeParams.options.channelParams['em'] = {
+            opacity: (mapParams && mapParams.em && mapParams.em.opacity) ? mapParams.em.opacity : 0.49,
+            wireframe: (mapParams && mapParams.em && mapParams.em.wireframe) ? mapParams.em.wireframe : false
+        };
+        pdbeParams.options.channelParams['2fo-fc'] = {
+            opacity: (mapParams && mapParams['2fo-fc'] && mapParams['2fo-fc'].opacity) ? mapParams['2fo-fc'].opacity : 0.49,
+            wireframe: (mapParams && mapParams['2fo-fc'] && mapParams['2fo-fc'].wireframe) ? mapParams['2fo-fc'].wireframe : false
+        };
+        pdbeParams.options.channelParams['fo-fc(+ve)'] = {
+            opacity: (mapParams && mapParams['fo-fc(+ve)'] && mapParams['fo-fc(+ve)'].opacity) ? mapParams['fo-fc(+ve)'].opacity : 0.3,
+            wireframe: (mapParams && mapParams['fo-fc(+ve)'] && mapParams['fo-fc(+ve)'].wireframe) ? mapParams['fo-fc(+ve)'].wireframe : true
+        };
+        pdbeParams.options.channelParams['fo-fc(-ve)'] = {
+            opacity: (mapParams && mapParams['fo-fc(-ve)'] && mapParams['fo-fc(-ve)'].opacity) ? mapParams['fo-fc(-ve)'].opacity : 0.3,
+            wireframe: (mapParams && mapParams['fo-fc(-ve)'] && mapParams['fo-fc(-ve)'].wireframe) ? mapParams['fo-fc(-ve)'].wireframe : true
+        };
+        return pdbeParams;
+    }
+    PDBeVolumes.mapParams = mapParams;
+    function displayUsibilityMessage(plugin) {
+        commands_1.PluginCommands.Toast.Show(plugin, {
+            title: 'Volume',
+            message: 'Streaming enabled, click on a residue or an atom to view the data.',
+            key: 'toast-1',
+            timeoutMs: 7000
+        });
+    }
+    PDBeVolumes.displayUsibilityMessage = displayUsibilityMessage;
+    function toggle(plugin) {
+        var state = plugin.state.data;
+        var streamingState = state.select(mol_state_1.StateSelection.Generators.ofTransformer(transformers_1.CreateVolumeStreamingInfo))[0];
+        if (streamingState) {
+            commands_1.PluginCommands.State.ToggleVisibility(plugin, { state: state, ref: streamingState.transform.ref });
+            return;
+        }
+    }
+    PDBeVolumes.toggle = toggle;
+})(PDBeVolumes = exports.PDBeVolumes || (exports.PDBeVolumes = {}));
+var AlphafoldView;
+(function (AlphafoldView) {
+    function getLociByPLDDT(score, contextData) {
+        var queryExp = builder_1.MolScriptBuilder.struct.modifier.union([
+            builder_1.MolScriptBuilder.struct.modifier.wholeResidues([
+                builder_1.MolScriptBuilder.struct.modifier.union([
+                    builder_1.MolScriptBuilder.struct.generator.atomGroups({
+                        'chain-test': builder_1.MolScriptBuilder.core.rel.eq([builder_1.MolScriptBuilder.ammp('objectPrimitive'), 'atomistic']),
+                        'residue-test': builder_1.MolScriptBuilder.core.rel.gr([prop_1.QualityAssessment.symbols.pLDDT.symbol(), score]),
+                    })
+                ])
+            ])
+        ]);
+        var query = (0, compiler_1.compile)(queryExp);
+        var sel = query(new structure_1.QueryContext(contextData));
+        return structure_1.StructureSelection.toLociWithSourceUnits(sel);
+    }
+    AlphafoldView.getLociByPLDDT = getLociByPLDDT;
+})(AlphafoldView = exports.AlphafoldView || (exports.AlphafoldView = {}));
+var LigandView;
+(function (LigandView) {
+    function query(ligandViewParams) {
+        var atomGroupsParams = {
+            'group-by': builder_1.MolScriptBuilder.core.str.concat([builder_1.MolScriptBuilder.struct.atomProperty.core.operatorName(), builder_1.MolScriptBuilder.struct.atomProperty.macromolecular.residueKey()])
+        };
+        // Residue Param
+        var residueParam;
+        if (ligandViewParams.auth_seq_id) {
+            residueParam = builder_1.MolScriptBuilder.core.rel.eq([builder_1.MolScriptBuilder.struct.atomProperty.macromolecular.auth_seq_id(), ligandViewParams.auth_seq_id]);
+        }
+        else if (ligandViewParams.label_comp_id) {
+            residueParam = builder_1.MolScriptBuilder.core.rel.eq([builder_1.MolScriptBuilder.struct.atomProperty.macromolecular.label_comp_id(), ligandViewParams.label_comp_id]);
+        }
+        if (residueParam)
+            atomGroupsParams['residue-test'] = residueParam;
+        // Chain Param
+        if (ligandViewParams.auth_asym_id) {
+            atomGroupsParams['chain-test'] = builder_1.MolScriptBuilder.core.rel.eq([builder_1.MolScriptBuilder.struct.atomProperty.macromolecular.auth_asym_id(), ligandViewParams.auth_asym_id]);
+        }
+        else if (ligandViewParams.struct_asym_id) {
+            atomGroupsParams['chain-test'] = builder_1.MolScriptBuilder.core.rel.eq([builder_1.MolScriptBuilder.struct.atomProperty.macromolecular.label_asym_id(), ligandViewParams.struct_asym_id]);
+        }
+        // Construct core query
+        var core = ligandViewParams.show_all ?
+            builder_1.MolScriptBuilder.struct.generator.atomGroups(atomGroupsParams) :
+            builder_1.MolScriptBuilder.struct.filter.first([
+                builder_1.MolScriptBuilder.struct.generator.atomGroups(atomGroupsParams)
+            ]);
+        // Construct surroundings query
+        var surroundings = builder_1.MolScriptBuilder.struct.modifier.includeSurroundings({ 0: core, radius: 5, 'as-whole-residues': true });
+        return {
+            core: core,
+            surroundings: surroundings
+        };
+    }
+    LigandView.query = query;
+    function branchedQuery(params) {
+        var entityObjArray = [];
+        params.atom_site.forEach(function (param) {
+            var qEntities = {
+                'group-by': builder_1.MolScriptBuilder.core.str.concat([builder_1.MolScriptBuilder.struct.atomProperty.core.operatorName(), builder_1.MolScriptBuilder.struct.atomProperty.macromolecular.residueKey()]),
+                'residue-test': builder_1.MolScriptBuilder.core.rel.eq([builder_1.MolScriptBuilder.struct.atomProperty.macromolecular.auth_seq_id(), param.auth_seq_id])
+            };
+            entityObjArray.push(qEntities);
+        });
+        var atmGroupsQueries = [];
+        entityObjArray.forEach(function (entityObj) {
+            atmGroupsQueries.push(builder_1.MolScriptBuilder.struct.generator.atomGroups(entityObj));
+        });
+        var core = builder_1.MolScriptBuilder.struct.modifier.union([
+            atmGroupsQueries.length === 1
+                ? atmGroupsQueries[0]
+                // Need to union before merge for fast performance
+                : builder_1.MolScriptBuilder.struct.combinator.merge(atmGroupsQueries.map(function (q) { return builder_1.MolScriptBuilder.struct.modifier.union([q]); }))
+        ]);
+        // Construct surroundings query
+        var surroundings = builder_1.MolScriptBuilder.struct.modifier.includeSurroundings({ 0: core, radius: 5, 'as-whole-residues': true });
+        return {
+            core: core,
+            surroundings: surroundings
+        };
+    }
+    LigandView.branchedQuery = branchedQuery;
+})(LigandView = exports.LigandView || (exports.LigandView = {}));
+var QueryHelper;
+(function (QueryHelper) {
+    function getQueryObject(params, contextData) {
+        var selections = [];
+        var siftMappings;
+        var currentAccession;
+        params.forEach(function (param) {
+            var selection = {};
+            // entity
+            if (param.entity_id)
+                selection['entityTest'] = function (l) { return structure_1.StructureProperties.entity.id(l.element) === param.entity_id; };
+            // chain
+            if (param.struct_asym_id) {
+                selection['chainTest'] = function (l) { return structure_1.StructureProperties.chain.label_asym_id(l.element) === param.struct_asym_id; };
+            }
+            else if (param.auth_asym_id) {
+                selection['chainTest'] = function (l) { return structure_1.StructureProperties.chain.auth_asym_id(l.element) === param.auth_asym_id; };
+            }
+            // residues
+            if (param.label_comp_id) {
+                selection['residueTest'] = function (l) { return structure_1.StructureProperties.atom.label_comp_id(l.element) === param.label_comp_id; };
+            }
+            else if (param.uniprot_accession && param.uniprot_residue_number) {
+                selection['residueTest'] = function (l) {
+                    if (!siftMappings || currentAccession !== param.uniprot_accession) {
+                        siftMappings = sifts_mapping_1.SIFTSMapping.Provider.get(contextData.models[0]).value;
+                        currentAccession = param.uniprot_accession;
+                    }
+                    var rI = structure_1.StructureProperties.residue.key(l.element);
+                    return param.uniprot_accession === siftMappings.accession[rI] && param.uniprot_residue_number === +siftMappings.num[rI];
+                };
+            }
+            else if (param.uniprot_accession && param.start_uniprot_residue_number && param.end_uniprot_residue_number) {
+                selection['residueTest'] = function (l) {
+                    if (!siftMappings || currentAccession !== param.uniprot_accession) {
+                        siftMappings = sifts_mapping_1.SIFTSMapping.Provider.get(contextData.models[0]).value;
+                        currentAccession = param.uniprot_accession;
+                    }
+                    var rI = structure_1.StructureProperties.residue.key(l.element);
+                    return param.uniprot_accession === siftMappings.accession[rI] && (param.start_uniprot_residue_number <= +siftMappings.num[rI] && param.end_uniprot_residue_number >= +siftMappings.num[rI]);
+                };
+            }
+            else if (param.residue_number) {
+                selection['residueTest'] = function (l) { return structure_1.StructureProperties.residue.label_seq_id(l.element) === param.residue_number; };
+            }
+            else if ((param.start_residue_number && param.end_residue_number) && (param.end_residue_number > param.start_residue_number)) {
+                selection['residueTest'] = function (l) {
+                    var labelSeqId = structure_1.StructureProperties.residue.label_seq_id(l.element);
+                    return labelSeqId >= param.start_residue_number && labelSeqId <= param.end_residue_number;
+                };
+            }
+            else if ((param.start_residue_number && param.end_residue_number) && (param.end_residue_number === param.start_residue_number)) {
+                selection['residueTest'] = function (l) { return structure_1.StructureProperties.residue.label_seq_id(l.element) === param.start_residue_number; };
+            }
+            else if (param.auth_seq_id) {
+                selection['residueTest'] = function (l) { return structure_1.StructureProperties.residue.auth_seq_id(l.element) === param.auth_seq_id; };
+            }
+            else if (param.auth_residue_number && !param.auth_ins_code_id) {
+                selection['residueTest'] = function (l) { return structure_1.StructureProperties.residue.auth_seq_id(l.element) === param.auth_residue_number; };
+            }
+            else if (param.auth_residue_number && param.auth_ins_code_id) {
+                selection['residueTest'] = function (l) { return structure_1.StructureProperties.residue.auth_seq_id(l.element) === param.auth_residue_number; };
+            }
+            else if ((param.start_auth_residue_number && param.end_auth_residue_number) && (param.end_auth_residue_number > param.start_auth_residue_number)) {
+                selection['residueTest'] = function (l) {
+                    var authSeqId = structure_1.StructureProperties.residue.auth_seq_id(l.element);
+                    return authSeqId >= param.start_auth_residue_number && authSeqId <= param.end_auth_residue_number;
+                };
+            }
+            else if ((param.start_auth_residue_number && param.end_auth_residue_number) && (param.end_auth_residue_number === param.start_auth_residue_number)) {
+                selection['residueTest'] = function (l) { return structure_1.StructureProperties.residue.auth_seq_id(l.element) === param.start_auth_residue_number; };
+            }
+            // atoms
+            if (param.atoms) {
+                selection['atomTest'] = function (l) { return param.atoms.includes(structure_1.StructureProperties.atom.label_atom_id(l.element)); };
+            }
+            if (param.atom_id) {
+                selection['atomTest'] = function (l) { return param.atom_id.includes(structure_1.StructureProperties.atom.id(l.element)); };
+            }
+            selections.push(selection);
+        });
+        var atmGroupsQueries = [];
+        selections.forEach(function (selection) {
+            atmGroupsQueries.push(structure_2.Queries.generators.atoms(selection));
+        });
+        return structure_2.Queries.combinators.merge(atmGroupsQueries);
+    }
+    QueryHelper.getQueryObject = getQueryObject;
+    function getInteractivityLoci(params, contextData) {
+        var sel = query_1.StructureQuery.run(QueryHelper.getQueryObject(params, contextData), contextData);
+        return structure_1.StructureSelection.toLociWithSourceUnits(sel);
+    }
+    QueryHelper.getInteractivityLoci = getInteractivityLoci;
+    function getHetLoci(queryExp, contextData) {
+        var query = (0, compiler_1.compile)(queryExp);
+        var sel = query(new structure_1.QueryContext(contextData));
+        return structure_1.StructureSelection.toLociWithSourceUnits(sel);
+    }
+    QueryHelper.getHetLoci = getHetLoci;
+})(QueryHelper = exports.QueryHelper || (exports.QueryHelper = {}));
+var ModelInfo;
+(function (ModelInfo) {
+    function get(model, structures) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var residueCount, residueOffsets, chainIndex, hetNames, carbEntityCount, rI, cI, eI, entityType, comp_id;
+            return tslib_1.__generator(this, function (_a) {
+                residueCount = model.atomicHierarchy.residues._rowCount;
+                residueOffsets = model.atomicHierarchy.residueAtomSegments.offsets;
+                chainIndex = model.atomicHierarchy.chainAtomSegments.index;
+                hetNames = [];
+                carbEntityCount = 0;
+                for (rI = 0; rI < residueCount; rI++) {
+                    cI = chainIndex[residueOffsets[rI]];
+                    eI = model.atomicHierarchy.index.getEntityFromChain(cI);
+                    entityType = model.entities.data.type.value(eI);
+                    if (entityType !== 'non-polymer' && entityType !== 'branched')
+                        continue;
+                    comp_id = model.atomicHierarchy.atoms.label_comp_id.value(residueOffsets[rI]);
+                    if (entityType === 'branched') {
+                        carbEntityCount++;
+                    }
+                    else {
+                        if (hetNames.indexOf(comp_id) === -1)
+                            hetNames.push(comp_id);
+                    }
+                }
+                return [2 /*return*/, {
+                        hetNames: hetNames,
+                        carbEntityCount: carbEntityCount
+                    }];
+            });
+        });
+    }
+    ModelInfo.get = get;
+})(ModelInfo = exports.ModelInfo || (exports.ModelInfo = {}));

package/lib/index.d.ts

@@ -0,0 +1 @@
+export {};