@jbrowse/wiggle-core 4.3.0

package/esm/scale.d.ts

@@ -0,0 +1,60 @@
+/**
+ * What `getScale` hands back: callable, plus the domain and ticks its callers
+ * read. The scales underneath are pure functions over a {@link ScaleSpec}, so
+ * this has no setters — the domain and range come in through `getScale`.
+ */
+export interface Scale {
+    (x: number): number;
+    domain(): [number, number];
+    range(): [number, number];
+    ticks(count?: number): number[];
+}
+export interface ScaleOpts {
+    domain: number[];
+    range: number[];
+    scaleType: string;
+    /**
+     * symlog's linear-region width. `0` (the config default) resolves from the
+     * domain — see {@link resolveSymlogConstant}. Ignored by the other scales.
+     */
+    symlogConstant?: number;
+    /**
+     * Round the domain to nice endpoints before building the scale. Defaults to
+     * true, which is what a caller handing over raw data wants. Pass false when
+     * the domain is already the one something else is drawing with — nicing it
+     * again moves the axis off that drawing, and can invent an endpoint outside
+     * it (a raw `[1, 1000]` nices to `[1, 1024]`, so the axis labels a tick at a
+     * value the data never reaches).
+     */
+    nice?: boolean;
+}
+/**
+ * #api
+ * Builds a d3 scale (linear/log/symlog) from a `ScaleOpts`, nicing the domain
+ * unless `nice: false` says it is already the one being drawn with.
+ */
+export declare function getScale({ domain, range, scaleType, symlogConstant, nice, }: ScaleOpts): Scale;
+/**
+ * #api
+ * Rounds a domain to "nice" endpoints, clamped to the origin. An end given an
+ * explicit `bounds` value keeps that value exactly — only an autoscaled end is
+ * rounded. A log scale's floor still outranks a bound it cannot hold.
+ *
+ * The result never descends: a bound that would put `min` above `max` widens
+ * the other end instead, so no consumer has to guess what a backwards domain
+ * means.
+ */
+export declare function getNiceDomain({ scaleType, domain, bounds, }: {
+    scaleType: string;
+    domain: readonly [number, number];
+    bounds: readonly [number | undefined, number | undefined];
+}): [number, number];
+/**
+ * #api
+ * Returns a niced `{min, max}` domain for a maximum score value.
+ * Uses log base-2 when `useLogScale` is true (domain is clamped to [1, max]).
+ */
+export declare function getNiceScale(maxScore: number, useLogScale?: boolean): {
+    min: number;
+    max: number;
+};

package/esm/scale.js

