@jbrowse/plugin-linear-genome-view 5.0.0-beta.11 → 5.0.0-beta.15

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

@@ -1,4 +1,5 @@
 import type { ExportSvgOptions, TrackLabelMode } from '../types.ts';
+import type { LgvSvgExportable } from '@jbrowse/display-kit/renderDisplaySvg';
 import type { ExportSvgDisplayOptions } from '@jbrowse/display-kit/types';
 import type { ThemeOptions } from '@mui/material';
 import type { ReactNode } from 'react';
@@ -6,8 +7,8 @@ export interface SvgExportTrack {
     minimized: boolean;
     displays: {
         height: number;
-        svgLegendWidth?: () => number;
-        svgSidebarWidth?: () => number;
+        regionTooLarge?: boolean;
+        svgSidebarWidth?: LgvSvgExportable['svgSidebarWidth'];
         /**
          * Optional, and the option is the point: SVG export is a substantial extra
          * implementation for a display type, and a third-party plugin that has not
@@ -22,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`.
@@ -41,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[];
@@ -73,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.
@@ -125,7 +120,15 @@ const FrozenSvgFigure = memo(function FrozenSvgFigure({ view, snapshot, }) {
  * question about regions and is true before a track is instantiated (the first
  * figure then draws a header over nothing, and nothing else ever changes to
  * correct it); **their heights and minimized flags**, since the geometry is
- * derived from them; **the width**, since a resize can widen the canvas without
+ * derived from them; **their configs**, since a display's settings are slots on
+ * the track config and a shown track's snapshot spells that config as its id;
+ * **the legend sections a reader dismissed** and **the per-group state**
+ * (hidden sections, collapses, height overrides: `groupStateKey`), which are
+ * volatile and in no snapshot; **the reload counter**, since a Retry or a Force
+ * load leaves every snapshot as it was while the figure has an error or a
+ * too-large note to replace; **the view's coloring toggles** (`colorByCDS`,
+ * `showAminoAcids`), named one by one because the view's own snapshot moves
+ * every pan frame; **the width**, since a resize can widen the canvas without
  * moving the locus; **the theme**, since each display bakes colors into its own
  * bodies, so a figure from the other mode is not stale but unreadable; and **the
  * highlight bands**, which are drawn in the figure and are the one thing in it a
@@ -133,8 +136,10 @@ const FrozenSvgFigure = memo(function FrozenSvgFigure({ view, snapshot, }) {
  *
  * 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.
+ * redraw rather than at once. So does a track's vertical scroll, which moves
+ * every wheel frame and has no settled copy to key on. 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,9 +161,19 @@ function figureKey(view, themeName) {
         view.coarseVisibleLocStrings,
         view.coarseBpPerPx,
         view.width,
-        // 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]),
+        view.tracks.map(track => {
+            const display = track.displays[0];
+            return [
+                getSnapshot(track),
+                getSnapshot(track.configuration),
+                display?.height,
+                display?.dismissedLegendSections,
+                display?.groupStateKey,
+                display?.reloadCounter,
+            ];
+        }),
+        view.colorByCDS,
+        view.showAminoAcids,
         session.getActiveThemeOptions?.(themeName),
         session.highlightsVisible ? view.highlights : false,
         session.highlightLabelsVisible,

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

@@ -1,25 +1,27 @@
 import type { TrackLabelMode } from '../types.ts';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import type { TrackCatalog } from '@jbrowse/core/util';
+import type { LgvSvgExportable } from '@jbrowse/display-kit/renderDisplaySvg';
+import type { ExportTextStyle } from '@jbrowse/display-kit/types';
 import type { ReactNode } from 'react';
+type SidebarDisplay = Pick<LgvSvgExportable, 'svgSidebarWidth'>;
 interface TrackHeights {
-    displays: {
+    displays: ({
         height: number;
         prefersOffset?: boolean;
-        svgSidebarWidth?: () => number;
-    }[];
+    } & SidebarDisplay)[];
 }
 export interface SvgDisplayResult {
     track: {
         configuration: AnyConfigurationModel;
-        displays: {
+        displays: ({
             height: number;
             regionTooLarge?: boolean;
-            drawsWhenTooLarge?: boolean;
-            svgSidebarWidth?: () => number;
-        }[];
+        } & 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: {
@@ -83,14 +85,15 @@ export declare function getRulerLayout(rulerHeight: number): {
 };
 export declare const refNameLabelBoxHeight: number;
 export declare const refNameLabelBaselineY: number;
-export declare function trackLabelMode(track: TrackHeights, trackLabels: TrackLabelMode): TrackLabelMode;
-export declare function leftLabelRaised(track: Pick<TrackHeights, 'displays'>, trackLabels: TrackLabelMode): boolean;
+export declare function trackLabelMode(track: {
+    displays: ({
+        prefersOffset?: boolean;
+    } & SidebarDisplay)[];
+}, trackLabels: TrackLabelMode): TrackLabelMode;
 export declare function labelOffset(track: TrackHeights, trackLabels: TrackLabelMode, textHeight: number): number;
 interface SidebarTrack {
     configuration: AnyConfigurationModel;
-    displays: {
-        svgSidebarWidth?: () => number;
-    }[];
+    displays: SidebarDisplay[];
 }
 export declare const TRACK_LABEL_GAP = 40;
 export declare function trackLabelLeftOffset({ tracks, trackLabels, fontSize, fontFamily, session, }: {
@@ -100,7 +103,7 @@ export declare function trackLabelLeftOffset({ tracks, trackLabels, fontSize, fo
     fontFamily?: string;
     session: TrackCatalog;
 }): number;
-export declare function trackSidebarWidth(track: Pick<SidebarTrack, 'displays'>): number;
+export declare function trackSidebarWidth(track: Pick<SidebarTrack, 'displays'>, text?: ExportTextStyle): 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;

package/esm/LinearGenomeView/svgcomponents/util.js

@@ -179,24 +179,17 @@ export const refNameLabelBaselineY = labelBaselineFromTop(0, REF_NAME_LABEL_FONT
 // 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.
+// 'left' yields to 'offset' for a track whose sidebar holds the gutter beside
+// its rows.
 export function trackLabelMode(track, trackLabels) {
-    return trackLabels === 'overlapping' && track.displays[0]?.prefersOffset
+    return (trackLabels === 'overlapping' && track.displays[0]?.prefersOffset) ||
+        (trackLabels === 'left' && trackSidebarWidth(track) > 0)
         ? 'offset'
         : trackLabels;
 }
-// Whether a 'left' name sits in a band above its track's rows rather than
-// beside the first of them: the gutter beside the rows holds the track's own
-// sidebar, so the name heads it instead of standing off to its left.
-export function leftLabelRaised(track, trackLabels) {
-    return trackLabels === 'left' && trackSidebarWidth(track) > 0;
-}
-// space the label pushes a track's body down by: an 'offset' label, or a raised
-// 'left' one
+// space an 'offset' label pushes a track's body down by
 export function labelOffset(track, trackLabels, textHeight) {
-    return trackLabelMode(track, trackLabels) === 'offset' ||
-        leftLabelRaised(track, trackLabels)
-        ? textHeight
-        : 0;
+    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`,
@@ -204,9 +197,7 @@ export function labelOffset(track, trackLabels, textHeight) {
 // gutter it was measured for.
 export const TRACK_LABEL_GAP = 40;
 // Horizontal gutter left of the track bodies: the widest of each track's
-// sidebar and, in 'left' mode, its name plus TRACK_LABEL_GAP. A sidebar and a
-// name share the column because the name rises above the sidebar
-// (leftLabelRaised). Takes an
+// sidebar and of each name drawn 'left', plus TRACK_LABEL_GAP. Takes an
 // already-minimized-filtered track list, so the reserved width matches the
 // labels that actually get drawn.
 //
@@ -225,14 +216,14 @@ export const TRACK_LABEL_GAP = 40;
 // `getScalebarRefNameLabels`, an on-screen model getter, so making them
 // family-aware means threading an export option through screen state.
 export function trackLabelLeftOffset({ tracks, trackLabels, fontSize, fontFamily, session, }) {
-    return max(tracks.map(t => Math.max(trackSidebarWidth(t), trackLabels === 'left'
+    return max(tracks.map(t => Math.max(trackSidebarWidth(t, { fontSize, fontFamily }), trackLabelMode(t, trackLabels) === 'left'
         ? measureText(svgTrackName(t, session), fontSize, fontFamily) +
             TRACK_LABEL_GAP
         : 0)), 0);
 }
 // Px of tree and row labels a track's display draws left of its body.
-export function trackSidebarWidth(track) {
-    return track.displays[0]?.svgSidebarWidth?.() ?? 0;
+export function trackSidebarWidth(track, text) {
+    return track.displays[0]?.svgSidebarWidth?.(text) ?? 0;
 }
 // vertical box a single track occupies. Shared by totalHeight (sum) and
 // trackBoxOffsets (prefix-sum) so the two can't drift.

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;