@jbrowse/core 4.3.0 → 5.0.0-beta.2

package/esm/ui/filterMenuItems.js

@@ -0,0 +1,86 @@
+import FilterAltIcon from '@mui/icons-material/FilterAlt';
+import FilterAltOffIcon from '@mui/icons-material/FilterAltOff';
+/** Total in effect — what a "(n)" in a group label counts. */
+export function activeCount(items) {
+    return Object.values(items).reduce((a, b) => a + b.count, 0);
+}
+/**
+ * Reverse every one. Inactive entries are cleared too (their `clear` is a
+ * no-op), so this stays a plain fold rather than a filtered one — a caller
+ * cannot half-clear by getting the gate wrong.
+ */
+export function clearAll(items) {
+    for (const item of Object.values(items)) {
+        item.clear();
+    }
+}
+/**
+ * The undo rows: one per entry that is in effect AND names itself. Spread,
+ * don't insert — an entry holding nothing contributes nothing.
+ */
+export function undoItems(items, priority) {
+    return Object.values(items)
+        .filter(item => item.count > 0 && item.label)
+        .map(item => ({
+        label: item.label(item.count),
+        icon: item.icon,
+        priority,
+        onClick: () => {
+            item.clear();
+        },
+    }));
+}
+/**
+ * The "Filter by..." family, in the one shape every display uses.
+ *
+ * On a track with nothing to recover this is the single dialog opener, because
+ * a submenu wrapping one row is pure indirection. Once filters are on — or a
+ * display contributes its own inline controls — the recovery rows join it and
+ * the group earns its submenu, with the dialog opener as its first row.
+ *
+ * Spread, don't insert: a display with neither a dialog nor sub-items (a
+ * pre-computed LD file has nothing to filter) contributes no row at all.
+ *
+ * Written once because the four copies had drifted into four designs, and only
+ * the alignments one put the active count in the label — so a filtered LD or
+ * multi-sample variant track said nothing, anywhere, about the rows it was
+ * dropping.
+ */
+export function filterMenuItems({ narrowings, activeCount: explicitCount = 0, onEdit, subItems = [], recoveryItems: explicitRecovery = [], onClear: explicitClear, priority, editLabel = 'Edit filters...', }) {
+    // One declaration drives all three, or the caller supplies them separately —
+    // the pre-`Reversible` shape, kept for the displays that haven't adopted it.
+    const count = narrowings ? activeCount(narrowings) : explicitCount;
+    const recoveryItems = narrowings ? undoItems(narrowings) : explicitRecovery;
+    const onClear = narrowings
+        ? () => {
+            clearAll(narrowings);
+        }
+        : explicitClear;
+    const label = count > 0 ? `Filter by... (${count})` : 'Filter by...';
+    const editItem = onEdit
+        ? [
+            {
+                label: editLabel,
+                icon: FilterAltIcon,
+                onClick: onEdit,
+            },
+        ]
+        : [];
+    const clearItem = onClear && count > 0
+        ? [
+            {
+                label: 'Clear all filters',
+                icon: FilterAltOffIcon,
+                onClick: onClear,
+            },
+        ]
+        : [];
+    const rows = [...editItem, ...subItems, ...recoveryItems, ...clearItem];
+    if (!rows.length) {
+        return [];
+    }
+    // the lone dialog opener stays a top-level row rather than a one-item submenu
+    return rows.length === 1 && onEdit
+        ? [{ label, icon: FilterAltIcon, priority, onClick: onEdit }]
+        : [{ label, icon: FilterAltIcon, priority, type: 'subMenu', subMenu: rows }];
+}

package/esm/ui/formatErrorStack.d.ts

@@ -0,0 +1 @@
+export declare function formatErrorStack(error: unknown): string;

package/esm/ui/formatErrorStack.js

