jbrowse-plugin-msaview 3.8.0 → 3.10.0

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -8,68 +8,70 @@ import { loadProteinDomains } from './loadProteinDomains';
 import { cleanupOldData, generateDataStoreId, retrieveMsaData, storeMsaData, } from './msaDataStore';
 import { runLaunch } from './runLaunch';
 import { getProteinViews } from './structureConnection';
+import { proteinPositionsInRange } from './transcriptMap';
 import { getUniprotIdFromAlphaFoldUrl, hasQueryRow, transcriptPosToVisibleCol, } from './util';
 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 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, rows } = self;
-    if (dataStoreId && rows.length === 0) {
-        void (async () => {
-            try {
-                self.setLoadingStoredData(true);
-                const storedData = await retrieveMsaData(dataStoreId);
-                if (storedData) {
-                    // one transaction, so storeDataToIndexedDB sees the restored data and
-                    // the record of it together and does not write it straight back
-                    transaction(() => {
-                        if (storedData.msa) {
-                            self.setMSA(storedData.msa);
-                        }
-                        if (storedData.tree) {
-                            self.setTree(storedData.tree);
-                        }
-                        if (storedData.treeMetadata) {
-                            self.setTreeMetadata(storedData.treeMetadata);
-                        }
-                        if (storedData.gff) {
-                            self.setGFF(storedData.gff);
-                        }
-                        self.setLastStoredData(currentData(self));
-                    });
+    const { dataStoreId } = self;
+    if (!dataStoreId) {
+        return;
+    }
+    void (async () => {
+        try {
+            self.setLoadingStoredData(true);
+            const stored = await retrieveMsaData(dataStoreId);
+            if (self.dataStoreId !== dataStoreId) {
+                return;
+            }
+            transaction(() => {
+                if (stored) {
+                    const { data } = self;
+                    if (stored.msa && !data.msa) {
+                        self.setMSA(stored.msa);
+                    }
+                    if (stored.tree && !data.tree) {
+                        self.setTree(stored.tree);
+                    }
+                    if (stored.treeMetadata && !data.treeMetadata) {
+                        self.setTreeMetadata(stored.treeMetadata);
+                    }
+                    if (stored.gff && !data.gff) {
+                        self.setGFF(stored.gff);
+                    }
+                    self.setLastStoredData(stored);
                 }
                 else {
-                    // the id names nothing, so clearing it is what lets react-msaview's
-                    // "Return to import form" actually return instead of landing back
-                    // here. The request that built the alignment is kept, though: it is
-                    // the whole of a retry, and dropping it left the user reading an
-                    // apology with nothing to press.
-                    transaction(() => {
-                        self.setDataStoreId(undefined);
+                    self.setDataStoreId(undefined);
+                    if (hasAlignmentSource(self)) {
+                        self.addWarning(EXPIRED_EXTRAS_WARNING);
+                    }
+                    else {
                         self.setError(new Error(EXPIRED_MESSAGE +
                             ((self.blastParams ?? self.orthologParams)
                                 ? RELAUNCHABLE
                                 : START_OVER)));
-                    });
+                    }
                 }
-            }
-            catch (e) {
-                console.error('Failed to load MSA data from IndexedDB:', e);
-            }
-            finally {
-                self.setLoadingStoredData(false);
-            }
-        })();
-    }
+            });
+        }
+        catch (e) {
+            console.error('Failed to load MSA data from IndexedDB:', e);
+        }
+        finally {
+            self.setLoadingStoredData(false);
+        }
+    })();
 }
