@jbrowse/core 5.0.0-beta.1 → 5.0.0-beta.11

package/esm/configuration/promotableResolve.d.ts

@@ -1,108 +0,0 @@
-import type { AnyConfigurationModel } from './types.ts';
-import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
-/**
- * Everything the cascade needs to read a promotable slot: the display type it
- * keys the session-wide default on, and the config holding the track's own
- * value. Every entry point takes this — `resolveConf`, the control builders,
- * the worker snapshot, the badge diff — so each can take a display state node
- * directly rather than through a cast.
- *
- * Read-only, and there is no write-capable variant. A `PromotableDisplay` used
- * to exist for the one member the subsystem wrote (`setIgnorePromotedDefaults`,
- * the received-session opt-out); with that flag gone the subsystem writes
- * nothing to a display but a config slot, which `setConf` reaches through
- * `configuration`.
- *
- * **`CONF` is a parameter rather than always `AnyConfigurationModel` because
- * intersecting is not narrowing.** A caller wanting the cascade's members *and*
- * a concrete schema — a mixin casting to reach its host — writes
- * `ResolvableDisplay<XConfigModel>`. Spelling it
- * `ResolvableDisplay & { configuration: XConfigModel }` instead reads identical
- * and silently does the opposite: the intersected `configuration` is
- * `AnyConfigurationModel & XConfigModel`, `ConfigurationSchemaForModel` infers
- * the widened brand off it, and every slot name typechecks again. Two mixins
- * shipped that spelling and only a sabotage found it.
- */
-export type ResolvableDisplay<CONF extends AnyConfigurationModel = AnyConfigurationModel> = IStateTreeNode & {
-    type: string;
-    configuration: CONF;
-};
-/**
- * Where the session-wide tier of the cascade is read from. Narrowed to the one
- * method so the resolver doesn't depend on the whole session type — and exported
- * for the same reason, so an entry point taking the store directly
- * (`getTrackConfigWithPromotables`) can ask for what it uses instead of for a
- * whole session a test then has to fake.
- */
-export interface PromotedDefaultStore {
-    getDisplayTypeDefault: (displayType: string, slot: string) => unknown;
-}
-/**
- * The cascade's inputs, stated directly rather than read off a display state
- * node. `ResolvableDisplay` is the usual way to supply them (see
- * `cascadeContextFor`), but nothing here *needs* a state node: the About
- * dialog's "Copy config" resolves a track's display configs directly, which is
- * what lets it answer "what would this render as" for a track that was never
- * opened. Reaching for the open display instead buys nothing — its
- * `configuration` is the same node, and its `type` is that config's own.
- */
-export interface CascadeContext {
-    config: AnyConfigurationModel;
-    displayType: string;
-    defaults: PromotedDefaultStore;
-}
-export declare function cascadeContextFor(self: ResolvableDisplay): CascadeContext;
-/**
- * What the slot literally holds, unevaluated — a stray `jexl:` string yields the
- * raw string rather than running it. Both callers ask "is the slot set, and to
- * what kind of thing?", which has to be answerable with no feature context.
- *
- * Deliberately not `readConfObject`: for a promotable slot this is the whole
- * stored read, and both of that reader's extra behaviors are unwanted here — it
- * evaluates a `jexl:` string (which `isUsableValue` refuses anyway) and it
- * snapshots an MST-node value, which a `maybe*` slot never holds.
- */
-export declare function storedSlotValue(config: AnyConfigurationModel, slot: string): unknown;
-/**
- * Whether `value` could actually become this slot's promoted default — the same
- * `isUsableValue` gate the cascade puts both tiers through, asked ahead of time
- * about a value a caller is about to offer as a pin's on-value.
- *
- * Exists because a pin built over a value the gate refuses is inert in a way
- * nothing reports: `applyDefaultToggle` writes it to the session store happily,
- * `resolveSlotIn` then drops it and every track keeps resolving to the tier
- * below, and `isPromotableDefault` compares the *raw* stored value, so the pin
- * draws outline forever while a dead key sits in the user's localStorage. See
- * `makePin`, which is the one caller.
- */
-export declare function isPromotableValue(config: AnyConfigurationModel, slot: string, value: unknown): boolean;
-/**
- * The outcome of walking the cascade for one slot: the two tiers that fed it,
- * whether the track customized it, and the settled value.
- *
- * There is deliberately **no callback case** — a `jexl:` value fails
- * `isUsableValue` like any other unusable value and degrades to the inherited
- * one, so `value` is always readable. See `isUsableValue`.
- */
-export interface SlotResolution {
-    /** value a track following the default shows with nothing promoted (CSS `initial`) */
-    base: unknown;
-    /** the raw session-wide promoted default, if any */
-    promoted: unknown;
-    /** track holds its own value rather than following the default */
-    customized: boolean;
-    /**
-     * the value came from the session-wide tier — the track follows the default
-     * *and* that default moves it off `base`. The "this display picked something
-     * up from the session" predicate, for the badge diff and the About dialog's
-     * copy-config note. A field rather than a `!customized && !deepEqual(value,
-     * base)` at each call site, because getting either half wrong is silent:
-     * dropping `customized` reports a customized track as inheriting, dropping
-     * the `base` compare flags a promoted default that changes nothing.
-     */
-    inherited: boolean;
-    /** the final cascaded value (never the `undefined` inherit sentinel) */
-    value: unknown;
-}
-export declare function resolveSlot(self: ResolvableDisplay, slot: string): SlotResolution;
-export declare function resolveSlotIn(ctx: CascadeContext, slot: string): SlotResolution;

