@jbrowse/wiggle-core 5.0.0-beta.11 → 5.0.0-beta.14

package/esm/ScorePlotChrome.d.ts

@@ -9,37 +9,38 @@ interface PlotBox {
     yTop: number;
     plotHeight: number;
 }
-interface ContextMenuView {
+export interface ScorePlotContextMenuHost<ContextHit> {
     contextMenuInfo?: ContextMenuAnchor;
     contextMenuItems: () => MenuItem[];
     closeContextMenu: () => void;
-}
-export interface ScorePlotContextMenuHost<Hit> extends ContextMenuView {
     openContextMenu: (info: ContextMenuAnchor & {
-        hit: Hit;
+        hit: ContextHit;
     }) => void;
     clearHoveredFeature: () => void;
 }
 export type ScorePlotChromeModel<Hit, TRegion, TState extends FrameDimensions> = ChromeModel & RenderLifecycleModel<PerRegionRenderingBackend<TRegion, TState>> & {
     canvasWidthPx: number;
+    scrollableHeight: number;
     setHoveredFeature: (hit?: Hit) => void;
     selectFeature: (hit: Hit) => void;
 };
 /**
  * The on-screen chrome of a display drawing a mark list on a score axis: the
  * canvas in the axis plot box, hover and click resolved through `findHit`, the
- * pointer-following `tooltip`, and the right-click menu where `contextMenu`
- * names the model that owns it. `findHit` takes y from the plot's own top.
+ * pointer-following `tooltip`, and the right-click menu where the model
+ * composes `ContextMenuMixin`. `findHit` takes y from the plot's own top.
+ * `findContextHit` is for a display whose menu is about something other than
+ * the hovered record (the wiggle's column, which exists where no bin does).
  */
-export declare const ScorePlotChrome: <Hit, TRegion, TState extends FrameDimensions>({ model, marks, testid, plotGeometry, findHit, tooltip, overlay, indicators, contextMenu, }: {
+export declare const ScorePlotChrome: <Hit, TRegion, TState extends FrameDimensions, ContextHit = Hit>({ model, marks, testid, plotGeometry, findHit, findContextHit, tooltip, overlay, indicators, }: {
     model: ScorePlotChromeModel<Hit, TRegion, TState>;
     marks: readonly Mark<TRegion, TState>[];
     testid: string;
     plotGeometry?: PlotBox;
     findHit: (x: number, y: number) => Hit | undefined;
+    findContextHit?: (x: number, y: number) => ContextHit | undefined;
     tooltip: (mouseState: MouseState | undefined) => ReactNode;
     overlay?: (plotGeometry: PlotBox) => ReactNode;
     indicators?: () => ReactNode;
-    contextMenu?: ScorePlotContextMenuHost<Hit>;
 }) => import("react").JSX.Element;
 export {};

package/esm/ScorePlotChrome.js

@@ -3,21 +3,27 @@ import { useMemo } from 'react';
 import { eventPoint } from '@jbrowse/core/util/eventPoint';
 import BottomRightIndicators from '@jbrowse/display-kit/BottomRightIndicators';
 import DisplayChrome from '@jbrowse/display-kit/DisplayChrome';
-import { DisplayContextMenu, openContextMenuFromEvent, } from '@jbrowse/display-kit/DisplayContextMenu';
+import { isContextMenuHost, openContextMenuFromEvent, } from '@jbrowse/display-kit/DisplayContextMenu';
 import { PointerLayer, axisPlotBox } from '@jbrowse/display-ui';
 import { createMarkBackend } from '@jbrowse/render-core/marks/backend';
 import { observer } from 'mobx-react';
+function isScorePlotMenuHost(model) {
+    return isContextMenuHost(model) && 'openContextMenu' in model;
+}
 /**
  * The on-screen chrome of a display drawing a mark list on a score axis: the
  * canvas in the axis plot box, hover and click resolved through `findHit`, the
- * pointer-following `tooltip`, and the right-click menu where `contextMenu`
- * names the model that owns it. `findHit` takes y from the plot's own top.
+ * pointer-following `tooltip`, and the right-click menu where the model
+ * composes `ContextMenuMixin`. `findHit` takes y from the plot's own top.
+ * `findContextHit` is for a display whose menu is about something other than
+ * the hovered record (the wiggle's column, which exists where no bin does).
  */
-export const ScorePlotChrome = observer(function ScorePlotChrome({ model, marks, testid, plotGeometry, findHit, tooltip, overlay, indicators, contextMenu, }) {
+export const ScorePlotChrome = observer(function ScorePlotChrome({ model, marks, testid, plotGeometry, findHit, findContextHit, tooltip, overlay, indicators, }) {
     const { height, canvasWidthPx: width } = model;
     const box = plotGeometry ?? axisPlotBox(height);
     const factory = useMemo(() => (canvas) => createMarkBackend(canvas, marks), [marks]);
     const hitAt = (x, y) => findHit(x, y - box.yTop);
+    const contextMenu = isScorePlotMenuHost(model) ? model : undefined;
     return (_jsx(DisplayChrome, { model: model, factory: factory, testid: testid, style: { width, whiteSpace: 'nowrap', textAlign: 'left' }, onPointerPosition: state => {
             model.setHoveredFeature(state ? hitAt(state.x, state.y) : undefined);
         }, onClick: event => {
@@ -29,19 +35,21 @@ export const ScorePlotChrome = observer(function ScorePlotChrome({ model, marks,
         }, onContextMenu: contextMenu
             ? event => {
                 const { x, y } = eventPoint(event);
-                const hit = hitAt(x, y);
+                const hit = findContextHit
+                    ? findContextHit(x, y - box.yTop)
+                    : hitAt(x, y);
                 openContextMenuFromEvent(contextMenu, event, hit
                     ? { clientX: event.clientX, clientY: event.clientY, hit }
                     : undefined);
             }
-            : undefined, children: ({ canvasRef, mouseTracker }) => (_jsx(ScorePlotBody, { canvasRef: canvasRef, mouseTracker: mouseTracker, width: width, plotGeometry: box, tooltip: tooltip, overlay: overlay, indicators: indicators, contextMenu: contextMenu })) }));
+            : undefined, children: ({ canvasRef, mouseTracker }) => (_jsx(ScorePlotBody, { model: model, canvasRef: canvasRef, mouseTracker: mouseTracker, width: width, plotGeometry: box, tooltip: tooltip, overlay: overlay, indicators: indicators })) }));
 });
-const ScorePlotBody = observer(function ScorePlotBody({ canvasRef, mouseTracker, width, plotGeometry, tooltip, overlay, indicators, contextMenu, }) {
+const ScorePlotBody = observer(function ScorePlotBody({ model, canvasRef, mouseTracker, width, plotGeometry, tooltip, overlay, indicators, }) {
     return (_jsxs(_Fragment, { children: [_jsx("canvas", { ref: canvasRef, style: {
                     width,
                     height: plotGeometry.plotHeight,
                     position: 'absolute',
                     left: 0,
                     top: plotGeometry.yTop,
-                } }), overlay?.(plotGeometry), _jsx(PointerLayer, { mouseTracker: mouseTracker, children: tooltip }), indicators ? (_jsx(BottomRightIndicators, { children: indicators() })) : null, contextMenu ? _jsx(DisplayContextMenu, { model: contextMenu }) : null] }));
+                } }), overlay?.(plotGeometry), _jsx(PointerLayer, { mouseTracker: mouseTracker, children: tooltip }), indicators ? (_jsx(BottomRightIndicators, { scrollableHeight: model.scrollableHeight, children: indicators() })) : null] }));
 });

