jbrowse-plugin-msaview 3.5.0 → 3.7.0

package/dist/MsaViewPanel/runLaunch.js

@@ -1,4 +1,5 @@
 import { getSession } from '@jbrowse/core/util';
+import { untracked } from 'mobx';
 import { isAbortError } from '../utils/fetch';
 /**
  * The in-browser aligner and a search hand back rows and no tree;
@@ -33,11 +34,21 @@ function buildTree(self) {
  * 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.
+ * is here: the Cancel button, and the disposer `afterCreate` registers. A launch
+ * already holding it is aborted first, so a re-fired autorun replaces the
+ * attempt rather than orphaning one that nothing can cancel.
+ *
+ * Runs untracked: it is called from the launch autoruns, and whatever the
+ * launch body reads before its first await would otherwise become a reason to
+ * launch again.
  */
-export function runLaunch({ self, message, launch, onLaunched, }) {
+export function runLaunch(args) {
+    untracked(() => {
+        startLaunch(args);
+    });
+}
+function startLaunch({ self, message, launch, onLaunched, }) {
+    self.launchController?.abort();
     const controller = new AbortController();
     const { signal } = controller;
     self.setLaunchController(controller);

package/dist/MsaViewPanel/runLaunch.test.js

@@ -112,6 +112,22 @@ describe('a launch that is abandoned', () => {
         expect(writes.some(w => w.startsWith('setError:Aborted'))).toBe(false);
     });
 });
