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

package/esm/ScorePlotSvgFrame.js

@@ -0,0 +1,23 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PaintLayer } from '@jbrowse/core/util/paintLayer';
+import { axisPlotBox } from '@jbrowse/display-ui';
+import { paintMarkBlocks } from '@jbrowse/render-core/marks';
+/**
+ * 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 function ScorePlotSvgFrame({ height, canvasWidth, renderBlocks, opts, plotGeometry = axisPlotBox(height), marks, regions, renderState, children, }) {
+    const { yTop, plotHeight } = plotGeometry;
+    return (_jsxs(_Fragment, { children: [_jsx("g", { transform: `translate(0,${yTop})`, children: _jsx(PaintLayer, { width: canvasWidth, height: plotHeight, opts: opts, paint: ctx => {
+                        paintMarkBlocks(ctx, marks, regions, renderBlocks, {
+                            ...renderState,
+                            canvasWidth,
+                            canvasHeight: plotHeight,
+                        });
+                    } }) }), children] }));
+}

package/esm/ScoreScaleMixin.d.ts

@@ -1,152 +1,112 @@
-import type { ScoreAxisConfigModel } from './scoreAxisConfigSchemaFields.ts';
-import type { ValueScale, YAxis } from '@jbrowse/display-ui';
+import type { scalesSchema } from './valueScaleConfigSchema.ts';
+import type { ConfigModelForFields } from '@jbrowse/core/configuration';
+import type { ValueScaleRule } from '@jbrowse/display-ui';
 /**
- * The whole of what `ScoreScaleMixin` needs a composing display to be. Exported
+ * The whole of what `ScoreScaleMixin` needs a composing display to be: a
+ * `scales` object holding the `y` the value-scale factory built. Exported
  * because it is the mixin's contract and `ScoreScaleMixin.test.ts` pins it:
  * widen it and the `@ts-expect-error`s there go unused.
  */
 export interface ScoreScaleHost {
-    configuration: ScoreAxisConfigModel;
+    configuration: ConfigModelForFields<{
+        scales: ReturnType<typeof scalesSchema>;
+    }>;
 }
 /**
  * #stateModel ScoreScaleMixin
  * #category display
- * #crossCuttingMixin Score axis. Nothing — the config slots. Brings `scaleType` / `autoscaleType` / `minScore` / `maxScore` / `manual*` / `*Bound` / `hasManualScoreBounds` / `numStdDev` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
+ * #crossCuttingMixin Value scale, written in `scales.y`. `valueScaleSchema` / `scalesSchema`. Brings `ScoreAxisMixin` plus `scaleType` / `scaleTypeChoices` / `autoscaleType` / `numStdDev` / `numQuantile` / `symlogConstant` / `manual*` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
  *
- * The score axis every quantitative display shares: which scale, how to
- * autoscale it, and the manual min/max bounds. This is the runtime half of
- * {@link ScoreScaleModel} in `scoreMenuItems.ts` — that interface is what the
- * shared Score menu, the autoscale/scale submenus and `SetMinMaxDialog` consume,
- * and it was already the canonical contract while two displays hand-wrote
- * identical implementations of it (`WiggleScoreConfigMixin`, and the alignments
- * coverage band). Composing this is now how a display satisfies it, so a new
- * score display cannot satisfy it *partially*.
+ * The value scale of every quantitative display: wiggle, the multi-wiggle,
+ * Manhattan, the alignments coverage band and the mark display each declare
+ * `scales.y` through {@link valueScaleSchema} and compose this. It backs
+ * {@link ScoreAxisMixin}'s three overridable members off that object and adds
+ * the setters that write it, so composing this is how a display satisfies
+ * {@link ScoreScaleModel} in `scoreMenuItems.ts` — the interface the shared
+ * Score menu, the scale and autoscale submenus and `SetMinMaxDialog` consume.
  *
- * Deliberately just the axis. Colors, `resolution`, cross-hatches and the
- * autoscale *computation* stay in `WiggleScoreConfigMixin` / `WiggleCommonMixin`
- * — the alignments coverage band shares this axis but none of the rest.
- *
- * `minScore`/`maxScore` are the **raw** slot values with their
- * `Number.MIN_VALUE`/`Number.MAX_VALUE` "unset" sentinels intact, and nothing
- * outside this file should want them: `manualMinScore`/`manualMaxScore` are the
- * same answer with the sentinel resolved to `undefined`, which is what the
- * dialog round-trips and what the menu captions itself with;
- * `minScoreBound`/`maxScoreBound` are the resolved bounds, where `undefined`
- * means "autoscale this end". Every consumer that computes a domain reads the
- * `*Bound` pair.
+ * What a display's scale offers follows what it draws, so the members below
+ * answer `undefined` where its factory call left them out: `autoscaleType` on
+ * Manhattan, whose domain is plain min/max, and `symlogConstant` wherever
+ * `symlog` is not among the scale types. `scaleTypeChoices` reads the declared
+ * enum back, which is what the scale-type radio offers.
  *
- * A display that declares its value scale elsewhere answers
- * `declaredValueScale`, and then the scale type and the pinned bounds come
- * from the declaration rather than from `scaleType`/`minScore`/`maxScore`.
- * Its setters are the display's to override so the edit lands on the same
- * declaration — one owner, whichever it is.
- *
- * Whether a bound is *configured* is a third question, and `hasManualScoreBounds`
- * is the only getter that answers it — the resolved pair cannot, since
- * `defaultScoreDomain` is exactly the hook that turns an unset end into a number.
+ * Deliberately just the scale. Colors, `resolution`, cross-hatches and the
+ * autoscale *computation* stay in `WiggleScoreConfigMixin` / `WiggleCommonMixin`
+ * — the alignments coverage band shares this scale but none of the rest.
  */
 export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IModelType<{}, {
-    /**
-     * #getter
-     * Overridable hook: a value scale the display declares somewhere other
-     * than these slots — the mark display's `encoding.y`. Where it answers,
-     * it is the owner and the slots below stand in only for the ends it
-     * leaves open, so a scale is read from one place whichever place that
-     * is. Default none, which is every display whose axis IS these slots.
-     */
-    readonly declaredValueScale: {
-        scaleType?: string;
-        domain?: [number | undefined, number | undefined];
-    } | undefined;
+    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[];
+} & {
     /**
      * #getter
      */
     readonly scaleType: string;
     /**
      * #getter
+     * The scale types this display's own enum admits, which is what the
+     * scale-type radio offers; a display with one draws no radio.
      */
-    readonly autoscaleType: string;
+    readonly scaleTypeChoices: string[];
     /**
      * #getter
+     * `undefined` on a display whose domain consults no autoscale mode.
      */
-    readonly numStdDev: number;
+    readonly autoscaleType: string | undefined;
     /**
      * #getter
-     * Raw slot value, sentinel intact — see the class comment.
      */
-    readonly minScore: number;
+    readonly numStdDev: number;
     /**
      * #getter
-     * Raw slot value, sentinel intact — see the class comment.
      */
-    readonly maxScore: number;
+    readonly numQuantile: number;
     /**
      * #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 below, which is the one thing that must not
-     * be duplicated: config bounds still win, precisely because they are
-     * checked before this is consulted.
+     * Raw slot; `0` means "derive from the domain". Resolve it with
+     * `resolveSymlogConstant` once the domain is known.
      */
-    readonly defaultScoreDomain: [number | undefined, number | undefined];
+    readonly symlogConstant: number;
     /**
      * #getter
-     * The lower bound the config really sets, `undefined` at the sentinel.
+     * The lower bound the config pins, `undefined` where it pins none.
      */
     readonly manualMinScore: number | undefined;
     /**
      * #getter
-     * The upper bound the config really sets, `undefined` at the sentinel.
+     * The upper bound the config pins, `undefined` where it pins none.
      */
     readonly manualMaxScore: number | undefined;
     /**
      * #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 sentinels 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 sentinels already
-     * there is a row that does nothing and never goes away.
+     * `scales.y.title` as written, `undefined` while unset or on a display
+     * whose scale declares no title.
      */
-    readonly hasManualScoreBounds: boolean;
+    readonly scaleTitle: string | 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.
+     * Whether this display draws `scales.y.rules`, which is whether the
+     * score menu offers the reference lines: its scale declares them, and
+     * a scale it places y through rules a band for them to cross, which a
+     * density plot's colour-mapped rows and a colour ramp do not.
      */
-    readonly valueScales: ValueScale[];
-} & {
+    readonly scoreRulesDrawn: 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.
+     * `scales.y.rules`, read off the live nodes: a snapshot strips a slot at
+     * its default, and a rule at 0 is one. Empty on a display whose scale
+     * declares no rules.
      */
-    readonly axes: YAxis[];
+    readonly scoreRules: ValueScaleRule[];
 } & {
     /**
      * #action
@@ -164,4 +124,10 @@ export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IM
      * #action
      */
     setMaxScore(val?: number): void;
+    /**
+     * #action
+     * Replaces `scales.y.rules` whole, each entry in a form the config
+     * takes: a number, or `{ value, color, label }`.
+     */
+    setScoreRules(rules: (number | ValueScaleRule)[]): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/ScoreScaleMixin.js

@@ -1,198 +1,127 @@
-import { getConf, setConf } from '@jbrowse/core/configuration';
-import { types } from '@jbrowse/mobx-state-tree';
-import { computeYTicks } from './computeYTicks.js';
+import { getConf, getSlotDefinition, readConfObject, setConf, slotChoices, } from '@jbrowse/core/configuration';
+import { rulesABand } from '@jbrowse/display-ui/axisPlacement';
+import { ScoreAxisMixin } from './ScoreAxisMixin.js';
 // The mixin composes onto a display that declares this, not the other way
 // round, so its own `self` isn't typed with it. Cast once, narrowed to the
-// field table beside it rather than `AnyConfigurationModel`, which is what keeps
-// the slot names below checked.
+// factory's schema rather than `AnyConfigurationModel`, which is what keeps the
+// member names below checked.
 const confNode = (self) => self;
 /**
  * #stateModel ScoreScaleMixin
  * #category display
- * #crossCuttingMixin Score axis. Nothing — the config slots. Brings `scaleType` / `autoscaleType` / `minScore` / `maxScore` / `manual*` / `*Bound` / `hasManualScoreBounds` / `numStdDev` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
+ * #crossCuttingMixin Value scale, written in `scales.y`. `valueScaleSchema` / `scalesSchema`. Brings `ScoreAxisMixin` plus `scaleType` / `scaleTypeChoices` / `autoscaleType` / `numStdDev` / `numQuantile` / `symlogConstant` / `manual*` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
  *
- * The score axis every quantitative display shares: which scale, how to
- * autoscale it, and the manual min/max bounds. This is the runtime half of
- * {@link ScoreScaleModel} in `scoreMenuItems.ts` — that interface is what the
- * shared Score menu, the autoscale/scale submenus and `SetMinMaxDialog` consume,
- * and it was already the canonical contract while two displays hand-wrote
- * identical implementations of it (`WiggleScoreConfigMixin`, and the alignments
- * coverage band). Composing this is now how a display satisfies it, so a new
- * score display cannot satisfy it *partially*.
+ * The value scale of every quantitative display: wiggle, the multi-wiggle,
+ * Manhattan, the alignments coverage band and the mark display each declare
+ * `scales.y` through {@link valueScaleSchema} and compose this. It backs
+ * {@link ScoreAxisMixin}'s three overridable members off that object and adds
+ * the setters that write it, so composing this is how a display satisfies
+ * {@link ScoreScaleModel} in `scoreMenuItems.ts` — the interface the shared
+ * Score menu, the scale and autoscale submenus and `SetMinMaxDialog` consume.
  *
- * Deliberately just the axis. Colors, `resolution`, cross-hatches and the
- * autoscale *computation* stay in `WiggleScoreConfigMixin` / `WiggleCommonMixin`
- * — the alignments coverage band shares this axis but none of the rest.
- *
- * `minScore`/`maxScore` are the **raw** slot values with their
- * `Number.MIN_VALUE`/`Number.MAX_VALUE` "unset" sentinels intact, and nothing
- * outside this file should want them: `manualMinScore`/`manualMaxScore` are the
- * same answer with the sentinel resolved to `undefined`, which is what the
- * dialog round-trips and what the menu captions itself with;
- * `minScoreBound`/`maxScoreBound` are the resolved bounds, where `undefined`
- * means "autoscale this end". Every consumer that computes a domain reads the
- * `*Bound` pair.
- *
- * A display that declares its value scale elsewhere answers
- * `declaredValueScale`, and then the scale type and the pinned bounds come
- * from the declaration rather than from `scaleType`/`minScore`/`maxScore`.
- * Its setters are the display's to override so the edit lands on the same
- * declaration — one owner, whichever it is.
+ * What a display's scale offers follows what it draws, so the members below
+ * answer `undefined` where its factory call left them out: `autoscaleType` on
+ * Manhattan, whose domain is plain min/max, and `symlogConstant` wherever
+ * `symlog` is not among the scale types. `scaleTypeChoices` reads the declared
+ * enum back, which is what the scale-type radio offers.
  *
- * Whether a bound is *configured* is a third question, and `hasManualScoreBounds`
- * is the only getter that answers it — the resolved pair cannot, since
- * `defaultScoreDomain` is exactly the hook that turns an unset end into a number.
+ * Deliberately just the scale. Colors, `resolution`, cross-hatches and the
+ * autoscale *computation* stay in `WiggleScoreConfigMixin` / `WiggleCommonMixin`
+ * — the alignments coverage band shares this scale but none of the rest.
  */
 export function ScoreScaleMixin() {
-    return types
-        .model('ScoreScaleMixin', {})
+    return ScoreAxisMixin()
         .views(self => ({
         /**
          * #getter
-         * Overridable hook: a value scale the display declares somewhere other
-         * than these slots — the mark display's `encoding.y`. Where it answers,
-         * it is the owner and the slots below stand in only for the ends it
-         * leaves open, so a scale is read from one place whichever place that
-         * is. Default none, which is every display whose axis IS these slots.
          */
-        get declaredValueScale() {
-            return undefined;
+        get scaleType() {
+            return getConf(confNode(self), ['scales', 'y', 'type']);
         },
         /**
          * #getter
+         * The scale types this display's own enum admits, which is what the
+         * scale-type radio offers; a display with one draws no radio.
          */
-        get scaleType() {
-            return (this.declaredValueScale?.scaleType ??
-                getConf(confNode(self), 'scaleType'));
+        get scaleTypeChoices() {
+            return (slotChoices(getSlotDefinition(confNode(self).configuration.scales.y, 'type')) ?? []);
         },
         /**
          * #getter
+         * `undefined` on a display whose domain consults no autoscale mode.
          */
         get autoscaleType() {
-            return getConf(confNode(self), 'autoscale');
+            return getConf(confNode(self), ['scales', 'y', 'autoscale']);
         },
         /**
          * #getter
          */
         get numStdDev() {
-            return getConf(confNode(self), 'numStdDev');
+            return getConf(confNode(self), ['scales', 'y', 'numStdDev']);
         },
         /**
          * #getter
-         * Raw slot value, sentinel intact — see the class comment.
          */
-        get minScore() {
-            return getConf(confNode(self), 'minScore');
+        get numQuantile() {
+            return getConf(confNode(self), ['scales', 'y', 'numQuantile']);
         },
         /**
          * #getter
-         * Raw slot value, sentinel intact — see the class comment.
+         * Raw slot; `0` means "derive from the domain". Resolve it with
+         * `resolveSymlogConstant` once the domain is known.
          */
-        get maxScore() {
-            return getConf(confNode(self), 'maxScore');
+        get symlogConstant() {
+            return getConf(confNode(self), ['scales', 'y', 'symlogConstant']);
         },
         /**
          * #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 below, 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
-         * The lower bound the config really sets, `undefined` at the sentinel.
+         * The lower bound the config pins, `undefined` where it pins none.
          */
         get manualMinScore() {
-            const declared = this.declaredValueScale?.domain?.[0];
-            if (declared !== undefined) {
-                return declared;
-            }
-            return this.minScore === Number.MIN_VALUE ? undefined : this.minScore;
+            return getConf(confNode(self), ['scales', 'y', 'domainMin']);
         },
         /**
          * #getter
-         * The upper bound the config really sets, `undefined` at the sentinel.
+         * The upper bound the config pins, `undefined` where it pins none.
          */
         get manualMaxScore() {
-            const declared = this.declaredValueScale?.domain?.[1];
-            if (declared !== undefined) {
-                return declared;
-            }
-            return this.maxScore === Number.MAX_VALUE ? undefined : this.maxScore;
+            return getConf(confNode(self), ['scales', 'y', 'domainMax']);
         },
         /**
          * #getter
-         * Resolved lower bound; `undefined` means autoscale this end.
+         * `scales.y.title` as written, `undefined` while unset or on a display
+         * whose scale declares no title.
          */
-        get minScoreBound() {
-            return this.manualMinScore ?? this.defaultScoreDomain[0];
+        get scaleTitle() {
+            return getConf(confNode(self), ['scales', 'y', 'title']);
         },
         /**
          * #getter
-         * Resolved upper bound; `undefined` means autoscale this end.
+         * Whether this display draws `scales.y.rules`, which is whether the
+         * score menu offers the reference lines: its scale declares them, and
+         * a scale it places y through rules a band for them to cross, which a
+         * density plot's colour-mapped rows and a colour ramp do not.
          */
-        get maxScoreBound() {
-            return this.manualMaxScore ?? this.defaultScoreDomain[1];
+        get scoreRulesDrawn() {
+            return (confNode(self).configuration.scales.y.rules !== undefined &&
+                self.valueScales.some(rulesABand));
         },
         /**
          * #getter
-         * Whether the user has pinned either end, which is a different question
-         * from whether either end resolved to a number: `defaultScoreDomain` fills
-         * the sentinels 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 sentinels already
-         * there is a row that does nothing and never goes away.
-         */
-        get hasManualScoreBounds() {
-            return (this.manualMinScore !== undefined || this.manualMaxScore !== 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
-         * 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.
-         */
-        get axes() {
-            return self.valueScales.flatMap(scale => {
-                const { domain } = scale;
-                const ticks = scale.ticks ??
-                    computeYTicks({
-                        height: scale.height,
-                        offset: scale.offset,
-                        domain,
-                        scaleType: scale.scaleType,
-                        minimalTicks: scale.minimalTicks ?? false,
-                        symlogConstant: scale.symlogConstant,
-                    });
-                return domain && ticks ? [{ ...scale, domain, ticks }] : [];
+         * `scales.y.rules`, read off the live nodes: a snapshot strips a slot at
+         * its default, and a rule at 0 is one. Empty on a display whose scale
+         * declares no rules.
+         */
+        get scoreRules() {
+            const { rules = [] } = confNode(self).configuration.scales.y;
+            return rules.map((rule) => {
+                const label = readConfObject(rule, 'label');
+                const color = readConfObject(rule, 'color');
+                return {
+                    value: readConfObject(rule, 'value'),
+                    ...(color ? { color } : {}),
+                    ...(label ? { label } : {}),
+                };
             });
         },
     }))
@@ -201,25 +130,33 @@ export function ScoreScaleMixin() {
          * #action
          */
         setScaleType(scaleType) {
-            setConf(confNode(self), 'scaleType', scaleType);
+            setConf(confNode(self), ['scales', 'y', 'type'], scaleType);
         },
         /**
          * #action
          */
         setAutoscale(val) {
-            setConf(confNode(self), 'autoscale', val);
+            setConf(confNode(self), ['scales', 'y', 'autoscale'], val);
         },
         /**
          * #action
          */
         setMinScore(val) {
-            setConf(confNode(self), 'minScore', val);
+            setConf(confNode(self), ['scales', 'y', 'domainMin'], val);
         },
         /**
          * #action
          */
         setMaxScore(val) {
-            setConf(confNode(self), 'maxScore', val);
+            setConf(confNode(self), ['scales', 'y', 'domainMax'], val);
+        },
+        /**
+         * #action
+         * Replaces `scales.y.rules` whole, each entry in a form the config
+         * takes: a number, or `{ value, color, label }`.
+         */
+        setScoreRules(rules) {
+            setConf(confNode(self), ['scales', 'y', 'rules'], rules);
         },
     }));
 }

package/esm/SetScoreRulesDialog.d.ts

@@ -0,0 +1,14 @@
+import type { ValueScaleRule } from '@jbrowse/display-ui';
+/**
+ * The score menu's editor for `scales.y.rules`: one row per reference line,
+ * its value on the plot's own scale, its label and its colour. An empty colour
+ * is the display's default, and removing every row removes every line.
+ */
+declare const _default: ({ model, handleClose, }: {
+    model: {
+        scoreRules: ValueScaleRule[];
+        setScoreRules: (rules: ValueScaleRule[]) => void;
+    };
+    handleClose: () => void;
+}) => import("react").JSX.Element;
+export default _default;

package/esm/SetScoreRulesDialog.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { SubmitDialog } from '@jbrowse/core/ui';
+import { isCssColor } from '@jbrowse/core/util/colorBits';
+import DeleteIcon from '@mui/icons-material/Delete';
+import { Button, IconButton, TextField, Typography } from '@mui/material';
+import { observer } from 'mobx-react';
+function rowOf({ value, label = '', color = '' }) {
+    return { value: String(value), label, color };
+}
+function valueOk({ value }) {
+    return value.trim() !== '' && Number.isFinite(Number(value));
+}
+function colorOk({ color }) {
+    return color.trim() === '' || isCssColor(color);
+}
+/**
+ * The score menu's editor for `scales.y.rules`: one row per reference line,
+ * its value on the plot's own scale, its label and its colour. An empty colour
+ * is the display's default, and removing every row removes every line.
+ */
+export default observer(function SetScoreRulesDialog({ model, handleClose, }) {
+    const [rows, setRows] = useState(() => model.scoreRules.map(rowOf));
+    const setRow = (index, patch) => {
+        setRows(rows.map((row, i) => (i === index ? { ...row, ...patch } : row)));
+    };
+    return (_jsxs(SubmitDialog, { open: true, title: "Reference lines", submitDisabled: !rows.every(row => valueOk(row) && colorOk(row)), onCancel: handleClose, onSubmit: () => {
+            model.setScoreRules(rows.map(row => ({
+                value: Number(row.value),
+                ...(row.label ? { label: row.label } : {}),
+                ...(row.color.trim() ? { color: row.color.trim() } : {}),
+            })));
+            handleClose();
+        }, children: [_jsx(Typography, { children: "A horizontal line at each value, on the same scale as the plot" }), rows.map((row, index) => (_jsxs("div", { style: { display: 'flex', gap: 8, marginTop: 8 }, children: [_jsx(TextField, { label: "Value", value: row.value, error: !valueOk(row), onChange: event => {
+                            setRow(index, { value: event.target.value });
+                        } }), _jsx(TextField, { label: "Label", value: row.label, onChange: event => {
+                            setRow(index, { label: event.target.value });
+                        } }), _jsx(TextField, { label: "Color", value: row.color, error: !colorOk(row), onChange: event => {
+                            setRow(index, { color: event.target.value });
+                        } }), _jsx(IconButton, { "aria-label": "remove line", onClick: () => {
+                            setRows(rows.filter((_, i) => i !== index));
+                        }, children: _jsx(DeleteIcon, {}) })] }, index))), _jsx(Button, { onClick: () => {
+                    setRows([...rows, { value: '', label: '', color: '' }]);
+                }, children: "Add line" })] }));
+});