jbrowse-plugin-protein3d 0.10.0 → 0.11.1

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
 
@@ -28,6 +29,13 @@ Source and details in [harness/](harness/).
 Example at
 https://jbrowse.org/code/jb2/latest/?config=%2Fucsc%2Fhg38%2Fconfig.json&session=share-aZOIjR_qs4&password=NT4sa
 
+## Demos
+
+[Structures that are easy to map wrong](docs/demos.md), each one link away: a
+peptide bound to a larger partner, a protein bound to DNA, a receptor with
+another protein fused into it, a phosphorylated residue, and a mitochondrial
+protein.
+
 ## Publication
 
 If you find this tool useful please cite our work
@@ -48,6 +56,19 @@ 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:
+
+- [Genome to structure alignment](docs/genome-to-structure-alignment.md): why
+  the plugin aligns the transcript's translation to the structure on the fly,
+  the precedent for that in SIFTS and G2S, how it picks the chain and isoform,
+  and what sequence alignment cannot decide.
+- [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/AddHighlightModel/HighlightComponents.js

@@ -4,14 +4,12 @@ import GenomeMouseoverHighlight from './GenomeMouseoverHighlight';
 import GenomeTo1DProteinHoverHighlight from './GenomeTo1DProteinHoverHighlight';
 import Protein1DToGenomeHoverHighlight from './Protein1DToGenomeHoverHighlight';
 import { ProteinToGenomeClickHighlight, ProteinToGenomeHoverHighlight, } from './ProteinToGenomeHighlight';
-import ProteinToMsaHoverSync from './ProteinToMsaHoverSync';
 const HighlightComponents = observer(function Highlight({ model, }) {
     return (React.createElement(React.Fragment, null,
         React.createElement(ProteinToGenomeClickHighlight, { model: model }),
         React.createElement(ProteinToGenomeHoverHighlight, { model: model }),
         React.createElement(Protein1DToGenomeHoverHighlight, { model: model }),
         React.createElement(GenomeTo1DProteinHoverHighlight, { model: model }),
-        React.createElement(GenomeMouseoverHighlight, { model: model }),
-        React.createElement(ProteinToMsaHoverSync, { model: model })));
+        React.createElement(GenomeMouseoverHighlight, { model: model })));
 });
 export default HighlightComponents;

package/dist/AddHighlightModel/proteinViewLookup.d.ts

@@ -8,19 +8,9 @@ import type { AbstractSessionModel } from '@jbrowse/core/util';
  */
 export interface HighlightSourceProteinView {
     id: string;
-    connectedMsaViewId?: string;
     structures: JBrowsePluginProteinStructureModel[];
-    primaryStructure?: JBrowsePluginProteinStructureModel;
 }
 export declare function getProteinViews(session: AbstractSessionModel): HighlightSourceProteinView[];
-/**
- * NOTE: assumes a single ProteinView. Unlike the genome-highlight bridge (which
- * pairs by the declared `connectedViewId`, see getStructuresConnectedTo), a
- * second ProteinView's MSA hover sync is skipped — pairing an MSA to one of
- * several protein views has no reliable rule when the protein view declares
- * neither a connectedMsaViewId nor a connectedViewId.
- */
-export declare function getProteinView(session: AbstractSessionModel): HighlightSourceProteinView | undefined;
 interface ConnectableStructure {
     connectedViewId?: string;
 }

package/dist/AddHighlightModel/proteinViewLookup.js

@@ -1,16 +1,6 @@
 export function getProteinViews(session) {
     return session.views.filter(v => v.type === 'ProteinView');
 }