package/esm/configuration/promotableResolve.js

@@ -1,117 +0,0 @@
-/**
- * @module
- * The read-time resolver behind `promotable` config slots — a small CSS cascade
- * for one slot: the track's own set value -> the session-wide default for its
- * display type -> the slot's `promotedBase`. `resolveSlotIn` is the whole of it;
- * `resolveConf` and the control builders in `promotableDefaults.ts` each read a
- * field off the `SlotResolution` it returns.
- *
- * Mechanism: `agent-docs/reference/DISPLAY_TYPE_DEFAULTS.md`. Two decisions this
- * file rests on: resolution is named at its call sites rather than folded into
- * `getConf` (ADR-046), and unset is the only inherit sentinel — so declaring
- * `promotedBase` is what makes a slot promotable (ADR-047, enforced by
- * `ConfigSlot`).
- *
- * Every comparison against a promoted or base value is `deepEqual`, never `===`:
- * an object-valued slot (`maybeFrozen`, e.g. alignments `colorBy`) reconstructs a
- * fresh value out of MST that is never `===` its stored twin, so `===` would read
- * it as permanently differing and no pin would ever light up.
- *
- * The gate a candidate value passes to count at all is `isUsableValue`, in
- * `slotShape.ts` — shared with `ConfigSlot`, which applies it to `promotedBase`
- * at construction so the tier this file falls back to is usable by construction.
- */
-import { deepEqual } from '../util/deepEqual.js';
-import { getSession } from '../util/mstUtils.js';
-import { getSlotDefinition } from './slotFacade.js';
-import { isUsableValue } from './slotShape.js';
-export function cascadeContextFor(self) {
-    return {
-        config: self.configuration,
-        displayType: self.type,
-        defaults: getSession(self),
-    };
-}
-/**
- * What the slot literally holds, unevaluated — a stray `jexl:` string yields the
- * raw string rather than running it. Both callers ask "is the slot set, and to
- * what kind of thing?", which has to be answerable with no feature context.
- *
- * Deliberately not `readConfObject`: for a promotable slot this is the whole
- * stored read, and both of that reader's extra behaviors are unwanted here — it
- * evaluates a `jexl:` string (which `isUsableValue` refuses anyway) and it
- * snapshots an MST-node value, which a `maybe*` slot never holds.
- */
-export function storedSlotValue(config, slot) {
-    return config[slot];
-}
-/**
- * Whether `value` could actually become this slot's promoted default — the same
- * `isUsableValue` gate the cascade puts both tiers through, asked ahead of time
- * about a value a caller is about to offer as a pin's on-value.
- *
- * Exists because a pin built over a value the gate refuses is inert in a way
- * nothing reports: `applyDefaultToggle` writes it to the session store happily,
- * `resolveSlotIn` then drops it and every track keeps resolving to the tier
- * below, and `isPromotableDefault` compares the *raw* stored value, so the pin
- * draws outline forever while a dead key sits in the user's localStorage. See
- * `makePin`, which is the one caller.
- */
-export function isPromotableValue(config, slot, value) {
-    return isUsableValue(getSlotDefinition(config, slot), value);
-}
-// The whole three-tier cascade for one slot, in one place. `resolveConf` is the
-// public reader over it, and the control builders in `promotableDefaults.ts`
-// read a field off it.
-export function resolveSlot(self, slot) {
-    return resolveSlotIn(cascadeContextFor(self), slot);
-}
-// The cascade over explicit inputs. `resolveSlot` is the display-state spelling
-// of this and the one nearly every consumer wants; the direct form exists for
-// the config-only path (a track that isn't open has no display state — see
-// `CascadeContext`).
-export function resolveSlotIn(ctx, slot) {
-    const def = getSlotDefinition(ctx.config, slot);
-    // A plain slot would otherwise resolve silently wrong here — with no
-    // `promotedBase` every tier collapses to `undefined` — and, through a control
-    // builder, write a promoted default nothing ever reads. `getSlotDefinition`
-    // already throws on a slot name that doesn't exist at all.
-    //
-    // Declaring `promotedBase` is what makes a slot promotable, so its absence is
-    // the whole test; there is no separate flag that could disagree with it.
-    if (def.promotedBase === undefined) {
-        throw new Error(`config slot "${slot}" is not promotable`);
-    }
-    // the slot's CSS `initial`
-    const base = def.promotedBase;
-    // a session-wide fact, and `isPromotableDefault` (the pin's filled/outline
-    // state) reports on the session, not on one display's view of it
-    const promoted = ctx.defaults.getDisplayTypeDefault(ctx.displayType, slot);
-    const own = storedSlotValue(ctx.config, slot);
-    // A track is customized exactly when it holds a *usable* value — being unset
-    // is the inherit sentinel, so "set to something the slot could hold" is the
-    // whole test. Routing `own` through the same gate as a promoted default is
-    // what makes a malformed or stale own value (a saved `colorBy` naming a
-    // since-removed scheme) read as not-customized and degrade in lockstep,
-    // instead of reaching a consumer that trusts every value it sees.
-    const customized = isUsableValue(def, own);
-    const inheritedValue = isUsableValue(def, promoted) ? promoted : base;
-    // A customized value wins unconditionally, which is what makes the share bake
-    // sufficient on its own: a baked value lands in the track's config, so the
-    // recipient reads it as customized and their own promoted default never gets
-    // consulted. The one case a bake cannot cover is the sender sitting at `base`
-    // while the recipient has promoted something — nothing is baked (the value
-    // *is* base, and `stripDefault` drops it from the snapshot), so the recipient
-    // resolves it from their own cascade. That is accepted: a promoted default is
-    // personal and local, exactly like the theme a session is viewed in, and the
-    // alternative was a per-display `ignorePromotedDefaults` flag that also
-    // detached received tracks from the recipient's own pins for good.
-    const value = customized ? own : inheritedValue;
-    return {
-        base,
-        customized,
-        promoted,
-        inherited: !customized && !deepEqual(value, base),
-        value,
-    };
-}