@@ -0,0 +1,56 @@
+import { stripStackTraceMessage } from './stripStackTraceMessage.js';
+// An error's own .stack never includes its cause's stack, so the chain has to be
+// walked by hand — and the cause is usually where the real failure is, since the
+// wrappers (`new Error(msg, { cause: e })` in configurationSchema, mstUtils,
+// tracks, ...) only stack up frames from the machinery that caught it. Causes
+// survive the worker boundary intact (see rpc/serializeError), so this is the
+// last place the chain would otherwise be dropped.
+// guards against a pathologically long chain; cycles are caught by `seen`
+const MAX_CAUSE_DEPTH = 10;
+function getStack(error) {
+    return typeof error === 'object' && error !== null && 'stack' in error
+        ? `${error.stack}`
+        : '';
+}
+function getCause(error) {
+    return typeof error === 'object' && error !== null && 'cause' in error
+        ? error.cause
+        : undefined;
+}
+// an AggregateError's own stack points at whatever collected the failures, and
+// its message names none of them, so the sub-errors have to be walked the same
+// way causes are. PhasedScheduler throws one of these for every plugin that
+// fails to create its pluggable elements.
+function getAggregated(error) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'errors' in error &&
+        Array.isArray(error.errors)
+        ? error.errors
+        : [];
+}
+export function formatErrorStack(error) {
+    const parts = [];
+    const seen = new Set();
+    // a cause chain is linear but an aggregate branches, so both are walked from
+    // one queue; the label is decided when a child is enqueued
+    const queue = [{ error, label: '' }];
+    while (queue.length > 0 && parts.length < MAX_CAUSE_DEPTH) {
+        const { error: current, label } = queue.shift();
+        if (current !== undefined && current !== null && !seen.has(current)) {
+            seen.add(current);
+            // chrome prepends the message to every stack in the chain; drop it and
+            // reintroduce it as the "Caused by" label so both browsers read the same
+            const stack = stripStackTraceMessage(getStack(current), `${current}`).replace(/^\n/, '');
+            parts.push([label, stack].filter(Boolean).join('\n'));
+            const cause = getCause(current);
+            if (cause !== undefined && cause !== null) {
+                queue.push({ error: cause, label: `Caused by: ${cause}` });
+            }
+            for (const sub of getAggregated(current)) {
+                queue.push({ error: sub, label: `Aggregated error: ${sub}` });
+            }
+        }
+    }
+    return parts.filter(Boolean).join('\n');
+}

package/esm/ui/gpuFallback.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The page-wide escape from a lost GPU context, as the three things every
+ * presentation of it needs. React-free on purpose: the MUI banners take
+ * {@link default as GpuFallbackButton} next door, but the plain-chrome overlays
+ * an embedder gets are deliberately MUI-free and render their own `<button>`,
+ * so the only thing all of them can share is this.
+ *
+ * Sharing it is not tidiness. The tooltip below was already written out twice,
+ * word for word, in the two overlays that offered the button — and the ones that
+ * did not offer it at all (dotplot, synteny) were the actual bug: a lost context
+ * is page-wide, so those views are the *victims* of a budget some other view
+ * spent, and they were the ones left with no way out.
+ */
+export declare const GPU_FALLBACK_LABEL = "Use Canvas2D";
+export declare const GPU_FALLBACK_TOOLTIP = "Stop using the GPU for the rest of this session and draw with Canvas2D instead. Slower on dense data, but unaffected by how many views are open.";
+/**
+ * Whether this error is one switching to Canvas2D would actually fix, and the
+ * GPU is still on. Both halves matter: an over-allocation error's remedy is to
+ * zoom in rather than to change backend, and once the GPU is off the button is a
+ * no-op that only invites a second click.
+ *
+ * **Pass the GPU error itself, not a combined one.** The flag lives on the error
+ * object, so anything that has flattened errors into a string — synteny's level
+ * banner joins the GPU error with each display's fetch error for display —
+ * answers `false` here and silently drops the button.
+ */
+export declare function shouldOfferGpuFallback(error: unknown): boolean;
+/**
+ * Turn the GPU off for the rest of the page. The same switch `?renderer=canvas2d`
+ * throws, so every backend built afterwards is the Canvas2D one; the caller
+ * still has to retry the display it is showing this from.
+ */
+export declare function disableGpuRendering(): void;

package/esm/ui/gpuFallback.js

@@ -0,0 +1,39 @@
+import { isGpuRenderingDisabled, setGpuOverride, } from '@jbrowse/render-core/gpuDevice';
+import { isGpuContextLostError } from '@jbrowse/render-core/useRenderingBackend';
+/**
+ * The page-wide escape from a lost GPU context, as the three things every
+ * presentation of it needs. React-free on purpose: the MUI banners take
+ * {@link default as GpuFallbackButton} next door, but the plain-chrome overlays
+ * an embedder gets are deliberately MUI-free and render their own `<button>`,
+ * so the only thing all of them can share is this.
+ *
+ * Sharing it is not tidiness. The tooltip below was already written out twice,
+ * word for word, in the two overlays that offered the button — and the ones that
+ * did not offer it at all (dotplot, synteny) were the actual bug: a lost context
+ * is page-wide, so those views are the *victims* of a budget some other view
+ * spent, and they were the ones left with no way out.
+ */
+export const GPU_FALLBACK_LABEL = 'Use Canvas2D';
+export const GPU_FALLBACK_TOOLTIP = 'Stop using the GPU for the rest of this session and draw with Canvas2D instead. Slower on dense data, but unaffected by how many views are open.';
+/**
+ * Whether this error is one switching to Canvas2D would actually fix, and the
+ * GPU is still on. Both halves matter: an over-allocation error's remedy is to
+ * zoom in rather than to change backend, and once the GPU is off the button is a
+ * no-op that only invites a second click.
+ *
+ * **Pass the GPU error itself, not a combined one.** The flag lives on the error
+ * object, so anything that has flattened errors into a string — synteny's level
+ * banner joins the GPU error with each display's fetch error for display —
+ * answers `false` here and silently drops the button.
+ */
+export function shouldOfferGpuFallback(error) {
+    return isGpuContextLostError(error) && !isGpuRenderingDisabled();
+}
+/**
+ * Turn the GPU off for the rest of the page. The same switch `?renderer=canvas2d`
+ * throws, so every backend built afterwards is the Canvas2D one; the caller
+ * still has to retry the display it is showing this from.
+ */
+export function disableGpuRendering() {
+    setGpuOverride('canvas2d');
+}