package/esm/ScorePlotSvgFrame.d.ts

@@ -1,21 +1,16 @@
-import type { SvgExportable } from '@jbrowse/core/svg/svgReady';
-import type { LgvSvgBodyProps } from '@jbrowse/display-kit/renderDisplaySvg';
+import type { LgvSvgBodyProps, LgvSvgExportable } from '@jbrowse/display-kit/renderDisplaySvg';
 import type { Mark, MarkFrame } from '@jbrowse/render-core/marks';
 import type React from 'react';
-export interface ScorePlotSvgModel extends SvgExportable {
-    id: string;
-    height: number;
-}
+export type ScorePlotSvgModel = LgvSvgExportable;
 /**
  * The SVG-export body of a display with a score axis, mounted through
  * `renderDisplaySvg`, which draws the axis and cross-hatches. Paints `marks`
- * over `regions` inside the plot box, at the export's width and the box's
- * height — the two fields of `renderState` the on-screen canvas sizes
- * differently. `plotGeometry` defaults to the single-plot box `ScorePlotChrome`
- * draws in; multi-wiggle stacks its rows over the full height instead.
- * `children` draw over the plot, in the same untranslated space as the axis.
+ * over `regions` inside the plot box. `plotGeometry` defaults to the
+ * single-plot box `ScorePlotChrome` draws in; multi-wiggle stacks its rows over
+ * the full height instead. `children` draw over the plot, in the same
+ * untranslated space as the axis.
  */
