@jbrowse/wiggle-core 4.3.0 → 5.0.0-beta.10

package/esm/index.d.ts

@@ -1,34 +1,33 @@
-export { scoreAxisConfigSchemaFields } from './scoreAxisConfigSchemaFields.ts';
-export type { ScoreAxisConfigModel } from './scoreAxisConfigSchemaFields.ts';
+export { retiredAxisSpellings, scalesSchema, valueScaleSchema, } from './valueScaleConfigSchema.ts';
+export type { ScalesConfigSchema, ValueScaleConfigSchema, ValueScaleOptions, } from './valueScaleConfigSchema.ts';
 export { getNiceDomain, getNiceScale, getScale } from './scale.ts';
 export type { ScaleOpts } from './scale.ts';
 export { toP } from './formatNumber.ts';
-export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, resolveSymlogConstant, scaleTypeFromString, } from './normalize.ts';
-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 { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, resolveSymlogConstant, } from './normalize.ts';
+export { autoscaleDomainFromSpans, autoscaleDomainFromStats, computeAutoscaleDomain, computeScoreStats, computeSpanStats, datasetSpan, getEffectiveScores, } from './autoscale.ts';
+export type { Dataset, FeatureArrays, ScoreSpan, ScoreStats, } from './autoscale.ts';
+export { axisDrawn } from '@jbrowse/display-ui/axisPlacement';
+export { DEFAULT_RULE_COLOR, SCORE_CAPTION_HEIGHT, YSCALEBAR_LABEL_OFFSET, } from '@jbrowse/display-ui/yAxisConstants';
+export { AXIS_GUTTER_WIDTH_PX, axisPlotBox, clampStrokeInsideAxis, scoreToAxisY, } from '@jbrowse/display-ui/yScaleTicks';
+export type { ValueScale, ValueScaleRule, YAxis, YScaleTicks, } from '@jbrowse/display-ui';
 export { computeYTicks } from './computeYTicks.ts';
+export { rowLabelOffset } from './rowLabelOffset.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';
-export { makeScatterPointSizeMenuItem } from './pointSizeMenu.tsx';
-export { SMALL_POINT_MAX_DIAMETER_PX, appendPointMarker, } from './pointMarker.ts';
-export { default as SetMinMaxDialog } from './SetMinMaxDialog.tsx';
-export { DEFAULT_AUTOSCALE_OPTIONS } from './autoscale.ts';
-export { makeAutoscaleTypeSubMenu, makeCrossHatchItem, makeScaleTypeSubMenu, makeScoreSubMenu, makeSetMinMaxScoreItem, } from './scoreMenuItems.ts';
-export type { ScoreScaleModel } from './scoreMenuItems.ts';
+export { visibleStatsDomain, visibleStatsRange } from './visibleStatsDomain.ts';
+export type { SettledBlocksView, VisibleEntry, VisibleStatsDomainSpec, VisibleStatsRangeSpec, } from './visibleStatsDomain.ts';
+export { scoreRuleMarks, widenRangeToRules } from './scoreRuleMarks.ts';
+export type { ScoreRuleMark } from './scoreRuleMarks.ts';
+export { DEFAULT_POINT_DIAMETER_PX, SMALL_POINT_MAX_DIAMETER_PX, appendPointMarker, } from './pointMarker.ts';
+export { makeClipOutliersItem, AXIS_ZERO_LABEL, makeAxisZeroItem, makeCrossHatchItem, makeScaleTypeSubMenu, makeScoreSubMenu, makeSetMinMaxScoreItem, } from './scoreMenuItems.ts';
+export type { ScoreScaleModel, ScoreSubMenuOptions } from './scoreMenuItems.ts';
+export { ScoreAxisMixin } from './ScoreAxisMixin.ts';
 export { ScoreScaleMixin } from './ScoreScaleMixin.ts';
-export { default as YScaleBar } from './YScaleBar.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 { ScoreScaleHost } from './ScoreScaleMixin.ts';
+export { WiggleScoreConfigMixin, wiggleScoreConfigExtraSlots, } from './WiggleScoreConfigMixin.ts';
+export type { WiggleScoreConfigHost } from './WiggleScoreConfigMixin.ts';
+export { ScoreFieldConfigMixin } from './ScoreFieldConfigMixin.ts';
+export { DEFAULT_SCORE_FIELD, scoreFieldConfigSchemaFields, } from './scoreFieldConfigSchemaFields.ts';
+export { MAX_WIGGLE_CUTS, 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';
 export { type WiggleGpuDisplayModel } from './displayModel.ts';

package/esm/index.js

@@ -1,26 +1,28 @@
-export { scoreAxisConfigSchemaFields } from './scoreAxisConfigSchemaFields.js';
+export { retiredAxisSpellings, scalesSchema, valueScaleSchema, } from './valueScaleConfigSchema.js';
 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';
+export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, resolveSymlogConstant, } from './normalize.js';
+export { autoscaleDomainFromSpans, autoscaleDomainFromStats, computeAutoscaleDomain, computeScoreStats, computeSpanStats, datasetSpan, getEffectiveScores, } from './autoscale.js';
+// The y-axis geometry, named at its own subpaths rather than through the
+// `@jbrowse/display-ui` barrel: the barrel reaches react-dom, and reaching it
+// from here put the score math and the three config mixins behind a worker
+// stub. The components that draw the axis are `./chrome`.
+export { axisDrawn } from '@jbrowse/display-ui/axisPlacement';
+export { DEFAULT_RULE_COLOR, SCORE_CAPTION_HEIGHT, YSCALEBAR_LABEL_OFFSET, } from '@jbrowse/display-ui/yAxisConstants';
+export { AXIS_GUTTER_WIDTH_PX, axisPlotBox, clampStrokeInsideAxis, scoreToAxisY, } from '@jbrowse/display-ui/yScaleTicks';
 export { computeYTicks } from './computeYTicks.js';
+export { rowLabelOffset } from './rowLabelOffset.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';
-export { SMALL_POINT_MAX_DIAMETER_PX, appendPointMarker, } from './pointMarker.js';
-export { default as SetMinMaxDialog } from './SetMinMaxDialog.js';
-export { DEFAULT_AUTOSCALE_OPTIONS } from './autoscale.js';
-export { makeAutoscaleTypeSubMenu, makeCrossHatchItem, makeScaleTypeSubMenu, makeScoreSubMenu, makeSetMinMaxScoreItem, } from './scoreMenuItems.js';
+export { visibleStatsDomain, visibleStatsRange } from './visibleStatsDomain.js';
+export { scoreRuleMarks, widenRangeToRules } from './scoreRuleMarks.js';
+export { DEFAULT_POINT_DIAMETER_PX, SMALL_POINT_MAX_DIAMETER_PX, appendPointMarker, } from './pointMarker.js';
+export { makeClipOutliersItem, AXIS_ZERO_LABEL, makeAxisZeroItem, makeCrossHatchItem, makeScaleTypeSubMenu, makeScoreSubMenu, makeSetMinMaxScoreItem, } from './scoreMenuItems.js';
+export { ScoreAxisMixin } from './ScoreAxisMixin.js';
 export { ScoreScaleMixin } from './ScoreScaleMixin.js';
-export { default as YScaleBar } from './YScaleBar.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 { WiggleScoreConfigMixin, wiggleScoreConfigExtraSlots, } from './WiggleScoreConfigMixin.js';
+export { ScoreFieldConfigMixin } from './ScoreFieldConfigMixin.js';
+export { DEFAULT_SCORE_FIELD, scoreFieldConfigSchemaFields, } from './scoreFieldConfigSchemaFields.js';
+export { MAX_WIGGLE_CUTS, 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';
 export { DEFAULT_GAP_BREAK_MULTIPLE, gapBreakLimit } from './gapBreak.js';

package/esm/normalize.d.ts

@@ -1,13 +1,4 @@
-export type WiggleScaleType = 0 | 1 | 2;
-export declare const SCALE_TYPE_LINEAR: WiggleScaleType;
-export declare const SCALE_TYPE_LOG: WiggleScaleType;
-export declare const SCALE_TYPE_SYMLOG: WiggleScaleType;
-/**
- * #api
- * Maps the `'log'`/`'symlog'`/`'linear'` string to the numeric
- * `WiggleScaleType`.
- */
-export declare function scaleTypeFromString(scaleType: string): WiggleScaleType;
+export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, } from '@jbrowse/render-core/scoreScale';
 /**
  * #api
  * The symlog constant actually used for a domain. `0` (the config default)
@@ -22,19 +13,3 @@ export declare function scaleTypeFromString(scaleType: string): WiggleScaleType;
  * rather than hard-coded.
  */
 export declare function resolveSymlogConstant(min: number, max: number, configured: number): number;
-/**
- * #api
- * Returns a loop-hoistable function normalizing a score to [0,1].
- *
- * `symlogConstant` is only read for `SCALE_TYPE_SYMLOG`, and is expected to be
- * already resolved by {@link resolveSymlogConstant} — the shader gets the same
- * resolved number as a uniform, so the "auto" rule lives on this side only and
- * the two backends compare like for like.
- *
- * A range that is zero **or negative** normalizes everything to 0, which is the
- * rule `scoreScale.slang` spells as `range <= 0.0`. Testing `range === 0` here
- * instead let a descending domain through to a negative `1 / range`, so every
- * score saturated to 1 on this side while the shader flattened them all to 0 —
- * one view, opposite plots. `normalizeScoreParity.test.ts` sweeps the two.
- */
-export declare function makeScoreNormalizer(min: number, max: number, scaleType: WiggleScaleType, symlogConstant?: number): (score: number) => number;

package/esm/normalize.js

@@ -1,24 +1,4 @@
-import { SCALE_TYPE_LOG as GENERATED_SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG as GENERATED_SCALE_TYPE_SYMLOG, } from './wiggleRenderModes.generated.js';
-export const SCALE_TYPE_LINEAR = 0;
-// The values the `scaleType` uniform is compared against, so they are
-// wiggle.slang's own — generated in by `pnpm gen:shaders` (adr-051). LINEAR is
-// simply "neither of these".
-export const SCALE_TYPE_LOG = GENERATED_SCALE_TYPE_LOG;
-export const SCALE_TYPE_SYMLOG = GENERATED_SCALE_TYPE_SYMLOG;
-/**
- * #api
- * Maps the `'log'`/`'symlog'`/`'linear'` string to the numeric
- * `WiggleScaleType`.
- */
-export function scaleTypeFromString(scaleType) {
-    if (scaleType === 'log') {
-        return SCALE_TYPE_LOG;
-    }
-    if (scaleType === 'symlog') {
-        return SCALE_TYPE_SYMLOG;
-    }
-    return SCALE_TYPE_LINEAR;
-}
+export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, } from '@jbrowse/render-core/scoreScale';
 /**
  * #api
  * The symlog constant actually used for a domain. `0` (the config default)
@@ -39,68 +19,3 @@ export function resolveSymlogConstant(min, max, configured) {
     const magnitude = Math.max(Math.abs(min), Math.abs(max));
     return magnitude > 0 ? magnitude / 1000 : 1;
 }
-/** sign(x) * log1p(|x / c|) — the transform d3's scaleSymlog applies. */
-function symlog(x, c) {
-    return Math.sign(x) * Math.log1p(Math.abs(x / c));
-}
-/**
- * #api
- * Returns a loop-hoistable function normalizing a score to [0,1].
- *
- * `symlogConstant` is only read for `SCALE_TYPE_SYMLOG`, and is expected to be
- * already resolved by {@link resolveSymlogConstant} — the shader gets the same
- * resolved number as a uniform, so the "auto" rule lives on this side only and
- * the two backends compare like for like.
- *
- * A range that is zero **or negative** normalizes everything to 0, which is the
- * rule `scoreScale.slang` spells as `range <= 0.0`. Testing `range === 0` here
- * instead let a descending domain through to a negative `1 / range`, so every
- * score saturated to 1 on this side while the shader flattened them all to 0 —
- * one view, opposite plots. `normalizeScoreParity.test.ts` sweeps the two.
- */
-export function makeScoreNormalizer(min, max, scaleType, symlogConstant = 1) {
-    if (scaleType === SCALE_TYPE_SYMLOG) {
-        // No flooring, and no clamp of the domain away from zero: symlog is defined
-        // across the whole real line, which is the point of offering it.
-        const c = symlogConstant;
-        const tMin = symlog(min, c);
-        const tMax = symlog(max, c);
-        const tRange = tMax - tMin;
-        if (tRange <= 0) {
-            return () => 0;
-        }
-        const invRange = 1 / tRange;
-        return (score) => Math.max(0, Math.min(1, (symlog(score, c) - tMin) * invRange));
-    }
-    if (scaleType === SCALE_TYPE_LOG) {
-        // Floor at the domain's own min, not at 1. A log domain can sit entirely
-        // below 1 — a mappability track, a methylation fraction, any normalized
-        // ratio — and `getNiceDomain` deliberately keeps it there, pinning min to 1
-        // only when max > 1 (an explicit `minScore` bound can also land under 1 at
-        // any max). Flooring at 1 collapsed logMin and logMax to 0 for all of
-        // those, so `logRange === 0` and every score in the track normalized to 0:
-        // a plot flat on the baseline under an axis that, reading the same domain
-        // through d3, spread its ticks down the full height.
-        //
-        // Callers passing min = 0 — the four coverage draws, whose domain starts at
-        // no reads — still floor at 1, which is where a depth axis starts.
-        const floor = min > 0 ? min : 1;
-        const logMin = Math.log2(floor);
-        const logMax = Math.log2(Math.max(max, floor));
-        const logRange = logMax - logMin;
-        if (logRange <= 0) {
-            return () => 0;
-        }
-        const invLogRange = 1 / logRange;
-        return (score) => {
-            const logScore = Math.log2(Math.max(score, floor));
-            return Math.max(0, Math.min(1, (logScore - logMin) * invLogRange));
-        };
-    }
-    const range = max - min;
-    if (range <= 0) {
-        return () => 0;
-    }
-    const invRange = 1 / range;
-    return (score) => Math.max(0, Math.min(1, (score - min) * invRange));
-}

package/esm/pointMarker.d.ts

@@ -1,3 +1,8 @@
-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;
+/**
+ * The diameter the mark display draws points at by default,
+ * where points are the plot rather than one of wiggle's renderings.
+ */
+export declare const DEFAULT_POINT_DIAMETER_PX = 4;
+export declare function appendPointMarker(ctx: MarkContext2D, cx: number, y: number, diameter: number): void;

package/esm/pointMarker.js

@@ -1,27 +1,23 @@
-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.
+/**
+ * The diameter the mark display draws points at by default,
+ * where points are the plot rather than one of wiggle's renderings.
+ */
+export const DEFAULT_POINT_DIAMETER_PX = 4;
+// 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/pointSizeMenu.d.ts

@@ -1,13 +1,32 @@
-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: {
+/** Where a display keeps its point size: the value shown, its default, and the write. */
+export interface PointSizeAccess {
+    value: () => number;
+    defaultValue: number;
+    set: (n?: number) => void;
+}
+/**
+ * The point size a display holding `WiggleScoreConfigMixin`'s `size` slot
+ * shows and writes.
+ */
+export declare function pointSizeAccess(self: {
+    size: number;
+    setSize: (n?: number) => void;
+    configuration: ConfigModelForFields<{
+        size: {
+            type: 'number';
+            defaultValue: number;
+        };
+    }>;
+}): PointSizeAccess;
+/**
+ * A top-level submenu holding the point-size slider, or nothing where the plot
+ * draws no points, so every score plot's menu resets and clamps alike.
+ * Top-level rather than under Score because the size describes the mark, not
+ * the axis.
+ */
+export declare function makePointSizeSubMenu({ label, applies, value, defaultValue, set, }: PointSizeAccess & {
     label: string;
-}): MenuItem;
+    applies: boolean;
+}): MenuItem[];

package/esm/pointSizeMenu.js