@@ -0,0 +1,161 @@
+import { resolveSymlogConstant } from './normalize.js';
+import { symlogTicks } from './symlogTicks.js';
+import { niceDomain, scaleTicks, scaleValue, } from './vendor/d3-scale.js';
+function buildScale(spec) {
+    const scale = ((x) => scaleValue(spec, x));
+    scale.domain = () => [...spec.domain];
+    scale.range = () => [...spec.range];
+    // symlog gets its ticks spaced down the axis rather than across the scores —
+    // see symlogTicks, which is this module's choice and not d3's. `scaleTicks`
+    // goes on answering exactly what d3 answers for all three kinds.
+    scale.ticks = (count) => spec.kind === 'symlog'
+        ? symlogTicks(spec.domain, spec.constant ?? 1, count)
+        : scaleTicks(spec, count);
+    return scale;
+}
+function specForType(scaleType, domain, symlogConstant = 0) {
+    const range = [0, 1];
+    if (scaleType === 'linear') {
+        return { kind: 'linear', domain, range };
+    }
+    if (scaleType === 'log') {
+        return { kind: 'log', base: 2, domain, range };
+    }
+    if (scaleType === 'symlog') {
+        // The axis has to be built with the same constant the renderer normalizes
+        // with, or the ticks label positions the bars are not drawn at. Both
+        // resolve through resolveSymlogConstant from the same domain.
+        const [min, max] = domain;
+        return {
+            kind: 'symlog',
+            constant: resolveSymlogConstant(min, max, symlogConstant),
+            domain,
+            range,
+        };
+    }
+    throw new Error(`undefined scaleType: ${scaleType}`);
+}
+/**
+ * #api
+ * Builds a d3 scale (linear/log/symlog) from a `ScaleOpts`, nicing the domain
+ * unless `nice: false` says it is already the one being drawn with.
+ */
+export function getScale({ domain, range, scaleType, symlogConstant, nice = true, }) {
+    const [min, max] = domain;
+    if (min === undefined || max === undefined) {
+        throw new Error('invalid domain');
+    }
+    const [rangeMin, rangeMax] = range;
+    if (rangeMin === undefined || rangeMax === undefined) {
+        throw new Error('invalid range');
+    }
+    // Nice first, then build the spec from the domain that came out. The renderer
+    // resolves symlog's constant from the domain it is handed, so a spec built
+    // before nicing would give the axis a different constant and label heights
+    // the bars are not drawn at. `niceDomain` ignores the constant, so it can
+    // take a throwaway spec.
+    const nicedDomain = nice
+        ? niceDomain(specForType(scaleType, [min, max]))
+        : [min, max];
+    return buildScale({
+        ...specForType(scaleType, nicedDomain, symlogConstant),
+        range: [rangeMin, rangeMax],
+    });
+}
+/**
+ * #api
+ * Rounds a domain to "nice" endpoints, clamped to the origin. An end given an
+ * explicit `bounds` value keeps that value exactly — only an autoscaled end is
+ * rounded. A log scale's floor still outranks a bound it cannot hold.
+ *
+ * The result never descends: a bound that would put `min` above `max` widens
+ * the other end instead, so no consumer has to guess what a backwards domain
+ * means.
+ */
+// No `symlogConstant` parameter: `niceDomain` puts symlog through d3's linear
+// path, which never reads the constant, so one passed here only looked like it
+// did something.
+export function getNiceDomain({ scaleType, domain, bounds, }) {
+    const [minScore, maxScore] = bounds;
+    let [min, max] = domain;
+    // symlog joins linear here rather than log: it is defined at 0, so the
+    // domain should reach the baseline its bars grow from instead of being
+    // floored off it the way a log domain has to be.
+    if (scaleType === 'linear' || scaleType === 'symlog') {
+        if (max < 0) {
+            max = 0;
+        }
+        if (min > 0) {
+            min = 0;
+        }
+    }
+    if (scaleType === 'log') {
+        if (min >= 0 && max > 1) {
+            min = 1;
+        }
+    }
+    if (minScore !== undefined) {
+        min = minScore;
+    }
+    if (maxScore !== undefined) {
+        max = maxScore;
+    }
+    if (scaleType === 'log') {
+        // d3 scaleLog is undefined at values <= 0, so autoscale (esp. localsd) or
+        // data that crosses zero (e.g. log-ratio bigwigs) would otherwise yield a
+        // domain that produces NaN ticks and a blank plot. Floor the domain to a
+        // positive, non-degenerate range so the axis renders its valid portion
+        // instead of silently disappearing.
+        if (min <= 0) {
+            min = max > 1 ? 1 : max > 0 ? max / 100 : 1;
+        }
+        if (max <= min) {
+            max = min * 2;
+        }
+    }
+    else if (max < min) {
+        // A bound can invert the domain — `minScore: 200` against an autoscaled max
+        // of 60, or `maxScore: -100` against an autoscaled min of -40. A descending
+        // domain is not a picture: the two score normalizers disagree about it, so
+        // the same view draws an empty band on the GPU and a solid full-height
+        // block in an SVG export. Widen whichever end the user did not pin, keeping
+        // the one they did; with both pinned there is no free end, so order them.
+        // (log has its own version above — its positivity floor has already moved
+        // `min`, so it can only ever widen upward.)
+        if (maxScore === undefined) {
+            max = min * 2;
+        }
+        else if (minScore === undefined) {
+            min = max * 2;
+        }
+        else {
+            ;
+            [min, max] = [max, min];
+        }
+    }
+    // Rounding is for an autoscaled end, whose only meaning is "roughly the
+    // data's extent". A bound the user typed into Set min/max score means itself,
+    // and the menu row goes on displaying it, so it is taken as given.
+    //
+    // `min`/`max` rather than `minScore`/`maxScore`: the log guards above may
+    // have moved a bound scaleLog cannot hold, and that correction has to
+    // survive.
+    const [nicedMin, nicedMax] = niceDomain(specForType(scaleType, [min, max]));
+    return [
+        minScore === undefined ? nicedMin : min,
+        maxScore === undefined ? nicedMax : max,
+    ];
+}
+/**
+ * #api
+ * Returns a niced `{min, max}` domain for a maximum score value.
+ * Uses log base-2 when `useLogScale` is true (domain is clamped to [1, max]).
+ */
+export function getNiceScale(maxScore, useLogScale) {
+    // A log scale needs a domain strictly inside its base, so guard against
+    // degenerate KR-normalized data where the top count is < 2.
+    const [min, max] = useLogScale
+        ? niceDomain(specForType('log', [1, Math.max(2, maxScore)]))
+        : niceDomain(specForType('linear', [0, maxScore]));
+    return { min, max };
+}