package/esm/configuration/promotableSlots.d.ts

@@ -1,12 +0,0 @@
-import type { AnyConfigurationModel } from './types.ts';
-import type { IAnyType } from '@jbrowse/mobx-state-tree';
-/**
- * Takes a live config node *or* the schema type itself, for the reason
- * `getConfigurationSchemaDefinition` does: every resolver here holds a node,
- * while a caller enumerating registered display types
- * (`displayTypesWithPromotableSlots`) holds only `DisplayType.configSchema` and
- * has nothing to create a node from. Caching under whichever handle it was
- * given is safe — a schema registers both its outer `stripDefault` wrapper and
- * its inner model against the same slot table, so the two entries agree.
- */
-export declare function promotableSlotNames(configOrType: AnyConfigurationModel | IAnyType): ReadonlySet<string>;

package/esm/configuration/promotableSlots.js

@@ -1,45 +0,0 @@
-import { getType, isType } from '@jbrowse/mobx-state-tree';
-import { getConfigurationSchemaDefinition } from './schemaRegistry.js';
-import { isSlotDefinitionEntry } from './schemaTypes.js';
-// The `promotable` slot names of one config schema (includes slots inherited via
-// baseConfiguration — merged into the table at construction), cached by MST type
-// since a schema's slot table is fixed.
-//
-// Only the functions that genuinely *enumerate* promotable slots call this — the
-// worker-payload resolver, the badge diff, "clear every default", and
-// `assertNoPromotableSlots`. It is deliberately NOT on any read path:
-// `getConf` used to consult it on all ~1300 config reads in the repo to decide
-// whether to cascade, which cost a `getType` per read (measured at ~60% overhead
-// over `readConfObject`) to serve the ~15 promotable ones. `resolveConf` names
-// the cascade at the call site instead, so there is nothing to look up.
-//
-// Its own module, and a leaf one, because `ui/promotablePinCoverage.ts` wants
-// the slot names and nothing else: reaching them through a module that also held
-// `readConfObject` pulled jexl and the whole read path into the ui graph. See the
-// note on that export in `ui/index.ts`.
-const promotableSlotsByType = new WeakMap();
-/**
- * Takes a live config node *or* the schema type itself, for the reason
- * `getConfigurationSchemaDefinition` does: every resolver here holds a node,
- * while a caller enumerating registered display types
- * (`displayTypesWithPromotableSlots`) holds only `DisplayType.configSchema` and
- * has nothing to create a node from. Caching under whichever handle it was
- * given is safe — a schema registers both its outer `stripDefault` wrapper and
- * its inner model against the same slot table, so the two entries agree.
- */
-export function promotableSlotNames(configOrType) {
-    const type = isType(configOrType) ? configOrType : getType(configOrType);
-    const cached = promotableSlotsByType.get(type);
-    if (cached) {
-        return cached;
-    }
-    const names = new Set();
-    const table = getConfigurationSchemaDefinition(configOrType);
-    for (const [name, def] of Object.entries(table ?? {})) {
-        if (isSlotDefinitionEntry(def) && def.promotedBase !== undefined) {
-            names.add(name);
-        }
-    }
-    promotableSlotsByType.set(type, names);
-    return names;
-}

