jbrowse-plugin-msaview 3.4.0 → 3.5.0

package/dist/MsaViewPanel/doLaunchOrthologs.test.js

@@ -33,10 +33,24 @@ const setQuerySeqName = vi.fn();
 function makeModel(orthologParams) {
     return {
         orthologParams,
-        setProgress: () => { },
         setQuerySeqName,
     };
 }
+// a scope that never cancels, so these tests see the launch's own behaviour --
+// what the scope does when it IS cancelled is runLaunch.test.ts's subject
+function launch({ self }) {
+    return doLaunchOrthologs({
+        self,
+        scope: {
+            signal: new AbortController().signal,
+            act: fn => {
+                fn();
+            },
+            onProgress: () => { },
+            onRid: () => { },
+        },
+    });
+}
 function params(extra = {}) {
     return {
         taxId: HUMAN,
@@ -79,11 +93,11 @@ beforeEach(() => {
 });
 describe('which species become rows', () => {
     test('omitted taxa asks for no restriction at all, which is every ortholog NCBI has', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(rowRequest().taxa).toBeUndefined();
     });
     test('given taxa is taken as written', async () => {
-        await doLaunchOrthologs({
+        await launch({
             self: makeModel(params({ taxa: [HUMAN, 10090, 9615] })),
         });
         expect(rowRequest().taxa).toEqual([9606, 9615, 10090]);
@@ -92,20 +106,20 @@ describe('which species become rows', () => {
     // and "the query row already covers this one" stay separable -- an unrestricted
     // launch still has to drop the query species.
     test('the query species is excluded whether or not taxa was given', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(rowRequest().exclude).toBe(HUMAN);
         vi.clearAllMocks();
         mockResolveGeneId.mockResolvedValue({ geneId: GENE_ID, matched: 'NLRP1' });
         mockFetchProtein.mockResolvedValue(REPRESENTATIVE);
         mockFetchRows.mockResolvedValue([]);
         mockLaunchMSA.mockResolvedValue({ msa: '', tree: '' });
-        await doLaunchOrthologs({
+        await launch({
             self: makeModel(params({ taxa: [HUMAN, 10090] })),
         });
         expect(rowRequest().exclude).toBe(HUMAN);
     });
     test('an empty list is a request for no rows, not a request for all of them', async () => {
-        await doLaunchOrthologs({ self: makeModel(params({ taxa: [] })) });
+        await launch({ self: makeModel(params({ taxa: [] })) });
         expect(rowRequest().taxa).toEqual([]);
     });
 });
@@ -114,11 +128,11 @@ describe('which species become rows', () => {
 // second a row.
 describe('the row cap', () => {
     test('is passed through when given', async () => {
-        await doLaunchOrthologs({ self: makeModel(params({ maxSpecies: 12 })) });
+        await launch({ self: makeModel(params({ maxSpecies: 12 })) });
         expect(rowRequest().limit).toBe(12);
     });
     test('omitted leaves the default to fetchOrthologGenes rather than sending Infinity', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(rowRequest().limit).toBeUndefined();
         expect(defaultMaxSpecies).toBeGreaterThan(2);
     });
@@ -129,7 +143,7 @@ describe('the row cap', () => {
 // model's querySeqName and the header have to be the same string.
 describe('the query row name', () => {
     test('is the species, marked, rather than a bare QUERY among named rows', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(queryRowName()).toBe('human_query');
         expect(setQuerySeqName).toHaveBeenCalledWith('human_query');
     });
@@ -137,41 +151,41 @@ describe('the query row name', () => {
         mockFetchRows.mockResolvedValue([
             { label: 'human_query', sequence: 'MM' },
         ]);
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(queryRowName()).toBe('human_query_2');
         expect(setQuerySeqName).toHaveBeenCalledWith('human_query_2');
     });
     test('falls back rather than throwing when NCBI cannot name the taxon', async () => {
         vi.spyOn(console, 'warn').mockImplementation(() => { });
         mockFetchTaxonomy.mockRejectedValue(new Error('429'));
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(queryRowName()).toBe('query_query');
     });
     test('the metadata that drives the domain overlay is keyed to that same name', async () => {
-        const result = await doLaunchOrthologs({ self: makeModel(params()) });
+        const result = await launch({ self: makeModel(params()) });
         expect(Object.keys(JSON.parse(result.treeMetadata))).toContain('human_query');
     });
 });
 describe('the query row sequence', () => {
     test('omitted proteinSequence falls back to the representative protein', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(queryRowSent()).toBe(REPRESENTATIVE.sequence);
     });
     test('a supplied sequence is used, and is cleaned first', async () => {
-        await doLaunchOrthologs({
+        await launch({
             self: makeModel(params({ proteinSequence: 'MAGG*AWGR&' })),
         });
         expect(queryRowSent()).toBe('MAGGAWGR');
     });
     test('throws when neither a sequence nor a representative is available', async () => {
         mockFetchProtein.mockResolvedValue(undefined);
-        await expect(doLaunchOrthologs({ self: makeModel(params()) })).rejects.toThrow(/No query protein/);
+        await expect(launch({ self: makeModel(params()) })).rejects.toThrow(/No query protein/);
         expect(mockLaunchMSA).not.toHaveBeenCalled();
     });
     test('a failed representative lookup does not take down a launch that brought its own sequence', async () => {
         vi.spyOn(console, 'warn').mockImplementation(() => { });
         mockFetchProtein.mockRejectedValue(new Error('429'));
-        await doLaunchOrthologs({
+        await launch({
             self: makeModel(params({ proteinSequence: REPRESENTATIVE.sequence })),
         });
         expect(queryRowSent()).toBe(REPRESENTATIVE.sequence);
@@ -183,14 +197,24 @@ describe('the query row sequence', () => {
 // here, in both directions.
 describe('the Accession that drives the domain overlay', () => {
     test('is attached when the query row IS the representative protein', async () => {
-        const result = await doLaunchOrthologs({ self: makeModel(params()) });
+        const result = await launch({ self: makeModel(params()) });
         expect(queryMetadata(result)).toMatchObject({
             'Gene ID': GENE_ID,
             Accession: REPRESENTATIVE.accession,
         });
     });
+    // orthologParams is frozen, so a session reload hands the transcript back as
+    // the plain JSON it serialized to; .get() on that threw
+    test('names the transcript from a snapshot-restored transcript', async () => {
+        const result = await launch({
+            self: makeModel(params({
+                selectedTranscript: { uniqueId: 'NM_1', name: 'TP53-201' },
+            })),
+        });
+        expect(queryMetadata(result).Transcript).toBe('TP53-201');
+    });
     test('is withheld from a non-representative isoform', async () => {
-        const result = await doLaunchOrthologs({
+        const result = await launch({
             self: makeModel(params({ proteinSequence: 'MDIFFERENTISOFORM' })),
         });
         expect(queryMetadata(result).Accession).toBeUndefined();
@@ -198,7 +222,7 @@ describe('the Accession that drives the domain overlay', () => {
     test('is withheld when the representative lookup failed', async () => {
         vi.spyOn(console, 'warn').mockImplementation(() => { });
         mockFetchProtein.mockRejectedValue(new Error('429'));
-        const result = await doLaunchOrthologs({
+        const result = await launch({
             self: makeModel(params({ proteinSequence: REPRESENTATIVE.sequence })),
         });
         expect(queryMetadata(result).Accession).toBeUndefined();
@@ -235,12 +259,12 @@ describe('the PANTHER source', () => {
         mockFetchTaxonomy.mockResolvedValue(new Map([[YEAST, { sciname: 'Saccharomyces cerevisiae' }]]));
     });
     test('source omitted is NCBI, so an old launch never reaches PANTHER', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(mockFetchPanther).not.toHaveBeenCalled();
         expect(mockResolveGeneId).toHaveBeenCalled();
     });
     test('source panther asks PANTHER with the same species semantics, and skips NCBI', async () => {
-        await doLaunchOrthologs({
+        await launch({
             self: makeModel({
                 taxId: YEAST,
                 source: 'panther',
@@ -260,7 +284,7 @@ describe('the PANTHER source', () => {
         expect(limit).toBe(7);
     });
     test("the query row is PANTHER's own entry for the gene when no sequence was supplied, and carries its UniProt accession for the domain overlay", async () => {
-        const result = await doLaunchOrthologs({
+        const result = await launch({
             self: makeModel({
                 taxId: YEAST,
                 source: 'panther',
@@ -280,7 +304,7 @@ describe('the PANTHER source', () => {
         });
     });
     test('a supplied sequence still wins, and a different isoform earns no Accession', async () => {
-        const result = await doLaunchOrthologs({
+        const result = await launch({
             self: makeModel({
                 taxId: YEAST,
                 source: 'panther',
@@ -294,7 +318,7 @@ describe('the PANTHER source', () => {
     });
     test('names PANTHER when it has no protein for the query row', async () => {
         mockFetchPanther.mockResolvedValue({ ...found, query: undefined });
-        await expect(doLaunchOrthologs({
+        await expect(launch({
             self: makeModel({
                 taxId: YEAST,
                 source: 'panther',

package/dist/MsaViewPanel/genomeToMSA.js

@@ -1,5 +1,5 @@
 import { getSession } from '@jbrowse/core/util';
-import { hasHoverPosition, hasQueryRow } from './util';
+import { hasHoverPosition, hasQueryRow, transcriptPosToVisibleCol, } from './util';
 export function genomeToMSA({ model }) {
     const { hovered } = getSession(model);
     const { querySeqName, transcriptToMsaMap, connectedView, mafRegion } = model;
@@ -26,9 +26,9 @@ export function genomeToMSA({ model }) {
     // without it the same numeric coordinate on an unrelated chromosome matches a
     // g2p key and lights up a column for a different locus
     if (refName === transcriptToMsaMap?.refName) {
-        const seqPos = transcriptToMsaMap.g2p[genomePos];
-        if (seqPos !== undefined) {
-            return model.seqPosToVisibleCol(querySeqName, seqPos);
+        const proteinPos = transcriptToMsaMap.g2p[genomePos];
+        if (proteinPos !== undefined) {
+            return transcriptPosToVisibleCol(model, proteinPos);
         }
     }
     return undefined;

package/dist/MsaViewPanel/genomeToMSA.test.js

@@ -202,6 +202,7 @@ describe('genomeToMSA', () => {
             const mockSeqPosToVisibleCol = vi.fn().mockReturnValue(10);
             const model = {
                 querySeqName: 'QUERY',
+                querySeqOffset: 0,
                 rows: [['QUERY', 'MKVLTAEEK']],
                 transcriptToMsaMap: {
                     refName: 'chr1',
@@ -211,6 +212,7 @@ describe('genomeToMSA', () => {
                 mafRegion: undefined,
                 connectedView: { initialized: true },
                 seqPosToVisibleCol: mockSeqPosToVisibleCol,
+                visibleColToSeqPos: (_name, col) => col,
             };
             const result = genomeToMSA({ model });
             expect(mockSeqPosToVisibleCol).toHaveBeenCalledWith('QUERY', 10);
@@ -240,6 +242,71 @@ describe('genomeToMSA', () => {
             expect(genomeToMSA({ model })).toBeUndefined();
             expect(mockSeqPosToVisibleCol).not.toHaveBeenCalled();
         });
+        // a pasted alignment often carries only the region BLAST aligned, and
+        // querySeqOffset says how much of the protein comes before it
+        test('shifts a trimmed query row by querySeqOffset', () => {
+            mockGetSession.mockReturnValue({
+                hovered: {
+                    hoverFeature: {},
+                    hoverPosition: { coord: 1005, refName: 'chr1' },
+                },
+            });
+            const seqPosToVisibleCol = vi.fn((_name, pos) => pos);
+            const model = {
+                querySeqName: 'QUERY',
+                querySeqOffset: 4,
+                rows: [['QUERY', 'MKVLTAEEK']],
+                transcriptToMsaMap: { refName: 'chr1', g2p: { 1004: 10 } },
+                mafRegion: undefined,
+                connectedView: { initialized: true },
+                seqPosToVisibleCol,
+                visibleColToSeqPos: (_name, col) => col,
+            };
+            expect(genomeToMSA({ model })).toBe(6);
+            expect(seqPosToVisibleCol).toHaveBeenCalledWith('QUERY', 6);
+        });
+        test('maps nothing for a residue before the trimmed row starts', () => {
+            mockGetSession.mockReturnValue({
+                hovered: {
+                    hoverFeature: {},
+                    hoverPosition: { coord: 1005, refName: 'chr1' },
+                },
+            });
+            const seqPosToVisibleCol = vi.fn((_name, pos) => pos);
+            const model = {
+                querySeqName: 'QUERY',
+                querySeqOffset: 20,
+                rows: [['QUERY', 'MKVLTAEEK']],
+                transcriptToMsaMap: { refName: 'chr1', g2p: { 1004: 10 } },
+                mafRegion: undefined,
+                connectedView: { initialized: true },
+                seqPosToVisibleCol,
+                visibleColToSeqPos: (_name, col) => col,
+            };
+            expect(genomeToMSA({ model })).toBeUndefined();
+            expect(seqPosToVisibleCol).not.toHaveBeenCalled();
+        });
+        // react-msaview answers one column past the end for a residue the row does
+        // not have, which would light the last column for everything beyond it
+        test('maps nothing for a residue the row stops short of', () => {
+            mockGetSession.mockReturnValue({
+                hovered: {
+                    hoverFeature: {},
+                    hoverPosition: { coord: 1005, refName: 'chr1' },
+                },
+            });
+            const model = {
+                querySeqName: 'QUERY',
+                querySeqOffset: 0,
+                rows: [['QUERY', 'MKV']],
+                transcriptToMsaMap: { refName: 'chr1', g2p: { 1004: 10 } },
+                mafRegion: undefined,
+                connectedView: { initialized: true },
+                seqPosToVisibleCol: () => 3,
+                visibleColToSeqPos: () => undefined,
+            };
+            expect(genomeToMSA({ model })).toBeUndefined();
+        });
         test('returns undefined when g2p has no mapping for coord', () => {
             mockGetSession.mockReturnValue({
                 hovered: {

package/dist/MsaViewPanel/loadProteinDomains.d.ts

@@ -1,16 +1,22 @@
-import type { InterProScanResults } from 'react-msaview';
+import type { Annotation } from 'react-msaview';
 interface DomainModel {
     data: {
         treeMetadata?: string;
     };
     setProgress: (arg: string) => void;
-    setDomains: (data: Record<string, InterProScanResults>) => void;
+    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.
  */
 export declare function loadProteinDomains(self: DomainModel): Promise<void>;
 export {};

package/dist/MsaViewPanel/loadProteinDomains.js

@@ -4,6 +4,12 @@ import { fetchProteinDomains } from '../utils/ncbiDomains';
  * 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.
  */
 export async function loadProteinDomains(self) {
     const metadataJson = self.data.treeMetadata;
@@ -19,15 +25,18 @@ export async function loadProteinDomains(self) {
     }
     self.setProgress(`Fetching protein domains from NCBI for ${rowAccessions.length} sequences...`);
     const byAccession = await fetchProteinDomains(rowAccessions.map(r => r.accession));
-    const annotations = {};
-    for (const { rowName, accession } of rowAccessions) {
-        const matches = byAccession.get(accession);
-        if (matches && matches.length > 0) {
-            annotations[rowName] = { matches, xref: [{ id: rowName }] };
-        }
-    }
-    if (Object.keys(annotations).length === 0) {
+    const annotations = rowAccessions.flatMap(({ rowName, accession }) => (byAccession.get(accession) ?? []).flatMap(({ signature, locations }) => signature.entry
+        ? locations.map(({ start, end }) => ({
+            id: rowName,
+            accession: signature.entry.accession,
+            name: signature.entry.name,
+            description: signature.entry.description,
+            start,
+            end,
+        }))
+        : []));
+    if (annotations.length === 0) {
         throw new Error('No CDD domain annotations found for these proteins');
     }
-    self.setDomains(annotations);
+    self.setAnnotations(annotations);
 }

package/dist/MsaViewPanel/loadProteinDomains.test.d.ts

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

package/dist/MsaViewPanel/loadProteinDomains.test.js

@@ -0,0 +1,41 @@
+import { expect, test, vi } from 'vitest';
+import { fetchProteinDomains } from '../utils/ncbiDomains';
+import { loadProteinDomains } from './loadProteinDomains';
+vi.mock('../utils/ncbiDomains', () => ({ fetchProteinDomains: vi.fn() }));
+const MATCH = {
+    signature: {
+        entry: { accession: 'cd00093', name: 'HTH_XRE', description: 'a domain' },
+    },
+    locations: [{ start: 5, end: 40 }],
+};
+function model(treeMetadata) {
+    return {
+        data: { treeMetadata: JSON.stringify(treeMetadata) },
+        setProgress: vi.fn(),
+        setAnnotations: vi.fn(),
+    };
+}
+test('an accession row becomes one annotation per location, keyed by row name', async () => {
+    vi.mocked(fetchProteinDomains).mockResolvedValue(new Map([['NP_1', [MATCH]]]));
+    const self = model({
+        QUERY: { Accession: 'NP_1' },
+        other: { 'Scientific name': 'Mus musculus' },
+    });
+    await loadProteinDomains(self);
+    expect(self.setAnnotations).toHaveBeenCalledWith([
+        {
+            id: 'QUERY',
+            accession: 'cd00093',
+            name: 'HTH_XRE',
+            description: 'a domain',
+            start: 5,
+            end: 40,
+        },
+    ]);
+});
+test('says so rather than clearing the overlay when NCBI has nothing', async () => {
+    vi.mocked(fetchProteinDomains).mockResolvedValue(new Map());
+    const self = model({ QUERY: { Accession: 'NP_1' } });
+    await expect(loadProteinDomains(self)).rejects.toThrow('No CDD domain annotations found');
+    expect(self.setAnnotations).not.toHaveBeenCalled();
+});