jbrowse-plugin-msaview 3.6.0 → 3.7.0

package/dist/LaunchMsaView/components/SubmitCancelActions.js

@@ -1,7 +1,7 @@
 import React from 'react';
 import { getSession } from '@jbrowse/core/util';
 import { Button, Checkbox, DialogActions, FormControlLabel, } from '@mui/material';
-import { sessionSupportsPlacement, writeLaunchPlacement, } from '../../utils/workspaces';
+import { readLaunchPlacement, sessionSupportsPlacement, writeLaunchPlacement, } from '../../utils/workspaces';
 import { useLaunchPlacement } from './launchPlacement';
 /**
  * Where the launch puts the view, offered wherever a launch is submitted.
@@ -21,10 +21,9 @@ function PlacementToggle({ checked, onChange, }) {
 }
 export default function SubmitCancelActions({ onSubmit, onCancel, submitDisabled, hint, submitLabel = 'Submit', cancelLabel = 'Cancel', model, }) {
     const [sideBySide, setSideBySide] = useLaunchPlacement();
-    // The stored value is what the next launch reads, so it is written on submit
-    // rather than on the click: ticking the box and then pressing Cancel used to
-    // change where every future launch landed, from a dialog the user backed out
-    // of.
+    // The stored value is what the next dialog opens on, so it is written on
+    // submit rather than on the click: a dialog the user backed out of must not
+    // move where every future launch lands.
     const offerPlacement = !!model && sessionSupportsPlacement(getSession(model));
     return (React.createElement(DialogActions, { sx: { flexWrap: 'wrap', rowGap: 1 } },
         offerPlacement ? (React.createElement(PlacementToggle, { checked: sideBySide, onChange: setSideBySide })) : null,
@@ -37,9 +36,13 @@ export default function SubmitCancelActions({ onSubmit, onCancel, submitDisabled
             hint,
             React.createElement(Button, { sx: { flexShrink: 0 }, color: "primary", variant: "contained", disabled: submitDisabled, onClick: () => {
                     if (offerPlacement) {
-                        writeLaunchPlacement(sideBySide ? 'splitRight' : 'stack');
+                        const placement = sideBySide ? 'splitRight' : 'stack';
+                        writeLaunchPlacement(placement);
+                        onSubmit(placement);
+                    }
+                    else {
+                        onSubmit(readLaunchPlacement());
                     }
-                    onSubmit();
                 } }, submitLabel),
             React.createElement(Button, { sx: { flexShrink: 0 }, color: "secondary", variant: "contained", onClick: () => {
                     onCancel();

package/dist/LaunchMsaView/components/SubmitCancelActions.test.js

@@ -40,13 +40,31 @@ test('a panel that launches nothing passes no model, and gets no box', () => {
     render(React.createElement(SubmitCancelActions, { onSubmit: () => { }, onCancel: () => { } }));
     expect(toggle()).toBeNull();
 });
-test('submitting writes the placement the launch will read', () => {
-    render(React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: () => { }, onCancel: () => { } }));
+test('submitting hands the launch the placement and remembers it', () => {
+    const onSubmit = vi.fn();
+    render(React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: onSubmit, onCancel: () => { } }));
     toggle().click();
     expect(toggle().checked).toBe(false);
     screen.getByText('Submit').click();
+    expect(onSubmit).toHaveBeenCalledWith('stack');
     expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBe('stack');
 });
+// an unticked box used to reach the launch only through storage, so a browser
+// refusing localStorage launched side by side anyway
+test('the box decides the launch even where storage throws', () => {
+    const onSubmit = vi.fn();
+    const setItem = vi
+        .spyOn(Storage.prototype, 'setItem')
+        .mockImplementation(() => {
+        throw new Error('SecurityError');
+    });
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+    render(React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: onSubmit, onCancel: () => { } }));
+    toggle().click();
+    screen.getByText('Submit').click();
+    expect(onSubmit).toHaveBeenCalledWith('stack');
+    setItem.mockRestore();
+});
 // the box is a property of this launch until it is launched; a dialog the user
 // backed out of should not have moved where every future one lands
 test('cancelling leaves the stored placement alone', () => {

package/dist/LaunchMsaView/components/calculateProteinSequence.d.ts

@@ -1,9 +1,11 @@
 import type { Feat } from './types';
 import type { Feature } from '@jbrowse/core/util';
-export declare function calculateProteinSequence({ cds, sequence, geneticCodeId, }: {
+import type { TranslExcept } from '@jbrowse/core/util/geneticCodes';
+export declare function calculateProteinSequence({ cds, sequence, geneticCodeId, translExcept, }: {
     cds: Feat[];
     sequence: string;
     geneticCodeId?: number;
+    translExcept?: TranslExcept[];
 }): string;
 export declare function revlist(list: Feat[], seqlen: number): {
     start: number;
@@ -11,6 +13,11 @@ export declare function revlist(list: Feat[], seqlen: number): {
     type?: string;
     phase?: number;
 }[];
+/**
+ * The translation core's own feature panel shows: the contig's or the
+ * feature's genetic code, its alternative initiators, and any `transl_except`
+ * (RefSeq's selenocysteines), read off the transcript or its CDS as core does.
+ */
 export declare function getProteinSequenceFromFeature({ feature, seq, assemblyGeneticCodeId, }: {
     seq: string;
     feature: Feature;

package/dist/LaunchMsaView/components/calculateProteinSequence.js

@@ -1,25 +1,20 @@
 import { revcom } from '@jbrowse/core/util';
 import { convertCodingSequenceToPeptides } from '@jbrowse/core/util/convertCodingSequenceToPeptides';
-import { getGeneticCode, parseTranslTable, } from '@jbrowse/core/util/geneticCodes';
+import { getGeneticCode, parseTranslTable, relativizeTranslExcept, } from '@jbrowse/core/util/geneticCodes';
 // `@jbrowse/core/util/convertCodingSequenceToPeptides` and
-// `@jbrowse/core/util/geneticCodes` are deep paths, so unlike the
-// `@jbrowse/core/util` barrel they are absent from ReExports and get bundled
-// rather than resolved out of the host's JBrowseExports. That is what makes
-// reusing core's translation safe across every host a config names: this module
-// previously built its codon table at module scope from the barrel's
-// `defaultCodonTable`, and a core build that dropped that export turned it into
-// `Object.keys(undefined)` while the UMD was still evaluating -- the plugin
-// global was never assigned and PluginLoader error-paged the whole app.
-export function calculateProteinSequence({ cds, sequence, geneticCodeId, }) {
-    // `starts` is deliberately not passed: @jbrowse/core 4.3.0's signature has no
-    // such parameter, so alternative initiators (GTG under table 11, ATA under
-    // table 2) render as their internal residue rather than M. Core main added it;
-    // pass it here when msaview's @jbrowse/core floor reaches that release.
-    const { codonTable } = getGeneticCode(geneticCodeId);
+// `@jbrowse/core/util/geneticCodes` are deep paths absent from ReExports, so
+// they are bundled rather than resolved out of the host's JBrowseExports: every
+// host runs the version this build installs. Importing translation from the
+// `@jbrowse/core/util` barrel instead is what error-paged the whole app when a
+// core build dropped `defaultCodonTable`.
+export function calculateProteinSequence({ cds, sequence, geneticCodeId, translExcept, }) {
+    const { codonTable, starts } = getGeneticCode(geneticCodeId);
     return convertCodingSequenceToPeptides({
         cds,
         sequence,
         codonTable,
+        starts,
+        translExcept,
     });
 }
 // The CDS list is sorted by start, so adjacent comparison is the whole job.
@@ -38,8 +33,13 @@ export function revlist(list, seqlen) {
     }))
         .toSorted((a, b) => a.start - b.start);
 }