package/esm/configuration/slotShape.d.ts

@@ -1,12 +0,0 @@
-import type { ConfigSlotDefinition } from './configurationSlot.ts';
-/**
- * Whether a stored value could really be a value of this slot. An unusable value
- * is dropped by the cascade, so the getter, the pin and the badge all fall back
- * in lockstep.
- *
- * The `jexl:` check is the only place the subsystem handles a callback, and it
- * handles it by refusing it — a hand-edited config or default store is untyped,
- * and a callback string would otherwise reach a renderer as a literal value.
- * DISPLAY_TYPE_DEFAULTS.md §"No callbacks".
- */
-export declare function isUsableValue(def: ConfigSlotDefinition, value: unknown): boolean;

package/esm/configuration/slotShape.js

@@ -1,84 +0,0 @@
-/**
- * @module
- * The one gate a candidate value for a `promotable` slot has to pass. Shared,
- * deliberately, by the two places that ask the question:
- *
- *  - `promotableResolve.ts` at read time, for both cascade tiers — a session-wide
- *    promoted default and a track's own value out of an untyped saved snapshot;
- *  - `configurationSlot.ts` at construction, for the slot's own `promotedBase`.
- *
- * One implementation is what makes "the base is always a usable value" true by
- * construction rather than assumed: the resolver falls back to `promotedBase`
- * whenever a tier fails this gate, so a base that would itself fail has nowhere
- * left to fall.
- */
-import { getEnumerationValues } from '../util/mst-reflection.js';
-import { isCallbackValue } from './slotValueUtils.js';
-// Per-slot-type JS shape checks, for the slot types whose value needs more than
-// a `typeof` against `promotedBase`. Only the `maybe*` types appear, because
-// `ConfigSlot` rejects a `promotedBase` on anything else and this table is only
-// ever consulted for a promotable slot. Any type absent here (`maybeBoolean`,
-// `maybeColor`, `maybeFrozen`) falls through to the `promotedBase`-derived check
-// in `matchesSlotShape`.
-const SHAPE_CHECKS = {
-    // a bare `typeof value === 'number'` would admit `NaN`/`±Infinity`, which no
-    // slot legitimately holds
-    maybeNumber: value => Number.isFinite(value),
-    // a `maybeStringEnum` with no `model` can't be membership-checked; reject
-    // rather than admit any string. `def.model` is the author's plain enumeration
-    // (ConfigSlot adds the nullability), so this reads the real vocabulary.
-    maybeStringEnum: (value, def) => !!def.model &&
-        typeof value === 'string' &&
-        getEnumerationValues(def.model).includes(value),
-};
-/**
- * Whether `value` has a JS shape this slot could hold. Guards the untyped
- * session store / saved snapshot against garbage; not a full validation
- * (`validate` layers semantics on top).
- *
- * Module-private on purpose: `isUsableValue` is the gate, and this is only one
- * of its four checks. A caller reaching for the shape test alone would skip the
- * `jexl:` refusal and the slot's `validate` hook — the two checks that exist
- * precisely because a shape-valid value can still be unusable.
- *
- * Keyed off `promotedBase` because that is the only concrete specimen of the
- * slot's value space a promotable slot declares — `defaultValue` is always the
- * inherit sentinel, so keying off it would demand `typeof value === 'undefined'`.
- * A `promotedBase` checked against itself therefore only exercises the
- * `SHAPE_CHECKS` entries, which is exactly the half that can be authored wrong
- * (an enum member that isn't in the vocabulary, a non-finite number).
- *
- * Can't delegate to the slot's MST `model.is(value)`, which is too permissive
- * exactly where this guard matters — `slotShape.test.ts` pins the two cases.
- */
-function matchesSlotShape(def, value) {
-    const { promotedBase } = def;
-    const check = SHAPE_CHECKS[def.type];
-    return check
-        ? check(value, def)
-        : typeof promotedBase === 'object' && promotedBase !== null
-            ? // object/array slot (e.g. `colorBy`): match null-ness and array-ness —
-                // a bare `typeof` compare would admit `null` (typeof null === 'object')
-                // and an array against an object base
-                typeof value === 'object' &&
-                    value !== null &&
-                    Array.isArray(value) === Array.isArray(promotedBase)
-            : typeof value === typeof promotedBase;
-}
-/**
- * Whether a stored value could really be a value of this slot. An unusable value
- * is dropped by the cascade, so the getter, the pin and the badge all fall back
- * in lockstep.
- *
- * The `jexl:` check is the only place the subsystem handles a callback, and it
- * handles it by refusing it — a hand-edited config or default store is untyped,
- * and a callback string would otherwise reach a renderer as a literal value.
- * DISPLAY_TYPE_DEFAULTS.md §"No callbacks".
- */
-export function isUsableValue(def, value) {
-    const { validate } = def;
-    return (value !== undefined &&
-        !isCallbackValue(value) &&
-        matchesSlotShape(def, value) &&
-        (!validate || validate(value)));
-}

