jbrowse-plugin-msaview 3.4.0 → 3.5.0

package/dist/MsaViewPanel/msaCoordToGenomeCoord.test.js

@@ -1,6 +1,41 @@
 import { genomeToTranscriptSeqMapping } from 'g2p_mapper';
+import { MSAModelF } from 'react-msaview';
 import { describe, expect, test } from 'vitest';
 import { msaCoordToGenomeCoord, msaCoordToGenomeRegions, } from './msaCoordToGenomeCoord';
+/**
+ * A stand-in for the view model, converting exactly as react-msaview does: a
+ * visible column is shifted right past every hidden column before it, and the
+ * residue is then counted along the row.
+ */
+function coordModel({ rows, blanks = [], ...rest }) {
+    return {
+        ...rest,
+        transcriptToMsaMap: rest.transcriptToMsaMap,
+        visibleColToSeqPos(rowName, visibleCol) {
+            const seq = rows.find(r => r[0] === rowName)?.[1];
+            if (seq === undefined) {
+                return undefined;
+            }
+            let globalCol = visibleCol;
+            for (const blank of blanks) {
+                if (blank <= globalCol) {
+                    globalCol++;
+                }
+            }
+            const isBlank = (c) => c === '-' || c === '.';
+            if (globalCol >= seq.length || isBlank(seq[globalCol])) {
+                return undefined;
+            }
+            let seqPos = 0;
+            for (let i = 0; i < globalCol; i++) {
+                if (!isBlank(seq[i])) {
+                    seqPos++;
+                }
+            }
+            return seqPos;
+        },
+    };
+}
 // codon at protein position i covers three consecutive genome bases starting at
 // 100 + i * 3, i.e. a single-exon forward-strand transcript
 function forwardCodons(n) {
@@ -11,49 +46,49 @@ function forwardCodons(n) {
 }
 describe('msaCoordToGenomeCoord', () => {
     test('returns undefined when neither transcriptToMsaMap nor mafRegion is defined', () => {
-        const model = {
+        const model = coordModel({
             querySeqName: 'QUERY',
             transcriptToMsaMap: undefined,
             mafRegion: undefined,
             rows: [['QUERY', 'MKAA']],
-        };
+        });
         const result = msaCoordToGenomeCoord({ model, coord: 0 });
         expect(result).toBeUndefined();
     });
     test('returns undefined when query row is not found', () => {
-        const model = {
+        const model = coordModel({
             querySeqName: 'QUERY',
             transcriptToMsaMap: {
                 refName: 'chr1',
                 p2gCodon: forwardCodons(2),
             },
             rows: [['OTHER', 'MKAA']],
-        };
+        });
         const result = msaCoordToGenomeCoord({ model, coord: 0 });
         expect(result).toBeUndefined();
     });
     test('returns undefined when coord is a gap', () => {
-        const model = {
+        const model = coordModel({
             querySeqName: 'QUERY',
             transcriptToMsaMap: {
                 refName: 'chr1',
                 p2gCodon: forwardCodons(2),
             },
             rows: [['QUERY', 'M-KA']],
-        };
+        });
         // Position 1 is a gap
         const result = msaCoordToGenomeCoord({ model, coord: 1 });
         expect(result).toBeUndefined();
     });
     test('returns genome region for valid non-gap position', () => {
-        const model = {
+        const model = coordModel({
             querySeqName: 'QUERY',
             transcriptToMsaMap: {
                 refName: 'chr1',
                 p2gCodon: forwardCodons(4),
             },
             rows: [['QUERY', 'MKAA']],
-        };
+        });
         // Position 0 (M) should map to ungapped 0, genome 100-103
         const result = msaCoordToGenomeCoord({ model, coord: 0 });
         expect(result).toEqual({
@@ -63,7 +98,7 @@ describe('msaCoordToGenomeCoord', () => {
         });
     });
     test('handles gapped sequence correctly', () => {
-        const model = {
+        const model = coordModel({
             querySeqName: 'QUERY',
             transcriptToMsaMap: {
                 refName: 'chr1',
@@ -72,7 +107,7 @@ describe('msaCoordToGenomeCoord', () => {
             rows: [['QUERY', 'M-K-AA']],
             //                 012345 gapped positions
             //                 0  1 23 ungapped positions
-        };
+        });
         // Gapped position 2 (K) = ungapped 1
         const result = msaCoordToGenomeCoord({ model, coord: 2 });
         expect(result).toEqual({
@@ -89,27 +124,27 @@ describe('msaCoordToGenomeCoord', () => {
         });
     });
     test('returns undefined when the position has no codon mapping', () => {
-        const model = {
+        const model = coordModel({
             querySeqName: 'QUERY',
             transcriptToMsaMap: {
                 refName: 'chr1',
                 p2gCodon: forwardCodons(1),
             },
             rows: [['QUERY', 'MKAA']],
-        };
+        });
         // ungapped position 1 has no entry in p2gCodon
         const result = msaCoordToGenomeCoord({ model, coord: 1 });
         expect(result).toBeUndefined();
     });
     test('maps the final residue, whose codon has no successor', () => {
-        const model = {
+        const model = coordModel({
             querySeqName: 'QUERY',
             transcriptToMsaMap: {
                 refName: 'chr1',
                 p2gCodon: forwardCodons(4),
             },
             rows: [['QUERY', 'MKAA']],
-        };
+        });
         const result = msaCoordToGenomeCoord({ model, coord: 3 });
         expect(result).toEqual({
             refName: 'chr1',
@@ -118,20 +153,20 @@ describe('msaCoordToGenomeCoord', () => {
         });
     });
     test('returns undefined for out of bounds coord', () => {
-        const model = {
+        const model = coordModel({
             querySeqName: 'QUERY',
             transcriptToMsaMap: {
                 refName: 'chr1',
                 p2gCodon: forwardCodons(2),
             },
             rows: [['QUERY', 'MK']],
-        };
+        });
         // Position 10 is out of bounds
         const result = msaCoordToGenomeCoord({ model, coord: 10 });
         expect(result).toBeUndefined();
     });
     test('works with multiple rows, uses querySeqName', () => {
-        const model = {
+        const model = coordModel({
             querySeqName: 'SEQ2',
             transcriptToMsaMap: {
                 refName: 'chr1',
@@ -142,7 +177,7 @@ describe('msaCoordToGenomeCoord', () => {
                 ['SEQ2', 'MKAA'],
                 ['SEQ3', 'LLLL'],
             ],
-        };
+        });
         const result = msaCoordToGenomeCoord({ model, coord: 0 });
         expect(result).toEqual({
             refName: 'chr1',
@@ -162,11 +197,11 @@ describe('msaCoordToGenomeCoord', () => {
                 strand: 1,
                 subfeatures: [{ refName: 'chr1', type: 'CDS', start: 100, end: 112 }],
             });
-            const model = {
+            const model = coordModel({
                 querySeqName: 'QUERY',
                 transcriptToMsaMap: { refName, p2gCodon },
                 rows: [['QUERY', 'MKAA']],
-            };
+            });
             expect(msaCoordToGenomeCoord({ model, coord: 0 })).toEqual({
                 refName: 'chr1',
                 start: 100,
@@ -186,11 +221,11 @@ describe('msaCoordToGenomeCoord', () => {
                 strand: -1,
                 subfeatures: [{ refName: 'chr1', type: 'CDS', start: 100, end: 112 }],
             });
-            const model = {
+            const model = coordModel({
                 querySeqName: 'QUERY',
                 transcriptToMsaMap: { refName, p2gCodon },
                 rows: [['QUERY', 'MKAA']],
-            };
+            });
             // the first residue is translated from the 3' end of the genome region
             expect(msaCoordToGenomeCoord({ model, coord: 0 })).toEqual({
                 refName: 'chr1',
@@ -215,11 +250,11 @@ describe('msaCoordToGenomeCoord', () => {
                     { refName: 'chr1', type: 'CDS', start: 200, end: 202 },
                 ],
             });
-            const model = {
+            const model = coordModel({
                 querySeqName: 'QUERY',
                 transcriptToMsaMap: { refName, p2gCodon },
                 rows: [['QUERY', 'MK']],
-            };
+            });
             expect(msaCoordToGenomeRegions({ model, coord: 1 })).toEqual([
                 { refName: 'chr1', start: 103, end: 104 },
                 { refName: 'chr1', start: 200, end: 202 },
@@ -235,7 +270,7 @@ describe('msaCoordToGenomeCoord', () => {
     // MAF region tests
     describe('mafRegion', () => {
         test('returns genome position for mafRegion mapping', () => {
-            const model = {
+            const model = coordModel({
                 querySeqName: 'hg38.chr1',
                 transcriptToMsaMap: undefined,
                 mafRegion: {
@@ -245,7 +280,7 @@ describe('msaCoordToGenomeCoord', () => {
                     assemblyName: 'hg38',
                 },
                 rows: [['hg38.chr1', 'ACGTACGTAC']],
-            };
+            });
             // Position 0 should map to genome 1000
             const result = msaCoordToGenomeCoord({ model, coord: 0 });
             expect(result).toEqual({
@@ -262,7 +297,7 @@ describe('msaCoordToGenomeCoord', () => {
             });
         });
         test('handles gaps in mafRegion sequence', () => {
-            const model = {
+            const model = coordModel({
                 querySeqName: 'hg38.chr1',
                 transcriptToMsaMap: undefined,
                 mafRegion: {
@@ -274,7 +309,7 @@ describe('msaCoordToGenomeCoord', () => {
                 rows: [['hg38.chr1', 'AC--GTAC']],
                 // Gapped positions: 0  1  2  3  4  5  6  7
                 // Ungapped:         0  1        2  3  4  5
-            };
+            });
             // Position 2 is a gap, should return undefined
             const result = msaCoordToGenomeCoord({ model, coord: 2 });
             expect(result).toBeUndefined();
@@ -287,7 +322,7 @@ describe('msaCoordToGenomeCoord', () => {
             });
         });
         test('returns undefined when position exceeds mafRegion end', () => {
-            const model = {
+            const model = coordModel({
                 querySeqName: 'hg38.chr1',
                 transcriptToMsaMap: undefined,
                 mafRegion: {
@@ -297,13 +332,13 @@ describe('msaCoordToGenomeCoord', () => {
                     assemblyName: 'hg38',
                 },
                 rows: [['hg38.chr1', 'ACGTACGTAC']], // 10 chars but region is only 5bp
-            };
+            });
             // Position 8 would be ungapped 8 = genome 1008, but region ends at 1005
             const result = msaCoordToGenomeCoord({ model, coord: 8 });
             expect(result).toBeUndefined();
         });
         test('mafRegion takes precedence over transcriptToMsaMap', () => {
-            const model = {
+            const model = coordModel({
                 querySeqName: 'hg38.chr1',
                 transcriptToMsaMap: {
                     refName: 'chr2',
@@ -316,7 +351,7 @@ describe('msaCoordToGenomeCoord', () => {
                     assemblyName: 'hg38',
                 },
                 rows: [['hg38.chr1', 'ACGTACGTAC']],
-            };
+            });
             // Should use mafRegion, not transcriptToMsaMap
             const result = msaCoordToGenomeCoord({ model, coord: 0 });
             expect(result).toEqual({
@@ -327,3 +362,69 @@ describe('msaCoordToGenomeCoord', () => {
         });
     });
 });
+// mouseCol and mouseClickCol are VISIBLE columns, and react-msaview hides
+// columns as soon as a clade collapses or allowedGappyness drops below 100 --
+// which `hideGaps` leaves on by default. Counting residues along the raw gapped
+// row instead landed every hover and click some codons off.
+describe('columns react-msaview is hiding', () => {
+    test('a visible column past a hidden one maps to the residue on screen', () => {
+        const model = coordModel({
+            querySeqName: 'QUERY',
+            transcriptToMsaMap: {
+                refName: 'chr1',
+                p2gCodon: forwardCodons(4),
+            },
+            rows: [['QUERY', 'M-KA']],
+            blanks: [1],
+        });
+        expect(msaCoordToGenomeCoord({ model, coord: 1 })).toEqual({
+            refName: 'chr1',
+            start: 103,
+            end: 106,
+        });
+        expect(msaCoordToGenomeCoord({ model, coord: 2 })).toEqual({
+            refName: 'chr1',
+            start: 106,
+            end: 109,
+        });
+    });
+    test('a MAF row shifts by the hidden columns too', () => {
+        const model = coordModel({
+            querySeqName: 'hg38.chr1',
+            mafRegion: {
+                refName: 'chr1',
+                start: 1000,
+                end: 1008,
+                assemblyName: 'hg38',
+            },
+            rows: [['hg38.chr1', 'AC--GTAC']],
+            blanks: [2, 3],
+        });
+        expect(msaCoordToGenomeCoord({ model, coord: 2 })).toEqual({
+            refName: 'chr1',
+            start: 1002,
+            end: 1003,
+        });
+    });
+    // the fixture above says what blanks mean; this says react-msaview agrees,
+    // so a change to how it hides columns fails here rather than in the browser
+    test('against the real react-msaview model', () => {
+        const model = MSAModelF().create({
+            type: 'MsaView',
+            data: { msa: '>QUERY\nM-KA\n>B\nMWKA\n>C\nM-KA\n' },
+            allowedGappyness: 50,
+        });
+        expect(model.blanks).toEqual([1]);
+        expect(model.numColumns).toBe(3);
+        const fromView = {
+            querySeqName: 'QUERY',
+            transcriptToMsaMap: { refName: 'chr1', p2gCodon: forwardCodons(4) },
+            visibleColToSeqPos: (rowName, visibleCol) => model.visibleColToSeqPos(rowName, visibleCol),
+        };
+        expect(msaCoordToGenomeCoord({ model: fromView, coord: 1 })).toEqual({
+            refName: 'chr1',
+            start: 103,
+            end: 106,
+        });
+    });
+});

package/dist/MsaViewPanel/msaDataStore.d.ts

@@ -1,12 +1,16 @@
-export declare function generateDataStoreId(): string;
-export declare function storeMsaData(id: string, data: {
+/** the documents a view keeps in IndexedDB rather than in its session snapshot */
+export interface MsaDataPayload {
     msa?: string;
     tree?: string;
     treeMetadata?: string;
-}): Promise<boolean>;
+}
+export declare function generateDataStoreId(): string;
+export declare function storeMsaData(id: string, data: MsaDataPayload): Promise<boolean>;
 export declare function retrieveMsaData(id: string): Promise<{
     msa: string | undefined;
     tree: string | undefined;
     treeMetadata: string | undefined;
 } | undefined>;
+/** drop one view's row, for a reset that just orphaned it */
+export declare function deleteMsaData(id: string): Promise<void>;
 export declare function cleanupOldData(maxAgeMs?: number): Promise<number>;

package/dist/MsaViewPanel/msaDataStore.js

@@ -33,20 +33,39 @@ export async function retrieveMsaData(id) {
     try {
         const db = await getDB();
         const result = await db.get(STORE_NAME, id);
-        if (result) {
-            return {
-                msa: result.msa,
-                tree: result.tree,
-                treeMetadata: result.treeMetadata,
-            };
+        if (!result) {
+            return undefined;
         }
-        return undefined;
+        // reading counts as use, which is what makes cleanupOldData's policy
+        // "unused for 7 days" rather than "written 7 days ago" -- a session opened
+        // every day used to lose its alignment on the eighth
+        try {
+            await db.put(STORE_NAME, { ...result, timestamp: Date.now() });
+        }
+        catch (e) {
+            console.warn('Failed to refresh MSA data timestamp:', e);
+        }
+        return {
+            msa: result.msa,
+            tree: result.tree,
+            treeMetadata: result.treeMetadata,
+        };
     }
     catch (e) {
         console.warn('Failed to retrieve MSA data:', e);
         return undefined;
     }
 }
+/** drop one view's row, for a reset that just orphaned it */
+export async function deleteMsaData(id) {
+    try {
+        const db = await getDB();
+        await db.delete(STORE_NAME, id);
+    }
+    catch (e) {
+        console.warn('Failed to delete MSA data:', e);
+    }
+}
 export async function cleanupOldData(maxAgeMs = 7 * 24 * 60 * 60 * 1000) {
     try {
         const db = await getDB();

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

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

package/dist/MsaViewPanel/msaDataStore.test.js

@@ -0,0 +1,44 @@
+import { beforeEach, expect, test, vi } from 'vitest';
+import { retrieveMsaData } from './msaDataStore';
+// An in-memory stand-in for the one object store this module opens, with a
+// switch for the write half so a browser that refuses writes can be played back.
+const { rows, state } = vi.hoisted(() => ({
+    rows: new Map(),
+    state: { putFails: false },
+}));
+vi.mock('../utils/idb', () => ({
+    createDbOpener: () => () => Promise.resolve({
+        get: (_store, id) => Promise.resolve(rows.get(id)),
+        put: (_store, value) => {
+            if (state.putFails) {
+                return Promise.reject(new Error('QuotaExceededError'));
+            }
+            rows.set(value.id, value);
+            return Promise.resolve(value.id);
+        },
+    }),
+}));
+beforeEach(() => {
+    rows.clear();
+    state.putFails = false;
+});
+// cleanupOldData deletes by timestamp, so without this a session opened every
+// single day still lost its alignment on the eighth
+test('reading a row refreshes its timestamp, making the expiry "unused for 7 days"', async () => {
+    rows.set('msa-1', { id: 'msa-1', msa: '>a\nMK', timestamp: 1000 });
+    const before = Date.now();
+    expect((await retrieveMsaData('msa-1'))?.msa).toBe('>a\nMK');
+    expect(rows.get('msa-1').timestamp).toBeGreaterThanOrEqual(before);
+});
+test('a row that is no longer there reads as undefined and writes nothing', async () => {
+    expect(await retrieveMsaData('msa-gone')).toBeUndefined();
+    expect(rows.size).toBe(0);
+});
+// the refresh is housekeeping; failing it must not turn a readable alignment
+// into a missing one, which is what the caller reports as expired
+test('a refresh that fails still hands back the data it read', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => { });
+    rows.set('msa-1', { id: 'msa-1', msa: '>a\nMK', timestamp: 1000 });
+    state.putFails = true;
+    expect((await retrieveMsaData('msa-1'))?.msa).toBe('>a\nMK');
+});

package/dist/MsaViewPanel/observeProteinHighlights.test.js

@@ -14,10 +14,11 @@ const CONNECTED = 'lgv-1';
  * column equals the genome coordinate that produced it and the test reads as
  * "these genome coords lit these columns".
  */
-function makeModel({ highlightColumns } = {}) {
+function makeModel({ highlightColumns, querySeqOffset = 0, } = {}) {
     const calls = [];
     const model = {
         querySeqName: 'query',
+        querySeqOffset,
         rows: [['query', 'MKVLTAEEK']],
         connectedViewId: CONNECTED,
         // g2p is indexed by genome coord; identity keeps the arithmetic out of the way
@@ -26,8 +27,8 @@ function makeModel({ highlightColumns } = {}) {
         },
         highlightColumns,
         highlightedColumns: undefined,
-        seqPosToGlobalCol: (_name, pos) => pos,
-        globalColToVisibleCol: (col) => col,
+        seqPosToVisibleCol: (_name, pos) => pos,
+        visibleColToSeqPos: (_name, col) => col,
         setHighlightedColumns: (cols) => {
             calls.push(cols);
             model.highlightedColumns = cols;
@@ -69,6 +70,22 @@ describe('the hover channel', () => {
         run();
         expect(calls).toEqual([[10, 11, 12]]);
     });
+    // a query row trimmed to what BLAST aligned starts partway into the protein,
+    // so the structure's residues sit that many columns to the left
+    test('a trimmed query row shifts the lit columns by its offset', () => {
+        const { model, calls } = makeModel({ querySeqOffset: 4 });
+        const run = observeProteinHighlights(model);
+        session({ hover: [{ start: 10, end: 13 }] });
+        run();
+        expect(calls).toEqual([[6, 7, 8]]);
+    });
+    test('a residue before a trimmed row lights nothing', () => {
+        const { model, calls } = makeModel({ querySeqOffset: 20 });
+        const run = observeProteinHighlights(model);
+        session({ hover: [{ start: 10, end: 13 }] });
+        run();
+        expect(calls).toEqual([]);
+    });
     test('releasing the hover clears the highlight', () => {
         const { model, calls } = makeModel();
         const run = observeProteinHighlights(model);

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

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

package/dist/MsaViewPanel/processInit.test.js

@@ -0,0 +1,72 @@
+import { beforeEach, expect, test, vi } from 'vitest';
+import { processInit, storeDataToIndexedDB } from './afterCreateAutoruns';
+import { fetchIndexedMsa } from './fetchIndexedMsa';
+vi.mock('./fetchIndexedMsa', () => ({ fetchIndexedMsa: vi.fn() }));
+vi.mock('./msaDataStore', () => ({
+    cleanupOldData: vi.fn(),
+    generateDataStoreId: vi.fn(() => 'generated'),
+    retrieveMsaData: vi.fn(),
+    storeMsaData: vi.fn(async () => true),
+}));
+const INDEXED = {
+    msaIndexedLocation: { uri: 'http://example.com/msa.fa.gz' },
+    msaName: 'ENST00000288602',
+};
+function makeModel(over = {}) {
+    const model = {
+        init: INDEXED,
+        data: {},
+        rows: [],
+        msaFilehandle: undefined,
+        treeFilehandle: undefined,
+        isStoringData: false,
+        lastStoredData: undefined,
+        setError: vi.fn(),
+        setUniprotId: vi.fn(),
+        setQuerySeqName: vi.fn(),
+        setMSAFilehandle: vi.fn(),
+        setDataStoreId: vi.fn(),
+        setIsStoringData: vi.fn(),
+        setLastStoredData: vi.fn(),
+        setInit: vi.fn(),
+        setMSA(arg) {
+            model.data.msa = arg;
+        },
+        ...over,
+    };
+    return model;
+}
+const settle = () => new Promise(res => setTimeout(res, 0));
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+// react-msaview drops an inline alignment over 50kb from the snapshot and an
+// indexed block has no filehandle to reload from, so clearing init left a
+// shared session saying the alignment had expired
+test('an indexed init is kept, so the block can be refetched', async () => {
+    vi.mocked(fetchIndexedMsa).mockResolvedValue('>a\nMK');
+    const model = makeModel();
+    processInit(model);
+    await settle();
+    expect(model.data.msa).toBe('>a\nMK');
+    expect(model.setInit).not.toHaveBeenCalled();
+});
+test('an alignment already in hand is not refetched', async () => {
+    const model = makeModel({ data: { msa: '>a\nMK' } });
+    processInit(model);
+    await settle();
+    expect(fetchIndexedMsa).not.toHaveBeenCalled();
+});
+test('a url init is still resolved once and cleared', async () => {
+    const model = makeModel({ init: { msaUrl: 'http://example.com/msa.fa' } });
+    processInit(model);
+    await settle();
+    expect(model.setMSAFilehandle).toHaveBeenCalled();
+    expect(model.setInit).toHaveBeenCalledWith(undefined);
+});
+test('an indexed view writes no IndexedDB row', async () => {
+    const model = makeModel({ rows: [['a', 'MK']], data: { msa: '>a\nMK' } });
+    storeDataToIndexedDB(model);
+    await settle();
+    expect(model.setDataStoreId).not.toHaveBeenCalled();
+});

package/dist/MsaViewPanel/resolveConnectedTranscript.d.ts

@@ -0,0 +1,9 @@
+import type { JBrowsePluginMsaViewModel } from './model';
+/**
+ * Resolve `connectedTranscript` into `connectedFeature` once the connected
+ * genome view has its assembly, regions and tracks, then hand the translation
+ * to whichever launch is waiting for a query. Left in place on failure so the
+ * error stays attributable; the autorun's tracked reads are the view's
+ * readiness, so nothing refires until that changes.
+ */
+export declare function resolveConnectedTranscriptIfNeeded(self: JBrowsePluginMsaViewModel): void;