package/esm/ui/highlightChipReveal.d.ts

@@ -0,0 +1,32 @@
+import type { MouseTracker } from './useMouseTracking.ts';
+export declare const OverlayPointerProvider: import("react").Provider<MouseTracker | undefined>;
+/**
+ * The stripe a band occupies: an x span across a full-height band, a y span
+ * across a full-width one. The other axis is the whole overlay, which is why it
+ * isn't here.
+ */
+export type HighlightStripe = {
+    left: number;
+    width: number;
+} | {
+    top: number;
+    height: number;
+};
+/**
+ * Whether a band should be drawing its chip, and the `setOpen` that keeps it
+ * drawn while its menu is up.
+ *
+ * A band reveals its chip while the pointer is in its stripe, so the highlight's
+ * menu is reachable where the highlight is rather than only from the view menu,
+ * and a view full of bands is not also a view full of link icons. `persistent`
+ * is the `showHighlightChips` pin, which a screenshot needs because nothing
+ * hovers in one.
+ *
+ * The menu is the reason this owns state at all: it is portalled out of the
+ * band, so opening it moves the pointer off the stripe that revealed it, and
+ * unmounting the chip under an open menu takes the menu's own anchor with it.
+ */
+export declare function useHighlightChip(stripe: HighlightStripe | undefined, persistent: boolean): {
+    chipVisible: boolean;
+    setMenuOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};

package/esm/ui/highlightChipReveal.js

@@ -0,0 +1,39 @@
+import { createContext, use, useState } from 'react';
+import { useMouseSelector } from './useMouseTracking.js';
+/**
+ * The pointer over the surface a view's highlight bands are positioned in — the
+ * LinearGenomeView's tracks container, the DotplotView's plot area. Published by
+ * whichever of those bound the handlers.
+ *
+ * A context rather than a prop because a band is often drawn by another plugin
+ * through an extension point (grid-bookmark's bookmark bands), and those carry
+ * only their `{ model }` props bag — the band families are siblings on screen
+ * and would otherwise reach the pointer two different ways.
+ */
+const OverlayPointerContext = createContext(undefined);
+export const OverlayPointerProvider = OverlayPointerContext.Provider;
+function pointerInStripe(stripe, state) {
+    return 'left' in stripe
+        ? state.x >= stripe.left && state.x < stripe.left + stripe.width
+        : state.y >= stripe.top && state.y < stripe.top + stripe.height;
+}
+/**
+ * Whether a band should be drawing its chip, and the `setOpen` that keeps it
+ * drawn while its menu is up.
+ *
+ * A band reveals its chip while the pointer is in its stripe, so the highlight's
+ * menu is reachable where the highlight is rather than only from the view menu,
+ * and a view full of bands is not also a view full of link icons. `persistent`
+ * is the `showHighlightChips` pin, which a screenshot needs because nothing
+ * hovers in one.
+ *
+ * The menu is the reason this owns state at all: it is portalled out of the
+ * band, so opening it moves the pointer off the stripe that revealed it, and
+ * unmounting the chip under an open menu takes the menu's own anchor with it.
+ */
+export function useHighlightChip(stripe, persistent) {
+    const tracker = use(OverlayPointerContext);
+    const [menuOpen, setMenuOpen] = useState(false);
+    const hovered = useMouseSelector(tracker, state => !!state && !!stripe && pointerInStripe(stripe, state));
+    return { chipVisible: persistent || hovered || menuOpen, setMenuOpen };
+}

package/esm/ui/hoverBoxStyle.d.ts

