@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/ui/menuLabels.js

@@ -0,0 +1,43 @@
+/**
+ * Menu row LABELS, as opposed to the rows themselves — the builders that make a
+ * row live in `toggleMenuItems.ts` and its neighbours, and take a label they do
+ * not compose.
+ *
+ * Its own module because a label is not a row: `withHint` is reached from radio
+ * options and from hand-written literals as often as from a builder, so filing
+ * it under the checkbox builders put it behind an import that half its callers
+ * had no other reason to make.
+ *
+ * Same purity boundary as the rest of `menuItems.ts` — no react, @mui or
+ * @emotion, ever (`menuItems.purity.test.ts`).
+ */
+/**
+ * #menuBuilder withHint | a row label carrying an aside that is only sometimes there
+ *
+ * `withHint('Show row separators', tooShort ? 'needs rows 4px or taller' :
+ * undefined)`.
+ *
+ * The rows that want this are the ones that can be on, correctly on, and doing
+ * nothing observable -- a band overridden by the summary tier, a separator
+ * below the height it draws at. The tick keeps reporting what the user chose,
+ * so silence would leave the setting looking broken.
+ *
+ * IN THE LABEL rather than a `subLabel`, which is what these were: a second
+ * line under the row is heavy for a clarifier this short, and rather than a
+ * `helpText`, which would reserve a "?" column across the whole menu for one
+ * conditional row and hide the reason behind a hover -- on a control the reader
+ * has no reason to hover, since from the tick it looks like it already works.
+ *
+ * AN EM DASH, NOT PARENTHESES. Two of these labels already end in a
+ * parenthetical of their own ("Show conservation (% identity)", "Codon changes
+ * (amino acids)"), and a second pair straight after the first reads as a typo.
+ * It also keeps the aside distinct from the ` - ` that names a permanent half of
+ * a label ("Square view - average bp per pixel").
+ *
+ * KEEP THE HINT SHORT -- a few words, not a sentence. A menu sizes to its widest
+ * row, so a long one widens every row for as long as it fires, which is the same
+ * cost that rules out `helpText` above.
+ */
+export function withHint(label, hint) {
+    return hint ? `${label} — ${hint}` : label;
+}

package/esm/ui/multiTrackMenuItems.d.ts

@@ -0,0 +1,25 @@
+import type PluginManager from '../PluginManager.ts';
+import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { AbstractSessionModel } from '../util/types/index.ts';
+import type { MenuItem } from './MenuTypes.ts';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+export interface MultiTrackSelection extends IStateTreeNode {
+    selection: AnyConfigurationModel[];
+}
+export interface MultiTrackMenuItemsProps {
+    session: AbstractSessionModel;
+    model: MultiTrackSelection;
+}
+/** Return the items to add, or nothing when the selection isn't yours. */
+export type MultiTrackMenuItemsCallback = (props: MultiTrackMenuItemsProps) => MenuItem | MenuItem[] | undefined;
+declare module '@jbrowse/core/PluginManager' {
+    interface ExtensionPointRegistry {
+        'TrackSelector-multiTrackMenuItems': {
+            args: MenuItem[];
+            result: MenuItem[];
+            props: MultiTrackMenuItemsProps;
+        };
+    }
+}
+export declare function addMultiTrackMenuItems(pluginManager: PluginManager, callback: MultiTrackMenuItemsCallback): void;
+export declare function buildMultiTrackMenuItems(pluginManager: PluginManager, props: MultiTrackMenuItemsProps): MenuItem[];

package/esm/ui/multiTrackMenuItems.js