package/esm/scoreAxisConfigSchemaFields.d.ts

@@ -0,0 +1,44 @@
+import type { ConfigModelForFields } from '@jbrowse/core/configuration';
+export declare const scoreAxisConfigSchemaFields: {
+    readonly minScore: {
+        readonly type: 'number';
+        readonly defaultValue: number;
+        readonly description: 'Fixed minimum score bound. The default (Number.MIN_VALUE) is a sentinel meaning "unset, use autoscale"';
+        readonly advanced: true;
+    };
+    readonly maxScore: {
+        readonly type: 'number';
+        readonly defaultValue: number;
+        readonly description: 'Fixed maximum score bound. The default (Number.MAX_VALUE) is a sentinel meaning "unset, use autoscale"';
+        readonly advanced: true;
+    };
+    readonly scaleType: {
+        readonly type: 'stringEnum';
+        readonly model: import("@jbrowse/mobx-state-tree").ISimpleType<"linear" | "log">;
+        readonly defaultValue: 'linear';
+        readonly description: 'Scale type (linear or log)';
+    };
+    readonly autoscale: {
+        readonly type: 'stringEnum';
+        readonly model: import("@jbrowse/mobx-state-tree").ISimpleType<"local" | "localpercentile" | "localsd">;
+        readonly defaultValue: 'localpercentile';
+        readonly description: 'Autoscale type: "local" uses the min/max in the visible region, "localsd" uses mean ± numStdDev standard deviations, "localpercentile" uses the numQuantile-th percentile score as the max (robust to skewed/peaky data)';
+    };
+    readonly numStdDev: {
+        readonly type: 'number';
+        readonly defaultValue: 3;
+        readonly description: 'Number of standard deviations to use for the localsd autoscale type';
+        readonly advanced: true;
+    };
+    readonly displayCrossHatches: {
+        readonly type: 'boolean';
+        readonly defaultValue: false;
+        readonly description: 'Rule the score axis with horizontal cross hatches at the tick positions — the config form of the score menu\'s "Show cross hatches". Ignored by the density rendering types, which spend color rather than height on the score and so have no axis to rule';
+    };
+};
+/**
+ * What `ScoreScaleMixin` asks a composing display's `configuration` to be — the
+ * slots above and nothing else, which is all the mixin touches. Narrow so
+ * `getConf`/`setConf` still check the slot name; see `ConfigModelForFields`.
+ */
+export type ScoreAxisConfigModel = ConfigModelForFields<typeof scoreAxisConfigSchemaFields>;

package/esm/scoreAxisConfigSchemaFields.js

