@jbrowse/plugin-linear-genome-view 4.3.0 → 5.0.0-beta.2

package/esm/LinearGenomeView/components/ZoomTransform.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { makeStyles } from '@jbrowse/core/util/tss-react';
+import { observer } from 'mobx-react';
+const useStyles = makeStyles()({
+    zoomContainer: {
+        position: 'absolute',
+        top: 0,
+        height: '100%',
+        width: '100%',
+        pointerEvents: 'none',
+    },
+    innerContainer: {
+        position: 'absolute',
+        height: '100%',
+        pointerEvents: 'none',
+        // its own compositor layer: a pan then moves the layer instead of
+        // re-rasterizing the root layer's tiles, which paid for the gridline paths
+        // on every frame
+        willChange: 'transform',
+    },
+});
+// Shared zoom/scroll-transform wrapper for the gridline ticks and padding-block
+// overlays. Lays the overlay out in the staticBlocks frame and shifts it into
+// the viewport by `staticBlocksTranslateX`, so it tracks scroll — but a
+// re-render only patches this div's transform plus the child's path `d`
+// strings, so it stays cheap per frame.
+const ZoomTransform = observer(function ZoomTransform({ model, offset = 0, children, }) {
+    const { classes } = useStyles();
+    const { staticBlocks, staticBlocksTranslateX } = model;
+    return (_jsx("div", { className: classes.zoomContainer, children: _jsx("div", { className: classes.innerContainer, style: {
+                // unrounded, unlike ScalebarCoordinateLabels: the children here are
+                // paths and boxes rather than text, so there is no glyph to blur
+                transform: `translateX(${staticBlocksTranslateX - offset}px)`,
+                width: staticBlocks.totalWidthPx,
+            }, children: children }) }));
+});
+export default ZoomTransform;

package/esm/LinearGenomeView/components/defaultMotifs.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_MOTIFS = "# name<space>site \u2014 '^' or, cutting downstream, '(n/m)'. Edit freely.\nEcoRI   G^AATTC\nBamHI   G^GATCC\nHindIII A^AGCTT\nNotI    GC^GGCCGC\nXhoI    C^TCGAG\nSalI    G^TCGAC\nPstI    CTGCA^G\nSmaI    CCC^GGG\nKpnI    GGTAC^C\nSacI    GAGCT^C\nXbaI    T^CTAGA\nSpeI    A^CTAGT\nNcoI    C^CATGG\nNdeI    CA^TATG\nEcoRV   GAT^ATC\nBglII   A^GATCT";

package/esm/LinearGenomeView/components/defaultMotifs.js

@@ -0,0 +1,22 @@
+// A starting point, not a database: this is only the initial value of the motif
+// textarea, so a user can wipe it and paste their own enzyme set (or any motif
+// set at all) from REBASE or elsewhere. Sites use REBASE notation: '^' for a cut
+// inside the site, '(n/m)' for the type IIS enzymes that cut downstream of it —
+// the prefill sticks to the classic '^' cutters, but both parse.
+export const DEFAULT_MOTIFS = `# name<space>site — '^' or, cutting downstream, '(n/m)'. Edit freely.
+EcoRI   G^AATTC
+BamHI   G^GATCC
+HindIII A^AGCTT
+NotI    GC^GGCCGC
+XhoI    C^TCGAG
+SalI    G^TCGAC
+PstI    CTGCA^G
+SmaI    CCC^GGG
+KpnI    GGTAC^C
+SacI    GAGCT^C
+XbaI    T^CTAGA
+SpeI    A^CTAGT
+NcoI    C^CATGG
+NdeI    CA^TATG
+EcoRV   GAT^ATC
+BglII   A^GATCT`;

package/esm/LinearGenomeView/components/fetchSequence.d.ts

