jbrowse-plugin-msaview 3.3.0 → 3.4.1

package/dist/AddHighlightModel/GenomeMouseoverHighlight.js

@@ -1,8 +1,8 @@
 import React from 'react';
 import { getSession } from '@jbrowse/core/util';
 import { observer } from 'mobx-react';
-import { hasHoverPosition, useStyles } from './util';
 import { isMsaView } from '../MsaViewPanel/model';
+import { hasHoverPosition, useStyles } from './util';
 const GenomeMouseoverHighlight = observer(function ({ model, }) {
     const { hovered, views } = getSession(model);
     const hasMsaView = views.some(s => isMsaView(s) && s.connectedViewId === model.id);

package/dist/AddHighlightModel/MsaToGenomeHighlight.js

@@ -1,8 +1,8 @@
 import React from 'react';
 import { getSession } from '@jbrowse/core/util';
 import { observer } from 'mobx-react';
-import { hasHoverPosition, useStyles } from './util';
 import { isMsaView } from '../MsaViewPanel/model';
+import { hasHoverPosition, useStyles } from './util';
 const MsaToGenomeHighlight = observer(function MsaToGenomeHighlight2({ model, }) {
     const { views, hovered } = getSession(model);
     const msaView = views

package/dist/AddHighlightModel/index.js

@@ -1,7 +1,7 @@
 import React from 'react';
 import { getSession } from '@jbrowse/core/util';
-import HighlightComponents from './HighlightComponents';
 import { isMsaView } from '../MsaViewPanel/model';
+import HighlightComponents from './HighlightComponents';
 export default function AddHighlightComponentsModelF(pluginManager) {
     pluginManager.addToExtensionPoint('LinearGenomeView-TracksContainerComponent', 
     // @ts-expect-error

package/dist/LaunchMsaView/components/BlastQuery/BlastAutomaticPanel.js

@@ -3,21 +3,28 @@ import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
 import { Accordion, AccordionDetails, AccordionSummary, MenuItem, Typography, } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
-import CachedBlastResults from './CachedBlastResults';
-import MsaAlgorithmSelect from './MsaAlgorithmSelect';
-import { blastLaunchView } from './blastLaunchView';
-import { blastDatabaseOptions, defaultBlastDatabase } from './consts';
-import { useCachedBlastResults } from './useCachedBlastResults';
 import TextField2 from '../../../components/TextField2';
 import { getBlastViewTitle, getGeneIdentifiers, getLinearGenomeView, } from '../../util';
 import LaunchPanelContent from '../LaunchPanelContent';
 import SubmitCancelActions from '../SubmitCancelActions';
 import TranscriptSelector from '../TranscriptSelector';
 import { useTranscriptSelection } from '../useTranscriptSelection';
+import CachedBlastResults from './CachedBlastResults';
+import MsaAlgorithmSelect from './MsaAlgorithmSelect';
+import { blastLaunchView } from './blastLaunchView';
+import { databaseOptionsFor, defaultSearchFor, searchPrograms } from './consts';
+import { useStoredMsaAlgorithm, useStoredSearchChoice, } from './searchChoiceStorage';
+import { useCachedBlastResults } from './useCachedBlastResults';
 const useStyles = makeStyles()({
     selectField: {
         width: 150,
     },
+    // wider than the rest because the values are what the user came to read, and
+    // `uniprotkb_swissprot` is 19 characters — at 150 the field showed
+    // `uniprotkb_swis…`, which does not distinguish it from `uniprotkb_trembl`
+    databaseField: {
+        width: 230,
+    },
     cachedResultsAccordion: {
         marginTop: 20,
     },
@@ -29,8 +36,12 @@ const BlastAutomaticPanel = observer(function ({ handleClose, feature, model, ch
     const { classes } = useStyles();
     const view = getLinearGenomeView(model);
     const [launchViewError, setLaunchViewError] = useState();
-    const [selectedBlastDatabase, setSelectedBlastDatabase] = useState(defaultBlastDatabase);
-    const [selectedMsaAlgorithm, setSelectedMsaAlgorithm] = useState('clustalo');
+    // one piece of state, not two: a program and a database that program does not
+    // have is a 400 from EBI minutes after Submit, and holding them apart is what
+    // would let them drift into that
+    const [search, setSearch] = useStoredSearchChoice();
+    const [selectedMsaAlgorithm, setSelectedMsaAlgorithm] = useStoredMsaAlgorithm();
+    const isPhmmer = search.program === 'phmmer';
     const geneIds = useMemo(() => getGeneIdentifiers(feature), [feature]);
     const { results: cachedResults, error: cachedResultsError } = useCachedBlastResults(geneIds);
     const transcriptSelection = useTranscriptSelection({ feature, view });
@@ -39,12 +50,35 @@ const BlastAutomaticPanel = observer(function ({ handleClose, feature, model, ch
     return (React.createElement(React.Fragment, null,
         React.createElement(LaunchPanelContent, { error: e },
             children,
-            React.createElement(TextField2, { variant: "outlined", label: "BLAST database", className: classes.selectField, select: true, value: selectedBlastDatabase, onChange: event => {
-                    setSelectedBlastDatabase(event.target.value);
-                } }, blastDatabaseOptions.map(val => (React.createElement(MenuItem, { value: val, key: val }, val)))),
-            React.createElement(MsaAlgorithmSelect, { className: classes.selectField, value: selectedMsaAlgorithm, onChange: setSelectedMsaAlgorithm }),
+            React.createElement(TextField2, { variant: "outlined", label: "Search program", className: classes.selectField, select: true, value: search.program, onChange: event => {
+                    // the two services name their databases differently, so switching
+                    // program replaces the database rather than keeping a name the new
+                    // one has never heard of
+                    setSearch(defaultSearchFor(event.target.value));
+                } }, searchPrograms.map(val => (React.createElement(MenuItem, { value: val, key: val }, val)))),
+            React.createElement(TextField2, { variant: "outlined", label: "Database", className: classes.databaseField, select: true, value: search.database, onChange: event => {
+                    setSearch({
+                        program: search.program,
+                        database: event.target.value,
+                    });
+                } }, databaseOptionsFor(search.program).map(val => (React.createElement(MenuItem, { value: val, key: val }, val)))),
+            isPhmmer ? null : (React.createElement(MsaAlgorithmSelect, { className: classes.selectField, value: selectedMsaAlgorithm, onChange: setSelectedMsaAlgorithm })),
             React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection }),
-            React.createElement(Typography, { className: classes.infoText }, "This panel will automatically submit a blastp query to EBI, which searches UniProtKB. Searches usually finish in under a minute, and swissprot returns curated sequences that align more cleanly than the many near-identical entries a TrEMBL search brings back. After completion, all the hits will be run through a multiple sequence alignment. Searching NCBI's nr needs the manual approach: NCBI no longer lets a browser read responses from Blast.cgi."),
+            React.createElement(Typography, { className: classes.infoText },
+                isPhmmer
+                    ? `phmmer searches UniProtKB with a profile HMM built from the query,
+               so it aligns the hits as it finds them and that alignment is used
+               directly — nothing is realigned afterwards. The tree is then built
+               from it by neighbour-joining. A hit matching the query in more
+               than one place appears once per matched region.`
+                    : `This panel will automatically submit a blastp query to EBI, which
+               searches UniProtKB. Searches usually finish in under a minute, and
+               swissprot returns curated sequences that align more cleanly than
+               the many near-identical entries a TrEMBL search brings back. After
+               completion, all the hits will be run through a multiple sequence
+               alignment.`,
+                ' ',
+                "Searching NCBI's nr needs the manual approach: NCBI no longer lets a browser read responses from Blast.cgi."),
             cachedResults.length > 0 ? (React.createElement(Accordion, { className: classes.cachedResultsAccordion },
                 React.createElement(AccordionSummary, { expandIcon: React.createElement(ExpandMoreIcon, null) },
                     React.createElement(Typography, null, "Previous BLAST Results")),
@@ -58,12 +92,20 @@ const BlastAutomaticPanel = observer(function ({ handleClose, feature, model, ch
                             feature: selectedTranscript,
                             view,
                             newViewTitle: getBlastViewTitle(feature, selectedTranscript),
-                            blastParams: {
-                                blastDatabase: selectedBlastDatabase,
-                                msaAlgorithm: selectedMsaAlgorithm,
-                                selectedTranscript,
-                                proteinSequence,
-                            },
+                            blastParams: search.program === 'phmmer'
+                                ? {
+                                    searchProgram: 'phmmer',
+                                    blastDatabase: search.database,
+                                    selectedTranscript,
+                                    proteinSequence,
+                                }
+                                : {
+                                    searchProgram: 'blastp',
+                                    blastDatabase: search.database,
+                                    msaAlgorithm: selectedMsaAlgorithm,
+                                    selectedTranscript,
+                                    proteinSequence,
+                                },
                         });
                         handleClose();
                     }

package/dist/LaunchMsaView/components/BlastQuery/BlastManualPanel.js

@@ -3,7 +3,6 @@ import { shorten2 } from '@jbrowse/core/util';
 import { Alert, Typography } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
-import { BASE_BLAST_URL } from './consts';
 import ExternalLink from '../../../components/ExternalLink';
 import TextField2 from '../../../components/TextField2';
 import { useQueryRowName } from '../../useQueryRowName';
@@ -14,6 +13,7 @@ import QueryRowSelector from '../QueryRowSelector';
 import SubmitCancelActions from '../SubmitCancelActions';
 import TranscriptSelector from '../TranscriptSelector';
 import { useTranscriptSelection } from '../useTranscriptSelection';
+import { BASE_BLAST_URL } from './consts';
 const useStyles = makeStyles()({
     ncbiLink: {
         wordBreak: 'break-all',

package/dist/LaunchMsaView/components/BlastQuery/BlastPanel.js

@@ -2,12 +2,12 @@ import React, { useState } from 'react';
 import SettingsIcon from '@mui/icons-material/Settings';
 import { IconButton } from '@mui/material';
 import { makeStyles } from 'tss-react/mui';
+import { DEFAULT_EBI_EMAIL, EBI_EMAIL_STORAGE_KEY, } from '../../../utils/ebiJobDispatcher';
+import { useLocalStorage } from '../../../utils/useLocalStorage';
 import BlastAutomaticPanel from './BlastAutomaticPanel';
 import BlastManualPanel from './BlastManualPanel';
 import BlastMethodSelector from './BlastMethodSelector';
 import BlastSettingsDialog from './BlastSettingsDialog';
-import { DEFAULT_EBI_EMAIL, EBI_EMAIL_STORAGE_KEY, } from '../../../utils/ebiJobDispatcher';
-import { useLocalStorage } from '../../../utils/useLocalStorage';
 const useStyles = makeStyles()({
     settingsButton: {
         float: 'right',

package/dist/LaunchMsaView/components/BlastQuery/CachedBlastResults.d.ts

@@ -1,5 +1,17 @@
 import React from 'react';
+import type { CachedBlastResult } from '../../../utils/blastCache';
 import type { AbstractTrackModel, Feature } from '@jbrowse/core/util';
+/**
+ * How the row was produced: `uniprotkb_swissprot / blastp / clustalo`, or
+ * `swissprot / phmmer` for a row phmmer aligned as it searched and that
+ * therefore ran no aligner. Each part is dropped when absent rather than
+ * printed empty — `msaAlgorithm` became optional when phmmer arrived, and a
+ * phmmer row read `(undefined)` until this stopped assuming one.
+ *
+ * `blastProgram` is the older field, written only while the plugin still
+ * queried NCBI directly and blastp/quick-blastp was a real choice.
+ */
+export declare function describeSearch(result: CachedBlastResult): string;
 declare const CachedBlastResults: ({ model, handleClose, feature, }: {
     model: AbstractTrackModel;
     handleClose: () => void;

package/dist/LaunchMsaView/components/BlastQuery/CachedBlastResults.js

@@ -4,9 +4,9 @@ import DeleteIcon from '@mui/icons-material/Delete';
 import { Button, IconButton, List, ListItem, ListItemButton, ListItemText, Typography, } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
+import { featureMatchesId, getGeneIdentifiers, getLinearGenomeView, getSortedTranscriptFeatures, } from '../../util';
 import { blastLaunchViewFromCache } from './blastLaunchView';
 import { useCachedBlastResults } from './useCachedBlastResults';
-import { featureMatchesId, getGeneIdentifiers, getLinearGenomeView, getSortedTranscriptFeatures, } from '../../util';
 const useStyles = makeStyles()({
     header: {
         display: 'flex',
@@ -30,6 +30,25 @@ function getResultDisplayName(result) {
         ? parts.join(' - ')
         : (result.geneId ?? result.transcriptId ?? 'Unknown');
 }
+/**
+ * How the row was produced: `uniprotkb_swissprot / blastp / clustalo`, or
+ * `swissprot / phmmer` for a row phmmer aligned as it searched and that
+ * therefore ran no aligner. Each part is dropped when absent rather than
+ * printed empty — `msaAlgorithm` became optional when phmmer arrived, and a
+ * phmmer row read `(undefined)` until this stopped assuming one.
+ *
+ * `blastProgram` is the older field, written only while the plugin still
+ * queried NCBI directly and blastp/quick-blastp was a real choice.
+ */
+export function describeSearch(result) {
+    return [
+        result.blastDatabase,
+        result.searchProgram ?? result.blastProgram ?? 'blastp',
+        result.msaAlgorithm,
+    ]
+        .filter(Boolean)
+        .join(' / ');
+}
 const CachedBlastResults = observer(function ({ model, handleClose, feature, }) {
     const { classes } = useStyles();
     const view = getLinearGenomeView(model);
@@ -83,6 +102,6 @@ const CachedBlastResults = observer(function ({ model, handleClose, feature, })
             React.createElement(ListItemButton, { onClick: () => {
                     handleUseCached(result);
                 } },
-                React.createElement(ListItemText, { primary: `${getResultDisplayName(result)} - ${result.blastDatabase}${result.blastProgram ? `/${result.blastProgram}` : ''} (${result.msaAlgorithm})`, secondary: `${new Date(result.timestamp).toLocaleString()} - Seq: ${result.proteinSequence.slice(0, 30)}...` }))))))));
+                React.createElement(ListItemText, { primary: `${getResultDisplayName(result)} - ${describeSearch(result)}`, secondary: `${new Date(result.timestamp).toLocaleString()} - Seq: ${result.proteinSequence.slice(0, 30)}...` }))))))));
 });
 export default CachedBlastResults;

package/dist/LaunchMsaView/components/BlastQuery/CachedBlastResults.test.d.ts

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

package/dist/LaunchMsaView/components/BlastQuery/CachedBlastResults.test.js

@@ -0,0 +1,29 @@
+import { expect, test } from 'vitest';
+import { describeSearch } from './CachedBlastResults';
+const base = {
+    id: 'k',
+    proteinSequence: 'MKV',
+    blastDatabase: 'uniprotkb_swissprot',
+    msa: '',
+    tree: '',
+    treeMetadata: '{}',
+    rid: 'r',
+    timestamp: 0,
+};
+function row(fields) {
+    return { ...base, ...fields };
+}
+test('a blastp row names its database, program and aligner', () => {
+    expect(describeSearch(row({ searchProgram: 'blastp', msaAlgorithm: 'muscle' }))).toBe('uniprotkb_swissprot / blastp / muscle');
+});
+// phmmer aligns as it searches, so its rows carry no msaAlgorithm at all --
+// which read as "(undefined)" while this assumed one
+test('a phmmer row names no aligner, because none ran', () => {
+    expect(describeSearch(row({ blastDatabase: 'swissprot', searchProgram: 'phmmer' }))).toBe('swissprot / phmmer');
+});
+test('a row cached before searchProgram existed reads as blastp', () => {
+    expect(describeSearch(row({ msaAlgorithm: 'clustalo' }))).toBe('uniprotkb_swissprot / blastp / clustalo');
+});
+test('a row from the NCBI era keeps the program it recorded', () => {
+    expect(describeSearch(row({ blastProgram: 'quick-blastp', msaAlgorithm: 'clustalo' }))).toBe('uniprotkb_swissprot / quick-blastp / clustalo');
+});

package/dist/LaunchMsaView/components/BlastQuery/MsaAlgorithmSelect.js

@@ -1,7 +1,7 @@
 import React from 'react';
 import { MenuItem } from '@mui/material';
-import { msaAlgorithms } from './consts';
 import TextField2 from '../../../components/TextField2';
+import { msaAlgorithms } from './consts';
 export default function MsaAlgorithmSelect({ value, onChange, className, }) {
     return (React.createElement(TextField2, { variant: "outlined", label: "MSA Algorithm", className: className, select: true, value: value, onChange: event => {
             onChange(event.target.value);

package/dist/LaunchMsaView/components/BlastQuery/consts.d.ts

@@ -17,3 +17,31 @@ export type MsaAlgorithm = (typeof msaAlgorithms)[number];
 export declare const blastDatabaseOptions: readonly ["uniprotkb_swissprot", "uniprotkb", "pan_proteomes", "uniprotkb_trembl"];
 export type BlastDatabase = (typeof blastDatabaseOptions)[number];
 export declare const defaultBlastDatabase: BlastDatabase;
+export declare const searchPrograms: readonly ["blastp", "phmmer"];
+export type SearchProgram = (typeof searchPrograms)[number];
+/**
+ * phmmer offers PDB, AlphaFold, Ensembl Genomes, MEROPS and ChEMBL too, but
+ * targets outside UniProt carry no OS=/OX= in their description, so those rows
+ * would lose their species and common name. Only the databases that label their
+ * hits are offered.
+ */
+export declare const phmmerDatabaseOptions: readonly ["swissprot", "uniprotkb", "uniprotrefprot"];
+export type PhmmerDatabase = (typeof phmmerDatabaseOptions)[number];
+export declare const defaultPhmmerDatabase: PhmmerDatabase;
+/**
+ * A program together with a database that program actually has.
+ *
+ * The pair travels as one value because neither service knows the other's
+ * database names — `swissprot` is a phmmer database and `uniprotkb_swissprot` a
+ * blastp one — so a program held apart from its database can drift into a
+ * combination EBI answers with a 400, minutes after the user pressed Submit.
+ */
+export type SearchChoice = {
+    program: 'blastp';
+    database: BlastDatabase;
+} | {
+    program: 'phmmer';
+    database: PhmmerDatabase;
+};
+export declare function defaultSearchFor(program: SearchProgram): SearchChoice;
+export declare function databaseOptionsFor(program: SearchProgram): readonly ["uniprotkb_swissprot", "uniprotkb", "pan_proteomes", "uniprotkb_trembl"] | readonly ["swissprot", "uniprotkb", "uniprotrefprot"];

package/dist/LaunchMsaView/components/BlastQuery/consts.js

@@ -22,3 +22,24 @@ export const blastDatabaseOptions = [
 // curated, so it returns roughly one good sequence per species rather than the
 // many near-identical TrEMBL entries an alignment reads poorly
 export const defaultBlastDatabase = 'uniprotkb_swissprot';
+export const searchPrograms = ['blastp', 'phmmer'];
+/**
+ * phmmer offers PDB, AlphaFold, Ensembl Genomes, MEROPS and ChEMBL too, but
+ * targets outside UniProt carry no OS=/OX= in their description, so those rows
+ * would lose their species and common name. Only the databases that label their
+ * hits are offered.
+ */
+export const phmmerDatabaseOptions = [
+    'swissprot',
+    'uniprotkb',
+    'uniprotrefprot',
+];
+export const defaultPhmmerDatabase = 'swissprot';
+export function defaultSearchFor(program) {
+    return program === 'phmmer'
+        ? { program, database: defaultPhmmerDatabase }
+        : { program, database: defaultBlastDatabase };
+}
+export function databaseOptionsFor(program) {
+    return program === 'phmmer' ? phmmerDatabaseOptions : blastDatabaseOptions;
+}

package/dist/LaunchMsaView/components/BlastQuery/searchChoiceStorage.d.ts

@@ -0,0 +1,7 @@
+import type { MsaAlgorithm, SearchChoice } from './consts';
+export declare const SEARCH_CHOICE_STORAGE_KEY = "msaView-blastSearch";
+export declare const MSA_ALGORITHM_STORAGE_KEY = "msaView-msaAlgorithm";
+export declare function validSearchChoice(stored: unknown): SearchChoice;
+export declare function validMsaAlgorithm(stored: unknown): MsaAlgorithm;
+export declare function useStoredSearchChoice(): readonly [SearchChoice, (choice: SearchChoice) => void];
+export declare function useStoredMsaAlgorithm(): readonly ["clustalo" | "muscle" | "kalign" | "mafft", (algorithm: MsaAlgorithm) => void];

package/dist/LaunchMsaView/components/BlastQuery/searchChoiceStorage.js

@@ -0,0 +1,42 @@
+import { useLocalStorage } from '../../../utils/useLocalStorage';
+import { databaseOptionsFor, defaultSearchFor, msaAlgorithms, searchPrograms, } from './consts';
+// The panel reopens on the last search run rather than on the defaults, the way
+// the Orthologs tab remembers its source.
+//
+// The program and its database stay ONE stored value for the reason consts.ts
+// keeps them one state: neither service knows the other's database names. What
+// comes back is checked against the current options before it is used — an
+// option this plugin has since dropped would otherwise reach EBI and come back
+// a 400, minutes after the user pressed Submit.
+export const SEARCH_CHOICE_STORAGE_KEY = 'msaView-blastSearch';
+export const MSA_ALGORITHM_STORAGE_KEY = 'msaView-msaAlgorithm';
+const defaultSearch = defaultSearchFor('blastp');
+const defaultMsaAlgorithm = 'clustalo';
+export function validSearchChoice(stored) {
+    const { program, database } = (stored ?? {});
+    const known = searchPrograms.find(p => p === program);
+    return known && databaseOptionsFor(known).some(d => d === database)
+        ? { program: known, database }
+        : defaultSearch;
+}
+export function validMsaAlgorithm(stored) {
+    return msaAlgorithms.find(a => a === stored) ?? defaultMsaAlgorithm;
+}
+export function useStoredSearchChoice() {
+    const [stored, setStored] = useLocalStorage(SEARCH_CHOICE_STORAGE_KEY, defaultSearch);
+    return [
+        validSearchChoice(stored),
+        (choice) => {
+            setStored(choice);
+        },
+    ];
+}
+export function useStoredMsaAlgorithm() {
+    const [stored, setStored] = useLocalStorage(MSA_ALGORITHM_STORAGE_KEY, defaultMsaAlgorithm);
+    return [
+        validMsaAlgorithm(stored),
+        (algorithm) => {
+            setStored(algorithm);
+        },
+    ];
+}

package/dist/LaunchMsaView/components/BlastQuery/searchChoiceStorage.test.d.ts

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

package/dist/LaunchMsaView/components/BlastQuery/searchChoiceStorage.test.js

@@ -0,0 +1,32 @@
+import { expect, test } from 'vitest';
+import { validMsaAlgorithm, validSearchChoice } from './searchChoiceStorage';
+test('a stored pair both services recognise comes back as it went in', () => {
+    expect(validSearchChoice({ program: 'phmmer', database: 'swissprot' })).toEqual({
+        program: 'phmmer',
+        database: 'swissprot',
+    });
+});
+test('a database the stored program does not have falls back to the defaults', () => {
+    // uniprotkb_swissprot is blastp's name for it; sending it to phmmer is a 400
+    // from EBI minutes after Submit
+    expect(validSearchChoice({ program: 'phmmer', database: 'uniprotkb_swissprot' })).toEqual({ program: 'blastp', database: 'uniprotkb_swissprot' });
+    // uniprotkb_reference_proteomes shipped as a menu entry EBI rejects, and 3.0.0
+    // is old enough that someone's storage still holds it
+    expect(validSearchChoice({
+        program: 'blastp',
+        database: 'uniprotkb_reference_proteomes',
+    })).toEqual({ program: 'blastp', database: 'uniprotkb_swissprot' });
+});
+test('storage holding something else entirely falls back rather than throwing', () => {
+    for (const stored of [null, undefined, 'blastp', 42, {}, []]) {
+        expect(validSearchChoice(stored)).toEqual({
+            program: 'blastp',
+            database: 'uniprotkb_swissprot',
+        });
+    }
+});
+test('an unknown algorithm falls back to clustalo', () => {
+    expect(validMsaAlgorithm('mafft')).toBe('mafft');
+    expect(validMsaAlgorithm('t_coffee')).toBe('clustalo');
+    expect(validMsaAlgorithm(null)).toBe('clustalo');
+});

package/dist/LaunchMsaView/components/ManualMSALoader/ManualMSALoader.js

@@ -3,7 +3,6 @@ import { FileSelector } from '@jbrowse/core/ui';
 import { FormControl, FormControlLabel, Radio, RadioGroup } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
-import { launchView } from './launchView';
 import TextField2 from '../../../components/TextField2';
 import { useQueryRowName } from '../../useQueryRowName';
 import { getGeneDisplayName, getLinearGenomeView } from '../../util';
@@ -12,6 +11,7 @@ import QueryRowSelector from '../QueryRowSelector';
 import SubmitCancelActions from '../SubmitCancelActions';
 import TranscriptSelector from '../TranscriptSelector';
 import { useTranscriptSelection } from '../useTranscriptSelection';
+import { launchView } from './launchView';
 const useStyles = makeStyles()({
     textAreaFont: {
         fontFamily: 'Courier New',

package/dist/LaunchMsaView/components/OrthologQuery/OrthologPanel.js

@@ -2,18 +2,19 @@ import React, { useMemo, useState } from 'react';
 import { Typography } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
-import OrthologSourceSelect, { ORTHOLOG_SOURCE_STORAGE_KEY, } from './OrthologSourceSelect';
-import QuerySpeciesSelect from './QuerySpeciesSelect';
-import { orthologLaunchView } from './orthologLaunchView';
 import TextField2 from '../../../components/TextField2';
 import { defaultMaxSpecies } from '../../../utils/ncbiOrthologs';
 import { useLocalStorage } from '../../../utils/useLocalStorage';
 import { getGeneDisplayName, getGeneIdentifiers, getLinearGenomeView, getTranscriptDisplayName, } from '../../util';
 import MsaAlgorithmSelect from '../BlastQuery/MsaAlgorithmSelect';
+import { useStoredMsaAlgorithm } from '../BlastQuery/searchChoiceStorage';
 import LaunchPanelContent from '../LaunchPanelContent';
 import SubmitCancelActions from '../SubmitCancelActions';
 import TranscriptSelector from '../TranscriptSelector';
 import { useTranscriptSelection } from '../useTranscriptSelection';
+import OrthologSourceSelect, { ORTHOLOG_SOURCE_STORAGE_KEY, } from './OrthologSourceSelect';
+import QuerySpeciesSelect from './QuerySpeciesSelect';
+import { orthologLaunchView } from './orthologLaunchView';
 const useStyles = makeStyles()({
     selectField: {
         width: 180,
@@ -25,7 +26,7 @@ const OrthologPanel = observer(function ({ handleClose, feature, model, }) {
     const [launchViewError, setLaunchViewError] = useState();
     const [taxId, setTaxId] = useState(9606);
     const [source, setSource] = useLocalStorage(ORTHOLOG_SOURCE_STORAGE_KEY, 'ncbi');
-    const [msaAlgorithm, setMsaAlgorithm] = useState('clustalo');
+    const [msaAlgorithm, setMsaAlgorithm] = useStoredMsaAlgorithm();
     const [maxSpecies, setMaxSpecies] = useState(String(defaultMaxSpecies));
     const geneCandidates = useMemo(() => getGeneIdentifiers(feature), [feature]);
     const transcriptSelection = useTranscriptSelection({ feature, view });

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

@@ -2,8 +2,8 @@
 import React from 'react';
 import { cleanup, render, screen } from '@testing-library/react';
 import { afterEach, beforeEach, expect, test, vi } from 'vitest';
-import SubmitCancelActions from './SubmitCancelActions';
 import { LAUNCH_PLACEMENT_KEY } from '../../utils/workspaces';
+import SubmitCancelActions from './SubmitCancelActions';
 // getSession walks the MST tree, and this component only wants the two actions
 // off the far end of that walk
 vi.mock('@jbrowse/core/util', () => ({

package/dist/LaunchMsaView/components/useFeatureSequence.js

@@ -1,7 +1,7 @@
 import { getSession } from '@jbrowse/core/util';
+import { useFetch } from '../../utils/useFetch';
 import { getProteinSequenceFromFeature } from './calculateProteinSequence';
 import { fetchSeq } from './fetchSeq';
-import { useFetch } from '../../utils/useFetch';
 export function useFeatureSequence({ view, feature, }) {
     const assemblyName = view?.assemblyNames?.[0];
     const { data: sequence, error } = useFetch(feature && assemblyName

package/dist/LaunchMsaView/detectQueryRow.d.ts

@@ -19,5 +19,18 @@ export interface QueryRowMatch {
     /** identity over the compared region, 0-1 */
     identity: number;
 }
-export declare function detectQueryRow(msaText: string, proteinSequence: string): QueryRowMatch | undefined;
-export declare function getMsaRowNames(msaText: string): string[];
+export interface MsaQueryRow {
+    /** every row name, in file order, for the picker to offer */
+    names: string[];
+    /** the row whose residues are the query's, if one of them is */
+    match?: QueryRowMatch;
+}
+/**
+ * The picker's whole answer for a pasted alignment: its row names, and which of
+ * them is the query.
+ *
+ * One function rather than two because there is one parse. Both answers were
+ * wanted on every keystroke in the paste box, and asking separately parsed a
+ * few-hundred-row alignment twice per character.
+ */
+export declare function findQueryRow(msaText: string, proteinSequence: string): MsaQueryRow;

package/dist/LaunchMsaView/detectQueryRow.js

@@ -36,23 +36,32 @@ const SIMILARITY_FLOOR = 0.9;
  * user is still typing.
  */
 const PARTIAL_COVERAGE_FLOOR = 0.5;
-export function detectQueryRow(msaText, proteinSequence) {
-    const query = normalize(proteinSequence);
-    if (!query || !msaText.trim()) {
-        return undefined;
+/**
+ * The picker's whole answer for a pasted alignment: its row names, and which of
+ * them is the query.
+ *
+ * One function rather than two because there is one parse. Both answers were
+ * wanted on every keystroke in the paste box, and asking separately parsed a
+ * few-hundred-row alignment twice per character.
+ */
+export function findQueryRow(msaText, proteinSequence) {
+    if (!msaText.trim()) {
+        return { names: [] };
     }
-    let names;
     let parsed;
     try {
-        const msa = parseMSA(msaText);
-        names = msa.getNames();
-        parsed = msa;
+        parsed = parseMSA(msaText);
     }
     catch {
         // a half-pasted alignment throws here on every keystroke; the caller shows
         // the field rather than an error
-        return undefined;
+        return { names: [] };
     }
+    const names = parsed.getNames();
+    const query = normalize(proteinSequence);
+    return { names, match: query ? bestMatch(parsed, names, query) : undefined };
+}
+function bestMatch(parsed, names, query) {
     const candidates = [];
     for (const name of names) {
         const row = normalize(getUngappedSequence(parsed.getRow(name)));
@@ -77,18 +86,8 @@ export function detectQueryRow(msaText, proteinSequence) {
             candidates.push({ name, quality: 'similar', identity });
         }
     }
-    const order = ['exact', 'partial', 'similar'];
+    // an exact match returns above, so only these two can be here
+    const order = ['partial', 'similar'];
     return candidates.sort((a, b) => order.indexOf(a.quality) - order.indexOf(b.quality) ||
         b.identity - a.identity)[0];
 }
-export function getMsaRowNames(msaText) {
-    if (!msaText.trim()) {
-        return [];
-    }
-    try {
-        return parseMSA(msaText).getNames();
-    }
-    catch {
-        return [];
-    }
-}