@@ -0,0 +1,11 @@
+import type { CSSProperties } from 'react';
+/**
+ * The hover mark for a cell or block on a canvas display: a white wash plus a
+ * dark border, never a color tint — the cell colors are the data, and a tint
+ * washes them out.
+ *
+ * One definition because the alternative was proven to fail: `highlightBoxColors`
+ * exists for the same reason, after two backends drifted apart on their own alpha
+ * literals kept in step by a comment.
+ */
+export declare const hoverBoxStyle: CSSProperties;

package/esm/ui/hoverBoxStyle.js

@@ -0,0 +1,13 @@
+/**
+ * The hover mark for a cell or block on a canvas display: a white wash plus a
+ * dark border, never a color tint — the cell colors are the data, and a tint
+ * washes them out.
+ *
+ * One definition because the alternative was proven to fail: `highlightBoxColors`
+ * exists for the same reason, after two backends drifted apart on their own alpha
+ * literals kept in step by a comment.
+ */
+export const hoverBoxStyle = {
+    border: '1px solid rgba(0,0,0,0.5)',
+    background: 'rgba(255,255,255,0.3)',
+};

package/esm/ui/index.d.ts

@@ -1,20 +1,92 @@
-export * from './theme.ts';
+export { type JBrowseTheme, type SerializableThemeArgs, type ThemeMap, colorFwdStrand, colorInterchrom, colorLongInsert, colorLongreadInv, colorNeutralRead, colorPairLL, colorPairLR, colorPairLRDark, colorPairRL, colorPairRR, colorRevStrand, colorShortInsert, colorSplitReadInversion, colorSupplementary, colorUnmappedMate, colorUnmappedMateDark, createJBrowseBaseTheme, createJBrowseTheme, createJBrowseThemeFromArgs, defaultThemes, methylated5hmC, methylated5mC, tagColorPalette, unmethylated5mC, } from './theme.ts';
+export { default as BaseExportSvgDialog } from './BaseExportSvgDialog.tsx';
+export type { BaseExportSvgOptions } from './BaseExportSvgDialog.tsx';
+export { default as ExportSvgDialog } from './ExportSvgDialog.tsx';
+export { useExportSvgPreference } from './useExportSvgPreference.ts';
 export { LogoFull, Logomark } from './Logo.tsx';
 export { default as AssemblySelector } from './AssemblySelector.tsx';
+export { useAssemblySelection } from './useAssemblySelection.ts';
+export { useRecentLocations } from './useRecentLocations.ts';
+export type { RecentLocation } from './useRecentLocations.ts';
+export { RefNameAutocompleteEndAdornment, adornmentReservePx, getInputWidth, default as RefNameAutocomplete, } from './RefNameAutocomplete/index.tsx';
 export { default as CascadingMenu } from './CascadingMenu.tsx';
 export { default as CascadingMenuButton } from './CascadingMenuButton.tsx';
+export { default as ContextMenu } from './ContextMenu.tsx';
+export type { ContextMenuAnchor } from './ContextMenu.tsx';
+export { CONTEXT_MENU_Z_INDEX, TOOLTIP_Z_INDEX } from './zIndexes.ts';
+export { default as ConfirmDialog } from './ConfirmDialog.tsx';
+export { default as JexlFilterDialog } from './JexlFilterDialog.tsx';
+export { default as CopyToClipboardButton } from './CopyToClipboardButton.tsx';
+export { useCopyToClipboard } from './useCopyToClipboard.ts';
 export { default as Dialog } from './Dialog.tsx';
 export { default as EditableTypography } from './EditableTypography.tsx';
+export { default as ErrorBanner } from './ErrorBanner.tsx';
+export { default as GpuFallbackButton } from './GpuFallbackButton.tsx';
 export { default as ErrorMessage } from './ErrorMessage.tsx';
 export { default as FatalErrorDialog } from './FatalErrorDialog.tsx';
 export { default as FileSelector } from './FileSelector/FileSelector.tsx';
+export { default as FileDropZone } from './FileDropZone.tsx';
+export { default as LabeledCheckbox } from './LabeledCheckbox.tsx';
 export { default as LoadingEllipses } from './LoadingEllipses.tsx';