@@ -0,0 +1,54 @@
+import { types } from '@jbrowse/mobx-state-tree';
+// The score AXIS alone: exactly the slots `ScoreScaleMixin` reads, and nothing
+// else. Split out of `wiggleConfigSchemaFields` below so a display with a score
+// axis but none of wiggle's palette/rendering vocabulary can declare the axis
+// without inheriting the rest — LinearManhattanDisplay used to extend the whole
+// wiggle display schema and advertised twelve slots that did nothing on a GWAS
+// track.
+//
+// `numQuantile` is deliberately NOT here even though `autoscale` names
+// `localpercentile`: it is read by the autoscale *computation*
+// (`WiggleCommonMixin`), which only the wiggle displays run.
+export const scoreAxisConfigSchemaFields = {
+    minScore: {
+        type: 'number',
+        defaultValue: Number.MIN_VALUE,
+        description: 'Fixed minimum score bound. The default (Number.MIN_VALUE) is a sentinel meaning "unset, use autoscale"',
+        advanced: true,
+    },
+    maxScore: {
+        type: 'number',
+        defaultValue: Number.MAX_VALUE,
+        description: 'Fixed maximum score bound. The default (Number.MAX_VALUE) is a sentinel meaning "unset, use autoscale"',
+        advanced: true,
+    },
+    // #region stringEnumSlot
+    scaleType: {
+        type: 'stringEnum',
+        model: types.enumeration('Scale type', ['linear', 'log']),
+        defaultValue: 'linear',
+        description: 'Scale type (linear or log)',
+    },
+    // #endregion
+    autoscale: {
+        type: 'stringEnum',
+        model: types.enumeration('Autoscale type', [
+            'local',
+            'localsd',
+            'localpercentile',
+        ]),
+        defaultValue: 'localpercentile',
+        description: 'Autoscale type: "local" uses the min/max in the visible region, "localsd" uses mean ± numStdDev standard deviations, "localpercentile" uses the numQuantile-th percentile score as the max (robust to skewed/peaky data)',
+    },
+    numStdDev: {
+        type: 'number',
+        defaultValue: 3,
+        description: 'Number of standard deviations to use for the localsd autoscale type',
+        advanced: true,
+    },
+    displayCrossHatches: {
+        type: 'boolean',
+        defaultValue: false,
+        description: 'Rule the score axis with horizontal cross hatches at the tick positions — the config form of the score menu\'s "Show cross hatches". Ignored by the density rendering types, which spend color rather than height on the score and so have no axis to rule',
+    },
+};

package/esm/scoreMenuItems.d.ts

@@ -0,0 +1,37 @@
+import type { MenuItem } from '@jbrowse/core/ui';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+export interface ScoreScaleModel extends IStateTreeNode {
+    scaleType: string;
+    autoscaleType: string;
+    minScore: number;
+    maxScore: number;
+    minScoreBound: number | undefined;
+    maxScoreBound: number | undefined;
+    setScaleType: (v: string) => void;
+    setAutoscale: (v?: string) => void;
+    setMinScore: (n?: number) => void;
+    setMaxScore: (n?: number) => void;
+}
+export declare function makeScaleTypeSubMenu(self: {
+    scaleType: string;
+    setScaleType: (v: string) => void;
+}): MenuItem;
+export declare function makeAutoscaleTypeSubMenu(self: {
+    autoscaleType: string;
+    setAutoscale: (v?: string) => void;
+}, options?: [string, string][]): MenuItem;
+export declare function makeSetMinMaxScoreItem(self: ScoreScaleModel): MenuItem;
+export declare function makeCrossHatchItem(self: {
+    displayCrossHatches: boolean;
+    toggleCrossHatches: () => void;
+}): MenuItem;
+export declare function makeScoreSubMenu(self: ScoreScaleModel, opts?: {
+    label?: string;
+    scaleType?: boolean;
+    autoscale?: boolean;
+    autoscaleOptions?: [string, string][];
+    leadingItems?: MenuItem[];
+    trailingItems?: MenuItem[];
+    disabled?: boolean;
+    disabledHelpText?: string;
+}): MenuItem;

package/esm/scoreMenuItems.js