-export declare function ScorePlotSvgFrame<TRegion, TState extends MarkFrame>({ height, canvasWidth, renderBlocks, opts, plotGeometry, marks, regions, renderState, children, }: LgvSvgBodyProps<ScorePlotSvgModel> & {
+export declare function ScorePlotSvgFrame<TRegion, TState extends MarkFrame>({ height, canvasWidth, renderBlocks, opts, plotGeometry, marks, regions, renderState, children, }: Pick<LgvSvgBodyProps<unknown>, 'height' | 'canvasWidth' | 'renderBlocks' | 'opts'> & {
     plotGeometry?: {
         yTop: number;
         plotHeight: number;

package/esm/ScorePlotSvgFrame.js

@@ -1,23 +1,15 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { PaintLayer } from '@jbrowse/core/util/paintLayer';
+import MarkSvgLayer from '@jbrowse/display-kit/MarkSvgLayer';
 import { axisPlotBox } from '@jbrowse/display-ui';
-import { paintMarkBlocks } from '@jbrowse/render-core/marks';
 /**
  * The SVG-export body of a display with a score axis, mounted through
  * `renderDisplaySvg`, which draws the axis and cross-hatches. Paints `marks`
- * over `regions` inside the plot box, at the export's width and the box's
- * height — the two fields of `renderState` the on-screen canvas sizes
- * differently. `plotGeometry` defaults to the single-plot box `ScorePlotChrome`
- * draws in; multi-wiggle stacks its rows over the full height instead.
- * `children` draw over the plot, in the same untranslated space as the axis.
+ * over `regions` inside the plot box. `plotGeometry` defaults to the
+ * single-plot box `ScorePlotChrome` draws in; multi-wiggle stacks its rows over
+ * the full height instead. `children` draw over the plot, in the same
+ * untranslated space as the axis.
  */
 export function ScorePlotSvgFrame({ height, canvasWidth, renderBlocks, opts, plotGeometry = axisPlotBox(height), marks, regions, renderState, children, }) {
     const { yTop, plotHeight } = plotGeometry;
-    return (_jsxs(_Fragment, { children: [_jsx("g", { transform: `translate(0,${yTop})`, children: _jsx(PaintLayer, { width: canvasWidth, height: plotHeight, opts: opts, paint: ctx => {
-                        paintMarkBlocks(ctx, marks, regions, renderBlocks, {
-                            ...renderState,
-                            canvasWidth,
-                            canvasHeight: plotHeight,
-                        });
-                    } }) }), children] }));
+    return (_jsxs(_Fragment, { children: [_jsx("g", { transform: `translate(0,${yTop})`, children: _jsx(MarkSvgLayer, { marks: marks, regions: regions, blocks: renderBlocks, state: renderState, width: canvasWidth, height: plotHeight, opts: opts }) }), children] }));
 }

package/esm/ScoreScaleMixin.d.ts

@@ -15,15 +15,15 @@ export interface ScoreScaleHost {
 /**
  * #stateModel ScoreScaleMixin
  * #category display
- * #crossCuttingMixin Value scale, written in `scales.y`. `valueScaleSchema` / `scalesSchema`. Brings `ScoreAxisMixin` plus `scaleType` / `scaleZero` / `domainQuantile` / `clipQuantile` / `symlogConstant` / `manual*` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
+ * #crossCuttingMixin Value scale, written in `scales.y`. `valueScaleSchema` / `scalesSchema`. Brings `ScoreAxisMixin` plus `scaleType` / `scaleZero` / `domainQuantile` / `clipQuantile` / `symlogConstant` / `manual*` and their setters, i.e. the whole `ScoreScaleModel` interface the Y axis row and its drawer widget consume
  *
  * The value scale of every quantitative display: wiggle, the alignments
  * coverage band and the mark display, Manhattan among them, each declare
  * `scales.y` through {@link valueScaleSchema} and compose this. It backs
  * {@link ScoreAxisMixin}'s three overridable members off that object and adds
  * the setters that write it, so composing this is how a display satisfies
- * {@link ScoreScaleModel} in `scoreMenuItems.ts` — the interface the shared
- * Score menu, the scale and autoscale submenus and `SetMinMaxDialog` consume.
+ * {@link ScoreScaleModel} in `scoreMenuItems.ts` — the interface the Y axis
+ * row and its drawer widget consume.
  *
  * Deliberately just the scale and the guides it owns. Colors, `resolution`
  * and the autoscale *computation* stay in `WiggleScoreConfigMixin` /
@@ -68,7 +68,7 @@ export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IM
     readonly domainQuantile: number;
     /**
      * #getter
-     * The quantile "Clip outliers" clips at: the one an untick this session
+     * The quantile "Clip extreme outliers" fences at: the one an untick this session
      * wrote over, else the scale's own default where that is below 1, else
      * 0.99.
      */
@@ -89,13 +89,6 @@ export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IM
      * The upper bound the config pins, `undefined` where it pins none.
      */
     readonly manualMaxScore: number | undefined;
-    /**
-     * #getter
-     * What `scales.y`'s ends say together that the axis cannot draw as
-     * written, as corner-notice lines, by the rule a colour ramp's ends
-     * answer to. The mark display reports them through its rule list.
-     */
-    readonly valueScaleNotices: string[];
     /**
      * #getter
      * `scales.y.autoscaleGroup`, `undefined` while it names none.
@@ -119,9 +112,9 @@ export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IM
     /**
      * #getter
      * Whether this display draws `scales.y.rules`, which is whether the
-     * score menu offers the reference lines: a scale it places y through
-     * rules a band for them to cross, which a density plot's colour-mapped
-     * rows and a colour ramp do not.
+     * Y axis panel offers Include 0 and the reference lines: a scale it places y through
+     * rules a band for them to cross, which a density plot's color-mapped
+     * rows and a color ramp do not.
      */
     readonly scoreRulesDrawn: boolean;
     /**

package/esm/ScoreScaleMixin.js

@@ -1,5 +1,4 @@
 import { getConf, getSlotDefinition, readConfObject, setConf, } from '@jbrowse/core/configuration';
-import { noticeLines, scaleEndProblems } from '@jbrowse/core/util/colorScale';
 import { clipQuantileOf } from '@jbrowse/core/util/quantileExtent';
 import { rulesABand } from '@jbrowse/display-ui/axisPlacement';
 import { ScoreAxisMixin } from './ScoreAxisMixin.js';
@@ -11,15 +10,15 @@ const confNode = (self) => self;
 /**
  * #stateModel ScoreScaleMixin
  * #category display
- * #crossCuttingMixin Value scale, written in `scales.y`. `valueScaleSchema` / `scalesSchema`. Brings `ScoreAxisMixin` plus `scaleType` / `scaleZero` / `domainQuantile` / `clipQuantile` / `symlogConstant` / `manual*` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
+ * #crossCuttingMixin Value scale, written in `scales.y`. `valueScaleSchema` / `scalesSchema`. Brings `ScoreAxisMixin` plus `scaleType` / `scaleZero` / `domainQuantile` / `clipQuantile` / `symlogConstant` / `manual*` and their setters, i.e. the whole `ScoreScaleModel` interface the Y axis row and its drawer widget consume
  *
  * The value scale of every quantitative display: wiggle, the alignments
  * coverage band and the mark display, Manhattan among them, each declare
  * `scales.y` through {@link valueScaleSchema} and compose this. It backs
  * {@link ScoreAxisMixin}'s three overridable members off that object and adds
  * the setters that write it, so composing this is how a display satisfies
- * {@link ScoreScaleModel} in `scoreMenuItems.ts` — the interface the shared
- * Score menu, the scale and autoscale submenus and `SetMinMaxDialog` consume.
+ * {@link ScoreScaleModel} in `scoreMenuItems.ts` — the interface the Y axis
+ * row and its drawer widget consume.
  *
  * Deliberately just the scale and the guides it owns. Colors, `resolution`
  * and the autoscale *computation* stay in `WiggleScoreConfigMixin` /
@@ -56,7 +55,7 @@ export function ScoreScaleMixin() {
         },
         /**
          * #getter
-         * The quantile "Clip outliers" clips at: the one an untick this session
+         * The quantile "Clip extreme outliers" fences at: the one an untick this session
          * wrote over, else the scale's own default where that is below 1, else
          * 0.99.
          */
@@ -86,19 +85,6 @@ export function ScoreScaleMixin() {
         get manualMaxScore() {
             return getConf(confNode(self), ['scales', 'y', 'domainMax']);
         },
-        /**
-         * #getter
-         * What `scales.y`'s ends say together that the axis cannot draw as
-         * written, as corner-notice lines, by the rule a colour ramp's ends
-         * answer to. The mark display reports them through its rule list.
-         */
-        get valueScaleNotices() {
-            return noticeLines('scales.y', scaleEndProblems({
-                domainMin: this.manualMinScore,
-                domainMax: this.manualMaxScore,
-                domainQuantile: this.domainQuantile,
-            }));
-        },
         /**
          * #getter
          * `scales.y.autoscaleGroup`, `undefined` while it names none.
@@ -131,9 +117,9 @@ export function ScoreScaleMixin() {
         /**
          * #getter
          * Whether this display draws `scales.y.rules`, which is whether the
-         * score menu offers the reference lines: a scale it places y through
-         * rules a band for them to cross, which a density plot's colour-mapped
-         * rows and a colour ramp do not.
+         * Y axis panel offers Include 0 and the reference lines: a scale it places y through
+         * rules a band for them to cross, which a density plot's color-mapped
+         * rows and a color ramp do not.
          */
         get scoreRulesDrawn() {
             return self.valueScales.some(rulesABand);

package/esm/WiggleScoreConfigMixin.d.ts

@@ -1,25 +1,18 @@
 import type { scalesSchema } from './valueScaleConfigSchema.ts';
 import type { ConfigModelForFields } from '@jbrowse/core/configuration';
-/** The slots its composers each declare, with their own defaults. */
-export declare const wiggleScoreConfigExtraSlots: {
-    readonly size: {
-        readonly type: 'number';
-        readonly defaultValue: 2;
-    };
-};
 export interface WiggleScoreConfigHost {
     configuration: ConfigModelForFields<{
         scales: ReturnType<typeof scalesSchema>;
-    } & typeof wiggleScoreConfigExtraSlots>;
+    }>;
 }
 /**
  * #stateModel WiggleScoreConfigMixin
  * #category display
  *
  * The score-plot config every display with a score axis shares: the axis
- * and its guides (`ScoreScaleMixin`) and the scatter point size. A
- * display plotting one configured field composes `ScoreFieldConfigMixin`,
- * which adds `scoreField`.
+ * and its guides (`ScoreScaleMixin`). A display plotting one configured
+ * field composes `YFieldConfigMixin`,
+ * which adds the `y` slot.
  */
 export declare function WiggleScoreConfigMixin(): import("@jbrowse/mobx-state-tree").IModelType<Omit<{}, never>, {
     readonly scaleType: string;
@@ -48,7 +41,6 @@ export declare function WiggleScoreConfigMixin(): import("@jbrowse/mobx-state-tr
     readonly symlogConstant: number;
     readonly manualMinScore: number | undefined;
     readonly manualMaxScore: number | undefined;
-    readonly valueScaleNotices: string[];
     readonly autoscaleGroup: string | undefined;
     readonly scaleTitle: string;
     readonly grid: boolean;
@@ -65,10 +57,6 @@ export declare function WiggleScoreConfigMixin(): import("@jbrowse/mobx-state-tr
     setGrid(grid: boolean): void;
     setScoreRules(rules: (number | import("@jbrowse/display-ui").ValueScaleRule)[]): void;
 } & {
-    /**
-     * #getter
-     */
-    readonly size: number;
     /**
      * #getter
      * Whether score maps to color instead of height; a display overrides it.
@@ -77,13 +65,8 @@ export declare function WiggleScoreConfigMixin(): import("@jbrowse/mobx-state-tr
 } & {
     /**
      * #getter
-     * A density row maps score to colour and has no axis to start at 0, so
+     * A density row maps score to color and has no axis to start at 0, so
      * its domain spans the values whatever `scales.y.zero` says.
      */
     readonly axisReachesZero: boolean;
-} & {
-    /**
-     * #action
-     */
-    setSize(val?: number): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/WiggleScoreConfigMixin.js

@@ -1,30 +1,18 @@
-import { getConf, setConf } from '@jbrowse/core/configuration';
 import { types } from '@jbrowse/mobx-state-tree';
 import { ScoreScaleMixin } from './ScoreScaleMixin.js';
-/** The slots its composers each declare, with their own defaults. */
-export const wiggleScoreConfigExtraSlots = {
-    size: { type: 'number', defaultValue: 2 },
-};
-const confNode = (self) => self;
 /**
  * #stateModel WiggleScoreConfigMixin
  * #category display
  *
  * The score-plot config every display with a score axis shares: the axis
- * and its guides (`ScoreScaleMixin`) and the scatter point size. A
- * display plotting one configured field composes `ScoreFieldConfigMixin`,
- * which adds `scoreField`.
+ * and its guides (`ScoreScaleMixin`). A display plotting one configured
+ * field composes `YFieldConfigMixin`,
+ * which adds the `y` slot.
  */
 export function WiggleScoreConfigMixin() {
     return types
         .compose('WiggleScoreConfigMixin', ScoreScaleMixin(), types.model({}))
-        .views(self => ({
-        /**
-         * #getter
-         */
-        get size() {
-            return getConf(confNode(self), 'size');
-        },
+        .views(() => ({
         /**
          * #getter
          * Whether score maps to color instead of height; a display overrides it.
@@ -36,19 +24,11 @@ export function WiggleScoreConfigMixin() {
         .views(self => ({
         /**
          * #getter
-         * A density row maps score to colour and has no axis to start at 0, so
+         * A density row maps score to color and has no axis to start at 0, so
          * its domain spans the values whatever `scales.y.zero` says.
          */
         get axisReachesZero() {
             return self.scaleZero && !self.isDensityMode;
         },
-    }))
-        .actions(self => ({
-        /**
-         * #action
-         */
-        setSize(val) {
-            setConf(confNode(self), 'size', val);
-        },
     }));
 }

package/esm/{ScoreFieldConfigMixin.d.ts → YFieldConfigMixin.d.ts}

@@ -1,17 +1,17 @@
-import type { ScoreFieldConfigModel } from './scoreFieldConfigSchemaFields.ts';
-export interface ScoreFieldConfigHost {
-    configuration: ScoreFieldConfigModel;
+import type { YFieldConfigModel } from './yFieldConfigSchemaFields.ts';
+export interface YFieldConfigHost {
+    configuration: YFieldConfigModel;
 }
 /**
- * #stateModel ScoreFieldConfigMixin
+ * #stateModel YFieldConfigMixin
  * #category display
  *
- * `WiggleScoreConfigMixin` plus `scoreField`, for a display that plots one
- * configured feature field and so declares `scoreFieldConfigSchemaFields`:
+ * `WiggleScoreConfigMixin` plus the `y` slot, for a display that plots one
+ * configured feature field and so declares `yFieldConfigSchemaFields`:
  * the wiggle display. `LinearMarkDisplay` names a field per mark and composes
  * the base instead.
  */
-export declare function ScoreFieldConfigMixin(): import("@jbrowse/mobx-state-tree").IModelType<Omit<{}, never>, {
+export declare function YFieldConfigMixin(): import("@jbrowse/mobx-state-tree").IModelType<Omit<{}, never>, {
     readonly scaleType: string;
     readonly scaleZero: boolean;
     readonly manualMinScore: number | undefined;
@@ -38,7 +38,6 @@ export declare function ScoreFieldConfigMixin(): import("@jbrowse/mobx-state-tre
     readonly symlogConstant: number;
     readonly manualMinScore: number | undefined;
     readonly manualMaxScore: number | undefined;
-    readonly valueScaleNotices: string[];
     readonly autoscaleGroup: string | undefined;
     readonly scaleTitle: string;
     readonly grid: boolean;
@@ -55,18 +54,15 @@ export declare function ScoreFieldConfigMixin(): import("@jbrowse/mobx-state-tre
     setGrid(grid: boolean): void;
     setScoreRules(rules: (number | import("@jbrowse/display-ui").ValueScaleRule)[]): void;
 } & {
-    readonly size: number;
     readonly isDensityMode: boolean;
 } & {
     readonly axisReachesZero: boolean;
-} & {
-    setSize(val?: number): void;
 } & {
     /**
      * #getter
-     * The feature field the worker plots on the score axis, `score` by
-     * default. A fetch input: every composing display carries it in its
-     * `rpcProps()`, since the field is read where the features are.
+     * The feature field the worker plots on the value axis, the `y` slot,
+     * `score` by default. A fetch input: every composing display carries it in
+     * its `rpcProps()`, since the field is read where the features are.
      */
-    readonly scoreField: string;
+    readonly yField: string;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/YFieldConfigMixin.js

@@ -0,0 +1,25 @@
+import { getConf } from '@jbrowse/core/configuration';
+import { WiggleScoreConfigMixin } from './WiggleScoreConfigMixin.js';
+const confNode = (self) => self;
+/**
+ * #stateModel YFieldConfigMixin
+ * #category display
+ *
+ * `WiggleScoreConfigMixin` plus the `y` slot, for a display that plots one
+ * configured feature field and so declares `yFieldConfigSchemaFields`:
+ * the wiggle display. `LinearMarkDisplay` names a field per mark and composes
+ * the base instead.
+ */
+export function YFieldConfigMixin() {
+    return WiggleScoreConfigMixin().views(self => ({
+        /**
+         * #getter
+         * The feature field the worker plots on the value axis, the `y` slot,
+         * `score` by default. A fetch input: every composing display carries it in
+         * its `rpcProps()`, since the field is read where the features are.
+         */
+        get yField() {
+            return getConf(confNode(self), 'y');
+        },
+    }));
+}

package/esm/autoscale.d.ts

@@ -48,48 +48,53 @@ export interface ScoreSpan {
     row?: Uint32Array;
     drawnKeys?: Uint8Array;
 }
-/** The wiggle packer's arrays as a span, under a summary mode. */
-export declare function datasetSpan({ data, visStart, visEnd }: Dataset, summaryScoreMode: string): ScoreSpan;
+/** The wiggle packer's arrays as a span, under an aggregate and an extent. */
+export declare function datasetSpan({ data, visStart, visEnd }: Dataset, aggregate: string, extent: string): ScoreSpan;
 /**
  * #api
- * Per-feature scalar score array for a summary mode: the min/max summary array
+ * Per-feature scalar score array for an aggregate: the min/max summary array
  * for `'min'`/`'max'`, otherwise the average score.
  */
 export declare function getEffectiveScores(data: {
     featureScores: Float32Array;
     featureMinScores: Float32Array;
     featureMaxScores: Float32Array;
-}, summaryScoreMode: string): Float32Array<ArrayBufferLike>;
+}, aggregate: string): Float32Array<ArrayBufferLike>;
 export declare function computeSpanStats(spans: ScoreSpan[]): ScoreStats | undefined;
 /** `computeSpanStats` over the wiggle packer's datasets. */
-export declare function computeScoreStats(summaryScoreMode: string, datasets: Dataset[]): ScoreStats | undefined;
+export declare function computeScoreStats(aggregate: string, datasets: Dataset[], extent: string): ScoreStats | undefined;
 /**
  * #api
  * The domain the visible instances autoscale to: at a `quantile` of 1 their
- * extremes, `stats`; below it `quantileExtent`'s ends, the bottom read off
- * the `low`s and the top off the `high`s less the zeros where any is
- * positive, so whiskers open to their spread, a sparse window's empty bins
- * lower no top, and a window of nothing above 0 keeps the top it has.
+ * extremes, `stats`; below it those extremes fenced by `quantileExtent`'s
+ * ends (`fenceOutliers`), the bottom read off the `low`s and the top off the
+ * `high`s less the zeros where any is positive, so whiskers open to their
+ * spread, a sparse window's empty bins lower no top, and a window of nothing
+ * above 0 keeps the top it has.
  */
-export declare function autoscaleDomainFromSpans({ stats, quantile, spans, }: {
+export declare function autoscaleDomainFromSpans({ stats, quantile, zero, spans, }: {
     stats: ScoreStats;
     quantile: number;
+    zero: boolean;
     spans: ScoreSpan[];
 }): [number, number];
 /** `autoscaleDomainFromSpans` over the wiggle packer's datasets. */
-export declare function autoscaleDomainFromStats({ stats, quantile, summaryScoreMode, visibleEntries, }: {
+export declare function autoscaleDomainFromStats({ stats, quantile, zero, aggregate, extent, visibleEntries, }: {
     stats: ScoreStats;
     quantile: number;
-    summaryScoreMode: string;
+    zero: boolean;
+    aggregate: string;
+    extent: string;
     visibleEntries: Dataset[];
 }): [number, number];
 /**
  * #api
  * The score domain of the visible feature arrays, following `quantile` as
- * `scales.y.domainQuantile` says.
+ * `scales.y.domainQuantile` says, its outliers fenced for an axis that
+ * reaches 0 under `zero`.
  */
-export declare function computeAutoscaleDomain(quantile: number, summaryScoreMode: string, visibleEntries: {
+export declare function computeAutoscaleDomain(quantile: number, aggregate: string, visibleEntries: {
     data: FeatureArrays;
     visStart: number;
     visEnd: number;
-}[]): [number, number] | undefined;
+}[], zero: boolean, extent?: string): [number, number] | undefined;