-/**
- * NOTE: assumes a single ProteinView. Unlike the genome-highlight bridge (which
- * pairs by the declared `connectedViewId`, see getStructuresConnectedTo), a
- * second ProteinView's MSA hover sync is skipped — pairing an MSA to one of
- * several protein views has no reliable rule when the protein view declares
- * neither a connectedMsaViewId nor a connectedViewId.
- */
-export function getProteinView(session) {
-    return getProteinViews(session)[0];
-}
 /**
  * Every structure across all ProteinViews that declares this genome view as its
  * connection. Structures are paired to a genome view explicitly, so a second

package/dist/LaunchProteinView/components/AlphaFoldDBSearch.js

@@ -6,7 +6,6 @@ import { makeStyles } from 'tss-react/mui';
 import AlphaFoldDBSearchStatus from './AlphaFoldDBSearchStatus';
 import IdentifierSelector from './IdentifierSelector';
 import ProteinViewActions from './ProteinViewActions';
-import SequenceSearchStatus from './SequenceSearchStatus';
 import TranscriptSelector from './TranscriptSelector';
 import UniProtIdInput from './UniProtIdInput';
 import UniProtResultsTable from './UniProtResultsTable';
@@ -41,7 +40,11 @@ const AlphaFoldDBSearch = observer(function AlphaFoldDBSearch({ feature, session
     return (React.createElement(React.Fragment, null,
         React.createElement(DialogContent, { className: classes.dialogContent },
             state.error ? React.createElement(ErrorMessage, { error: state.error }) : null,
-            React.createElement(UniProtIdInput, { lookupMode: state.lookupMode, onLookupModeChange: state.setLookupMode, manualUniprotId: state.manualUniprotId, onManualUniprotIdChange: state.setManualUniprotId, featureUniprotId: state.featureUniprotId, hasProteinSequence: !!state.userSelectedProteinSequence?.seq, sequenceSearchType: state.sequenceSearchType, onSequenceSearchTypeChange: state.setSequenceSearchType, endContent: state.showIdentifierSelector ? (React.createElement("div", { className: classes.endRow },
+            state.noModel ? (React.createElement(Typography, null,
+                "AlphaFold DB has no model for ",
+                state.uniprotId,
+                ". The PDB and Foldseek tabs may have a structure.")) : null,
+            React.createElement(UniProtIdInput, { lookupMode: state.lookupMode, onLookupModeChange: state.setLookupMode, manualUniprotId: state.manualUniprotId, onManualUniprotIdChange: state.setManualUniprotId, featureUniprotId: state.featureUniprotId, endContent: state.showIdentifierSelector ? (React.createElement("div", { className: classes.endRow },
                     React.createElement(IdentifierSelector, { recognizedIds: state.recognizedIds, geneName: state.geneName, selectedId: state.selectedQueryId, onSelectedIdChange: state.setSelectedQueryId }),
                     React.createElement(TextField, { size: "small", label: "Organism (NCBI taxon)", helperText: "Scopes the gene-name search", value: state.taxonId, onChange: event => {
                             state.setTaxonId(event.target.value);
@@ -65,13 +68,15 @@ const AlphaFoldDBSearch = observer(function AlphaFoldDBSearch({ feature, session
                 ' ',
                 React.createElement(ExternalLink, { href: "https://www.uniprot.org/" }, "UniProt"),
                 ' ',
-                "directly and use \"Enter manually\" above, or use \"Search sequence against AlphaFoldDB API\" if available.")),
-            state.showStructureSelectors && state.isoformSequences ? (React.createElement(React.Fragment, null,
+                "directly and use \"Enter manually\" above.")),
+            state.isoformSequences &&
+                state.selectedTranscript &&
+                state.structureSequence &&
+                state.uniprotId ? (React.createElement(React.Fragment, null,
                 React.createElement("div", { className: classes.selectorsRow },
                     React.createElement(TranscriptSelector, { val: state.userSelection, setVal: state.setUserSelection, structureSequence: state.structureSequence, feature: feature, isoforms: state.transcriptOptions, isoformSequences: state.isoformSequences })),
-                state.showSequenceSearchStatus && (React.createElement(SequenceSearchStatus, { isLoading: state.isSequenceSearchLoading, uniprotId: state.uniprotId, url: state.url, hasProteinSequence: !!state.userSelectedProteinSequence?.seq, sequenceSearchType: state.sequenceSearchType })),
-                state.showAlphaFoldDBSearchStatus && (React.createElement(AlphaFoldDBSearchStatus, { uniprotId: state.uniprotId, selectedTranscript: state.selectedTranscript, structureSequence: state.structureSequence, isoformSequences: state.isoformSequences, url: state.url })))) : null),
+                React.createElement(AlphaFoldDBSearchStatus, { uniprotId: state.modelAccession ?? state.uniprotId, structureSequence: state.structureSequence, isoformSequences: state.isoformSequences, url: state.url }))) : null),
         React.createElement(DialogActions, null,
-            React.createElement(ProteinViewActions, { handleClose: handleClose, uniprotId: state.uniprotId, userSelectedProteinSequence: state.userSelectedProteinSequence, selectedTranscript: state.selectedTranscript, url: state.url, confidenceUrl: state.confidenceUrl, feature: feature, view: view, session: session, alignmentAlgorithm: alignmentAlgorithm, onAlignmentAlgorithmChange: onAlignmentAlgorithmChange, sequencesMatch: state.sequencesMatch, isLoading: state.isLoading, error: state.error }))));
+            React.createElement(ProteinViewActions, { handleClose: handleClose, uniprotId: state.modelAccession ?? state.uniprotId, userSelectedProteinSequence: state.userSelectedProteinSequence, selectedTranscript: state.selectedTranscript, url: state.url, confidenceUrl: state.confidenceUrl, feature: feature, view: view, session: session, alignmentAlgorithm: alignmentAlgorithm, onAlignmentAlgorithmChange: onAlignmentAlgorithmChange, sequencesMatch: state.sequencesMatch, isLoading: state.isLoading, error: state.error }))));
 });
 export default AlphaFoldDBSearch;

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

@@ -1,10 +1,8 @@
 import React from 'react';
 import type { IsoformSequences } from '../utils/util';
-import type { Feature } from '@jbrowse/core/util';
-export default function AlphaFoldDBSearchStatus({ uniprotId, selectedTranscript, structureSequence, isoformSequences, url, }: {
-    uniprotId?: string;
-    selectedTranscript?: Feature;
-    structureSequence?: string;
+export default function AlphaFoldDBSearchStatus({ uniprotId, structureSequence, isoformSequences, url, }: {
+    uniprotId: string;
+    structureSequence: string;
     isoformSequences: IsoformSequences;
     url?: string;
 }): React.JSX.Element;

package/dist/LaunchProteinView/components/AlphaFoldDBSearchStatus.js

@@ -3,15 +3,8 @@ import { Typography } from '@mui/material';
 import IsoformSequencesToggle from './IsoformSequencesToggle';
 import ExternalLink from '../../components/ExternalLink';
 import { uniprotEntryUrl } from '../utils/structureUrls';
-import { getTranscriptDisplayName } from '../utils/util';
-function NotFound({ uniprotId }) {
-    return (React.createElement(Typography, null,
-        "No structure found for this UniProtID in AlphaFoldDB",
-        ' ',
-        React.createElement(ExternalLink, { href: `https://alphafold.ebi.ac.uk/search/text/${uniprotId}` }, "(search for results)")));
-}
-export default function AlphaFoldDBSearchStatus({ uniprotId, selectedTranscript, structureSequence, isoformSequences, url, }) {
-    return uniprotId ? (React.createElement(React.Fragment, null,
+export default function AlphaFoldDBSearchStatus({ uniprotId, structureSequence, isoformSequences, url, }) {
+    return (React.createElement(React.Fragment, null,
         React.createElement("div", null,
             React.createElement(Typography, null,
                 "UniProt link:",
@@ -20,12 +13,5 @@ export default function AlphaFoldDBSearchStatus({ uniprotId, selectedTranscript,
             React.createElement(Typography, null,
                 "AlphaFoldDB link: ",
                 React.createElement(ExternalLink, { href: url }, url))),
-        structureSequence ? (React.createElement(IsoformSequencesToggle, { structureSequence: structureSequence, structureName: uniprotId, isoformSequences: isoformSequences })) : (React.createElement(NotFound, { uniprotId: uniprotId })))) : (React.createElement(Typography, null,
-        "Searching",
-        ' ',
-        selectedTranscript
-            ? getTranscriptDisplayName(selectedTranscript)
-            : 'transcript',
-        ' ',
-        "for UniProt ID"));
+        React.createElement(IsoformSequencesToggle, { structureSequence: structureSequence, structureName: uniprotId, isoformSequences: isoformSequences })));
 }

package/dist/LaunchProteinView/components/FoldseekSearch.js

@@ -77,7 +77,7 @@ const FoldseekSearch = observer(function FoldseekSearch({ feature, session, view
                     } }))) : null,
             React.createElement(FoldseekDatabaseSelector, { selected: selectedDatabases, onChange: setSelectedDatabases, disabled: isBusy }),
             statusMessage ? (React.createElement(LoadingEllipses, { variant: "subtitle2", message: statusMessage })) : null,
-            results ? (React.createElement(FoldseekResultsTable, { results: results, session: session, view: view, feature: feature, selectedTranscript: selectedTranscript, userProvidedTranscriptSequence: sequence, onClose: handleClose })) : null),
+            results ? (React.createElement(FoldseekResultsTable, { results: results, session: session, view: view, feature: feature, selectedTranscript: selectedTranscript, userProvidedTranscriptSequence: selectedIsoformData?.seq, onClose: handleClose })) : null),
         React.createElement(DialogActions, null,
             React.createElement(Button, { variant: "contained", color: "secondary", onClick: () => {
                     handleClose();

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,10 +16,11 @@ 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.
-    const canLaunch = !isLoading && missingReasons.length === 0;
+    // Loading or errored, SWR's keepPreviousData can still hold the previous
+    // accession's structure, which Launch would open under the new name.
+    const canLaunch = !isLoading && !error && missingReasons.length === 0;
     // Suppress the derived reasons while loading or while a real upstream error
     // is displayed above via <ErrorMessage> — a duplicate hint would mislead.
     const showMissingReasons = !isLoading && !error && missingReasons.length > 0;

package/dist/LaunchProteinView/components/TranscriptSelector.js

@@ -1,6 +1,7 @@
 import React from 'react';
 import { MenuItem, TextField } from '@mui/material';
-import { classifyIsoforms, getGeneDisplayName, getTranscriptDisplayName, } from '../utils/util';
+import { classifyIsoforms } from '../utils/isoformRanking';
+import { getGeneDisplayName, getTranscriptDisplayName, stripStopCodon, } from '../utils/util';
 export default function TranscriptSelector({ val, setVal, isoforms, isoformSequences, structureSequence, feature, disabled, }) {
     const geneName = getGeneDisplayName(feature);
     const { matches, nonMatches, noData } = classifyIsoforms({
@@ -8,7 +9,12 @@ export default function TranscriptSelector({ val, setVal, isoforms, isoformSeque
         isoformSequences,
         structureSequence,
     });
-    const renderOption = ({ feature: f, length }, note = '') => (React.createElement(MenuItem, { value: f.id(), key: f.id() },
+    const structureLength = structureSequence
+        ? stripStopCodon(structureSequence).length
+        : undefined;
+    const renderOption = ({ feature: f, length, identical }, note = identical === undefined
+        ? ''
+        : ` (${identical}/${structureLength} structure residues identical)`) => (React.createElement(MenuItem, { value: f.id(), key: f.id() },
         geneName,
         " - ",
         getTranscriptDisplayName(f),

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

@@ -1,16 +1,12 @@
 import React from 'react';
-import type { SequenceSearchType } from '../hooks/useAlphaFoldSequenceSearch';
-export type LookupMode = 'auto' | 'manual' | 'feature' | 'sequence';
+export type LookupMode = 'auto' | 'manual' | 'feature';
 interface UniProtIdInputProps {
     lookupMode: LookupMode;
     onLookupModeChange: (mode: LookupMode) => void;
     manualUniprotId: string;
     onManualUniprotIdChange: (id: string) => void;
     featureUniprotId?: string;
-    hasProteinSequence?: boolean;
-    sequenceSearchType?: SequenceSearchType;
-    onSequenceSearchTypeChange?: (type: SequenceSearchType) => void;
     endContent?: React.ReactNode;
 }
-export default function UniProtIdInput({ lookupMode, onLookupModeChange, manualUniprotId, onManualUniprotIdChange, featureUniprotId, hasProteinSequence, sequenceSearchType, onSequenceSearchTypeChange, endContent, }: UniProtIdInputProps): React.JSX.Element;
+export default function UniProtIdInput({ lookupMode, onLookupModeChange, manualUniprotId, onManualUniprotIdChange, featureUniprotId, endContent, }: UniProtIdInputProps): React.JSX.Element;
 export {};

package/dist/LaunchProteinView/components/UniProtIdInput.js

@@ -1,32 +1,27 @@
 import React from 'react';
 import { FormControl, FormControlLabel, Radio, RadioGroup, TextField, Typography, } from '@mui/material';
 import ExternalLink from '../../components/ExternalLink';
-export default function UniProtIdInput({ lookupMode, onLookupModeChange, manualUniprotId, onManualUniprotIdChange, featureUniprotId, hasProteinSequence, sequenceSearchType, onSequenceSearchTypeChange, endContent, }) {
+const LOOKUP_MODES = ['auto', 'manual', 'feature'];
+function isLookupMode(value) {
+    return LOOKUP_MODES.some(mode => mode === value);
+}
+export default function UniProtIdInput({ lookupMode, onLookupModeChange, manualUniprotId, onManualUniprotIdChange, featureUniprotId, endContent, }) {
     return (React.createElement(React.Fragment, null,
         React.createElement("div", { style: { display: 'flex', alignItems: 'center', flexWrap: 'wrap' } },
             React.createElement(FormControl, { component: "fieldset" },
                 React.createElement(RadioGroup, { row: true, value: lookupMode, onChange: event => {
-                        onLookupModeChange(event.target.value);
+                        if (isLookupMode(event.target.value)) {
+                            onLookupModeChange(event.target.value);
+                        }
                     } },
                     featureUniprotId && (React.createElement(FormControlLabel, { value: "feature", control: React.createElement(Radio, null), label: `From feature (${featureUniprotId})` })),
                     React.createElement(FormControlLabel, { value: "auto", control: React.createElement(Radio, null), label: "Auto-detect using UniProt ID mapping API" }),
-                    React.createElement(FormControlLabel, { value: "manual", control: React.createElement(Radio, null), label: "Enter manually" }),
-                    hasProteinSequence && (React.createElement(FormControlLabel, { value: "sequence", control: React.createElement(Radio, null), label: "Search sequence against AlphaFoldDB API" })))),
+                    React.createElement(FormControlLabel, { value: "manual", control: React.createElement(Radio, null), label: "Enter manually" }))),
             endContent),
         lookupMode === 'manual' && (React.createElement("div", null,
             React.createElement(TextField, { label: "UniProt ID", variant: "outlined", placeholder: "e.g. P68871", size: "small", value: manualUniprotId, onChange: e => {
                     onManualUniprotIdChange(e.target.value);
                 } }))),
-        lookupMode === 'sequence' &&
-            sequenceSearchType &&
-            onSequenceSearchTypeChange && (React.createElement("div", null,
-            React.createElement(FormControl, { component: "fieldset" },
-                React.createElement(RadioGroup, { row: true, value: sequenceSearchType, onChange: event => {
-                        onSequenceSearchTypeChange(event.target.value);
-                    } },
-                    React.createElement(FormControlLabel, { value: "md5", control: React.createElement(Radio, null), label: "Exact match" }),
-                    React.createElement(FormControlLabel, { value: "sequence", control: React.createElement(Radio, null), label: "Fuzzy match" }))),
-            React.createElement(Typography, { variant: "body2", color: "text.secondary" }, "May not find the canonical UniProt entry."))),
         lookupMode === 'manual' && !manualUniprotId && (React.createElement(Typography, { variant: "body2", color: "text.secondary" },
             "Search",
             ' ',

package/dist/LaunchProteinView/components/proteinTrackSetup.js

@@ -150,8 +150,11 @@ export async function addAllProteinTracks({ session, uniprotId, confidenceUrl, }
         uniprotId,
         confidenceUrl,
     });
-    addAlphaMissenseTrack({
-        session,
-        uniprotId,
-    });
+    // AlphaFold DB publishes substitution scores for canonical entries only
+    if (!uniprotId.includes('-')) {
+        addAlphaMissenseTrack({
+            session,
+            uniprotId,
+        });
+    }
 }

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

@@ -1,50 +1,46 @@
-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;
+    modelAccession: string | undefined;
     structureSequence: string | undefined;
+    noModel: boolean;
     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>>;
+    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;
+    showIdentifierSelector: boolean;
+    searchDescription: string;
+    searchDescriptionOr: string;
 };