+export { default as LoadingProgress } from './LoadingProgress.tsx';
+export { default as ViewLoadingScreen } from './ViewLoadingScreen.tsx';
+export { default as ProgressChip } from './ProgressChip.tsx';
+export { default as NumberTextField } from './NumberTextField.tsx';
+export { type TagQuickPick, default as TagTextField } from './TagTextField.tsx';
+export { default as MonospaceTextField } from './MonospaceTextField.tsx';
+export { default as ShareLinkField } from './ShareLinkField.tsx';
+export { default as SingleSlider } from './SingleSlider.tsx';
+export { default as SliderTooltip } from './SliderTooltip.tsx';
+export { makePromotableSizeMenu, makeSizeMenu, makeSizeSubMenu, } from './makeSizeMenu.tsx';
+export { INLINE_MENU_ROW_WIDTH, ResetToDefaultButton, } from './InlineMenuControls.tsx';
+export { sliderScale } from './sliderScale.ts';
+export type { SliderScale } from './sliderScale.ts';
+export { default as ErrorBar } from './ErrorBar.tsx';
+export { default as ErrorOverlay } from './ErrorOverlay.tsx';
+export { default as LoadingOverlay } from './LoadingOverlay.tsx';
+export { default as StatusProgressBar } from './StatusProgressBar.tsx';
 export { default as Menu } from './Menu.tsx';
 export { default as PrerenderedCanvas } from './PrerenderedCanvas.tsx';
 export { default as ResizeHandle } from './ResizeHandle.tsx';
+export { default as ScrollEdgeShadow } from './ScrollEdgeShadow.tsx';
+export { default as VerticalScrollbar } from './VerticalScrollbar.tsx';
+export { default as SubmitDialog } from './SubmitDialog.tsx';
+export { default as SubmitForm } from './SubmitForm.tsx';
+export { default as ReplaceCurrentViewButton } from './ReplaceCurrentViewButton.tsx';
+export { replaceViewAction } from './replaceViewAction.tsx';
+export { default as InfoDialog } from './InfoDialog.tsx';
+export { default as SettingsChangesTable } from './SettingsChangesTable.tsx';
+export { default as ActionLink } from './ActionLink.tsx';
 export { default as ExternalLink } from './ExternalLink.tsx';
 export { default as SanitizedHTML } from './SanitizedHTML.tsx';
-export { default as BaseTooltip } from './BaseTooltip.tsx';
-export * from './Menu.tsx';
-export * from './MenuTypes.ts';
+export { default as PluggableComponent } from './PluggableComponent.tsx';
+export { default as PluggableComponents } from './PluggableComponents.tsx';
+export type { ComponentExtensionPointName } from './PluggableComponents.tsx';
+export { default as PluggableElements } from './PluggableElements.tsx';
+export { addExtensionElement } from './addExtensionElement.tsx';
+export type { ElementExtensionPointName } from './addExtensionElement.tsx';
+export { wrapComponent } from './wrapComponent.tsx';
+export type { SlotExtensionPointName, SlotProps, WrapperProps, } from './wrapComponent.tsx';
+export { matchesTrackSelector } from './extensionSelectors.ts';
+export type { TrackSelector } from './extensionSelectors.ts';
+export type { BaseMenuItem, CheckboxMenuItem, ClickableMenuItem, CustomMenuItem, MenuDivider, MenuItem, MenuItemClickHandler, MenuItemsGetter, MenuSubHeader, NormalMenuItem, RadioMenuItem, SubMenuItem, } from './MenuTypes.ts';
+export { resolveSubMenu, staysOpenOnClick } from './MenuTypes.ts';
+export { LAUNCH_LABEL, pushIntoSubMenu, pushLaunchViewMenuItem, } from './launchViewMenu.ts';
+export { launchTargetsMenuItem } from './launchTargetsMenuItem.ts';
+export { default as Crosshairs } from './Crosshairs.tsx';
+export { hoverBoxStyle } from './hoverBoxStyle.ts';
+export { useMouseState, useMouseTracking } from './useMouseTracking.ts';
+export type { MouseState, MouseTracker } from './useMouseTracking.ts';
+export { PinAdornment } from './PinAdornment.tsx';
+export { promotableRadioItem, promotableRadioItems, promotableToggleItem, } from './promotableMenuItems.ts';
+export { displayTypesWithPromotableSlots, promotableSlotsWithoutPin, } from './promotablePinCoverage.ts';
 export declare const VIEW_HEADER_HEIGHT = 28;
+export { GRADIENT_LEGEND_HEIGHT, GRADIENT_LEGEND_SVG_AREA_WIDTH, GRADIENT_LEGEND_WIDTH, default as SvgGradientLegend, } from './SvgGradientLegend.tsx';
+export type { GradientLabel, GradientStop } from './SvgGradientLegend.tsx';
+export { LEGEND_ROW_HEIGHT, LEGEND_SWATCH, default as SvgColorLegend, } from './SvgColorLegend.tsx';
+export type { ColorLegendEntry } from './SvgColorLegend.tsx';
+export { measureLegendText } from './measureLegendText.ts';
+export { LegendSwatchGlyph } from './LegendSwatchGlyph.tsx';
+export { MAX_LEGEND_ITEMS, legendEntries, legendIsReadable, legendSwatches, nonEmptyLegendSections, } from './legendSpec.ts';
+export type { LegendItem, LegendMark, LegendSection, LegendSpec, LegendSwatch, } from './legendSpec.ts';
+export { checkboxItem, radioItems } from './toggleMenuItems.ts';