@@ -1,21 +1,44 @@
-import { makePromotableSizeMenu } 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.
-export function makeScatterPointSizeMenuItem(self, opts) {
-    return makePromotableSizeMenu({
-        label: opts.label,
-        title: 'Point size',
-        display: self,
-        slot: 'scatterPointSize',
-        getValue: () => self.scatterPointSize,
-        onChange: n => {
-            self.setScatterPointSize(n);
+import { getSlotDefinition } from '@jbrowse/core/configuration';
+import { makeSizeMenu } from '@jbrowse/core/ui';
+import ScatterPlotIcon from '@mui/icons-material/ScatterPlot';
+/**
+ * The point size a display holding `WiggleScoreConfigMixin`'s `size` slot
+ * shows and writes.
+ */
+export function pointSizeAccess(self) {
+    return {
+        value: () => self.size,
+        defaultValue: Number(getSlotDefinition(self.configuration, 'size').defaultValue),
+        set: n => {
+            self.setSize(n);
         },
-        onReset: () => {
-            self.setScatterPointSize(undefined);
-        },
-    });
+    };
+}
+/**
+ * A top-level submenu holding the point-size slider, or nothing where the plot
+ * draws no points, so every score plot's menu resets and clamps alike.
+ * Top-level rather than under Score because the size describes the mark, not
+ * the axis.
+ */
+export function makePointSizeSubMenu({ label, applies, value, defaultValue, set, }) {
+    return applies
+        ? [
+            {
+                label,
+                icon: ScatterPlotIcon,
+                subMenu: [
+                    makeSizeMenu({
+                        label,
+                        title: 'Point size',
+                        getValue: value,
+                        isDefault: value() === defaultValue,
+                        onChange: set,
+                        onReset: () => {
+                            set();
+                        },
+                    }),
+                ],
+            },
+        ]
+        : [];
 }

package/esm/renderingBackendTypes.d.ts

@@ -1,5 +1,5 @@
-import type { WiggleScaleType } from './normalize.ts';
 import type { PerRegionRenderingBackend } from '@jbrowse/render-core/perRegionRenderingBackend';
+import type { ScaleTypeCode } from '@jbrowse/render-core/scoreScale';
 export type WiggleRenderingType = 0 | 1 | 2 | 3 | 4;
 export declare const RENDERING_TYPE_XYPLOT: WiggleRenderingType;
 export declare const RENDERING_TYPE_DENSITY: WiggleRenderingType;
@@ -8,9 +8,10 @@ export declare const RENDERING_TYPE_SCATTER: WiggleRenderingType;
 export declare const RENDERING_TYPE_LINE_CENTER: WiggleRenderingType;
 export declare const NO_PREV_START = 4294967295;
 export declare const MIN_FILL_WIDTH_PX = 1.5;
+export declare const MAX_WIGGLE_CUTS = 8;
 export interface WiggleGPURenderState {
     domainY: [number, number];
-    scaleType: WiggleScaleType;
+    scaleType: ScaleTypeCode;
     /**
      * symlog's linear-region width, already resolved from the domain by
      * `resolveSymlogConstant`. Both backends read this one number so the axis,
@@ -21,10 +22,14 @@ export interface WiggleGPURenderState {
     canvasWidth: number;
     canvasHeight: number;
     numRows: number;
-    scatterPointSize: number;
+    diameterPx: number;
     lineWidth: number;
     origin: number;
-    densityColorRamp?: string;
+    pivot: number;
+    cuts: number[];
+    innerColors: [number, number, number][];
+    rampMid?: number;
+    rampLut?: Uint8Array;
 }
 export interface SourceRenderData {
     featurePositions: Uint32Array;
@@ -34,6 +39,10 @@ export interface SourceRenderData {
     rowIndex: number;
     renderingType: WiggleRenderingType;
     colorsAbgr?: Uint32Array;
+    negColor?: [number, number, number];
     gapLimitBp?: number;
+    band?: {
+        minScores: Float32Array;
+    };
 }
 export type WiggleRenderingBackend = PerRegionRenderingBackend<SourceRenderData[], WiggleGPURenderState>;

package/esm/renderingBackendTypes.js

@@ -1,4 +1,4 @@
-import { MIN_FILL_WIDTH_PX as GENERATED_MIN_FILL_WIDTH_PX, NO_PREV_START as GENERATED_NO_PREV_START, RENDERING_TYPE_DENSITY as GENERATED_RENDERING_TYPE_DENSITY, RENDERING_TYPE_LINE as GENERATED_RENDERING_TYPE_LINE, RENDERING_TYPE_LINE_CENTER as GENERATED_RENDERING_TYPE_LINE_CENTER, RENDERING_TYPE_SCATTER as GENERATED_RENDERING_TYPE_SCATTER, RENDERING_TYPE_XYPLOT as GENERATED_RENDERING_TYPE_XYPLOT, } from './wiggleRenderModes.generated.js';
+import { MAX_WIGGLE_CUTS as GENERATED_MAX_WIGGLE_CUTS, MIN_FILL_WIDTH_PX as GENERATED_MIN_FILL_WIDTH_PX, NO_PREV_START as GENERATED_NO_PREV_START, RENDERING_TYPE_DENSITY as GENERATED_RENDERING_TYPE_DENSITY, RENDERING_TYPE_LINE as GENERATED_RENDERING_TYPE_LINE, RENDERING_TYPE_LINE_CENTER as GENERATED_RENDERING_TYPE_LINE_CENTER, RENDERING_TYPE_SCATTER as GENERATED_RENDERING_TYPE_SCATTER, RENDERING_TYPE_XYPLOT as GENERATED_RENDERING_TYPE_XYPLOT, } from './wiggleRenderModes.generated.js';
 // The `renderingType` uniform's vocabulary. These are wiggle.slang's own
 // numbers, generated in by `pnpm gen:shaders` (adr-051): the Canvas2D path
 // branches on them to pick a draw function while the GPU path branches on them
@@ -27,3 +27,6 @@ export const NO_PREV_START = GENERATED_NO_PREV_START;
 // It was a `1.5` in each, kept together by a comment in each pointing at the
 // other.
 export const MIN_FILL_WIDTH_PX = GENERATED_MIN_FILL_WIDTH_PX;
+// The most cuts a threshold colour parts a plot at: the shader's uniform
+// block holds this many.
+export const MAX_WIGGLE_CUTS = GENERATED_MAX_WIGGLE_CUTS;

package/esm/rowLabelOffset.d.ts

@@ -0,0 +1,8 @@
+import type { YAxis } from '@jbrowse/display-ui';
+/**
+ * Where row labels start: `offset`, past the dendrogram, or past the axis each
+ * row repeats where one draws, since a label grows rightward over the plot.
+ * `exportContentLeft` is the export shell's, which moves an axis nothing
+ * pushes right into the margin, so the labels follow it there.
+ */
+export declare function rowLabelOffset(axes: readonly YAxis[], offset: number, exportContentLeft?: number): number;

package/esm/rowLabelOffset.js

@@ -0,0 +1,16 @@
+import { axisDrawn, axisGutterLeft, axisGutterWidth, } from '@jbrowse/display-ui/axisPlacement';
+const AXIS_TO_LABEL_GAP_PX = 4;
+/**
+ * Where row labels start: `offset`, past the dendrogram, or past the axis each
+ * row repeats where one draws, since a label grows rightward over the plot.
+ * `exportContentLeft` is the export shell's, which moves an axis nothing
+ * pushes right into the margin, so the labels follow it there.
+ */
+export function rowLabelOffset(axes, offset, exportContentLeft) {
+    const axis = axes.find(axisDrawn);
+    return axis
+        ? Math.max(offset, axisGutterLeft(axis, 0, 0, exportContentLeft) +
+            axisGutterWidth(axis) +
+            AXIS_TO_LABEL_GAP_PX)
+        : offset;
+}

package/esm/scale.d.ts

@@ -20,7 +20,7 @@ export interface ScaleOpts {
     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
+     * true, for a caller handing over raw data. 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
@@ -36,18 +36,22 @@ export interface ScaleOpts {
 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.
+ * Rounds a domain to "nice" endpoints. `zero` reaches a linear or symlog
+ * domain to 0 (`scales.y.zero`, ADR-182); a log domain has no 0 and floors at
+ * 1 instead. 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.
+ * The result never descends and never collapses: a bound that would put `min`
+ * above `max` widens the other end instead, and one value in view widens
+ * away from itself, so no consumer has to guess what a backwards or a flat
+ * domain means.
  */
-export declare function getNiceDomain({ scaleType, domain, bounds, }: {
+export declare function getNiceDomain({ scaleType, domain, bounds, zero, }: {
     scaleType: string;
     domain: readonly [number, number];
     bounds: readonly [number | undefined, number | undefined];
+    zero: boolean;
 }): [number, number];
 /**
  * #api

package/esm/scale.js

@@ -64,24 +64,27 @@ export function getScale({ domain, range, scaleType, symlogConstant, nice = true
 }
 /**
  * #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.
+ * Rounds a domain to "nice" endpoints. `zero` reaches a linear or symlog
+ * domain to 0 (`scales.y.zero`, ADR-182); a log domain has no 0 and floors at
+ * 1 instead. 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.
+ * The result never descends and never collapses: a bound that would put `min`
+ * above `max` widens the other end instead, and one value in view widens
+ * away from itself, so no consumer has to guess what a backwards or a flat
+ * 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, }) {
+export function getNiceDomain({ scaleType, domain, bounds, zero, }) {
     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
+    // domain can 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 (zero && (scaleType === 'linear' || scaleType === 'symlog')) {
         if (max < 0) {
             max = 0;
         }
@@ -101,11 +104,9 @@ export function getNiceDomain({ scaleType, domain, bounds, }) {
         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.
+        // d3 scaleLog is undefined at values <= 0, so data crossing zero (a
+        // log-ratio bigwig) would yield NaN ticks and a blank plot; floor the
+        // domain to a positive, non-degenerate range instead.
         if (min <= 0) {
             min = max > 1 ? 1 : max > 0 ? max / 100 : 1;
         }
@@ -133,6 +134,18 @@ export function getNiceDomain({ scaleType, domain, bounds, }) {
             [min, max] = [max, min];
         }
     }
+    else if (max === min) {
+        // One value in view, which a domain reaching 0 never collapses on unless
+        // that value is 0. Flat, the normalizer steps at the value and every bar
+        // draws at 0 height; widen the free end by the value's own size.
+        const pad = Math.abs(min) || 1;
+        if (maxScore === undefined) {
+            max += pad;
+        }
+        else if (minScore === undefined) {
+            min -= pad;
+        }
+    }
     // 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.

package/esm/scoreFieldConfigSchemaFields.d.ts

@@ -0,0 +1,10 @@
+import type { ConfigModelForFields } from '@jbrowse/core/configuration';
+export declare const DEFAULT_SCORE_FIELD = "score";
+export declare const scoreFieldConfigSchemaFields: {
+    readonly scoreField: {
+        readonly type: 'string';
+        readonly defaultValue: "score";
+        readonly description: "Feature field plotted on the score axis, read natively off each feature. The default `score` is the field every adapter serves — including the value a BED adapter's `scoreColumn` rewrote it to — so an explicit name here reaches a raw column the adapter left alone (a BED extra column, a GFF attribute) and takes precedence over that adapter-tier rewrite. The Manhattan plot skips a feature with no finite value in the field; the wiggle renderings plot it at 0";
+    };
+};
+export type ScoreFieldConfigModel = ConfigModelForFields<typeof scoreFieldConfigSchemaFields>;

package/esm/scoreFieldConfigSchemaFields.js

@@ -0,0 +1,8 @@
+export const DEFAULT_SCORE_FIELD = 'score';
+export const scoreFieldConfigSchemaFields = {
+    scoreField: {
+        type: 'string',
+        defaultValue: DEFAULT_SCORE_FIELD,
+        description: "Feature field plotted on the score axis, read natively off each feature. The default `score` is the field every adapter serves — including the value a BED adapter's `scoreColumn` rewrote it to — so an explicit name here reaches a raw column the adapter left alone (a BED extra column, a GFF attribute) and takes precedence over that adapter-tier rewrite. The Manhattan plot skips a feature with no finite value in the field; the wiggle renderings plot it at 0",
+    },
+};