@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/ui/filterMenuItems.d.ts

@@ -0,0 +1,112 @@
+import type { MenuItem } from './MenuTypes.ts';
+/**
+ * One reversible piece of display state — a filter, a hidden set, a collected
+ * "show only these", a highlight set — declared once so that the three things a
+ * display currently derives separately all come from the same place: how many
+ * of them are in effect, the row offered to undo this one, and the group-level
+ * "clear everything".
+ *
+ * It exists because those three drifted apart, repeatedly and silently, and the
+ * failures are invisible rather than loud:
+ *
+ * - a set with no undo row at all (canvas `pinnedFeatureIds`: persistent,
+ *   layout-affecting, and reachable only from the pinned feature's own
+ *   right-click menu, so a pin left on another chromosome could not be reached);
+ * - an undo derived from the state's ABSENCE, so it vanished with the thing it
+ *   undid (the canvas colour key's "×" was a one-way door for the session);
+ * - a count derived from a different predicate than the state's actual effect
+ *   ("Filter by... (1)" for opening the filter dialog and pressing Submit).
+ *
+ * The pairing rule that used to live in a comment — *every filter counted must
+ * be reset by the clear, or the menu offers a recovery that doesn't recover* —
+ * is structural once both sides read this list.
+ */
+export interface Reversible {
+    /** How many independent things this is holding. 0 = not in effect. */
+    count: number;
+    /**
+     * Row text for undoing just this one, given its count. Omit for state whose
+     * only sensible undo is the group's "clear all" — a jexl filter list has no
+     * per-item recovery to name.
+     */
+    label?: (count: number) => string;
+    icon?: React.ElementType;
+    /** Reverse it. Must be a no-op when `count` is 0. */
+    clear: () => void;
+}
+/**
+ * A display's reversibles, keyed by name — `{ hiddenFeatures: {...}, solo: {...} }`.
+ * A record rather than an array so a consumer wanting one specific entry (the
+ * feature context menu offers "Show N hidden features" without the rest of the
+ * family) reads `.hiddenFeatures` and is type-checked, instead of searching a
+ * list for a string id. Row order is the record's insertion order.
+ */
+export type Reversibles = Record<string, Reversible>;
+/** Total in effect — what a "(n)" in a group label counts. */
+export declare function activeCount(items: Reversibles): number;
+/**
+ * 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 declare function clearAll(items: Reversibles): void;
+/**
+ * The undo rows: one per entry that is in effect AND names itself. Spread,
+ * don't insert — an entry holding nothing contributes nothing.
+ */
+export declare function undoItems(items: Reversibles, priority?: number): MenuItem[];
+export interface FilterMenuOpts {
+    /**
+     * The display's narrowings, declared once (see {@link Reversible}). Supplying
+     * this derives `activeCount`, `recoveryItems` and `onClear` together, so the
+     * count in the label, the rows inside the submenu and what "Clear all filters"
+     * actually clears cannot disagree. Prefer it to spelling the three out.
+     */
+    narrowings?: Reversibles;
+    /**
+     * How many independent filters are narrowing the view right now, so the label
+     * can say that something is hiding data. Count a filter when its value is not
+     * its **no-op** value, which is not always its config default: the LD
+     * display's `minorAlleleFrequencyFilter` ships at 0.1 and is genuinely
+     * dropping variants, while the alignments flag masks default non-zero and are
+     * the no-filtering state, so they count only when edited away from it.
+     *
+     * This is usually the only affordance telling the user a filter is silently
+     * hiding rows — nothing else in the track chrome says so.
+     *
+     * Ignored when `narrowings` is given.
+     */
+    activeCount?: number;
+    /** Opens the display's filter dialog, where it has a single one. */
+    onEdit?: () => void;
+    /** Controls that belong inside the submenu (inline sliders, further dialogs). */
+    subItems?: MenuItem[];
+    /**
+     * Recovery rows offered alongside "Clear all filters" once something is
+     * filtering — the canvas display's "Show N hidden features", for one.
+     */
+    recoveryItems?: MenuItem[];
+    /** Turn every filter off. Offered only while `activeCount` is non-zero. */
+    onClear?: () => void;
+    /** Rides the top-level row; see the canvas display's RECOVERY_PRIORITY. */
+    priority?: number;
+    /** Label for the dialog opener inside the submenu. */
+    editLabel?: string;
+}
+/**
+ * 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 declare function filterMenuItems({ narrowings, activeCount: explicitCount, onEdit, subItems, recoveryItems: explicitRecovery, onClear: explicitClear, priority, editLabel, }: FilterMenuOpts): MenuItem[];

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/hoverBoxStyle.d.ts

@@ -0,0 +1,23 @@
+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`
+ * below 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;
+/**
+ * The border and fill of a pinned highlight box, off the palette's highlight
+ * hue. The chrome draws it on screen and `renderDisplaySvg` bakes it into the
+ * export, so both reach one definition.
+ *
+ * JBrowse's own `alpha`, not Material UI's: the SVG export reaches this module
+ * and should not drag @mui/material along.
+ */
+export declare function highlightBoxColors(highlightMain: string): {
+    border: string;
+    fill: string;
+};