package/esm/ui/index.js

@@ -1,20 +1,91 @@
-export * from "./theme.js";
-export { LogoFull, Logomark } from "./Logo.js";
-export { default as AssemblySelector } from "./AssemblySelector.js";
-export { default as CascadingMenu } from "./CascadingMenu.js";
-export { default as CascadingMenuButton } from "./CascadingMenuButton.js";
-export { default as Dialog } from "./Dialog.js";
-export { default as EditableTypography } from "./EditableTypography.js";
-export { default as ErrorMessage } from "./ErrorMessage.js";
-export { default as FatalErrorDialog } from "./FatalErrorDialog.js";
-export { default as FileSelector } from "./FileSelector/FileSelector.js";
-export { default as LoadingEllipses } from "./LoadingEllipses.js";
-export { default as Menu } from "./Menu.js";
-export { default as PrerenderedCanvas } from "./PrerenderedCanvas.js";
-export { default as ResizeHandle } from "./ResizeHandle.js";
-export { default as ExternalLink } from "./ExternalLink.js";
-export { default as SanitizedHTML } from "./SanitizedHTML.js";
-export { default as BaseTooltip } from "./BaseTooltip.js";
-export * from "./Menu.js";
-export * from "./MenuTypes.js";
+export { colorFwdStrand, colorInterchrom, colorLongInsert, colorLongreadInv, colorNeutralRead, colorPairLL, colorPairLR, colorPairLRDark, colorPairRL, colorPairRR, colorRevStrand, colorShortInsert, colorSplitReadInversion, colorSupplementary, colorUnmappedMate, colorUnmappedMateDark, createJBrowseBaseTheme, createJBrowseTheme, createJBrowseThemeFromArgs, defaultThemes, methylated5hmC, methylated5mC, tagColorPalette, unmethylated5mC, } from './theme.js';
+export { default as BaseExportSvgDialog } from './BaseExportSvgDialog.js';
+export { default as ExportSvgDialog } from './ExportSvgDialog.js';
+export { useExportSvgPreference } from './useExportSvgPreference.js';
+export { LogoFull, Logomark } from './Logo.js';
+export { default as AssemblySelector } from './AssemblySelector.js';
+export { useAssemblySelection } from './useAssemblySelection.js';
+export { useRecentLocations } from './useRecentLocations.js';
+export { RefNameAutocompleteEndAdornment, adornmentReservePx, getInputWidth, default as RefNameAutocomplete, } from './RefNameAutocomplete/index.js';
+export { default as CascadingMenu } from './CascadingMenu.js';
+export { default as CascadingMenuButton } from './CascadingMenuButton.js';
+export { default as ContextMenu } from './ContextMenu.js';
+export { CONTEXT_MENU_Z_INDEX, TOOLTIP_Z_INDEX } from './zIndexes.js';
+export { default as ConfirmDialog } from './ConfirmDialog.js';
+export { default as JexlFilterDialog } from './JexlFilterDialog.js';
+export { default as CopyToClipboardButton } from './CopyToClipboardButton.js';
+export { useCopyToClipboard } from './useCopyToClipboard.js';
+export { default as Dialog } from './Dialog.js';
+export { default as EditableTypography } from './EditableTypography.js';
+export { default as ErrorBanner } from './ErrorBanner.js';
+export { default as GpuFallbackButton } from './GpuFallbackButton.js';
+export { default as ErrorMessage } from './ErrorMessage.js';
+export { default as FatalErrorDialog } from './FatalErrorDialog.js';
+export { default as FileSelector } from './FileSelector/FileSelector.js';
+export { default as FileDropZone } from './FileDropZone.js';
+export { default as LabeledCheckbox } from './LabeledCheckbox.js';
+export { default as LoadingEllipses } from './LoadingEllipses.js';
+export { default as LoadingProgress } from './LoadingProgress.js';
+export { default as ViewLoadingScreen } from './ViewLoadingScreen.js';
+export { default as ProgressChip } from './ProgressChip.js';
+export { default as NumberTextField } from './NumberTextField.js';
+export { default as TagTextField } from './TagTextField.js';
+export { default as MonospaceTextField } from './MonospaceTextField.js';
+export { default as ShareLinkField } from './ShareLinkField.js';
+export { default as SingleSlider } from './SingleSlider.js';
+export { default as SliderTooltip } from './SliderTooltip.js';
+export { makePromotableSizeMenu, makeSizeMenu, makeSizeSubMenu, } from './makeSizeMenu.js';
+export { INLINE_MENU_ROW_WIDTH, ResetToDefaultButton, } from './InlineMenuControls.js';
+export { sliderScale } from './sliderScale.js';
+export { default as ErrorBar } from './ErrorBar.js';
+export { default as ErrorOverlay } from './ErrorOverlay.js';
+export { default as LoadingOverlay } from './LoadingOverlay.js';
+export { default as StatusProgressBar } from './StatusProgressBar.js';
+export { default as Menu } from './Menu.js';
+export { default as PrerenderedCanvas } from './PrerenderedCanvas.js';
+export { default as ResizeHandle } from './ResizeHandle.js';
+export { default as ScrollEdgeShadow } from './ScrollEdgeShadow.js';
+export { default as VerticalScrollbar } from './VerticalScrollbar.js';
+export { default as SubmitDialog } from './SubmitDialog.js';
+export { default as SubmitForm } from './SubmitForm.js';
+export { default as ReplaceCurrentViewButton } from './ReplaceCurrentViewButton.js';
+export { replaceViewAction } from './replaceViewAction.js';
+export { default as InfoDialog } from './InfoDialog.js';
+export { default as SettingsChangesTable } from './SettingsChangesTable.js';
+export { default as ActionLink } from './ActionLink.js';
+export { default as ExternalLink } from './ExternalLink.js';
+export { default as SanitizedHTML } from './SanitizedHTML.js';
+// BaseTooltip is deliberately NOT re-exported here: it reaches @floating-ui
+// (~266KB), and this barrel is imported by eager plugin entries, so the
+// re-export alone held that dependency on the startup path. Every consumer
+// deep-imports '@jbrowse/core/ui/BaseTooltip' instead.
+export { default as PluggableComponent } from './PluggableComponent.js';
+export { default as PluggableComponents } from './PluggableComponents.js';
+export { default as PluggableElements } from './PluggableElements.js';
+export { addExtensionElement } from './addExtensionElement.js';
+export { wrapComponent } from './wrapComponent.js';
+export { matchesTrackSelector } from './extensionSelectors.js';
+export { resolveSubMenu, staysOpenOnClick } from './MenuTypes.js';
+export { LAUNCH_LABEL, pushIntoSubMenu, pushLaunchViewMenuItem, } from './launchViewMenu.js';
+export { launchTargetsMenuItem } from './launchTargetsMenuItem.js';
+export { default as Crosshairs } from './Crosshairs.js';
+export { hoverBoxStyle } from './hoverBoxStyle.js';
+export { useMouseState, useMouseTracking } from './useMouseTracking.js';
+export { PinAdornment } from './PinAdornment.js';
+export { promotableRadioItem, promotableRadioItems, promotableToggleItem, } from './promotableMenuItems.js';
+// Not on the React-free `menuItems.ts` entry beside the two builders above: this
+// reads a config's slot table, so it pulls `configuration/promotableSlots.ts`
+// in, and that entry exists precisely to stay out of every plugin's eager graph.
+//
+// `pinnedSlots`, the walk underneath it, stays module-private: the question a
+// caller has is "which promotable slots does this menu miss", and answering the
+// half of it that lists what a menu *does* offer needs the schema's slot table
+// to mean anything.
+export { displayTypesWithPromotableSlots, promotableSlotsWithoutPin, } from './promotablePinCoverage.js';
 export const VIEW_HEADER_HEIGHT = 28;
