jbrowse-plugin-msaview 3.5.0 → 3.7.0

package/dist/LaunchMsaView/util.js

@@ -2,11 +2,14 @@ import { getContainingView, sum } from '@jbrowse/core/util';
 export function getLinearGenomeView(model) {
     return getContainingView(model);
 }
+function isNonEmptyString(v) {
+    return typeof v === 'string' && v !== '';
+}
 function uniqueDefined(vals) {
-    return [...new Set(vals.filter((v) => !!v))];
+    return [...new Set(vals.filter(isNonEmptyString))];
 }
 function joinDefined(sep, parts) {
-    return parts.filter((p) => !!p).join(sep);
+    return parts.filter(isNonEmptyString).join(sep);
 }
 export function getTranscriptFeatures(feature) {
     // check if we are looking at a 'two-level' or 'three-level' feature by
@@ -67,8 +70,14 @@ export function getSortedTranscriptFeatures(feature) {
     const transcripts = getTranscriptFeatures(feature);
     return transcripts.toSorted((a, b) => getTranscriptLength(b).len - getTranscriptLength(a).len);
 }
+/**
+ * A translation as a query, still one residue per codon: g2p numbers codons,
+ * and the query row is read through it. So the partial first codon (`&`), an
+ * internal stop and an unreadable codon become X, and only what trails the
+ * last whole codon is dropped.
+ */
 export function cleanProteinSequence(seq) {
-    return seq.replaceAll('*', '').replaceAll('&', '');
+    return seq.replace(/[*&]+$/, '').replaceAll(/[*&]/g, 'X');
 }
 export function getGeneIdentifiers(feature) {
     return uniqueDefined([

package/dist/LaunchMsaViewExtensionPoint/index.test.js

@@ -53,6 +53,21 @@ test('searchParams is a source, stored under the name the dialog uses', () => {
 test('a launch naming no source at all is refused', () => {
     expect(() => launch({ connectedViewId: 'lgv1' })).toThrow(/searchParams/);
 });
+test('region and the data-layer keys reach the view as snapshot properties', () => {
+    const region = { row: 'Human', start: 245, end: 249 };
+    const clades = [{ mrca: ['Human', 'Mouse'], tips: 2, mark: 'bracket' }];
+    const snapshot = launch({
+        data: { msa: '>Human\nMEEP' },
+        region,
+        clades,
+        relativeTo: 'Human',
+        gffFilehandle: { uri: 'http://example.com/a.gff' },
+    });
+    expect(snapshot.region).toEqual(region);
+    expect(snapshot.clades).toEqual(clades);
+    expect(snapshot.relativeTo).toBe('Human');
+    expect(snapshot.gffFilehandle).toEqual({ uri: 'http://example.com/a.gff' });
+});
 test('one field set is enough to need init', () => {
     const snapshot = launch({ data: { msa: '>a\nMEEP' }, querySeqName: 'QUERY' });
     expect(snapshot.init).toEqual({

package/dist/MsaViewPanel/afterCreateAutoruns.d.ts

@@ -19,10 +19,12 @@ export declare function loadStoredData(self: JBrowsePluginMsaViewModel): void;
 export declare function storeDataToIndexedDB(self: JBrowsePluginMsaViewModel): void;
 /**
  * Same shape as launchBlastIfNeeded, for the ortholog path: the params ARE the
- * request, and clearing them on success is what marks it done. They are left in
- * place on failure so the error stays attributable to a specific request; the
- * autorun's only tracked read is orthologParams itself, so nothing refires
- * until a new request replaces them.
+ * request, and `launchCompleted` is what marks it done. They are left in place
+ * either way -- on failure so the error stays attributable to a specific
+ * request, and on success because they are the only durable statement of what
+ * the view is, which is what a stored alignment that expired is rebuilt from.
+ * The autorun tracks those two reads alone, so nothing refires until a new
+ * request replaces them or a retry clears the mark.
  */
 export declare function launchOrthologsIfNeeded(self: JBrowsePluginMsaViewModel): void;
 export declare function launchBlastIfNeeded(self: JBrowsePluginMsaViewModel): void;

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -9,7 +9,9 @@ import { cleanupOldData, generateDataStoreId, retrieveMsaData, storeMsaData, } f
 import { runLaunch } from './runLaunch';
 import { getProteinViews } from './structureConnection';
 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. Relaunch the alignment to rebuild it.";
+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.';
 export function loadStoredData(self) {
     const { dataStoreId, rows } = self;
     if (dataStoreId && rows.length === 0) {
@@ -30,15 +32,24 @@ export function loadStoredData(self) {
                         if (storedData.treeMetadata) {
                             self.setTreeMetadata(storedData.treeMetadata);
                         }
+                        if (storedData.gff) {
+                            self.setGFF(storedData.gff);
+                        }
                         self.setLastStoredData(currentData(self));
                     });
                 }
                 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
+                    // "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.setError(new Error(EXPIRED_MESSAGE));
+                        self.setError(new Error(EXPIRED_MESSAGE +
+                            ((self.blastParams ?? self.orthologParams)
+                                ? RELAUNCHABLE
+                                : START_OVER)));
                     });
                 }
             }
@@ -51,15 +62,21 @@ export function loadStoredData(self) {
         })();
     }
 }
+/**
+ * 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 } = self.data;
-    return { msa, tree, treeMetadata };
+    const { msa, tree, treeMetadata, gff } = self.data;
+    return { msa, tree, treeMetadata, gff };
 }
 function sameData(a, b) {
     return (!!a &&
         a.msa === b.msa &&
         a.tree === b.tree &&
-        a.treeMetadata === b.treeMetadata);
+        a.treeMetadata === b.treeMetadata &&
+        a.gff === b.gff);
 }
 /**
  * Keep IndexedDB holding what the view holds. The first run writes a new row and
@@ -115,19 +132,26 @@ export function storeDataToIndexedDB(self) {
 }
 /**
  * Same shape as launchBlastIfNeeded, for the ortholog path: the params ARE the
- * request, and clearing them on success is what marks it done. They are left in
- * place on failure so the error stays attributable to a specific request; the
- * autorun's only tracked read is orthologParams itself, so nothing refires
- * until a new request replaces them.
+ * request, and `launchCompleted` is what marks it done. They are left in place
+ * either way -- on failure so the error stays attributable to a specific
+ * request, and on success because they are the only durable statement of what
+ * the view is, which is what a stored alignment that expired is rebuilt from.
+ * The autorun tracks those two reads alone, so nothing refires until a new
+ * request replaces them or a retry clears the mark.
  */
 export function launchOrthologsIfNeeded(self) {
-    if (self.orthologParams && !awaitingTranscript(self)) {
+    if (self.orthologParams &&
+        !self.launchCompleted &&
+        !awaitingTranscript(self)) {
         runLaunch({
             self,
             message: 'Resolving orthologs',
             launch: scope => doLaunchOrthologs({ self, scope }),
+            // marked rather than dropped: the request is the only durable statement
+            // of what this view is, and a view whose stored alignment expired runs it
+            // again
             onLaunched: () => {
-                self.setOrthologParams(undefined);
+                self.setLaunchCompleted(true);
             },
         });
     }
@@ -142,13 +166,13 @@ function awaitingTranscript(self) {
     return !!self.connectedTranscript && !self.connectedFeature;
 }
 export function launchBlastIfNeeded(self) {
-    if (self.blastParams && !awaitingTranscript(self)) {
+    if (self.blastParams && !self.launchCompleted && !awaitingTranscript(self)) {
         runLaunch({
             self,
             message: 'Submitting query',
             launch: scope => doLaunchBlast({ self, scope }),
             onLaunched: () => {
-                self.setBlastParams(undefined);
+                self.setLaunchCompleted(true);
             },
         });
     }

package/dist/MsaViewPanel/applyRegion.d.ts

@@ -0,0 +1,23 @@
+import type { Region } from 'react-msaview';
+interface RegionModel {
+    region?: Region;
+    viewInitialized: boolean;
+    numColumns: number;
+    treeFilehandle?: unknown;
+    data: {
+        tree?: string;
+    };
+    zoomToRegion: (region: Region) => void;
+    setRegion: (region?: Region) => void;
+}
+/**
+ * Zoom onto the launch's `region` once, then forget it, so a reloaded session
+ * opens where the reader left it rather than back on the region.
+ *
+ * zoomToRegion is a no-op until the view has a width, and it resolves residues
+ * through the visible columns, so it waits for the alignment and for a tree
+ * file too: a clade the tree collapses hides columns and would move the
+ * target after the zoom.
+ */
+export declare function applyRegion(self: RegionModel): void;
+export {};

package/dist/MsaViewPanel/applyRegion.js

@@ -0,0 +1,19 @@
+/**
+ * Zoom onto the launch's `region` once, then forget it, so a reloaded session
+ * opens where the reader left it rather than back on the region.
+ *
+ * zoomToRegion is a no-op until the view has a width, and it resolves residues
+ * through the visible columns, so it waits for the alignment and for a tree
+ * file too: a clade the tree collapses hides columns and would move the
+ * target after the zoom.
+ */
+export function applyRegion(self) {
+    const { region } = self;
+    if (region &&
+        self.viewInitialized &&
+        self.numColumns > 0 &&
+        !(self.treeFilehandle && !self.data.tree)) {
+        self.zoomToRegion(region);
+        self.setRegion(undefined);
+    }
+}

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

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

package/dist/MsaViewPanel/applyRegion.test.js

@@ -0,0 +1,45 @@
+import { expect, test, vi } from 'vitest';
+import { applyRegion } from './applyRegion';
+const REGION = { row: 'Human', start: 245, end: 249 };
+function makeModel(over = {}) {
+    const model = {
+        region: REGION,
+        viewInitialized: true,
+        numColumns: 400,
+        treeFilehandle: undefined,
+        data: {},
+        zoomToRegion: vi.fn(),
+        setRegion: vi.fn((arg) => {
+            model.region = arg;
+        }),
+        ...over,
+    };
+    return model;
+}
+test('zooms onto the region once, then forgets it', () => {
+    const model = makeModel();
+    applyRegion(model);
+    applyRegion(model);
+    expect(model.zoomToRegion).toHaveBeenCalledTimes(1);
+    expect(model.zoomToRegion).toHaveBeenCalledWith(REGION);
+    expect(model.region).toBeUndefined();
+});
+test('waits for the view to have a width', () => {
+    const model = makeModel({ viewInitialized: false });
+    applyRegion(model);
+    expect(model.zoomToRegion).not.toHaveBeenCalled();
+    expect(model.region).toEqual(REGION);
+});
+test('waits for the alignment', () => {
+    const model = makeModel({ numColumns: 0 });
+    applyRegion(model);
+    expect(model.zoomToRegion).not.toHaveBeenCalled();
+});
+test('waits for a tree file, whose collapsed clades move the columns', () => {
+    const model = makeModel({ treeFilehandle: { uri: 'x.nh' } });
+    applyRegion(model);
+    expect(model.zoomToRegion).not.toHaveBeenCalled();
+    model.data.tree = '(a,b);';
+    applyRegion(model);
+    expect(model.zoomToRegion).toHaveBeenCalledTimes(1);
+});

package/dist/MsaViewPanel/components/LaunchProgress.d.ts

@@ -4,9 +4,10 @@ import type { JBrowsePluginMsaViewModel } from '../model';
  * What a view shows while it is still building its alignment, and what it shows
  * when that fails.
  *
- * Every launch that resolves something leaves its request on the model until it
- * succeeds -- `blastParams`, `orthologParams`, `init` -- so one still being
- * there IS "no alignment yet", and the error a failed launch records is only
+ * Every launch that resolves something states its request on the model --
+ * `blastParams`, `orthologParams`, `init` -- and one not yet marked
+ * `launchCompleted` IS "no alignment yet", as is a completed one whose stored
+ * alignment has since expired. The error a failed launch records is only
  * readable here. This used to key on `blastParams` alone, which left an ortholog
  * launch rendering an empty MSAView for the minutes its alignment takes and, on
  * failure, forever: the error was set and nothing drew it.

package/dist/MsaViewPanel/components/LaunchProgress.js

@@ -18,16 +18,21 @@ const useStyles = makeStyles()({
  * What a view shows while it is still building its alignment, and what it shows
  * when that fails.
  *
- * Every launch that resolves something leaves its request on the model until it
- * succeeds -- `blastParams`, `orthologParams`, `init` -- so one still being
- * there IS "no alignment yet", and the error a failed launch records is only
+ * Every launch that resolves something states its request on the model --
+ * `blastParams`, `orthologParams`, `init` -- and one not yet marked
+ * `launchCompleted` IS "no alignment yet", as is a completed one whose stored
+ * alignment has since expired. The error a failed launch records is only
  * readable here. This used to key on `blastParams` alone, which left an ortholog
  * launch rendering an empty MSAView for the minutes its alignment takes and, on
  * failure, forever: the error was set and nothing drew it.
  */
 const LaunchProgress = observer(function LaunchProgress2({ model, }) {
-    const { blastParams, orthologParams, progress, rid, error } = model;
+    const { progress, rid, error } = model;
     const { classes } = useStyles();
+    // the request stays on the model after it succeeds, so an expired
+    // alignment's panel is still named after the search that built it
+    const pending = !model.launchCompleted;
+    const { blastParams, orthologParams } = model;
     const message = blastParams
         ? `Running EBI ${blastParams.searchProgram === 'phmmer' ? 'phmmer' : 'BLAST'}`
         : orthologParams
@@ -36,9 +41,7 @@ const LaunchProgress = observer(function LaunchProgress2({ model, }) {
                 : 'Building ortholog alignment'
             : 'Loading alignment';
     return (React.createElement("div", { className: classes.margin }, error ? (React.createElement(React.Fragment, null,
-        React.createElement(Typography, { variant: "h5" },
-            message,
-            " failed"),
+        React.createElement(Typography, { variant: "h5" }, pending ? `${message} failed` : 'Alignment no longer available'),
         rid ? React.createElement(JobLink, { jobId: rid }) : null,
         React.createElement(ErrorMessage, { error: error }),
         React.createElement("div", { className: classes.progressRow },

package/dist/MsaViewPanel/components/MsaViewPanel.js

@@ -17,9 +17,13 @@ const MsaViewPanel = observer(function MsaViewPanel2({ model, }) {
     // three gate the same panel -- see LaunchProgress. An indexed view keeps its
     // init for the life of the view (it is how the block is refetched), so that
     // one is only "launching" until the alignment arrives.
-    const launching = !!(blastParams ??
-        orthologParams ??
-        (init && !model.dataInitialized));
+    const request = blastParams ?? orthologParams;
+    const pending = !!request && !model.launchCompleted;
+    // a request that finished and then lost its alignment -- browser storage
+    // expires one after 7 days -- is a request again, and LaunchProgress draws it
+    // with the Retry that runs it
+    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(LoadingEllipses, { message: "Loading MSA data", variant: "h6" }))) : (React.createElement(MSAView, { model: model })))));

package/dist/MsaViewPanel/components/MsaViewPanel.test.js

@@ -97,6 +97,30 @@ test('a failed launch can be retried or dismissed', () => {
     screen.getByRole('button', { name: 'Dismiss' }).click();
     expect(cancelLaunch).toHaveBeenCalled();
 });
+// a stored alignment expires after 7 days, and the view used to say so and
+// stop there -- the request that built it had been dropped on success, so the
+// only way back was to find the gene again
+test('an expired alignment offers to run its original search again', () => {
+    const retryLaunch = vi.fn();
+    panel({
+        progress: '',
+        dataInitialized: false,
+        error: new Error("This view's alignment is no longer in browser storage."),
+        blastParams: { blastDatabase: 'uniprotkb_swissprot' },
+        launchCompleted: true,
+        retryLaunch,
+    });
+    expect(screen.queryByText('the alignment')).toBeNull();
+    expect(screen.getByText('Alignment no longer available')).toBeTruthy();
+    screen.getByRole('button', { name: 'Retry' }).click();
+    expect(retryLaunch).toHaveBeenCalled();
+});
+// with nothing to retry from -- a pasted alignment, say -- the panel stays out
+// of the way and react-msaview's own import form is what the user gets
+test('an expired alignment with no request behind it draws the view', () => {
+    panel({ progress: '', dataInitialized: false, error: new Error('gone') });
+    expect(screen.getByText('the alignment')).toBeTruthy();
+});
 test('a running job links out to it', () => {
     panel({
         blastParams: { proteinSequence: 'MKV' },

package/dist/MsaViewPanel/doLaunchBlast.js

@@ -84,8 +84,9 @@ export async function doLaunchBlast({ self, scope, }) {
     await saveBlastResult({
         proteinSequence: query,
         blastDatabase: params.blastDatabase,
-        msaAlgorithm: params.msaAlgorithm,
+        msaAlgorithm: queryRow ? undefined : (params.msaAlgorithm ?? 'browser'),
         searchProgram: params.searchProgram,
+        maxHits,
         msa,
         tree,
         treeMetadata: treeMetadataJson,

package/dist/MsaViewPanel/doLaunchBlast.test.js

@@ -67,6 +67,18 @@ test('bare hits go to the chosen aligner, with the query first', async () => {
     expect(result.msa).toBe('aligned');
     expect(result.tree).toBe('tree');
 });
+// the history names the aligner that ran, which for a spec naming none is the
+// in-browser one -- not a key reading `db:undefined:...`
+test('a search naming no aligner is saved as aligned in the browser', async () => {
+    blastp.mockResolvedValue({ rid: 'job', hits: [{ ...HIT, sequence: 'MKWV' }] });
+    mockLaunchMSA.mockResolvedValue({ msa: 'aligned', tree: '' });
+    await launch(makeModel({
+        blastDatabase: 'uniprotkb_swissprot',
+        maxHits: 20,
+        proteinSequence: 'MKWVTF',
+    }));
+    expect(saveBlastResult).toHaveBeenCalledWith(expect.objectContaining({ msaAlgorithm: 'browser', maxHits: 20 }));
+});
 test('an aligned result skips the aligner and leaves the tree to the browser', async () => {
     phmmer.mockResolvedValue({
         rid: 'job',

package/dist/MsaViewPanel/doLaunchOrthologs.test.js

@@ -175,7 +175,7 @@ describe('the query row sequence', () => {
         await launch({
             self: makeModel(params({ proteinSequence: 'MAGG*AWGR&' })),
         });
-        expect(queryRowSent()).toBe('MAGGAWGR');
+        expect(queryRowSent()).toBe('MAGGXAWGR');
     });
     test('throws when neither a sequence nor a representative is available', async () => {
         mockFetchProtein.mockResolvedValue(undefined);

package/dist/MsaViewPanel/genomeToMSA.js

@@ -1,8 +1,8 @@
 import { getSession } from '@jbrowse/core/util';
-import { hasHoverPosition, hasQueryRow, transcriptPosToVisibleCol, } from './util';
+import { hasHoverPosition, hasQueryRow, querySeqPosToVisibleCol, transcriptPosToVisibleCol, } from './util';
 export function genomeToMSA({ model }) {
-    const { hovered } = getSession(model);
-    const { querySeqName, transcriptToMsaMap, connectedView, mafRegion } = model;
+    const { assemblyManager, hovered } = getSession(model);
+    const { transcriptToMsaMap, connectedView, mafRegion } = model;
     if (!connectedView?.initialized ||
         !hasHoverPosition(hovered) ||
         !hasQueryRow(model)) {
@@ -12,20 +12,38 @@ export function genomeToMSA({ model }) {
     // hoverPosition.coord is a 1-based display coordinate (core's pxToBp adds the
     // +1), while g2p and mafRegion are keyed by 0-based genome position
     const genomePos = coord - 1;
+    // The two sides name the chromosome differently. A hover carries the
+    // assembly's canonical name -- `1` on jbrowse.org's hg38 -- while mafRegion
+    // and the transcript's g2p map carry the feature's, straight out of the
+    // annotation file, which is `chr1` in GENCODE. Compared raw they agree only
+    // where a config happens to pair files that agree, and everywhere else
+    // hovering a codon lit nothing at all, with no throw and no console line.
+    //
+    // `initialized` is the gate rather than a try/catch: getCanonicalRefName
+    // throws until the assembly's aliases load, and this runs from a hover
+    // autorun over an assembly nothing here waited for -- mafRegion names its own
+    // on a frozen spec, which need not be one the connected view loaded. Until
+    // the aliases arrive the raw name is the whole answer, and the hover lights
+    // nothing for those frames rather than throwing out of the autorun.
+    const assembly = assemblyManager.get(mafRegion?.assemblyName ?? connectedView.assemblyNames[0] ?? '');
+    const canonical = (name) => (assembly?.initialized ? assembly.getCanonicalRefName(name) : undefined) ??
+        name;
+    const hoveredRefName = canonical(refName);
     if (mafRegion) {
-        if (refName !== mafRegion.refName ||
+        if (hoveredRefName !== canonical(mafRegion.refName) ||
             !connectedView.assemblyNames.includes(mafRegion.assemblyName) ||
             genomePos < mafRegion.start ||
             genomePos >= mafRegion.end) {
             return undefined;
         }
-        return model.seqPosToVisibleCol(querySeqName, genomePos - mafRegion.start);
+        return querySeqPosToVisibleCol(model, genomePos - mafRegion.start);
     }
     // session.hovered is global -- set by whichever LinearGenomeView the cursor
     // was last over, on any assembly -- so the refName gate is load bearing:
     // 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) {
+    if (transcriptToMsaMap &&
+        hoveredRefName === canonical(transcriptToMsaMap.refName)) {
         const proteinPos = transcriptToMsaMap.g2p[genomePos];
         if (proteinPos !== undefined) {
             return transcriptPosToVisibleCol(model, proteinPos);