jbrowse-plugin-msaview 5.1.0 → 5.2.0

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -1,5 +1,7 @@
 import { getSession } from '@jbrowse/core/util';
+import { addDisposer, isAlive } from '@jbrowse/mobx-state-tree';
 import { transaction } from 'mobx';
+import { isAbortError } from '../utils/fetch';
 import { doLaunchBlast } from './doLaunchBlast';
 import { doLaunchOrthologs } from './doLaunchOrthologs';
 import { fetchIndexedMsa } from './fetchIndexedMsa';
@@ -13,6 +15,7 @@ import { getUniprotIdFromAlphaFoldUrl, hasQueryRow, transcriptPosToVisibleCol, }
 const EXPIRED_MESSAGE = "This view's alignment is no longer in browser storage. Stored alignments are kept for 7 days after they were last used, and are lost when site data is cleared.";
 const RELAUNCHABLE = ' Retry runs the original search again and rebuilds it.';
 const START_OVER = ' Relaunch it from the gene to rebuild it.';
+const UNREADABLE_MESSAGE = "This view's alignment could not be read from browser storage.";
 const EXPIRED_EXTRAS_WARNING = 'Part of this view is no longer in browser storage: annotations, a tree or row metadata too large for the session. Stored documents are kept for 7 days after they were last used, and are lost when site data is cleared.';
 export function loadStoredData(self) {
     const { dataStoreId } = self;
@@ -59,6 +62,10 @@ export function loadStoredData(self) {
         }
         catch (e) {
             console.error('Failed to load MSA data from IndexedDB:', e);
+            // the row may still be there, so the id is kept for the next reload
+            if (isAlive(self) && !hasAlignmentSource(self)) {
+                self.setError(new Error(`${UNREADABLE_MESSAGE} ${e}.${(self.blastParams ?? self.orthologParams) ? RELAUNCHABLE : START_OVER}`));
+            }
         }
         finally {
             self.setLoadingStoredData(false);
@@ -126,75 +133,70 @@ export function storeDataToIndexedDB(self) {
     })();
 }
 /**
- * Same shape as launchBlastIfNeeded, for the ortholog path: the params ARE the
- * request, and `launchCompleted` is what marks it done. They are left in place
- * either way -- on failure so the error stays attributable to a specific
- * request, and on success because they are the only durable statement of what
- * the view is, which is what a stored alignment that expired is rebuilt from.
- * The autorun tracks those two reads alone, so nothing refires until a new
- * request replaces them or a retry clears the mark.
- */
-export function launchOrthologsIfNeeded(self) {
-    if (self.orthologParams &&
-        !self.launchCompleted &&
-        !awaitingTranscript(self)) {
-        runLaunch({
-            self,
-            message: 'Resolving orthologs',
-            launch: scope => doLaunchOrthologs({ self, scope }),
-            // marked rather than dropped: the request is the only durable statement
-            // of what this view is, and a view whose stored alignment expired runs it
-            // again
-            onLaunched: () => {
-                self.setLaunchCompleted(true);
-            },
-        });
-    }
-}
-/**
- * A launch that names its transcript rather than its feature has to wait for
- * the lookup: the query row is that transcript's translation, and the launch
- * cannot start without a query. Both launchers read the same two fields, so
- * the resolver setting `connectedFeature` is what refires them.
+ * A launch that names its transcript rather than its feature waits for the
+ * lookup, since the query row is that transcript's translation. The resolver
+ * setting `connectedFeature` is what refires the launchers.
  */
 function awaitingTranscript(self) {
     return !!self.connectedTranscript && !self.connectedFeature;
 }
