@jbrowse/wiggle-core 5.0.0-beta.8 → 5.0.0-beta.9

package/README.md

@@ -1,6 +1,7 @@
 # @jbrowse/wiggle-core
 
-Shared scale and autoscale utilities for wiggle and coverage displays
+Score-axis scale, autoscale, config mixins and plot chrome shared by wiggle,
+Manhattan, mark and coverage displays
 
 <!-- API_DOCS_START -->
 
@@ -8,6 +9,19 @@ Shared scale and autoscale utilities for wiggle and coverage displays
 
 Auto-generated from `#api` JSDoc tags in this package. Do not edit by hand.
 
+### autoscaleDomainFromSpans
+
+Already-computed stats to the displayed domain, for the `local` / `localsd` /
+`localpercentile` autoscale modes. `localpercentile` re-walks the spans to build
+its histogram; the other modes read the stats alone.
+
+```js
+// type signature
+({…}: { stats: ScoreStats; autoscaleType: string | undefined; numStdDev: number; numQuantile?: number | undefined; spans: ScoreSpan[]; }) => [number, number]
+```
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/autoscale.ts)
+
 ### computeAutoscaleDomain
 
 Computes a score domain from the visible feature arrays for the `local` /
@@ -15,7 +29,7 @@ Computes a score domain from the visible feature arrays for the `local` /
 
 ```js
 // type signature
-(autoscaleType: string, summaryScoreMode: string, numStdDev: number, visibleEntries: {…}[], numQuantile?: number) => [...] | undefined
+(autoscaleType: string | undefined, summaryScoreMode: string, numStdDev: number, visibleEntries: {…}[], numQuantile?: number) => [...] | undefined
 ```
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/autoscale.ts)
@@ -53,11 +67,12 @@ exactly what it always got.
 ### domainFromStats
 
 Converts score stats into a `[min, max]` domain, applying std-dev expansion for
-the `localsd` autoscale type.
+the `localsd` autoscale type. An `undefined` mode is a display whose scale
+declares none, and takes the plain extremes.
 
 ```js
 // type signature
-(stats: ScoreStats, autoscaleType: string, numStdDev: number) => [number, number]
+(stats: ScoreStats, autoscaleType: string | undefined, numStdDev: number) => [number, number]
 ```
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/autoscale.ts)
@@ -69,12 +84,12 @@ may be before the span between them counts as a hole rather than a segment to
 draw. Returns `Infinity` when there is nothing to decide, so a caller can always
 compare against it unguarded.
 
-The limit is a multiple of the series' own _mean_ spacing rather than an
-absolute distance, which is what makes one number work across zoom levels and
-data types: reduced BigWig bins get wider as you zoom out, so any fixed bp
-threshold would be either useless at one end or destructive at the other. It
-also lets the same rule serve a bp axis (wiggle's linecenter) and a px one — the
-caller picks the space, this only cares that the units are consistent.
+The limit is a multiple of the series' _mean_ spacing rather than an absolute
+distance, so one number works across zoom levels and data types: reduced BigWig
+bins get wider as you zoom out, so any fixed bp threshold would be either
+useless at one end or destructive at the other. It also lets the same rule serve
+a bp axis (wiggle's linecenter) and a px one — the caller picks the space, this
+only cares that the units are consistent.
 
 Mean, not median: it is O(1) from the endpoints, and it errs the safe way. A
 series' holes inflate their own mean, which raises the limit and so breaks
@@ -145,41 +160,6 @@ unless `nice: false` says it is already the one being drawn with.
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/scale.ts)
 
-### makeScoreNormalizer
-
-Returns a loop-hoistable function normalizing a score to [0,1].
-
-`symlogConstant` is only read for `SCALE_TYPE_SYMLOG`, and is expected to be
-already resolved by resolveSymlogConstant — the shader gets the same resolved
-number as a uniform, so the "auto" rule lives on this side only and the two
-backends compare like for like.
-
-A range that is zero **or negative** normalizes everything to 0, which is the
-rule `scoreScale.slang` spells as `range <= 0.0`. Testing `range === 0` here
-instead let a descending domain through to a negative `1 / range`, so every
-score saturated to 1 on this side while the shader flattened them all to 0 — one
-view, opposite plots. `normalizeScoreParity.test.ts` sweeps the two.
-
-```js
-// type signature
-(min: number, max: number, scaleType: WiggleScaleType, symlogConstant?: number) => (score: number) => number
-```
-
-[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/normalize.ts)
-
-### parseScoreRules
-
-Normalizes whatever a `scoreRules` config slot holds into `ScoreRule`s, dropping
-entries that are not usable. Config is user-authored JSON, so a bare number, a
-missing value or a non-numeric one all have to survive being read.
-
-```js
-// type signature
-(value: unknown) => ScoreRule[]
-```
-
-[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/scoreRuleMarks.ts)
-
 ### resolveSymlogConstant
 
 The symlog constant actually used for a domain. `0` (the config default) means
@@ -200,30 +180,6 @@ rather than hard-coded.
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/normalize.ts)
 
