jbrowse-plugin-protein3d 0.10.0 → 0.11.0

package/README.md

@@ -8,8 +8,9 @@ The major workflow enabled by this is
   mouseover between genome and structure
 
 It has features to automatically look up a protein structure of interest using
-the UniProt ID mapping API to connect to AlphaFoldDB, and can also use Foldseek
-to look up related structures also
+the UniProt ID mapping API to connect to AlphaFoldDB, lists the experimental PDB
+entries SIFTS maps to that UniProt entry, and can also use Foldseek to look up
+related structures
 
 ## Coordinate-mapping harness
 
@@ -48,6 +49,15 @@ use it on any species there
 
 See [DEVELOPERS.md](DEVELOPERS.md)
 
+## How it works
+
+Notes on the parts that are easy to get subtly wrong, written for someone
+extending the plugin or checking what a number on screen means:
+
+- [Residue numbering](docs/residue-numbering.md): how a paper's R248 becomes
+  position 154 in the file, `label_seq_id` 155 for Mol\*, and the codon on
+  chr17, and how a session spec names a residue the literature's way.
+
 ## Publishing
 
 just push a new tag using e.g.

package/dist/LaunchProteinView/components/LaunchProteinViewDialog.js

@@ -5,6 +5,7 @@ import { Tab, Tabs } from '@mui/material';
 import AlphaFoldDBSearch from './AlphaFoldDBSearch';
 import FoldseekSearch from './FoldseekSearch';
 import HelpButton from './HelpButton';
+import PdbSearch from './PdbSearch';
 import TabPanel from './TabPanel';
 import UserProvidedStructure from './UserProvidedStructure';
 import { DEFAULT_ALIGNMENT_ALGORITHM } from '../../ProteinView/types';
@@ -21,12 +22,15 @@ export default function LaunchProteinViewDialog({ handleClose, feature, model, }
                 setChoice(val);
             } },
             React.createElement(Tab, { value: 0, label: "AlphaFoldDB search" }),
-            React.createElement(Tab, { value: 1, label: "Foldseek search" }),
-            React.createElement(Tab, { value: 2, label: "Open file manually" })),
+            React.createElement(Tab, { value: 1, label: "PDB search" }),
+            React.createElement(Tab, { value: 2, label: "Foldseek search" }),
+            React.createElement(Tab, { value: 3, label: "Open file manually" })),
         React.createElement(TabPanel, { value: choice, index: 0 },
             React.createElement(AlphaFoldDBSearch, { session: session, view: view, feature: feature, handleClose: handleClose, alignmentAlgorithm: alignmentAlgorithm, onAlignmentAlgorithmChange: setAlignmentAlgorithm })),
         React.createElement(TabPanel, { value: choice, index: 1 },
-            React.createElement(FoldseekSearch, { session: session, view: view, feature: feature, handleClose: handleClose })),
+            React.createElement(PdbSearch, { session: session, view: view, feature: feature, handleClose: handleClose, alignmentAlgorithm: alignmentAlgorithm, onAlignmentAlgorithmChange: setAlignmentAlgorithm })),
         React.createElement(TabPanel, { value: choice, index: 2 },
+            React.createElement(FoldseekSearch, { session: session, view: view, feature: feature, handleClose: handleClose })),
+        React.createElement(TabPanel, { value: choice, index: 3 },
             React.createElement(UserProvidedStructure, { session: session, view: view, feature: feature, handleClose: handleClose, alignmentAlgorithm: alignmentAlgorithm, onAlignmentAlgorithmChange: setAlignmentAlgorithm }))));
 }

package/dist/LaunchProteinView/components/PdbResultsTable.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { PdbStructureEntry } from '../services/pdbeBestStructures';
+export default function PdbResultsTable({ entries, selectedPdbId, onSelect, }: {
+    entries: PdbStructureEntry[];
+    selectedPdbId?: string;
+    onSelect: (pdbId: string) => void;
+}): React.JSX.Element;

package/dist/LaunchProteinView/components/PdbResultsTable.js

@@ -0,0 +1,70 @@
+import React from 'react';
+import { Paper, Radio, Table, TableBody, TableCell, TableContainer, TableHead, TableRow, Typography, } from '@mui/material';
+import { makeStyles } from 'tss-react/mui';
+import ExternalLink from '../../components/ExternalLink';
+import { rcsbEntryUrl } from '../services/pdbeBestStructures';
+const useStyles = makeStyles()(theme => ({
+    tableContainer: {
+        maxHeight: 300,
+    },
+    headerCell: {
+        fontWeight: 'bold',
+        backgroundColor: theme.palette.mode === 'dark'
+            ? theme.palette.grey[900]
+            : theme.palette.grey[100],
+    },
+    selectedRow: {
+        backgroundColor: theme.palette.action.selected,
+    },
+    clickableRow: {
+        cursor: 'pointer',
+        '&:hover': {
+            backgroundColor: theme.palette.action.hover,
+        },
+    },
+}));
+const MAX_ROWS = 100;
+export default function PdbResultsTable({ entries, selectedPdbId, onSelect, }) {
+    const { classes } = useStyles();
+    const shown = entries.slice(0, MAX_ROWS);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Typography, { variant: "body2", color: "textSecondary" },
+            entries.length,
+            " PDB entries, ranked by PDBe on coverage and resolution",
+            entries.length > shown.length
+                ? ` (showing the first ${MAX_ROWS})`
+                : ''),
+        React.createElement(TableContainer, { component: Paper, className: classes.tableContainer },
+            React.createElement(Table, { size: "small", stickyHeader: true, "data-testid": "pdb-results-table" },
+                React.createElement(TableHead, null,
+                    React.createElement(TableRow, null,
+                        React.createElement(TableCell, { className: classes.headerCell, padding: "checkbox" }),
+                        React.createElement(TableCell, { className: classes.headerCell }, "PDB ID"),
+                        React.createElement(TableCell, { className: classes.headerCell }, "Method"),
+                        React.createElement(TableCell, { className: classes.headerCell }, "Resolution"),
+                        React.createElement(TableCell, { className: classes.headerCell }, "UniProt residues"),
+                        React.createElement(TableCell, { className: classes.headerCell }, "Coverage"),
+                        React.createElement(TableCell, { className: classes.headerCell }, "Chains"))),
+                React.createElement(TableBody, null, shown.map(entry => {
+                    const selected = entry.pdbId === selectedPdbId;
+                    return (React.createElement(TableRow, { key: entry.pdbId, className: `${classes.clickableRow} ${selected ? classes.selectedRow : ''}`, onClick: () => {
+                            onSelect(entry.pdbId);
+                        } },
+                        React.createElement(TableCell, { padding: "checkbox" },
+                            React.createElement(Radio, { checked: selected, size: "small" })),
+                        React.createElement(TableCell, null,
+                            React.createElement(ExternalLink, { href: rcsbEntryUrl(entry.pdbId) }, entry.pdbId.toUpperCase())),
+                        React.createElement(TableCell, null, entry.experimentalMethod),
+                        React.createElement(TableCell, null, entry.resolution === undefined
+                            ? '-'
+                            : `${entry.resolution.toFixed(2)} Å`),
+                        React.createElement(TableCell, null,
+                            entry.unpStart,
+                            "-",
+                            entry.unpEnd),
+                        React.createElement(TableCell, null,
+                            (entry.coverage * 100).toFixed(0),
+                            "%"),
+                        React.createElement(TableCell, null, entry.chains.join(', '))));
+                }))))));
+}

package/dist/LaunchProteinView/components/PdbSearch.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { AlignmentAlgorithm } from '../../ProteinView/types';
+import type { AbstractSessionModel, Feature } from '@jbrowse/core/util';
+import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
+declare const PdbSearch: ({ feature, session, view, handleClose, alignmentAlgorithm, onAlignmentAlgorithmChange, }: {
+    feature: Feature;
+    session: AbstractSessionModel;
+    view: LinearGenomeViewModel;
+    handleClose: () => void;
+    alignmentAlgorithm: AlignmentAlgorithm;
+    onAlignmentAlgorithmChange: (algorithm: AlignmentAlgorithm) => void;
+}) => React.JSX.Element;
+export default PdbSearch;

package/dist/LaunchProteinView/components/PdbSearch.js

@@ -0,0 +1,92 @@
+import React, { useState } from 'react';
+import { ErrorMessage, LoadingEllipses } from '@jbrowse/core/ui';
+import { DialogActions, DialogContent, TextField, Typography, } from '@mui/material';
+import { observer } from 'mobx-react';
+import { makeStyles } from 'tss-react/mui';
+import IdentifierSelector from './IdentifierSelector';
+import PdbResultsTable from './PdbResultsTable';
+import ProteinViewActions from './ProteinViewActions';
+import TranscriptSelector from './TranscriptSelector';
+import UniProtIdInput from './UniProtIdInput';
+import UniProtResultsTable from './UniProtResultsTable';
+import ExternalLink from '../../components/ExternalLink';
+import usePdbBestStructures from '../hooks/usePdbBestStructures';
+import useTranscriptIsoformSelection from '../hooks/useTranscriptIsoformSelection';
+import useUniProtIdLookup from '../hooks/useUniProtIdLookup';
+import { getPdbStructureUrl, uniprotEntryUrl } from '../utils/structureUrls';
+const useStyles = makeStyles()({
+    dialogContent: {
+        width: '80em',
+        '& > *': {
+            marginBottom: 20,
+        },
+        '& > *:last-child': {
+            marginBottom: 0,
+        },
+    },
+    endRow: {
+        display: 'flex',
+        flexDirection: 'row',
+        gap: 12,
+        alignItems: 'flex-start',
+    },
+});
+// Experimental structures of the gene's protein, found through SIFTS: PDBe
+// lists every entry mapped to the UniProt accession, ranked on coverage and
+// resolution, so a reader who does not know a PDB id can still reach one.
+// A crystal is usually a fragment, often with partners, so the view aligns
+// the transcript to it after launch rather than expecting a sequence match
+// here.
+const PdbSearch = observer(function PdbSearch({ feature, session, view, handleClose, alignmentAlgorithm, onAlignmentAlgorithmChange, }) {
+    const { classes } = useStyles();
+    const lookup = useUniProtIdLookup({ feature, view });
+    const { uniprotId, isAutoMode, isLookupLoading } = lookup;
+    const { entries, error: pdbError, isLoading: isPdbLoading, } = usePdbBestStructures(uniprotId);
+    const [userPdbId, setUserPdbId] = useState();
+    const { transcripts, isoformSequences, isLoading: isIsoformLoading, error: isoformError, selectedTranscriptId, setSelectedTranscriptId, selectedTranscript, selectedIsoform, } = useTranscriptIsoformSelection({ feature, view, resetKey: uniprotId });
+    const selectedPdbId = userPdbId && entries?.some(e => e.pdbId === userPdbId)
+        ? userPdbId
+        : entries?.[0]?.pdbId;
+    const loadingStatuses = [
+        isLookupLoading && 'Looking up UniProt ID',
+        isIsoformLoading && 'Loading protein sequences from transcript isoforms',
+        isPdbLoading && 'Listing PDB entries from PDBe',
+    ].filter((s) => !!s);
+    const isLoading = loadingStatuses.length > 0;
+    const error = isLoading
+        ? undefined
+        : (isoformError ?? lookup.lookupError ?? pdbError);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(DialogContent, { className: classes.dialogContent },
+            error ? React.createElement(ErrorMessage, { error: error }) : null,
+            React.createElement(UniProtIdInput, { lookupMode: lookup.lookupMode, onLookupModeChange: lookup.setLookupMode, manualUniprotId: lookup.manualUniprotId, onManualUniprotIdChange: lookup.setManualUniprotId, featureUniprotId: lookup.featureUniprotId, endContent: lookup.showIdentifierSelector ? (React.createElement("div", { className: classes.endRow },
+                    React.createElement(IdentifierSelector, { recognizedIds: lookup.recognizedIds, geneName: lookup.geneName, selectedId: lookup.selectedQueryId, onSelectedIdChange: lookup.setSelectedQueryId }),
+                    React.createElement(TextField, { size: "small", label: "Organism (NCBI taxon)", helperText: "Scopes the gene-name search", value: lookup.taxonId, onChange: event => {
+                            lookup.setTaxonId(event.target.value);
+                        }, placeholder: String(lookup.effectiveTaxonId), slotProps: { inputLabel: { shrink: true } }, sx: { width: 180 } }))) : null }),
+            loadingStatuses.map(status => (React.createElement(LoadingEllipses, { key: status, variant: "subtitle2", message: status }))),
+            isAutoMode && lookup.uniprotEntries.length > 0 ? (React.createElement(React.Fragment, null,
+                React.createElement(Typography, { variant: "body2", color: "textSecondary" },
+                    "Searched UniProt by ",
+                    lookup.searchDescription),
+                React.createElement(UniProtResultsTable, { entries: lookup.uniprotEntries, selectedAccession: lookup.selectedTableAccession, onSelect: lookup.setSelectedUniprotId }))) : null,
+            isAutoMode &&
+                !isLookupLoading &&
+                lookup.uniprotEntries.length === 0 ? (React.createElement(Typography, { variant: "body2", color: "textSecondary" },
+                "No UniProt entries found for ",
+                lookup.searchDescriptionOr,
+                ". Try a different identifier above, or search",
+                ' ',
+                React.createElement(ExternalLink, { href: "https://www.uniprot.org/" }, "UniProt"),
+                ' ',
+                "directly and use \"Enter manually\".")) : null,
+            uniprotId && entries && !isPdbLoading ? (entries.length > 0 ? (React.createElement(PdbResultsTable, { entries: entries, selectedPdbId: selectedPdbId, onSelect: setUserPdbId })) : (React.createElement(Typography, null,
+                "PDBe lists no experimental structure for",
+                ' ',
+                React.createElement(ExternalLink, { href: uniprotEntryUrl(uniprotId) }, uniprotId),
+                ". The AlphaFoldDB tab has a predicted one."))) : null,
+            isoformSequences && selectedTranscript ? (React.createElement(TranscriptSelector, { val: selectedTranscriptId, setVal: setSelectedTranscriptId, feature: feature, isoforms: transcripts, isoformSequences: isoformSequences })) : null),
+        React.createElement(DialogActions, null,
+            React.createElement(ProteinViewActions, { handleClose: handleClose, uniprotId: uniprotId, userSelectedProteinSequence: selectedIsoform, selectedTranscript: selectedTranscript, url: selectedPdbId ? getPdbStructureUrl(selectedPdbId) : undefined, feature: feature, view: view, session: session, alignmentAlgorithm: alignmentAlgorithm, onAlignmentAlgorithmChange: onAlignmentAlgorithmChange, isLoading: isLoading, error: error }))));
+});
+export default PdbSearch;

package/dist/LaunchProteinView/components/ProteinViewActions.js

@@ -16,6 +16,7 @@ export default function ProteinViewActions({ handleClose, uniprotId, userSelecte
         uniprotId,
         userSelectedProteinSequence,
         selectedTranscript,
+        url,
     });
     // Disable launch while loading — SWR's keepPreviousData would otherwise let
     // a user click Launch on stale results (wrong UniProt ID) during a refetch.

package/dist/LaunchProteinView/hooks/useAlphaFoldDBSearch.d.ts

@@ -1,34 +1,18 @@
 import type { SequenceSearchType } from './useAlphaFoldSequenceSearch';
-import type { LookupMode } from '../components/UniProtIdInput';
 import type { Feature } from '@jbrowse/core/util';
 import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
 export default function useAlphaFoldDBSearch({ feature, view, }: {
     feature: Feature;
     view: LinearGenomeViewModel;
 }): {
-    lookupMode: LookupMode;
-    setLookupMode: import("react").Dispatch<import("react").SetStateAction<LookupMode>>;
-    manualUniprotId: string;
-    setManualUniprotId: import("react").Dispatch<import("react").SetStateAction<string>>;
-    taxonId: string;
-    setTaxonId: import("react").Dispatch<import("react").SetStateAction<string>>;
-    effectiveTaxonId: number;
-    selectedQueryId: string;
-    setSelectedQueryId: import("react").Dispatch<import("react").SetStateAction<string>>;
     sequenceSearchType: SequenceSearchType;
     setSequenceSearchType: import("react").Dispatch<import("react").SetStateAction<SequenceSearchType>>;
-    selectedUniprotId: string | undefined;
-    setSelectedUniprotId: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     userSelection: string | undefined;
     setUserSelection: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     transcriptOptions: Feature[];
     selectedTranscript: Feature | undefined;
     isoformSequences: import("../utils/util").IsoformSequences | undefined;
     userSelectedProteinSequence: import("../utils/util").IsoformSequence | undefined;
-    uniprotEntries: import("../services/lookupMethods").UniProtEntry[];
-    recognizedIds: string[];
-    geneName: string | undefined;
-    featureUniprotId: string | undefined;
     uniprotId: string | undefined;
     url: string | undefined;
     confidenceUrl: string | undefined;
@@ -36,15 +20,34 @@ export default function useAlphaFoldDBSearch({ feature, view, }: {
     error: any;
     loadingStatuses: string[];
     isSequenceSearchLoading: boolean;
-    showIdentifierSelector: boolean;
     showStructureSelectors: boolean;
     sequencesMatch: boolean | undefined;
-    searchDescription: string;
-    searchDescriptionOr: string;
-    selectedTableAccession: string | undefined;
     showUniprotResults: boolean;
     showNoResults: boolean;
     showSequenceSearchStatus: boolean;
     showAlphaFoldDBSearchStatus: boolean;
     isLoading: boolean;
+    lookupMode: import("../components/UniProtIdInput").LookupMode;
+    setLookupMode: import("react").Dispatch<import("react").SetStateAction<import("../components/UniProtIdInput").LookupMode>>;
+    manualUniprotId: string;
+    setManualUniprotId: import("react").Dispatch<import("react").SetStateAction<string>>;
+    taxonId: string;
+    setTaxonId: import("react").Dispatch<import("react").SetStateAction<string>>;
+    effectiveTaxonId: number;
+    selectedQueryId: string;
+    setSelectedQueryId: import("react").Dispatch<import("react").SetStateAction<string>>;
+    selectedUniprotId: string | undefined;
+    setSelectedUniprotId: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
+    selectedTableAccession: string | undefined;
+    uniprotEntries: import("../services/lookupMethods").UniProtEntry[];
+    isLookupLoading: boolean;
+    lookupError: any;
+    featureUniprotId: string | undefined;
+    recognizedIds: string[];
+    geneName: string | undefined;
+    isAutoMode: boolean;
+    isSequenceMode: boolean;
+    showIdentifierSelector: boolean;
+    searchDescription: string;
+    searchDescriptionOr: string;
 };

package/dist/LaunchProteinView/hooks/useAlphaFoldDBSearch.js

@@ -1,65 +1,14 @@
 import { useState } from 'react';
-import { getConf } from '@jbrowse/core/configuration';
-import { getSession } from '@jbrowse/core/util';
 import useAlphaFoldData from './useAlphaFoldData';
 import useAlphaFoldSequenceSearch from './useAlphaFoldSequenceSearch';
-import useDebouncedValue from './useDebouncedValue';
 import useTranscriptIsoformSelection from './useTranscriptIsoformSelection';
-import useUniProtSearch from './useUniProtSearch';
-import getSearchDescription from '../utils/getSearchDescription';
-import { extractFeatureIdentifiers, extractTaxonId, stripStopCodon, } from '../utils/util';
+import useUniProtIdLookup from './useUniProtIdLookup';
+import { stripStopCodon } from '../utils/util';
 export default function useAlphaFoldDBSearch({ feature, view, }) {
-    const [lookupMode, setLookupMode] = useState('auto');
-    const [manualUniprotId, setManualUniprotId] = useState('');
-    const [taxonIdInput, setTaxonIdInput] = useState('');
-    const geneIds = extractFeatureIdentifiers(feature);
-    // The gene-name UniProt search is ambiguous across species, so scope it to
-    // the assembly's organism. jb2hubs assemblies carry the NCBI taxon in the
-    // reference-sequence track metadata (UCSC: metadata.taxId, GenArk:
-    // metadata.ucsc.taxId). Falls back to human via searchUniProtEntries when
-    // absent; a user override (taxonIdInput) always wins.
-    const assemblyName = view.assemblyNames[0];
-    const assembly = assemblyName
-        ? getSession(view).assemblyManager.get(assemblyName)
-        : undefined;
-    const assemblyTaxonId = assembly
-        ? extractTaxonId(getConf(assembly, ['sequence', 'metadata']))
-        : undefined;
-    const overrideTaxon = Number(taxonIdInput.trim());
-    const effectiveTaxonId = taxonIdInput.trim() !== '' &&
-        Number.isFinite(overrideTaxon) &&
-        overrideTaxon > 0
-        ? overrideTaxon
-        : assemblyTaxonId;
-    const [selectedQueryId, setSelectedQueryId] = useState('auto');
+    const lookup = useUniProtIdLookup({ feature, view });
+    const { uniprotId, isSequenceMode, isAutoMode, isLookupLoading } = lookup;
     const [sequenceSearchType, setSequenceSearchType] = useState('md5');
-    const [selectedUniprotId, setSelectedUniprotId] = useState();
-    const featureUniprotId = geneIds.uniprotId;
-    const effectiveLookupMode = lookupMode === 'auto' && featureUniprotId ? 'feature' : lookupMode;
-    const isSequenceMode = effectiveLookupMode === 'sequence';
-    const isAutoMode = effectiveLookupMode === 'auto';
-    const { entries: uniprotEntries, isLoading: isLookupLoading, error: lookupError, } = useUniProtSearch({
-        recognizedIds: geneIds.recognizedIds,
-        geneId: geneIds.geneId,
-        geneName: geneIds.geneName,
-        organismId: effectiveTaxonId,
-        selectedQueryId,
-        enabled: isAutoMode,
-    });
-    // Debounce manual entry so fetches don't fire on every keystroke and
-    // pollute the SWR cache with partial-ID 404s.
-    const debouncedManualUniprotId = useDebouncedValue(manualUniprotId, 400);
-    const autoUniprotId = uniprotEntries[0]?.accession;
-    const uniprotId = effectiveLookupMode === 'feature'
-        ? featureUniprotId
-        : isAutoMode
-            ? (selectedUniprotId ?? autoUniprotId)
-            : effectiveLookupMode === 'manual'
-                ? debouncedManualUniprotId
-                : undefined;
-    const { isLoading: isAlphaFoldLoading, isValidating: isAlphaFoldValidating, error: alphaFoldError, url: alphaFoldUrl, confidenceUrl: alphaFoldConfidenceUrl, structureSequences: alphaFoldStructureSequences, } = useAlphaFoldData({
-        uniprotId: isSequenceMode ? undefined : uniprotId,
-    });
+    const { isLoading: isAlphaFoldLoading, isValidating: isAlphaFoldValidating, error: alphaFoldError, url: alphaFoldUrl, confidenceUrl: alphaFoldConfidenceUrl, structureSequences: alphaFoldStructureSequences, } = useAlphaFoldData({ uniprotId });
     const { transcripts: transcriptOptions, isoformSequences, structureSequence: alphaFoldStructureSequence, isLoading: isIsoformLoading, error: isoformError, selectedTranscriptId: effectiveTranscriptId, setSelectedTranscriptId: setUserSelection, selectedTranscript, selectedIsoform: userSelectedProteinSequence, } = useTranscriptIsoformSelection({
         feature,
         view,
@@ -99,33 +48,18 @@ export default function useAlphaFoldDBSearch({ feature, view, }) {
     // Only show errors once all loading is done — the synchronous
     // effectiveLookupMode and autoTranscriptId computations prevent the
     // one-frame gaps that previously caused brief error flashes
-    const rawError = isoformError ?? lookupError ?? alphaFoldError ?? sequenceSearchError;
+    const rawError = isoformError ?? lookup.lookupError ?? alphaFoldError ?? sequenceSearchError;
     const error = isLoading ? undefined : rawError;
     return {
-        lookupMode: effectiveLookupMode,
-        setLookupMode,
-        manualUniprotId,
-        setManualUniprotId,
-        taxonId: taxonIdInput,
-        setTaxonId: setTaxonIdInput,
-        // shown as the field placeholder so the user sees the organism in effect
-        effectiveTaxonId: effectiveTaxonId ?? 9606,
-        selectedQueryId,
-        setSelectedQueryId,
+        ...lookup,
         sequenceSearchType,
         setSequenceSearchType,
-        selectedUniprotId,
-        setSelectedUniprotId,
         userSelection: effectiveTranscriptId,
         setUserSelection,
         transcriptOptions,
         selectedTranscript,
         isoformSequences,
         userSelectedProteinSequence,
-        uniprotEntries,
-        recognizedIds: geneIds.recognizedIds,
-        geneName: geneIds.geneName,
-        featureUniprotId,
         uniprotId: finalUniprotId,
         url: finalUrl,
         confidenceUrl: finalConfidenceUrl,
@@ -133,7 +67,6 @@ export default function useAlphaFoldDBSearch({ feature, view, }) {
         error,
         loadingStatuses,
         isSequenceSearchLoading,
-        showIdentifierSelector: isAutoMode && (geneIds.recognizedIds.length > 0 || !!geneIds.geneName),
         showStructureSelectors: !!isoformSequences &&
             !!selectedTranscript &&
             (isSequenceMode || !!(finalStructureSequence && finalUniprotId)),
@@ -143,25 +76,13 @@ export default function useAlphaFoldDBSearch({ feature, view, }) {
             ? stripStopCodon(userSelectedProteinSequence.seq) ===
                 finalStructureSequence
             : undefined,
-        searchDescription: getSearchDescription({
-            selectedQueryId,
-            recognizedIds: geneIds.recognizedIds,
-            geneName: geneIds.geneName,
-        }),
-        searchDescriptionOr: getSearchDescription({
-            selectedQueryId,
-            recognizedIds: geneIds.recognizedIds,
-            geneName: geneIds.geneName,
-            joinWord: 'or',
-        }),
-        selectedTableAccession: selectedUniprotId ?? autoUniprotId,
         showUniprotResults: !!isoformSequences &&
             isAutoMode &&
-            (uniprotEntries.length > 0 || isLookupLoading),
+            (lookup.uniprotEntries.length > 0 || isLookupLoading),
         showNoResults: !!isoformSequences &&
             isAutoMode &&
             !isLookupLoading &&
-            uniprotEntries.length === 0,
+            lookup.uniprotEntries.length === 0,
         showSequenceSearchStatus: isSequenceMode,
         showAlphaFoldDBSearchStatus: !!finalStructureSequence && !!finalUniprotId && !isSequenceMode,
         isLoading,

package/dist/LaunchProteinView/hooks/usePdbBestStructures.d.ts

@@ -0,0 +1,6 @@
+import { type PdbStructureEntry } from '../services/pdbeBestStructures';
+export default function usePdbBestStructures(uniprotId: string | undefined): {
+    entries: PdbStructureEntry[] | undefined;
+    error: any;
+    isLoading: boolean;
+};

package/dist/LaunchProteinView/hooks/usePdbBestStructures.js

@@ -0,0 +1,19 @@
+import useSWR from 'swr';
+import { STATIC_SWR_OPTIONS } from './swrOptions';
+import { parseBestStructures, pdbeBestStructuresUrl, } from '../services/pdbeBestStructures';
+// PDBe answers 404 for an accession with no experimental structure, which is
+// the ordinary case for most genes rather than a failure.
+async function fetchBestStructures(url) {
+    const response = await fetch(url);
+    if (response.status === 404) {
+        return [];
+    }
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status} fetching ${url} ${await response.text()}`);
+    }
+    return parseBestStructures(await response.json());
+}
+export default function usePdbBestStructures(uniprotId) {
+    const { data, error, isLoading } = useSWR(uniprotId ? pdbeBestStructuresUrl(uniprotId) : null, fetchBestStructures, STATIC_SWR_OPTIONS);
+    return { entries: data, error, isLoading };
+}

package/dist/LaunchProteinView/hooks/useUniProtIdLookup.d.ts

@@ -0,0 +1,39 @@
+import type { LookupMode } from '../components/UniProtIdInput';
+import type { Feature } from '@jbrowse/core/util';
+import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
+/**
+ * Which UniProt entry a feature is, by the dialog's lookup modes: the
+ * feature's own attribute, the ID-mapping search over its recognised ids and
+ * gene name, a typed accession, or none (sequence mode, where the structure
+ * search itself names the entry). Shared by every tab that starts from an
+ * accession so they agree on what the gene is.
+ */
+export default function useUniProtIdLookup({ feature, view, }: {
+    feature: Feature;
+    view: LinearGenomeViewModel;
+}): {
+    lookupMode: LookupMode;
+    setLookupMode: import("react").Dispatch<import("react").SetStateAction<LookupMode>>;
+    manualUniprotId: string;
+    setManualUniprotId: import("react").Dispatch<import("react").SetStateAction<string>>;
+    taxonId: string;
+    setTaxonId: import("react").Dispatch<import("react").SetStateAction<string>>;
+    effectiveTaxonId: number;
+    selectedQueryId: string;
+    setSelectedQueryId: import("react").Dispatch<import("react").SetStateAction<string>>;
+    selectedUniprotId: string | undefined;
+    setSelectedUniprotId: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
+    selectedTableAccession: string | undefined;
+    uniprotEntries: import("../services/lookupMethods").UniProtEntry[];
+    isLookupLoading: boolean;
+    lookupError: any;
+    uniprotId: string | undefined;
+    featureUniprotId: string | undefined;
+    recognizedIds: string[];
+    geneName: string | undefined;
+    isAutoMode: boolean;
+    isSequenceMode: boolean;
+    showIdentifierSelector: boolean;
+    searchDescription: string;
+    searchDescriptionOr: string;
+};

package/dist/LaunchProteinView/hooks/useUniProtIdLookup.js

@@ -0,0 +1,99 @@
+import { useState } from 'react';
+import { getConf } from '@jbrowse/core/configuration';
+import { getSession } from '@jbrowse/core/util';
+import useDebouncedValue from './useDebouncedValue';
+import useUniProtSearch from './useUniProtSearch';
+import getSearchDescription from '../utils/getSearchDescription';
+import { extractFeatureIdentifiers, extractTaxonId } from '../utils/util';
+/**
+ * Which UniProt entry a feature is, by the dialog's lookup modes: the
+ * feature's own attribute, the ID-mapping search over its recognised ids and
+ * gene name, a typed accession, or none (sequence mode, where the structure
+ * search itself names the entry). Shared by every tab that starts from an
+ * accession so they agree on what the gene is.
+ */
+export default function useUniProtIdLookup({ feature, view, }) {
+    const [lookupMode, setLookupMode] = useState('auto');
+    const [manualUniprotId, setManualUniprotId] = useState('');
+    const [taxonIdInput, setTaxonIdInput] = useState('');
+    const geneIds = extractFeatureIdentifiers(feature);
+    // The gene-name UniProt search is ambiguous across species, so scope it to
+    // the assembly's organism. jb2hubs assemblies carry the NCBI taxon in the
+    // reference-sequence track metadata (UCSC: metadata.taxId, GenArk:
+    // metadata.ucsc.taxId). Falls back to human via searchUniProtEntries when
+    // absent; a user override (taxonIdInput) always wins.
+    const assemblyName = view.assemblyNames[0];
+    const assembly = assemblyName
+        ? getSession(view).assemblyManager.get(assemblyName)
+        : undefined;
+    const assemblyTaxonId = assembly
+        ? extractTaxonId(getConf(assembly, ['sequence', 'metadata']))
+        : undefined;
+    const overrideTaxon = Number(taxonIdInput.trim());
+    const effectiveTaxonId = taxonIdInput.trim() !== '' &&
+        Number.isFinite(overrideTaxon) &&
+        overrideTaxon > 0
+        ? overrideTaxon
+        : assemblyTaxonId;
+    const [selectedQueryId, setSelectedQueryId] = useState('auto');
+    const [selectedUniprotId, setSelectedUniprotId] = useState();
+    const featureUniprotId = geneIds.uniprotId;
+    const effectiveLookupMode = lookupMode === 'auto' && featureUniprotId ? 'feature' : lookupMode;
+    const isSequenceMode = effectiveLookupMode === 'sequence';
+    const isAutoMode = effectiveLookupMode === 'auto';
+    const { entries: uniprotEntries, isLoading: isLookupLoading, error: lookupError, } = useUniProtSearch({
+        recognizedIds: geneIds.recognizedIds,
+        geneId: geneIds.geneId,
+        geneName: geneIds.geneName,
+        organismId: effectiveTaxonId,
+        selectedQueryId,
+        enabled: isAutoMode,
+    });
+    // Debounce manual entry so fetches don't fire on every keystroke and
+    // pollute the SWR cache with partial-ID 404s.
+    const debouncedManualUniprotId = useDebouncedValue(manualUniprotId, 400);
+    const autoUniprotId = uniprotEntries[0]?.accession;
+    const uniprotId = effectiveLookupMode === 'feature'
+        ? featureUniprotId
+        : isAutoMode
+            ? (selectedUniprotId ?? autoUniprotId)
+            : effectiveLookupMode === 'manual'
+                ? debouncedManualUniprotId
+                : undefined;
+    return {
+        lookupMode: effectiveLookupMode,
+        setLookupMode,
+        manualUniprotId,
+        setManualUniprotId,
+        taxonId: taxonIdInput,
+        setTaxonId: setTaxonIdInput,
+        // shown as the field placeholder so the user sees the organism in effect
+        effectiveTaxonId: effectiveTaxonId ?? 9606,
+        selectedQueryId,
+        setSelectedQueryId,
+        selectedUniprotId,
+        setSelectedUniprotId,
+        selectedTableAccession: selectedUniprotId ?? autoUniprotId,
+        uniprotEntries,
+        isLookupLoading,
+        lookupError,
+        uniprotId,
+        featureUniprotId,
+        recognizedIds: geneIds.recognizedIds,
+        geneName: geneIds.geneName,
+        isAutoMode,
+        isSequenceMode,
+        showIdentifierSelector: isAutoMode && (geneIds.recognizedIds.length > 0 || !!geneIds.geneName),
+        searchDescription: getSearchDescription({
+            selectedQueryId,
+            recognizedIds: geneIds.recognizedIds,
+            geneName: geneIds.geneName,
+        }),
+        searchDescriptionOr: getSearchDescription({
+            selectedQueryId,
+            recognizedIds: geneIds.recognizedIds,
+            geneName: geneIds.geneName,
+            joinWord: 'or',
+        }),
+    };
+}