+export { GRADIENT_LEGEND_HEIGHT, GRADIENT_LEGEND_SVG_AREA_WIDTH, GRADIENT_LEGEND_WIDTH, default as SvgGradientLegend, } from './SvgGradientLegend.js';
+export { LEGEND_ROW_HEIGHT, LEGEND_SWATCH, default as SvgColorLegend, } from './SvgColorLegend.js';
+export { measureLegendText } from './measureLegendText.js';
+export { LegendSwatchGlyph } from './LegendSwatchGlyph.js';
+export { MAX_LEGEND_ITEMS, legendEntries, legendIsReadable, legendSwatches, nonEmptyLegendSections, } from './legendSpec.js';
+export { checkboxItem, radioItems } from './toggleMenuItems.js';

package/esm/ui/inlineMenuRowWidth.d.ts

@@ -0,0 +1 @@
+export declare const INLINE_MENU_ROW_WIDTH = 220;

package/esm/ui/inlineMenuRowWidth.js

@@ -0,0 +1,8 @@
+// Width of an inline menu row (a slider row, a stepper) in px.
+//
+// Its own module, and not a const in `InlineMenuControls.tsx`, because that file
+// imports MUI: a caller that wants only the number — to size a placeholder while
+// the real row loads, say — would otherwise pull `IconButton`, `Tooltip` and an
+// icon in with it. Same reason `ui/menuItems.ts` exists; see
+// reference/EAGER_BUNDLE.md.
+export const INLINE_MENU_ROW_WIDTH = 220;

