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

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.
      */
@@ -119,7 +119,7 @@ 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
+     * 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 colour-mapped
      * rows and a colour ramp do not.
      */

package/esm/ScoreScaleMixin.js

@@ -11,15 +11,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 +56,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.
          */
@@ -131,7 +131,7 @@ 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
+         * 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 colour-mapped
          * rows and a colour ramp do not.
          */

package/esm/autoscale.d.ts

@@ -66,30 +66,34 @@ export declare function computeScoreStats(summaryScoreMode: string, datasets: Da
 /**
  * #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, summaryScoreMode, visibleEntries, }: {
     stats: ScoreStats;
     quantile: number;
+    zero: boolean;
     summaryScoreMode: 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: {
     data: FeatureArrays;
     visStart: number;
     visEnd: number;
-}[]): [number, number] | undefined;
+}[], zero: boolean): [number, number] | undefined;

package/esm/autoscale.js

@@ -1,4 +1,4 @@
-import { quantileExtent } from '@jbrowse/core/util/quantileExtent';
+import { fenceOutliers, quantileExtent, } from '@jbrowse/core/util/quantileExtent';
 /** The wiggle packer's arrays as a span, under a summary mode. */
 export function datasetSpan({ data, visStart, visEnd }, summaryScoreMode) {
     const { low, high } = boundArrays(summaryScoreMode);
@@ -128,12 +128,13 @@ export function computeScoreStats(summaryScoreMode, datasets) {
 /**
  * #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 function autoscaleDomainFromSpans({ stats, quantile, spans, }) {
+export function autoscaleDomainFromSpans({ stats, quantile, zero, spans, }) {
     if (quantile >= 1) {
         return [stats.scoreMin, stats.scoreMax];
     }
@@ -153,25 +154,31 @@ export function autoscaleDomainFromSpans({ stats, quantile, spans, }) {
     const tops = highs.some(v => v > 0) ? highs.filter(v => v !== 0) : highs;
     const min = quantileExtent(lows, lows.length, quantile)[0];
     const max = quantileExtent(tops, tops.length, quantile)[1];
-    return [Number.isFinite(min) ? min : 0, Number.isFinite(max) ? max : 0];
+    return fenceOutliers({
+        extremes: [stats.scoreMin, stats.scoreMax],
+        quantiles: [Number.isFinite(min) ? min : 0, Number.isFinite(max) ? max : 0],
+        zero,
+    });
 }
 /** `autoscaleDomainFromSpans` over the wiggle packer's datasets. */
-export function autoscaleDomainFromStats({ stats, quantile, summaryScoreMode, visibleEntries, }) {
+export function autoscaleDomainFromStats({ stats, quantile, zero, summaryScoreMode, visibleEntries, }) {
     return autoscaleDomainFromSpans({
         stats,
         quantile,
+        zero,
         spans: visibleEntries.map(d => datasetSpan(d, summaryScoreMode)),
     });
 }
 /**
  * #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 function computeAutoscaleDomain(quantile, summaryScoreMode, visibleEntries) {
+export function computeAutoscaleDomain(quantile, summaryScoreMode, visibleEntries, zero) {
     const spans = visibleEntries.map(d => datasetSpan(d, summaryScoreMode));
     const stats = computeSpanStats(spans);
     return stats
-        ? autoscaleDomainFromSpans({ stats, quantile, spans })
+        ? autoscaleDomainFromSpans({ stats, quantile, zero, spans })
         : undefined;
 }

package/esm/chrome.d.ts

@@ -2,4 +2,3 @@ export { AxisGutter, CrossHatchLines, CrossHatches, ScoreDomainCaption, ScoreRul
 export { makeResolutionSubMenuItem } from './ResolutionStepper.tsx';
 export { makePointSizeSubMenu, pointSizeAccess } from './pointSizeMenu.tsx';
 export type { PointSizeAccess } from './pointSizeMenu.tsx';
-export { default as SetMinMaxDialog } from './SetMinMaxDialog.tsx';

package/esm/chrome.js

@@ -4,4 +4,3 @@
 export { AxisGutter, CrossHatchLines, CrossHatches, ScoreDomainCaption, ScoreRuleLines, ScoreRules, YScaleBar, YScaleBarOverlay, } from '@jbrowse/display-ui';
 export { makeResolutionSubMenuItem } from './ResolutionStepper.js';
 export { makePointSizeSubMenu, pointSizeAccess } from './pointSizeMenu.js';
-export { default as SetMinMaxDialog } from './SetMinMaxDialog.js';

package/esm/dataTypes.d.ts

@@ -2,7 +2,6 @@ import type { ZoomRange } from '@jbrowse/core/data_adapters/BaseAdapter/zoomRang
 export interface SourceInfo {
     name: string;
     color?: string;
-    labelColor?: string;
     label?: string;
     group?: string;
     baseUri?: string;

package/esm/index.d.ts

@@ -18,8 +18,8 @@ export type { SettledBlocksView, VisibleEntry, VisibleStatsDomainSpec, VisibleSt
 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 { COVERAGE_AXIS_LABEL, SCORE_RANGE_LABEL, Y_AXIS_LABEL, makeScoreAxisMenuItem, } from './scoreMenuItems.ts';
+export type { ScoreAxisMenuItemOptions, ScoreRulesModel, ScoreScaleModel, } from './scoreMenuItems.ts';
 export { ScoreAxisMixin } from './ScoreAxisMixin.ts';
 export { ScoreScaleMixin } from './ScoreScaleMixin.ts';
 export type { ScoreScaleHost } from './ScoreScaleMixin.ts';

package/esm/index.js

@@ -16,7 +16,7 @@ export { resolveRenderState } from './resolveRenderState.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 { COVERAGE_AXIS_LABEL, SCORE_RANGE_LABEL, Y_AXIS_LABEL, makeScoreAxisMenuItem, } from './scoreMenuItems.js';
 export { ScoreAxisMixin } from './ScoreAxisMixin.js';
 export { ScoreScaleMixin } from './ScoreScaleMixin.js';
 export { WiggleScoreConfigMixin, wiggleScoreConfigExtraSlots, } from './WiggleScoreConfigMixin.js';

package/esm/scale.js

@@ -147,7 +147,7 @@ export function getNiceDomain({ scaleType, domain, bounds, zero, }) {
         }
     }
     // 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,
+    // data's extent". A bound the user typed into the Y axis panel means itself,
     // and the menu row goes on displaying it, so it is taken as given.
     //
     // `min`/`max` rather than `minScore`/`maxScore`: the log guards above may

package/esm/scoreMenuItems.d.ts

@@ -1,5 +1,4 @@
-import type { AutoscalePeer } from './autoscaleGroup.ts';
-import type { CheckboxMenuItem, MenuItem } from '@jbrowse/core/ui';
+import type { NormalMenuItem } from '@jbrowse/core/ui';
 import type { ValueScaleRule } from '@jbrowse/display-ui';
 import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 export interface ScoreScaleModel extends IStateTreeNode {
@@ -12,6 +11,7 @@ export interface ScoreScaleModel extends IStateTreeNode {
     minScoreBound: number | undefined;
     maxScoreBound: number | undefined;
     hasManualScoreBounds: boolean;
+    autoscaleRange: [number, number] | undefined;
     autoscaledDomain: [number, number] | undefined;
     setScaleType: (v: string) => void;
     setScaleZero: (zero: boolean) => void;
@@ -24,33 +24,19 @@ export interface ScoreRulesModel {
     scoreRules: ValueScaleRule[];
     setScoreRules: (rules: ValueScaleRule[]) => void;
 }
-export declare function makeScaleTypeSubMenu(self: {
-    scaleType: string;
-    setScaleType: (v: string) => void;
-}): MenuItem;
-export declare const CLIP_OUTLIERS_LABEL = "Clip outliers";
-export declare function makeClipOutliersItem(self: {
-    domainQuantile: number;
-    clipQuantile: number;
-    setDomainQuantile: (quantile: number) => void;
-}): CheckboxMenuItem;
-export declare const AXIS_ZERO_LABEL = "Start axis at 0";
-export declare function makeAxisZeroItem(self: {
-    scaleZero: boolean;
-    setScaleZero: (zero: boolean) => void;
-}): CheckboxMenuItem;
-export declare function makeSetMinMaxScoreItem(self: ScoreScaleModel): MenuItem;
-export declare function makeCrossHatchItem(self: {
-    grid: boolean;
-    setGrid: (grid: boolean) => void;
-}): MenuItem;
-export interface ScoreSubMenuOptions {
+export declare const Y_AXIS_LABEL = "Y axis";
+export declare const COVERAGE_AXIS_LABEL = "Coverage axis";
+export declare const SCORE_RANGE_LABEL = "Score range";
+export interface ScoreAxisMenuItemOptions {
     label?: string;
-    leadingItems?: MenuItem[];
-    trailingItems?: MenuItem[];
     disabled?: boolean;
     disabledHelpText?: string;
 }
-export declare function makeAutoscaleGroupItem(self: IStateTreeNode & AutoscalePeer): MenuItem;
-export declare function makeSetScoreRulesItem(self: IStateTreeNode & ScoreRulesModel): MenuItem;
-export declare function makeScoreSubMenu(self: ScoreScaleModel & Partial<ScoreRulesModel> & Partial<AutoscalePeer>, opts?: ScoreSubMenuOptions): MenuItem;
+/**
+ * The one track-menu row for a value scale. It opens the drawer widget that
+ * edits `scales.y` live — scale type, range, 0, outlier clipping, the axis a
+ * group shares, grid and reference lines — so the track redraws beside it.
+ */
+export declare function makeScoreAxisMenuItem(self: ScoreScaleModel & {
+    id: string;
+}, opts?: ScoreAxisMenuItemOptions): NormalMenuItem;

package/esm/scoreMenuItems.js

@@ -1,137 +1,42 @@
-import { lazy } from 'react';
-import { checkboxItem, radioItems, toggleItem, } from '@jbrowse/core/ui/menuItems';
-import { getDialogHost } from '@jbrowse/core/util';
+import { getSession, isSessionModelWithWidgets } from '@jbrowse/core/util';
 import EqualizerIcon from '@mui/icons-material/Equalizer';
-import { autoscaleGroupMembers, autoscalePeers } from './autoscaleGroup.js';
-import { VALUE_SCALE_TYPES } from './valueScaleConfigSchema.js';
-const AutoscaleGroupDialog = lazy(() => import('./AutoscaleGroupDialog.js'));
-const SetMinMaxDialog = lazy(() => import('./SetMinMaxDialog.js'));
-const SetScoreRulesDialog = lazy(() => import('./SetScoreRulesDialog.js'));
-const SCALE_TYPE_LABELS = {
-    linear: 'Linear scale',
-    log: 'Log scale',
-    symlog: 'Symlog scale (allows zero)',
-};
-export function makeScaleTypeSubMenu(self) {
+import { SCORE_AXIS_WIDGET } from './ScoreAxisWidget/constants.js';
+// Quoted by the docs' click paths, so literal strings.
+export const Y_AXIS_LABEL = 'Y axis';
+export const COVERAGE_AXIS_LABEL = 'Coverage axis';
+export const SCORE_RANGE_LABEL = 'Score range';
+// The caption carries only what the plot cannot show: a pinned end, `auto`
+// for the other, and a scale that isn't linear. The resolved pair would
+// caption every GC content track "(0 – 1)" off its default domain.
+function caption(self) {
+    const parts = [
+        ...(self.hasManualScoreBounds
+            ? [`${self.manualMinScore ?? 'auto'} – ${self.manualMaxScore ?? 'auto'}`]
+            : []),
+        ...(self.scaleType === 'linear' ? [] : [self.scaleType]),
+    ];
+    return parts.length ? ` (${parts.join(', ')})` : '';
+}
+/**
+ * The one track-menu row for a value scale. It opens the drawer widget that
+ * edits `scales.y` live — scale type, range, 0, outlier clipping, the axis a
+ * group shares, grid and reference lines — so the track redraws beside it.
+ */
+export function makeScoreAxisMenuItem(self, opts = {}) {
+    const { label = Y_AXIS_LABEL, disabled, disabledHelpText } = opts;
     return {
-        label: 'Scale type',
-        subMenu: radioItems(VALUE_SCALE_TYPES.map(value => ({
-            value,
-            label: SCALE_TYPE_LABELS[value],
-        })), self.scaleType, v => {
-            self.setScaleType(v);
-        }),
-    };
-}
-// Quoted by the docs' click paths, so one literal string.
-export const CLIP_OUTLIERS_LABEL = 'Clip outliers';
-// One checkbox rather than a radio over modes: what a reader decides is whether
-// a spike may take the axis, and the quantile it clips at is the config's.
-export function makeClipOutliersItem(self) {
-    const clipsAt = self.domainQuantile < 1 ? self.domainQuantile : self.clipQuantile;
-    const percent = Math.round(clipsAt * 100);
-    return toggleItem(CLIP_OUTLIERS_LABEL, self.domainQuantile < 1, on => {
-        self.setDomainQuantile(on ? self.clipQuantile : 1);
-    }, {
-        helpText: `An unpinned end follows the ${percent}th percentile of each sign rather than the extremes, so one spike no longer flattens the rest.`,
-    });
-}
-// Quoted by the docs' click paths, so one literal string.
-export const AXIS_ZERO_LABEL = 'Start axis at 0';
-export function makeAxisZeroItem(self) {
-    return toggleItem(AXIS_ZERO_LABEL, self.scaleZero, zero => {
-        self.setScaleZero(zero);
-    }, {
-        helpText: 'A linear or symlog axis reaches 0 whatever the values in view span. Off, it spans those values alone.',
-    });
-}
-// The label shows the PINNED pair, `auto` for an end nobody pinned: the
-// resolved pair captioned every GC content track "(0 – 1)" off its default
-// domain. "Use current range" copies `autoscaledDomain`, undefined while the
-// alignments density tier's features per bin stand in for depth.
-export function makeSetMinMaxScoreItem(self) {
-    const { manualMinScore, manualMaxScore, autoscaledDomain: domain } = self;
-    return {
-        label: self.hasManualScoreBounds
-            ? `Set min/max score (${manualMinScore ?? 'auto'} – ${manualMaxScore ?? 'auto'})...`
-            : 'Set min/max score...',
-        onClick: () => {
-            getDialogHost(self).queueDialog(handleClose => [
-                SetMinMaxDialog,
-                { model: self, domain, handleClose },
-            ]);
-        },
-    };
-}
-export function makeCrossHatchItem(self) {
-    return checkboxItem('Show cross hatches', self.grid, () => {
-        self.setGrid(!self.grid);
-    });
-}
-// The count of the other tracks in the group is in the label, as the min/max
-// row carries its bounds: an axis that moves when another track pans is
-// something the reader has to be able to find the cause of.
-export function makeAutoscaleGroupItem(self) {
-    const { autoscaleGroup } = self;
-    const others = autoscaleGroup === undefined
-        ? 0
-        : autoscaleGroupMembers(self, autoscaleGroup).length - 1;
-    return {
-        label: others > 0
-            ? `Autoscale with other tracks (${others})...`
-            : 'Autoscale with other tracks...',
-        onClick: () => {
-            getDialogHost(self).queueDialog(handleClose => [
-                AutoscaleGroupDialog,
-                { model: self, handleClose },
-            ]);
-        },
-    };
-}
-// Offered once the view holds another track with a value axis to share.
-function autoscalesInGroups(self) {
-    return self.setAutoscaleGroup !== undefined && autoscalePeers(self).length > 0;
-}
-function drawsScoreRules(self) {
-    return (self.scoreRulesDrawn === true &&
-        self.scoreRules !== undefined &&
-        self.setScoreRules !== undefined);
-}
-// A density plot maps its score to colour and rules no band, so its domain
-// spans the values whatever `zero` says; the row is offered with the axis.
-function rulesABand(self) {
-    return self.scoreRulesDrawn === true;
-}
-// The count is in the label, as the min/max row carries its bounds: a dashed
-// line across a plot means nothing until the reader knows it was put there.
-export function makeSetScoreRulesItem(self) {
-    const count = self.scoreRules.length;
-    return {
-        label: count > 0 ? `Reference lines (${count})...` : 'Reference lines...',
-        onClick: () => {
-            getDialogHost(self).queueDialog(handleClose => [
-                SetScoreRulesDialog,
-                { model: self, handleClose },
-            ]);
-        },
-    };
-}
-export function makeScoreSubMenu(self, opts = {}) {
-    const { label = 'Score', leadingItems = [], trailingItems = [], disabled, disabledHelpText, } = opts;
-    return {
-        label,
+        label: `${label}${caption(self)}...`,
         icon: EqualizerIcon,
         disabled,
         disabledHelpText,
-        subMenu: [
-            ...leadingItems,
-            makeScaleTypeSubMenu(self),
-            makeClipOutliersItem(self),
-            ...(rulesABand(self) ? [makeAxisZeroItem(self)] : []),
-            makeSetMinMaxScoreItem(self),
-            ...(autoscalesInGroups(self) ? [makeAutoscaleGroupItem(self)] : []),
-            ...(drawsScoreRules(self) ? [makeSetScoreRulesItem(self)] : []),
-            ...trailingItems,
-        ],
+        onClick: () => {
+            const session = getSession(self);
+            if (isSessionModelWithWidgets(session)) {
+                session.openWidget(SCORE_AXIS_WIDGET, 'scoreAxis', {
+                    display: self.id,
+                    label,
+                });
+            }
+        },
     };
 }

package/esm/valueScaleConfigSchema.d.ts

@@ -1,7 +1,7 @@
 import type { Instance } from '@jbrowse/mobx-state-tree';
 export declare const VALUE_SCALE_TYPES: readonly ['linear', 'log', 'symlog'];
 export interface ValueScaleOptions {
-    /** `domainQuantile`'s default: 1 follows the extremes, 0.99 clips the outermost 1% */
+    /** `domainQuantile`'s default: 1 follows the extremes, 0.99 fences a spike */
     domainQuantile?: number;
     /** `symlogConstant`'s default */
     symlogConstant?: number;
@@ -35,9 +35,8 @@ export type ValueScaleRuleConfig = Instance<ReturnType<typeof valueScaleRuleSche
  * autoscaled linear or symlog axis reaches 0 whatever those regions hold.
  *
  * Two defaults come from the display rather than from the scale.
- * `domainQuantile` starts at `0.99` on the wiggle plot, clipping the outermost
- * 1% of each sign, and at `1`, the extremes, on the coverage band and the mark
- * display. `symlogConstant` starts at `0` on the wiggle family and the mark
+ * `domainQuantile` starts at `0.99` on the wiggle plot, fencing a spike, and
+ * at `1`, the extremes, on the coverage band and the mark display. `symlogConstant` starts at `0` on the wiggle family and the mark
  * display and at `1` on the coverage band.
  *
  * Every scale carries the same guides: `rules`, reference lines at chosen
@@ -65,7 +64,7 @@ export type ValueScaleRuleConfig = Instance<ReturnType<typeof valueScaleRuleSche
  * ```
  *
  * #example
- * The whole visible range, rather than the 99th percentile the wiggle
+ * The whole visible range, spikes included, rather than the fence the wiggle
  * displays start on:
  * ```js
  * {

package/esm/valueScaleConfigSchema.js

@@ -50,9 +50,8 @@ function valueScaleRuleSchema() {
  * autoscaled linear or symlog axis reaches 0 whatever those regions hold.
  *
  * Two defaults come from the display rather than from the scale.
- * `domainQuantile` starts at `0.99` on the wiggle plot, clipping the outermost
- * 1% of each sign, and at `1`, the extremes, on the coverage band and the mark
- * display. `symlogConstant` starts at `0` on the wiggle family and the mark
+ * `domainQuantile` starts at `0.99` on the wiggle plot, fencing a spike, and
+ * at `1`, the extremes, on the coverage band and the mark display. `symlogConstant` starts at `0` on the wiggle family and the mark
  * display and at `1` on the coverage band.
  *
  * Every scale carries the same guides: `rules`, reference lines at chosen
@@ -80,7 +79,7 @@ function valueScaleRuleSchema() {
  * ```
  *
  * #example
- * The whole visible range, rather than the 99th percentile the wiggle
+ * The whole visible range, spikes included, rather than the fence the wiggle
  * displays start on:
  * ```js
  * {
@@ -135,8 +134,8 @@ export function valueScaleSchema({ domainQuantile = 1, symlogConstant = 0, } = {
         /**
          * #slot scales.y.domainMin
          * The bottom of the axis, pinning what would otherwise autoscale to the
-         * loaded regions. Unset autoscales that end. The score menu's "Set
-         * min/max" writes here.
+         * loaded regions. Unset autoscales that end. The Y axis panel's Min
+         * field writes here.
          */
         domainMin: {
             type: 'maybeNumber',
@@ -158,7 +157,7 @@ export function valueScaleSchema({ domainQuantile = 1, symlogConstant = 0, } = {
          * Off, the axis spans the values alone. A pinned end is unmoved either
          * way, a log axis has no 0, and a density plot, which maps score to
          * colour and has no axis, spans its values whatever this says.
-         * The score menu's "Start axis at 0" toggles it.
+         * The Y axis panel's "Include 0" toggles it.
          */
         zero: {
             type: 'boolean',
@@ -170,8 +169,8 @@ export function valueScaleSchema({ domainQuantile = 1, symlogConstant = 0, } = {
          * A name shared by the tracks whose axes autoscale together: each
          * unpinned end spans the data of every track in the view naming the
          * same group, so three coverage lanes stay comparable as the view
-         * moves. A pinned end stays this track's own. The score menu's
-         * "Autoscale with other tracks" writes it.
+         * moves. A pinned end stays this track's own. The Y axis panel's
+         * "Share axis with" writes it.
          */
         autoscaleGroup: {
             type: 'maybeString',
@@ -193,24 +192,27 @@ export function valueScaleSchema({ domainQuantile = 1, symlogConstant = 0, } = {
         },
         /**
          * #slot scales.y.domainQuantile
-         * What an unpinned end follows over the loaded values: `1` their
-         * extremes, and below it that quantile of the values on its side of 0,
-         * so `0.99` drops the outermost 1% at each end and one spike no longer
-         * flattens the rest. Where both signs appear each end is measured on its
-         * own sign, so a sparse minority tail stays visible; whether the axis
-         * then reaches 0 is `zero`'s. The score menu's "Clip outliers" toggles
-         * it.
+         * Where an unpinned end's outliers are fenced. An end follows the
+         * loaded values' extreme; below `1`, an extreme that would stretch the
+         * axis past twice the span this quantile of the values draws stops at
+         * that fence, and the bars past it wear the red clip strip. So `0.99`
+         * leaves a plot with no spike whole and keeps one spike from flattening
+         * the rest. Each end's quantile is measured among the values on its side
+         * of 0, so a sparse minority tail stays visible, and the span includes 0
+         * where `zero` reaches it. A colour ramp's `domainQuantile` clips at the
+         * quantile itself, since a saturated colour hides nothing its key does
+         * not say. The Y axis panel's "Clip extreme outliers" toggles it.
          */
         domainQuantile: {
             type: 'number',
             defaultValue: domainQuantile,
-            description: 'the quantile an unpinned end follows: 1 the extremes, 0.99 drops the outermost 1% at each end, each sign measured on its own',
+            description: 'fences outliers: 1 follows the extremes; below it an extreme past twice the span this quantile draws is cut there',
         },
         /**
          * #slot scales.y.grid
          * Rule the plot across at every tick, ggplot2's panel grid and
-         * Vega-Lite's `axis.grid`. The score menu's "Show cross hatches"
-         * toggles it.
+         * Vega-Lite's `axis.grid`. The Y axis panel's "Grid lines" toggles
+         * it.
          */
         grid: {
             type: 'boolean',

package/esm/visibleStatsDomain.d.ts

@@ -17,7 +17,6 @@ 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.
- * reference/FETCH_SKELETON.md, "Every fetch autorun runs on the leading edge".
  */
 export interface SettledBlocksView {
     initialized: boolean;