-### scaleTypeFromString
-
-Maps the `'log'`/`'symlog'`/`'linear'` string to the numeric `WiggleScaleType`.
-
-```js
-// type signature
-(scaleType: string) => WiggleScaleType
-```
-
-[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/normalize.ts)
-
-### ScoreRule
-
-One horizontal rule across a score plot, at a score the user chose.
-
-`label` is free text and carries no meaning this package assigns. That is
-deliberate: the obvious use is reading a coverage or CNV track against copy
-number, and there is no ploidy JBrowse could assume on the user's behalf. A
-whole-genome triplication is not diploid, plenty of genomes are not diploid to
-begin with, and a cancer sample can be neither — so "2 copies" is a claim only
-the person looking at the track can make.
-
-[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/scoreRuleMarks.ts)
-
 ### scoreRuleMarks
 
 Screen y for each rule that falls inside the plotted domain, dropping the rest.
@@ -240,17 +196,28 @@ because the axis need not be linear: on a log or symlog track, placing a rule at
 read against is not.
 
 `box` is likewise the caller's own — hand it the same `{yTop, yBottom}` the
-display's ticks were built with (a `YScaleTicks` satisfies it). Recomputing a
-box here would silently disagree with any band that lays its axis out
+display's ticks were built with (a `YScaleTicks` satisfies it). A box recomputed
+here would place rules off the ticks of any band that lays its axis out
 differently, and the alignments coverage band does.
 
 ```js
 // type signature
-({…}: { rules: readonly ScoreRule[]; domain: [number, number] | undefined; box: { yTop: number; yBottom: number; }; normalize: (score: number) => number; }) => ScoreRuleMark[]
+({…}: { rules: readonly ValueScaleRule[]; domain: [number, number] | undefined; box: { yTop: number; yBottom: number; }; normalize: (score: number) => number; }) => ScoreRuleMark[]
 ```
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/scoreRuleMarks.ts)
 
+### ScoreSpan
+
+One block's worth of values to fold into a domain, whatever packed them: a
+wiggle source's interleaved `featurePositions` and its three summary arrays, or
+a mark layer's separate `x`/`x2` and its one `y` lane. `starts[i * stride]` and
+`ends[i * stride + endOffset]` give instance `i`'s span; `low`, `high` and `avg`
+give the two ends of its value and the one the mean is taken over, which are the
+same array wherever the packer ships a single scalar.
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/autoscale.ts)
+
 ### visibleStatsDomain
 
 The visible score domain four displays derive identically: walk the settled
@@ -270,17 +237,16 @@ initialized — which every caller distinguishes from a domain.
 
 Widens an autoscaled range so every configured rule stays on the axis.
 