@@ -0,0 +1,104 @@
+import { lazy } from 'react';
+import { checkboxItem, radioItems } from '@jbrowse/core/ui/menuItems';
+import { getDialogHost } from '@jbrowse/core/util';
+import EqualizerIcon from '@mui/icons-material/Equalizer';
+import { DEFAULT_AUTOSCALE_OPTIONS } from './autoscale.js';
+const SetMinMaxDialog = lazy(() => import('./SetMinMaxDialog.js'));
+// All three scales, so a display offering this menu at all must hold all three
+// in its own `scaleType` enum. `scoreAxisConfigSchemaFields` deliberately does
+// not — symlog is widened in by whoever implements it — so a display that spreads
+// the shared axis fields unchanged has to opt out with `scaleType: false` the way
+// manhattan does, or the radio writes a value its enumeration rejects.
+export function makeScaleTypeSubMenu(self) {
+    return {
+        label: 'Scale type',
+        subMenu: radioItems([
+            { value: 'linear', label: 'Linear scale' },
+            { value: 'log', label: 'Log scale' },
+            { value: 'symlog', label: 'Symlog scale (allows zero)' },
+        ], self.scaleType, v => {
+            self.setScaleType(v);
+        }),
+    };
+}
+export function makeAutoscaleTypeSubMenu(self, options = DEFAULT_AUTOSCALE_OPTIONS) {
+    return {
+        label: 'Autoscale type',
+        subMenu: radioItems(options.map(([value, label]) => ({ value, label })), self.autoscaleType, v => {
+            self.setAutoscale(v);
+        }),
+    };
+}
+// The model resolves the Number.MIN_VALUE / MAX_VALUE "unset, fall back to
+// autoscale" sentinel into minScoreBound/maxScoreBound (undefined = autoscale).
+// Surfacing them lets the menu show that a manual range is in force — otherwise
+// an autoscale-type radio still reads as checked while a fixed bound silently
+// overrides it.
+function resolveScoreBounds(self) {
+    const min = self.minScoreBound;
+    const max = self.maxScoreBound;
+    return { min, max, hasManual: min !== undefined || max !== undefined };
+}
+export function makeSetMinMaxScoreItem(self) {
+    const { min, max, hasManual } = resolveScoreBounds(self);
+    return {
+        label: hasManual
+            ? `Set min/max score (${min ?? 'auto'} – ${max ?? 'auto'})...`
+            : 'Set min/max score...',
+        onClick: () => {
+            getDialogHost(self).queueDialog(handleClose => [
+                SetMinMaxDialog,
+                { model: self, handleClose },
+            ]);
+        },
+    };
+}
+// Only offered when a manual bound is set; resets both to the sentinel (same
+// path the dialog takes when its fields are cleared) so autoscale resumes.
+function makeClearMinMaxScoreItem(self) {
+    return {
+        label: 'Clear manual min/max',
+        onClick: () => {
+            self.setMinScore(undefined);
+            self.setMaxScore(undefined);
+        },
+    };
+}
+export function makeCrossHatchItem(self) {
+    return checkboxItem('Show cross hatches', self.displayCrossHatches, () => {
+        self.toggleCrossHatches();
+    });
+}
+// The single Score submenu used by every wiggle-family display. Composition is
+// capability-driven: `leadingItems` lets wiggle prepend its Resolution/Summary
+// submenus, `trailingItems` appends what belongs after the range controls rather
+// than before them (the alignments band's allele-fraction floor); `scaleType` is
+// dropped by manhattan (linear-only); `autoscaleOptions` is overridden by
+// coverage's reduced + dynamic-σ list.
+//
+// `autoscale` is the same kind of opt-out as `scaleType`, and exists for the
+// same reason: a display whose domain doesn't consult `autoscaleType` must not
+// offer radios for it. Manhattan takes plain min/max over the loaded regions and
+// applies only the manual bounds, so its Autoscale-type radios wrote the config
+// slot and changed nothing on screen — a control that lies is worse than a
+// missing one. Opt-out rather than opt-in so a display that grows a domain
+// without wiring autoscale keeps the menu it already had.
+export function makeScoreSubMenu(self, opts = {}) {
+    const { label = 'Score', scaleType = true, autoscale = true, autoscaleOptions, leadingItems = [], trailingItems = [], disabled, disabledHelpText, } = opts;
+    return {
+        label,
+        icon: EqualizerIcon,
+        disabled,
+        disabledHelpText,
+        subMenu: [
+            ...leadingItems,
+            ...(scaleType ? [makeScaleTypeSubMenu(self)] : []),
+            ...(autoscale ? [makeAutoscaleTypeSubMenu(self, autoscaleOptions)] : []),
+            makeSetMinMaxScoreItem(self),
+            ...(resolveScoreBounds(self).hasManual
+                ? [makeClearMinMaxScoreItem(self)]
+                : []),
+            ...trailingItems,
+        ],
+    };
+}

package/esm/scoreRuleMarks.d.ts