@@ -0,0 +1,15 @@
+// Declared here rather than in the plugin owning the track selector, because a
+// contributor is a plugin that selector already depends on — wiggle offers
+// "create multi-wiggle track" — and a type augmentation reaches a contributor
+// only through an import it can afford to make. Same reason as
+// Core-extraTrackMenuItems.
+export function addMultiTrackMenuItems(pluginManager, callback) {
+    pluginManager.contributeToExtensionPoint('TrackSelector-multiTrackMenuItems', callback);
+}
+// Returns the contributed items, or an empty array when no plugin contributes,
+// so callers can spread it.
+export function buildMultiTrackMenuItems(pluginManager, props) {
+    return pluginManager.evaluateExtensionPoint(
+    /** #extensionPoint TrackSelector-multiTrackMenuItems | sync | Add items to the multi-track (shopping cart) menu */
+    'TrackSelector-multiTrackMenuItems', [], props);
+}

package/esm/ui/palette.d.ts

@@ -0,0 +1,561 @@
+/** A resolved color and the three shades MUI-shaped consumers expect. */
+export interface ColorQuad {
+    main: string;
+    light: string;
+    dark: string;
+    contrastText: string;
+}
+/**
+ * What a theme may supply for an augmentable color: a bare CSS string, a
+ * `{ main }` object, or a full MUI-style shade map (`{ 300, 500, 700 }`).
+ */
+export type ColorInput = string | ShadeInput;
+export interface ShadeInput {
+    main?: string;
+    light?: string;
+    dark?: string;
+    contrastText?: string;
+    300?: string;
+    500?: string;
+    700?: string;
+}
+/**
+ * `[null, f1, f2, f3, f-3, f-2, f-1]`. Slot 0 is unused so positive frames read
+ * as `.at(1/2/3)` and negative frames fall out of JS negative-index semantics.
+ */
+export type FrameTuple<T> = [
+    null,
+    T | undefined,
+    T | undefined,
+    T | undefined,
+    T | undefined,
+    T | undefined,
+    T | undefined
+];
+export type BaseKey = 'A' | 'C' | 'G' | 'T' | 'N';
+export interface AlignmentFill {
+    /** LR (→ ←): a normal, concordant proper pair */
+    pairLR: string;
+    /** RL (← →): mates point away from each other */
+    pairRL: string;
+    /** LL (→ →): both mates on the forward strand */
+    pairLL: string;
+    /** RR (← ←): both mates on the reverse strand */
+    pairRR: string;
+    /** The other end of the pair aligned nowhere, so no orientation is honest */
+    unmappedMate: string;
+}
+export declare function lighten(color: string, coefficient: number): string;
+export declare function darken(color: string, coefficient: number): string;
+/** Restate a color at a given opacity, as `rgba(r, g, b, a)`. */
+export declare function alpha(color: string, value: number): string;
+/** WCAG relative luminance, truncated to three digits the way MUI does. */
+export declare function getLuminance(color: string): number;
+export declare function getContrastRatio(foreground: string, background: string): number;
+export declare function getContrastText(background: string): "#fff" | "rgba(0, 0, 0, 0.87)";
+/**
+ * Expand a color into its four shades. A shade map supplies `light`/`dark`
+ * directly from its 300/700 entries, anything else derives them by tonal
+ * offset, and `contrastText` is chosen by contrast ratio against `main`.
+ */
+export declare function augmentColor(input: ColorInput): ColorQuad;
+export declare const grey: {
+    50: string;
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    600: string;
+    700: string;
+    800: string;
+    900: string;
+};
+export interface NeutralTokens {
+    text: {
+        primary: string;
+        secondary: string;
+        disabled: string;
+    };
+    background: {
+        paper: string;
+        default: string;
+    };
+    divider: string;
+    common: {
+        black: string;
+        white: string;
+    };
+    grey: typeof grey;
+    action: {
+        active: string;
+        hover: string;
+        hoverOpacity: number;
+        selected: string;
+        selectedOpacity: number;
+        disabled: string;
+        disabledBackground: string;
+        disabledOpacity: number;
+        focus: string;
+        focusOpacity: number;
+        activatedOpacity: number;
+    };
+}
+/**
+ * The four states a UI conveys with color rather than with words. Not domain
+ * colors — nothing renders a feature in `warning.main` — but the styling
+ * layer's, and JBrowse's own rather than borrowed from Material UI at read
+ * time, for the same reason every other color here is.
+ */
+export interface SemanticColors {
+    error: ColorQuad;
+    warning: ColorQuad;
+    info: ColorQuad;
+    success: ColorQuad;
+}
+/** #color alignments-strand | Forward strand | Read maps to the forward strand */
+export declare const colorFwdStrand = "#EC8B8B";
+/** #color alignments-strand | Reverse strand | Read maps to the reverse strand */
+export declare const colorRevStrand = "#8F8FD8";
+/** #color alignments-pair-orientation | LR (→ ←) | Normal proper pair */
+export declare const colorPairLR = "#d3d3d3";
+export declare const colorPairLRDark = "#b0b0b0";
+/** #color alignments-pair-orientation | RL (← →) | Mates point away from each other */
+export declare const colorPairRL = "#0099bb";
+/** #color alignments-pair-orientation | LL (→ →) | Both mates on the forward strand */
+export declare const colorPairLL = "#4d9a4d";
+/** #color alignments-pair-orientation | RR (← ←) | Both mates on the reverse strand */
+export declare const colorPairRR = "#5555bb";
+/**
+ * #color alignments-pair-orientation | Inter-chromosomal | Mate on another chromosome
+ * #color alignments-insert-size | Inter-chromosomal | Mate on another chromosome
+ */
+export declare const colorInterchrom = "#af4d19";
+/** #color alignments-insert-size | Insert larger than expected | Deletion between the mates */
+export declare const colorLongInsert = "#ff0000";
+/** #color alignments-insert-size | Insert smaller than expected | Insertion between the mates */
+export declare const colorShortInsert = "#f582c0";
+/**
+ * #color alignments-pair-orientation | Mate unmapped | Mate aligned nowhere
+ * #color alignments-insert-size | Mate unmapped | Mate aligned nowhere
+ */
+export declare const colorUnmappedMate = "#000000";
+export declare const colorUnmappedMateDark = "#4a4a4a";
+export declare const colorLongreadInv = "#7755bb";
+/** #color alignments-pair-orientation | Split read (inverted) | Supplementary segment on the opposite strand to its primary */
+export declare const colorSplitReadInversion = "#9b30b0";
+export declare const colorSupplementary = "#f0b878";
+export declare const tagColorPalette: string[];
+/**
+ * #color theme-colors | Feature (default) | A feature with no color of its own — no `color` slot, no BED itemRgb
+ *
+ * What an uncolored feature is painted. Lives here rather than in the display
+ * that draws most of them because it is not one display's default: the
+ * single-feature variant display resolves it through `plugins/canvas`, and the
+ * multi-sample variant display's lane bakes it into the color array its worker
+ * ships. Two copies of a color two displays are supposed to agree on is exactly
+ * the "never a fallback copy" this module exists to prevent.
+ */
+export declare const featureDefaultColor = "goldenrod";
+/**
+ * #color theme-colors | UTR (default) | The untranslated ends of a gene glyph when no `utrColor` slot is set
+ *
+ * Same reasoning as featureDefaultColor: the canvas gene track and the
+ * multi-way synteny lanes both draw UTRs, and the two must be the same blue or
+ * a lane's gene models read as a different annotation from the gene track
+ * above them.
+ */
+export declare const utrDefaultColor = "#357089";
+/** #color theme-methylation | methylated5mC | 5-methylcytosine, methylated */
+export declare const methylated5mC = "#ff0000";
+/** #color theme-methylation | unmethylated5mC | 5-methylcytosine, unmethylated */
+export declare const unmethylated5mC = "#0000ff";
+/** #color theme-methylation | methylated5hmC | 5-hydroxymethylcytosine, methylated */
+export declare const methylated5hmC = "#ffc0cb";
+/** Plain string colors that a theme may override wholesale. */
+export interface StringColors {
+    /** Stop codon in gene/CDS tracks */
+    stopCodon: string;
+    /** Start codon in gene/CDS tracks */
+    startCodon: string;
+    /** MAF codon view: the species' amino acid differs from the reference */
+    codonNonsynonymous: string;
+    /** MAF codon view: the codon differs but the amino acid does not */
+    codonSynonymous: string;
+    /** MAF codon view: a stop the reference codon is not */
+    codonStop: string;
+    /** Coverage histogram fill */
+    coverage: string;
+    /** Insertion markers in alignments */
+    insertion: string;
+    /** Soft-clipped bases (clipped bases retained in the read) */
+    softclip: string;
+    /** Skipped regions, such as introns in RNA-seq reads */
+    skip: string;
+    /** Hard-clipped bases (clipped bases removed from the read) */
+    hardclip: string;
+    /** Deletion markers in alignments */
+    deletion: string;
+    /** MAF alignment-gap cells, where a species has no base */
+    mafGap: string;
+    /** Span where two segments of one molecule both align (view-as-pairs / chains) */
+    readOverlap: string;
+    /** Base modifications on the forward strand */
+    modificationFwd: string;
+    /** Base modifications on the reverse strand */
+    modificationRev: string;
+    /** SNP bases muted when show-modifications coloring is on */
+    mutedSnpBase: string;
+    /** MAF bridged-row fill where a species has no alignment */
+    missingData: string;
+    /** Minor vertical gridlines behind the genome */
+    gridlineMinor: string;
+    /** Major vertical gridlines behind the genome */
+    gridlineMajor: string;
+    /**
+     * Minor coordinate gridlines inside a plot area, e.g. the dotplot's. Lighter
+     * than the genome gridlines above: a 2D grid crosses itself, so it lays down
+     * far more ink at the same alpha than one running behind a linear genome
+     */
+    plotGridlineMinor: string;
+    /** Major coordinate gridlines inside a plot area. See plotGridlineMinor */
+    plotGridlineMajor: string;
+    /**
+     * Line marking a chromosome or region boundary, well above both plot gridline
+     * weights: it is the landmark the coordinates hang off, so it has to stay
+     * readable as a boundary on a plot that also draws a full grid
+     */
+    regionBoundary: string;
+    /**
+     * Opaque bar between two displayed regions of a linear genome view. Opaque
+     * because it paints over track data on both sides and has to mask it
+     */
+    regionSeparator: string;
+    /** Cell and header rules in JBrowse's own tables, e.g. the faceted track selector */
+    tableBorder: string;
+    /** Hover shading over a single feature */
+    featureHover: string;
+    /** Hover shading over a feature group, e.g. a linked-read chain */
+    featureHoverStrong: string;
+    /** Border accent around the click-selected feature */
+    featureSelected: string;
+    /** Feature description labels, e.g. gene descriptions */
+    featureDescription: string;
+    /** Intron lines, strand chevrons and strand arrows in feature tracks */
+    featureConnector: string;
+}
+/**
+ * Every color JBrowse renders, resolved. Plain strings throughout, so this
+ * crosses the RPC worker boundary as itself rather than as arguments something
+ * on the far side has to rebuild.
+ */
+export interface JBrowsePalette extends StringColors, NeutralTokens, SemanticColors {
+    mode: 'light' | 'dark';
+    primary: ColorQuad;
+    /**
+     * The primary colour where it marks something on the page's own ground,
+     * such as a checked box or a selected row. `primary.main` in light mode. In
+     * dark mode a primary as deep as midnight vanishes against the background,
+     * so it is the secondary text colour, which the Material controls take there
+     * too.
+     */
+    accent: string;
+    secondary: ColorQuad;
+    tertiary: ColorQuad;
+    quaternary: ColorQuad;
+    highlight: ColorQuad;
+    textHighlight: ColorQuad;
+    bases: Record<BaseKey, ColorQuad>;
+    frames: FrameTuple<ColorQuad>;
+    framesCDS: FrameTuple<ColorQuad>;
+    alignmentFill: AlignmentFill;
+}
+/**
+ * The colors a palette wants when JBrowse draws it dark. Only the slots that
+ * differ: the neutrals, the semantics and two dozen string colors already
+ * follow the mode on their own, so a palette that states nothing here still
+ * has a working dark half.
+ *
+ * What does not survive a mode flip is a brand color. `primary` is the case —
+ * a deep navy reads at 1.2:1 against a dark background where it reads at 16:1
+ * against a light one — and it is the reason this exists rather than a `mode`
+ * flag being the whole story.
+ */
+export type DarkPaletteInput = Omit<PaletteInput, 'mode' | 'dark'>;
+/**
+ * The palette half of what a theme may declare. Structurally compatible with
+ * MUI's `PaletteOptions`, which is what the config `theme` slot carries, so a
+ * config theme is assignable here without a cast.
+ */
+export interface PaletteInput extends Partial<StringColors> {
+    mode?: 'light' | 'dark';
+    /** what changes when this palette is drawn dark; see {@link DarkPaletteInput} */
+    dark?: DarkPaletteInput;
+    primary?: ShadeInput;
+    accent?: string;
+    secondary?: ShadeInput;
+    tertiary?: ShadeInput;
+    quaternary?: ShadeInput;
+    highlight?: ShadeInput;
+    textHighlight?: ShadeInput;
+    error?: ShadeInput;
+    warning?: ShadeInput;
+    info?: ShadeInput;
+    success?: ShadeInput;
+    bases?: Partial<Record<BaseKey, ShadeInput>>;
+    frames?: FrameTuple<ShadeInput>;
+    framesCDS?: FrameTuple<ShadeInput>;
+    alignmentFill?: Partial<AlignmentFill>;
+    text?: Partial<NeutralTokens['text']>;
+    background?: Partial<NeutralTokens['background']>;
+    divider?: string;
+    common?: Partial<NeutralTokens['common']>;
+    grey?: Partial<NeutralTokens['grey']>;
+    action?: Partial<NeutralTokens['action']>;
+}
+/** A theme, as far as the palette is concerned. */
+export interface ThemeInput {
+    palette?: PaletteInput;
+}
+export declare const palettePresets: {
+    default: {
+        stopCodon?: string | undefined;
+        startCodon?: string | undefined;
+        codonNonsynonymous?: string | undefined;
+        codonSynonymous?: string | undefined;
+        codonStop?: string | undefined;
+        coverage?: string | undefined;
+        insertion?: string | undefined;
+        softclip?: string | undefined;
+        skip?: string | undefined;
+        hardclip?: string | undefined;
+        deletion?: string | undefined;
+        mafGap?: string | undefined;
+        readOverlap?: string | undefined;
+        modificationFwd?: string | undefined;
+        modificationRev?: string | undefined;
+        mutedSnpBase?: string | undefined;
+        missingData?: string | undefined;
+        gridlineMinor?: string | undefined;
+        gridlineMajor?: string | undefined;
+        plotGridlineMinor?: string | undefined;
+        plotGridlineMajor?: string | undefined;
+        regionBoundary?: string | undefined;
+        regionSeparator?: string | undefined;
+        tableBorder?: string | undefined;
+        featureHover?: string | undefined;
+        featureHoverStrong?: string | undefined;
+        featureSelected?: string | undefined;
+        featureDescription?: string | undefined;
+        featureConnector?: string | undefined;
+        mode?: 'light' | 'dark';
+        /** what changes when this palette is drawn dark; see {@link DarkPaletteInput} */
+        dark?: DarkPaletteInput;
+        primary?: ShadeInput;
+        accent?: string;
+        secondary?: ShadeInput;
+        tertiary?: ShadeInput;
+        quaternary?: ShadeInput;
+        highlight?: ShadeInput;
+        textHighlight?: ShadeInput;
+        error?: ShadeInput;
+        warning?: ShadeInput;
+        info?: ShadeInput;
+        success?: ShadeInput;
+        bases?: Partial<Record<BaseKey, ShadeInput>>;
+        frames?: FrameTuple<ShadeInput>;
+        framesCDS?: FrameTuple<ShadeInput>;
+        alignmentFill?: Partial<AlignmentFill>;
+        text?: Partial<NeutralTokens['text']>;
+        background?: Partial<NeutralTokens['background']>;
+        divider?: string;
+        common?: Partial<NeutralTokens['common']>;
+        grey?: Partial<NeutralTokens['grey']>;
+        action?: Partial<NeutralTokens['action']>;
+    };
+    stock: {
+        stopCodon?: string | undefined;
+        startCodon?: string | undefined;
+        codonNonsynonymous?: string | undefined;
+        codonSynonymous?: string | undefined;
+        codonStop?: string | undefined;
+        coverage?: string | undefined;
+        insertion?: string | undefined;
+        softclip?: string | undefined;
+        skip?: string | undefined;
+        hardclip?: string | undefined;
+        deletion?: string | undefined;
+        mafGap?: string | undefined;
+        readOverlap?: string | undefined;
+        modificationFwd?: string | undefined;
+        modificationRev?: string | undefined;
+        mutedSnpBase?: string | undefined;
+        missingData?: string | undefined;
+        gridlineMinor?: string | undefined;
+        gridlineMajor?: string | undefined;
+        plotGridlineMinor?: string | undefined;
+        plotGridlineMajor?: string | undefined;
+        regionBoundary?: string | undefined;
+        regionSeparator?: string | undefined;
+        tableBorder?: string | undefined;
+        featureHover?: string | undefined;
+        featureHoverStrong?: string | undefined;
+        featureSelected?: string | undefined;
+        featureDescription?: string | undefined;
+        featureConnector?: string | undefined;
+        mode?: 'light' | 'dark';
+        /** what changes when this palette is drawn dark; see {@link DarkPaletteInput} */
+        dark?: DarkPaletteInput;
+        primary?: ShadeInput;
+        accent?: string;
+        secondary?: ShadeInput;
+        tertiary?: ShadeInput;
+        quaternary?: ShadeInput;
+        highlight?: ShadeInput;
+        textHighlight?: ShadeInput;
+        error?: ShadeInput;
+        warning?: ShadeInput;
+        info?: ShadeInput;
+        success?: ShadeInput;
+        bases?: Partial<Record<BaseKey, ShadeInput>>;
+        frames?: FrameTuple<ShadeInput>;
+        framesCDS?: FrameTuple<ShadeInput>;
+        alignmentFill?: Partial<AlignmentFill>;
+        text?: Partial<NeutralTokens['text']>;
+        background?: Partial<NeutralTokens['background']>;
+        divider?: string;
+        common?: Partial<NeutralTokens['common']>;
+        grey?: Partial<NeutralTokens['grey']>;
+        action?: Partial<NeutralTokens['action']>;
+    };
+    minimal: {
+        stopCodon?: string | undefined;
+        startCodon?: string | undefined;
+        codonNonsynonymous?: string | undefined;
+        codonSynonymous?: string | undefined;
+        codonStop?: string | undefined;
+        coverage?: string | undefined;
+        insertion?: string | undefined;
+        softclip?: string | undefined;
+        skip?: string | undefined;
+        hardclip?: string | undefined;
+        deletion?: string | undefined;
+        mafGap?: string | undefined;
+        readOverlap?: string | undefined;
+        modificationFwd?: string | undefined;
+        modificationRev?: string | undefined;
+        mutedSnpBase?: string | undefined;
+        missingData?: string | undefined;
+        gridlineMinor?: string | undefined;
+        gridlineMajor?: string | undefined;
+        plotGridlineMinor?: string | undefined;
+        plotGridlineMajor?: string | undefined;
+        regionBoundary?: string | undefined;
+        regionSeparator?: string | undefined;
+        tableBorder?: string | undefined;
+        featureHover?: string | undefined;
+        featureHoverStrong?: string | undefined;
+        featureSelected?: string | undefined;
+        featureDescription?: string | undefined;
+        featureConnector?: string | undefined;
+        mode?: 'light' | 'dark';
+        accent?: string;
+        quaternary?: ShadeInput;
+        highlight?: ShadeInput;
+        textHighlight?: ShadeInput;
+        error?: ShadeInput;
+        warning?: ShadeInput;
+        info?: ShadeInput;
+        success?: ShadeInput;
+        bases?: Partial<Record<BaseKey, ShadeInput>>;
+        frames?: FrameTuple<ShadeInput>;
+        framesCDS?: FrameTuple<ShadeInput>;
+        alignmentFill?: Partial<AlignmentFill>;
+        text?: Partial<NeutralTokens['text']>;
+        background?: Partial<NeutralTokens['background']>;
+        divider?: string;
+        common?: Partial<NeutralTokens['common']>;
+        grey?: Partial<NeutralTokens['grey']>;
+        action?: Partial<NeutralTokens['action']>;
+        primary: {
+            main: string;
+        };
+        secondary: {
+            main: string;
+        };
+        tertiary: {
+            main: string;
+        };
+        dark: {
+            primary: {
+                main: string;
+            };
+        };
+    };
+};
+/**
+ * The theme names from before light and dark were an axis, as the palette and
+ * mode each one meant. A stored selection, a share link, an admin's
+ * `configuration.theme`, `jbrowse-img --theme` and a saved figure spec all
+ * carry these, so they keep resolving rather than falling back to the default.
+ */
+export declare const legacyThemeNames: {
+    readonly lightStock: {
+        readonly themeName: 'stock';
+        readonly mode: 'light';
+    };
+    readonly darkStock: {
+        readonly themeName: 'stock';
+        readonly mode: 'dark';
+    };
+    readonly lightMinimal: {
+        readonly themeName: 'minimal';
+        readonly mode: 'light';
+    };
+    readonly darkMinimal: {
+        readonly themeName: 'minimal';
+        readonly mode: 'dark';
+    };
+};
+export type PaletteMode = 'light' | 'dark';
+export type LegacyThemeName = keyof typeof legacyThemeNames;
+/**
+ * What a name and a mode mean together, with a name that predates the axis
+ * resolved to the pair it stood for. An explicit `mode` still wins — a user
+ * picking Dark over a stored `lightStock` gets dark stock, not light.
+ *
+ * `themes` is whatever map the caller looks names up in, so an admin's
+ * `extraThemes` entry taking one of the retired names wins over the alias it
+ * would otherwise shadow.
+ */
+export declare function resolveThemeSelection(themeName?: string, mode?: PaletteMode, themes?: Record<string, unknown>): {
+    themeName: string;
+    mode?: PaletteMode;
+};
+/**
+ * What `resolvePalette` reads. Structurally the minimum of the public
+ * `SerializableThemeArgs` (declared in `theme.ts`, where the MUI `ThemeOptions`
+ * type is available), so a caller passes the public type straight in and this
+ * module still imports no toolkit.
+ */
+export interface PaletteArgs {
+    configTheme?: ThemeInput;
+    themeName?: string;
+    extraThemes?: Record<string, ThemeInput>;
+    /**
+     * Draw the named palette light or dark, whatever mode it declares. This is
+     * the axis a user picks along, so it wins over a `mode` written into the
+     * palette or the config `theme` slot; leaving it out keeps reading the mode
+     * off the palette, which is how every theme named `dark*` still resolves
+     * dark.
+     */
+    mode?: 'light' | 'dark';
+}
+/**
+ * Build the palette for a set of theme arguments.
+ *
+ * Only the `default` theme draws from `configTheme`. Every other named theme is
+ * a fixed preset and intentionally ignores it, which is what the picker entry
+ * "Default (from config)" means. Do not "fix" that.
+ */
+export declare function resolvePalette(args?: PaletteArgs): JBrowsePalette;