@jbrowse/plugin-linear-genome-view 5.0.0-beta.2 → 5.0.0-beta.20

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,18 +176,30 @@ 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.
+// '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) ||
+        (trackLabels === 'left' && trackSidebarWidth(track) > 0)
+        ? 'offset'
+        : trackLabels;
+}
+// space an 'offset' label pushes a track's body down by
+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`,
 // so it and trackLabelLeftOffset must agree or the widest name overflows the
 // gutter it was measured for.
 export const TRACK_LABEL_GAP = 40;
-// Horizontal gutter reserved for 'left' track labels (0 in every other mode).
-// Takes an already-minimized-filtered track list, so the reserved width matches
-// the labels that actually get drawn.
+// Horizontal gutter left of the track bodies: the widest of each track's
+// 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.
 //
 // `fontFamily` is the export's own font option, and it has to reach the ruler
 // here: the labels are drawn in it (wrapSvgExport puts it on the root <svg>,
@@ -208,31 +216,35 @@ 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, }) {
-    // no labels means no gutter, and that includes having no tracks to label: the
-    // gap alone would push the whole figure right of a margin nothing is drawn in
-    return trackLabels === 'left' && tracks.length > 0
-        ? max(tracks.map(t => measureText(svgTrackName(t, session), fontSize, fontFamily)), 0) + TRACK_LABEL_GAP
-        : 0;
+    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, 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.
-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,18 @@ 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' | 'launch'>>;
+/**
+ * One LinearGenomeView panel inside another view (a breakpoint split view's
+ * stack, a synteny view's rows): the LGV's launch keys and props, less `nav`
+ * and `tracklist`, the header and the track selector a panel does not show.
+ */
+export type LinearGenomeViewPanelInit = Omit<InitState, 'nav' | 'tracklist'> & LinearGenomeViewLaunchProps;

package/esm/LinearGenomeView/types.js

@@ -1,2 +1 @@
 export {};
-// #endregion

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
@@ -17,7 +25,7 @@ import type { Region } from '@jbrowse/core/util/types';
  * A caller building a view SNAPSHOT does: it has no model to call
  * `fitAllRegions()` on, and naming `bpPerPx`/`offsetPx` instead is dropped
  * whenever the snapshot also carries a `windowWidthBp` — which one copied off an
- * existing view always does. plugin-canvas's collapsed-intron launch is that
+ * existing view always does. plugin-features's collapsed-intron launch is that
  * caller. A live view calls `fitAllRegions()`.
  *
  * `width` enters only through the zoom-in floor, which bites for a region set
@@ -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 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 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 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;
@@ -347,4 +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 {};