package/esm/pluggableElementTypes/models/HighlightsMixin.d.ts

@@ -1,51 +0,0 @@
-import type { HighlightType } from '../../util/highlights.ts';
-/**
- * #stateModel HighlightsMixin
- * #category view
- *
- * The `view.highlight` band state shared verbatim by the LinearGenomeView and
- * DotplotView: an array of translucent highlight regions plus the
- * `showHighlightChips` toggle for their interactive chips. Both views compose
- * this so the props and actions stay identical by construction rather than by
- * two hand-kept copies. Visibility across all views is the session-wide
- * `highlightsVisible` flag (on BaseSession), not a prop here.
- */
-export default function HighlightsMixin(): import("@jbrowse/mobx-state-tree").IModelType<{
-    /**
-     * #property
-     * translucent highlight bands, seeded from URL params or session JSON and
-     * added interactively via the rubber-band menu
-     */
-    highlight: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<HighlightType, HighlightType, HighlightType>>, [undefined]>;
-    /**
-     * #property
-     * pins the interactive highlight chip (link icon + context menu) to every
-     * highlight band; off by default, where a band instead reveals its chip
-     * while the pointer is in it. This is what a screenshot needs, since
-     * nothing hovers in one
-     */
-    showHighlightChips: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
-}, {
-    /**
-     * #action
-     */
-    addToHighlights(highlight: HighlightType): void;
-    /**
-     * #action
-     */
-    setHighlight(highlight?: HighlightType[]): void;
-    /**
-     * #action
-     */
-    removeHighlight(highlight: HighlightType): void;
-    /**
-     * #action
-     */
-    updateHighlight(old: HighlightType, updates: Partial<HighlightType>): void;
-    /**
-     * #action
-     */
-    setShowHighlightChips(arg: boolean): void;
-} & {
-    afterAttach(): void;
-}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/pluggableElementTypes/models/HighlightsMixin.js