+/**
+ * The translation core's own feature panel shows: the contig's or the
+ * feature's genetic code, its alternative initiators, and any `transl_except`
+ * (RefSeq's selenocysteines), read off the transcript or its CDS as core does.
+ */
 export function getProteinSequenceFromFeature({ feature, seq, assemblyGeneticCodeId, }) {
-    const { subfeatures, start, strand } = feature.toJSON();
+    const { subfeatures, start, end, strand } = feature.toJSON();
     const cds = dedupe(subfeatures
         ?.toSorted((a, b) => a.start - b.start)
         .map(sub => ({
@@ -48,19 +48,24 @@ export function getProteinSequenceFromFeature({ feature, seq, assemblyGeneticCod
         end: sub.end - start,
     }))
         .filter(subfeature => subfeature.type === 'CDS') ?? []);
-    // RefSeq declares transl_table=2 on a mitochondrial CDS, usually on the CDS
-    // rather than the transcript. GENCODE and UCSC declare nothing, so without
-    // the assembly's code all 13 human mitochondrial proteins read TGA as a stop
-    // and ATA as I.
     const cdsSubfeature = feature
         .get('subfeatures')
         ?.find((f) => f.get('type')?.toLowerCase() === 'cds');
     const geneticCodeId = parseTranslTable(feature.get('transl_table')) ??
         parseTranslTable(cdsSubfeature?.get('transl_table')) ??
         assemblyGeneticCodeId;
+    const rawTranslExcept = feature.get('transl_except') ?? cdsSubfeature?.get('transl_except');
     return calculateProteinSequence({
         cds: strand === -1 ? revlist(cds, seq.length) : cds,
         sequence: strand === -1 ? revcom(seq) : seq,
         geneticCodeId,
+        translExcept: rawTranslExcept
+            ? relativizeTranslExcept({
+                raw: rawTranslExcept,
+                featureStart: start,
+                featureLength: end - start,
+                strand,
+            })
+            : undefined,
     });
 }

package/dist/LaunchMsaView/components/launchConnectedView.d.ts

@@ -0,0 +1,23 @@
+import type { MsaViewPlacement } from '../../utils/workspaces';
+import type { Feature } from '@jbrowse/core/util';
+import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
+/** how a view whose alignment the plugin builds opens */
+export declare const builtAlignmentLook: {
+    drawNodeBubbles: boolean;
+    colWidth: number;
+    rowHeight: number;
+};
+/**
+ * Every dialog launch: an MSA view tied to the genome view it came from, and
+ * through `feature` to the transcript whose codons its query row is read by.
+ */
+export declare function launchConnectedView({ view, feature, placement, ...snapshot }: {
+    view: LinearGenomeViewModel;
+    feature?: Feature;
+    placement: MsaViewPlacement;
+} & Record<string, unknown>): void;
+/** runs a panel's launch, closing the dialog on success and keeping the error */
+export declare function useLaunchSubmit(handleClose: () => void): {
+    launchError: unknown;
+    submit: (launch: () => void) => void;
+};

package/dist/LaunchMsaView/components/launchConnectedView.js

@@ -0,0 +1,39 @@
+import { useState } from 'react';
+import { getSession } from '@jbrowse/core/util';
+import { launchMsaView } from '../../utils/launchMsaView';
+/** how a view whose alignment the plugin builds opens */
+export const builtAlignmentLook = {
+    drawNodeBubbles: true,
+    colWidth: 10,
+    rowHeight: 12,
+};
+/**
+ * Every dialog launch: an MSA view tied to the genome view it came from, and
+ * through `feature` to the transcript whose codons its query row is read by.
+ */
+export function launchConnectedView({ view, feature, placement, ...snapshot }) {
+    launchMsaView(getSession(view), {
+        placement,
+        connectedViewId: view.id,
+        connectedFeature: feature?.toJSON(),
+        ...snapshot,
+    });
+}
+/** runs a panel's launch, closing the dialog on success and keeping the error */
+export function useLaunchSubmit(handleClose) {
+    const [launchError, setLaunchError] = useState();
+    return {
+        launchError,
+        submit: (launch) => {
+            try {
+                setLaunchError(undefined);
+                launch();
+                handleClose();
+            }
+            catch (e) {
+                console.error(e);
+                setLaunchError(e);
+            }
+        },
+    };
+}

package/dist/LaunchMsaView/detectQueryRow.js

@@ -1,14 +1,11 @@
 import { getUngappedSequence, parseMSA } from 'msa-parsers';
+import { cleanProteinSequence } from './util';
 /**
- * A stop codon is present in the transcript's translation and absent from
- * anything an aligner returns, and case is not meaningful in either.
+ * The translation as a search launch would have sent it, so a row that launch
+ * built matches exactly; case means nothing on either side.
  */
 function normalize(seq) {
-    return seq
-        .replaceAll('*', '')
-        .replaceAll('-', '')
-        .replaceAll('.', '')
-        .toUpperCase();
+    return cleanProteinSequence(seq).toUpperCase();
 }
 function identityOverOverlap(a, b) {
     const len = Math.min(a.length, b.length);

package/dist/LaunchMsaView/util.d.ts

@@ -13,5 +13,11 @@ export declare function getTranscriptDisplayName(val?: Feature): string;
 export declare function getGeneDisplayName(val?: Feature): string;
 export declare function getBlastViewTitle(feature: Feature, transcript: Feature): string;
 export declare function getSortedTranscriptFeatures(feature: Feature): Feature[];
+/**
+ * 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 declare function cleanProteinSequence(seq: string): string;
 export declare function getGeneIdentifiers(feature: Feature): string[];

package/dist/LaunchMsaView/util.js

@@ -70,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.js

@@ -32,6 +32,9 @@ export function loadStoredData(self) {
                         if (storedData.treeMetadata) {
                             self.setTreeMetadata(storedData.treeMetadata);
                         }
+                        if (storedData.gff) {
+                            self.setGFF(storedData.gff);
+                        }
                         self.setLastStoredData(currentData(self));
                     });
                 }
@@ -59,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

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/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 { assemblyManager, hovered } = getSession(model);
-    const { querySeqName, transcriptToMsaMap, connectedView, mafRegion } = model;
+    const { transcriptToMsaMap, connectedView, mafRegion } = model;
     if (!connectedView?.initialized ||
         !hasHoverPosition(hovered) ||
         !hasQueryRow(model)) {
@@ -36,7 +36,7 @@ export function genomeToMSA({ model }) {
             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: