jbrowse-plugin-msaview 3.3.0 → 3.4.1

package/dist/MsaViewPanel/runLaunch.js

@@ -0,0 +1,65 @@
+import { isAbortError } from '../utils/fetch';
+/**
+ * Run one launch attempt, owning the AbortController that ties it to the view.
+ *
+ * The controller lives on the model because two things end a launch and neither
+ * is here: the Cancel button, and the disposer `afterCreate` registers. Before
+ * it existed, closing a view mid-BLAST left the poller checking EBI for the
+ * job's lifetime and then writing to a node that was gone.
+ */
+export function runLaunch({ self, message, launch, onLaunched, }) {
+    const controller = new AbortController();
+    const { signal } = controller;
+    self.setLaunchController(controller);
+    const act = (fn) => {
+        if (!signal.aborted) {
+            fn();
+        }
+    };
+    const scope = {
+        signal,
+        act,
+        onProgress: arg => {
+            act(() => {
+                self.setProgress(arg);
+            });
+        },
+        onRid: arg => {
+            act(() => {
+                self.setRid(arg);
+            });
+        },
+    };
+    void (async () => {
+        try {
+            act(() => {
+                self.setProgress(message);
+                self.setError(undefined);
+            });
+            const data = await launch(scope);
+            act(() => {
+                self.setData(data);
+                onLaunched();
+            });
+        }
+        catch (e) {
+            // a cancel is not a failure: drawing the error panel for one would tell
+            // the user their launch broke when they are the one who stopped it
+            if (!isAbortError(e)) {
+                act(() => {
+                    self.setError(e);
+                });
+                console.error(e);
+            }
+        }
+        finally {
+            act(() => {
+                self.setProgress('');
+                // only if a later launch has not already claimed the slot
+                if (self.launchController === controller) {
+                    self.setLaunchController(undefined);
+                }
+            });
+        }
+    })();
+}

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

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

package/dist/MsaViewPanel/runLaunch.test.js

@@ -0,0 +1,129 @@
+import { describe, expect, test, vi } from 'vitest';
+import { runLaunch } from './runLaunch';
+/**
+ * A model that records every write, so "no model actions after abort" is
+ * assertable rather than inferred. The real thing throws on a destroyed node;
+ * here a write that should not have happened simply shows up in the log.
+ */
+function makeModel() {
+    const writes = [];
+    const model = {
+        launchController: undefined,
+        setLaunchController(arg) {
+            model.launchController = arg;
+            writes.push(`setLaunchController:${arg ? 'set' : 'cleared'}`);
+        },
+        setProgress: (arg) => writes.push(`setProgress:${arg}`),
+        setError: (e) => writes.push(`setError:${e instanceof Error ? e.message : String(e)}`),
+        setRid: (arg) => writes.push(`setRid:${arg}`),
+        setData: () => writes.push('setData'),
+    };
+    return { model, writes };
+}
+const DATA = { msa: '>a\nMK', tree: '(a);', treeMetadata: '{}' };
+/** run the microtask queue out so the launch's async body has finished */
+const settle = () => new Promise(res => setTimeout(res, 0));
+describe('a launch that finishes', () => {
+    test('applies its data, clears its params and releases the controller', async () => {
+        const { model, writes } = makeModel();
+        const onLaunched = vi.fn();
+        runLaunch({
+            self: model,
+            message: 'Submitting query',
+            onLaunched,
+            launch: async (scope) => {
+                scope.onRid('ncbiblast-1');
+                scope.onProgress('Re-checking BLAST status in... 7');
+                return DATA;
+            },
+        });
+        await settle();
+        expect(writes).toEqual([
+            'setLaunchController:set',
+            'setProgress:Submitting query',
+            'setError:undefined',
+            'setRid:ncbiblast-1',
+            'setProgress:Re-checking BLAST status in... 7',
+            'setData',
+            'setProgress:',
+            'setLaunchController:cleared',
+        ]);
+        expect(onLaunched).toHaveBeenCalled();
+    });
+});
+// The failure this file exists for: closing a view mid-BLAST left the poller
+// running for the job's lifetime and then writing to a destroyed
+// mobx-state-tree node, whose throw surfaced as an unhandled rejection.
+describe('a launch that is abandoned', () => {
+    async function abandonMidFlight(reject) {
+        const { model, writes } = makeModel();
+        let released;
+        const held = new Promise(res => {
+            released = res;
+        });
+        let captured;
+        runLaunch({
+            self: model,
+            message: 'Submitting query',
+            onLaunched: () => {
+                throw new Error('a cancelled launch must not report success');
+            },
+            launch: async (scope) => {
+                captured = scope;
+                await held;
+                // what the network hop does once its signal is aborted: either it
+                // rejects with an AbortError, or it had already resolved and returns
+                if (reject) {
+                    throw new DOMException('Aborted', 'AbortError');
+                }
+                return DATA;
+            },
+        });
+        await settle();
+        const before = writes.length;
+        model.launchController.abort();
+        // everything the launch would still try to do after the abort
+        captured.onProgress('Re-checking BLAST status in... 3');
+        captured.onRid('ncbiblast-2');
+        captured.act(() => {
+            throw new Error('act must not run its callback after an abort');
+        });
+        released();
+        await settle();
+        return writes.slice(before);
+    }
+    test('nothing is written to the model once the abort lands', async () => {
+        expect(await abandonMidFlight(true)).toEqual([]);
+    });
+    test('a launch that resolved anyway still applies nothing', async () => {
+        expect(await abandonMidFlight(false)).toEqual([]);
+    });
+    test('an abort renders no error, so a cancel does not read as a failure', async () => {
+        const { model, writes } = makeModel();
+        runLaunch({
+            self: model,
+            message: 'Submitting query',
+            onLaunched: () => { },
+            launch: () => Promise.reject(new DOMException('Aborted', 'AbortError')),
+        });
+        await settle();
+        expect(writes.some(w => w.startsWith('setError:Aborted'))).toBe(false);
+    });
+});
+describe('a launch that fails', () => {
+    test('records the error and stops the spinner', async () => {
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+        const { model, writes } = makeModel();
+        runLaunch({
+            self: model,
+            message: 'Resolving orthologs',
+            onLaunched: () => {
+                throw new Error('a failed launch must not report success');
+            },
+            launch: () => Promise.reject(new Error('Only 1 ortholog(s) found')),
+        });
+        await settle();
+        expect(writes).toContain('setError:Only 1 ortholog(s) found');
+        expect(writes.at(-2)).toBe('setProgress:');
+    });
+});

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

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