-export function launchBlastIfNeeded(self) {
-    if (self.blastParams && !self.launchCompleted && !awaitingTranscript(self)) {
+/**
+ * The params are the request and `launchCompleted` marks it done. They stay in
+ * place on failure, so the error is attributable, and on success, because a
+ * stored alignment that expired is rebuilt from them.
+ */
+function launchIfNeeded(self, requested, message, launch) {
+    if (requested && !self.launchCompleted && !awaitingTranscript(self)) {
         runLaunch({
             self,
-            message: 'Submitting query',
-            launch: scope => doLaunchBlast({ self, scope }),
+            message,
+            launch,
             onLaunched: () => {
                 self.setLaunchCompleted(true);
             },
         });
     }
 }
+export function launchOrthologsIfNeeded(self) {
+    launchIfNeeded(self, !!self.orthologParams, 'Resolving orthologs', scope => doLaunchOrthologs({ self, scope }));
+}
+export function launchBlastIfNeeded(self) {
+    launchIfNeeded(self, !!self.blastParams, 'Submitting query', scope => doLaunchBlast({ self, scope }));
+}
 /**
- * Once an accession-bearing alignment is present (fresh from BLAST or restored
- * from cache), fetch NCBI CDD domains for those accessions and overlay them.
- * Runs once per view; the domainsRequested guard prevents refiring when NCBI
- * returns no domains (which leaves the annotation list empty).
+ * Once an alignment whose rows carry accessions is present, fetch NCBI CDD
+ * domains for them and overlay them. `domainsRequested` makes this once per
+ * view, so NCBI returning no domains does not refire it.
  */
 export function autoLoadProteinDomains(self) {
-    const { rows, domainsRequested, annotations } = self;
-    const hasAccessions = self.data.treeMetadata?.includes('"Accession"') ?? false;
+    const { rows, domainsRequested, annotations, rowData } = self;
     if (rows.length > 0 &&
-        hasAccessions &&
         annotations.length === 0 &&
-        !domainsRequested) {
+        !domainsRequested &&
+        Object.values(rowData).some(row => row?.Accession)) {
+        const controller = new AbortController();
+        const abort = () => {
+            controller.abort();
+        };
+        addDisposer(self, abort);
         self.setDomainsRequested(true);
+        self.setStatus({
+            msg: 'Fetching protein domains from NCBI',
+            onCancel: abort,
+        });
         void (async () => {
             try {
-                await loadProteinDomains(self);
+                await loadProteinDomains(self, controller.signal);
             }
             catch (e) {
-                console.error('[msaview-domains] auto-load failed:', e);
+                if (!isAbortError(e)) {
+                    console.error('[msaview-domains] auto-load failed:', e);
+                }
             }
             finally {
-                self.setProgress('');
+                if (isAlive(self)) {
+                    self.setStatus(undefined);
+                }
             }
         })();
     }
@@ -224,15 +226,15 @@ export function processInit(self) {
         void (async () => {
             try {
                 self.setError(undefined);
-                if (msaUrl) {
-                    const id = getUniprotIdFromAlphaFoldUrl(msaUrl);
-                    if (id) {
-                        self.setUniprotId(id);
-                        self.setQuerySeqName('query');
-                    }
+                const uniprotId = msaUrl
+                    ? getUniprotIdFromAlphaFoldUrl(msaUrl)
+                    : undefined;
+                if (uniprotId) {
+                    self.setUniprotId(uniprotId);
                 }
-                if (querySeqName) {
-                    self.setQuerySeqName(querySeqName);
+                const rowName = querySeqName ?? (uniprotId ? 'query' : undefined);
+                if (rowName) {
+                    self.setQuerySeqName(rowName);
                 }
                 if (msaUrl) {
                     self.setMSAFilehandle({ uri: msaUrl, locationType: 'UriLocation' });
@@ -242,12 +244,10 @@ export function processInit(self) {
                         location: msaIndexedLocation,
                         name: msaName,
                     });
-                    if (fasta) {
-                        self.setMSA(fasta);
-                    }
-                    else {
+                    if (!fasta) {
                         throw new Error(`No alignment named ${msaName} in ${msaIndexedLocation.uri}`);
                     }
+                    self.setMSA(fasta);
                 }
                 if (!indexed) {
                     self.setInit(undefined);

package/dist/MsaViewPanel/components/MsaViewPanel.js

@@ -3,7 +3,6 @@ import { LoadingEllipses } from '@jbrowse/core/ui';
 import { observer } from 'mobx-react';
 import { MSAView } from 'react-msaview';
 import { makeStyles } from 'tss-react/mui';
-import { ErrorBoundary } from './ErrorBoundary';
 import LaunchProgress from './LaunchProgress';
 const useStyles = makeStyles()({
     loadingContainer: {
@@ -21,11 +20,12 @@ const MsaViewPanel = observer(function MsaViewPanel2({ model, }) {
     const pending = !!request && !model.launchCompleted;
     // a request that finished and then lost its alignment -- browser storage
     // expires one after 7 days -- is a request again, and LaunchProgress draws it
-    // with the Retry that runs it
-    const expired = !!request && !!model.error && !model.dataInitialized;
+    // with the Retry that runs it. An error over an alignment still in hand is
+    // react-msaview's to draw.
+    const hasAlignment = !!(model.data.msa || model.data.tree);
+    const expired = !!request && !!model.error && !hasAlignment;
     const launching = pending || expired || (!!init && !model.dataInitialized);
-    return (React.createElement(ErrorBoundary, null,
-        React.createElement("div", null, launching ? (React.createElement(LaunchProgress, { model: model })) : loadingStoredData && !model.dataInitialized ? (React.createElement("div", { className: classes.loadingContainer },
-            React.createElement(LoadingEllipses, { message: "Loading MSA data", variant: "h6" }))) : (React.createElement(MSAView, { model: model })))));
+    return (React.createElement("div", null, launching ? (React.createElement(LaunchProgress, { model: model })) : loadingStoredData && !model.dataInitialized ? (React.createElement("div", { className: classes.loadingContainer },
+        React.createElement(LoadingEllipses, { message: "Loading MSA data", variant: "h6" }))) : (React.createElement(MSAView, { model: model }))));
 });
 export default MsaViewPanel;

package/dist/MsaViewPanel/components/MsaViewPanel.test.js

@@ -9,7 +9,7 @@ vi.mock('react-msaview', () => ({
     MSAView: () => React.createElement("div", null, "the alignment"),
 }));
 function panel(model) {
-    return render(React.createElement(MsaViewPanel, { model: model }));
+    return render(React.createElement(MsaViewPanel, { model: { data: {}, ...model } }));
 }
 afterEach(() => {
     cleanup();
@@ -115,6 +115,18 @@ test('an expired alignment offers to run its original search again', () => {
     screen.getByRole('button', { name: 'Retry' }).click();
     expect(retryLaunch).toHaveBeenCalled();
 });
+// react-msaview draws an error over an alignment it still holds, with its own
+// way back; rerunning a fifteen minute search is the wrong offer there
+test('an error over an alignment still in hand is not an expiry', () => {
+    panel({
+        progress: '',
+        data: { msa: '>a\nMKV' },
+        error: new Error('bad tree'),
+        blastParams: { blastDatabase: 'uniprotkb_swissprot' },
+        launchCompleted: true,
+    });
+    expect(screen.getByText('the alignment')).toBeTruthy();
+});
 // with nothing to retry from -- a pasted alignment, say -- the panel stays out
 // of the way and react-msaview's own import form is what the user gets
 test('an expired alignment with no request behind it draws the view', () => {

package/dist/MsaViewPanel/doLaunchBlast.d.ts

@@ -1,5 +1,5 @@
 import type { JBrowsePluginMsaViewModel } from './model';
-import type { LaunchScope } from './runLaunch';
+import type { LaunchScope, LaunchedData } from './runLaunch';
 /**
  * A similarity search, then an alignment of what it found. The program is a
  * backend behind one interface (utils/homologSearch.ts); what differs between
@@ -11,8 +11,4 @@ import type { LaunchScope } from './runLaunch';
 export declare function doLaunchBlast({ self, scope, }: {
     self: JBrowsePluginMsaViewModel;
     scope: LaunchScope;
-}): Promise<{
-    msa: string;
-    tree: string;
-    treeMetadata: string;
-}>;
+}): Promise<LaunchedData>;

package/dist/MsaViewPanel/doLaunchBlast.js

@@ -1,3 +1,4 @@
+import { defaultMaxHits } from '../LaunchMsaView/components/BlastQuery/consts';
 import { cleanProteinSequence } from '../LaunchMsaView/util';
 import { saveBlastResult } from '../utils/blastCache';
 import { checkPairSize } from '../utils/browserAlign';
@@ -7,10 +8,7 @@ import { buildSearchMsa } from '../utils/msaRows';
 import { getCachedSearch, saveSearch, searchKey } from '../utils/searchCache';
 import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
 import { resolveUniProtEntry } from '../utils/unirefHomologs';
-import { transcriptFields, transcriptName } from './util';
-function asString(val) {
-    return typeof val === 'string' ? val : undefined;
-}
+import { str, transcriptFields, transcriptName } from './util';
 /**
  * The query sequence, and what its row is called. The dialog hands over the
  * translated transcript and the row stays `QUERY`; a spec naming a UniProt
@@ -40,13 +38,13 @@ async function resolveQuery(self, scope) {
     }
     throw new Error('No query: a search needs a proteinSequence, a UniProt accession, or a connectedTranscript to translate');
 }
-async function search({ self, scope, query, querySeqName, key, }) {
+async function search({ self, scope, query, querySeqName, maxHits, key, }) {
     const params = self.blastParams;
     const { onProgress, onRid, signal } = scope;
     const { hits, queryRow, rid } = await searchBackends[params.searchProgram ?? 'blastp']({
         query,
         database: params.blastDatabase,
-        maxHits: params.maxHits,
+        maxHits,
         onProgress,
         onRid,
         signal,
@@ -55,7 +53,10 @@ async function search({ self, scope, query, querySeqName, key, }) {
         throw new Error('No hits found');
     }
     onProgress('Fetching species taxonomy info...');
-    const taxonomyInfo = await fetchTaxonomyInfo(hits.map(h => h.taxid).filter((t) => t !== undefined), signal);
+    const nameFailures = [];
+    const taxonomyInfo = await fetchTaxonomyInfo(hits.map(h => h.taxid).filter((t) => t !== undefined), signal, e => {
+        nameFailures.push(e);
+    });
     const { msa: fasta, treeMetadata } = buildSearchMsa({
         hits,
         query,
@@ -63,10 +64,22 @@ async function search({ self, scope, query, querySeqName, key, }) {
         taxonomyInfo,
         querySeqName,
     });
-    if (!queryRow) {
+    // rows named without NCBI's answer are not worth reusing for a week
+    const namesFailed = nameFailures.length > 0;
+    if (!queryRow && !namesFailed) {
         await saveSearch({ id: key, fasta, treeMetadata, rid });
     }
-    return { fasta, treeMetadata, rid, queryRow };
+    return {
+        fasta,
+        treeMetadata,
+        rid,
+        queryRow,
+        warnings: namesFailed
+            ? [
+                'NCBI did not answer for some species names, so those rows are named by scientific name alone.',
+            ]
+            : [],
+    };
 }
 /**
  * A similarity search, then an alignment of what it found. The program is a
@@ -78,7 +91,7 @@ async function search({ self, scope, query, querySeqName, key, }) {
  */
 export async function doLaunchBlast({ self, scope, }) {
     const params = self.blastParams;
-    const { selectedTranscript, maxHits, searchProgram = 'blastp' } = params;
+    const { selectedTranscript, maxHits = defaultMaxHits, searchProgram = 'blastp', } = params;
     const msaAlgorithm = params.msaAlgorithm ?? 'browser';
     const { sequence: query, name: querySeqName } = await resolveQuery(self, scope);
     if (searchProgram === 'blastp' && msaAlgorithm === 'browser') {
@@ -96,7 +109,7 @@ export async function doLaunchBlast({ self, scope, }) {
     if (found) {
         onProgress(`Reusing the ${searchProgram} search from ${new Date(found.timestamp).toLocaleString()}...`);
     }
-    const { fasta, treeMetadata, rid, queryRow } = found ?? (await search({ self, scope, query, querySeqName, key }));
+    const { fasta, treeMetadata, rid, queryRow, warnings } = found ?? (await search({ self, scope, query, querySeqName, maxHits, key }));
     const { msa, tree } = queryRow
         ? { msa: fasta, tree: '' }
         : await launchMSA({
@@ -117,10 +130,10 @@ export async function doLaunchBlast({ self, scope, }) {
         tree,
         treeMetadata: treeMetadataJson,
         rid: rid ?? '',
-        geneId: asString(transcript.parentId),
-        transcriptId: asString(transcript.uniqueId),
+        geneId: str(transcript.parentId),
+        transcriptId: str(transcript.uniqueId),
         transcriptName: transcriptName(selectedTranscript),
-        geneName: asString(transcript.gene_name) ?? asString(transcript.parentId),
+        geneName: str(transcript.gene_name) ?? str(transcript.parentId),
     });
-    return { msa, tree, treeMetadata: treeMetadataJson };
+    return { msa, tree, treeMetadata: treeMetadataJson, warnings };
 }

package/dist/MsaViewPanel/doLaunchOrthologs.d.ts

@@ -22,6 +22,7 @@ export declare function doLaunchOrthologs({ self, scope, }: {
     scope: LaunchScope;
 }): Promise<{
     treeMetadata: string;
+    warnings: string[];
     msa: string;
     tree: string;
 }>;

package/dist/MsaViewPanel/doLaunchOrthologs.js

@@ -36,7 +36,7 @@ export async function doLaunchOrthologs({ self, scope, }) {
         onProgress,
         signal,
     };
-    const { geneId, representative, rows } = source === 'panther'
+    const { geneId, representative, rows, warning } = source === 'panther'
         ? await findPantherOrthologs(request)
         : source === 'uniref'
             ? await findUnirefHomologs({
@@ -91,6 +91,7 @@ export async function doLaunchOrthologs({ self, scope, }) {
     return {
         ...result,
         treeMetadata: JSON.stringify(treeMetadata),
+        warnings: warning ? [warning] : [],
     };
 }
 /**
@@ -138,6 +139,7 @@ async function findUnirefHomologs({ geneCandidates, identity, referenceProteomes
             sequence: found.query.sequence,
         },
         rows: found.rows,
+        warning: found.warning,
     };
 }
 /**

package/dist/MsaViewPanel/fetchIndexedMsa.js

@@ -6,7 +6,7 @@ import { openLocation } from '@jbrowse/core/util/io';
 // offset + length) are found by suffix. We fetch the small `.idx` once, look up
 // the name, and random-read just that block — already valid FASTA
 // (`>hg38\nSEQ\n>panTro4\nSEQ\n...`). One genome-scale alignment serves any gene
-// with no per-gene files or coordinates. See react-msaview's gene-explorer.
+// with no per-gene files or coordinates.
 export async function fetchIndexedMsa({ location, name, }) {
     const open = (uri) => openLocation({ uri, locationType: 'UriLocation' });
     const idxText = await open(`${location.uri}.idx`).readFile('utf8');

package/dist/MsaViewPanel/loadProteinDomains.d.ts

@@ -1,22 +1,13 @@
 import type { Annotation } from 'react-msaview';
 interface DomainModel {
-    data: {
-        treeMetadata?: string;
-    };
-    setProgress: (arg: string) => void;
+    rowData: Record<string, Record<string, string> | undefined>;
     setAnnotations: (annotations: Annotation[]) => void;
 }
 /**
  * Overlay protein domains on the alignment using NCBI's pre-computed CDD
- * annotations. The BLAST workflow stores each hit's accession in treeMetadata,
- * so we look those up via efetch and key the results by MSA row name (which is
- * what react-msaview matches domains against).
- *
- * The overlay is handed over as `Annotation[]`, the shape every source flattens
- * to. It used to be dressed up as an InterProScan response — an `xref` invented
- * to carry the row name — so that `setDomains` could unwrap it again; that entry
- * point exists for plugins holding the actual EBI wire format, which this is
- * not.
+ * annotations. Each launch stores a row's accession in its row data, so those
+ * are looked up via efetch and keyed by MSA row name, which is what
+ * react-msaview matches annotations against.
  */
-export declare function loadProteinDomains(self: DomainModel): Promise<void>;
+export declare function loadProteinDomains(self: DomainModel, signal?: AbortSignal): Promise<void>;
 export {};

package/dist/MsaViewPanel/loadProteinDomains.js

@@ -1,30 +1,16 @@
 import { fetchProteinDomains } from '../utils/ncbiDomains';
 /**
  * Overlay protein domains on the alignment using NCBI's pre-computed CDD
- * annotations. The BLAST workflow stores each hit's accession in treeMetadata,
- * so we look those up via efetch and key the results by MSA row name (which is
- * what react-msaview matches domains against).
- *
- * The overlay is handed over as `Annotation[]`, the shape every source flattens
- * to. It used to be dressed up as an InterProScan response — an `xref` invented
- * to carry the row name — so that `setDomains` could unwrap it again; that entry
- * point exists for plugins holding the actual EBI wire format, which this is
- * not.
+ * annotations. Each launch stores a row's accession in its row data, so those
+ * are looked up via efetch and keyed by MSA row name, which is what
+ * react-msaview matches annotations against.
  */
-export async function loadProteinDomains(self) {
-    const metadataJson = self.data.treeMetadata;
-    if (!metadataJson) {
-        throw new Error('No sequence metadata available to look up domains');
-    }
-    const metadata = JSON.parse(metadataJson);
-    const rowAccessions = Object.entries(metadata)
-        .map(([rowName, meta]) => ({ rowName, accession: meta.Accession }))
-        .filter((r) => !!r.accession);
+export async function loadProteinDomains(self, signal) {
+    const rowAccessions = Object.entries(self.rowData).flatMap(([rowName, row]) => row?.Accession ? [{ rowName, accession: row.Accession }] : []);
     if (rowAccessions.length === 0) {
         throw new Error('No NCBI accessions found in alignment rows');
     }
-    self.setProgress(`Fetching protein domains from NCBI for ${rowAccessions.length} sequences...`);
-    const byAccession = await fetchProteinDomains(rowAccessions.map(r => r.accession));
+    const byAccession = await fetchProteinDomains(rowAccessions.map(r => r.accession), signal);
     const annotations = rowAccessions.flatMap(({ rowName, accession }) => (byAccession.get(accession) ?? []).flatMap(({ signature, locations }) => signature.entry
         ? locations.map(({ start, end }) => ({
             id: rowName,

package/dist/MsaViewPanel/loadProteinDomains.test.js

@@ -10,8 +10,7 @@ const MATCH = {
 };
 function model(treeMetadata) {
     return {
-        data: { treeMetadata: JSON.stringify(treeMetadata) },
-        setProgress: vi.fn(),
+        rowData: treeMetadata,
         setAnnotations: vi.fn(),
     };
 }