@@ -1,78 +0,0 @@
-import { cast, types } from '@jbrowse/mobx-state-tree';
-import { revealHighlightsOnGrowth } from '../../util/highlights.js';
-import { getSession } from '../../util/index.js';
-/**
- * #stateModel HighlightsMixin
- * #category view
- *
- * The `view.highlight` band state shared verbatim by the LinearGenomeView and
- * DotplotView: an array of translucent highlight regions plus the
- * `showHighlightChips` toggle for their interactive chips. Both views compose
- * this so the props and actions stay identical by construction rather than by
- * two hand-kept copies. Visibility across all views is the session-wide
- * `highlightsVisible` flag (on BaseSession), not a prop here.
- */
-export default function HighlightsMixin() {
-    return types
-        .model({
-        /**
-         * #property
-         * translucent highlight bands, seeded from URL params or session JSON and
-         * added interactively via the rubber-band menu
-         */
-        highlight: types.stripDefault(types.array(types.frozen()), []),
-        /**
-         * #property
-         * pins the interactive highlight chip (link icon + context menu) to every
-         * highlight band; off by default, where a band instead reveals its chip
-         * while the pointer is in it. This is what a screenshot needs, since
-         * nothing hovers in one
-         */
-        showHighlightChips: types.stripDefault(types.boolean, false),
-    })
-        .actions(self => ({
-        /**
-         * #action
-         */
-        addToHighlights(highlight) {
-            self.highlight.push(highlight);
-        },
-        /**
-         * #action
-         */
-        setHighlight(highlight) {
-            self.highlight = cast(highlight);
-        },
-        /**
-         * #action
-         */
-        removeHighlight(highlight) {
-            self.highlight.remove(highlight);
-        },
-        /**
-         * #action
-         */
-        updateHighlight(old, updates) {
-            const idx = self.highlight.indexOf(old);
-            if (idx !== -1) {
-                self.highlight[idx] = { ...old, ...updates };
-                // reachable from the highlight grid, which lists entries even with
-                // the bands off, so recoloring there would otherwise do nothing
-                // visible. Not a growth, so revealHighlightsOnGrowth can't see it
-                getSession(self).revealHighlights();
-            }
-        },
-        /**
-         * #action
-         */
-        setShowHighlightChips(arg) {
-            self.showHighlightChips = arg;
-        },
-    }))
-        .actions(self => ({
-        afterAttach() {
-            // covers the rubber-band menu, dotplot drag and URL init alike
-            revealHighlightsOnGrowth(self, () => self.highlight.length);
-        },
-    }));
-}

package/esm/ui/PinAdornment.d.ts

@@ -1,5 +0,0 @@
-import type { MenuItemPin } from './MenuTypes.ts';
-export declare function PinAdornment({ pin, disabled, }: {
-    pin: MenuItemPin;
-    disabled?: boolean;
-}): import("react").JSX.Element;