-Without this a rule silently disappears in exactly the window that makes it
-worth having. Autoscale follows the visible data, so over a homozygous deletion
-a coverage domain collapses to about `[0, 1]` and a rule at the diploid depth
-falls outside it — and "2 copies would be up there" is the most informative
-thing that view can say. The reader has no menu to check either: `scoreRules` is
-set by whoever wrote the config, so a rule that vanishes leaves nothing behind
-to notice.
-
-Applied to the raw range, before `getNiceDomain` takes the `minScore` /
-`maxScore` bounds. Those still win: a rule outside an explicitly bounded axis is
-one the config asked not to be shown, and it drops as before.
+Without this a rule is dropped from the plot in the views where it is most
+useful. Autoscale follows the visible data, so over a homozygous deletion a
+coverage domain collapses to about `[0, 1]` and a rule at the diploid depth
+falls outside it, though the rule's position above the data is the most
+informative mark in that view, and a rule that vanishes leaves nothing behind to
+notice.
+
+Applied to the raw range, before `getNiceDomain` takes the `scales.y` domain
+bounds. Those still win: a rule outside an explicitly bounded axis is one the
+config asked not to be shown, and it drops as before.
 
 ```js
 // type signature

package/esm/ScoreAxisMixin.d.ts

@@ -0,0 +1,99 @@
+import type { ValueScale, YAxis } from '@jbrowse/display-ui';
+/**
+ * #stateModel ScoreAxisMixin
+ * #category display
+ * Not a cross-cutting mixin any more: {@link ScoreScaleMixin} is its one
+ * composer, and a display takes the axis by taking that. The two stay apart
+ * because the halves answer different questions — this one derives, the other
+ * says where the answer is written.
+ *
+ * The axis contract apart from where it is written down. `scaleType`,
+ * `manualMinScore` and `manualMaxScore` are declared here with neutral answers
+ * and a composing display overrides them, so the bounds, the "is anything
+ * pinned" question, the ticks and the cross-hatches derive the same way
+ * wherever the declaration lives. {@link ScoreScaleMixin} is the one composer
+ * in the tree, backing them with the `scales.y` object every quantitative
+ * display declares; the split stays because the derived half is what a display
+ * writing its scale down somewhere else would answer.
+ *
+ * The setters are not here. A display cannot set what it has not said where to
+ * put, so `setScaleType`/`setMinScore`/`setMaxScore` belong to whichever
+ * composer owns the declaration — one owner, whichever it is.
+ */
+export declare function ScoreAxisMixin(): import("@jbrowse/mobx-state-tree").IModelType<{}, {
+    /**
+     * #getter
+     * Overridable: where this display's scale type is written down.
+     */
+    readonly scaleType: string;
+    /**
+     * #getter
+     * Overridable: the lower bound the config really pins, `undefined`
+     * where nothing does.
+     */
+    readonly manualMinScore: number | undefined;
+    /**
+     * #getter
+     * Overridable: the upper bound the config really pins.
+     */
+    readonly manualMaxScore: number | undefined;
+    /**
+     * #getter
+     * Overridable hook: what each end of the domain falls back to where the
+     * config leaves its bound unset. `[undefined, undefined]` — the default —
+     * means autoscale both ends, which is right for a track whose scores have
+     * no absolute meaning (a bigwig's units are its own).
+     *
+     * A display whose scores are bounded *by construction* overrides it, so
+     * the axis stops being a function of what happens to be on screen: GC
+     * content is a fraction, so 0 and 1 are its real limits and mean the same
+     * thing at every locus. Autoscaled, the same GC value drew at different
+     * heights depending on where the user had panned, and the track could not
+     * be read across loci.
+     *
+     * A hook rather than a config default because the answer can depend on
+     * display state — GC's does, on `gcMode` — and rather than each display
+     * re-resolving the sentinels, which is the one thing that must not be
+     * duplicated: config bounds still win, precisely because they are checked
+     * before this is consulted.
+     */
+    readonly defaultScoreDomain: [number | undefined, number | undefined];
+    /**
+     * #getter
+     * Overridable hook (default none): the scales this display draws its y
+     * through. A display that answers it gets an axis per band of each,
+     * with its cross-hatches, placed by `DisplayChrome` and
+     * `renderDisplaySvg`, and the ticks derived below.
+     */
+    readonly valueScales: ValueScale[];
+} & {
+    /**
+     * #getter
+     * Resolved lower bound; `undefined` means autoscale this end.
+     */
+    readonly minScoreBound: number | undefined;
+    /**
+     * #getter
+     * Resolved upper bound; `undefined` means autoscale this end.
+     */
+    readonly maxScoreBound: number | undefined;
+    /**
+     * #getter
+     * Whether the user has pinned either end, which is a different question
+     * from whether either end resolved to a number: `defaultScoreDomain` fills
+     * the unset ends in, so a GC content track answers yes to the second with
+     * nothing configured. The score menu asks this one — it gates the "Clear
+     * manual min/max" row, and a Clear that writes the nothing already there
+     * is a row that does nothing and never goes away.
+     */
+    readonly hasManualScoreBounds: boolean;
+    /**
+     * #getter
+     * The axes, one per declared scale whose domain resolved: where each
+     * tick lands in the band's own pixel space, through `computeYTicks`
+     * unless the scale brought its own ladder, and where each of the
+     * scale's `rules` inside the domain lands in that same box, through the
+     * scale type the renderer places its values by.
+     */
+    readonly axes: YAxis[];
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/ScoreAxisMixin.js

@@ -0,0 +1,150 @@
+import { types } from '@jbrowse/mobx-state-tree';
+import { scaleTypeCode } from '@jbrowse/render-core/scoreScale';
+import { computeYTicks } from './computeYTicks.js';
+import { makeScoreNormalizer, resolveSymlogConstant } from './normalize.js';
+import { scoreRuleMarks } from './scoreRuleMarks.js';
+/**
+ * #stateModel ScoreAxisMixin
+ * #category display
+ * Not a cross-cutting mixin any more: {@link ScoreScaleMixin} is its one
+ * composer, and a display takes the axis by taking that. The two stay apart
+ * because the halves answer different questions — this one derives, the other
+ * says where the answer is written.
+ *
+ * The axis contract apart from where it is written down. `scaleType`,
+ * `manualMinScore` and `manualMaxScore` are declared here with neutral answers
+ * and a composing display overrides them, so the bounds, the "is anything
+ * pinned" question, the ticks and the cross-hatches derive the same way
+ * wherever the declaration lives. {@link ScoreScaleMixin} is the one composer
+ * in the tree, backing them with the `scales.y` object every quantitative
+ * display declares; the split stays because the derived half is what a display
+ * writing its scale down somewhere else would answer.
+ *
+ * The setters are not here. A display cannot set what it has not said where to
+ * put, so `setScaleType`/`setMinScore`/`setMaxScore` belong to whichever
+ * composer owns the declaration — one owner, whichever it is.
+ */
+export function ScoreAxisMixin() {
+    return types
+        .model('ScoreAxisMixin', {})
+        .views(() => ({
+        /**
+         * #getter
+         * Overridable: where this display's scale type is written down.
+         */
+        get scaleType() {
+            return 'linear';
+        },
+        /**
+         * #getter
+         * Overridable: the lower bound the config really pins, `undefined`
+         * where nothing does.
+         */
+        get manualMinScore() {
+            return undefined;
+        },
+        /**
+         * #getter
+         * Overridable: the upper bound the config really pins.
+         */
+        get manualMaxScore() {
+            return undefined;
+        },
+        /**
+         * #getter
+         * Overridable hook: what each end of the domain falls back to where the
+         * config leaves its bound unset. `[undefined, undefined]` — the default —
+         * means autoscale both ends, which is right for a track whose scores have
+         * no absolute meaning (a bigwig's units are its own).
+         *
+         * A display whose scores are bounded *by construction* overrides it, so
+         * the axis stops being a function of what happens to be on screen: GC
+         * content is a fraction, so 0 and 1 are its real limits and mean the same
+         * thing at every locus. Autoscaled, the same GC value drew at different
+         * heights depending on where the user had panned, and the track could not
+         * be read across loci.
+         *
+         * A hook rather than a config default because the answer can depend on
+         * display state — GC's does, on `gcMode` — and rather than each display
+         * re-resolving the sentinels, which is the one thing that must not be
+         * duplicated: config bounds still win, precisely because they are checked
+         * before this is consulted.
+         */
+        get defaultScoreDomain() {
+            return [undefined, undefined];
+        },
+        /**
+         * #getter
+         * Overridable hook (default none): the scales this display draws its y
+         * through. A display that answers it gets an axis per band of each,
+         * with its cross-hatches, placed by `DisplayChrome` and
+         * `renderDisplaySvg`, and the ticks derived below.
+         */
+        get valueScales() {
+            return [];
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * Resolved lower bound; `undefined` means autoscale this end.
+         */
+        get minScoreBound() {
+            return self.manualMinScore ?? self.defaultScoreDomain[0];
+        },
+        /**
+         * #getter
+         * Resolved upper bound; `undefined` means autoscale this end.
+         */
+        get maxScoreBound() {
+            return self.manualMaxScore ?? self.defaultScoreDomain[1];
+        },
+        /**
+         * #getter
+         * Whether the user has pinned either end, which is a different question
+         * from whether either end resolved to a number: `defaultScoreDomain` fills
+         * the unset ends in, so a GC content track answers yes to the second with
+         * nothing configured. The score menu asks this one — it gates the "Clear
+         * manual min/max" row, and a Clear that writes the nothing already there
+         * is a row that does nothing and never goes away.
+         */
+        get hasManualScoreBounds() {
+            return (self.manualMinScore !== undefined || self.manualMaxScore !== undefined);
+        },
+        /**
+         * #getter
+         * The axes, one per declared scale whose domain resolved: where each
+         * tick lands in the band's own pixel space, through `computeYTicks`
+         * unless the scale brought its own ladder, and where each of the
+         * scale's `rules` inside the domain lands in that same box, through the
+         * scale type the renderer places its values by.
+         */
+        get axes() {
+            return self.valueScales.flatMap(scale => {
+                const { domain, rules = [] } = scale;
+                const ticks = scale.ticks ??
+                    computeYTicks({
+                        height: scale.height,
+                        offset: scale.offset,
+                        domain,
+                        scaleType: scale.scaleType,
+                        minimalTicks: scale.minimalTicks ?? false,
+                        symlogConstant: scale.symlogConstant,
+                    });
+                if (!domain || !ticks) {
+                    return [];
+                }
+                const [min, max] = domain;
+                const ruleMarks = rules.length > 0
+                    ? scoreRuleMarks({
+                        rules,
+                        domain,
+                        box: ticks,
+                        normalize: makeScoreNormalizer(min, max, scaleTypeCode(scale.scaleType), resolveSymlogConstant(min, max, scale.symlogConstant ?? 0)),
+                    })
+                    : [];
+                return [{ ...scale, domain, ticks, ruleMarks }];
+            });
+        },
+    }));
+}

package/esm/ScoreFieldConfigMixin.d.ts

@@ -0,0 +1,60 @@
+import type { ScoreFieldConfigModel } from './scoreFieldConfigSchemaFields.ts';
+export interface ScoreFieldConfigHost {
+    configuration: ScoreFieldConfigModel;
+}
+/**
+ * #stateModel ScoreFieldConfigMixin
+ * #category display
+ *
+ * `WiggleScoreConfigMixin` plus `scoreField`, for a display that plots one
+ * configured feature field and so declares `scoreFieldConfigSchemaFields`:
+ * both wiggle displays and the Manhattan plot. `LinearMarkDisplay` names a
+ * field per mark and composes the base instead.
+ */
+export declare function ScoreFieldConfigMixin(): import("@jbrowse/mobx-state-tree").IModelType<Omit<{}, never>, {
+    readonly scaleType: string;
+    readonly manualMinScore: number | undefined;
+    readonly manualMaxScore: number | undefined;
+    readonly defaultScoreDomain: [number | undefined, number | undefined];
+    readonly valueScales: import("@jbrowse/display-ui").ValueScale[];
+} & {
+    readonly minScoreBound: number | undefined;
+    readonly maxScoreBound: number | undefined;
+    readonly hasManualScoreBounds: boolean;
+    readonly axes: import("@jbrowse/display-ui").YAxis[];
+} & {
+    readonly scaleType: string;
+    readonly scaleTypeChoices: string[];
+    readonly autoscaleType: string | undefined;
+    readonly numStdDev: number;
+    readonly numQuantile: number;
+    readonly symlogConstant: number;
+    readonly manualMinScore: number | undefined;
+    readonly manualMaxScore: number | undefined;
+    readonly scaleTitle: string | undefined;
+    readonly scoreRulesDrawn: boolean;
+    readonly scoreRules: import("@jbrowse/display-ui").ValueScaleRule[];
+} & {
+    setScaleType(scaleType: string): void;
+    setAutoscale(val?: string): void;
+    setMinScore(val?: number): void;
+    setMaxScore(val?: number): void;
+    setScoreRules(rules: (number | import("@jbrowse/display-ui").ValueScaleRule)[]): void;
+} & {
+    readonly scatterPointSize: number;
+    readonly displayCrossHatches: boolean;
+    readonly isDensityMode: boolean;
+} & {
+    toggleCrossHatches(): void;
+    setScatterPointSize(val?: number): void;
+} & {
+    readonly showCrossHatches: boolean;
+} & {
+    /**
+     * #getter
+     * The feature field the worker plots on the score axis, `score` by
+     * default. A fetch input: every composing display carries it in its
+     * `rpcProps()`, since the field is read where the features are.
+     */
+    readonly scoreField: string;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/ScoreFieldConfigMixin.js

@@ -0,0 +1,25 @@
+import { getConf } from '@jbrowse/core/configuration';
+import { WiggleScoreConfigMixin } from './WiggleScoreConfigMixin.js';
+const confNode = (self) => self;
+/**
+ * #stateModel ScoreFieldConfigMixin
+ * #category display
+ *
+ * `WiggleScoreConfigMixin` plus `scoreField`, for a display that plots one
+ * configured feature field and so declares `scoreFieldConfigSchemaFields`:
+ * both wiggle displays and the Manhattan plot. `LinearMarkDisplay` names a
+ * field per mark and composes the base instead.
+ */
+export function ScoreFieldConfigMixin() {
+    return WiggleScoreConfigMixin().views(self => ({
+        /**
+         * #getter
+         * The feature field the worker plots on the score axis, `score` by
+         * default. A fetch input: every composing display carries it in its
+         * `rpcProps()`, since the field is read where the features are.
+         */
+        get scoreField() {
+            return getConf(confNode(self), 'scoreField');
+        },
+    }));
+}

package/esm/ScorePlotChrome.d.ts

@@ -0,0 +1,45 @@
+import type { ContextMenuAnchor, MenuItem, MouseState } from '@jbrowse/core/ui';
+import type { ChromeModel } from '@jbrowse/display-kit/DisplayChrome';
+import type { Mark } from '@jbrowse/render-core/marks';
+import type { PerRegionRenderingBackend } from '@jbrowse/render-core/perRegionRenderingBackend';
+import type { FrameDimensions } from '@jbrowse/render-core/renderingBackendBase';
+import type { RenderLifecycleModel } from '@jbrowse/render-core/useRenderingBackend';
+import type { ReactNode } from 'react';
+interface PlotBox {
+    yTop: number;
+    plotHeight: number;
+}
+interface ContextMenuView {
+    contextMenuInfo?: ContextMenuAnchor;
+    contextMenuItems: () => MenuItem[];
+    closeContextMenu: () => void;
+}
+export interface ScorePlotContextMenuHost<Hit> extends ContextMenuView {
+    openContextMenu: (info: ContextMenuAnchor & {
+        hit: Hit;
+    }) => void;
+    clearHoveredFeature: () => void;
+}
+export type ScorePlotChromeModel<Hit, TRegion, TState extends FrameDimensions> = ChromeModel & RenderLifecycleModel<PerRegionRenderingBackend<TRegion, TState>> & {
+    canvasWidthPx: number;
+    setHoveredFeature: (hit?: Hit) => void;
+    selectFeature: (hit: Hit) => void;
+};
+/**
+ * The on-screen chrome of a display drawing a mark list on a score axis: the
+ * canvas in the axis plot box, hover and click resolved through `findHit`, the
+ * pointer-following `tooltip`, and the right-click menu where `contextMenu`
+ * names the model that owns it. `findHit` takes y from the plot's own top.
+ */
+export declare const ScorePlotChrome: <Hit, TRegion, TState extends FrameDimensions>({ model, marks, testid, plotGeometry, findHit, tooltip, overlay, indicators, contextMenu, }: {
+    model: ScorePlotChromeModel<Hit, TRegion, TState>;
+    marks: readonly Mark<TRegion, TState>[];
+    testid: string;
+    plotGeometry?: PlotBox;
+    findHit: (x: number, y: number) => Hit | undefined;
+    tooltip: (mouseState: MouseState | undefined) => ReactNode;
+    overlay?: (plotGeometry: PlotBox) => ReactNode;
+    indicators?: () => ReactNode;
+    contextMenu?: ScorePlotContextMenuHost<Hit>;
+}) => import("react").JSX.Element;
+export {};

package/esm/ScorePlotChrome.js

@@ -0,0 +1,47 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { eventPoint } from '@jbrowse/core/util/eventPoint';
+import BottomRightIndicators from '@jbrowse/display-kit/BottomRightIndicators';
+import DisplayChrome from '@jbrowse/display-kit/DisplayChrome';
+import { DisplayContextMenu, openContextMenuFromEvent, } from '@jbrowse/display-kit/DisplayContextMenu';
+import { PointerLayer, axisPlotBox } from '@jbrowse/display-ui';
+import { createMarkBackend } from '@jbrowse/render-core/marks/backend';
+import { observer } from 'mobx-react';
+/**
+ * The on-screen chrome of a display drawing a mark list on a score axis: the
+ * canvas in the axis plot box, hover and click resolved through `findHit`, the
+ * pointer-following `tooltip`, and the right-click menu where `contextMenu`
+ * names the model that owns it. `findHit` takes y from the plot's own top.
+ */
+export const ScorePlotChrome = observer(function ScorePlotChrome({ model, marks, testid, plotGeometry, findHit, tooltip, overlay, indicators, contextMenu, }) {
+    const { height, canvasWidthPx: width } = model;
+    const box = plotGeometry ?? axisPlotBox(height);
+    const factory = useMemo(() => (canvas) => createMarkBackend(canvas, marks), [marks]);
+    const hitAt = (x, y) => findHit(x, y - box.yTop);
+    return (_jsx(DisplayChrome, { model: model, factory: factory, testid: testid, style: { width, height, whiteSpace: 'nowrap', textAlign: 'left' }, onPointerPosition: state => {
+            model.setHoveredFeature(state ? hitAt(state.x, state.y) : undefined);
+        }, onClick: event => {
+            const { x, y } = eventPoint(event);
+            const hit = hitAt(x, y);
+            if (hit) {
+                model.selectFeature(hit);
+            }
+        }, onContextMenu: contextMenu
+            ? event => {
+                const { x, y } = eventPoint(event);
+                const hit = hitAt(x, y);
+                openContextMenuFromEvent(contextMenu, event, hit
+                    ? { clientX: event.clientX, clientY: event.clientY, hit }
+                    : undefined);
+            }
+            : undefined, children: ({ canvasRef, mouseTracker }) => (_jsx(ScorePlotBody, { canvasRef: canvasRef, mouseTracker: mouseTracker, width: width, plotGeometry: box, tooltip: tooltip, overlay: overlay, indicators: indicators, contextMenu: contextMenu })) }));
+});
+const ScorePlotBody = observer(function ScorePlotBody({ canvasRef, mouseTracker, width, plotGeometry, tooltip, overlay, indicators, contextMenu, }) {
+    return (_jsxs(_Fragment, { children: [_jsx("canvas", { ref: canvasRef, style: {
+                    width,
+                    height: plotGeometry.plotHeight,
+                    position: 'absolute',
+                    left: 0,
+                    top: plotGeometry.yTop,
+                } }), overlay?.(plotGeometry), _jsx(PointerLayer, { mouseTracker: mouseTracker, children: tooltip }), indicators ? (_jsx(BottomRightIndicators, { children: indicators() })) : null, contextMenu ? _jsx(DisplayContextMenu, { model: contextMenu }) : null] }));
+});

package/esm/ScorePlotSvgFrame.d.ts

@@ -0,0 +1,27 @@
+import type { SvgExportable } from '@jbrowse/core/svg/svgReady';
+import type { LgvSvgBodyProps } from '@jbrowse/display-kit/renderDisplaySvg';
+import type { Mark, MarkFrame } from '@jbrowse/render-core/marks';
+import type React from 'react';
+export interface ScorePlotSvgModel extends SvgExportable {
+    id: string;
+    height: number;
+}
+/**
+ * The SVG-export body of a display with a score axis, mounted through
+ * `renderDisplaySvg`, which draws the axis and cross-hatches. Paints `marks`
+ * over `regions` inside the plot box, at the export's width and the box's
+ * height — the two fields of `renderState` the on-screen canvas sizes
+ * differently. `plotGeometry` defaults to the single-plot box `ScorePlotChrome`
+ * draws in; multi-wiggle stacks its rows over the full height instead.
+ * `children` draw over the plot, in the same untranslated space as the axis.
+ */
+export declare function ScorePlotSvgFrame<TRegion, TState extends MarkFrame>({ height, canvasWidth, renderBlocks, opts, plotGeometry, marks, regions, renderState, children, }: LgvSvgBodyProps<ScorePlotSvgModel> & {
+    plotGeometry?: {
+        yTop: number;
+        plotHeight: number;
+    };
+    marks: readonly Mark<TRegion, TState>[];
+    regions: ReadonlyMap<number, TRegion>;
+    renderState: TState;
+    children?: React.ReactNode;
+}): React.JSX.Element;