package/esm/ui/launchTargetsMenuItem.d.ts

@@ -0,0 +1,18 @@
+import type { MenuItem } from './MenuTypes.ts';
+import type { SvgIconComponent } from '@mui/icons-material';
+/**
+ * One launch offer, over the datasets that can serve it: nothing at all when
+ * none can, otherwise a submenu naming each. Which dataset a launch reads from
+ * changes the answer, so the name is always on screen — a single dataset gets
+ * the same submenu as several rather than a flat item that leaves it unsaid.
+ *
+ * Kept apart from the discovery it is fed so the shape is testable on plain
+ * data.
+ */
+export declare function launchTargetsMenuItem<T>({ label, icon, entries, entryLabel, onSelect, }: {
+    label: string;
+    icon: SvgIconComponent;
+    entries: T[];
+    entryLabel: (entry: T) => string;
+    onSelect: (entry: T) => () => void;
+}): MenuItem[];

package/esm/ui/launchTargetsMenuItem.js

@@ -0,0 +1,24 @@
+/**
+ * One launch offer, over the datasets that can serve it: nothing at all when
+ * none can, otherwise a submenu naming each. Which dataset a launch reads from
+ * changes the answer, so the name is always on screen — a single dataset gets
+ * the same submenu as several rather than a flat item that leaves it unsaid.
+ *
+ * Kept apart from the discovery it is fed so the shape is testable on plain
+ * data.
+ */
+export function launchTargetsMenuItem({ label, icon, entries, entryLabel, onSelect, }) {
+    return entries.length
+        ? [
+            {
+                label,
+                icon,
+                type: 'subMenu',
+                subMenu: entries.map(entry => ({
+                    label: entryLabel(entry),
+                    onClick: onSelect(entry),
+                })),
+            },
+        ]
+        : [];
+}

package/esm/ui/launchViewMenu.d.ts

@@ -0,0 +1,4 @@
+import type { MenuItem } from './MenuTypes.ts';
+export declare const LAUNCH_LABEL = "Launch";
+export declare function pushIntoSubMenu(items: MenuItem[], label: string, item: MenuItem): void;
+export declare function pushLaunchViewMenuItem(items: MenuItem[], item: MenuItem): void;

package/esm/ui/launchViewMenu.js

@@ -0,0 +1,42 @@
+// The submenu every "open something for this region" contribution collects
+// under, in a track menu, a view menu and the rubberband menu alike. One word,
+// because half of what it now launches is not a view — a consensus dialog, the
+// MAF subsequence widget, a sequence readout — and the rubberband menu has
+// spelled it this way all along.
+export const LAUNCH_LABEL = 'Launch';
+// Add `item` under the `label` submenu of `items`, creating that submenu the
+// first time. What makes several plugins' contributions collect in one place
+// instead of each becoming its own top-level row, whatever order they ran in.
+export function pushIntoSubMenu(items, label, item) {
+    const existing = items.find((i) => i.type === 'subMenu' && i.label === label);
+    if (existing) {
+        const { subMenu } = existing;
+        if (typeof subMenu === 'function') {
+            existing.subMenu = () => [...subMenu(), item];
+        }
+        else {
+            subMenu.push(item);
+        }
+    }
+    else {
+        items.push({ label, type: 'subMenu', subMenu: [item] });
+    }
+}
+// Several independent plugins (dotplot-view, linear-comparative-view, …) each
+// contribute one "open another view for this feature" context-menu item. Call
+// this instead of pushing a top-level item so the contributions land in a
+// single "Launch" submenu regardless of which plugin's extension runs
+// first. The `group` option on `addViewMenuItems`/`addDisplayMenuItems` does the
+// same thing for a contributor registered that way, and is the shorter road to
+// it.
+//
+// The rubberband menu has its own seam for the same job —
+// `rubberBandLaunchMenuItems()` on the linear genome view — because there the
+// grouping is the model's, not each contributor's, to do.
+//
+// Keeps its name while the label loses a word: this one is pinned by
+// `abiBaseline.json`, so a published plugin bundle reads it off the host at
+// module scope and a rename is `undefined` inside an already-shipped UMD.
+export function pushLaunchViewMenuItem(items, item) {
+    pushIntoSubMenu(items, LAUNCH_LABEL, item);
+}