@jbrowse/plugin-linear-genome-view 5.0.0-beta.13 → 5.0.0-beta.16

package/esm/LinearGenomeView/svgcomponents/SVGStackedRow.d.ts

@@ -7,7 +7,7 @@ import type { TrackLabelMode } from '@jbrowse/display-kit/types';
  * reserves `getRowHeaderLayout().bandHeight` above it for the header to draw
  * into, and the row is `rulerHeight + rendered.tracksHeight` tall below it.
  */
-export default function SVGStackedRow({ view, rendered, top, margin, fontSize, textHeight, rulerHeight, trackLabels, trackLabelOffset, showGridlines, legendWidth, showAssemblyName, showScalebar, }: {
+export default function SVGStackedRow({ view, rendered, top, margin, fontSize, textHeight, rulerHeight, trackLabels, trackLabelOffset, showGridlines, showAssemblyName, showScalebar, }: {
     view: LinearGenomeViewModel;
     rendered: {
         displayResults: SvgDisplayResult[];
@@ -21,7 +21,6 @@ export default function SVGStackedRow({ view, rendered, top, margin, fontSize, t
     trackLabels: TrackLabelMode;
     trackLabelOffset: number;
     showGridlines: boolean;
-    legendWidth?: number;
     showAssemblyName?: boolean;
     showScalebar?: boolean;
 }): import("react").JSX.Element;

package/esm/LinearGenomeView/svgcomponents/SVGStackedRow.js

@@ -7,6 +7,6 @@ import SVGView from './SVGView.js';
  * reserves `getRowHeaderLayout().bandHeight` above it for the header to draw
  * into, and the row is `rulerHeight + rendered.tracksHeight` tall below it.
  */
-export default function SVGStackedRow({ view, rendered, top, margin, fontSize, textHeight, rulerHeight, trackLabels, trackLabelOffset, showGridlines, legendWidth, showAssemblyName, showScalebar, }) {
-    return (_jsx("g", { transform: `translate(${margin} ${top})`, children: _jsx(SVGView, { view: view, displayResults: rendered.displayResults, header: _jsx(SVGRowHeader, { view: view, fontSize: fontSize, rulerHeight: rulerHeight, showAssemblyName: showAssemblyName, showScalebar: showScalebar }), fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabels, trackLabelOffset: trackLabelOffset, contentTop: rulerHeight, tracksHeight: rendered.tracksHeight, showGridlines: showGridlines, leftBuffer: margin, legendWidth: legendWidth }) }));
+export default function SVGStackedRow({ view, rendered, top, margin, fontSize, textHeight, rulerHeight, trackLabels, trackLabelOffset, showGridlines, showAssemblyName, showScalebar, }) {
+    return (_jsx("g", { transform: `translate(${margin} ${top})`, children: _jsx(SVGView, { view: view, displayResults: rendered.displayResults, header: _jsx(SVGRowHeader, { view: view, fontSize: fontSize, rulerHeight: rulerHeight, showAssemblyName: showAssemblyName, showScalebar: showScalebar }), fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabels, trackLabelOffset: trackLabelOffset, contentTop: rulerHeight, tracksHeight: rendered.tracksHeight, showGridlines: showGridlines, leftBuffer: margin }) }));
 }

package/esm/LinearGenomeView/svgcomponents/SVGTracks.d.ts

@@ -2,7 +2,7 @@ import type { LinearGenomeViewModel } from '../index.ts';
 import type { TrackLabelMode } from '../types.ts';
 import type { SvgDisplayResult } from './util.ts';
 type LGV = LinearGenomeViewModel;
-export default function SVGTracks({ displayResults, model, textHeight, fontSize, trackLabels, trackLabelOffset, leftBuffer, legendWidth, }: {
+export default function SVGTracks({ displayResults, model, textHeight, fontSize, trackLabels, trackLabelOffset, leftBuffer, }: {
     displayResults: SvgDisplayResult[];
     model: LGV;
     textHeight: number;
@@ -10,6 +10,5 @@ export default function SVGTracks({ displayResults, model, textHeight, fontSize,
     trackLabels: TrackLabelMode;
     trackLabelOffset: number;
     leftBuffer: number;
-    legendWidth: number;
 }): import("react").JSX.Element;
 export {};

package/esm/LinearGenomeView/svgcomponents/SVGTracks.js

@@ -3,20 +3,20 @@ import { SvgClipRect } from '@jbrowse/core/svg/SvgExport';
 import { svgNodeId } from '@jbrowse/core/svg/svgId';
 import { svgTrackName } from '@jbrowse/core/svg/trackNames';
 import { getSession } from '@jbrowse/core/util';
-import { exportsTooLargeNote } from '@jbrowse/display-kit/renderDisplaySvg';
+import { SvgLegend } from '@jbrowse/display-kit/renderDisplaySvg';
 import SVGRegionSeparators from './SVGRegionSeparators.js';
 import SVGTrackLabel from './SVGTrackLabel.js';
 import { labelOffset, trackBoxOffsets, trackLabelMode } from './util.js';
-export default function SVGTracks({ displayResults, model, textHeight, fontSize, trackLabels, trackLabelOffset, leftBuffer, legendWidth, }) {
+export default function SVGTracks({ displayResults, model, textHeight, fontSize, trackLabels, trackLabelOffset, leftBuffer, }) {
     const session = getSession(model);
     const x = Math.max(-model.offsetPx, 0);
     const offsets = trackBoxOffsets(displayResults.map(r => r.track), trackLabels, textHeight);
-    return (_jsx(_Fragment, { children: displayResults.map(({ track, result }, i) => {
+    return (_jsx(_Fragment, { children: displayResults.map(({ track, result, legendHeight }, i) => {
             const conf = track.configuration;
             const trackName = svgTrackName(track, session);
             const display = track.displays[0];
             const currentOffset = offsets[i];
             const textOffset = labelOffset(track, trackLabels, textHeight);
-            return (_jsxs("g", { transform: `translate(0 ${currentOffset})`, children: [_jsx(SvgClipRect, { id: `track-clip-${svgNodeId(model)}-${conf.trackId}`, x: -leftBuffer, y: textOffset, width: model.width + trackLabelOffset + leftBuffer + legendWidth, height: display.height, children: _jsxs("g", { transform: `translate(${trackLabelOffset} ${textOffset})`, children: [result, exportsTooLargeNote(display) ? null : (_jsx(SVGRegionSeparators, { model: model, height: display.height }))] }) }), _jsx(SVGTrackLabel, { trackName: trackName, fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabelMode(track, trackLabels), trackLabelOffset: trackLabelOffset, x: x + trackLabelOffset })] }, conf.trackId));
+            return (_jsxs("g", { transform: `translate(0 ${currentOffset})`, children: [_jsx(SvgClipRect, { id: `track-clip-${svgNodeId(model)}-${conf.trackId}`, x: -leftBuffer, y: textOffset, width: model.width + trackLabelOffset + leftBuffer, height: display.height, children: _jsxs("g", { transform: `translate(${trackLabelOffset} ${textOffset})`, children: [result, display.regionTooLarge ? null : (_jsx(SVGRegionSeparators, { model: model, height: display.height }))] }) }), legendHeight === undefined ? null : (_jsx("g", { transform: `translate(${trackLabelOffset} ${textOffset})`, children: _jsx(SvgLegend, { model: display, width: model.width, height: legendHeight }) })), _jsx(SVGTrackLabel, { trackName: trackName, fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabelMode(track, trackLabels), trackLabelOffset: trackLabelOffset, x: x + trackLabelOffset })] }, conf.trackId));
         }) }));
 }

package/esm/LinearGenomeView/svgcomponents/SVGView.d.ts

@@ -2,7 +2,7 @@ import type { LinearGenomeViewModel } from '../index.ts';
 import type { TrackLabelMode } from '../types.ts';
 import type { SvgDisplayResult } from './util.ts';
 import type { ReactNode } from 'react';
-export default function SVGView({ view, displayResults, header, fontSize, textHeight, trackLabels, trackLabelOffset, contentTop, tracksHeight, showGridlines, leftBuffer, legendWidth, }: {
+export default function SVGView({ view, displayResults, header, fontSize, textHeight, trackLabels, trackLabelOffset, contentTop, tracksHeight, showGridlines, leftBuffer, }: {
     view: LinearGenomeViewModel;
     displayResults: SvgDisplayResult[];
     header: ReactNode;
@@ -14,5 +14,4 @@ export default function SVGView({ view, displayResults, header, fontSize, textHe
     tracksHeight: number;
     showGridlines: boolean;
     leftBuffer: number;
-    legendWidth?: number;
 }): import("react").JSX.Element;

package/esm/LinearGenomeView/svgcomponents/SVGView.js

@@ -7,7 +7,7 @@ import SVGTracks from './SVGTracks.js';
 // Shared by all three exports that stack an LGV — the standalone one, and the
 // linear-synteny and breakpoint-split rows — so their per-view layout can't
 // drift. It did drift while the standalone export kept its own copy of these
-// four groups: only that copy widened the per-track clip by `legendWidth`.
-export default function SVGView({ view, displayResults, header, fontSize, textHeight, trackLabels, trackLabelOffset, contentTop, tracksHeight, showGridlines, leftBuffer, legendWidth = 0, }) {
-    return (_jsxs(_Fragment, { children: [_jsx("g", { transform: `translate(${trackLabelOffset})`, children: header }), showGridlines ? (_jsx("g", { transform: `translate(${trackLabelOffset} ${contentTop})`, children: _jsx(SVGGridlines, { model: view, height: tracksHeight }) })) : null, _jsx("g", { transform: `translate(0 ${contentTop})`, children: _jsx(SVGTracks, { textHeight: textHeight, trackLabels: trackLabels, fontSize: fontSize, model: view, displayResults: displayResults, trackLabelOffset: trackLabelOffset, leftBuffer: leftBuffer, legendWidth: legendWidth }) }), _jsx("g", { transform: `translate(${trackLabelOffset} ${contentTop})`, children: _jsx(SVGHighlightsOverlay, { model: view, tracksHeight: tracksHeight }) })] }));
+// four groups.
+export default function SVGView({ view, displayResults, header, fontSize, textHeight, trackLabels, trackLabelOffset, contentTop, tracksHeight, showGridlines, leftBuffer, }) {
+    return (_jsxs(_Fragment, { children: [_jsx("g", { transform: `translate(${trackLabelOffset})`, children: header }), showGridlines ? (_jsx("g", { transform: `translate(${trackLabelOffset} ${contentTop})`, children: _jsx(SVGGridlines, { model: view, height: tracksHeight }) })) : null, _jsx("g", { transform: `translate(0 ${contentTop})`, children: _jsx(SVGTracks, { textHeight: textHeight, trackLabels: trackLabels, fontSize: fontSize, model: view, displayResults: displayResults, trackLabelOffset: trackLabelOffset, leftBuffer: leftBuffer }) }), _jsx("g", { transform: `translate(${trackLabelOffset} ${contentTop})`, children: _jsx(SVGHighlightsOverlay, { model: view, tracksHeight: tracksHeight }) })] }));
 }

package/esm/LinearGenomeView/svgcomponents/renderViewTracks.d.ts

@@ -7,7 +7,7 @@ export interface SvgExportTrack {
     minimized: boolean;
     displays: {
         height: number;
-        svgLegendWidth?: () => number;
+        regionTooLarge?: boolean;
         svgSidebarWidth?: LgvSvgExportable['svgSidebarWidth'];
         /**
          * Optional, and the option is the point: SVG export is a substantial extra
@@ -23,13 +23,18 @@ export interface SvgExportTrack {
 export interface ViewTracksSvg<T> {
     /** the tracks that were rendered, in the order they were laid out */
     tracks: T[];
+    /**
+     * `legendHeight` is the room a track's key has in the gutter, absent for a
+     * track with no key to draw
+     */
     displayResults: {
         track: T;
         result: ReactNode;
+        legendHeight?: number;
     }[];
     /** total height of the stack, valid only because the renders above resolved */
     tracksHeight: number;
-    /** 0 unless `reserveLegendWidth` was asked for */
+    /** px the caller widens its canvas by for the keys right of the plot */
     legendWidth: number;
     /**
      * Visible tracks left out because their display implements no `renderSvg`.
@@ -42,30 +47,28 @@ export interface ViewTracksSvg<T> {
  * One view's worth of exported track bodies: which tracks are in, their
  * rendered SVG, and how tall the stack ends up.
  *
- * It exists to own the two orderings that each of the three view exports got
- * wrong at least once, because neither is visible at a call site that merely
- * lists the same statements in some order:
+ * It exists to own an ordering that each of the three view exports got wrong at
+ * least once, because it is not visible at a call site that merely lists the
+ * same statements in some order: the geometry is measured **after** the
+ * awaits.
  *
- * - `legendWidth` is measured **before** the awaits, because it is an input to
- *   them: a display draws its legend beside its body or floating over it
- *   depending on whether the container reserved room. That is why
- *   `svgLegendWidth` is specified as a function of the *settings* and not of
- *   the loaded data — see LinearHicDisplay's implementation.
- * - `tracksHeight` is measured **after** them. A display whose height follows
- *   its data (grow mode; `LinearMultiRowFeatureDisplay` is `nrow *
- *   effectiveRowHeight`) only reaches its final height once `renderSvg`'s
- *   readiness wait resolves, and `SVGTracks` re-reads `displays[0].height`
- *   later still. Measuring up front sized the canvas for the pre-fetch height
- *   and the taller bodies ran off the bottom of the export — and in the
- *   breakpoint-split export it also desynced the overlay anchors, resolved
- *   after, from the view tops, which weren't.
+ * - `tracksHeight`: a display whose height follows its data (grow mode;
+ *   `LinearMultiRowFeatureDisplay` is `nrow * effectiveRowHeight`) only reaches
+ *   its final height once `renderSvg`'s readiness wait resolves, and
+ *   `SVGTracks` re-reads `displays[0].height` later still. Measuring up front
+ *   sized the canvas for the pre-fetch height and the taller bodies ran off the
+ *   bottom of the export — and in the breakpoint-split export it also desynced
+ *   the overlay anchors, resolved after, from the view tops, which weren't.
+ * - `legendWidth`: most keys list what was loaded, and on a headless export
+ *   (jbrowse-img) nothing has loaded before the waits. Measured after, a track
+ *   with no key reserves nothing and the figure has no empty strip.
  *
  * The minimized filter and the track order are here for the same reason: the
  * reserved height, the rendered bodies, the label gutter and (breakpoint-split)
  * the ribbon anchors must all be derived from one list, and pinned tracks are
  * drawn at the top of a view on screen.
  */
-export declare function renderViewTracks<T extends SvgExportTrack>({ view, opts, theme, textHeight, trackLabels, reserveLegendWidth, }: {
+export declare function renderViewTracks<T extends SvgExportTrack>({ view, opts, theme, textHeight, trackLabels, }: {
     view: {
         pinnedTracks: T[];
         unpinnedTracks: T[];
@@ -74,5 +77,4 @@ export declare function renderViewTracks<T extends SvgExportTrack>({ view, opts,
     theme: ThemeOptions | undefined;
     textHeight: number;
     trackLabels: TrackLabelMode;
-    reserveLegendWidth?: boolean;
 }): Promise<ViewTracksSvg<T>>;

package/esm/LinearGenomeView/svgcomponents/renderViewTracks.js

@@ -1,34 +1,33 @@
 import { awaitSvgRenders } from '@jbrowse/core/svg/svgReady';
 import { max } from '@jbrowse/core/util';
-import { totalHeight } from './util.js';
+import { svgLegendGutterWidth } from '@jbrowse/display-kit/renderDisplaySvg';
+import { labelOffset, totalHeight, trackBoxOffsets } from './util.js';
 /**
  * One view's worth of exported track bodies: which tracks are in, their
  * rendered SVG, and how tall the stack ends up.
  *
- * It exists to own the two orderings that each of the three view exports got
- * wrong at least once, because neither is visible at a call site that merely
- * lists the same statements in some order:
+ * It exists to own an ordering that each of the three view exports got wrong at
+ * least once, because it is not visible at a call site that merely lists the
+ * same statements in some order: the geometry is measured **after** the
+ * awaits.
  *
- * - `legendWidth` is measured **before** the awaits, because it is an input to
- *   them: a display draws its legend beside its body or floating over it
- *   depending on whether the container reserved room. That is why
- *   `svgLegendWidth` is specified as a function of the *settings* and not of
- *   the loaded data — see LinearHicDisplay's implementation.
- * - `tracksHeight` is measured **after** them. A display whose height follows
- *   its data (grow mode; `LinearMultiRowFeatureDisplay` is `nrow *
- *   effectiveRowHeight`) only reaches its final height once `renderSvg`'s
- *   readiness wait resolves, and `SVGTracks` re-reads `displays[0].height`
- *   later still. Measuring up front sized the canvas for the pre-fetch height
- *   and the taller bodies ran off the bottom of the export — and in the
- *   breakpoint-split export it also desynced the overlay anchors, resolved
- *   after, from the view tops, which weren't.
+ * - `tracksHeight`: a display whose height follows its data (grow mode;
+ *   `LinearMultiRowFeatureDisplay` is `nrow * effectiveRowHeight`) only reaches
+ *   its final height once `renderSvg`'s readiness wait resolves, and
+ *   `SVGTracks` re-reads `displays[0].height` later still. Measuring up front
+ *   sized the canvas for the pre-fetch height and the taller bodies ran off the
+ *   bottom of the export — and in the breakpoint-split export it also desynced
+ *   the overlay anchors, resolved after, from the view tops, which weren't.
+ * - `legendWidth`: most keys list what was loaded, and on a headless export
+ *   (jbrowse-img) nothing has loaded before the waits. Measured after, a track
+ *   with no key reserves nothing and the figure has no empty strip.
  *
  * The minimized filter and the track order are here for the same reason: the
  * reserved height, the rendered bodies, the label gutter and (breakpoint-split)
  * the ribbon anchors must all be derived from one list, and pinned tracks are
  * drawn at the top of a view on screen.
  */
-export async function renderViewTracks({ view, opts, theme, textHeight, trackLabels, reserveLegendWidth = false, }) {
+export async function renderViewTracks({ view, opts, theme, textHeight, trackLabels, }) {
     // Partitioned before anything is measured, so a skipped track reserves no
     // height and takes no place in the label gutter — the alternative is a figure
     // with a labelled empty band where the track would have been. One pass, so
@@ -42,25 +41,39 @@ export async function renderViewTracks({ view, opts, theme, textHeight, trackLab
             (track.displays[0]?.renderSvg ? tracks : skippedTracks).push(track);
         }
     }
-    const legendWidth = reserveLegendWidth
-        ? max(tracks.map(track => track.displays[0].svgLegendWidth?.() ?? 0), 0)
-        : 0;
     // `awaitSvgRenders` over `Promise.all`: a track whose data won't load fails
     // the export, and a view with three broken tracks should say so once rather
     // than name whichever rejected first
     const displayResults = await awaitSvgRenders(tracks.map(async (track) => ({
         track,
-        result: await track.displays[0].renderSvg({
-            ...opts,
-            theme,
-            legendWidth,
-        }),
+        result: await track.displays[0].renderSvg({ ...opts, theme }),
     })));
+    const tracksHeight = totalHeight(tracks, trackLabels, textHeight);
+    const keyed = tracks.map(track => !track.displays[0].regionTooLarge &&
+        svgLegendGutterWidth(track.displays[0], theme, Infinity) > 0);
+    const bodyTops = trackBoxOffsets(tracks, trackLabels, textHeight).map((top, i) => top + labelOffset(tracks[i], trackLabels, textHeight));
+    // A key runs from its body's top to the next keyed body's, or to the foot of
+    // the stack, so a long key beside a short track carries on past the unkeyed
+    // tracks below it before it cuts to "+N more".
+    const legendHeights = keyed.map((isKeyed, i) => {
+        const next = keyed.findIndex((k, j) => k && j > i);
+        return isKeyed
+            ? (next === -1 ? tracksHeight : bodyTops[next]) - bodyTops[i]
+            : undefined;
+    });
     return {
         tracks,
-        displayResults,
-        tracksHeight: totalHeight(tracks, trackLabels, textHeight),
-        legendWidth,
+        displayResults: displayResults.map((r, i) => ({
+            ...r,
+            legendHeight: legendHeights[i],
+        })),
+        tracksHeight,
+        legendWidth: max(tracks.map((track, i) => {
+            const height = legendHeights[i];
+            return height === undefined
+                ? 0
+                : svgLegendGutterWidth(track.displays[0], theme, height);
+        }), 0),
         skippedTracks,
     };
 }

package/esm/LinearGenomeView/svgcomponents/useViewSvgFigure.js

@@ -16,12 +16,11 @@ import { defaultTextHeight, getRowHeaderLayout, trackLabelLeftOffset, } from './
  * One figure: every visible track rendered to SVG elements, and the geometry
  * that lays them out.
  *
- * `renderViewTracks` owns the two orderings this cannot state for itself — the
- * legend gutter measured before the renders (a display draws its key beside the
- * plot or floating over it depending on whether the container reserved room),
- * the stack height after them (a display whose height follows its data only
- * reaches its final height once its readiness wait resolves). Everything read
- * below is read after the awaits for the same reason.
+ * `renderViewTracks` owns the ordering this cannot state for itself: the stack
+ * height and the legend gutter are measured after the renders, since a
+ * display's height and its key follow data that lands only once its readiness
+ * wait resolves. Everything read below is read after the awaits for the same
+ * reason.
  */
 async function renderFigure(view, opts) {
     const { fontSize, rulerHeight, trackLabels, rasterizeLayers, showScalebar } = opts;
@@ -39,9 +38,6 @@ async function renderFigure(view, opts) {
         theme,
         textHeight,
         trackLabels,
-        // an inline figure has room to give: a legend sits beside the plot rather
-        // than over it
-        reserveLegendWidth: true,
     });
     // the room the row header needs *above* its own origin — it draws the assembly
     // name and the scalebar at negative y, so the caller reserves the band and
@@ -61,7 +57,6 @@ async function renderFigure(view, opts) {
         height: bandHeight + rulerHeight + tracksHeight + opts.margin,
         bandHeight,
         tracksHeight,
-        legendWidth,
         trackLabelOffset,
         textHeight,
         locstring: view.visibleLocStrings,
@@ -108,7 +103,7 @@ const FrozenSvgFigure = memo(function FrozenSvgFigure({ view, snapshot, }) {
             // anything passed per-render would have to reach past the memo above,
             // which is the one thing holding the figure's two halves together. A
             // host that wants other sizing wraps this in a box of its own.
-            style: { display: 'block', maxWidth: '100%' }, children: _jsx(SVGStackedRow, { view: view, rendered: snapshot, top: snapshot.bandHeight, margin: margin, fontSize: snapshot.fontSize, textHeight: snapshot.textHeight, rulerHeight: snapshot.rulerHeight, trackLabels: snapshot.trackLabels, trackLabelOffset: snapshot.trackLabelOffset, showGridlines: snapshot.showGridlines, legendWidth: snapshot.legendWidth, showScalebar: snapshot.showScalebar }) }) }));
+            style: { display: 'block', maxWidth: '100%' }, children: _jsx(SVGStackedRow, { view: view, rendered: snapshot, top: snapshot.bandHeight, margin: margin, fontSize: snapshot.fontSize, textHeight: snapshot.textHeight, rulerHeight: snapshot.rulerHeight, trackLabels: snapshot.trackLabels, trackLabelOffset: snapshot.trackLabelOffset, showGridlines: snapshot.showGridlines, showScalebar: snapshot.showScalebar }) }) }));
 });
 /**
  * What "the figure is out of date" means, as a string.

package/esm/LinearGenomeView/svgcomponents/util.d.ts

@@ -17,10 +17,11 @@ export interface SvgDisplayResult {
         displays: ({
             height: number;
             regionTooLarge?: boolean;
-            drawsWhenTooLarge?: boolean;
         } & SidebarDisplay)[];
     };
     result: ReactNode;
+    /** the room its key has in the export's legend gutter, absent for no key */
+    legendHeight?: number;
 }
 export declare const trackSpacing = 2;
 export declare function gridlineTickXs(model: {

package/esm/LinearGenomeView/util.d.ts

@@ -361,5 +361,47 @@ export declare function generateLocations({ regions, assemblyManager, assemblyNa
  * Used by navToLocString
  */
 export declare function parseLocStrings(input: string, assemblyName: string, isValidRefName: (str: string, assemblyName: string) => boolean): ParsedLocString[];
+/** One span of the row that is not track data — see `paddingSpans`. */
+export interface PaddingSpan {
+    key: string;
+    x: number;
+    width: number;
+    kind: 'seam' | 'elided' | 'boundary';
+}
+/**
+ * Tick positions in the staticBlocks frame, one pass per merged run so a tick
+ * on an internal ~800px chunk boundary is emitted once.
+ */
+export declare function getGridlineTicks({ blocks, firstBlockOffset, bpPerPx, }: {
+    blocks: BaseBlock[];
+    firstBlockOffset: number;
+    bpPerPx: number;
+}): {
+    x: number;
+    major: boolean;
+}[];
+/**
+ * Coordinate labels in the staticBlocks frame, off the same ticks as
+ * `getGridlineTicks`. A run that can hold too few labels to make a ruler goes
+ * unnumbered, and the bold refName label pinned at a run's left edge takes
+ * precedence over a number.
+ */
+export declare function getScalebarLabels({ blocks, firstBlockOffset, bpPerPx, orientation, }: {
+    blocks: BaseBlock[];
+    firstBlockOffset: number;
+    bpPerPx: number;
+    orientation: RegionsOrientation;
+}): {
+    x: number;
+    label: string;
+    key: string;
+}[];
+/**
+ * Every span along the row that is not track data, in the staticBlocks frame.
+ * Nothing to draw returns one shared array, so the computed's value repeats and
+ * MobX's `===` stops the chain: a view inside one contig has no seam, elision
+ * or boundary, and a fresh `[]` each frame re-rendered every track's padding.
+ */
+export declare function getPaddingSpans(blocks: BaseBlock[], firstBlockOffset: number): readonly PaddingSpan[];
 export declare function calculateVisibleLocStrings(contentBlocks: ContentBlock[]): string;
 export {};

package/esm/LinearGenomeView/util.js

@@ -636,6 +636,87 @@ export function parseLocStrings(input, assemblyName, isValidRefName) {
         throw e;
     }
 }
+// Frozen because every consumer maps over it and a caller that sorted in place
+// would do so for the whole session.
+const NO_PADDING_SPANS = Object.freeze([]);
+/**
+ * Tick positions in the staticBlocks frame, one pass per merged run so a tick
+ * on an internal ~800px chunk boundary is emitted once.
+ */
+export function getGridlineTicks({ blocks, firstBlockOffset, bpPerPx, }) {
+    const ticks = [];
+    for (const run of groupContiguousBlocks(blocks)) {
+        const runLeft = run.offsetPx - firstBlockOffset;
+        for (const { type, x } of makeBlockTicks(run, bpPerPx)) {
+            if (x >= 0 && x <= run.widthPx) {
+                ticks.push({ x: runLeft + x, major: type === 'major' });
+            }
+        }
+    }
+    return ticks;
+}
+/**
+ * Coordinate labels in the staticBlocks frame, off the same ticks as
+ * `getGridlineTicks`. A run that can hold too few labels to make a ruler goes
+ * unnumbered, and the bold refName label pinned at a run's left edge takes
+ * precedence over a number.
+ */
+export function getScalebarLabels({ blocks, firstBlockOffset, bpPerPx, orientation, }) {
+    const labels = [];
+    const runs = groupContiguousBlocks(blocks);
+    const refNameLabelPx = runRefNameLabelPx(runs, orientation);
+    for (const [i, run] of runs.entries()) {
+        const runLeft = run.offsetPx - firstBlockOffset;
+        const runLabels = [];
+        for (const { base, x } of makeBlockTicks(run, bpPerPx, false)) {
+            const label = getTickDisplayStr(base + 1, bpPerPx);
+            const w = tickLabelWidth(label);
+            if (x - w / 2 >= refNameLabelPx[i] &&
+                labelFitsInBlock(x - w / 2, w, run.widthPx)) {
+                runLabels.push({
+                    x: runLeft + x,
+                    label,
+                    key: `${run.offsetPx}-${base}`,
+                });
+            }
+        }
+        if (tickLabelsWorthDrawing(runLabels.length)) {
+            labels.push(...runLabels);
+        }
+    }
+    return labels;
+}
+/**
+ * Every span along the row that is not track data, in the staticBlocks frame.
+ * Nothing to draw returns one shared array, so the computed's value repeats and
+ * MobX's `===` stops the chain: a view inside one contig has no seam, elision
+ * or boundary, and a fresh `[]` each frame re-rendered every track's padding.
+ */
+export function getPaddingSpans(blocks, firstBlockOffset) {
+    const spans = [];
+    for (const block of blocks) {
+        const x = block.offsetPx - firstBlockOffset;
+        if (block.type === 'ContentBlock') {
+            if (block.isRightEndOfDisplayedRegion) {
+                spans.push({
+                    key: `${block.key}-sep`,
+                    x: x + block.widthPx - 1,
+                    width: 3,
+                    kind: 'seam',
+                });
+            }
+        }
+        else {
+            spans.push({
+                key: block.key,
+                x,
+                width: block.widthPx,
+                kind: block.type === 'ElidedBlock' ? 'elided' : 'boundary',
+            });
+        }
+    }
+    return spans.length > 0 ? spans : NO_PADDING_SPANS;
+}
 export function calculateVisibleLocStrings(contentBlocks) {
     return assembleLocStrings(contentBlocks.map(block => ({
         refName: block.refName,

package/esm/MultiLevelRubberband/MultiLevelRubberband.js

@@ -34,7 +34,7 @@ const MultiLevelRubberband = observer(function MultiLevelRubberband({ model, Con
 });
 // one row per rubberband level, in level order. values repeat across levels
 // whenever the assemblies line up, so the index is the only stable key
-function PerLevelRows({ rows }) {
+const PerLevelRows = observer(function PerLevelRows({ rows, }) {
     return rows.map((row, idx) => (_jsx("div", { children: row }, idx)));
-}
+});
 export default MultiLevelRubberband;

package/esm/displayKitTests/perRegionTestEnv.d.ts

@@ -245,6 +245,8 @@ declare function makeStateModel(control: PerRegionTestControl, gate: GateOptIns,
         }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
     };
     trackMenuItems(): import("@jbrowse/core/ui").MenuItem[];
+    configProblemsOf(conf: import("@jbrowse/core/configuration").AnyConfigurationModel): string[];
+    readonly liveNotices: string[];
 } & {
     setStatusMessage(status?: import("@jbrowse/core/util").RpcStatus): void;
     setError(error?: unknown): void;
@@ -263,15 +265,23 @@ declare function makeStateModel(control: PerRegionTestControl, gate: GateOptIns,
 } & {
     readonly plotKeys: string[];
     readonly plot: import("@jbrowse/core/configuration").Plot;
+    readonly configNotices: string[];
+    readonly notices: string[];
+    readonly cornerNotices: string[];
     readonly plotExamples: readonly import("@jbrowse/core/configuration").PlotExample[];
     readonly configDocsUrl: string;
-    liftPlot(draft: import("@jbrowse/core/configuration").Plot): import("@jbrowse/core/configuration").AnyConfigurationModel;
-    plotProblems(draft: import("@jbrowse/core/configuration").Plot): string[];
-    plotWrites(draft: import("@jbrowse/core/configuration").Plot): Record<string, unknown>;
+    liftPlot(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): import("@jbrowse/core/configuration").AnyConfigurationModel;
+    plotProblems(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): string[];
+    plotWrites(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): Record<string, unknown>;
 } & {
-    applyPlot(draft: import("@jbrowse/core/configuration").Plot): void;
+    applyPlot(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): void;
 } & {
     scrollTop: number;
+    hostHeight: number | undefined;
+} & {
+    readonly configuredHeight: number;
+} & {
+    readonly allottedHeight: number;
 } & {
     readonly height: number;
     readonly resizing: boolean;
@@ -281,6 +291,7 @@ declare function makeStateModel(control: PerRegionTestControl, gate: GateOptIns,
     readonly scrollableHeight: number;
 } & {
     setScrollTop(scrollTop: number): void;
+    setHostHeight(height: number | undefined): void;
     setHeight(displayHeight: number): number;
     resizeHeight(distance: number): number;
 } & {
@@ -772,6 +783,8 @@ export declare function createPerRegionTestEnvironment({ measuresBytes, gate, es
                 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
             };
             trackMenuItems(): import("@jbrowse/core/ui").MenuItem[];
+            configProblemsOf(conf: import("@jbrowse/core/configuration").AnyConfigurationModel): string[];
+            readonly liveNotices: string[];
         } & {
             setStatusMessage(status?: import("@jbrowse/core/util").RpcStatus): void;
             setError(error?: unknown): void;
@@ -790,15 +803,23 @@ export declare function createPerRegionTestEnvironment({ measuresBytes, gate, es
         } & {
             readonly plotKeys: string[];
             readonly plot: import("@jbrowse/core/configuration").Plot;
+            readonly configNotices: string[];
+            readonly notices: string[];
+            readonly cornerNotices: string[];
             readonly plotExamples: readonly import("@jbrowse/core/configuration").PlotExample[];
             readonly configDocsUrl: string;
-            liftPlot(draft: import("@jbrowse/core/configuration").Plot): import("@jbrowse/core/configuration").AnyConfigurationModel;
-            plotProblems(draft: import("@jbrowse/core/configuration").Plot): string[];
-            plotWrites(draft: import("@jbrowse/core/configuration").Plot): Record<string, unknown>;
+            liftPlot(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): import("@jbrowse/core/configuration").AnyConfigurationModel;
+            plotProblems(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): string[];
+            plotWrites(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): Record<string, unknown>;
         } & {
-            applyPlot(draft: import("@jbrowse/core/configuration").Plot): void;
+            applyPlot(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): void;
         } & {
             scrollTop: number;
+            hostHeight: number | undefined;
+        } & {
+            readonly configuredHeight: number;
+        } & {
+            readonly allottedHeight: number;
         } & {
             readonly height: number;
             readonly resizing: boolean;
@@ -808,6 +829,7 @@ export declare function createPerRegionTestEnvironment({ measuresBytes, gate, es
             readonly scrollableHeight: number;
         } & {
             setScrollTop(scrollTop: number): void;
+            setHostHeight(height: number | undefined): void;
             setHeight(displayHeight: number): number;
             resizeHeight(distance: number): number;
         } & {
@@ -1188,6 +1210,8 @@ export declare function createPerRegionTestEnvironment({ measuresBytes, gate, es
                 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
             };
             trackMenuItems(): import("@jbrowse/core/ui").MenuItem[];
+            configProblemsOf(conf: import("@jbrowse/core/configuration").AnyConfigurationModel): string[];
+            readonly liveNotices: string[];
         } & {
             setStatusMessage(status?: import("@jbrowse/core/util").RpcStatus): void;
             setError(error?: unknown): void;
@@ -1206,15 +1230,23 @@ export declare function createPerRegionTestEnvironment({ measuresBytes, gate, es
         } & {
             readonly plotKeys: string[];
             readonly plot: import("@jbrowse/core/configuration").Plot;
+            readonly configNotices: string[];
+            readonly notices: string[];
+            readonly cornerNotices: string[];
             readonly plotExamples: readonly import("@jbrowse/core/configuration").PlotExample[];
             readonly configDocsUrl: string;
-            liftPlot(draft: import("@jbrowse/core/configuration").Plot): import("@jbrowse/core/configuration").AnyConfigurationModel;
-            plotProblems(draft: import("@jbrowse/core/configuration").Plot): string[];
-            plotWrites(draft: import("@jbrowse/core/configuration").Plot): Record<string, unknown>;
+            liftPlot(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): import("@jbrowse/core/configuration").AnyConfigurationModel;
+            plotProblems(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): string[];
+            plotWrites(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): Record<string, unknown>;
         } & {
-            applyPlot(draft: import("@jbrowse/core/configuration").Plot): void;
+            applyPlot(draft: import("@jbrowse/core/configuration").Plot, options?: import("@jbrowse/core/configuration").PlotWriteOptions): void;
         } & {
             scrollTop: number;
+            hostHeight: number | undefined;
+        } & {
+            readonly configuredHeight: number;
+        } & {
+            readonly allottedHeight: number;
         } & {
             readonly height: number;
             readonly resizing: boolean;
@@ -1224,6 +1256,7 @@ export declare function createPerRegionTestEnvironment({ measuresBytes, gate, es
             readonly scrollableHeight: number;
         } & {
             setScrollTop(scrollTop: number): void;
+            setHostHeight(height: number | undefined): void;
             setHeight(displayHeight: number): number;
             resizeHeight(distance: number): number;
         } & {