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

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 {};

package/esm/LinearGenomeView/util.js

@@ -89,7 +89,7 @@ export function makeOverviewTicks(start, end, bpPerPx, reversed = false) {
  * `makeBlockTicks`. What the two do share is already shared: `chooseGridPitch`,
  * and `base` as the 0-based coordinate that `getTickDisplayStr` labels `base+1`.
  */
-export function makeTicks(start, end, bpPerPx, emitMajor = true, emitMinor = true) {
+export function makeTicks(start, end, bpPerPx, includeMinor = true) {
     // Ask for the ~200px spacing this ruler actually wants, and mark majors at
     // that pitch. This used to ask for 60px and then mark majors every *two*
     // pitches, which spaced them the same but off chooseGridPitch's 1/2/5 ladder:
@@ -106,12 +106,12 @@ export function makeTicks(start, end, bpPerPx, emitMajor = true, emitMinor = tru
     const iterPitch = minorPitch || majorPitch;
     const ticks = [];
     for (let base = Math.floor(minBase / iterPitch) * iterPitch; base < Math.ceil(maxBase / iterPitch) * iterPitch + 1; base += iterPitch) {
-        if (emitMinor && base % majorPitch) {
-            ticks.push({ type: 'minor', base: base - 1 });
-        }
-        else if (emitMajor && !(base % majorPitch)) {
+        if (!(base % majorPitch)) {
             ticks.push({ type: 'major', base: base - 1 });
         }
+        else if (includeMinor) {
+            ticks.push({ type: 'minor', base: base - 1 });
+        }
     }
     return ticks;
 }
@@ -177,13 +177,12 @@ function refNameRuns(blocks) {
     return runs;
 }
 /**
- * Index of the run carrying the "sticky" refName label pinned to the left edge:
- * the rightmost run whose left edge has scrolled off the left of the viewport,
- * or the first run when none have.
+ * Index of the run carrying the "sticky" refName label pinned to the strip's
+ * left edge: the rightmost run starting left of `leftEdgePx` (block frame), or
+ * the first run when none does.
  */
-function stickyRunIndex(runs, offsetPx) {
-    const scrolledOff = runs.findLastIndex(run => run.offsetPx < offsetPx);
-    return scrolledOff === -1 ? 0 : scrolledOff;
+function stickyRunIndex(runs, leftEdgePx) {
+    return Math.max(0, runs.findLastIndex(run => run.offsetPx < leftEdgePx));
 }
 export function regionsOrientation(regions) {
     const first = !!regions[0]?.reversed;
@@ -202,161 +201,79 @@ export function regionsOrientation(regions) {
  * upstream is whole-or-nothing, and it would go on believing a glyph fits.
  */
 const REV_MARKER = ' [rev]';
-/** Clearance between the standalone assembly-name chip and a sticky label. */
-const PREFIX_GAP = 4;
-/** Left inset of a non-sticky refName label from its region's left edge. */
-const REF_NAME_LABEL_PADDING_PX = 7;
+/** Clearance between the caption chip and the sticky label after it. */
+const CAPTION_GAP = 4;
 /**
- * translateX, maxWidth and paddingLeft for one refName label. Sticky labels
- * start at the viewport's left edge; others start at their run's left edge.
- *
- * maxWidth is the width of the whole label box, paddingLeft included, so the
- * text has `maxWidth - paddingLeft` to draw in — that is what both consumers
- * clip to (a border-box max-width on the span, an SVG clip rect from the box's
- * own left edge). The caller decides whether the name it wants to draw fits in
- * that (see refNameLabelWidth); a name is drawn whole or not at all.
+ * Left inset of a non-sticky refName label from its region's left edge, clear
+ * of the 3px region divider drawn there.
  */
-function refLabelLayout({ run, offsetPx, sticky, 
-// left-edge x a sticky label may not start before, so a caption chip drawn
-// there keeps the strip to itself. Zero wherever the caption folds into the
-// label instead (the assembly prefix does)
-minTransform = 0, }) {
-    const transform = sticky
-        ? Math.max(minTransform, -offsetPx)
-        : run.offsetPx - offsetPx - 1;
-    // block-frame x where the label actually starts. Derived from `transform` (=
-    // transform + offsetPx) so the width-to-run-end clip stays in lockstep with
-    // where the label is drawn: a sticky label pins to the run's left edge, not
-    // the viewport's, whenever the view is left-overscrolled (offsetPx < 0) —
-    // reading offsetPx directly there over-counted the available width by
-    // |offsetPx|, letting the name bleed past its run's right edge.
-    const labelStartPx = transform + offsetPx;
-    // A non-sticky label's transform anchors at the same x as the region
-    // divider drawn just to its left (SVGRegionSeparators, a 3px bar spanning
-    // local [0,3] from this same run.offsetPx edge), so paddingLeft must clear
-    // that bar plus a few px of breathing room, else the text visually touches
-    // the divider. Sticky labels sit at the viewport's own left edge, no divider.
-    const paddingLeft = sticky ? 0 : REF_NAME_LABEL_PADDING_PX;
-    return { transform, maxWidth: run.endPx - labelStartPx - 1, paddingLeft };
-}
+const REF_NAME_LABEL_PADDING_PX = 7;
 /**
  * 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 function getScalebarRefNameLabels({ blocks, offsetPx, prefix, orientation = 'forward', }) {
-    const hasPrefix = prefix !== undefined && prefix !== '';
-    const rowIsReversed = orientation === 'reversed';
-    const captionText = rowIsReversed
-        ? `${hasPrefix ? prefix : ''}${REV_MARKER}`.trimStart()
-        : prefix;
-    // the caption chip occupies the viewport's left edge, so a sticky label
-    // starting inside that span has to yield: absorb the assembly name, or, where
-    // the caption carries the row's orientation and so cannot fold, start after
-    // it. The gap is part of the span: a sticky label carries no padding of its
-    // own, so one starting at exactly the chip's right edge abuts it and the two
-    // read as a single word ("volvoxctgA") for the few px of scroll around the
-    // threshold
-    const captionSpanPx = captionText
-        ? refNameLabelWidth(captionText) + PREFIX_GAP
-        : 0;
+    const caption = [prefix, orientation === 'reversed' ? REV_MARKER.trim() : undefined]
+        .filter(Boolean)
+        .join(' ') || undefined;
+    const captionSpanPx = caption ? refNameLabelWidth(caption) + CAPTION_GAP : 0;
     const runs = refNameRuns(blocks);
-    const stickyIdx = stickyRunIndex(runs, offsetPx);
+    const stickyIdx = stickyRunIndex(runs, offsetPx + captionSpanPx);
     const labels = [];
-    let stickyHasPrefix = false;
     for (const [i, run] of runs.entries()) {
         const sticky = i === stickyIdx;
-        // A non-sticky run starting left of the viewport is entirely off-screen:
-        // the sticky run is by definition the rightmost one starting there, so
-        // every earlier run also *ends* left of the viewport. Its label would just
-        // repeat the name the sticky label already shows, drawn off-canvas —
-        // invisible on screen (overflow:clip) but bleeding into the margin of an
-        // SVG export, which has no such clip.
-        const runStart = run.offsetPx >= offsetPx && run.isLeftEndOfDisplayedRegion;
-        if (!(sticky || runStart)) {
+        // runs left of the sticky one end under the caption or off screen
+        if (i < stickyIdx || !(sticky || run.isLeftEndOfDisplayedRegion)) {
             continue;
         }
-        const layout = refLabelLayout({
-            run,
-            offsetPx,
-            sticky,
-            minTransform: rowIsReversed ? captionSpanPx : 0,
-        });
-        const withPrefix = !rowIsReversed && sticky && hasPrefix && layout.transform < captionSpanPx;
-        const name = withPrefix ? `${prefix}:${run.refName}` : run.refName;
-        // draw the name whole or not at all: a name clipped mid-glyph reads as a
-        // different chromosome ("LG2" cut to "LG"), and measuring it means a short
-        // name gets its label in a region a fixed minimum width would have skipped.
-        // The marker is the one part that degrades instead of dropping the label
+        const runStartPx = run.offsetPx - offsetPx;
+        const transform = sticky
+            ? Math.max(captionSpanPx, runStartPx)
+            : runStartPx - 1;
+        const paddingLeft = sticky ? 0 : REF_NAME_LABEL_PADDING_PX;
+        const maxWidth = run.endPx - offsetPx - transform - 1;
         const text = (orientation === 'mixed' && run.reversed
-            ? [`${name}${REV_MARKER}`, name]
-            : [name]).find(candidate => layout.maxWidth >= layout.paddingLeft + refNameLabelWidth(candidate));
-        if (text === undefined) {
-            continue;
+            ? [`${run.refName}${REV_MARKER}`, run.refName]
+            : [run.refName]).find(candidate => maxWidth >= paddingLeft + refNameLabelWidth(candidate));
+        if (text !== undefined) {
+            labels.push({
+                key: run.key,
+                refName: run.refName,
+                displayedRegionIndex: run.firstRegionIndex,
+                lastDisplayedRegionIndex: run.lastRegionIndex,
+                sticky,
+                transform,
+                maxWidth,
+                paddingLeft,
+                text,
+            });
         }
-        stickyHasPrefix ||= withPrefix;
-        labels.push({
-            key: run.key,
-            refName: run.refName,
-            displayedRegionIndex: run.firstRegionIndex,
-            lastDisplayedRegionIndex: run.lastRegionIndex,
-            sticky,
-            transform: layout.transform,
-            maxWidth: layout.maxWidth,
-            paddingLeft: layout.paddingLeft,
-            text,
-        });
     }
-    return {
-        labels,
-        // the chip to draw at the left edge, or undefined for none. A caption
-        // carrying the orientation always draws; one carrying only the assembly
-        // name draws when no sticky label folded it in
-        caption: rowIsReversed || (hasPrefix && !stickyHasPrefix)
-            ? captionText
-            : undefined,
-        captionSpanPx,
-    };
+    return { labels, caption, captionSpanPx };
 }
 /**
  * Screen-x span a refName label paints over: its padding and its glyphs, which
@@ -404,22 +321,74 @@ export function regionMoveActions(idx, numRegions) {
         },
     ].flatMap(({ when, label, to }) => (when ? [{ label, to }] : []));
 }
-/**
- * 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).
- */
 export function withRegionMoved(regions, from, to) {
     const out = [...regions];
     const [moved] = out.splice(from, 1);
     out.splice(to, 0, moved);
-    return out;
+    return {
+        regions: out,
+        newIndexOf: i => i === from
+            ? to
+            : i - (i > from && i <= to ? 1 : 0) + (i >= to && i < from ? 1 : 0),
+    };
 }
 export function withRegionRemoved(regions, index) {
-    return regions.filter((_, i) => i !== index);
+    return {
+        regions: regions.filter((_, i) => i !== index),
+        newIndexOf: i => (i === index ? -1 : i > index ? i - 1 : i),
+    };
+}
+export function withRegionsKept(regions, first, last) {
+    return {
+        regions: regions.slice(first, last + 1),
+        newIndexOf: i => (i >= first && i <= last ? i - first : -1),
+    };
 }
 export function withRegionReversed(regions, index) {
-    return regions.map((region, i) => i === index ? { ...region, reversed: !region.reversed } : region);
+    return {
+        regions: regions.map((region, i) => i === index ? { ...region, reversed: !region.reversed } : region),
+        newIndexOf: i => i,
+    };
+}
+/**
+ * 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 function setDisplayedRegionsKeepingCenter(model, { regions, newIndexOf }) {
+    const center = model.displayedRegions.length
+        ? model.pxToBp(model.width / 2)
+        : undefined;
+    model.setDisplayedRegions(regions);
+    const index = center ? newIndexOf(center.index) : -1;
+    if (center && index !== -1) {
+        model.centerAt(center.coord0, center.refName, index);
+    }
+}
+/**
+ * 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 function regionRunBounds(regions, firstIndex, lastIndex) {
+    const anchor = regions[firstIndex];
+    const inRun = (r) => r !== undefined &&
+        anchor !== undefined &&
+        r.refName === anchor.refName &&
+        r.assemblyName === anchor.assemblyName &&
+        !!r.reversed === !!anchor.reversed;
+    let first = firstIndex;
+    let last = lastIndex;
+    while (inRun(regions[first - 1])) {
+        first--;
+    }
+    while (inRun(regions[last + 1])) {
+        last++;
+    }
+    return { first, last };
 }
 /**
  * Whether a label occupying [leftPx, leftPx + labelWidth] fits within a block
@@ -508,14 +477,16 @@ export function groupContiguousBlocks(blocks) {
                 current.end = Math.max(current.end, block.end);
             }
             else {
+                const reversed = !!block.reversed;
                 current = {
                     offsetPx: block.offsetPx,
                     widthPx: block.widthPx,
                     start: block.start,
                     end: block.end,
-                    reversed: !!block.reversed,
+                    reversed,
                     refName: block.refName,
                     isLeftEndOfDisplayedRegion: !!block.isLeftEndOfDisplayedRegion,
+                    labeled: current?.refName !== block.refName || current.reversed !== reversed,
                 };
                 currentRegionIndex = block.displayedRegionIndex;
                 runs.push(current);
@@ -553,8 +524,7 @@ export function groupContiguousBlocks(blocks) {
  * this frame.
  */
 export function runRefNameLabelPx(runs, orientation = 'forward') {
-    const isRunStart = showRefNameLabels(runs, run => run.refName);
-    return runs.map((run, i) => isRunStart[i] && run.isLeftEndOfDisplayedRegion
+    return runs.map(run => run.labeled && run.isLeftEndOfDisplayedRegion
         ? REF_NAME_LABEL_PADDING_PX +
             refNameLabelWidth(orientation === 'mixed' && run.reversed
                 ? `${run.refName}${REV_MARKER}`
@@ -566,10 +536,10 @@ export function runRefNameLabelPx(runs, orientation = 'forward') {
  * regions. Single source of the tick→px formula shared by gridlines, the
  * scalebar coordinate labels, and SVG export so their positions can't drift.
  */
-export function makeBlockTicks({ start, end, reversed = false, }, bpPerPx, emitMajor = true, emitMinor = true) {
-    return makeTicks(start, end, bpPerPx, emitMajor, emitMinor).map(tick => ({
+export function makeBlockTicks({ start, end, reversed = false, }, bpPerPx, includeMinor = true) {
+    return makeTicks(start, end, bpPerPx, includeMinor).map(tick => ({
         ...tick,
-        x: (reversed ? end - tick.base : tick.base - start) / bpPerPx,
+        x: bpOffsetInRegion({ start, end, reversed }, tick.base) / bpPerPx,
     }));
 }
 /**
@@ -656,6 +626,7 @@ export function parseLocStrings(input, assemblyName, isValidRefName) {
         // in this form as in the colon form.
         const [refName, start = '', end = ''] = inputs;
         if (e instanceof UnknownRefNameError &&
+            inputs.length === 3 &&
             parseBpString(start) !== undefined &&
             parseBpString(end) !== undefined) {
             return [

package/esm/MultiLevelRubberband/MultiLevelRubberband.js

@@ -5,7 +5,7 @@ import { getBpDisplayStr, stringify } from '@jbrowse/core/util';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
 import { observer } from 'mobx-react';
 import RubberbandSpan from '../shared/RubberbandSpan.js';
-import VerticalGuide from './VerticalGuide.js';
+import { VerticalGuideLine } from '../shared/coordLabels.js';
 import { useRangeSelect } from './useRangeSelect.js';
 const useStyles = makeStyles()({
     rubberbandControl: {
@@ -19,11 +19,14 @@ const useStyles = makeStyles()({
 const MultiLevelRubberband = observer(function MultiLevelRubberband({ model, ControlComponent = _jsx("div", {}), }) {
     const ref = useRef(null);
     const { classes } = useStyles();
-    const { guideX, rubberbandOn, leftBpOffset, rightBpOffset, numOfBpSelected, width, left, anchorPosition, open, handleMenuItemClick, handleClose, mouseMove, mouseDown, mouseOut, } = useRangeSelect(ref, model);
-    return (_jsxs(_Fragment, { children: [guideX !== undefined ? (_jsx(VerticalGuide, { model: model, coordX: guideX })) : rubberbandOn ? (_jsx(RubberbandSpan, { leftLabel: _jsx(PerLevelRows, { rows: leftBpOffset.map(l => stringify(l, true)) }), rightLabel: _jsx(PerLevelRows, { rows: rightBpOffset.map(r => stringify(r, true)) }), size: _jsx(PerLevelRows, { rows: numOfBpSelected.map(getBpDisplayStr) }), width: width, left: left, viewWidth: Math.min(...model.views.map(view => view.width)), stickyTop: undefined })) : null, anchorPosition ? (_jsx(Menu, { anchorReference: "anchorPosition", anchorPosition: {
+    const { isClick, guideX, rubberbandOn, leftBpOffset, rightBpOffset, numOfBpSelected, width, left, anchorPosition, handleMenuItemClick, handleClose, mouseMove, mouseDown, mouseOut, } = useRangeSelect(ref, model);
+    const viewWidth = Math.min(...model.views.map(view => view.width));
+    return (_jsxs(_Fragment, { children: [guideX !== undefined ? (_jsx(VerticalGuideLine, { coordX: guideX, viewWidth: viewWidth, stickyTop: undefined, children: _jsx(PerLevelRows, { rows: model.views.map(view => stringify(view.pxToBp(guideX), true)) }) })) : rubberbandOn ? (_jsx(RubberbandSpan, { leftLabel: _jsx(PerLevelRows, { rows: leftBpOffset.map(l => stringify(l, true)) }), rightLabel: _jsx(PerLevelRows, { rows: rightBpOffset.map(r => stringify(r, true)) }), size: _jsx(PerLevelRows, { rows: numOfBpSelected.map(getBpDisplayStr) }), width: width, left: left, viewWidth: viewWidth, stickyTop: undefined })) : null, anchorPosition ? (_jsx(Menu, { anchorReference: "anchorPosition", anchorPosition: {
                     left: anchorPosition.clientX,
                     top: anchorPosition.clientY,
-                }, onMenuItemClick: handleMenuItemClick, open: open, onClose: handleClose, menuItems: model.rubberBandMenuItems() })) : null, _jsx("div", { "data-testid": "rubberband_controls", className: classes.rubberbandControl, ref: ref, onMouseDown: mouseDown, onMouseMove: mouseMove, 
+                }, onMenuItemClick: handleMenuItemClick, open: true, onClose: handleClose, menuItems: isClick
+                    ? model.rubberbandClickMenuItemsAtPx(anchorPosition.offsetX)
+                    : model.rubberBandMenuItems() })) : null, _jsx("div", { "data-testid": "rubberband_controls", className: classes.rubberbandControl, ref: ref, onMouseDown: mouseDown, onMouseMove: mouseMove, 
                 // Leave, not out: mouseout bubbles up from every child, so moving across
                 // the ControlComponent's own children fired it and flickered the guide.
                 // Matches Rubberband/OverviewRubberband.

package/esm/MultiLevelRubberband/index.d.ts

@@ -1,2 +1,4 @@
 export { default as MultiLevelRubberband } from './MultiLevelRubberband.tsx';
+export { multiLevelRowClickMenuItems, multiLevelRowMenuItems, } from './menuItems.ts';
+export { rowLabels } from './rowLabel.ts';
 export type { MultiLevelRubberbandModel } from './types.ts';

package/esm/MultiLevelRubberband/index.js

@@ -1 +1,3 @@
 export { default as MultiLevelRubberband } from './MultiLevelRubberband.js';
+export { multiLevelRowClickMenuItems, multiLevelRowMenuItems, } from './menuItems.js';
+export { rowLabels } from './rowLabel.js';

package/esm/MultiLevelRubberband/menuItems.d.ts

@@ -0,0 +1,34 @@
+import type { LinearGenomeViewModel } from '../LinearGenomeView/model.ts';
+import type { MenuItem } from '@jbrowse/core/ui';
+/**
+ * One row per genome row, each holding that row's own rubberband menu — Get
+ * sequence, Copy range, Highlight region, and whatever a plugin contributes
+ * under Launch.
+ *
+ * A drag on the multi-level strip commits offsets on EVERY row (see
+ * `useRangeSelect`), so each row's `rubberBandMenuItems()` already describes a
+ * real selection and was simply never offered: the stacked views' menu held
+ * "Zoom to region(s)" and nothing else, while the same drag in a plain linear
+ * genome view offered five actions. Per row rather than applied across rows
+ * because each row is its own assembly — one sequence to fetch, one range to
+ * copy, one highlight to place — so there is no "all rows" answer to give.
+ *
+ * Zoom is the exception and stays where each view already has it: zooming every
+ * row at once is what the gesture means, and the synteny view holds its follow
+ * anchor across the loop.
+ */
+export declare function multiLevelRowMenuItems(views: LinearGenomeViewModel[]): MenuItem[];
+/**
+ * The same per-row rows for a bare CLICK on the strip rather than a drag — each
+ * row's Center view here, Zoom to base level and Copy coordinate, at the base
+ * that row paints under `px`.
+ *
+ * No all-rows row above them, unlike the drag's "Zoom to region(s)". A drag
+ * names a span in pixels and every row can act on it; a click names a
+ * COORDINATE, and the rows are different assemblies, so which genome's base the
+ * pointer is over is the question the menu has to ask rather than answer.
+ *
+ * `px` rather than a resolved offset: each row maps the pixel through its own
+ * `pxToBp`, so there is no one offset to pass.
+ */
+export declare function multiLevelRowClickMenuItems(views: LinearGenomeViewModel[], px: number): MenuItem[];