@@ -1,9 +1,8 @@
-import type { BpOffset } from '../types.ts';
-import type { Feature } from '@jbrowse/core/util';
+import type { StatusCallback } from '@jbrowse/core/util';
+import type { StopToken } from '@jbrowse/core/util/stopToken';
 import type { Region } from '@jbrowse/core/util/types';
-export declare function fetchSequence(model: {
-    leftOffset?: BpOffset;
-    rightOffset?: BpOffset;
-    getSelectedRegions: (left?: BpOffset, right?: BpOffset) => Region[];
-    setOffsets: (left?: BpOffset, right?: BpOffset) => void;
-}, regions: Region[]): Promise<Feature[]>;
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
+export declare function fetchSequence(model: IAnyStateTreeNode, regions: Region[], opts?: {
+    stopToken?: StopToken;
+    statusCallback?: StatusCallback;
+}): Promise<import("@jbrowse/core/util").Feature[]>;

package/esm/LinearGenomeView/components/fetchSequence.js

@@ -1,26 +1,34 @@
-import { getConf } from '@jbrowse/core/configuration';
+import { getSequenceAdapterConfig } from '@jbrowse/core/assemblyManager/assembly';
 import { getSession } from '@jbrowse/core/util';
-export async function fetchSequence(model, regions) {
+export async function fetchSequence(model, regions, opts = {}) {
     const session = getSession(model);
-    const { leftOffset, rightOffset } = model;
-    if (!leftOffset || !rightOffset) {
-        throw new Error('no offsets on model to use for range');
-    }
     const assemblyNames = new Set(regions.map(r => r.assemblyName));
     if (assemblyNames.size > 1) {
         throw new Error('not able to fetch sequences from multiple assemblies currently');
     }
     const { rpcManager, assemblyManager } = session;
-    const assemblyName = leftOffset.assemblyName || rightOffset.assemblyName || '';
+    const assemblyName = regions[0]?.assemblyName;
+    if (!assemblyName) {
+        throw new Error('no assemblyName found on the selected region');
+    }
     const assembly = assemblyManager.get(assemblyName);
     if (!assembly) {
         throw new Error(`assembly ${assemblyName} not found`);
     }
-    const adapterConfig = getConf(assembly, ['sequence', 'adapter']);
+    // Undefined here means the assembly's `configuration` safeReference is
+    // unresolved — the assembly outlived the config entry it points at. NOT an
+    // assembly whose sequence carries no residues: a ChromSizesAdapter one still
+    // has a `sequence.adapter`, and fails later, inside the adapter. Say which
+    // this is; passing the undefined on fails in getAdapterPre as "could not
+    // determine adapter type", naming neither the assembly nor what was wanted.
+    const adapterConfig = getSequenceAdapterConfig(assembly);
+    if (!adapterConfig) {
+        throw new Error(`assembly ${assemblyName} has no resolved configuration, so its sequence adapter cannot be read`);
+    }
     const sessionId = 'getSequence';
     return rpcManager.call(sessionId, 'CoreGetFeatures', {
         adapterConfig,
         regions,
-        sessionId,
+        ...opts,
     });
 }

package/esm/LinearGenomeView/components/recentLocationsMenu.d.ts

@@ -0,0 +1,15 @@
+import BaseResult from '@jbrowse/core/TextSearch/BaseResults';
+import type { MenuItem, RecentLocation } from '@jbrowse/core/ui';
+/**
+ * What a navigated result is worth remembering as. The display string is what
+ * the row shows; the location is what reopening it opens, and is absent for a
+ * freehand query, whose label is the searchable thing. Paired with the
+ * `BaseResult` the menu rebuilds below so the round trip stays visible in one
+ * place: a row replayed through it records the same pair it came from.
+ */
+export declare function recentLocationOf(option: BaseResult): RecentLocation;
+export declare function recentLocationsMenu({ recentLocations, onNavigate, onClear, }: {
+    recentLocations: RecentLocation[];
+    onNavigate: (option: BaseResult) => void;
+    onClear: () => void;
+}): MenuItem[];

package/esm/LinearGenomeView/components/recentLocationsMenu.js

@@ -0,0 +1,36 @@
+import BaseResult from '@jbrowse/core/TextSearch/BaseResults';
+/**
+ * What a navigated result is worth remembering as. The display string is what
+ * the row shows; the location is what reopening it opens, and is absent for a
+ * freehand query, whose label is the searchable thing. Paired with the
+ * `BaseResult` the menu rebuilds below so the round trip stays visible in one
+ * place: a row replayed through it records the same pair it came from.
+ */
+export function recentLocationOf(option) {
+    return { label: option.getDisplayString(), loc: option.getLocation() };
+}
+// Builds the "Recent ▸" submenu shared by the header search box and the import
+// form overflow menus, so both surfaces stay identical. Empty when there is no
+// history yet, so the ⋮ button only appears once there is something to show.
+export function recentLocationsMenu({ recentLocations, onNavigate, onClear, }) {
+    return recentLocations.length
+        ? [
+            {
+                label: 'Recent',
+                subMenu: [
+                    ...recentLocations.map(({ label, loc }) => ({
+                        label,
+                        onClick: () => {
+                            // a row that recorded a location navigates straight to it; one
+                            // with only a label goes back through the search path, which is
+                            // where a freehand query resolved the first time
+                            onNavigate(new BaseResult({ label, locString: loc }));
+                        },
+                    })),
+                    { type: 'divider' },
+                    { label: 'Clear recent locations', onClick: onClear },
+                ],
+            },
+        ]
+        : [];
+}

package/esm/LinearGenomeView/components/searchModes.d.ts

@@ -0,0 +1,13 @@
+export interface SequenceSearchModel {
+    assemblyNames: string[];
+    launchTrack: (trackId: string) => Promise<unknown>;
+}
+export interface SequenceSearchModeProps {
+    model: SequenceSearchModel;
+    handleClose: () => void;
+}
+export declare function addReferenceScanTrack(model: SequenceSearchModel, args: {
+    trackId: string;
+    name: string;
+    adapter: Record<string, unknown>;
+}): void;

package/esm/LinearGenomeView/components/searchModes.js

@@ -0,0 +1,22 @@
+import { getSession, isSessionWithAddSessionTrack } from '@jbrowse/core/util';
+// Creates a FeatureTrack that scans the assembly's reference sequence and shows
+// it. `adapter` carries the type + params only: the scan adapters resolve the
+// sequence from the track's assembly at fetch time (getSequenceSubAdapter), so
+// no sequence adapter is baked into the track config here.
+export function addReferenceScanTrack(model, args) {
+    const session = getSession(model);
+    const assemblyName = model.assemblyNames[0];
+    if (isSessionWithAddSessionTrack(session)) {
+        session.addSessionTrackConf({
+            trackId: args.trackId,
+            name: args.name,
+            assemblyNames: [assemblyName],
+            type: 'FeatureTrack',
+            adapter: args.adapter,
+        });
+        void model.launchTrack(args.trackId);
+    }
+    else {
+        session.notify('This session does not support adding tracks', 'warning');
+    }
+}

package/esm/LinearGenomeView/components/trackLabelMenuItems.d.ts

@@ -0,0 +1,7 @@
+import type { LinearGenomeViewModel } from '../model.ts';
+import type { BaseTrackModel } from '@jbrowse/core/pluggableElementTypes/models';
+import type { MenuItem } from '@jbrowse/core/ui';
+export declare function getTrackOrderSubMenu({ view, track, }: {
+    view: LinearGenomeViewModel;
+    track: BaseTrackModel;
+}): MenuItem[];

package/esm/LinearGenomeView/components/trackLabelMenuItems.js

@@ -0,0 +1,67 @@
+import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown';
+import KeyboardArrowUpIcon from '@mui/icons-material/KeyboardArrowUp';
+import KeyboardDoubleArrowDownIcon from '@mui/icons-material/KeyboardDoubleArrowDown';
+import KeyboardDoubleArrowUpIcon from '@mui/icons-material/KeyboardDoubleArrowUp';
+import PushPinIcon from '@mui/icons-material/PushPin';
+// Pin/unpin and reorder items for a single track. Pinning is only meaningful in
+// a top-level view; the to-top/to-bottom jumps are redundant with up/down when
+// there are only two tracks, so they need a third track to appear.
+export function getTrackOrderSubMenu({ view, track, }) {
+    const { isTopLevelView, tracks } = view;
+    const { pinned } = track;
+    const canMove = tracks.length > 1;
+    const canJump = tracks.length > 2;
+    return [
+        ...(isTopLevelView
+            ? [
+                {
+                    label: pinned ? 'Unpin track' : 'Pin track',
+                    icon: PushPinIcon,
+                    onClick: () => {
+                        track.setPinned(!pinned);
+                    },
+                },
+            ]
+            : []),
+        ...(canJump
+            ? [
+                {
+                    label: 'Move track to top',
+                    icon: KeyboardDoubleArrowUpIcon,
+                    onClick: () => {
+                        view.moveTrackToTop(track.id);
+                    },
+                },
+            ]
+            : []),
+        ...(canMove
+            ? [
+                {
+                    label: 'Move track up',
+                    icon: KeyboardArrowUpIcon,
+                    onClick: () => {
+                        view.moveTrackUp(track.id);
+                    },
+                },
+                {
+                    label: 'Move track down',
+                    icon: KeyboardArrowDownIcon,
+                    onClick: () => {
+                        view.moveTrackDown(track.id);
+                    },
+                },
+            ]
+            : []),
+        ...(canJump
+            ? [
+                {
+                    label: 'Move track to bottom',
+                    icon: KeyboardDoubleArrowDownIcon,
+                    onClick: () => {
+                        view.moveTrackToBottom(track.id);
+                    },
+                },
+            ]
+            : []),
+    ];
+}

package/esm/LinearGenomeView/components/useRangeSelect.d.ts

@@ -1,84 +1,29 @@
-import type React from 'react';
 import type { LinearGenomeViewModel } from '../index.ts';
+import type React from 'react';
 interface AnchorPosition {
     offsetX: number;
     clientX: number;
     clientY: number;
-    isClick?: boolean;
+    isClick: boolean;
 }
 export declare function useRangeSelect(ref: React.RefObject<HTMLDivElement | null>, model: LinearGenomeViewModel, shiftOnly?: boolean): {
     open: boolean;
     isClick: boolean | undefined;
-    clickBpOffset: {
-        coord: number;
-        index: number;
-        refName: string;
-        oob: boolean;
-        assemblyName: string;
-        offset: number;
-        start: number;
-        end: number;
-        reversed?: boolean;
-    } | undefined;
-    guideX: number | undefined;
-    mouseDown: (event: React.MouseEvent<HTMLDivElement>) => void;
-    mouseMove: (event: React.MouseEvent<HTMLDivElement>) => void;
-    mouseOut: () => void;
-    handleClose: () => void;
-    handleMenuItemClick: (_: unknown, callback: () => void) => void;
-    anchorPosition: AnchorPosition | undefined;
-    rubberbandOn?: undefined;
-    leftBpOffset?: undefined;
-    rightBpOffset?: undefined;
-    numOfBpSelected?: undefined;
-    width?: undefined;
-    left?: undefined;
-} | {
-    open: boolean;
-    isClick: boolean | undefined;
-    clickBpOffset: {
-        coord: number;
-        index: number;
-        refName: string;
-        oob: boolean;
-        assemblyName: string;
-        offset: number;
-        start: number;
-        end: number;
-        reversed?: boolean;
-    } | undefined;
+    clickBpOffset: import("@jbrowse/core/util/Base1DUtils").PxToBpResult | undefined;
     guideX: number | undefined;
     rubberbandOn: boolean;
     mouseDown: (event: React.MouseEvent<HTMLDivElement>) => void;
     mouseMove: (event: React.MouseEvent<HTMLDivElement>) => void;
     mouseOut: () => void;
     handleClose: () => void;
-    handleMenuItemClick: (_: unknown, callback: () => void) => void;
-    leftBpOffset: {
-        coord: number;
-        index: number;
-        refName: string;
-        oob: boolean;
-        assemblyName: string;
-        offset: number;
-        start: number;
-        end: number;
-        reversed?: boolean;
-    };
-    rightBpOffset: {
-        coord: number;
-        index: number;
-        refName: string;
-        oob: boolean;
-        assemblyName: string;
-        offset: number;
-        start: number;
-        end: number;
-        reversed?: boolean;
-    };
+    handleMenuItemClick: (callback: () => void) => void;
     anchorPosition: AnchorPosition | undefined;
-    numOfBpSelected: number;
-    width: number;
-    left: number;
+    rubberband: {
+        leftBpOffset: ReturnType<LinearGenomeViewModel['pxToBp']>;
+        rightBpOffset: ReturnType<LinearGenomeViewModel['pxToBp']>;
+        numOfBpSelected: number;
+        width: number;
+        left: number;
+    } | undefined;
 };
 export {};

package/esm/LinearGenomeView/components/useRangeSelect.js

@@ -1,8 +1,10 @@
 import { useCallback, useEffect, useState } from 'react';
-import { getRelativeX } from "./util.js";
+import { getRelativeX } from '@jbrowse/core/util/getRelativeX';
 export function useRangeSelect(ref, model, shiftOnly) {
     const [startX, setStartX] = useState();
     const [currentX, setCurrentX] = useState();
+    // clientX and clientY used for anchorPosition for menu
+    // offsetX used for calculations about width of selection
     const [anchorPosition, setAnchorPosition] = useState();
     const [guideX, setGuideX] = useState();
     const mouseDragging = startX !== undefined && anchorPosition === undefined;
@@ -13,102 +15,99 @@ export function useRangeSelect(ref, model, shiftOnly) {
         setGuideX(undefined);
     }, []);
     useEffect(() => {
-        function computeOffsets(offsetX) {
-            if (startX === undefined) {
-                return;
-            }
-            const leftPx = Math.min(startX, offsetX);
-            const rightPx = Math.max(startX, offsetX);
-            return {
-                leftOffset: model.pxToBp(leftPx),
-                rightOffset: model.pxToBp(rightPx),
-            };
+        const el = ref.current;
+        if (!mouseDragging || !el) {
+            return;
         }
+        // the container's left edge is fixed for the duration of a drag, so measure
+        // it once here rather than calling getBoundingClientRect on every mousemove
+        const { left } = el.getBoundingClientRect();
         function globalMouseMove(event) {
-            if (ref.current && mouseDragging) {
-                const relativeX = getRelativeX(event, ref.current);
-                setCurrentX(relativeX);
-            }
+            setCurrentX(event.clientX - left);
         }
         function globalMouseUp(event) {
-            if (startX !== undefined && ref.current) {
-                const { clientX, clientY } = event;
-                const offsetX = getRelativeX(event, ref.current);
-                const isClick = Math.abs(offsetX - startX) <= 3;
-                if (isClick && model.scalebarRefNameClickPending) {
-                    setStartX(undefined);
-                    setCurrentX(undefined);
-                    return;
-                }
-                if (!isClick && model.scalebarRefNameClickPending) {
-                    model.setScalebarRefNameClickPending(false);
-                }
-                setAnchorPosition({
-                    offsetX,
-                    clientX,
-                    clientY,
-                    isClick,
-                });
-                if (isClick) {
-                    setGuideX(offsetX);
-                }
-                else {
-                    const args = computeOffsets(offsetX);
-                    if (args) {
-                        model.setOffsets(args.leftOffset, args.rightOffset);
-                    }
-                    setGuideX(undefined);
-                }
+            if (startX === undefined) {
+                return;
+            }
+            const { clientX, clientY } = event;
+            const offsetX = clientX - left;
+            const isClick = Math.abs(offsetX - startX) <= 3;
+            // Clear the flag unconditionally once consumed: the label's own onClick
+            // also clears it, but that only fires if mouseup lands on the label, so
+            // relying on it alone can leave the flag stuck (swallowing the next
+            // scalebar click) when mouseup drifts a few px off the label edge.
+            const startedOnRefLabel = model.scalebarRefNameClickPending;
+            if (startedOnRefLabel) {
+                model.setScalebarRefNameClickPending(false);
+            }
+            // A click that began on a scalebar refname label is handled by that
+            // label's onClick (opens its menu), not by the rubberband menu here.
+            // Drop the hover guide too: the label's menu covers it while it is open,
+            // and nothing else clears it, so picking an item like "Focus on X" left a
+            // red line stranded on the scalebar with the pointer nowhere near it
+            if (isClick && startedOnRefLabel) {
+                setStartX(undefined);
+                setCurrentX(undefined);
+                setGuideX(undefined);
+                return;
+            }
+            setAnchorPosition({ offsetX, clientX, clientY, isClick });
+            if (isClick) {
+                setGuideX(offsetX);
+            }
+            else {
+                model.setOffsets(model.pxToBp(Math.min(startX, offsetX)), model.pxToBp(Math.max(startX, offsetX)));
+                setGuideX(undefined);
             }
         }
-        if (mouseDragging) {
-            window.addEventListener('mousemove', globalMouseMove);
-            window.addEventListener('mouseup', globalMouseUp);
-            return () => {
-                window.removeEventListener('mousemove', globalMouseMove);
-                window.removeEventListener('mouseup', globalMouseUp);
-            };
+        function globalKeyDown(event) {
+            if (event.key === 'Escape') {
+                setStartX(undefined);
+                setCurrentX(undefined);
+            }
         }
-        return () => { };
-    }, [startX, mouseDragging, model, ref, handleClose]);
+        window.addEventListener('mousemove', globalMouseMove);
+        window.addEventListener('mouseup', globalMouseUp);
+        window.addEventListener('keydown', globalKeyDown);
+        return () => {
+            window.removeEventListener('mousemove', globalMouseMove);
+            window.removeEventListener('mouseup', globalMouseUp);
+            window.removeEventListener('keydown', globalKeyDown);
+        };
+    }, [startX, mouseDragging, model, ref]);
     function mouseDown(event) {
         if (shiftOnly && !event.shiftKey) {
             return;
         }
+        // a press with the refName menu already open reopens it on the label under
+        // the pointer; same stranded-guide reasoning as the mouseup path above
         if (model.isScalebarRefNameMenuOpen) {
+            setGuideX(undefined);
             return;
         }
         event.preventDefault();
         event.stopPropagation();
+        // clear any leftover menu/selection so a fresh drag isn't blocked by a
+        // stale anchorPosition keeping mouseDragging false
+        setAnchorPosition(undefined);
         const relativeX = getRelativeX(event, ref.current);
         setStartX(relativeX);
         setCurrentX(relativeX);
     }
     function mouseMove(event) {
+        // Keep the rubberband visible while a drag-selection menu is open
         if (anchorPosition?.isClick === false) {
             return;
         }
-        if (mouseDragging) {
-            setGuideX(undefined);
-        }
-        else if (shiftOnly) {
-            if (event.shiftKey) {
-                setGuideX(getRelativeX(event, ref.current));
-            }
-            else {
-                setGuideX(undefined);
-            }
-        }
-        else {
-            setGuideX(getRelativeX(event, ref.current));
-        }
+        const wantsGuide = !mouseDragging && (!shiftOnly || event.shiftKey);
+        setGuideX(wantsGuide ? getRelativeX(event, ref.current) : undefined);
     }
     function mouseOut() {
         if (!anchorPosition?.isClick) {
             setGuideX(undefined);
         }
     }
-    function handleMenuItemClick(_, callback) {
+    function handleMenuItemClick(callback) {
         callback();
         handleClose();
     }
@@ -117,42 +116,34 @@ export function useRangeSelect(ref, model, shiftOnly) {
     const clickBpOffset = isClick
         ? model.pxToBp(anchorPosition.offsetX)
         : undefined;
-    if (startX === undefined) {
-        return {
-            open,
-            isClick,
-            clickBpOffset,
-            guideX,
-            mouseDown,
-            mouseMove,
-            mouseOut,
-            handleClose,
-            handleMenuItemClick,
-            anchorPosition,
+    // rubberband geometry only exists while a drag is in progress (startX set);
+    // grouped so a single truthiness check narrows all fields for RubberbandSpan
+    let rubberband;
+    if (startX !== undefined) {
+        const right = anchorPosition ? anchorPosition.offsetX : (currentX ?? startX);
+        const left = Math.min(right, startX);
+        const width = Math.abs(right - startX);
+        rubberband = {
+            leftBpOffset: model.pxToBp(left),
+            rightBpOffset: model.pxToBp(left + width),
+            numOfBpSelected: Math.ceil(width * model.bpPerPx),
+            width,
+            left,
         };
     }
-    const right = anchorPosition ? anchorPosition.offsetX : currentX || 0;
-    const left = Math.min(right, startX);
-    const width = Math.abs(right - startX);
-    const leftBpOffset = model.pxToBp(left);
-    const rightBpOffset = model.pxToBp(left + width);
-    const numOfBpSelected = Math.ceil(width * model.bpPerPx);
     return {
         open,
         isClick,
         clickBpOffset,
         guideX,
-        rubberbandOn: !isClick,
+        // true only mid-drag and not a click — drives RubberbandSpan vs guide
+        rubberbandOn: rubberband !== undefined && !isClick,
         mouseDown,
         mouseMove,
         mouseOut,
         handleClose,
         handleMenuItemClick,
-        leftBpOffset,
-        rightBpOffset,
         anchorPosition,
-        numOfBpSelected,
-        width,
-        left,
+        rubberband,
     };
 }

package/esm/LinearGenomeView/components/useSearchBoxPrefs.d.ts

@@ -0,0 +1,26 @@
+import type { MenuItem } from '@jbrowse/core/ui';
+/**
+ * Visibility and orientation of the search-box strip a stacked-LGV header
+ * draws, persisted per regime (few vs many rows) rather than under one global
+ * key, so the "compact default" heuristic isn't permanently overridden by a
+ * choice made in a differently-sized view.
+ *
+ * `prefix` keys the storage per container — the comparative view and the
+ * breakpoint split view remember their own. Everything else is shared, because
+ * the two headers held a copy each and the copies carried a comment telling the
+ * next editor to change the labels in both. They already import
+ * `HeaderSearchBoxRow` from this plugin, so the shared home costs no new
+ * dependency edge.
+ */
+export declare function useSearchBoxPrefs(prefix: string, numViews: number): {
+    showSearchBoxes: boolean;
+    setShowSearchBoxes: (value: boolean | ((val: boolean) => boolean)) => void;
+    sideBySide: boolean;
+    setSideBySide: (value: boolean | ((val: boolean) => boolean)) => void;
+};
+export type SearchBoxPrefs = ReturnType<typeof useSearchBoxPrefs>;
+/**
+ * The menu rows that drive those prefs. "Stacked" rather than "Vertical": the
+ * two headers name the same state and had drifted apart on it once already.
+ */
+export declare function searchBoxMenuItems({ showSearchBoxes, setShowSearchBoxes, sideBySide, setSideBySide, }: SearchBoxPrefs): MenuItem[];