@jbrowse/wiggle-core 5.0.0-beta.1 → 5.0.0-beta.3

package/esm/ScoreScaleMixin.d.ts

@@ -10,7 +10,7 @@ export interface ScoreScaleHost {
 /**
  * #stateModel ScoreScaleMixin
  * #category display
- * #crossCuttingMixin Score axis. Nothing — the config slots. Brings `scaleType` / `autoscaleType` / `minScore` / `maxScore` / `*Bound` / `numStdDev` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
+ * #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
  *
  * 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
@@ -26,10 +26,17 @@ export interface ScoreScaleHost {
  * — 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, because that
- * is what the dialog round-trips; `minScoreBound`/`maxScoreBound` are the
- * resolved bounds, where `undefined` means "autoscale this end". Every consumer
- * that computes a domain reads the `*Bound` pair.
+ * `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.
+ *
+ * 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<{}, {
     /**
@@ -75,6 +82,16 @@ export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IM
      * checked before this is consulted.
      */
     readonly defaultScoreDomain: [number | undefined, number | undefined];
+    /**
+     * #getter
+     * The lower bound the config really sets, `undefined` at the sentinel.
+     */
+    readonly manualMinScore: number | undefined;
+    /**
+     * #getter
+     * The upper bound the config really sets, `undefined` at the sentinel.
+     */
+    readonly manualMaxScore: number | undefined;
     /**
      * #getter
      * Resolved lower bound; `undefined` means autoscale this end.
@@ -85,6 +102,16 @@ export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IM
      * 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.
+     */
+    readonly hasManualScoreBounds: boolean;
 } & {
     /**
      * #action

package/esm/ScoreScaleMixin.js

@@ -8,7 +8,7 @@ const confNode = (self) => self;
 /**
  * #stateModel ScoreScaleMixin
  * #category display
- * #crossCuttingMixin Score axis. Nothing — the config slots. Brings `scaleType` / `autoscaleType` / `minScore` / `maxScore` / `*Bound` / `numStdDev` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
+ * #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
  *
  * 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
@@ -24,10 +24,17 @@ const confNode = (self) => self;
  * — 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, because that
- * is what the dialog round-trips; `minScoreBound`/`maxScoreBound` are the
- * resolved bounds, where `undefined` means "autoscale this end". Every consumer
- * that computes a domain reads the `*Bound` pair.
+ * `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.
+ *
+ * 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 function ScoreScaleMixin() {
     return types
@@ -88,23 +95,45 @@ export function ScoreScaleMixin() {
         get defaultScoreDomain() {
             return [undefined, undefined];
         },
+        /**
+         * #getter
+         * The lower bound the config really sets, `undefined` at the sentinel.
+         */
+        get manualMinScore() {
+            return this.minScore === Number.MIN_VALUE ? undefined : this.minScore;
+        },
+        /**
+         * #getter
+         * The upper bound the config really sets, `undefined` at the sentinel.
+         */
+        get manualMaxScore() {
+            return this.maxScore === Number.MAX_VALUE ? undefined : this.maxScore;
+        },
         /**
          * #getter
          * Resolved lower bound; `undefined` means autoscale this end.
          */
         get minScoreBound() {
-            return this.minScore === Number.MIN_VALUE
-                ? this.defaultScoreDomain[0]
-                : this.minScore;
+            return this.manualMinScore ?? this.defaultScoreDomain[0];
         },
         /**
          * #getter
          * Resolved upper bound; `undefined` means autoscale this end.
          */
         get maxScoreBound() {
-            return this.maxScore === Number.MAX_VALUE
-                ? this.defaultScoreDomain[1]
-                : this.maxScore;
+            return this.manualMaxScore ?? this.defaultScoreDomain[1];
+        },
+        /**
+         * #getter
+         * Whether the user has pinned either end, which is a different question
+         * from whether either end resolved to a number: `defaultScoreDomain` fills
+         * the 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);
         },
     }))
         .actions(self => ({

package/esm/SetMinMaxDialog.d.ts

@@ -1,7 +1,7 @@
 declare const _default: (props: {
     model: {
-        minScore: number;
-        maxScore: number;
+        manualMinScore: number | undefined;
+        manualMaxScore: number | undefined;
         scaleType: string;
         setMinScore: (arg?: number) => void;
         setMaxScore: (arg?: number) => void;

package/esm/SetMinMaxDialog.js

@@ -3,11 +3,15 @@ import { useState } from 'react';
 import { NumberTextField, SubmitDialog } from '@jbrowse/core/ui';
 import { Typography } from '@mui/material';
 import { observer } from 'mobx-react';
+// The two fields open on what the config really pins, which is the mixin's
+// `manual*` pair rather than the raw slots — the sentinel comparison is one
+// answer per end and lives there. Submitting `undefined` writes the sentinel
+// back, so an emptied field is how autoscale resumes.
 export default observer(function SetMinMaxDialog(props) {
     const { model, handleClose } = props;
-    const { minScore, maxScore, scaleType } = model;
-    const [min, setMin] = useState(minScore === Number.MIN_VALUE ? undefined : minScore);
-    const [max, setMax] = useState(maxScore === Number.MAX_VALUE ? undefined : maxScore);
+    const { manualMinScore, manualMaxScore, scaleType } = model;
+    const [min, setMin] = useState(manualMinScore);
+    const [max, setMax] = useState(manualMaxScore);
     const rangeOk = min === undefined || max === undefined || max > min;
     const logOk = !(scaleType === 'log' && min !== undefined && min <= 0);
     return (_jsxs(SubmitDialog, { open: true, title: "Set min/max score for track", submitDisabled: !rangeOk || !logOk, onCancel: handleClose, onSubmit: () => {

package/esm/YScaleGutter.d.ts

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,31 @@
+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/autoscale.js

@@ -116,16 +116,27 @@ export function computeScoreStats(summaryScoreMode, datasets) {
                 !overlaps(featurePositions[i * 2], featurePositions[i * 2 + 1], visStart, visEnd)) {
                 continue;
             }
-            min = Math.min(min, minScores[i]);
-            max = Math.max(max, maxScores[i]);
+            // Non-finite scores are skipped rather than folded in: a wig file may
+            // carry a NaN, and one of them poisons min/max and mean alike, collapsing
+            // the whole domain to the [0, 1] stub the callers fall back to.
+            const lo = minScores[i];
+            if (Number.isFinite(lo)) {
+                min = Math.min(min, lo);
+            }
+            const hi = maxScores[i];
+            if (Number.isFinite(hi)) {
+                max = Math.max(max, hi);
+            }
             // Mean/stddev always use featureScores (the average) regardless of
             // summaryScoreMode; min/max for the domain bounds come from the mode-
             // selected arrays above. Intentional: sd-based autoscale centers on the
             // average-value distribution even in whiskers/min/max summary modes.
             const avg = featureScores[i];
-            sum += avg;
-            sumSq += avg * avg;
-            count++;
+            if (Number.isFinite(avg)) {
+                sum += avg;
+                sumSq += avg * avg;
+                count++;
+            }
         }
     }
     if (count === 0 || !Number.isFinite(min) || !Number.isFinite(max)) {

package/esm/index.d.ts

@@ -27,6 +27,7 @@ export { makeAutoscaleTypeSubMenu, makeCrossHatchItem, makeScaleTypeSubMenu, mak
 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';

package/esm/index.js

@@ -19,6 +19,7 @@ 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';

package/esm/pointMarker.d.ts

@@ -1,3 +1,3 @@
-import type { Ctx2D } from '@jbrowse/core/util/paintLayer';
+import type { MarkContext2D } from '@jbrowse/render-core/marks';
 export declare const SMALL_POINT_MAX_DIAMETER_PX = 3;
-export declare function appendPointMarker(ctx: Ctx2D, cx: number, y: number, diameter: number): void;
+export declare function appendPointMarker(ctx: MarkContext2D, cx: number, y: number, diameter: number): void;

package/esm/pointMarker.js

@@ -1,27 +1,18 @@
-import { crispSquareTopLeftPx } from '@jbrowse/render-core/shaders/pointGlyph';
+import { appendGlyph } from '@jbrowse/render-core/marks/glyphPaint';
 import { SMALL_POINT_MAX_DIAMETER } from '@jbrowse/render-core/shaders/pointGlyphConsts';
+import { GLYPH_DISC } from '@jbrowse/render-core/shaders/pointMarkConsts';
 // At/below a 3px diameter an antialiased disc reads as a blurry blob, so scatter
 // points draw as a crisp filled square below this threshold and an AA disc
 // above it. The value comes from pointGlyph.slang via `//! export-consts`, so
 // the two backends can't disagree about where the square/disc split is; the
 // alias keeps this module's long-standing public name.
 export const SMALL_POINT_MAX_DIAMETER_PX = SMALL_POINT_MAX_DIAMETER;
-// Append one scatter point marker to the current path, centered on (cx, y): a
-// crisp filled square at/below SMALL_POINT_MAX_DIAMETER_PX, else an antialiased
-// disc. Shared by the wiggle scatter and GWAS Manhattan Canvas2D paths so the
-// square/disc threshold can't drift between them or from the shader. The caller
-// owns ctx.beginPath()/ctx.fill() so many markers batch into one fill.
+// Append one scatter point marker to the current path, centered on (cx, y): the
+// `point` shape's disc glyph, which is a crisp filled square at/below
+// SMALL_POINT_MAX_DIAMETER_PX and an antialiased disc above it. Wiggle's
+// scatter mode draws only that one glyph, so this is the shape's painter
+// reached at a name that predates it. The caller owns
+// ctx.beginPath()/ctx.fill() so many markers batch into one fill.
 export function appendPointMarker(ctx, cx, y, diameter) {
-    const radius = diameter / 2;
-    if (diameter <= SMALL_POINT_MAX_DIAMETER_PX) {
-        // Snap the top-left to the pixel grid (round-half-up) so the crisp square's
-        // fill lands on whole pixels instead of AA-blurring across columns/rows.
-        // `crispSquareTopLeftPx` is generated from pointGlyph.slang (adr-051), so
-        // this is the shader's snap rather than a re-derivation of it.
-        ctx.rect(crispSquareTopLeftPx(cx, diameter), crispSquareTopLeftPx(y, diameter), diameter, diameter);
-    }
-    else {
-        ctx.moveTo(cx + radius, y);
-        ctx.arc(cx, y, radius, 0, Math.PI * 2);
-    }
+    appendGlyph(ctx, GLYPH_DISC, cx, y, diameter);
 }

package/esm/scoreMenuItems.d.ts

@@ -3,10 +3,11 @@ import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 export interface ScoreScaleModel extends IStateTreeNode {
     scaleType: string;
     autoscaleType: string;
-    minScore: number;
-    maxScore: number;
+    manualMinScore: number | undefined;
+    manualMaxScore: number | undefined;
     minScoreBound: number | undefined;
     maxScoreBound: number | undefined;
+    hasManualScoreBounds: boolean;
     setScaleType: (v: string) => void;
     setAutoscale: (v?: string) => void;
     setMinScore: (n?: number) => void;

package/esm/scoreMenuItems.js

@@ -29,21 +29,19 @@ export function makeAutoscaleTypeSubMenu(self, options = DEFAULT_AUTOSCALE_OPTIO
         }),
     };
 }
-// 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 };
-}
+// Showing the range in the label is how the menu says a fixed bound is in force
+// — otherwise an autoscale-type radio still reads as checked while a manual
+// bound silently overrides it. So it is the PINNED pair that is shown, with
+// `auto` for the end nobody pinned. A display overriding `defaultScoreDomain`
+// resolves both ends to numbers with nothing configured: asking the resolved
+// pair captioned every GC content track "(0 – 1)", and once one end was really
+// set it printed the other end's default beside it, in the one place the user
+// looks to find out what they have pinned.
 export function makeSetMinMaxScoreItem(self) {
-    const { min, max, hasManual } = resolveScoreBounds(self);
+    const { manualMinScore, manualMaxScore } = self;
     return {
-        label: hasManual
-            ? `Set min/max score (${min ?? 'auto'} – ${max ?? 'auto'})...`
+        label: self.hasManualScoreBounds
+            ? `Set min/max score (${manualMinScore ?? 'auto'} – ${manualMaxScore ?? 'auto'})...`
             : 'Set min/max score...',
         onClick: () => {
             getDialogHost(self).queueDialog(handleClose => [
@@ -95,9 +93,7 @@ export function makeScoreSubMenu(self, opts = {}) {
             ...(scaleType ? [makeScaleTypeSubMenu(self)] : []),
             ...(autoscale ? [makeAutoscaleTypeSubMenu(self, autoscaleOptions)] : []),
             makeSetMinMaxScoreItem(self),
-            ...(resolveScoreBounds(self).hasManual
-                ? [makeClearMinMaxScoreItem(self)]
-                : []),
+            ...(self.hasManualScoreBounds ? [makeClearMinMaxScoreItem(self)] : []),
             ...trailingItems,
         ],
     };

package/esm/transferables.js

@@ -12,7 +12,7 @@
 // per-result Set would list a shared buffer twice.
 //
 // Aliasing the adapter's own arrays here as well, rather than copying them, is
-// costed and declined in agent-docs/reference/REJECTED_IDEAS.md: it retains 20
+// costed and declined in agent-docs/architecture-decision-records/: it retains 20
 // bytes a feature on the main thread where copying retains 12.
 export function collectWiggleTransferables(results) {
     const buffers = new Set();

package/esm/visibleStatsDomain.d.ts

@@ -17,7 +17,7 @@ export interface VisibleEntry<T> {
  * `coarseDynamicBlocks`: over the empty initial coarse list every walker below
  * yields no entries, and no entries is not a stale domain but the caller's
  * `[0, 1]` fallback — a bigwig line track drew blank and a density track solid.
- * ARCHITECTURE.md, "Every fetch autorun runs on the leading edge".
+ * reference/FETCH_SKELETON.md, "Every fetch autorun runs on the leading edge".
  */
 export interface SettledBlocksView {
     initialized: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/wiggle-core",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.3",
   "type": "module",
   "description": "Shared scale and autoscale utilities for wiggle and coverage displays",
   "keywords": [
@@ -29,12 +29,12 @@
   ],
   "dependencies": {
     "@jbrowse/mobx-state-tree": "^6.5.1",
-    "@mui/icons-material": "^9.3.1",
-    "@mui/material": "^9.3.1",
+    "@mui/icons-material": "^9.4.0",
+    "@mui/material": "^9.4.0",
     "mobx-react": "^10.0.2",
-    "@jbrowse/display-kit": "^5.0.0-beta.1",
-    "@jbrowse/core": "^5.0.0-beta.1",
-    "@jbrowse/render-core": "^5.0.0-beta.1"
+    "@jbrowse/core": "^5.0.0-beta.3",
+    "@jbrowse/render-core": "^5.0.0-beta.3",
+    "@jbrowse/display-kit": "^5.0.0-beta.3"
   },
   "peerDependencies": {
     "react": ">=19.0.0"