jbrowse-plugin-msaview 2.7.3 → 2.7.4

package/dist/LaunchMsaView/components/LaunchMsaViewDialog.js

@@ -4,6 +4,7 @@ import { getSession } from '@jbrowse/core/util';
 import { Tab, Tabs } from '@mui/material';
 import ManualMSALoader from './ManualMSALoader/ManualMSALoader';
 import NCBIBlastPanel from './NCBIBlastQuery/NCBIBlastPanel';
+import OrthologPanel from './OrthologQuery/OrthologPanel';
 import PreLoadedMSA from './PreLoadedMSA/PreLoadedMSADataPanel';
 import { readMsaDatasets } from './PreLoadedMSA/types';
 import TabPanel from './TabPanel';
@@ -11,14 +12,19 @@ export default function LaunchMsaViewDialog({ handleClose, feature, model, }) {
     const session = getSession(model);
     const datasets = readMsaDatasets(session.jbrowse);
     const hasPreloadedDatasets = !!datasets?.length;
-    const [value, setValue] = useState('ncbi_blast');
+    // orthologs first, and the default: it answers the same question in ~10s
+    // that BLAST takes 10+ minutes to answer worse (see utils/ncbiOrthologs.ts)
+    const [value, setValue] = useState('orthologs');
     return (React.createElement(Dialog, { maxWidth: "xl", title: "Launch MSA view", open: true, onClose: handleClose },
         React.createElement(Tabs, { value: value, onChange: (_event, newValue) => {
                 setValue(newValue);
             } },
+            React.createElement(Tab, { label: "Orthologs (fast)", value: "orthologs" }),
             React.createElement(Tab, { label: "NCBI BLAST query", value: "ncbi_blast" }),
             hasPreloadedDatasets ? (React.createElement(Tab, { label: "Pre-loaded MSA datasets", value: "preloaded_msa" })) : null,
             React.createElement(Tab, { label: "Manual upload", value: "manual_msa" })),
+        React.createElement(TabPanel, { value: value, index: "orthologs" },
+            React.createElement(OrthologPanel, { handleClose: handleClose, feature: feature, model: model })),
         React.createElement(TabPanel, { value: value, index: "ncbi_blast" },
             React.createElement(NCBIBlastPanel, { handleClose: handleClose, feature: feature, model: model })),
         hasPreloadedDatasets ? (React.createElement(TabPanel, { value: value, index: "preloaded_msa" },

package/dist/LaunchMsaView/components/OrthologQuery/OrthologPanel.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { AbstractTrackModel, Feature } from '@jbrowse/core/util';
+declare const OrthologPanel: ({ handleClose, feature, model, }: {
+    model: AbstractTrackModel;
+    feature: Feature;
+    handleClose: () => void;
+}) => React.JSX.Element;
+export default OrthologPanel;

package/dist/LaunchMsaView/components/OrthologQuery/OrthologPanel.js

@@ -0,0 +1,86 @@
+import React, { useMemo, useState } from 'react';
+import { Checkbox, FormControlLabel, MenuItem, Typography } from '@mui/material';
+import { observer } from 'mobx-react';
+import { makeStyles } from 'tss-react/mui';
+import { orthologLaunchView } from './orthologLaunchView';
+import TextField2 from '../../../components/TextField2';
+import { COMMON_SPECIES } from '../../../utils/ncbiOrthologs';
+import { getGeneDisplayName, getGeneIdentifiers, getLinearGenomeView, getTranscriptDisplayName, } from '../../util';
+import LaunchPanelContent from '../LaunchPanelContent';
+import MsaAlgorithmSelect from '../NCBIBlastQuery/MsaAlgorithmSelect';
+import SubmitCancelActions from '../SubmitCancelActions';
+import TranscriptSelector from '../TranscriptSelector';
+import { useTranscriptSelection } from '../useTranscriptSelection';
+const useStyles = makeStyles()({
+    selectField: {
+        width: 180,
+    },
+    speciesBox: {
+        display: 'flex',
+        flexWrap: 'wrap',
+        maxWidth: 560,
+        marginTop: 12,
+    },
+    species: {
+        width: 160,
+    },
+    infoText: {
+        marginTop: 20,
+        maxWidth: 620,
+    },
+});
+const OrthologPanel = observer(function ({ handleClose, feature, model, }) {
+    const { classes } = useStyles();
+    const view = getLinearGenomeView(model);
+    const [launchViewError, setLaunchViewError] = useState();
+    const [taxId, setTaxId] = useState(9606);
+    const [msaAlgorithm, setMsaAlgorithm] = useState('clustalo');
+    const [excluded, setExcluded] = useState([]);
+    const geneCandidates = useMemo(() => getGeneIdentifiers(feature), [feature]);
+    const transcriptSelection = useTranscriptSelection({ feature, view });
+    const { selectedTranscript, proteinSequence } = transcriptSelection;
+    const e = transcriptSelection.error ?? launchViewError;
+    const taxa = COMMON_SPECIES.map(s => s.taxId).filter(t => !excluded.includes(t));
+    return (React.createElement(React.Fragment, null,
+        React.createElement(LaunchPanelContent, { error: e },
+            React.createElement(Typography, null, "Builds the alignment from NCBI's precomputed orthologs \u2014 one gene per species \u2014 instead of searching. There is no job to wait on: the NCBI lookups take about a second, and only the multiple alignment at EBI costs real time (~10s), against 10+ minutes for BLAST. Rows come out labelled by species rather than by accession, and NCBI's CDD domains are overlaid automatically."),
+            React.createElement("div", null,
+                React.createElement(TextField2, { variant: "outlined", label: "Query species", className: classes.selectField, select: true, value: taxId, onChange: event => {
+                        setTaxId(Number(event.target.value));
+                    }, helperText: "the species this gene is from" }, COMMON_SPECIES.map(s => (React.createElement(MenuItem, { value: s.taxId, key: s.taxId }, s.label)))),
+                React.createElement(MsaAlgorithmSelect, { className: classes.selectField, value: msaAlgorithm, onChange: setMsaAlgorithm })),
+            React.createElement(Typography, { variant: "subtitle2", style: { marginTop: 12 } }, "Species to include (those without an ortholog are skipped)"),
+            React.createElement("div", { className: classes.speciesBox }, COMMON_SPECIES.map(s => (React.createElement(FormControlLabel, { className: classes.species, key: s.taxId, control: React.createElement(Checkbox, { checked: !excluded.includes(s.taxId), onChange: event => {
+                        setExcluded(event.target.checked
+                            ? excluded.filter(t => t !== s.taxId)
+                            : [...excluded, s.taxId]);
+                    } }), label: s.label })))),
+            React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection }),
+            React.createElement(Typography, { className: classes.infoText, variant: "body2" }, "The query row is the transcript selected above, not NCBI's representative protein, so the alignment stays linked to the genome view at codon resolution.")),
+        React.createElement(SubmitCancelActions, { submitDisabled: !proteinSequence || taxa.length < 2, onSubmit: () => {
+                try {
+                    if (selectedTranscript) {
+                        setLaunchViewError(undefined);
+                        orthologLaunchView({
+                            feature: selectedTranscript,
+                            view,
+                            newViewTitle: `Orthologs - ${getGeneDisplayName(feature)} - ${getTranscriptDisplayName(selectedTranscript)}`,
+                            orthologParams: {
+                                taxId,
+                                taxa,
+                                geneCandidates,
+                                msaAlgorithm,
+                                selectedTranscript,
+                                proteinSequence,
+                            },
+                        });
+                        handleClose();
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                    setLaunchViewError(e);
+                }
+            }, onCancel: handleClose })));
+});
+export default OrthologPanel;

package/dist/LaunchMsaView/components/OrthologQuery/orthologLaunchView.d.ts

@@ -0,0 +1,9 @@
+import type { OrthologParams } from '../../../MsaViewPanel/model';
+import type { Feature } from '@jbrowse/core/util';
+import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
+export declare function orthologLaunchView({ newViewTitle, view, feature, orthologParams, }: {
+    newViewTitle: string;
+    view: LinearGenomeViewModel;
+    feature: Feature;
+    orthologParams: OrthologParams;
+}): void;

package/dist/LaunchMsaView/components/OrthologQuery/orthologLaunchView.js

@@ -0,0 +1,13 @@
+import { getSession } from '@jbrowse/core/util';
+export function orthologLaunchView({ newViewTitle, view, feature, orthologParams, }) {
+    getSession(view).addView('MsaView', {
+        type: 'MsaView',
+        displayName: newViewTitle,
+        connectedViewId: view.id,
+        connectedFeature: feature.toJSON(),
+        drawNodeBubbles: true,
+        colWidth: 10,
+        rowHeight: 12,
+        orthologParams,
+    });
+}

package/dist/MsaViewPanel/afterCreateAutoruns.d.ts

@@ -1,6 +1,14 @@
 import type { JBrowsePluginMsaViewModel } from './model';
 export declare function loadStoredData(self: JBrowsePluginMsaViewModel): void;
 export declare function storeDataToIndexedDB(self: JBrowsePluginMsaViewModel): void;
+/**
+ * Same shape as launchBlastIfNeeded, for the ortholog path: the params ARE the
+ * request, and clearing them on success is what marks it done. They are left in
+ * place on failure so the error stays attributable to a specific request; the
+ * autorun's only tracked read is orthologParams itself, so nothing refires
+ * until a new request replaces them.
+ */
+export declare function launchOrthologsIfNeeded(self: JBrowsePluginMsaViewModel): void;
 export declare function launchBlastIfNeeded(self: JBrowsePluginMsaViewModel): void;
 /**
  * Once an accession-bearing alignment is present (fresh from BLAST or restored

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -1,5 +1,6 @@
 import { getSession } from '@jbrowse/core/util';
 import { doLaunchBlast } from './doLaunchBlast';
+import { doLaunchOrthologs } from './doLaunchOrthologs';
 import { fetchIndexedMsa } from './fetchIndexedMsa';
 import { genomeToMSA } from './genomeToMSA';
 import { loadProteinDomains } from './loadProteinDomains';
@@ -69,6 +70,33 @@ export function storeDataToIndexedDB(self) {
         }
     }
 }
+/**
+ * Same shape as launchBlastIfNeeded, for the ortholog path: the params ARE the
+ * request, and clearing them on success is what marks it done. They are left in
+ * place on failure so the error stays attributable to a specific request; the
+ * autorun's only tracked read is orthologParams itself, so nothing refires
+ * until a new request replaces them.
+ */
+export function launchOrthologsIfNeeded(self) {
+    if (self.orthologParams) {
+        void (async () => {
+            try {
+                self.setProgress('Resolving orthologs');
+                self.setError(undefined);
+                const data = await doLaunchOrthologs({ self });
+                self.setData(data);
+                self.setOrthologParams(undefined);
+            }
+            catch (e) {
+                self.setError(e);
+                console.error(e);
+            }
+            finally {
+                self.setProgress('');
+            }
+        })();
+    }
+}
 export function launchBlastIfNeeded(self) {
     if (self.blastParams) {
         void (async () => {

package/dist/MsaViewPanel/doLaunchOrthologs.d.ts

@@ -0,0 +1,23 @@
+import type { JBrowsePluginMsaViewModel } from './model';
+/**
+ * The no-search-job alternative to doLaunchBlast.
+ *
+ * BLAST spends 10+ minutes answering "what looks like this sequence" and
+ * returns a redundant, accession-labelled hit list. This asks NCBI the question
+ * the alignment actually wants — "what is this gene's ortholog in each species"
+ * — which NCBI has already computed, so the whole NCBI half returns in about a
+ * second and only the EBI alignment (~10s) costs real time.
+ *
+ * The query row is the user's OWN selected transcript, not NCBI's
+ * representative protein for the query species, because `connectedFeature`
+ * maps genome coordinates through that row — swapping in a different isoform
+ * would silently break the genome<->MSA linkage. The query species is therefore
+ * excluded from the ortholog set rather than appearing twice.
+ */
+export declare function doLaunchOrthologs({ self, }: {
+    self: JBrowsePluginMsaViewModel;
+}): Promise<{
+    treeMetadata: string;
+    msa: string;
+    tree: string;
+}>;

package/dist/MsaViewPanel/doLaunchOrthologs.js

@@ -0,0 +1,97 @@
+import { cleanProteinSequence } from '../LaunchMsaView/util';
+import { launchMSA } from '../utils/msa';
+import { fetchOrthologRows, fetchProteinForGene, resolveGeneId, } from '../utils/ncbiOrthologs';
+/**
+ * The no-search-job alternative to doLaunchBlast.
+ *
+ * BLAST spends 10+ minutes answering "what looks like this sequence" and
+ * returns a redundant, accession-labelled hit list. This asks NCBI the question
+ * the alignment actually wants — "what is this gene's ortholog in each species"
+ * — which NCBI has already computed, so the whole NCBI half returns in about a
+ * second and only the EBI alignment (~10s) costs real time.
+ *
+ * The query row is the user's OWN selected transcript, not NCBI's
+ * representative protein for the query species, because `connectedFeature`
+ * maps genome coordinates through that row — swapping in a different isoform
+ * would silently break the genome<->MSA linkage. The query species is therefore
+ * excluded from the ortholog set rather than appearing twice.
+ */
+export async function doLaunchOrthologs({ self, }) {
+    const { taxId, taxa, geneCandidates, msaAlgorithm, proteinSequence } = self.orthologParams;
+    const cleanedSeq = cleanProteinSequence(proteinSequence);
+    const onProgress = (arg) => {
+        self.setProgress(arg);
+    };
+    onProgress('Resolving gene at NCBI...');
+    const resolved = await resolveGeneId(geneCandidates, taxId);
+    if (!resolved) {
+        throw new Error(`Could not resolve any of ${geneCandidates.join(', ')} to an NCBI gene in taxon ${taxId}. Try the NCBI BLAST tab, which needs no gene identifier.`);
+    }
+    // the query species is represented by the user's own transcript below
+    const wanted = new Set(taxa.filter(t => t !== taxId));
+    const rows = await fetchOrthologRows({
+        geneId: resolved.geneId,
+        taxa: wanted,
+        onProgress,
+    });
+    const treeMetadata = {
+        QUERY: await buildQueryMetadata(self, resolved.geneId, cleanedSeq),
+    };
+    for (const row of rows) {
+        treeMetadata[row.label] = buildRowMetadata(row);
+    }
+    const result = await launchMSA({
+        algorithm: msaAlgorithm,
+        sequence: [
+            `>QUERY\n${cleanedSeq}`,
+            ...rows.map(r => `>${r.label}\n${r.sequence}`),
+        ].join('\n'),
+        onProgress,
+    });
+    return {
+        ...result,
+        treeMetadata: JSON.stringify(treeMetadata),
+    };
+}
+/**
+ * The query row is the user's own translated transcript, so it carries an
+ * Accession — which is what drives the automatic CDD overlay
+ * (afterCreateAutoruns.autoLoadProteinDomains -> loadProteinDomains) — ONLY
+ * when its sequence is byte-identical to the RefSeq protein that accession
+ * names. Attaching it unconditionally would put every domain box at an offset
+ * whenever the user picked a non-representative isoform, which is a silently
+ * wrong figure rather than a missing one.
+ */
+async function buildQueryMetadata(self, geneId, proteinSequence) {
+    const transcript = self.orthologParams?.selectedTranscript;
+    const metadata = { 'Gene ID': geneId };
+    const name = transcript?.get('name') ?? transcript?.get('id');
+    if (name) {
+        metadata.Transcript = name;
+    }
+    try {
+        const representative = await fetchProteinForGene(geneId);
+        if (representative?.sequence === proteinSequence) {
+            metadata.Accession = representative.accession;
+        }
+    }
+    catch (e) {
+        // a failed lookup only costs the query row its domain overlay, so it must
+        // not take down an alignment that is otherwise complete
+        console.warn('[msaview-orthologs] query protein lookup failed:', e);
+    }
+    return metadata;
+}
+function buildRowMetadata(row) {
+    const metadata = {
+        'Scientific name': row.scientificName,
+        // Accession drives the automatic CDD domain overlay
+        // (afterCreateAutoruns.autoLoadProteinDomains -> loadProteinDomains)
+        Accession: row.protein,
+        'Gene ID': row.geneId,
+    };
+    if (row.commonName) {
+        metadata['Common name'] = row.commonName;
+    }
+    return metadata;
+}

package/dist/MsaViewPanel/model.d.ts

@@ -20,6 +20,17 @@ export interface BlastParams {
     proteinSequence: string;
     rid?: string;
 }
+export interface OrthologParams {
+    /** NCBI taxon id of the assembly the query gene came from */
+    taxId: number;
+    /** taxon ids to include as rows (the query taxon is represented by QUERY) */
+    taxa: number[];
+    /** candidate gene identifiers off the feature, tried in order */
+    geneCandidates: string[];
+    msaAlgorithm: MsaAlgorithm;
+    selectedTranscript?: Feature;
+    proteinSequence: string;
+}
 /**
  * #stateModel MsaViewPlugin
  * extends
@@ -42,7 +53,7 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     bgColor: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
     colorSchemeName: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
     showColumnStats: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
-    msaFormat: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<import("react-msaview").MSAFormat>>;
+    msaFormat: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<import("msa-parsers").MSAFormat>>;
 }, "height" | "id" | "type" | "allowedGappyness" | "colWidth" | "collapsed" | "currentAlignment" | "data" | "drawMsaLetters" | "featureFilters" | "gffFilehandle" | "hideGaps" | "highlightColumns" | "msaFilehandle" | "relativeTo" | "rowHeight" | "scrollX" | "scrollY" | "scrollZoom" | "showDomains" | "showOnly" | "subFeatureRows" | "treeFilehandle" | "treeMetadataFilehandle" | "turnedOffTracks"> & {
     id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
     showDomains: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
@@ -456,10 +467,11 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     featureFilters: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IMapType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>>, [undefined]>;
     relativeTo: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
     highlightColumns: import("@jbrowse/mobx-state-tree").IType<number[] | undefined, number[] | undefined, number[] | undefined>;
-}, "init" | "querySeqName" | "zoomToBaseLevel" | "connectedViewId" | "connectedFeature" | "blastParams" | "uniprotId" | "dataStoreId" | "mafRegion"> & {
+}, "init" | "querySeqName" | "zoomToBaseLevel" | "connectedViewId" | "connectedFeature" | "blastParams" | "orthologParams" | "uniprotId" | "dataStoreId" | "mafRegion"> & {
     connectedViewId: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
     connectedFeature: import("@jbrowse/mobx-state-tree").IType<any, any, any>;
     blastParams: import("@jbrowse/mobx-state-tree").IType<BlastParams | undefined, BlastParams | undefined, BlastParams | undefined>;
+    orthologParams: import("@jbrowse/mobx-state-tree").IType<OrthologParams | undefined, OrthologParams | undefined, OrthologParams | undefined>;
     querySeqName: import("@jbrowse/mobx-state-tree").IType<string | undefined, string, string>;
     uniprotId: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
     zoomToBaseLevel: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
@@ -495,7 +507,7 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     setColorSchemeName(name: string): void;
     setBgColor(arg: boolean): void;
     setShowColumnStats(arg: boolean): void;
-    setMSAFormat(arg?: import("react-msaview").MSAFormat): void;
+    setMSAFormat(arg?: import("msa-parsers").MSAFormat): void;
 } & {
     headerHeight: number;
     status: {
@@ -582,7 +594,7 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     readonly noDomains: boolean;
     menuItems(): never[];
     readonly treeMetadata: Record<string, Record<string, string> | undefined>;
-    readonly MSA: import("react-msaview").MSAParserType | null;
+    readonly MSA: import("msa-parsers").MSAParserType | null;
     readonly numColumns: number;
     readonly tree: import("react-msaview").NodeWithIds;
     readonly rowNames: string[];
@@ -879,6 +891,10 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
      * #action
      */
     setBlastParams(args?: BlastParams): void;
+    /**
+     * #action
+     */
+    setOrthologParams(args?: OrthologParams): void;
     /**
      * #action
      */
@@ -940,7 +956,7 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     bgColor: boolean;
     colorSchemeName: string;
     showColumnStats: boolean;
-    msaFormat: import("react-msaview").MSAFormat | undefined;
+    msaFormat: import("msa-parsers").MSAFormat | undefined;
     drawLabels: boolean;
     labelsAlignRight: boolean;
     treeAreaWidth: number;

package/dist/MsaViewPanel/model.js

@@ -4,7 +4,7 @@ import { addDisposer, types } from '@jbrowse/mobx-state-tree';
 import { genomeToTranscriptSeqMapping } from 'g2p_mapper';
 import { autorun } from 'mobx';
 import { MSAModelF } from 'react-msaview';
-import { autoLoadProteinDomains, launchBlastIfNeeded, loadStoredData, observeProteinHighlights, processInit, runCleanup, storeDataToIndexedDB, syncGenomeHoverToMsaColumn, } from './afterCreateAutoruns';
+import { autoLoadProteinDomains, launchBlastIfNeeded, launchOrthologsIfNeeded, loadStoredData, observeProteinHighlights, processInit, runCleanup, storeDataToIndexedDB, syncGenomeHoverToMsaColumn, } from './afterCreateAutoruns';
 import { msaCoordToGenomeCoord, msaCoordToGenomeRegions, } from './msaCoordToGenomeCoord';
 /**
  * #stateModel MsaViewPlugin
@@ -26,6 +26,10 @@ export default function stateModelFactory() {
          * #property
          */
         blastParams: types.frozen(),
+        /**
+         * #property
+         */
+        orthologParams: types.frozen(),
         /**
          * #property
          */
@@ -183,6 +187,12 @@ export default function stateModelFactory() {
         setBlastParams(args) {
             self.blastParams = args;
         },
+        /**
+         * #action
+         */
+        setOrthologParams(args) {
+            self.orthologParams = args;
+        },
         /**
          * #action
          */
@@ -289,6 +299,7 @@ export default function stateModelFactory() {
                 loadStoredData,
                 storeDataToIndexedDB,
                 launchBlastIfNeeded,
+                launchOrthologsIfNeeded,
                 processInit,
                 autoLoadProteinDomains,
             ]) {