package/dist/MsaViewPanel/storedData.test.js

@@ -0,0 +1,160 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { loadStoredData, storeDataToIndexedDB } from './afterCreateAutoruns';
+import { generateDataStoreId, retrieveMsaData, storeMsaData, } from './msaDataStore';
+// IndexedDB itself is msaDataStore.test.ts's subject; what is under test here is
+// which writes these two autoruns decide to make.
+vi.mock('./msaDataStore', () => ({
+    cleanupOldData: vi.fn(),
+    generateDataStoreId: vi.fn(),
+    retrieveMsaData: vi.fn(),
+    storeMsaData: vi.fn(),
+}));
+const mockRetrieve = vi.mocked(retrieveMsaData);
+const mockStore = vi.mocked(storeMsaData);
+const mockGenerateId = vi.mocked(generateDataStoreId);
+const MSA = '>a\nMK';
+const NEW_ID = 'msa-generated';
+function makeModel(over = {}) {
+    const model = {
+        dataStoreId: undefined,
+        rows: [],
+        data: {},
+        msaFilehandle: undefined,
+        treeFilehandle: undefined,
+        isStoringData: false,
+        lastStoredData: undefined,
+        loadingStoredData: false,
+        error: undefined,
+        setDataStoreId(arg) {
+            model.dataStoreId = arg;
+        },
+        setIsStoringData(arg) {
+            model.isStoringData = arg;
+        },
+        setLastStoredData(arg) {
+            model.lastStoredData = arg;
+        },
+        setLoadingStoredData(arg) {
+            model.loadingStoredData = arg;
+        },
+        setError(arg) {
+            model.error = arg;
+        },
+        setMSA(arg) {
+            model.data.msa = arg;
+        },
+        setTree(arg) {
+            model.data.tree = arg;
+        },
+        setTreeMetadata(arg) {
+            model.data.treeMetadata = arg;
+        },
+        ...over,
+    };
+    return model;
+}
+const settle = () => new Promise(res => setTimeout(res, 0));
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockGenerateId.mockReturnValue(NEW_ID);
+    mockStore.mockResolvedValue(true);
+});
+describe('restoring a view from IndexedDB', () => {
+    test('a row that is still there is applied and recorded as stored', async () => {
+        mockRetrieve.mockResolvedValue({
+            msa: MSA,
+            tree: '(a);',
+            treeMetadata: '{}',
+        });
+        const model = makeModel({ dataStoreId: 'msa-1' });
+        loadStoredData(model);
+        await settle();
+        expect(model.data.msa).toBe(MSA);
+        expect(model.error).toBeUndefined();
+        // recorded, so the store autorun does not write the restored data straight
+        // back out again
+        expect(model.lastStoredData).toEqual({
+            msa: MSA,
+            tree: '(a);',
+            treeMetadata: '{}',
+        });
+        model.rows = [['a', 'MK']];
+        storeDataToIndexedDB(model);
+        expect(mockStore).not.toHaveBeenCalled();
+    });
+    // the row expires or the user clears site data, and the view used to reopen as
+    // a blank import form with no hint that anything had been lost
+    test('a row that is gone says so, in words that name the policy', async () => {
+        mockRetrieve.mockResolvedValue(undefined);
+        const model = makeModel({ dataStoreId: 'msa-1' });
+        loadStoredData(model);
+        await settle();
+        expect(model.error).toBeInstanceOf(Error);
+        expect(model.error.message).toMatch(/7 days/);
+        // the id names nothing now, so it goes -- otherwise react-msaview's "Return
+        // to import form" lands straight back on this error
+        expect(model.dataStoreId).toBeUndefined();
+    });
+});
+describe('keeping IndexedDB up to date', () => {
+    test('the first alignment is written under a fresh id', async () => {
+        const model = makeModel({ rows: [['a', 'MK']], data: { msa: MSA } });
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(mockStore).toHaveBeenCalledWith(NEW_ID, { msa: MSA });
+        expect(model.dataStoreId).toBe(NEW_ID);
+        expect(model.isStoringData).toBe(false);
+    });
+    // react-msaview's "calculate neighbor-joining tree" replaces data.tree long
+    // after the first write; the row used to keep the alignment's original tree
+    // forever, so a reopened session restored a picture the user had replaced
+    test('an edit after the first write updates the existing row', async () => {
+        const model = makeModel({
+            dataStoreId: 'msa-1',
+            rows: [['a', 'MK']],
+            data: { msa: MSA, tree: '(a);' },
+            lastStoredData: { msa: MSA, tree: '(a);' },
+        });
+        storeDataToIndexedDB(model);
+        expect(mockStore).not.toHaveBeenCalled();
+        model.data.tree = '(a:0.1);';
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(mockStore).toHaveBeenCalledWith('msa-1', {
+            msa: MSA,
+            tree: '(a:0.1);',
+            treeMetadata: undefined,
+        });
+        expect(model.dataStoreId).toBe('msa-1');
+    });
+    // a browser that refuses IndexedDB (private mode) answers every write the same
+    // way, and the autorun reruns on its own isStoringData flag -- so a write that
+    // is not recorded as attempted is a write that retries forever
+    test('a write that fails is not retried on the same data', async () => {
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+        mockStore.mockResolvedValue(false);
+        const model = makeModel({ rows: [['a', 'MK']], data: { msa: MSA } });
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(model.dataStoreId).toBeUndefined();
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(mockStore).toHaveBeenCalledTimes(1);
+    });
+    test('a view reading from a filehandle stores nothing, since the file is the source', () => {
+        storeDataToIndexedDB(makeModel({
+            rows: [['a', 'MK']],
+            data: { msa: MSA },
+            msaFilehandle: { uri: 'msa.fa', locationType: 'UriLocation' },
+        }));
+        expect(mockStore).not.toHaveBeenCalled();
+    });
+    test('a write already in flight is not duplicated', () => {
+        storeDataToIndexedDB(makeModel({
+            rows: [['a', 'MK']],
+            data: { msa: MSA },
+            isStoringData: true,
+        }));
+        expect(mockStore).not.toHaveBeenCalled();
+    });
+});