package/esm/ui/PinAdornment.js

@@ -1,79 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import PushPinIcon from '@mui/icons-material/PushPin';
-import PushPinOutlinedIcon from '@mui/icons-material/PushPinOutlined';
-import { ToggleButton, Tooltip } from '@mui/material';
-import { makeStyles } from '../util/tss-react/index.js';
-const useStyles = makeStyles()(theme => ({
-    // compact enough to sit inline with the value check: drop the default
-    // ToggleButton border/padding so it's ~icon-sized, but keep the selected
-    // background tint (an unmistakable on/off signal, unlike a hollow-vs-filled
-    // icon alone)
-    button: {
-        border: 0,
-        padding: theme.spacing(0.25),
-    },
-    // the Tooltip listens on this rather than on the button, which fires no
-    // events once the row disables it
-    wrapper: {
-        display: 'inline-flex',
-    },
-}));
-// How the pin names what it acts on. Two shapes, decided by the on-value:
-//
-// - **A boolean on-value carries a state**, and the row's label names the
-//   setting rather than a value ("Show legend", "Show soft clipping"). A pin on
-//   an unchecked such row applies the setting *off*, so the value-shaped copy
-//   below stated the opposite of what the click does — and then, once filled,
-//   claimed the setting was on by default when it had just been turned off.
-// - **Everything else IS what the label says**: a radio option ("Compact"), a
-//   size row whose caller folds the value into the label ("Line width (2px)").
-//
-// One `typeof` rather than a flag on the row, because the two forms of
-// `makePin` are exactly this distinction: a symmetric pin over a `maybeBoolean`
-// slot is the only way a pin's value and its label can disagree.
-function pinPredicate(onValue) {
-    return typeof onValue === 'boolean'
-        ? `${onValue ? 'on' : 'off'} by default`
-        : 'the default';
-}
-// The click, which is not the state the pin draws: an outline pin applies the
-// value to the open tracks, a filled one clears the default it stands for.
-function pinCopy(label, onValue, isDefault) {
-    return isDefault
-        ? {
-            title: `${label} is ${pinPredicate(onValue)} for all tracks of this type (click to clear)`,
-            ariaLabel: `clear the default for ${label}`,
-        }
-        : typeof onValue === 'boolean'
-            ? {
-                title: `Turn ${label} ${onValue ? 'on' : 'off'} for all open tracks of this type`,
-                ariaLabel: `turn ${label} ${onValue ? 'on' : 'off'} for all open tracks`,
-            }
-            : {
-                title: `Apply ${label} to all open tracks of this type`,
-                ariaLabel: `apply ${label} to all open tracks`,
-            };
-}
-// Trailing pin for a promotable setting, rendered as a menu item's
-// `endAdornment` beside the value check. A ToggleButton (native button a11y + a
-// clear selected tint) with a pin — distinct from the value checkbox.
-//
-// **The click and the state are two different things.** One click writes the
-// value into every open track of this display type and raises a snackbar
-// offering to keep it as the display type's default; the filled pin means that
-// default is in place, so a click on a filled pin clears it and touches no
-// track. A default therefore takes two deliberate clicks, which is what it costs
-// to govern every track of the type opened later (ADR-048). Always shown so the
-// capability is discoverable. stopPropagation keeps the click off the row value
-// / menu dismissal. "of this type" because a promoted default is scoped to the
-// display type (e.g. every LinearAlignmentsDisplay), not literally all tracks.
-export function PinAdornment({ pin, disabled, }) {
-    const { classes } = useStyles();
-    const { label, control } = pin;
-    const isDefault = control.active;
-    const { title, ariaLabel } = pinCopy(label, control.onValue, isDefault);
-    return (_jsx(Tooltip, { title: title, children: _jsx("span", { className: classes.wrapper, children: _jsx(ToggleButton, { className: classes.button, value: "default", disabled: disabled, selected: isDefault, color: "primary", size: "small", "aria-label": ariaLabel, onChange: e => {
-                    e.stopPropagation();
-                    control.toggle();
-                }, children: isDefault ? (_jsx(PushPinIcon, { fontSize: "small" })) : (_jsx(PushPinOutlinedIcon, { fontSize: "small" })) }) }) }));
-}