@@ -0,0 +1,73 @@
+/**
+ * #api
+ * 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.
+ */
+export interface ScoreRule {
+    value: number;
+    label?: string;
+    color?: string;
+}
+export interface ScoreRuleMark extends ScoreRule {
+    y: number;
+}
+/**
+ * #api
+ * Screen y for each rule that falls inside the plotted domain, dropping the
+ * rest.
+ *
+ * Out-of-domain is a real case rather than a guard: the domain is whatever
+ * autoscale resolved for the visible data, so panning to a quiet stretch can put
+ * a rule above everything on screen, and a rule pinned to the top edge there
+ * reads as "the whole view is over the line".
+ *
+ * `normalize` is the display's OWN score normalizer — the same one the renderer
+ * draws with. It is a parameter rather than a linear interpolation of the domain
+ * because the axis need not be linear: on a log or symlog track, placing a rule
+ * at `(value - min) / (max - min)` puts the line somewhere the data it is meant
+ * to be 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
+ * differently, and the alignments coverage band does.
+ */
+export declare function scoreRuleMarks({ rules, domain, box, normalize, }: {
+    rules: readonly ScoreRule[];
+    domain: [number, number] | undefined;
+    box: {
+        yTop: number;
+        yBottom: number;
+    };
+    normalize: (score: number) => number;
+}): ScoreRuleMark[];
+/**
+ * #api
+ * 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.
+ */
+export declare function parseScoreRules(value: unknown): ScoreRule[];
+/**
+ * #api
+ * 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.
+ */
+export declare function widenRangeToRules(range: [number, number], ruleValues: readonly number[]): [number, number];

package/esm/scoreRuleMarks.js

@@ -0,0 +1,98 @@
+import { clampStrokeInsideAxis, scoreToAxisY } from './yScaleTicks.js';
+/**
+ * #api
+ * Screen y for each rule that falls inside the plotted domain, dropping the
+ * rest.
+ *
+ * Out-of-domain is a real case rather than a guard: the domain is whatever
+ * autoscale resolved for the visible data, so panning to a quiet stretch can put
+ * a rule above everything on screen, and a rule pinned to the top edge there
+ * reads as "the whole view is over the line".
+ *
+ * `normalize` is the display's OWN score normalizer — the same one the renderer
+ * draws with. It is a parameter rather than a linear interpolation of the domain
+ * because the axis need not be linear: on a log or symlog track, placing a rule
+ * at `(value - min) / (max - min)` puts the line somewhere the data it is meant
+ * to be 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
+ * differently, and the alignments coverage band does.
+ */
+export function scoreRuleMarks({ rules, domain, box, normalize, }) {
+    if (!domain) {
+        return [];
+    }
+    const [min, max] = domain;
+    if (max === min) {
+        return [];
+    }
+    return rules
+        .filter(r => Number.isFinite(r.value) && r.value >= min && r.value <= max)
+        .map(r => ({
+        ...r,
+        y: clampStrokeInsideAxis(scoreToAxisY(normalize(r.value), {
+            ...box,
+            plotHeight: box.yBottom - box.yTop,
+        }), box.yBottom),
+    }));
+}
+/**
+ * #api
+ * 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.
+ */
+export function parseScoreRules(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const out = [];
+    for (const entry of value) {
+        if (typeof entry === 'number') {
+            if (Number.isFinite(entry)) {
+                out.push({ value: entry });
+            }
+            continue;
+        }
+        if (entry && typeof entry === 'object') {
+            const { value: v, label, color } = entry;
+            const n = typeof v === 'string' ? Number(v) : v;
+            if (typeof n === 'number' && Number.isFinite(n)) {
+                out.push({
+                    value: n,
+                    ...(typeof label === 'string' && label ? { label } : {}),
+                    ...(typeof color === 'string' && color ? { color } : {}),
+                });
+            }
+        }
+    }
+    return out;
+}
+/**
+ * #api
+ * 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.
+ */
+export function widenRangeToRules(range, ruleValues) {
+    let [min, max] = range;
+    for (const value of ruleValues) {
+        if (Number.isFinite(value)) {
+            min = Math.min(min, value);
+            max = Math.max(max, value);
+        }
+    }
+    return [min, max];
+}

package/esm/symlogTicks.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Tick values for a symlog domain, spaced evenly down the axis rather than
+ * evenly across the scores.
+ *
+ * The domain endpoints are always ticks: symlog's whole point is that the small
+ * end stays legible, and both ends of an autoscaled domain are what tell a
+ * reader what the plot's extent is. Zero joins them when the domain crosses it —
+ * on a log-ratio track that is the one score with an absolute meaning, and
+ * rounding never lands on it.
+ *
+ * Rounding can put an interior tick on top of a neighbour (a domain crossing
+ * zero rounds its smallest magnitudes to something a pixel from the zero line),
+ * so a candidate closer than half a slot to a tick already kept is dropped
+ * rather than drawn over it. Endpoints and zero are kept in preference to any
+ * rounded value, which is the same order they are stated in above.
+ */
+export declare function symlogTicks(domain: readonly [number, number], constant: number, count?: number): number[];