package/dist/MsaViewPanel/syncGenomeHoverToMsaColumn.test.js

@@ -21,6 +21,7 @@ function makeModel() {
     const calls = [];
     const model = {
         querySeqName: 'hg38.chr1',
+        rows: [['hg38.chr1', 'ACGTACGTAC']],
         transcriptToMsaMap: undefined,
         mafRegion,
         connectedView: { initialized: true, assemblyNames: ['hg38'] },

package/dist/MsaViewPanel/util.d.ts

@@ -1,3 +1,21 @@
+/**
+ * Whether `querySeqName` names a row this alignment actually has.
+ *
+ * react-msaview's `seqPosToGlobalCol` answers 0 for a name it does not know, so
+ * without this every genome position maps to the first column and hovering the
+ * genome — or a connected structure — lights column 0 of an unrelated row. The
+ * name is wrong more often than it looks: it defaults to `QUERY`, which an
+ * uploaded alignment has no reason to carry, and the manual panel leaves it
+ * empty when it cannot match the protein to a row.
+ *
+ * The other direction has no such hole: msaCoordToGenomeRegions needs the query
+ * row's sequence to map a column at all, so a missing row is already nothing
+ * there.
+ */
+export declare function hasQueryRow(model: {
+    rows: string[][];
+    querySeqName: string;
+}): boolean;
 export declare function hasHoverPosition(hovered: unknown): hovered is {
     hoverPosition: {
         coord: number;

package/dist/MsaViewPanel/util.js

@@ -1,3 +1,20 @@
+/**
+ * Whether `querySeqName` names a row this alignment actually has.
+ *
+ * react-msaview's `seqPosToGlobalCol` answers 0 for a name it does not know, so
+ * without this every genome position maps to the first column and hovering the
+ * genome — or a connected structure — lights column 0 of an unrelated row. The
+ * name is wrong more often than it looks: it defaults to `QUERY`, which an
+ * uploaded alignment has no reason to carry, and the manual panel leaves it
+ * empty when it cannot match the protein to a row.
+ *
+ * The other direction has no such hole: msaCoordToGenomeRegions needs the query
+ * row's sequence to map a column at all, so a missing row is already nothing
+ * there.
+ */
+export function hasQueryRow(model) {
+    return model.rows.some(r => r[0] === model.querySeqName);
+}
 export function hasHoverPosition(hovered) {
     return (!!hovered &&
         typeof hovered === 'object' &&