@jbrowse/plugin-linear-genome-view 5.0.0-beta.1 → 5.0.0-beta.10

package/esm/LinearGenomeView/svgcomponents/useViewSvgFigure.js

@@ -1,17 +1,14 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { memo, useCallback, useEffect, useRef, useSyncExternalStore, } from 'react';
+import { SvgThemeProviders } from '@jbrowse/core/svg/SvgThemeProviders';
 import { exportMargin } from '@jbrowse/core/svg/constants';
+import { svgNodeId } from '@jbrowse/core/svg/svgId';
 import { svgTrackName } from '@jbrowse/core/svg/trackNames';
-import { StyleThemeProvider } from '@jbrowse/core/ui/PaletteContext';
-import { resolveStyleTheme } from '@jbrowse/core/ui/styleTheme';
-import { createJBrowseTheme } from '@jbrowse/core/ui/theme';
 import { getSession } from '@jbrowse/core/util';
 import { useFetch } from '@jbrowse/core/util/useFetch';
-import { isAlive } from '@jbrowse/mobx-state-tree';
-import { ThemeProvider } from '@mui/material';
+import { getSnapshot, isAlive } from '@jbrowse/mobx-state-tree';
 import { reaction } from 'mobx';
-import SVGRowHeader from './SVGRowHeader.js';
-import SVGView from './SVGView.js';
+import SVGStackedRow from './SVGStackedRow.js';
 import { useFrozenFigureContract, useOneFigurePerView, } from './figureContract.js';
 import { renderViewTracks } from './renderViewTracks.js';
 import { defaultTextHeight, getRowHeaderLayout, trackLabelLeftOffset, } from './util.js';
@@ -87,38 +84,31 @@ async function renderFigure(view, opts) {
  * render. Where it matters, this line is the only thing holding the two halves
  * together.
  *
- * Both providers, as `wrapSvgExport` mounts for the file path, and for the same
- * reason: the chrome takes its colors from the Material UI theme and a
- * `makeStyles` component would take its own from the style theme, so a figure
- * mounted in a host that installs neither would otherwise draw itself in
- * JBrowse's *default light* theme whatever the session is set to.
+ * The export's theme providers, as the file path mounts them: a host that
+ * installs neither would otherwise get JBrowse's default light theme whatever
+ * the session is set to.
  *
  * No background rect, unlike a file — that has nothing behind it, and a figure
- * in a page has the page. No `resetSvgClipIds` either, and that is the opposite
- * decision from the file path on purpose: the counter is document-global, so
- * resetting it here would renumber ids that a figure already on the page is
- * pointing at. Letting it run is what makes several live figures unique.
+ * in a page has the page. No `withFreshSvgClipIds` either, and that is the
+ * opposite decision from the file path on purpose: the counter is
+ * document-global, so restarting it here would reuse ids that a figure already
+ * on the page is pointing at. Letting it run is what makes several live figures
+ * unique.
  */
 const FrozenSvgFigure = memo(function FrozenSvgFigure({ view, snapshot, }) {
     const { width, height, margin, theme } = snapshot;
-    // dev-only, and it watches for the one thing this component cannot enforce:
-    // an observer INSIDE the tree, which the memo above is not between
+    // it watches for the one thing this component cannot enforce: an observer
+    // INSIDE the tree, which the memo above is not between
     const ref = useRef(null);
     useFrozenFigureContract(ref, snapshot);
-    return (_jsx(ThemeProvider, { theme: createJBrowseTheme(theme), children: _jsx(StyleThemeProvider, { theme: resolveStyleTheme({ configTheme: theme }), children: _jsx("svg", { ref: ref, width: width, height: height, viewBox: `0 0 ${width} ${height}`, 
-                // It is a vector, so a narrower container scales it rather than
-                // clipping it; the height attribute stays, so a box reserved for it
-                // does not change size when that happens. Deliberately not a prop:
-                // 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("g", { transform: `translate(${margin} ${snapshot.bandHeight})`, children: _jsx(SVGView, { view: view, displayResults: snapshot.displayResults, header: _jsx(SVGRowHeader, { view: view, fontSize: snapshot.fontSize, rulerHeight: snapshot.rulerHeight, showScalebar: snapshot.showScalebar }), fontSize: snapshot.fontSize, textHeight: snapshot.textHeight, trackLabels: snapshot.trackLabels, trackLabelOffset: snapshot.trackLabelOffset, 
-                        // the row header is exactly the ruler, so the bodies start at its
-                        // height
-                        contentTop: snapshot.rulerHeight, tracksHeight: snapshot.tracksHeight, showGridlines: snapshot.showGridlines, 
-                        // the left gutter the per-track clip may bleed into, so content
-                        // drawn left of zero — a wiggle's y-axis — survives
-                        leftBuffer: snapshot.margin, legendWidth: snapshot.legendWidth }) }) }) }) }));
+    return (_jsx(SvgThemeProviders, { theme: theme, children: _jsx("svg", { ref: ref, width: width, height: height, viewBox: `0 0 ${width} ${height}`, 
+            // It is a vector, so a narrower container scales it rather than
+            // clipping it; the height attribute stays, so a box reserved for it
+            // does not change size when that happens. Deliberately not a prop:
+            // 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 }) }) }));
 });
 /**
  * What "the figure is out of date" means, as a string.
@@ -141,11 +131,10 @@ const FrozenSvgFigure = memo(function FrozenSvgFigure({ view, snapshot, }) {
  * highlight bands**, which are drawn in the figure and are the one thing in it a
  * reader adds without navigating anywhere.
  *
- * A plugin's own overlay (grid-bookmark's bookmarks, through
- * `LinearGenomeView-HighlightSVGComponent`) is state this cannot see, so a
- * bookmark added under a drawn figure shows up at its next redraw rather than at
- * once. Subscribing from inside the figure is the thing that must not happen —
- * see the note at the top of the file.
+ * A plugin's own overlay, through `LinearGenomeView-HighlightSVGComponent`, is
+ * state this cannot see, so a change to it shows up at the figure's next
+ * redraw rather than at once. Subscribing from inside the figure is the thing
+ * that must not happen — see the note at the top of the file.
  */
 function figureKey(view, themeName) {
     // A closed view is not an error, it is a host doing an ordinary thing in an
@@ -156,10 +145,10 @@ function figureKey(view, themeName) {
     // throw a TypeError inside the reaction, where MobX swallows it. No key means
     // no figure, which is what a host that closed the view wanted anyway.
     //
-    // `view.width` throws by design before the view has been measured, and
-    // `ready` is the gate that says it has been — and that there are regions to
-    // draw, which is the second async step `initialized` does not cover
-    if (!isAlive(view) || !view.ready) {
+    // `view.width` throws by design before the view has been measured. `status`
+    // is ready only once it has been AND there are regions to draw — `ready` is
+    // also true for a view nothing has told where to look, measured or not
+    if (!isAlive(view) || view.status.type !== 'ready') {
         return '';
     }
     const session = getSession(view);
@@ -167,14 +156,12 @@ function figureKey(view, themeName) {
         view.coarseVisibleLocStrings,
         view.coarseBpPerPx,
         view.width,
-        view.tracks.map(track => [
-            track.configuration.trackId,
-            track.minimized,
-            track.displays[0]?.height,
-        ]),
+        // the snapshot carries pinned, minimized and the display settings a body
+        // bakes in; the effective height is a getter, so it is read beside it
+        view.tracks.map(track => [getSnapshot(track), track.displays[0]?.height]),
         session.getActiveThemeOptions?.(themeName),
-        session.highlightsVisible ? view.highlight : false,
-        view.labelsVisible,
+        session.highlightsVisible ? view.highlights : false,
+        session.highlightLabelsVisible,
     ]);
 }
 /**
@@ -212,25 +199,7 @@ function useFigureKey(view, themeName) {
 export function useViewSvgFigure(view, { fontSize = 12, rulerHeight = 30, trackLabels = 'offset', showGridlines = true, showScalebar = true, rasterizeLayers = false, margin = exportMargin, themeName, } = {}) {
     const key = useFigureKey(view, themeName);
     useOneFigurePerView(view);
-    const { data: snapshot, error, isLoading, } = useFetch(
-    // Every option is in the key by value, so an inline options object costs
-    // nothing and a changed option redraws. A null key is `useFetch`'s own "not
-    // yet", which is what an unready view reports.
-    key
-        ? [
-            'lgv-svg-figure',
-            key,
-            JSON.stringify([
-                fontSize,
-                rulerHeight,
-                trackLabels,
-                showGridlines,
-                showScalebar,
-                rasterizeLayers,
-                margin,
-            ]),
-        ]
-        : null, () => renderFigure(view, {
+    const opts = {
         fontSize,
         rulerHeight,
         trackLabels,
@@ -239,7 +208,20 @@ export function useViewSvgFigure(view, { fontSize = 12, rulerHeight = 30, trackL
         rasterizeLayers,
         margin,
         themeName,
-    }));
+    };
+    const { data: snapshot, error, isLoading, } = useFetch(
+    // Every option is in the key by value, so an inline options object costs
+    // nothing and a changed option redraws. The view's id too: two views can
+    // share every other term. A null key is `useFetch`'s own "not yet", which
+    // is what an unready view reports.
+    key
+        ? [
+            'lgv-svg-figure',
+            svgNodeId(view),
+            key,
+            JSON.stringify(opts),
+        ]
+        : null, () => renderFigure(view, opts));
     // Written in an effect and read during render, which is the order that makes
     // it work: a key change clears `data` on the render where the ref still holds
     // the previous commit's size, so the host's box keeps the height it had rather

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

@@ -5,6 +5,7 @@ import type { ReactNode } from 'react';
 interface TrackHeights {
     displays: {
         height: number;
+        prefersOffset?: boolean;
     }[];
 }
 export interface SvgDisplayResult {
@@ -12,6 +13,8 @@ export interface SvgDisplayResult {
         configuration: AnyConfigurationModel;
         displays: {
             height: number;
+            regionTooLarge?: boolean;
+            drawsWhenTooLarge?: boolean;
         }[];
     };
     result: ReactNode;
@@ -58,6 +61,7 @@ export declare function getRowHeaderLayout({ fontSize, showScalebar, }: {
     assemblyLabelBaselineY: number;
     bandHeight: number;
 };
+export type HeaderLayout = ReturnType<typeof getHeaderLayout>;
 export declare function getHeaderLayout({ fontSize, showCytobands, rulerHeight, }: {
     fontSize: number;
     showCytobands: boolean;
@@ -71,14 +75,14 @@ export declare function getHeaderLayout({ fontSize, showCytobands, rulerHeight,
 };
 export declare const RULER_MAJOR_TICK = 5;
 export declare const RULER_MINOR_TICK = 3;
-export declare const RULER_TICK_FONT_SIZE = 11;
 export declare function getRulerLayout(rulerHeight: number): {
     tickTopY: number;
     numbersBaselineY: number;
 };
 export declare const refNameLabelBoxHeight: number;
 export declare const refNameLabelBaselineY: number;
-export declare function labelOffset(trackLabels: TrackLabelMode, textHeight: number): number;
+export declare function trackLabelMode(track: TrackHeights, trackLabels: TrackLabelMode): TrackLabelMode;
+export declare function labelOffset(track: TrackHeights, trackLabels: TrackLabelMode, textHeight: number): number;
 export declare const TRACK_LABEL_GAP = 40;
 export declare function trackLabelLeftOffset({ tracks, trackLabels, fontSize, fontFamily, session, }: {
     tracks: {
@@ -89,7 +93,7 @@ export declare function trackLabelLeftOffset({ tracks, trackLabels, fontSize, fo
     fontFamily?: string;
     session: TrackCatalog;
 }): number;
-export declare function trackBoxHeight(track: TrackHeights, textOffset: number): number;
-export declare function trackBoxOffsets(tracks: TrackHeights[], textOffset: number): number[];
-export declare function totalHeight(tracks: TrackHeights[], textHeight: number, trackLabels: TrackLabelMode): number;
+export declare function trackBoxHeight(track: TrackHeights, trackLabels: TrackLabelMode, textHeight: number): number;
+export declare function trackBoxOffsets(tracks: TrackHeights[], trackLabels: TrackLabelMode, textHeight: number): number[];
+export declare function totalHeight(tracks: TrackHeights[], trackLabels: TrackLabelMode, textHeight: number): number;
 export {};

package/esm/LinearGenomeView/svgcomponents/util.js

@@ -80,7 +80,7 @@ export function defaultTextHeight(fontSize) {
 export function offsetLabelBaselineY(textHeight, fontSize) {
     return textHeight - LABEL_PAD_BOTTOM - labelDescent(fontSize);
 }
-// Baseline for a label inset into the top of the box it draws over ('overlay'
+// Baseline for a label inset into the top of the box it draws over ('overlapping'
 // mode), measured down from that top edge so the ascenders stay inside it.
 export function insetLabelBaselineY(fontSize) {
     return labelBaselineFromTop(LABEL_PAD_TOP, fontSize);
@@ -99,6 +99,9 @@ export function insetLabelBaselineY(fontSize) {
 // scale in each row the only thing saying whether two rows are at the same zoom
 // is their ruler coordinates, which are unreadable at the size a figure is
 // published at. The standalone LGV export has drawn this bar all along.
+//
+// The name's band is reserved whether or not the row draws one: a breakpoint
+// split view names its first row only, and the rest stay the same height as it.
 export function getRowHeaderLayout({ fontSize, showScalebar, }) {
     const label = labelInkHeight(fontSize);
     // the bp label hangs a cap below the bar's line and its own ink box ends a gap
@@ -111,8 +114,10 @@ export function getRowHeaderLayout({ fontSize, showScalebar, }) {
     // ink box rather than by baseline, because the gaps are fixed while a font's
     // descent is not: laying the label out from its baseline instead put its
     // descenders through that cap at the larger export fonts.
+    // without a scalebar the name sits on its baseline at the origin, its
+    // descenders into the ruler's top, so only the ink above the baseline counts
     const assemblyInkTop = scalebarLineY === undefined
-        ? -label
+        ? -labelBaselineFromTop(0, fontSize)
         : scalebarLineY - SVG_SCALEBAR_CAP - ROW_GAP - label;
     return {
         // undefined rather than an unused number: a row without a scalebar has no
@@ -123,17 +128,9 @@ export function getRowHeaderLayout({ fontSize, showScalebar, }) {
         assemblyLabelBaselineY: showScalebar
             ? labelBaselineFromTop(assemblyInkTop, fontSize)
             : 0,
-        // up from the ruler to the top of the topmost ink box — the assembly
-        // label's, in both cases
         bandHeight: -assemblyInkTop,
     };
 }
-// Compact vertical layout for the exported header: rows (assembly name,
-// cytoband overview, "you are here" polygon, total-bp scalebar, ruler) are
-// stacked with a small fixed gap rather than reserving loose fixed-height
-// bands, so nothing is separated by dead space. `tracksTop` is where the track
-// bodies begin (renderToSvg's `offset`). Shared by SVGHeader and renderToSvg so
-// the header height and the track origin can't drift.
 export function getHeaderLayout({ fontSize, showCytobands, rulerHeight, }) {
     // the assembly name is drawn on its ink box, not on `fontSize`: at y=0 with a
     // hanging baseline its ascenders rose above the export's top edge and got
@@ -161,7 +158,6 @@ export function getHeaderLayout({ fontSize, showCytobands, rulerHeight, }) {
 // Ruler tick geometry, shared by the tick marks and their number labels.
 export const RULER_MAJOR_TICK = 5;
 export const RULER_MINOR_TICK = 3;
-export const RULER_TICK_FONT_SIZE = 11;
 // clearance between the tick-number baseline and the marks below it
 const RULER_TICK_LABEL_GAP = 2;
 // Vertical positions within a ruler of the given budget: tick marks hang just
@@ -180,9 +176,17 @@ export function getRulerLayout(rulerHeight) {
 // 13, and both ends of the glyphs at any smaller export font.
 export const refNameLabelBoxHeight = labelInkHeight(REF_NAME_LABEL_FONT_SIZE);
 export const refNameLabelBaselineY = labelBaselineFromTop(0, REF_NAME_LABEL_FONT_SIZE);
-// space the label pushes a track down by; only 'offset' mode does
-export function labelOffset(trackLabels, textHeight) {
-    return trackLabels === 'offset' ? textHeight : 0;
+// The mode one track's label is drawn in. 'overlapping' yields to 'offset' for a
+// display that `prefersOffset`, as TrackContainer does on screen: its left edge
+// carries content — an axis, a sample's genotypes — the label would print over.
+export function trackLabelMode(track, trackLabels) {
+    return trackLabels === 'overlapping' && track.displays[0]?.prefersOffset
+        ? 'offset'
+        : trackLabels;
+}
+// space the label pushes a track's body down by; only 'offset' mode does
+export function labelOffset(track, trackLabels, textHeight) {
+    return trackLabelMode(track, trackLabels) === 'offset' ? textHeight : 0;
 }
 // Gap between a 'left' track label's right edge and the track body.
 // SVGTrackLabel right-aligns its text at `trackLabelOffset - TRACK_LABEL_GAP`,
@@ -216,23 +220,24 @@ export function trackLabelLeftOffset({ tracks, trackLabels, fontSize, fontFamily
 }
 // vertical box a single track occupies. Shared by totalHeight (sum) and
 // trackBoxOffsets (prefix-sum) so the two can't drift.
-export function trackBoxHeight(track, textOffset) {
-    return track.displays[0].height + textOffset + trackSpacing;
+export function trackBoxHeight(track, trackLabels, textHeight) {
+    return (track.displays[0].height +
+        labelOffset(track, trackLabels, textHeight) +
+        trackSpacing);
 }
 // Top y of each track's box within a stack of them. SVGTracks lays the bodies
 // out with it and the breakpoint-split export anchors its overlay ribbons with
 // it, so one implementation rather than two prefix-sums that must agree —
 // they drifted by trackSpacing per track when they didn't.
-export function trackBoxOffsets(tracks, textOffset) {
+export function trackBoxOffsets(tracks, trackLabels, textHeight) {
     const offsets = [];
     let total = 0;
     for (const track of tracks) {
         offsets.push(total);
-        total += trackBoxHeight(track, textOffset);
+        total += trackBoxHeight(track, trackLabels, textHeight);
     }
     return offsets;
 }
-export function totalHeight(tracks, textHeight, trackLabels) {
-    const textOffset = labelOffset(trackLabels, textHeight);
-    return sum(tracks.map(t => trackBoxHeight(t, textOffset)));
+export function totalHeight(tracks, trackLabels, textHeight) {
+    return sum(tracks.map(t => trackBoxHeight(t, trackLabels, textHeight)));
 }

package/esm/LinearGenomeView/types.d.ts

@@ -1,20 +1,16 @@
 import type { LinearGenomeViewStateModel } from './model.ts';
-import type { HighlightType } from '@jbrowse/core/util/highlights';
+import type { BpOffset as CoreBpOffset } from '@jbrowse/core/util/Base1DUtils';
+import type { HighlightInput, HighlightType } from '@jbrowse/core/util/highlights';
 import type { TrackInit } from '@jbrowse/core/util/tracks';
 import type { SnapshotIn } from '@jbrowse/mobx-state-tree';
-export interface BpOffset {
-    refName?: string;
-    index: number;
-    offset: number;
-    start?: number;
-    end?: number;
+export interface BpOffset extends CoreBpOffset {
     coord?: number;
     reversed?: boolean;
     assemblyName?: string;
     oob?: boolean;
 }
-export type { ExportSvgOptions, TrackLabelMode, } from '@jbrowse/display-kit/types';
-export type { HighlightType };
+export type { ExportSvgOptions, TrackLabelMode, ViewTrackLabelMode, } from '@jbrowse/display-kit/types';
+export type { HighlightInput, HighlightType };
 export interface NavLocation {
     refName: string;
     start?: number;
@@ -34,11 +30,12 @@ export interface InitState {
      */
     loc?: string;
     grow?: number;
+    showHitTrack?: boolean;
     assembly: string;
     displayedRegionNames?: string[];
     tracks?: TrackInit[];
     tracklist?: boolean;
     nav?: boolean;
-    highlight?: (string | HighlightType)[];
+    highlight?: (string | HighlightInput)[];
 }
-export type LinearGenomeViewLaunchProps = Partial<Omit<SnapshotIn<LinearGenomeViewStateModel>, keyof InitState | 'id' | 'type' | 'init'>>;
+export type LinearGenomeViewLaunchProps = Partial<Omit<SnapshotIn<LinearGenomeViewStateModel>, keyof InitState | 'id' | 'type' | 'launch'>>;

package/esm/LinearGenomeView/util.d.ts

@@ -1,6 +1,14 @@
 import type { AssemblyManager, ParsedLocString } from '@jbrowse/core/util';
+import type { PxToBpResult } from '@jbrowse/core/util/Base1DUtils';
 import type { BaseBlock, ContentBlock } from '@jbrowse/core/util/blockTypes';
 import type { Region } from '@jbrowse/core/util/types';
+interface CenterKeepingView {
+    width: number;
+    displayedRegions: Region[];
+    pxToBp: (px: number) => PxToBpResult;
+    setDisplayedRegions: (regions: Region[]) => void;
+    centerAt: (coord: number, refName: string, index?: number) => void;
+}
 /**
  * The stored viewport of a view showing `totalBp` of displayed regions fitted to
  * `width` — the regions filling it edge to edge, and centered in it only where
@@ -64,7 +72,7 @@ export interface Tick {
  * `makeBlockTicks`. What the two do share is already shared: `chooseGridPitch`,
  * and `base` as the 0-based coordinate that `getTickDisplayStr` labels `base+1`.
  */
-export declare function makeTicks(start: number, end: number, bpPerPx: number, emitMajor?: boolean, emitMinor?: boolean): Tick[];
+export declare function makeTicks(start: number, end: number, bpPerPx: number, includeMinor?: boolean): Tick[];
 /** A block's refName, or undefined for non-content (elided/padding) blocks. */
 export declare function getBlockRefName(block: BaseBlock): string | undefined;
 /**
@@ -104,48 +112,31 @@ export interface ScalebarRefNameLabel {
 }
 /**
  * Builds the refName labels drawn along the scalebar as plain data (no JSX): one
- * label per run of same-refName regions (deduped so collapsed introns don't
- * repeat the name) plus a "sticky" label pinned to the left edge naming the
- * refName under the viewport's left border.
- *
- * `caption` is the row-level chip at the viewport's left edge, and it says two
- * things: which assembly this row is (`prefix`, an assembly name, synteny only)
- * and whether the row is flipped. Without it a row of stacked genomes would
- * label some rows with the assembly name and some without, depending only on
- * how wide their leftmost chromosome happens to be.
+ * label per run of same-refName regions, the leftmost of them "sticky" — pinned
+ * so the run under the left edge stays named once its own left edge scrolls off.
  *
- * The assembly name alone folds into the sticky label instead — "prefix:refName"
- * — whenever the two would collide at the left edge, and stands alone when the
- * sticky label sits far enough right not to (a view scrolled left of its first
- * region, so the row's data starts mid-viewport) or when there is no sticky
- * label at all.
+ * `caption` is the row-level chip at the viewport's left edge: which assembly
+ * the row is (`prefix`, synteny only) and whether the whole row is flipped. The
+ * chip takes `captionSpanPx` of the strip and the labels get the rest, so the
+ * sticky label pins to the chip's right edge ("hg38" then "chr1") and rides the
+ * run under THAT edge. A run the chip covers entirely goes unnamed, and the
+ * chip is not shortened to uncover it: a width fitted to the run under it
+ * changes with every run that pans past, and a fixed cap short enough to
+ * uncover a 55px chromosome cuts ordinary names. The assembly's `displayName`
+ * is where a long name gets shortened.
  *
- * `orientation` decides the ` [rev]` marker, and it is the row's
- * (`displayedRegionsOrientation`) rather than anything read off the blocks —
- * blocks cover the window, and a row is flipped or not whatever part of it you
- * are looking at. The rule is `assembleLocStrings`': say it where it
- * distinguishes, once where it does not.
+ * `orientation` decides the ` [rev]` marker, following `assembleLocStrings`: say
+ * it where it distinguishes, once where it does not.
  *
- * - `reversed`: the whole row is flipped, which is a fact about the row, so the
- *   caption carries it and NO name does. The caption cannot fold in this state
- *   — the sticky label is pushed clear of it instead — because a marker sitting
- *   on a chromosome name is how the mixed case spells a fact about that one
- *   region. `chr1 [rev] | chr2` would otherwise mean both "the row is flipped,
- *   said once" and "chr1 is flipped and chr2 is not", in identical pixels.
- * - `mixed`: only some regions are flipped — reachable through the label menu's
- *   per-region "Reverse region" — so every reversed run is marked and the
- *   forward ones are left alone. Here the marker on a name is the only thing
- *   telling two labels apart.
+ * - `reversed`: the caption carries the marker and no name does. A marker on a
+ *   chromosome name is how the mixed case flags that one region.
+ * - `mixed`: every reversed run is marked. A marked label that fails the fit
+ *   test falls back to the bare name rather than dropping.
  * - `forward`: no marker.
  *
- * Saying it once is the point: a flipped whole-genome row would otherwise
- * repeat `[rev]` after all 24 chromosomes to say a single thing about the row.
- *
- * Under `mixed` the marker never costs a name: a suffixed label that fails the
- * fit test falls back to the bare name rather than being dropped. Widening the
- * text moves the region width a name needs from ~30px to ~56px at 11px bold,
- * and a feature meant to surface information should not be deleting chromosome
- * names in the narrow half of that gap.
+ * `maxWidth` is the whole label box, `paddingLeft` included — both consumers
+ * clip from the box's left edge. A name is drawn whole or not at all: clipped
+ * mid-glyph, "chr16" reads as "chr1".
  */
 export declare function getScalebarRefNameLabels({ blocks, offsetPx, prefix, orientation, }: {
     blocks: BaseBlock[];
@@ -192,13 +183,35 @@ export declare function regionMoveActions(idx: number, numRegions: number): {
     to: number;
 }[];
 /**
- * The region reorderings offered by the refName-label menu, as pure list
- * transforms feeding setDisplayedRegions (which re-clamps bpPerPx/offsetPx for
- * the new region set).
+ * A new region list, and where each old index went in it (-1 for a region it
+ * dropped). The index map is what lets a region displayed twice be followed.
  */
-export declare function withRegionMoved(regions: Region[], from: number, to: number): Region[];
-export declare function withRegionRemoved(regions: Region[], index: number): Region[];
-export declare function withRegionReversed(regions: Region[], index: number): Region[];
+export interface RegionEdit {
+    regions: Region[];
+    newIndexOf: (oldIndex: number) => number;
+}
+export declare function withRegionMoved(regions: Region[], from: number, to: number): RegionEdit;
+export declare function withRegionRemoved(regions: Region[], index: number): RegionEdit;
+export declare function withRegionsKept(regions: Region[], first: number, last: number): RegionEdit;
+export declare function withRegionReversed(regions: Region[], index: number): RegionEdit;
+/**
+ * Apply a region edit and keep the base under the middle of the viewport
+ * there, where the edit kept its region. `setDisplayedRegions` alone carries
+ * `offsetPx` into a coordinate space the edit redefined, which lands on
+ * whatever region now sits at that offset.
+ */
+export declare function setDisplayedRegionsKeepingCenter(model: CenterKeepingView, { regions, newIndexOf }: RegionEdit): void;
+/**
+ * The full run of same-orientation regions on one refName that a scalebar
+ * label's `firstRegionIndex`..`lastRegionIndex` sits inside. Those come off the
+ * static blocks, which are clipped to the viewport and broken by an elided
+ * block, so a zoomed-in collapsed-introns view brackets only the exons on
+ * screen — which is the wrong answer for anything acting on the whole run.
+ */
+export declare function regionRunBounds(regions: Region[], firstIndex: number, lastIndex: number): {
+    first: number;
+    last: number;
+};
 /**
  * Whether a label occupying [leftPx, leftPx + labelWidth] fits within a block
  * of the given pixel width, used to skip tick labels that would be clipped at a
@@ -264,6 +277,7 @@ export interface BlockRun {
     reversed: boolean;
     refName: string;
     isLeftEndOfDisplayedRegion: boolean;
+    labeled: boolean;
 }
 export declare function groupContiguousBlocks(blocks: BaseBlock[]): BlockRun[];
 /**
@@ -300,7 +314,7 @@ export declare function makeBlockTicks({ start, end, reversed, }: {
     start: number;
     end: number;
     reversed?: boolean;
-}, bpPerPx: number, emitMajor?: boolean, emitMinor?: boolean): {
+}, bpPerPx: number, includeMinor?: boolean): {
     type: 'major' | 'minor';
     base: number;
     x: number;
@@ -348,3 +362,4 @@ export declare function generateLocations({ regions, assemblyManager, assemblyNa
  */
 export declare function parseLocStrings(input: string, assemblyName: string, isValidRefName: (str: string, assemblyName: string) => boolean): ParsedLocString[];
 export declare function calculateVisibleLocStrings(contentBlocks: ContentBlock[]): string;
+export {};