@jbrowse/core 4.2.1 → 5.0.0-beta.1

package/esm/BaseFeatureWidget/SequenceFeatureDetails/dialogs/SequenceFeatureMenu.js

@@ -1,62 +1,69 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { forwardRef, lazy, useState } from 'react';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { lazy, useState } from 'react';
 import MoreVert from '@mui/icons-material/MoreVert';
 import Settings from '@mui/icons-material/Settings';
 import { observer } from 'mobx-react';
-import CascadingMenuButton from "../../../ui/CascadingMenuButton.js";
-const SequenceFeatureSettingsDialog = lazy(() => import("./SettingsDialog.js"));
-const SequenceFeatureMenu = observer(forwardRef(function SequenceFeatureMenu2({ model, extraItems = [] }, ref) {
-    if (typeof ref === 'function') {
-        throw new Error('needs a non function ref');
-    }
+import CascadingMenuButton from '../../../ui/CascadingMenuButton.js';
+import { copyTextWithSession } from '../../../util/copyText.js';
+import { saveAs } from '../../../util/index.js';
+import { modeSupportsRevcomp, resolveShowCoordinates, showGenomicCoordsOption, } from '../featureTypeUtil.js';
+import { getSequenceFasta } from '../util.js';
+// lazies
+const SequenceFeatureSettingsDialog = lazy(() => import('./SettingsDialog.js'));
+const SequenceFeatureMenu = observer(function SequenceFeatureMenu({ model, session, ref, mode, revcomp, setRevcomp, extraItems = [], }) {
     const [showSettings, setShowSettings] = useState(false);
-    const { showCoordinatesSetting, showGenomicCoordsOption } = model;
+    // the radio reflects what the panel renders, not the raw stored setting: a
+    // sticky 'genomic' preference renders as relative in modes that can't label
+    // genomic positions, and would otherwise leave every radio unchecked
+    const coordinatesMode = resolveShowCoordinates(model.showCoordinatesSetting, mode);
+    // every export row reads the rendered panel out of the ref, which is empty
+    // until the panel mounts (the sequence is still loading, or errored)
+    const withPanel = (f) => async () => {
+        const panel = ref.current;
+        if (panel) {
+            await f(panel);
+        }
+    };
     return (_jsxs(_Fragment, { children: [_jsx(CascadingMenuButton, { menuItems: [
                     {
-                        label: 'Copy plaintext',
-                        onClick: async () => {
-                            const { default: copy } = await import('copy-to-clipboard');
-                            const r = ref?.current;
-                            if (r) {
-                                copy(r.textContent || '', { format: 'text/plain' });
-                            }
-                        },
+                        label: 'Copy FASTA',
+                        onClick: withPanel(panel => copyTextWithSession(session, getSequenceFasta(panel), 'sequence')),
                     },
                     {
                         label: 'Copy HTML',
-                        onClick: async () => {
-                            const { default: copy } = await import('copy-to-clipboard');
-                            const r = ref?.current;
-                            if (r) {
-                                copy(r.outerHTML, { format: 'text/html' });
-                            }
-                        },
+                        onClick: withPanel(panel => copyTextWithSession(session, panel.outerHTML, 'sequence HTML', {
+                            format: 'text/html',
+                        })),
                     },
                     {
-                        label: 'Download plaintext',
-                        onClick: async () => {
-                            const { saveAs } = await import('file-saver-es');
-                            const r = ref?.current;
-                            if (r) {
-                                saveAs(new Blob([r.textContent || ''], {
-                                    type: 'text/plain;charset=utf-8',
-                                }), 'sequence.txt');
-                            }
-                        },
+                        label: 'Download FASTA',
+                        onClick: withPanel(panel => {
+                            saveAs(new Blob([getSequenceFasta(panel)], {
+                                type: 'text/plain;charset=utf-8',
+                            }), 'sequence.fa');
+                        }),
                     },
                     {
                         label: 'Download HTML',
-                        onClick: async () => {
-                            const { saveAs } = await import('file-saver-es');
-                            const r = ref?.current;
-                            if (r) {
-                                saveAs(new Blob([r.outerHTML || ''], {
-                                    type: 'text/html;charset=utf-8',
-                                }), 'sequence.html');
-                            }
-                        },
+                        onClick: withPanel(panel => {
+                            saveAs(new Blob([panel.outerHTML], {
+                                type: 'text/html;charset=utf-8',
+                            }), 'sequence.html');
+                        }),
                     },
                     ...extraItems,
+                    ...(modeSupportsRevcomp(mode)
+                        ? [
+                            {
+                                label: 'Reverse complement',
+                                type: 'checkbox',
+                                checked: revcomp,
+                                onClick: () => {
+                                    setRevcomp(!revcomp);
+                                },
+                            },
+                        ]
+                        : []),
                     {
                         label: 'Show coordinates?',
                         type: 'subMenu',
@@ -64,7 +71,7 @@ const SequenceFeatureMenu = observer(forwardRef(function SequenceFeatureMenu2({
                             {
                                 label: 'No coordinates',
                                 type: 'radio',
-                                checked: showCoordinatesSetting === 'none',
+                                checked: coordinatesMode === 'none',
                                 onClick: () => {
                                     model.setShowCoordinates('none');
                                 },
@@ -72,23 +79,21 @@ const SequenceFeatureMenu = observer(forwardRef(function SequenceFeatureMenu2({
                             {
                                 label: 'Coordinates relative to feature start',
                                 type: 'radio',
-                                checked: showCoordinatesSetting === 'relative',
+                                checked: coordinatesMode === 'relative',
                                 onClick: () => {
                                     model.setShowCoordinates('relative');
                                 },
                             },
-                            ...(showGenomicCoordsOption
-                                ? [
-                                    {
-                                        label: 'Coordinates relative to genome (only available for continuous genome based sequence types)',
-                                        type: 'radio',
-                                        checked: showCoordinatesSetting === 'genomic',
-                                        onClick: () => {
-                                            model.setShowCoordinates('genomic');
-                                        },
-                                    },
-                                ]
-                                : []),
+                            {
+                                label: 'Coordinates relative to genome',
+                                type: 'radio',
+                                checked: coordinatesMode === 'genomic',
+                                disabled: !showGenomicCoordsOption(mode),
+                                disabledHelpText: 'Only available for continuous genome based sequence types',
+                                onClick: () => {
+                                    model.setShowCoordinates('genomic');
+                                },
+                            },
                         ],
                     },
                     {
@@ -101,5 +106,5 @@ const SequenceFeatureMenu = observer(forwardRef(function SequenceFeatureMenu2({
                 ], children: _jsx(MoreVert, {}) }), showSettings ? (_jsx(SequenceFeatureSettingsDialog, { model: model, handleClose: () => {
                     setShowSettings(false);
                 } })) : null] }));
-}));
+});
 export default SequenceFeatureMenu;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/dialogs/SequenceTypeSelector.d.ts

@@ -1,5 +1,9 @@
-import type { SequenceFeatureDetailsModel } from '../model.ts';
-declare const SequenceTypeSelector: ({ model, }: {
+import type { SimpleFeatureSerialized } from '../../../util/index.ts';
+import type { SequenceDisplayMode, SequenceFeatureDetailsModel } from '../model.ts';
+declare const SequenceTypeSelector: ({ model, feature, mode, setMode, }: {
     model: SequenceFeatureDetailsModel;
-}) => import("react/jsx-runtime").JSX.Element;
+    feature: SimpleFeatureSerialized;
+    mode: SequenceDisplayMode;
+    setMode: (mode: SequenceDisplayMode) => void;
+}) => import("react").JSX.Element;
 export default SequenceTypeSelector;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/dialogs/SequenceTypeSelector.js

@@ -1,64 +1,51 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { FormControl, MenuItem, Select } from '@mui/material';
 import { observer } from 'mobx-react';
-import { makeStyles } from "../../../util/tss-react/index.js";
+import { makeStyles } from '../../../util/tss-react/index.js';
+import { featureHasCDS, featureHasExonOrCDS } from '../featureTypeUtil.js';
 const useStyles = makeStyles()({
     formControl: {
         margin: 0,
         marginLeft: 4,
     },
 });
-const SequenceTypeSelector = observer(function SequenceTypeSelector({ model, }) {
+const SequenceTypeSelector = observer(function SequenceTypeSelector({ model, feature, mode, setMode, }) {
     const { classes } = useStyles();
-    const { intronBp, upDownBp, mode, hasCDS, hasExonOrCDS } = model;
+    const { intronBp, upDownBp } = model;
+    const hasCDS = featureHasCDS(feature);
+    const hasExonOrCDS = featureHasExonOrCDS(feature);
+    // each group is annotated, so a mode name that isn't a SequenceDisplayMode is
+    // a compile error rather than a Select whose value silently matches no option
+    const codingOptions = [
+        ['cds', 'CDS'],
+        ['protein', 'Protein'],
+    ];
+    const splicedOptions = [
+        ['cdna', 'cDNA'],
+        ['gene', 'Genomic w/ full introns'],
+        [
+            'gene_updownstream',
+            `Genomic w/ full introns +/- ${upDownBp}bp up+down stream`,
+        ],
+        ['gene_collapsed_intron', `Genomic w/ ${intronBp}bp intron`],
+        [
+            'gene_updownstream_collapsed_intron',
+            `Genomic w/ ${intronBp}bp intron +/- ${upDownBp}bp up+down stream`,
+        ],
+    ];
+    const plainGenomicOptions = [
+        ['genomic', 'Genomic'],
+        [
+            'genomic_sequence_updownstream',
+            `Genomic +/- ${upDownBp}bp up+down stream`,
+        ],
+    ];
+    const options = [
+        ...(hasCDS ? codingOptions : []),
+        ...(hasExonOrCDS ? splicedOptions : plainGenomicOptions),
+    ];
     return (_jsx(FormControl, { className: classes.formControl, children: _jsx(Select, { size: "small", value: mode, onChange: event => {
-                model.setMode(event.target.value);
-            }, children: Object.entries({
-                ...(hasCDS
-                    ? {
-                        cds: 'CDS',
-                    }
-                    : {}),
-                ...(hasCDS
-                    ? {
-                        protein: 'Protein',
-                    }
-                    : {}),
-                ...(hasExonOrCDS
-                    ? {
-                        cdna: 'cDNA',
-                    }
-                    : {}),
-                ...(hasExonOrCDS
-                    ? {
-                        gene: 'Genomic w/ full introns',
-                    }
-                    : {}),
-                ...(hasExonOrCDS
-                    ? {
-                        gene_updownstream: `Genomic w/ full introns +/- ${upDownBp}bp up+down stream`,
-                    }
-                    : {}),
-                ...(hasExonOrCDS
-                    ? {
-                        gene_collapsed_intron: `Genomic w/ ${intronBp}bp intron`,
-                    }
-                    : {}),
-                ...(hasExonOrCDS
-                    ? {
-                        gene_updownstream_collapsed_intron: `Genomic w/ ${intronBp}bp intron +/- ${upDownBp}bp up+down stream `,
-                    }
-                    : {}),
-                ...(!hasExonOrCDS
-                    ? {
-                        genomic: 'Genomic',
-                    }
-                    : {}),
-                ...(!hasExonOrCDS
-                    ? {
-                        genomic_sequence_updownstream: `Genomic +/- ${upDownBp}bp up+down stream`,
-                    }
-                    : {}),
-            }).map(([key, val]) => (_jsx(MenuItem, { value: key, children: val }, key))) }) }));
+                setMode(event.target.value);
+            }, "aria-label": "Sequence type", children: options.map(([key, val]) => (_jsx(MenuItem, { value: key, "data-testid": `sequence_type_${key}`, children: val }, key))) }) }));
 });
 export default SequenceTypeSelector;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/dialogs/SettingsDialog.d.ts

@@ -2,5 +2,5 @@ import type { SequenceFeatureDetailsModel } from '../model.ts';
 declare const SequenceFeatureSettingsDialog: ({ handleClose, model, }: {
     handleClose: () => void;
     model: SequenceFeatureDetailsModel;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => import("react").JSX.Element;
 export default SequenceFeatureSettingsDialog;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/dialogs/SettingsDialog.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
-import { Dialog } from '@jbrowse/core/ui';
-import { makeStyles } from '@jbrowse/core/util/tss-react';
-import { Button, DialogActions, DialogContent, FormControl, FormControlLabel, FormLabel, Radio, RadioGroup, TextField, } from '@mui/material';
+import { FormControl, FormControlLabel, FormLabel, Radio, RadioGroup, } from '@mui/material';
 import { observer } from 'mobx-react';
+import { NumberTextField, SubmitDialog } from '../../../ui/index.js';
+import { makeStyles } from '../../../util/tss-react/index.js';
 const useStyles = makeStyles()(theme => ({
     formElt: {
         margin: theme.spacing(3),
@@ -16,33 +16,25 @@ const useStyles = makeStyles()(theme => ({
         padding: 4,
     },
 }));
-function TextField2(props) {
-    return (_jsx("div", { children: _jsx(TextField, { ...props }) }));
-}
-function FormControl2({ children }) {
-    return (_jsx("div", { children: _jsx(FormControl, { children: children }) }));
-}
 const SequenceFeatureSettingsDialog = observer(function SequenceFeatureSettingsDialog({ handleClose, model, }) {
     const { classes } = useStyles();
     const { upperCaseCDS } = model;
-    const [intronBp, setIntronBp] = useState(`${model.intronBp}`);
-    const [upDownBp, setUpDownBp] = useState(`${model.upDownBp}`);
-    const intronBpValid = !Number.isNaN(+intronBp);
-    const upDownBpValid = !Number.isNaN(+upDownBp);
-    return (_jsxs(Dialog, { maxWidth: "xl", open: true, onClose: () => {
-            handleClose();
-        }, title: "Feature sequence settings", children: [_jsxs(DialogContent, { className: classes.dialogContent, children: [_jsx(TextField2, { label: "Number of intronic bases around splice site to display", className: classes.formElt, value: intronBp, helperText: !intronBpValid ? 'Not a number' : '', error: !intronBpValid, onChange: event => {
-                            setIntronBp(event.target.value);
-                        } }), _jsx(TextField2, { label: "Number of bases up/down stream of feature to display", className: classes.formElt, value: upDownBp, helperText: !upDownBpValid ? 'Not a number' : '', error: !upDownBpValid, onChange: event => {
-                            setUpDownBp(event.target.value);
-                        } }), _jsxs(FormControl2, { children: [_jsx(FormLabel, { children: "Sequence capitalization" }), _jsxs(RadioGroup, { value: upperCaseCDS ? 'cds' : 'unchanged', onChange: e => {
+    const [intronBp, setIntronBp] = useState(model.intronBp);
+    const [upDownBp, setUpDownBp] = useState(model.upDownBp);
+    const [charactersPerRow, setCharactersPerRow] = useState(model.charactersPerRow);
+    return (_jsx(SubmitDialog, { maxWidth: "xl", open: true, title: "Feature sequence settings", submitDisabled: intronBp === undefined ||
+            upDownBp === undefined ||
+            charactersPerRow === undefined, onCancel: handleClose, onSubmit: () => {
+            if (intronBp !== undefined &&
+                upDownBp !== undefined &&
+                charactersPerRow !== undefined) {
+                model.setIntronBp(intronBp);
+                model.setUpDownBp(upDownBp);
+                model.setCharactersPerRow(charactersPerRow);
+                handleClose();
+            }
+        }, children: _jsxs("div", { className: classes.dialogContent, children: [_jsx("div", { children: _jsx(NumberTextField, { label: "Number of intronic bases around splice site to display", className: classes.formElt, defaultValue: model.intronBp, onValueChange: setIntronBp }) }), _jsx("div", { children: _jsx(NumberTextField, { label: "Number of bases up/down stream of feature to display", className: classes.formElt, defaultValue: model.upDownBp, onValueChange: setUpDownBp }) }), _jsx("div", { children: _jsx(NumberTextField, { label: "Number of bases per row", className: classes.formElt, defaultValue: model.charactersPerRow, onValueChange: setCharactersPerRow }) }), _jsx("div", { children: _jsxs(FormControl, { children: [_jsx(FormLabel, { children: "Sequence capitalization" }), _jsxs(RadioGroup, { value: upperCaseCDS ? 'cds' : 'unchanged', onChange: e => {
                                     model.setUpperCaseCDS(e.target.value === 'cds');
-                                }, children: [_jsx(FormControlLabel, { value: "cds", control: _jsx(Radio, { className: classes.root, size: "small" }), label: "Capitalize CDS and lower case everything else" }), _jsx(FormControlLabel, { value: "unchanged", control: _jsx(Radio, { className: classes.root, size: "small" }), label: "Capitalization from reference genome sequence" })] })] })] }), _jsxs(DialogActions, { children: [_jsx(Button, { onClick: () => {
-                            model.setIntronBp(+intronBp);
-                            model.setUpDownBp(+upDownBp);
-                            handleClose();
-                        }, disabled: !intronBpValid || !upDownBpValid, color: "primary", variant: "contained", children: "Submit" }), _jsx(Button, { onClick: () => {
-                            handleClose();
-                        }, color: "secondary", autoFocus: true, variant: "contained", children: "Cancel" })] })] }));
+                                }, children: [_jsx(FormControlLabel, { value: "cds", control: _jsx(Radio, { className: classes.root, size: "small" }), label: "Capitalize CDS and lower case everything else" }), _jsx(FormControlLabel, { value: "unchanged", control: _jsx(Radio, { className: classes.root, size: "small" }), label: "Capitalization from reference genome sequence" })] })] }) })] }) }));
 });
 export default SequenceFeatureSettingsDialog;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/dialogs/TranscriptSelector.d.ts

@@ -0,0 +1,6 @@
+import type { SimpleFeatureSerialized } from '../../../util/index.ts';
+export default function TranscriptSelector({ transcripts, transcriptIndex, setTranscriptIndex, }: {
+    transcripts: SimpleFeatureSerialized[];
+    transcriptIndex: number;
+    setTranscriptIndex: (index: number) => void;
+}): import("react").JSX.Element;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/dialogs/TranscriptSelector.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormControl, MenuItem, Select } from '@mui/material';
+import { makeStyles } from '../../../util/tss-react/index.js';
+const useStyles = makeStyles()({
+    formControl: {
+        margin: 0,
+        marginRight: 4,
+    },
+});
+// Only rendered when a container feature (a gene) has more than one
+// transcript child — picks which transcript's exon/CDS structure the
+// sequence-type selector and body compute from.
+export default function TranscriptSelector({ transcripts, transcriptIndex, setTranscriptIndex, }) {
+    const { classes } = useStyles();
+    return (_jsx(FormControl, { className: classes.formControl, children: _jsx(Select, { size: "small", value: transcriptIndex, onChange: event => {
+                setTranscriptIndex(Number(event.target.value));
+            }, "aria-label": "Transcript", children: transcripts.map((transcript, idx) => (_jsx(MenuItem, { value: idx, "data-testid": `transcript_${idx}`, children: transcript.name || transcript.id || `Transcript ${idx + 1}` }, transcript.uniqueId))) }) }));
+}

package/esm/BaseFeatureWidget/SequenceFeatureDetails/featureTypeUtil.d.ts

@@ -0,0 +1,12 @@
+import type { SimpleFeatureSerialized, SimpleFeatureSerializedNoId } from '../../util/index.ts';
+import type { SequenceDisplayMode, ShowCoordinatesMode } from './model.ts';
+export declare function featureHasCDS(feature: SimpleFeatureSerializedNoId): boolean;
+export declare function featureHasExon(feature: SimpleFeatureSerializedNoId): boolean;
+export declare function featureHasExonOrCDS(feature: SimpleFeatureSerializedNoId): boolean;
+export declare function getTranscripts(feature: SimpleFeatureSerialized): SimpleFeatureSerialized[];
+export declare function pickDefaultTranscriptIndex(transcripts: SimpleFeatureSerialized[]): number;
+export declare function getDefaultMode(feature: SimpleFeatureSerializedNoId): SequenceDisplayMode;
+export declare function modeHasUpDownstream(mode: SequenceDisplayMode): boolean;
+export declare function modeSupportsRevcomp(mode: SequenceDisplayMode): boolean;
+export declare function showGenomicCoordsOption(mode: SequenceDisplayMode): boolean;
+export declare function resolveShowCoordinates(setting: ShowCoordinatesMode, mode: SequenceDisplayMode): ShowCoordinatesMode;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/featureTypeUtil.js

@@ -0,0 +1,97 @@
+// these predicates only ever read type/subfeatures, so they accept a bare
+// subfeature (no guaranteed uniqueId) as readily as a full feature
+export function featureHasCDS(feature) {
+    if (feature.type?.toLowerCase() === 'mature_protein_region_of_cds') {
+        return true;
+    }
+    return (feature.subfeatures?.some(sub => {
+        const type = sub.type?.toLowerCase();
+        return type === 'cds' || type === 'mature_protein_region_of_cds';
+    }) ?? false);
+}
+export function featureHasExon(feature) {
+    return (feature.subfeatures?.some(sub => sub.type?.toLowerCase() === 'exon') ??
+        false);
+}
+export function featureHasExonOrCDS(feature) {
+    return featureHasExon(feature) || featureHasCDS(feature);
+}
+// A container feature's (e.g. a gene's) direct subfeatures that are
+// themselves transcripts (have their own exon/CDS). An actual transcript's
+// exon/CDS children don't have exon/CDS of their own, so this bottoms out
+// one level down without a type-name allowlist. Synthesizes a uniqueId the
+// same way FeatureDetails does for nested subfeature cards, since a
+// subfeature isn't guaranteed one by its type.
+export function getTranscripts(feature) {
+    return (feature.subfeatures
+        ?.filter(sub => featureHasExonOrCDS(sub))
+        .map((sub, idx) => ({
+        ...sub,
+        uniqueId: `${feature.uniqueId}_${idx}`,
+    })) ?? []);
+}
+// index of the transcript the gene glyph itself would collapse to in
+// 'longestCoding' mode (RenderFeatureDataRPC/glyphs/subfeatures.ts): prefer a
+// coding transcript, then the longest span — so the sequence panel's default
+// matches what the track already drew. A feature that is itself a transcript
+// (clicked directly, not via its container gene) has no nested transcripts to
+// autopick from.
+export function pickDefaultTranscriptIndex(transcripts) {
+    if (transcripts.length === 0) {
+        return 0;
+    }
+    const coding = transcripts.filter(t => featureHasCDS(t));
+    const candidates = coding.length > 0 ? coding : transcripts;
+    const longest = candidates.reduce((a, b) => b.end - b.start > a.end - a.start ? b : a);
+    return transcripts.indexOf(longest);
+}
+export function getDefaultMode(feature) {
+    return featureHasCDS(feature)
+        ? 'cds'
+        : featureHasExon(feature)
+            ? 'cdna'
+            : 'genomic';
+}
+// whether the mode renders up/downstream flanks. shared by the sequence body
+// (which fetches+renders the flanks) and the FASTA header (which annotates
+// them) so the two can't drift, e.g. gene_updownstream_collapsed_intron
+// contains 'updownstream' but does not end with it
+export function modeHasUpDownstream(mode) {
+    return mode.includes('updownstream');
+}
+// reverse complement reads the opposite strand of the genome, so it is offered
+// for the genomic sequence types only: the antisense of a spliced cDNA, of an
+// annotated CDS, or of a translated peptide is not a sequence anyone asked for.
+// Shared by the menu (which offers it) and the panel (which applies it) so a
+// toggle left on in a genomic mode can't silently flip a cDNA readout.
+export function modeSupportsRevcomp(mode) {
+    return [
+        'gene',
+        'gene_collapsed_intron',
+        'gene_updownstream',
+        'gene_updownstream_collapsed_intron',
+        'genomic',
+        'genomic_sequence_updownstream',
+    ].includes(mode);
+}
+// genomic coordinates only make sense for continuous genome-based sequence
+// types (not collapsed-intron or spliced views)
+export function showGenomicCoordsOption(mode) {
+    return [
+        'gene',
+        'gene_updownstream',
+        'genomic',
+        'genomic_sequence_updownstream',
+    ].includes(mode);
+}
+// The coordinate mode a given sequence type actually renders. The setting is
+// sticky and global, so a 'genomic' preference picked in e.g. gene mode
+// survives a switch to a spliced mode that cannot label genomic positions;
+// there it falls back to relative. Shared by the seqtypes (which render it) and
+// the menu (which shows it as the checked radio) so the panel can't display one
+// coordinate mode while the menu reports another.
+export function resolveShowCoordinates(setting, mode) {
+    return setting === 'genomic' && !showGenomicCoordsOption(mode)
+        ? 'relative'
+        : setting;
+}

package/esm/BaseFeatureWidget/SequenceFeatureDetails/index.js

@@ -1 +1 @@
-export { default } from "./SequenceFeaturePanel.js";
+export { default } from './SequenceFeaturePanel.js';

package/esm/BaseFeatureWidget/SequenceFeatureDetails/model.d.ts

@@ -1,79 +1,66 @@
-import type { SimpleFeatureSerialized } from '../../util/index.ts';
 import type { Instance } from '@jbrowse/mobx-state-tree';
-type ShowCoordinatesMode = 'none' | 'relative' | 'genomic';
-type SequenceDisplayMode = '' | 'gene' | 'gene_collapsed_intron' | 'gene_updownstream' | 'cdna' | 'cds' | 'genomic' | 'genomic_sequence_updownstream' | 'protein';
+export type ShowCoordinatesMode = 'none' | 'relative' | 'genomic';
+export interface SequenceHoverPosition {
+    refName: string;
+    start: number;
+    end: number;
+    assemblyName?: string;
+}
+export interface SequenceHoverTarget {
+    setSequenceHoverPosition: (pos: SequenceHoverPosition | undefined) => void;
+}
+export type SequenceDisplayMode = 'gene' | 'gene_collapsed_intron' | 'gene_updownstream' | 'gene_updownstream_collapsed_intron' | 'cdna' | 'cds' | 'genomic' | 'genomic_sequence_updownstream' | 'protein';
 export declare function SequenceFeatureDetailsF(): import("@jbrowse/mobx-state-tree").IModelType<{}, {
-    showCoordinatesSetting: string;
+    /**
+     * #volatile
+     */
+    showCoordinatesSetting: ShowCoordinatesMode;
+    /**
+     * #volatile
+     */
     intronBp: number;
+    /**
+     * #volatile
+     */
     upDownBp: number;
+    /**
+     * #volatile
+     */
     upperCaseCDS: boolean;
+    /**
+     * #volatile
+     * how wide a row of the readout is. Rows exist only while coordinates are
+     * shown — without them the panel wraps to its container — so this is what
+     * the labels step by, and the line width of the FASTA exported from that
+     * state.
+     */
     charactersPerRow: number;
-    feature: SimpleFeatureSerialized | undefined;
-    mode: SequenceDisplayMode;
 } & {
-    setFeature(f: SimpleFeatureSerialized): void;
+    /**
+     * #action
+     */
     setUpDownBp(f: number): void;
+    /**
+     * #action
+     */
     setIntronBp(f: number): void;
+    /**
+     * #action
+     */
     setUpperCaseCDS(f: boolean): void;
+    /**
+     * #action
+     */
+    setCharactersPerRow(f: number): void;
+    /**
+     * #action
+     */
     setShowCoordinates(f: ShowCoordinatesMode): void;
-    setMode(mode: SequenceDisplayMode): void;
 } & {
+    /**
+     * #getter
+     */
     readonly showCoordinates: boolean;
-    readonly showGenomicCoordsOption: boolean;
-    readonly hasCDS: boolean | undefined;
-    readonly hasExon: boolean | undefined;
-    readonly hasExonOrCDS: boolean | undefined;
-} & {
-    afterCreate(): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
-export declare function createSequenceFeatureDetailsModel(): {} & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
-    showCoordinatesSetting: string;
-    intronBp: number;
-    upDownBp: number;
-    upperCaseCDS: boolean;
-    charactersPerRow: number;
-    feature: SimpleFeatureSerialized | undefined;
-    mode: SequenceDisplayMode;
-} & {
-    setFeature(f: SimpleFeatureSerialized): void;
-    setUpDownBp(f: number): void;
-    setIntronBp(f: number): void;
-    setUpperCaseCDS(f: boolean): void;
-    setShowCoordinates(f: ShowCoordinatesMode): void;
-    setMode(mode: SequenceDisplayMode): void;
-} & {
-    readonly showCoordinates: boolean;
-    readonly showGenomicCoordsOption: boolean;
-    readonly hasCDS: boolean | undefined;
-    readonly hasExon: boolean | undefined;
-    readonly hasExonOrCDS: boolean | undefined;
-} & {
-    afterCreate(): void;
-} & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{}, {
-    showCoordinatesSetting: string;
-    intronBp: number;
-    upDownBp: number;
-    upperCaseCDS: boolean;
-    charactersPerRow: number;
-    feature: SimpleFeatureSerialized | undefined;
-    mode: SequenceDisplayMode;
-} & {
-    setFeature(f: SimpleFeatureSerialized): void;
-    setUpDownBp(f: number): void;
-    setIntronBp(f: number): void;
-    setUpperCaseCDS(f: boolean): void;
-    setShowCoordinates(f: ShowCoordinatesMode): void;
-    setMode(mode: SequenceDisplayMode): void;
-} & {
-    readonly showCoordinates: boolean;
-    readonly showGenomicCoordsOption: boolean;
-    readonly hasCDS: boolean | undefined;
-    readonly hasExon: boolean | undefined;
-    readonly hasExonOrCDS: boolean | undefined;
-} & {
-    afterCreate(): void;
-}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
-export declare function destroySequenceFeatureDetailsModel(model: SequenceFeatureDetailsModel): void;
 export type SequenceFeatureDetailsStateModel = ReturnType<typeof SequenceFeatureDetailsF>;
 export type SequenceFeatureDetailsModel = Instance<SequenceFeatureDetailsStateModel>;
-export {};