-/**
- * Everything react-msaview drops from the snapshot once it passes 50kB. The
- * GFF is among them: a local one's filehandle is cleared once it loads, so
- * this row is the only copy.
- */
-function currentData(self) {
-    const { msa, tree, treeMetadata, gff } = self.data;
-    return { msa, tree, treeMetadata, gff };
+function hasAlignmentSource(self) {
+    return !!(self.data.msa ||
+        self.msaFilehandle ||
+        self.init?.msaIndexedLocation);
+}
+function isEmpty(data) {
+    return !(data.msa || data.tree || data.treeMetadata || data.gff);
 }
 function sameData(a, b) {
     return (!!a &&
@@ -79,44 +81,37 @@ function sameData(a, b) {
         a.gff === b.gff);
 }
 /**
- * Keep IndexedDB holding what the view holds. The first run writes a new row and
- * records its id in the session snapshot; later runs update that row, because
- * the alignment keeps changing after it arrives — react-msaview's
- * "calculate neighbor-joining tree" replaces `data.tree` — and a session
- * reopened against a stale row restores the wrong picture.
- *
- * `lastStoredData` is what makes that safe to run on every data change: it is
- * the only thing separating "this is new" from "this is what we just wrote", and
- * it is recorded whether or not the write succeeded, so a browser refusing
- * IndexedDB (private mode) fails once rather than in a loop.
- *
- * A view whose data comes from a filehandle -- or from the indexed block its
- * kept `init` names -- stores nothing at all: the file is the source of truth
- * and it is refetched at startup.
+ * Keep IndexedDB holding `unsavedDocuments`. A view writes in place only to a
+ * row it created (`ownsDataStoreRow`), and never deletes one, since other
+ * views may name it: an emptied set drops the id and cleanupOldData ages the
+ * row out. `lastStoredData` is recorded even when a write fails, so a browser
+ * refusing IndexedDB fails once rather than in a loop.
  */
 export function storeDataToIndexedDB(self) {
-    const { rows, dataStoreId, isStoringData, lastStoredData, init } = self;
-    const data = currentData(self);
-    if (rows.length === 0 ||
-        isStoringData ||
-        self.msaFilehandle ||
-        self.treeFilehandle ||
-        // an indexed view keeps its init and refetches the block, so a row here
-        // would be one nothing ever reads
-        !!init?.msaIndexedLocation ||
-        !(data.msa || data.tree) ||
-        sameData(lastStoredData, data)) {
+    const { dataStoreId, ownsDataStoreRow, isStoringData, loadingStoredData, lastStoredData, } = self;
+    const data = self.unsavedDocuments;
+    if (isStoringData || loadingStoredData || sameData(lastStoredData, data)) {
+        return;
+    }
+    if (isEmpty(data)) {
+        if (lastStoredData) {
+            transaction(() => {
+                self.setDataStoreId(undefined);
+                self.setOwnsDataStoreRow(false);
+                self.setLastStoredData(data);
+            });
+        }
         return;
     }
-    // mark as storing synchronously so re-runs of this autorun (e.g. when data
-    // observables change while the write is pending) don't kick off a duplicate
-    // write and leave an orphan IndexedDB entry
     self.setIsStoringData(true);
     void (async () => {
         try {
-            const id = dataStoreId ?? generateDataStoreId();
+            const id = dataStoreId && ownsDataStoreRow ? dataStoreId : generateDataStoreId();
             if (await storeMsaData(id, data)) {
-                self.setDataStoreId(id);
+                transaction(() => {
+                    self.setDataStoreId(id);
+                    self.setOwnsDataStoreRow(true);
+                });
             }
         }
         catch (e) {
@@ -297,19 +292,15 @@ function genomeHighlightsToVisibleColumns(self, field) {
     if (!transcriptToMsaMap || !hasQueryRow(self)) {
         return [];
     }
-    const { g2p } = transcriptToMsaMap;
     const columns = new Set();
     for (const view of getProteinViews(getSession(self).views)) {
         for (const structure of view.structures) {
             if (structure.connectedViewId !== connectedViewId) {
                 continue;
             }
-            for (const highlight of structure[field] ?? []) {
-                for (let coord = highlight.start; coord < highlight.end; coord++) {
-                    const proteinPos = g2p[coord];
-                    const col = proteinPos === undefined
-                        ? undefined
-                        : transcriptPosToVisibleCol(self, proteinPos);
+            for (const { start, end } of structure[field] ?? []) {
+                for (const proteinPos of proteinPositionsInRange(transcriptToMsaMap, start, end)) {
+                    const col = transcriptPosToVisibleCol(self, proteinPos);
                     if (col !== undefined) {
                         columns.add(col);
                     }

package/dist/MsaViewPanel/components/MsaViewPanel.js

@@ -25,7 +25,7 @@ const MsaViewPanel = observer(function MsaViewPanel2({ model, }) {
     const expired = !!request && !!model.error && !model.dataInitialized;
     const launching = pending || expired || (!!init && !model.dataInitialized);
     return (React.createElement(ErrorBoundary, null,
-        React.createElement("div", null, launching ? (React.createElement(LaunchProgress, { model: model })) : loadingStoredData ? (React.createElement("div", { className: classes.loadingContainer },
+        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/doLaunchBlast.js

@@ -1,8 +1,10 @@
 import { cleanProteinSequence } from '../LaunchMsaView/util';
 import { saveBlastResult } from '../utils/blastCache';
+import { checkPairSize } from '../utils/browserAlign';
 import { searchBackends } from '../utils/homologSearch';
 import { launchMSA } from '../utils/msa';
 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';
@@ -38,23 +40,13 @@ async function resolveQuery(self, scope) {
     }
     throw new Error('No query: a search needs a proteinSequence, a UniProt accession, or a connectedTranscript to translate');
 }
-/**
- * A similarity search, then an alignment of what it found. The program is a
- * backend behind one interface (utils/homologSearch.ts); what differs between
- * them is settled by whether the result came back aligned. A program that
- * aligns as it searches (phmmer) hands over the alignment and the tree is
- * built from it in the browser; one that does not (blastp) hands over bare
- * hits and the chosen aligner runs on them.
- */
-export async function doLaunchBlast({ self, scope, }) {
+async function search({ self, scope, query, querySeqName, key, }) {
     const params = self.blastParams;
-    const { selectedTranscript, maxHits, searchProgram = 'blastp' } = params;
-    const { sequence: query, name: querySeqName } = await resolveQuery(self, scope);
     const { onProgress, onRid, signal } = scope;
-    const { hits, queryRow, rid } = await searchBackends[searchProgram]({
+    const { hits, queryRow, rid } = await searchBackends[params.searchProgram ?? 'blastp']({
         query,
         database: params.blastDatabase,
-        maxHits,
+        maxHits: params.maxHits,
         onProgress,
         onRid,
         signal,
@@ -63,7 +55,7 @@ export async function doLaunchBlast({ self, scope, }) {
         throw new Error('No hits found');
     }
     onProgress('Fetching species taxonomy info...');
-    const taxonomyInfo = await fetchTaxonomyInfo(hits.map(h => h.taxid).filter((t) => t !== undefined));
+    const taxonomyInfo = await fetchTaxonomyInfo(hits.map(h => h.taxid).filter((t) => t !== undefined), signal);
     const { msa: fasta, treeMetadata } = buildSearchMsa({
         hits,
         query,
@@ -71,10 +63,44 @@ export async function doLaunchBlast({ self, scope, }) {
         taxonomyInfo,
         querySeqName,
     });
+    if (!queryRow) {
+        await saveSearch({ id: key, fasta, treeMetadata, rid });
+    }
+    return { fasta, treeMetadata, rid, queryRow };
+}
+/**
+ * A similarity search, then an alignment of what it found. The program is a
+ * backend behind one interface (utils/homologSearch.ts); what differs between
+ * them is settled by whether the result came back aligned. A program that
+ * aligns as it searches (phmmer) hands over the alignment and the tree is
+ * built from it in the browser; one that does not (blastp) hands over bare
+ * hits and the chosen aligner runs on them.
+ */
+export async function doLaunchBlast({ self, scope, }) {
+    const params = self.blastParams;
+    const { selectedTranscript, maxHits, searchProgram = 'blastp' } = params;
+    const msaAlgorithm = params.msaAlgorithm ?? 'browser';
+    const { sequence: query, name: querySeqName } = await resolveQuery(self, scope);
+    if (searchProgram === 'blastp' && msaAlgorithm === 'browser') {
+        checkPairSize(querySeqName, query.length, query.length);
+    }
+    const { onProgress, signal } = scope;
+    const key = searchKey({
+        searchProgram,
+        database: params.blastDatabase,
+        maxHits,
+        querySeqName,
+        query,
+    });
+    const found = await getCachedSearch(key);
+    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 { msa, tree } = queryRow
         ? { msa: fasta, tree: '' }
         : await launchMSA({
-            algorithm: params.msaAlgorithm ?? 'browser',
+            algorithm: msaAlgorithm,
             sequence: fasta,
             onProgress,
             signal,
@@ -84,7 +110,7 @@ export async function doLaunchBlast({ self, scope, }) {
     await saveBlastResult({
         proteinSequence: query,
         blastDatabase: params.blastDatabase,
-        msaAlgorithm: queryRow ? undefined : (params.msaAlgorithm ?? 'browser'),
+        msaAlgorithm: queryRow ? undefined : msaAlgorithm,
         searchProgram: params.searchProgram,
         maxHits,
         msa,

package/dist/MsaViewPanel/doLaunchBlast.test.js

@@ -1,7 +1,9 @@
 import { beforeEach, expect, test, vi } from 'vitest';
 import { saveBlastResult } from '../utils/blastCache';
+import { MAX_PAIR_CELLS } from '../utils/browserAlign';
 import { searchBackends } from '../utils/homologSearch';
 import { launchMSA } from '../utils/msa';
+import { getCachedSearch, saveSearch } from '../utils/searchCache';
 import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
 import { resolveUniProtEntry } from '../utils/unirefHomologs';
 import { doLaunchBlast } from './doLaunchBlast';
@@ -15,6 +17,11 @@ vi.mock('../utils/msa', () => ({ launchMSA: vi.fn() }));
 vi.mock('../utils/taxonomyNames', () => ({ fetchTaxonomyInfo: vi.fn() }));
 vi.mock('../utils/blastCache', () => ({ saveBlastResult: vi.fn() }));
 vi.mock('../utils/unirefHomologs', () => ({ resolveUniProtEntry: vi.fn() }));
+vi.mock('../utils/searchCache', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getCachedSearch: vi.fn(),
+    saveSearch: vi.fn(),
+}));
 const blastp = vi.mocked(searchBackends.blastp);
 const phmmer = vi.mocked(searchBackends.phmmer);
 const mockLaunchMSA = vi.mocked(launchMSA);
@@ -44,6 +51,8 @@ beforeEach(() => {
     vi.clearAllMocks();
     vi.mocked(fetchTaxonomyInfo).mockResolvedValue(new Map());
     vi.mocked(saveBlastResult).mockResolvedValue(undefined);
+    vi.mocked(getCachedSearch).mockResolvedValue(undefined);
+    vi.mocked(saveSearch).mockResolvedValue(undefined);
 });
 test('bare hits go to the chosen aligner, with the query first', async () => {
     blastp.mockResolvedValue({ rid: 'job', hits: [{ ...HIT, sequence: 'MKWV' }] });
@@ -168,3 +177,48 @@ test('a live Feature handed over in the same session labels it the same way', as
         geneName: 'TP53',
     }));
 });
+const BLASTP_BROWSER = {
+    searchProgram: 'blastp',
+    blastDatabase: 'uniprotkb_swissprot',
+    msaAlgorithm: 'browser',
+    proteinSequence: 'MKWVTF',
+};
+test('the hits are saved before the aligner runs, so a failed alignment keeps them', async () => {
+    blastp.mockResolvedValue({ rid: 'job', hits: [{ ...HIT, sequence: 'MKWV' }] });
+    mockLaunchMSA.mockRejectedValue(new Error('aligner fell over'));
+    await expect(launch(makeModel(BLASTP_BROWSER))).rejects.toThrow('aligner fell over');
+    expect(saveSearch).toHaveBeenCalledWith(expect.objectContaining({
+        fasta: '>QUERY\nMKWVTF\n>P1-Mus_musculus\nMKWV',
+        rid: 'job',
+    }));
+});
+test('a relaunch with saved hits aligns them without searching again', async () => {
+    vi.mocked(getCachedSearch).mockResolvedValue({
+        id: 'k',
+        fasta: '>QUERY\nMKWVTF\n>P1\nMKWV',
+        treeMetadata: {},
+        rid: 'job',
+        timestamp: 0,
+    });
+    mockLaunchMSA.mockResolvedValue({ msa: 'aligned', tree: '' });
+    const result = await launch(makeModel(BLASTP_BROWSER));
+    expect(blastp).not.toHaveBeenCalled();
+    expect(mockLaunchMSA).toHaveBeenCalledWith(expect.objectContaining({ sequence: '>QUERY\nMKWVTF\n>P1\nMKWV' }));
+    expect(result.msa).toBe('aligned');
+});
+test('a query too long for the in-browser aligner is refused before the search', async () => {
+    const side = Math.ceil(Math.sqrt(MAX_PAIR_CELLS)) + 1;
+    await expect(launch(makeModel({ ...BLASTP_BROWSER, proteinSequence: 'M'.repeat(side) }))).rejects.toThrow(/too large to align in the browser/);
+    expect(blastp).not.toHaveBeenCalled();
+});
+test('the same long query goes to an EBI aligner without complaint', async () => {
+    const side = Math.ceil(Math.sqrt(MAX_PAIR_CELLS)) + 1;
+    blastp.mockResolvedValue({ rid: 'job', hits: [{ ...HIT, sequence: 'MKWV' }] });
+    mockLaunchMSA.mockResolvedValue({ msa: 'aligned', tree: 'tree' });
+    await launch(makeModel({
+        ...BLASTP_BROWSER,
+        msaAlgorithm: 'clustalo',
+        proteinSequence: 'M'.repeat(side),
+    }));
+    expect(blastp).toHaveBeenCalled();
+});

package/dist/MsaViewPanel/doLaunchOrthologs.js

@@ -1,4 +1,5 @@
 import { cleanProteinSequence } from '../LaunchMsaView/util';
+import { isAbortError } from '../utils/fetch';
 import { launchMSA } from '../utils/msa';
 import { dedupeLabels, fetchOrthologRows, fetchProteinForGene, resolveGeneId, } from '../utils/ncbiOrthologs';
 import { fetchPantherOrthologs } from '../utils/pantherOrthologs';
@@ -33,6 +34,7 @@ export async function doLaunchOrthologs({ self, scope, }) {
         exclude: taxId,
         limit: maxSpecies,
         onProgress,
+        signal,
     };
     const { geneId, representative, rows } = source === 'panther'
         ? await findPantherOrthologs(request)
@@ -41,7 +43,6 @@ export async function doLaunchOrthologs({ self, scope, }) {
                 ...request,
                 identity,
                 referenceProteomesOnly,
-                signal,
             })
             : await findNcbiOrthologs(request);
     // The query row. The dialog always supplies it — it is the user's OWN
@@ -68,7 +69,7 @@ export async function doLaunchOrthologs({ self, scope, }) {
     // taxon is excluded from that set, but a subspecies can sanitize to the same
     // token, and a collision would silently point the coordinate mapping at
     // another animal's row.
-    const queryLabel = await queryRowLabel(taxId, rows);
+    const queryLabel = await queryRowLabel(taxId, rows, signal);
     act(() => {
         self.setQuerySeqName(queryLabel);
     });
@@ -98,16 +99,17 @@ export async function doLaunchOrthologs({ self, scope, }) {
  * wants "this gene across species" gets NCBI's own order, which leads with the
  * reference organisms.
  */
-async function findNcbiOrthologs({ taxId, geneCandidates, onProgress, ...rest }) {
+async function findNcbiOrthologs({ taxId, geneCandidates, onProgress, signal, ...rest }) {
     onProgress('Resolving gene at NCBI...');
-    const resolved = await resolveGeneId(geneCandidates, taxId);
+    const resolved = await resolveGeneId(geneCandidates, taxId, signal);
     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.`);
     }
-    const representative = await fetchRepresentativeQueryProtein(resolved.geneId);
+    const representative = await fetchRepresentativeQueryProtein(resolved.geneId, signal);
     const rows = await fetchOrthologRows({
         geneId: resolved.geneId,
         onProgress,
+        signal,
         ...rest,
     });
     return { geneId: resolved.geneId, representative, rows };
@@ -122,12 +124,11 @@ const sourceNames = {
  * entry the cluster was looked up from, whose sequence a spec-launched row
  * takes and whose accession earns the CDD overlay when the two match.
  */
-async function findUnirefHomologs({ geneCandidates, identity, referenceProteomesOnly, signal, ...rest }) {
+async function findUnirefHomologs({ geneCandidates, identity, referenceProteomesOnly, ...rest }) {
     const found = await fetchUnirefHomologs({
         candidates: geneCandidates,
         identity,
         referenceProteomesOnly,
-        signal,
         ...rest,
     });
     return {
@@ -160,13 +161,16 @@ async function findPantherOrthologs({ geneCandidates, ...rest }) {
  * marker when NCBI cannot name the taxon, which is a naming failure and must not
  * take down the launch.
  */
-async function queryRowLabel(taxId, rows) {
+async function queryRowLabel(taxId, rows, signal) {
     let name;
     try {
-        const info = (await fetchTaxonomyInfo([taxId])).get(taxId);
+        const info = (await fetchTaxonomyInfo([taxId], signal)).get(taxId);
         name = info?.commonName ?? info?.sciname;
     }
     catch (e) {
+        if (isAbortError(e)) {
+            throw e;
+        }
         console.warn('[msaview-orthologs] taxonomy name lookup failed:', e);
     }
     return dedupeLabels([
@@ -179,11 +183,14 @@ async function queryRowLabel(taxId, rows) {
  * that supplied no sequence of its own, the alignment — so it is reported by
  * returning nothing rather than by throwing here.
  */
-async function fetchRepresentativeQueryProtein(geneId) {
+async function fetchRepresentativeQueryProtein(geneId, signal) {
     try {
-        return await fetchProteinForGene(geneId);
+        return await fetchProteinForGene(geneId, signal);
     }
     catch (e) {
+        if (isAbortError(e)) {
+            throw e;
+        }
         console.warn('[msaview-orthologs] query protein lookup failed:', e);
         return undefined;
     }

package/dist/MsaViewPanel/launchAutoruns.test.js

@@ -8,7 +8,6 @@ vi.mock('@jbrowse/core/util', async (importOriginal) => ({
 vi.mock('./doLaunchBlast', () => ({ doLaunchBlast: vi.fn() }));
 vi.mock('./msaDataStore', () => ({
     cleanupOldData: vi.fn(async () => { }),
-    deleteMsaData: vi.fn(async () => { }),
     generateDataStoreId: vi.fn(),
     retrieveMsaData: vi.fn(),
     storeMsaData: vi.fn(),