+describe('a launch started while another holds the controller', () => {
+    test('aborts the first, so nothing is left polling that Cancel cannot reach', async () => {
+        const { model } = makeModel();
+        const signals = [];
+        const launch = (scope) => {
+            signals.push(scope.signal);
+            return new Promise(() => { });
+        };
+        runLaunch({ self: model, message: 'a', onLaunched: () => { }, launch });
+        runLaunch({ self: model, message: 'b', onLaunched: () => { }, launch });
+        await settle();
+        expect(signals.map(s => s.aborted)).toEqual([true, false]);
+        model.launchController.abort();
+        expect(signals[1].aborted).toBe(true);
+    });
+});
 describe('a launch that fails', () => {
     test('records the error and stops the spinner', async () => {
         vi.spyOn(console, 'error').mockImplementation(() => { });

package/dist/MsaViewPanel/storedData.test.js

@@ -49,6 +49,9 @@ function makeModel(over = {}) {
         setTreeMetadata(arg) {
             model.data.treeMetadata = arg;
         },
+        setGFF(arg) {
+            model.data.gff = arg;
+        },
         ...over,
     };
     return model;
@@ -82,6 +85,14 @@ describe('restoring a view from IndexedDB', () => {
         storeDataToIndexedDB(model);
         expect(mockStore).not.toHaveBeenCalled();
     });
+    // react-msaview drops a GFF over 50kB from the snapshot too
+    test('a stored GFF comes back with the alignment', async () => {
+        mockRetrieve.mockResolvedValue({ msa: MSA, gff: 'a\t.\tdomain\t1\t2' });
+        const model = makeModel({ dataStoreId: 'msa-1' });
+        loadStoredData(model);
+        await settle();
+        expect(model.data.gff).toBe('a\t.\tdomain\t1\t2');
+    });
     // 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 () => {
@@ -95,6 +106,26 @@ describe('restoring a view from IndexedDB', () => {
         // to import form" lands straight back on this error
         expect(model.dataStoreId).toBeUndefined();
     });
+    // the request that built the alignment is kept past the launch, so the view
+    // can offer to run it again instead of sending the user back to the gene
+    test('a row that is gone points at Retry when the search is still known', async () => {
+        mockRetrieve.mockResolvedValue(undefined);
+        const model = makeModel({
+            dataStoreId: 'msa-1',
+            blastParams: { blastDatabase: 'uniprotkb_swissprot' },
+        });
+        loadStoredData(model);
+        await settle();
+        expect(model.error.message).toMatch(/Retry/);
+        expect(model.blastParams).toBeDefined();
+    });
+    test('a row that is gone with no search behind it says to relaunch', async () => {
+        mockRetrieve.mockResolvedValue(undefined);
+        const model = makeModel({ dataStoreId: 'msa-1' });
+        loadStoredData(model);
+        await settle();
+        expect(model.error.message).toMatch(/Relaunch it from the gene/);
+    });
 });
 describe('keeping IndexedDB up to date', () => {
     test('the first alignment is written under a fresh id', async () => {
@@ -127,6 +158,18 @@ describe('keeping IndexedDB up to date', () => {
         });
         expect(model.dataStoreId).toBe('msa-1');
     });
+    test('a GFF loaded after the first write updates the row', async () => {
+        const model = makeModel({
+            dataStoreId: 'msa-1',
+            rows: [['a', 'MK']],
+            data: { msa: MSA },
+            lastStoredData: { msa: MSA },
+        });
+        model.data.gff = 'a\t.\tdomain\t1\t2';
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(mockStore).toHaveBeenCalledWith('msa-1', expect.objectContaining({ gff: 'a\t.\tdomain\t1\t2' }));
+    });
     // 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

package/dist/MsaViewPanel/syncGenomeHoverToMsaColumn.test.js

@@ -15,32 +15,40 @@ const mafRegion = {
     assemblyName: 'hg38',
 };
 // A model wired through the real genomeToMSA path: a connected genome view
-// over a maf region, with seqPosToVisibleCol as identity so the asserted
+// over a maf region, with the column converters as identity so the asserted
 // column equals the ungapped offset into the region.
 function makeModel() {
     const calls = [];
     const model = {
         querySeqName: 'hg38.chr1',
-        rows: [['hg38.chr1', 'ACGTACGTAC']],
+        rowMap: new Map([['hg38.chr1', 'ACGTACGTAC']]),
         transcriptToMsaMap: undefined,
         mafRegion,
         connectedView: { initialized: true, assemblyNames: ['hg38'] },
         seqPosToVisibleCol: (_name, pos) => pos,
+        visibleColToSeqPos: (_name, col) => col,
         setMousePos: (col) => {
             calls.push(col);
         },
     };
     return { model, calls };
 }
-function hoverGenome(coord) {
+// this config spells the refName the same way on both sides, so the assembly
+// hands every name straight back
+const assemblyManager = {
+    get: () => ({ getCanonicalRefName: (refName) => refName }),
+};
+function mockSession(hovered) {
     mockGetSession.mockReturnValue({
-        hovered: { hoverFeature: {}, hoverPosition: { coord, refName: 'chr1' } },
+        assemblyManager,
+        hovered,
     });
 }
+function hoverGenome(coord) {
+    mockSession({ hoverFeature: {}, hoverPosition: { coord, refName: 'chr1' } });
+}
 function clearGenomeHover() {
-    mockGetSession.mockReturnValue({
-        hovered: null,
-    });
+    mockSession(null);
 }
 describe('syncGenomeHoverToMsaColumn (real genomeToMSA mapping)', () => {
     beforeEach(() => {

package/dist/MsaViewPanel/util.d.ts

@@ -1,19 +1,14 @@
 /**
- * Whether `querySeqName` names a row this alignment actually has.
+ * Whether `querySeqName` names a row this alignment actually has. The name
+ * defaults to `QUERY`, which an uploaded alignment has no reason to carry, so
+ * the genome and structure hovers ask this before mapping anything.
  *
- * 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.
+ * `rowMap`, not `rows`: `rows` is what is on screen, and a query row folded
+ * into a collapsed clade is still in the alignment, still has its columns, and
+ * still maps.
  */
 export declare function hasQueryRow(model: {
-    rows: string[][];
+    rowMap: ReadonlyMap<string, string>;
     querySeqName: string;
 }): boolean;
 /**
@@ -35,23 +30,28 @@ interface LiveFeature {
 export declare function transcriptFields(transcript?: TranscriptRef): Record<string, unknown>;
 /** what a transcript is called, preferring its name over its id */
 export declare function transcriptName(transcript?: TranscriptRef): string | undefined;
-export interface QueryRowModel {
+interface QueryRowColumns {
     querySeqName: string;
-    querySeqOffset: number;
     seqPosToVisibleCol: (rowName: string, seqPos: number) => number | undefined;
     visibleColToSeqPos: (rowName: string, visibleCol: number) => number | undefined;
 }
+export interface QueryRowModel extends QueryRowColumns {
+    querySeqOffset: number;
+}
 /**
- * The visible column showing residue `proteinPos` (0-based) of the transcript,
- * or undefined when the query row does not carry that residue or react-msaview
- * is hiding its column.
+ * The visible column showing residue `seqPos` (0-based) of the query row, or
+ * undefined when the row does not carry that residue or react-msaview is
+ * hiding its column.
  *
- * Two things separate the transcript from the row. `querySeqOffset` is the
- * trimming — a pasted BLAST alignment carries the aligned region, not the whole
- * protein. And the row can simply stop short: react-msaview answers one column
- * past the end for a position it does not have, which would light the last
- * column for every residue beyond the row, so the round trip back through
- * visibleColToSeqPos is what rejects those.
+ * react-msaview answers one column past the end for a position the row does not
+ * have, which would light the last column for every residue beyond the row, so
+ * the round trip back through visibleColToSeqPos is what rejects those.
+ */
+export declare function querySeqPosToVisibleCol(model: QueryRowColumns, seqPos: number): number | undefined;
+/**
+ * The visible column showing residue `proteinPos` (0-based) of the transcript.
+ * `querySeqOffset` is what separates the two: a pasted BLAST alignment carries
+ * the aligned region, not the whole protein.
  */
 export declare function transcriptPosToVisibleCol(model: QueryRowModel, proteinPos: number): number | undefined;
 export declare function hasHoverPosition(hovered: unknown): hovered is {

package/dist/MsaViewPanel/util.js

@@ -1,19 +1,14 @@
 /**
- * Whether `querySeqName` names a row this alignment actually has.
+ * Whether `querySeqName` names a row this alignment actually has. The name
+ * defaults to `QUERY`, which an uploaded alignment has no reason to carry, so
+ * the genome and structure hovers ask this before mapping anything.
  *
- * 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.
+ * `rowMap`, not `rows`: `rows` is what is on screen, and a query row folded
+ * into a collapsed clade is still in the alignment, still has its columns, and
+ * still maps.
  */
 export function hasQueryRow(model) {
-    return model.rows.some(r => r[0] === model.querySeqName);
+    return model.rowMap.has(model.querySeqName);
 }
 /**
  * Read the transcript's fields whichever shape it arrived in: a caller inside
@@ -36,20 +31,16 @@ export function transcriptName(transcript) {
     return str(fields.name) ?? str(fields.id);
 }
 /**
- * The visible column showing residue `proteinPos` (0-based) of the transcript,
- * or undefined when the query row does not carry that residue or react-msaview
- * is hiding its column.
+ * The visible column showing residue `seqPos` (0-based) of the query row, or
+ * undefined when the row does not carry that residue or react-msaview is
+ * hiding its column.
  *
- * Two things separate the transcript from the row. `querySeqOffset` is the
- * trimming — a pasted BLAST alignment carries the aligned region, not the whole
- * protein. And the row can simply stop short: react-msaview answers one column
- * past the end for a position it does not have, which would light the last
- * column for every residue beyond the row, so the round trip back through
- * visibleColToSeqPos is what rejects those.
+ * react-msaview answers one column past the end for a position the row does not
+ * have, which would light the last column for every residue beyond the row, so
+ * the round trip back through visibleColToSeqPos is what rejects those.
  */
-export function transcriptPosToVisibleCol(model, proteinPos) {
-    const { querySeqName, querySeqOffset } = model;
-    const seqPos = proteinPos - querySeqOffset;
+export function querySeqPosToVisibleCol(model, seqPos) {
+    const { querySeqName } = model;
     if (seqPos < 0) {
         return undefined;
     }
@@ -59,6 +50,14 @@ export function transcriptPosToVisibleCol(model, proteinPos) {
         ? col
         : undefined;
 }
+/**
+ * The visible column showing residue `proteinPos` (0-based) of the transcript.
+ * `querySeqOffset` is what separates the two: a pasted BLAST alignment carries
+ * the aligned region, not the whole protein.
+ */
+export function transcriptPosToVisibleCol(model, proteinPos) {
+    return querySeqPosToVisibleCol(model, proteinPos - model.querySeqOffset);
+}
 export function hasHoverPosition(hovered) {
     return (!!hovered &&
         typeof hovered === 'object' &&

package/dist/index.d.ts

@@ -7,20 +7,20 @@ export default class MsaViewPlugin extends Plugin {
     configure(pluginManager: PluginManager): void;
     rootConfigurationSchema: (pluginManager: PluginManager) => {
         msa: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-            datasets: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-                datasetId: {
-                    type: string;
-                    defaultValue: string;
+            readonly datasets: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+                readonly datasetId: {
+                    readonly type: "string";
+                    readonly defaultValue: "";
                 };
-                description: {
-                    type: string;
-                    defaultValue: string;
+                readonly description: {
+                    readonly type: "string";
+                    readonly defaultValue: "";
                 };
-                name: {
-                    type: string;
-                    defaultValue: string;
+                readonly name: {
+                    readonly type: "string";
+                    readonly defaultValue: "";
                 };
-                adapter: import("@jbrowse/mobx-state-tree").IAnyModelType;
+                readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
             }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>>>;
         }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
     };

package/dist/index.js

@@ -45,16 +45,23 @@ export default class MsaViewPlugin extends Plugin {
         BgzipFastaMsaAdapterF(pluginManager);
     }
     configure(pluginManager) {
-        if (isAbstractMenuManager(pluginManager.rootModel)) {
-            pluginManager.rootModel.appendToSubMenu(['Add'], {
-                label: 'Multiple sequence alignment view',
-                icon: GridOn,
-                onClick: (session) => {
-                    // stacked, by default: nothing was launched from, so there is no
-                    // connected view for it to sit beside
-                    launchMsaView(session, {});
-                },
-            });
+        // a throw here error-pages the whole app, and a menu entry is not worth a
+        // session: every released host's File menu already throws on append
+        try {
+            if (isAbstractMenuManager(pluginManager.rootModel)) {
+                pluginManager.rootModel.appendToSubMenu(['Add'], {
+                    label: 'Multiple sequence alignment view',
+                    icon: GridOn,
+                    onClick: (session) => {
+                        // stacked, by default: nothing was launched from, so there is no
+                        // connected view for it to sit beside
+                        launchMsaView(session, {});
+                    },
+                });
+            }
+        }
+        catch (e) {
+            console.error('jbrowse-plugin-msaview: could not add the Add menu item', e);
         }
     }
 }