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

package/esm/ScoreScaleMixin.d.ts

@@ -1,4 +1,5 @@
 import type { ScoreAxisConfigModel } from './scoreAxisConfigSchemaFields.ts';
+import type { ValueScale, YAxis } from '@jbrowse/display-ui';
 /**
  * The whole of what `ScoreScaleMixin` needs a composing display to be. Exported
  * because it is the mixin's contract and `ScoreScaleMixin.test.ts` pins it:
@@ -34,11 +35,29 @@ export interface ScoreScaleHost {
  * 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.
+ *
  * 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.
  */
 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;
     /**
      * #getter
      */
@@ -112,6 +131,22 @@ export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IM
      * there is a row that does nothing and never goes away.
      */
     readonly hasManualScoreBounds: boolean;
+    /**
+     * #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
+     * 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.
+     */
+    readonly axes: YAxis[];
 } & {
     /**
      * #action

package/esm/ScoreScaleMixin.js

@@ -1,5 +1,6 @@
 import { getConf, setConf } from '@jbrowse/core/configuration';
 import { types } from '@jbrowse/mobx-state-tree';
+import { computeYTicks } from './computeYTicks.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
@@ -32,6 +33,12 @@ const confNode = (self) => self;
  * 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.
+ *
  * 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.
@@ -40,11 +47,23 @@ export function ScoreScaleMixin() {
     return types
         .model('ScoreScaleMixin', {})
         .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;
+        },
         /**
          * #getter
          */
         get scaleType() {
-            return getConf(confNode(self), 'scaleType');
+            return (this.declaredValueScale?.scaleType ??
+                getConf(confNode(self), 'scaleType'));
         },
         /**
          * #getter
@@ -100,6 +119,10 @@ export function ScoreScaleMixin() {
          * The lower bound the config really sets, `undefined` at the sentinel.
          */
         get manualMinScore() {
+            const declared = this.declaredValueScale?.domain?.[0];
+            if (declared !== undefined) {
+                return declared;
+            }
             return this.minScore === Number.MIN_VALUE ? undefined : this.minScore;
         },
         /**
@@ -107,6 +130,10 @@ export function ScoreScaleMixin() {
          * The upper bound the config really sets, `undefined` at the sentinel.
          */
         get manualMaxScore() {
+            const declared = this.declaredValueScale?.domain?.[1];
+            if (declared !== undefined) {
+                return declared;
+            }
             return this.maxScore === Number.MAX_VALUE ? undefined : this.maxScore;
         },
         /**
@@ -135,6 +162,39 @@ export function ScoreScaleMixin() {
         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 }] : [];
+            });
+        },
     }))
         .actions(self => ({
         /**

package/esm/computeYTicks.d.ts

@@ -1,4 +1,4 @@
-import type { YScaleTicks } from './yScaleTicks.ts';
+import type { YScaleTicks } from '@jbrowse/display-ui';
 export declare function computeYTicks(opts: {
     height: number;
     domain: [number, number] | number[] | undefined;

package/esm/computeYTicks.js

@@ -1,6 +1,5 @@
-import { YSCALEBAR_LABEL_OFFSET } from './constants.js';
+import { YSCALEBAR_LABEL_OFFSET, axisPlotBox } from '@jbrowse/display-ui';
 import { getScale } from './scale.js';
-import { axisPlotBox } from './yScaleTicks.js';
 // Builds Y-axis tick positions for a wiggle-family display: tick values come
 // from d3's scale.ticks(4) at normal heights, or fall back to the domain
 // endpoints for short tracks / when the user opts into minimal ticks.

package/esm/constants.d.ts

@@ -1,2 +1 @@
-export declare const YSCALEBAR_LABEL_OFFSET = 5;
-export declare const ONSCREEN_AXIS_LEFT_PX = 50;
+export { YSCALEBAR_LABEL_OFFSET } from '@jbrowse/display-ui/yAxisConstants';

package/esm/constants.js

@@ -1,10 +1 @@
-// Vertical inset the single-wiggle family reserves above and below the plot so
-// the top/bottom y-axis labels aren't clipped. Lives in its own module because
-// both index.ts (which re-exports computeYTicks) and computeYTicks.ts need it —
-// importing it from index.ts would close a cycle.
-export const YSCALEBAR_LABEL_OFFSET = 5;
-// Left indent of the on-screen y-axis overlay (single-wiggle / manhattan) and of
-// multi-wiggle's per-row scalebars. The axis is right-oriented on screen, so its
-// labels grow into the plot from here; the indent keeps them clear of the track
-// label. Export uses its own anchor (the content left edge).
-export const ONSCREEN_AXIS_LEFT_PX = 50;
+export { YSCALEBAR_LABEL_OFFSET } from '@jbrowse/display-ui/yAxisConstants';

package/esm/displayModel.d.ts

@@ -1,7 +1,7 @@
 import type { WiggleDataResult } from './dataTypes.ts';
 import type { WiggleRenderingBackend } from './renderingBackendTypes.ts';
-import type { YScaleTicks } from './yScaleTicks.ts';
 import type { RegionHost } from '@jbrowse/display-kit/regionHost';
+import type { YScaleTicks } from '@jbrowse/display-ui';
 import type { DisplayPhase } from '@jbrowse/render-core/displayPhase';
 import type { RenderLifecycleModel } from '@jbrowse/render-core/useRenderingBackend';
 export interface WiggleGpuDisplayModel<TRenderingBackend = WiggleRenderingBackend, TData = WiggleDataResult> extends RenderLifecycleModel<TRenderingBackend> {

package/esm/index.d.ts

@@ -7,15 +7,12 @@ export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormaliz
 export type { WiggleScaleType } from './normalize.ts';
 export { autoscaleDomainFromStats, computeAutoscaleDomain, computeScoreStats, domainFromStats, getEffectiveScores, } from './autoscale.ts';
 export type { Dataset, FeatureArrays, ScoreStats } from './autoscale.ts';
-export { ONSCREEN_AXIS_LEFT_PX, YSCALEBAR_LABEL_OFFSET } from './constants.ts';
+export { AXIS_GUTTER_WIDTH_PX, AxisGutter, CrossHatchLines, CrossHatches, SCORE_CAPTION_HEIGHT, ScoreDomainCaption, ScoreRuleLines, ScoreRules, YSCALEBAR_LABEL_OFFSET, YScaleBar, YScaleBarOverlay, axisDrawn, axisPlotBox, clampStrokeInsideAxis, scoreToAxisY, } from '@jbrowse/display-ui';
+export type { ValueScale, YAxis, YScaleTicks } from '@jbrowse/display-ui';
 export { computeYTicks } from './computeYTicks.ts';
 export { resolveRenderState } from './resolveRenderState.ts';
 export { visibleStatsDomain } from './visibleStatsDomain.ts';
 export type { SettledBlocksView, VisibleEntry, VisibleStatsDomainSpec, } from './visibleStatsDomain.ts';
-export { AXIS_GUTTER_WIDTH_PX, axisPlotBox, clampStrokeInsideAxis, leftAxisSpineX, scoreToAxisY, } from './yScaleTicks.ts';
-export type { YScaleTicks } from './yScaleTicks.ts';
-export { CrossHatchLines, default as CrossHatches } from './CrossHatches.tsx';
-export { ScoreRuleLines, default as ScoreRules } from './ScoreRules.tsx';
 export { parseScoreRules, scoreRuleMarks, widenRangeToRules, } from './scoreRuleMarks.ts';
 export type { ScoreRule, ScoreRuleMark } from './scoreRuleMarks.ts';
 export { makeResolutionSubMenuItem } from './ResolutionStepper.tsx';
@@ -26,9 +23,6 @@ export { DEFAULT_AUTOSCALE_OPTIONS } from './autoscale.ts';
 export { makeAutoscaleTypeSubMenu, makeCrossHatchItem, makeScaleTypeSubMenu, makeScoreSubMenu, makeSetMinMaxScoreItem, } from './scoreMenuItems.ts';
 export type { ScoreScaleModel } from './scoreMenuItems.ts';
 export { ScoreScaleMixin } from './ScoreScaleMixin.ts';
-export { default as YScaleBar } from './YScaleBar.tsx';
-export { SvgYScaleGutter, default as YScaleGutter } from './YScaleGutter.tsx';
-export { default as YScaleBarOverlay } from './YScaleBarOverlay.tsx';
 export { MIN_FILL_WIDTH_PX, NO_PREV_START, RENDERING_TYPE_DENSITY, RENDERING_TYPE_LINE, RENDERING_TYPE_LINE_CENTER, RENDERING_TYPE_SCATTER, RENDERING_TYPE_XYPLOT, } from './renderingBackendTypes.ts';
 export type { SourceRenderData, WiggleGPURenderState, WiggleRenderingBackend, WiggleRenderingType, } from './renderingBackendTypes.ts';
 export type { SourceInfo, WiggleDataResult, WiggleFeatureArrays, WiggleSourceData, } from './dataTypes.ts';

package/esm/index.js

@@ -3,13 +3,13 @@ export { getNiceDomain, getNiceScale, getScale } from './scale.js';
 export { toP } from './formatNumber.js';
 export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, resolveSymlogConstant, scaleTypeFromString, } from './normalize.js';
 export { autoscaleDomainFromStats, computeAutoscaleDomain, computeScoreStats, domainFromStats, getEffectiveScores, } from './autoscale.js';
-export { ONSCREEN_AXIS_LEFT_PX, YSCALEBAR_LABEL_OFFSET } from './constants.js';
+// The y-axis primitives live in `@jbrowse/display-ui`, where the chrome
+// places them for any display declaring `valueScales`; re-exported here so
+// their published names hold.
+export { AXIS_GUTTER_WIDTH_PX, AxisGutter, CrossHatchLines, CrossHatches, SCORE_CAPTION_HEIGHT, ScoreDomainCaption, ScoreRuleLines, ScoreRules, YSCALEBAR_LABEL_OFFSET, YScaleBar, YScaleBarOverlay, axisDrawn, axisPlotBox, clampStrokeInsideAxis, scoreToAxisY, } from '@jbrowse/display-ui';
 export { computeYTicks } from './computeYTicks.js';
 export { resolveRenderState } from './resolveRenderState.js';
 export { visibleStatsDomain } from './visibleStatsDomain.js';
-export { AXIS_GUTTER_WIDTH_PX, axisPlotBox, clampStrokeInsideAxis, leftAxisSpineX, scoreToAxisY, } from './yScaleTicks.js';
-export { CrossHatchLines, default as CrossHatches } from './CrossHatches.js';
-export { ScoreRuleLines, default as ScoreRules } from './ScoreRules.js';
 export { parseScoreRules, scoreRuleMarks, widenRangeToRules, } from './scoreRuleMarks.js';
 export { makeResolutionSubMenuItem } from './ResolutionStepper.js';
 export { makeScatterPointSizeMenuItem } from './pointSizeMenu.js';
@@ -18,9 +18,6 @@ export { default as SetMinMaxDialog } from './SetMinMaxDialog.js';
 export { DEFAULT_AUTOSCALE_OPTIONS } from './autoscale.js';
 export { makeAutoscaleTypeSubMenu, makeCrossHatchItem, makeScaleTypeSubMenu, makeScoreSubMenu, makeSetMinMaxScoreItem, } from './scoreMenuItems.js';
 export { ScoreScaleMixin } from './ScoreScaleMixin.js';
-export { default as YScaleBar } from './YScaleBar.js';
-export { SvgYScaleGutter, default as YScaleGutter } from './YScaleGutter.js';
-export { default as YScaleBarOverlay } from './YScaleBarOverlay.js';
 export { MIN_FILL_WIDTH_PX, NO_PREV_START, RENDERING_TYPE_DENSITY, RENDERING_TYPE_LINE, RENDERING_TYPE_LINE_CENTER, RENDERING_TYPE_SCATTER, RENDERING_TYPE_XYPLOT, } from './renderingBackendTypes.js';
 export {} from './displayModel.js';
 export { collectWiggleTransferables } from './transferables.js';

package/esm/pointSizeMenu.d.ts

@@ -1,13 +1,14 @@
-import type { ConfigModelForFields, ResolvableDisplay } from '@jbrowse/core/configuration';
+import type { ConfigModelForFields } from '@jbrowse/core/configuration';
 import type { MenuItem } from '@jbrowse/core/ui';
 export declare function makeScatterPointSizeMenuItem(self: {
     scatterPointSize: number;
     setScatterPointSize: (n?: number) => void;
-} & ResolvableDisplay<ConfigModelForFields<{
-    scatterPointSize: {
-        type: 'maybeNumber';
-        promotedBase: number;
-    };
-}>>, opts: {
+    configuration: ConfigModelForFields<{
+        scatterPointSize: {
+            type: 'number';
+            defaultValue: number;
+        };
+    }>;
+}, opts: {
     label: string;
 }): MenuItem;

package/esm/pointSizeMenu.js

@@ -1,16 +1,15 @@
-import { makePromotableSizeMenu } from '@jbrowse/core/ui';
+import { getSlotDefinition } from '@jbrowse/core/configuration';
+import { makeSizeMenu } from '@jbrowse/core/ui';
 // Wires a display's shared `scatterPointSize`/`setScatterPointSize` (from
-// WiggleScoreConfigMixin) to makePromotableSizeMenu. Used by both the wiggle
-// scatter and GWAS Manhattan track menus so the slider/reset/pin behavior can't
-// drift. The `scatterPointSize` slot is promotable, so the row carries the
-// "default for all tracks of this type" pin.
+// WiggleScoreConfigMixin) to makeSizeMenu. Used by both the wiggle scatter and
+// GWAS Manhattan track menus so the slider/reset behavior can't drift.
 export function makeScatterPointSizeMenuItem(self, opts) {
-    return makePromotableSizeMenu({
+    return makeSizeMenu({
         label: opts.label,
         title: 'Point size',
-        display: self,
-        slot: 'scatterPointSize',
         getValue: () => self.scatterPointSize,
+        isDefault: self.scatterPointSize ===
+            getSlotDefinition(self.configuration, 'scatterPointSize').defaultValue,
         onChange: n => {
             self.setScatterPointSize(n);
         },

package/esm/scoreRuleMarks.d.ts

@@ -1,3 +1,4 @@
+import type { ScoreRuleMark } from '@jbrowse/display-ui';
 /**
  * #api
  * One horizontal rule across a score plot, at a score the user chose.
@@ -14,9 +15,7 @@ export interface ScoreRule {
     label?: string;
     color?: string;
 }
-export interface ScoreRuleMark extends ScoreRule {
-    y: number;
-}
+export type { ScoreRuleMark } from '@jbrowse/display-ui';
 /**
  * #api
  * Screen y for each rule that falls inside the plotted domain, dropping the

package/esm/scoreRuleMarks.js

@@ -1,4 +1,4 @@
-import { clampStrokeInsideAxis, scoreToAxisY } from './yScaleTicks.js';
+import { clampStrokeInsideAxis, scoreToAxisY } from '@jbrowse/display-ui';
 /**
  * #api
  * Screen y for each rule that falls inside the plotted domain, dropping the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/wiggle-core",
-  "version": "5.0.0-beta.4",
+  "version": "5.0.0-beta.8",
   "type": "module",
   "description": "Shared scale and autoscale utilities for wiggle and coverage displays",
   "keywords": [
@@ -32,9 +32,10 @@
     "@mui/icons-material": "^9.4.0",
     "@mui/material": "^9.4.0",
     "mobx-react": "^10.0.2",
-    "@jbrowse/display-kit": "^5.0.0-beta.4",
-    "@jbrowse/core": "^5.0.0-beta.4",
-    "@jbrowse/render-core": "^5.0.0-beta.4"
+    "@jbrowse/display-kit": "^5.0.0-beta.8",
+    "@jbrowse/core": "^5.0.0-beta.8",
+    "@jbrowse/display-ui": "^5.0.0-beta.8",
+    "@jbrowse/render-core": "^5.0.0-beta.8"
   },
   "peerDependencies": {
     "react": ">=19.0.0"

package/esm/CrossHatches.d.ts

@@ -1,11 +0,0 @@
-import type { YScaleTicks } from './yScaleTicks.ts';
-export declare function CrossHatchLines({ ticks, width, offsetY, }: {
-    ticks: YScaleTicks;
-    width: number;
-    offsetY?: number;
-}): import("react").JSX.Element;
-export default function CrossHatches({ ticks, width, height, }: {
-    ticks: YScaleTicks;
-    width: number;
-    height: number;
-}): import("react").JSX.Element;

package/esm/CrossHatches.js

@@ -1,32 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { clampStrokeInsideAxis } from './yScaleTicks.js';
-// Bare <line> set for the Y-scale tick guide lines, no wrapping <svg>. Shared by
-// the absolutely-positioned on-screen CrossHatches overlay and the flat SVG
-// export (single- and multi-wiggle), so the three can't drift. `offsetY` shifts
-// every line down for per-row rendering in multi-wiggle.
-export function CrossHatchLines({ ticks, width, offsetY = 0, }) {
-    return (_jsx(_Fragment, { children: ticks.items.map(({ value, y }) => {
-            // Same clamp the axis ticks take, so a guide line and the tick it
-            // belongs to can't disagree at the bottom edge — where, in multi-wiggle,
-            // "one pixel lower" is the next sample's row. Only that edge moves; the
-            // guide lines don't crispen to a half pixel the way the axis does.
-            const lineY = offsetY + clampStrokeInsideAxis(y, ticks.yBottom);
-            return (_jsx("line", { x1: 0, x2: width, y1: lineY, y2: lineY, stroke: "rgb(200,200,200)", 
-                // a separate stroke-opacity attribute (not baked into an rgba()
-                // string) survives the SVG export, whose renderToStaticMarkup strips
-                // rgba() alpha
-                strokeOpacity: 0.8, strokeWidth: 1 }, `${value}-${y}`));
-        }) }));
-}
-// Horizontal guide lines at each Y-scale tick. Pointer-events disabled so
-// the underlying canvas still receives mouse events.
-export default function CrossHatches({ ticks, width, height, }) {
-    return (_jsx("svg", { style: {
-            position: 'absolute',
-            top: 0,
-            left: 0,
-            pointerEvents: 'none',
-            height,
-            width,
-        }, children: _jsx(CrossHatchLines, { ticks: ticks, width: width }) }));
-}

package/esm/ScoreRules.d.ts

@@ -1,11 +0,0 @@
-import type { ScoreRuleMark } from './scoreRuleMarks.ts';
-export declare function ScoreRuleLines({ marks, width, offsetY, }: {
-    marks: ScoreRuleMark[];
-    width: number;
-    offsetY?: number;
-}): import("react").JSX.Element;
-export default function ScoreRules({ marks, width, height, }: {
-    marks: ScoreRuleMark[];
-    width: number;
-    height: number;
-}): import("react").JSX.Element;

package/esm/ScoreRules.js

@@ -1,37 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { usePalette } from '@jbrowse/core/ui/PaletteContext';
-const DEFAULT_RULE_COLOR = 'rgb(120,120,120)';
-// Bare marks, no wrapping <svg>, so the on-screen overlay and the SVG export
-// draw the same elements from the same y. Same split as CrossHatchLines.
-export function ScoreRuleLines({ marks, width, offsetY = 0, }) {
-    // A caption sits over the plot, not beside it, so it needs the halo the tick
-    // labels next to it already draw (YScaleBar) — without one a rule crossing
-    // filled bars captions itself in grey on the fill and cannot be read. From
-    // the palette rather than a hardcoded white, which inverts into a glare in
-    // dark mode.
-    const haloColor = usePalette().background.default;
-    return (_jsx(_Fragment, { children: marks.map(({ value, label, color, y }) => {
-            const lineY = offsetY + y;
-            const stroke = color ?? DEFAULT_RULE_COLOR;
-            return (_jsxs("g", { children: [_jsx("line", { x1: 0, x2: width, y1: lineY, y2: lineY, stroke: stroke, 
-                        // separate attribute rather than an rgba() string: the SVG
-                        // export's renderToStaticMarkup strips rgba() alpha
-                        strokeOpacity: 0.9, strokeWidth: 1, strokeDasharray: "4 3" }), label ? (_jsx("text", { x: width - 4, y: lineY - 2, textAnchor: "end", fontSize: 10, 
-                        // full alpha, unlike the line: 0.9 is there to let the rule
-                        // recede into the plot, and a caption that has to be read wants
-                        // the opposite
-                        fill: stroke, stroke: haloColor, strokeWidth: 2.5, paintOrder: "stroke", children: label })) : null] }, `${value}-${y}`));
-        }) }));
-}
-// Pointer-events disabled so the canvas underneath still gets mouse events,
-// matching CrossHatches.
-export default function ScoreRules({ marks, width, height, }) {
-    return (_jsx("svg", { style: {
-            position: 'absolute',
-            top: 0,
-            left: 0,
-            pointerEvents: 'none',
-            height,
-            width,
-        }, children: _jsx(ScoreRuleLines, { marks: marks, width: width }) }));
-}

package/esm/YScaleBar.d.ts

@@ -1,6 +0,0 @@
-import type { YScaleTicks } from './yScaleTicks.ts';
-export default function YScaleBar({ ticks, orientation, insetLabels, }: {
-    ticks: YScaleTicks | undefined;
-    orientation?: 'left' | 'right';
-    insetLabels?: boolean;
-}): import("react").JSX.Element | null;

package/esm/YScaleBar.js

@@ -1,46 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { usePalette } from '@jbrowse/core/ui/PaletteContext';
-import { clampStrokeInsideAxis } from './yScaleTicks.js';
-// Not an `observer`, and deliberately: there is nothing here to observe. Every
-// caller already reads `model.ticks` inside its own observer and hands the
-// resolved plain object down, and `usePalette` is a React context, not MobX.
-// Wrapping it anyway allocated a Reaction per instance — multi-wiggle renders
-// one per sample row, on screen as well as in export — and, per CLAUDE.md, put
-// the component out of `babel-plugin-react-compiler`'s reach, so it got neither
-// the MobX tracking it doesn't need nor the memoization it does. Its sibling
-// `CrossHatchLines`, consuming the same ticks, is already plain.
-// Half the vertical space a 10px label needs, halo included: digits reach about
-// 3.6px above the centered baseline and the 2.5px-wide background stroke another
-// 1.25px past that.
-const LABEL_HALF_HEIGHT_PX = 5;
-export default function YScaleBar({ ticks, orientation, insetLabels, }) {
-    const palette = usePalette();
-    if (!ticks) {
-        return null;
-    }
-    const { items, yTop, yBottom } = ticks;
-    const bg = palette.background.default;
-    const fg = palette.text.primary;
-    const isLeft = orientation !== 'right';
-    const k = isLeft ? -1 : 1;
-    const tickLength = 6;
-    // Crispen to `y + 0.5` so each 1px stroke fills one pixel instead of
-    // straddling two, then clamp, which only bites at the bottom edge: there the
-    // stroke goes on the last pixel inside the box rather than the first one
-    // below it.
-    const strokeY = (y) => clampStrokeInsideAxis(y + 0.5, yBottom);
-    // The tick keeps the group transform; only the text moves off it, and only
-    // under `insetLabels` within half a label of an end. A tick is where the data
-    // is, so it never moves — the label is then drawn against the tick rather than
-    // across it, which is what any axis does at the edge of its own frame.
-    // `undefined` rather than 0 for the labels that don't move, so the markup this
-    // emits is unchanged wherever the inset doesn't apply.
-    const labelDy = (sy) => {
-        if (!insetLabels) {
-            return undefined;
-        }
-        const inset = Math.min(Math.max(sy, yTop + LABEL_HALF_HEIGHT_PX), yBottom - LABEL_HALF_HEIGHT_PX);
-        return inset === sy ? undefined : inset - sy;
-    };
-    return (_jsxs("g", { fontSize: 10, textAnchor: isLeft ? 'end' : 'start', stroke: fg, strokeWidth: 1, children: [_jsx("path", { fill: "none", d: `M${k * tickLength} ${strokeY(yTop)}H0.5V${strokeY(yBottom)}H${k * tickLength}` }), items.map(({ value, y, label }) => (_jsxs("g", { transform: `translate(0,${strokeY(y)})`, children: [_jsx("line", { x2: k * tickLength }), _jsx("text", { stroke: bg, strokeWidth: 2.5, paintOrder: "stroke", fill: fg, y: labelDy(strokeY(y)), dy: "0.32em", x: k * 9, children: label ?? value })] }, `${value}-${y}`)))] }));
-}

package/esm/YScaleBarOverlay.d.ts

@@ -1,6 +0,0 @@
-import type { YScaleTicks } from './yScaleTicks.ts';
-export default function YScaleBarOverlay({ ticks, height, width, }: {
-    ticks: YScaleTicks;
-    height: number;
-    width: number;
-}): import("react").JSX.Element;

package/esm/YScaleBarOverlay.js

@@ -1,24 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import YScaleBar from './YScaleBar.js';
-import { ONSCREEN_AXIS_LEFT_PX } from './constants.js';
-// Y-axis tick labels positioned absolutely, indented from the track's left edge
-// so a right-oriented axis reads inside the plot. The SVG export instead anchors
-// a left-oriented axis at the content edge, putting the labels in the export
-// margin — see WiggleFamilySvgFrame.
-//
-// `width` is the track's, not a fixed strip: an <svg> clips to its own box, and
-// the hardcoded 70px this used to carry silently truncated any label past ~11
-// characters. Not hypothetical on a log axis — a domain under 1 nices to
-// negative powers of two, so `0.0009765625` is an ordinary tick on a
-// mappability track and the labels grow exactly where the numbers get small.
-// The track's own right edge is the real boundary.
-export default function YScaleBarOverlay({ ticks, height, width, }) {
-    return (_jsx("svg", { style: {
-            position: 'absolute',
-            top: 0,
-            left: ONSCREEN_AXIS_LEFT_PX,
-            pointerEvents: 'none',
-            height,
-            width: Math.max(0, width - ONSCREEN_AXIS_LEFT_PX),
-        }, children: _jsx(YScaleBar, { ticks: ticks, orientation: "right" }) }));
-}

package/esm/YScaleGutter.d.ts

@@ -1,27 +0,0 @@
-import type { YScaleTicks } from './yScaleTicks.ts';
-/**
- * A left-oriented Y-axis in the shared gutter, at a band's top-left corner on
- * screen. Every stacked band that carries one — the alignments coverage band,
- * MAF's coverage and conservation bands — draws it through this, and its export
- * emits `SvgYScaleGutter` with the same spine placement, so the on-screen and
- * exported axes cannot drift apart.
- *
- * `left` is the gutter's own left edge; the spine is placed inside the gutter
- * from there, so a caller positioning the box does not also offset the spine.
- */
-export default function YScaleGutter({ top, left, height, ticks, }: {
-    top: number;
-    left?: number;
-    height: number;
-    ticks: YScaleTicks;
-}): import("react").JSX.Element;
-/**
- * The gutter's `<g>` on its own, for a caller that already owns an `<svg>` —
- * the SVG export, whose bands are positioned by the enclosing document. `left`
- * is the gutter's left edge in that document.
- */
-export declare function SvgYScaleGutter({ left, y, ticks, }: {
-    left?: number;
-    y: number;
-    ticks: YScaleTicks;
-}): import("react").JSX.Element;

package/esm/YScaleGutter.js

@@ -1,31 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import YScaleBar from './YScaleBar.js';
-import { AXIS_GUTTER_WIDTH_PX, leftAxisSpineX } from './yScaleTicks.js';
-/**
- * A left-oriented Y-axis in the shared gutter, at a band's top-left corner on
- * screen. Every stacked band that carries one — the alignments coverage band,
- * MAF's coverage and conservation bands — draws it through this, and its export
- * emits `SvgYScaleGutter` with the same spine placement, so the on-screen and
- * exported axes cannot drift apart.
- *
- * `left` is the gutter's own left edge; the spine is placed inside the gutter
- * from there, so a caller positioning the box does not also offset the spine.
- */
-export default function YScaleGutter({ top, left = 0, height, ticks, }) {
-    return (_jsx("svg", { style: {
-            position: 'absolute',
-            top,
-            left,
-            pointerEvents: 'none',
-            height,
-            width: AXIS_GUTTER_WIDTH_PX,
-        }, children: _jsx(SvgYScaleGutter, { y: 0, ticks: ticks }) }));
-}
-/**
- * The gutter's `<g>` on its own, for a caller that already owns an `<svg>` —
- * the SVG export, whose bands are positioned by the enclosing document. `left`
- * is the gutter's left edge in that document.
- */
-export function SvgYScaleGutter({ left = 0, y, ticks, }) {
-    return (_jsx("g", { transform: `translate(${leftAxisSpineX(left)}, ${y})`, children: _jsx(YScaleBar, { ticks: ticks, orientation: "left" }) }));
-}

package/esm/yScaleTicks.d.ts

@@ -1,59 +0,0 @@
-export interface YScaleTicks {
-    items: {
-        value: number;
-        y: number;
-        label?: string;
-    }[];
-    yTop: number;
-    yBottom: number;
-}
-/**
- * The plot box a wiggle-family display insets inside its own height, for both
- * sides of the contract above: the renderer positions its canvas at `yTop` and
- * draws `plotHeight` tall, and the axis puts domain-max at `yTop` and
- * domain-min at `yBottom`.
- *
- * One function because the two have to agree exactly, and `height - 2 * offset`
- * spelled out at each end is how they stopped: `computeYTicks` derived its own
- * bottom as `height - offset - 1`, and every tick above it inherited a fraction
- * of that pixel.
- */
-export declare function axisPlotBox(height: number, offset?: number): {
-    yTop: number;
-    yBottom: number;
-    plotHeight: number;
-};
-/**
- * Screen y for an already-normalized ([0,1], 0 at domain-min) score. The
- * composition of {@link axisPlotBox} with a `makeScoreNormalizer` result, which
- * is what a tick at that score must land on.
- */
-export declare function scoreToAxisY(normalized: number, box: ReturnType<typeof axisPlotBox>): number;
-/**
- * Width of the gutter a left-oriented {@link YScaleBar} is drawn in, and the x
- * inside that gutter its spine goes at.
- *
- * `YScaleBar` grows its ticks and numbers *away* from the spine, so a
- * left-oriented axis has to inset its spine by the label width or the labels
- * land at negative x — which is what once put an exported coverage axis off the
- * image entirely. Both numbers live here, beside the component whose own
- * geometry (`x = ±9`, `fontSize 10`, `textAnchor: end`) is what makes them the
- * right ones: the alignments coverage axis and the MAF band axes had each
- * arrived at this same 50/45 pair independently, so a change to the labels moved
- * neither.
- *
- * An axis drawn over its own plot rather than in reserved space may narrow the
- * gutter — every px of it is a px of data hidden. Such an axis still places its
- * spine at `width - 1`, the same rule stated against its own width.
- */
-export declare const AXIS_GUTTER_WIDTH_PX = 50;
-export declare function leftAxisSpineX(gutterLeft?: number): number;
-/**
- * Keep a 1px stroke's center inside the axis box. At `yBottom` — the box's own
- * bottom edge — the stroke has to cover the pixel *above* the boundary, since
- * the one below belongs to whatever is drawn next; in multi-wiggle, where rows
- * stack edge to edge, that is literally the next sample's first row of pixels.
- * Callers pass whatever stroke center their own convention gives (the axis
- * crispens to `y + 0.5`, the guide lines don't); only the bottom edge moves.
- */
-export declare function clampStrokeInsideAxis(strokeY: number, yBottom: number): number;

package/esm/yScaleTicks.js

@@ -1,59 +0,0 @@
-import { YSCALEBAR_LABEL_OFFSET } from './constants.js';
-/**
- * The plot box a wiggle-family display insets inside its own height, for both
- * sides of the contract above: the renderer positions its canvas at `yTop` and
- * draws `plotHeight` tall, and the axis puts domain-max at `yTop` and
- * domain-min at `yBottom`.
- *
- * One function because the two have to agree exactly, and `height - 2 * offset`
- * spelled out at each end is how they stopped: `computeYTicks` derived its own
- * bottom as `height - offset - 1`, and every tick above it inherited a fraction
- * of that pixel.
- */
-export function axisPlotBox(height, offset = YSCALEBAR_LABEL_OFFSET) {
-    return {
-        yTop: offset,
-        yBottom: height - offset,
-        plotHeight: height - 2 * offset,
-    };
-}
-/**
- * Screen y for an already-normalized ([0,1], 0 at domain-min) score. The
- * composition of {@link axisPlotBox} with a `makeScoreNormalizer` result, which
- * is what a tick at that score must land on.
- */
-export function scoreToAxisY(normalized, box) {
-    return box.yTop + (1 - normalized) * box.plotHeight;
-}
-/**
- * Width of the gutter a left-oriented {@link YScaleBar} is drawn in, and the x
- * inside that gutter its spine goes at.
- *
- * `YScaleBar` grows its ticks and numbers *away* from the spine, so a
- * left-oriented axis has to inset its spine by the label width or the labels
- * land at negative x — which is what once put an exported coverage axis off the
- * image entirely. Both numbers live here, beside the component whose own
- * geometry (`x = ±9`, `fontSize 10`, `textAnchor: end`) is what makes them the
- * right ones: the alignments coverage axis and the MAF band axes had each
- * arrived at this same 50/45 pair independently, so a change to the labels moved
- * neither.
- *
- * An axis drawn over its own plot rather than in reserved space may narrow the
- * gutter — every px of it is a px of data hidden. Such an axis still places its
- * spine at `width - 1`, the same rule stated against its own width.
- */
-export const AXIS_GUTTER_WIDTH_PX = 50;
-export function leftAxisSpineX(gutterLeft = 0) {
-    return gutterLeft + AXIS_GUTTER_WIDTH_PX - YSCALEBAR_LABEL_OFFSET;
-}
-/**
- * Keep a 1px stroke's center inside the axis box. At `yBottom` — the box's own
- * bottom edge — the stroke has to cover the pixel *above* the boundary, since
- * the one below belongs to whatever is drawn next; in multi-wiggle, where rows
- * stack edge to edge, that is literally the next sample's first row of pixels.
- * Callers pass whatever stroke center their own convention gives (the axis
- * crispens to `y + 0.5`, the guide lines don't); only the bottom edge moves.
- */
-export function clampStrokeInsideAxis(strokeY, yBottom) {
-    return Math.min(strokeY, yBottom - 0.5);
-}