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

package/esm/ui/legendSpec.js

@@ -1,51 +1,42 @@
-// The marks a row draws: its explicit list, else its single color/mark pair,
-// else nothing at all (a heading).
+// The boxes a row draws: its explicit list, else its single color, else nothing
+// at all (a heading).
 export function legendSwatches(item) {
-    return (item.swatches ??
-        (item.color === undefined ? [] : [{ color: item.color, mark: item.mark }]));
+    return (item.swatches ?? (item.color === undefined ? [] : [{ color: item.color }]));
 }
 // Drop sections with nothing in them, so a heading can never end up with no
 // swatches under it.
-export function nonEmptyLegendSections({ items, sections }) {
-    return (sections ?? (items ? [{ id: 'items', items }] : [])).filter(s => s.items.length > 0);
+export function nonEmptyLegendSections(sections) {
+    return sections.filter(s => s.items.length > 0);
 }
 // Flatten a legend spec into `SvgColorLegend` rows: a color-less row reads as a
 // heading rather than a swatch. Section titles appear only when more than one
 // section survives — a lone vocabulary needs no title above it — which is the
 // rule `FloatingLegend` applies on screen, so an export and the live legend
 // agree about when headings show. A box-level `title` is unconditional, like its
-// on-screen counterpart.
+// on-screen counterpart, and `''` is no heading in either.
 export function legendEntries(spec) {
-    const sections = nonEmptyLegendSections(spec);
+    const sections = nonEmptyLegendSections(spec.sections);
     const titled = sections.length > 1;
     return [
-        ...(spec.title === undefined
-            ? []
-            : [{ key: 'legend-title', label: spec.title }]),
+        ...(spec.title ? [{ key: 'legend-title', label: spec.title }] : []),
         ...sections.flatMap(section => [
-            ...(titled && section.title !== undefined
+            ...(titled && section.title
                 ? [{ key: `${section.id}-title`, label: section.title }]
                 : []),
+            ...(section.note === undefined
+                ? []
+                : [{ key: `${section.id}-note`, label: section.note }]),
             ...section.items.map((item, idx) => ({
                 key: `${section.id}-${idx}`,
                 label: item.label,
                 color: item.color,
-                swatches: exportSwatches(item),
+                swatches: item.swatches,
                 hidden: item.hidden,
+                gradient: item.gradient,
             })),
         ]),
     ];
 }
-// A single filled swatch is what `color` alone already draws, so only a row
-// that says something more — several marks, or one that isn't a fill — carries
-// the list into the export. Keeps the common entry the three fields it has
-// always been.
-function exportSwatches(item) {
-    const swatches = legendSwatches(item);
-    return swatches.length > 1 || swatches.some(s => s.mark && s.mark !== 'fill')
-        ? swatches
-        : undefined;
-}
 /**
  * How many rows a color key may have and still be one. Past this it is a list
  * of every row, which is the thing a key exists instead of.

package/esm/ui/makeSizeMenu.d.ts

@@ -1,5 +1,3 @@
-import type { ResolvableDisplay } from '../configuration/promotableResolve.ts';
-import type { AnyConfigurationModel, ConfigurationSchemaForModel, ConfigurationSlotName } from '../configuration/types.ts';
 import type { MenuItem } from './MenuTypes.ts';
 import type { SliderScale } from './sliderScale.ts';
 interface SizeMenuOptions {
@@ -23,8 +21,4 @@ export declare function makeSizeMenu(opts: SizeMenuOptions & {
 export declare function makeSizeSubMenu(opts: SizeMenuOptions & {
     isDefault: boolean;
 }): MenuItem;
-export declare function makePromotableSizeMenu<CONFMODEL extends AnyConfigurationModel, SLOT extends ConfigurationSlotName<ConfigurationSchemaForModel<CONFMODEL>>>(opts: SizeMenuOptions & {
-    display: ResolvableDisplay<CONFMODEL>;
-    slot: SLOT;
-}): MenuItem;
 export {};

package/esm/ui/makeSizeMenu.js

@@ -1,10 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Suspense, lazy } from 'react';
-import { isSlotCustomized, makePin, } from '../configuration/promotableDefaults.js';
 import { INLINE_MENU_ROW_WIDTH } from './inlineMenuRowWidth.js';
-// The row's drawn half is `lazy()` for the reason the promotable pin is a
-// description rather than an element: this builder is called from state models
-// and menu modules, which are eager, and the row is the only route by which MUI
+// The row's drawn half is `lazy()` because this builder is called from state
+// models and menu modules, which are eager, and the row is the only route by
+// which MUI
 // `Slider` — the largest single Material component in the eager graph — reached
 // a host's first paint. `type: 'custom'` already made `render` a thunk, so the
 // laziness is free at call time; it is the module edge that had to go.
@@ -20,10 +19,8 @@ const sizeRowFallbackHeight = 46;
 // accessors + a title (which also derives the slider's test id). Used by wiggle
 // point-size/line-width, GWAS Manhattan point-size, arc width, the alignments
 // modification threshold and GC-content window/step sizes, so the
-// slider/reset/pin behavior can't drift. Pass `scale: 'log'` for values spanning
+// slider/reset behavior can't drift. Pass `scale: 'log'` for values spanning
 // orders of magnitude, and `format` to label non-`px` units.
-//
-// For a row over a promotable slot use `makePromotableSizeMenu`.
 export function makeSizeMenu(opts) {
     return sizeMenu(opts, opts.isDefault);
 }
@@ -48,35 +45,14 @@ export function makeSizeSubMenu(opts) {
         subMenu: [makeSizeMenu(opts)],
     };
 }
-// The same row over a **promotable** slot, which derives both halves the plain
-// form takes by hand — the reset button's enablement (`isSlotCustomized`) and
-// the "default for all tracks of this type" pin — from the one slot name. A
-// slider has no fixed on-value, so the pin promotes whatever the track is
-// currently showing.
-//
-// Naming the slot once is the point: the call sites used to spell it twice, in
-// `isDefault` and again in the pin, with nothing checking the two agreed.
-export function makePromotableSizeMenu(opts) {
-    const { display, slot } = opts;
-    return sizeMenu(opts, !isSlotCustomized(display, slot), makePin(display, slot));
-}
-function sizeMenu(opts, isDefault, pin) {
+function sizeMenu(opts, isDefault) {
     const { label, title, getValue, min = 0.5, max = 12, step = 0.5, unit = 'px', scale = 'linear', format = (n) => `${n}${unit}`, commitOnRelease, onChange, onReset, } = opts;
     return {
         label,
         type: 'custom',
-        // Declared even though `SizeSliderRow` below is what draws it: a custom row
-        // never reaches the shared trailing column, so without this the pin exists
-        // on screen and is invisible to `pinnedSlots` — which is the difference
-        // between a promotable slot that is genuinely unreachable and one that just
-        // renders its own control. See `hasMenuItemAdornment` for why declaring it
-        // costs no layout.
-        ...(pin && {
-            pin: { control: pin, label: title },
-        }),
         render: () => (_jsx(Suspense, { fallback: _jsx("div", { style: {
                     width: INLINE_MENU_ROW_WIDTH,
                     height: sizeRowFallbackHeight,
-                } }), children: _jsx(SizeSliderRow, { title: title, getValue: getValue, min: min, max: max, step: step, scale: scale, format: format, isDefault: isDefault, commitOnRelease: commitOnRelease, onChange: onChange, onReset: onReset, pin: pin }) })),
+                } }), children: _jsx(SizeSliderRow, { title: title, getValue: getValue, min: min, max: max, step: step, scale: scale, format: format, isDefault: isDefault, commitOnRelease: commitOnRelease, onChange: onChange, onReset: onReset }) })),
     };
 }

package/esm/ui/measureLegendText.js

@@ -1,4 +1,4 @@
-import { measureText } from '../util/index.js';
+import { measureText } from '../util/measureText.js';
 // measureText uses a Helvetica width table, but SVG legend <text> nodes have no
 // font-family and render in the wider app font (Roboto), so scale the estimate
 // up before sizing the white paper behind a label or it clips.

package/esm/ui/menuItemAdornment.d.ts

@@ -2,32 +2,21 @@ import type { MenuItem } from './MenuTypes.ts';
 /**
  * The trailing control a menu row draws, resolved at the point of drawing.
  *
- * Two fields feed it and they are not equivalent. `endAdornment` is an element
- * the builder already made — the escape hatch, for content nothing else can
- * describe. `pin` is a *description* of the "default for all tracks of
- * this type" pin, and turning it into `PinAdornment` here is the whole
- * point: the builders that set it (`promotableToggleItem`,
- * `promotableRadioItem`) are called from state models and menu modules, which
- * are eager, so a module that constructs the element instead puts MUI's
- * `ToggleButton`, `Tooltip` and two icons into every host's first paint.
+ * `endAdornment` is an element the builder already made — synteny's and
+ * wiggle's colour swatches — so the row hands it straight through.
  *
- * Live in one place rather than at each of the four render sites, because the
- * "does any row have one?" predicates and the rendering have to agree — a row
- * that draws a pin the column-reservation pass didn't count is a misaligned
- * menu, not a crash.
+ * Lives in one place rather than at each of the four render sites, because the
+ * "does any row have one?" predicate and the rendering have to agree — a row
+ * that draws an adornment the column-reservation pass didn't count is a
+ * misaligned menu, not a crash.
  */
-export declare function menuItemAdornment(item: MenuItem): string | number | bigint | true | import("react").JSX.Element | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | Iterable<import("react").ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | undefined;
+export declare function menuItemAdornment(item: MenuItem): import("react").ReactNode;
 /**
  * Whether this row draws something in the shared trailing column — the question
  * `getMenuColumnFlags` asks to decide whether to reserve that column on every
  * row of the menu.
  *
- * **Not the same question as "does this row offer a pin"** (`pinnedSlots`, which
- * counts a `pin` wherever it appears). A `type: 'custom'` row renders
- * its own content edge to edge and never reaches `menuItemAdornment`, so it
- * cannot draw in that column however it is declared — counting it would reserve
- * a spacer on its siblings for a control that never appears. It still declares
- * `pin` when it draws a pin of its own (`makePromotableSizeMenu`),
- * which is what keeps the pin findable. Don't "fix" the two into agreement.
+ * A `type: 'custom'` row renders its own content edge to edge and never reaches
+ * `menuItemAdornment`, so it cannot draw in that column however it is declared.
  */
 export declare function hasMenuItemAdornment(item: MenuItem): boolean;

package/esm/ui/menuItemAdornment.js

@@ -1,50 +1,28 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { PinAdornment } from './PinAdornment.js';
 /**
  * The trailing control a menu row draws, resolved at the point of drawing.
  *
- * Two fields feed it and they are not equivalent. `endAdornment` is an element
- * the builder already made — the escape hatch, for content nothing else can
- * describe. `pin` is a *description* of the "default for all tracks of
- * this type" pin, and turning it into `PinAdornment` here is the whole
- * point: the builders that set it (`promotableToggleItem`,
- * `promotableRadioItem`) are called from state models and menu modules, which
- * are eager, so a module that constructs the element instead puts MUI's
- * `ToggleButton`, `Tooltip` and two icons into every host's first paint.
+ * `endAdornment` is an element the builder already made — synteny's and
+ * wiggle's colour swatches — so the row hands it straight through.
  *
- * Live in one place rather than at each of the four render sites, because the
- * "does any row have one?" predicates and the rendering have to agree — a row
- * that draws a pin the column-reservation pass didn't count is a misaligned
- * menu, not a crash.
+ * Lives in one place rather than at each of the four render sites, because the
+ * "does any row have one?" predicate and the rendering have to agree — a row
+ * that draws an adornment the column-reservation pass didn't count is a
+ * misaligned menu, not a crash.
  */
 export function menuItemAdornment(item) {
-    if ('endAdornment' in item && item.endAdornment) {
-        return item.endAdornment;
-    }
-    // A disabled row is `pointer-events: none` (see `DisabledTooltip`, which
-    // exists because that also swallows a Tooltip's hover), so a pin drawn in one
-    // takes no click while looking exactly like a live one. Greying it is what
-    // the help "?" does on such a row by not rendering at all; the pin stays
-    // drawn so the trailing column keeps its alignment.
-    return 'pin' in item && item.pin ? (_jsx(PinAdornment, { pin: item.pin, disabled: item.disabled })) : undefined;
+    return 'endAdornment' in item ? item.endAdornment : undefined;
 }
 /**
  * Whether this row draws something in the shared trailing column — the question
  * `getMenuColumnFlags` asks to decide whether to reserve that column on every
  * row of the menu.
  *
- * **Not the same question as "does this row offer a pin"** (`pinnedSlots`, which
- * counts a `pin` wherever it appears). A `type: 'custom'` row renders
- * its own content edge to edge and never reaches `menuItemAdornment`, so it
- * cannot draw in that column however it is declared — counting it would reserve
- * a spacer on its siblings for a control that never appears. It still declares
- * `pin` when it draws a pin of its own (`makePromotableSizeMenu`),
- * which is what keeps the pin findable. Don't "fix" the two into agreement.
+ * A `type: 'custom'` row renders its own content edge to edge and never reaches
+ * `menuItemAdornment`, so it cannot draw in that column however it is declared.
  */
 export function hasMenuItemAdornment(item) {
     if (item.type === 'custom') {
         return false;
     }
-    return (('endAdornment' in item && !!item.endAdornment) ||
-        ('pin' in item && !!item.pin));
+    return 'endAdornment' in item && !!item.endAdornment;
 }

package/esm/ui/menuItems.d.ts

@@ -13,16 +13,11 @@
  * from `@jbrowse/core/ui`.** This entry must never reach react, @mui or
  * @emotion, and `menuItems.purity.test.ts` fails if it starts to — including
  * transitively, which is the only way the failure would ever show up.
- *
- * The other half of keeping that true is `MenuItemPin`: a row's pin is
- * described here and built by the renderer, because an element in a descriptor
- * pulls its whole component graph back in.
  */
 export { checkboxItem, radioItem, radioItems, toggleItem, withSubHeader, } from './toggleMenuItems.ts';
 export { withHint } from './menuLabels.ts';
 export { makeRadioSubMenu } from './radioSubMenu.ts';
 export { showLegendCheckboxItem } from './legendMenuItem.ts';
-export { promotableRadioItem, promotableRadioItems, promotableToggleItem, } from './promotableMenuItems.ts';
 export type { RadioOption, SettingRowOptions } from './toggleMenuItems.ts';
-export { staysOpenOnClick } from './MenuTypes.ts';
-export type { BaseMenuItem, CheckboxMenuItem, ClickableMenuItem, CustomMenuItem, MenuDivider, MenuItem, MenuItemClickHandler, MenuItemPin, MenuItemsGetter, MenuSubHeader, NormalMenuItem, RadioMenuItem, SubMenuItem, } from './MenuTypes.ts';
+export { resolveSubMenu, staysOpenOnClick } from './MenuTypes.ts';
+export type { BaseMenuItem, CheckboxMenuItem, ClickableMenuItem, CustomMenuItem, MenuDivider, MenuItem, MenuItemClickHandler, MenuItemsGetter, MenuSubHeader, NormalMenuItem, RadioMenuItem, SubMenuItem, } from './MenuTypes.ts';

package/esm/ui/menuItems.js

@@ -13,14 +13,9 @@
  * from `@jbrowse/core/ui`.** This entry must never reach react, @mui or
  * @emotion, and `menuItems.purity.test.ts` fails if it starts to — including
  * transitively, which is the only way the failure would ever show up.
- *
- * The other half of keeping that true is `MenuItemPin`: a row's pin is
- * described here and built by the renderer, because an element in a descriptor
- * pulls its whole component graph back in.
  */
 export { checkboxItem, radioItem, radioItems, toggleItem, withSubHeader, } from './toggleMenuItems.js';
 export { withHint } from './menuLabels.js';
 export { makeRadioSubMenu } from './radioSubMenu.js';
 export { showLegendCheckboxItem } from './legendMenuItem.js';
-export { promotableRadioItem, promotableRadioItems, promotableToggleItem, } from './promotableMenuItems.js';
-export { staysOpenOnClick } from './MenuTypes.js';
+export { resolveSubMenu, staysOpenOnClick } from './MenuTypes.js';

package/esm/ui/multiTrackMenuItems.d.ts

@@ -1,8 +1,14 @@
 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;