package/esm/ui/SvgGradientLegend.d.ts

@@ -1,26 +0,0 @@
-export interface GradientStop {
-    offset: string;
-    color: string;
-    opacity?: number;
-}
-export interface GradientLabel {
-    text: string;
-    position: 'start' | 'middle' | 'end';
-}
-export declare const GRADIENT_LEGEND_WIDTH = 120;
-export declare const GRADIENT_LEGEND_HEIGHT = 40;
-export declare const GRADIENT_LEGEND_SVG_AREA_WIDTH: number;
-export default function SvgGradientLegend({ gradientId, stops, labels, title, x, y, width, height, barWidth, barHeight, padding, fontSize, }: {
-    gradientId: string;
-    stops: GradientStop[];
-    labels: GradientLabel[];
-    title?: string;
-    x?: number;
-    y?: number;
-    width?: number;
-    height?: number;
-    barWidth?: number;
-    barHeight?: number;
-    padding?: number;
-    fontSize?: number;
-}): import("react").JSX.Element;

package/esm/ui/SvgGradientLegend.js

@@ -1,26 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/* eslint-disable react-refresh/only-export-components -- layout constants belong with this leaf SVG primitive; no component state to fast-refresh */
-import { svgSafeId } from '../svg/svgId.js';
-// Default box/bar geometry shared by the LD and Hi-C legends. Exported so
-// callers that size an outer container (an <svg> wrapper) or compute an offset
-// stay in lockstep with what this component draws.
-export const GRADIENT_LEGEND_WIDTH = 120;
-export const GRADIENT_LEGEND_HEIGHT = 40;
-// Horizontal space a display should reserve (via `svgLegendWidth()`) to park
-// this legend beside the plot in an SVG export: the bar itself plus a 10px
-// margin either side.
-export const GRADIENT_LEGEND_SVG_AREA_WIDTH = GRADIENT_LEGEND_WIDTH + 20;
-// Shared SVG color-ramp key: a rounded translucent box, a horizontal gradient
-// bar, and labels below it. Used by any display that colors by a continuous
-// scale (Hi-C contact counts, LD r²/D'). Renders a <g>; position via x/y.
-export default function SvgGradientLegend({ gradientId, stops, labels, title, x = 0, y = 0, width = GRADIENT_LEGEND_WIDTH, height = GRADIENT_LEGEND_HEIGHT, barWidth = 100, barHeight = 12, padding = 8, fontSize = 10, }) {
-    const titleGap = title ? fontSize + 4 : 0;
-    const barY = padding + titleGap;
-    const labelY = barY + barHeight + fontSize + 2;
-    const safeGradientId = svgSafeId(gradientId);
-    return (_jsxs("g", { transform: `translate(${x}, ${y})`, children: [_jsx("defs", { children: _jsx("linearGradient", { id: safeGradientId, x1: "0%", y1: "0%", x2: "100%", y2: "0%", children: stops.map(stop => (_jsx("stop", { offset: stop.offset, style: { stopColor: stop.color, stopOpacity: stop.opacity ?? 1 } }, stop.offset))) }) }), _jsx("rect", { x: 0, y: 0, width: width, height: height + titleGap, fill: "rgba(255,255,255,0.95)", stroke: "#ccc", strokeWidth: 1, rx: 4 }), title ? (_jsx("text", { x: padding, y: padding + fontSize, fontSize: fontSize, fill: "black", children: title })) : null, _jsx("rect", { x: padding, y: barY, width: barWidth, height: barHeight, fill: `url(#${safeGradientId})`, rx: 2 }), labels.map(label => (_jsx("text", { x: label.position === 'start'
-                    ? padding
-                    : label.position === 'middle'
-                        ? padding + barWidth / 2
-                        : padding + barWidth, y: labelY, fontSize: fontSize, fill: "black", textAnchor: label.position === 'start' ? undefined : label.position, children: label.text }, `${label.position}-${label.text}`)))] }));
-}