package/esm/ui/hoverBoxStyle.js

@@ -0,0 +1,28 @@
+import { alpha } from './palette.js';
+/**
+ * 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`
+ * below 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)',
+};
+/**
+ * The border and fill of a pinned highlight box, off the palette's highlight
+ * hue. The chrome draws it on screen and `renderDisplaySvg` bakes it into the
+ * export, so both reach one definition.
+ *
+ * JBrowse's own `alpha`, not Material UI's: the SVG export reaches this module
+ * and should not drag @mui/material along.
+ */
+export function highlightBoxColors(highlightMain) {
+    return {
+        border: alpha(highlightMain, 0.9),
+        fill: alpha(highlightMain, 0.25),
+    };
+}

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, 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, default as RefNameAutocomplete, } from './RefNameAutocomplete/index.tsx';
+export { adornmentReservePx, getInputWidth, } from './RefNameAutocomplete/util.ts';
 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 { 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 ScrollChrome } from './ScrollChrome.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 declare const VIEW_HEADER_HEIGHT = 28;
+export { default as BaseTooltip } from './LazyBaseTooltip.tsx';
+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 { VIEW_HEADER_HEIGHT } from './viewHeaderHeight.ts';
+export { LEGEND_ROW_HEIGHT, LEGEND_SVG_GUTTER_WIDTH, 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 { LegendGradient, LegendItem, LegendSection, LegendSpec, LegendSwatch, } from './legendSpec.ts';
+export { colorScaleIsEmpty, legendSpecOf } from './colorScale.ts';
+export type { CategoricalEntry, CategoricalScale, ColorScale, RampScale, RampStop, } from './colorScale.ts';
+export { checkboxItem, radioItems } from './toggleMenuItems.ts';

package/esm/ui/index.js

@@ -1,20 +1,83 @@
-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 const VIEW_HEADER_HEIGHT = 28;
+export { colorFwdStrand, colorInterchrom, colorLongInsert, colorLongreadInv, 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, default as RefNameAutocomplete, } from './RefNameAutocomplete/index.js';
+export { adornmentReservePx, getInputWidth, } from './RefNameAutocomplete/util.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 { 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 ScrollChrome } from './ScrollChrome.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';
+// The eager BaseTooltip reaches @floating-ui (~266KB), and this barrel is
+// imported by eager plugin entries, so the barrel serves the lazy wrapper:
+// published apollo reads `BaseTooltip` off the served ui namespace. In-tree
+// consumers deep-import '@jbrowse/core/ui/BaseTooltip'.
+export { default as BaseTooltip } from './LazyBaseTooltip.js';
+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 { VIEW_HEADER_HEIGHT } from './viewHeaderHeight.js';
+export { LEGEND_ROW_HEIGHT, LEGEND_SVG_GUTTER_WIDTH, 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 { colorScaleIsEmpty, legendSpecOf } from './colorScale.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[];