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

package/esm/autoscale.js

@@ -1,7 +1,7 @@
-import { 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);
+import { fenceOutliers, quantileExtent, } from '@jbrowse/core/util/quantileExtent';
+/** The wiggle packer's arrays as a span, under an aggregate and an extent. */
+export function datasetSpan({ data, visStart, visEnd }, aggregate, extent) {
+    const { low, high } = boundArrays(aggregate, extent);
     return {
         count: data.numFeatures,
         starts: data.featurePositions,
@@ -17,13 +17,13 @@ export function datasetSpan({ data, visStart, visEnd }, summaryScoreMode) {
 }
 /**
  * #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 function getEffectiveScores(data, summaryScoreMode) {
-    return summaryScoreMode === 'min'
+export function getEffectiveScores(data, aggregate) {
+    return aggregate === 'min'
         ? data.featureMinScores
-        : summaryScoreMode === 'max'
+        : aggregate === 'max'
             ? data.featureMaxScores
             : data.featureScores;
 }
@@ -31,19 +31,15 @@ export function getEffectiveScores(data, summaryScoreMode) {
 function overlaps(fStart, fEnd, visStart, visEnd) {
     return fEnd > visStart && fStart < visEnd;
 }
-// Which per-feature array each end of the domain comes from. Whiskers spreads
-// the two ends across the min/max summary arrays; every other mode draws both
-// from a single scalar. One table because the extent and the clipped bound have
-// to read the same arrays, or a domain clips its own data.
-function boundArrays(summaryScoreMode) {
-    const useWhiskers = summaryScoreMode === 'whiskers';
+// Which per-feature array each end of the domain comes from. A min-max extent
+// spreads the two ends across the min/max summary arrays; without one both come
+// from the aggregate's single array. One table because the data's span and the
+// clipped bound have to read the same arrays, or a domain clips its own data.
+function boundArrays(aggregate, extent) {
+    const minMax = extent === 'min-max';
     return {
-        low: (data) => useWhiskers
-            ? data.featureMinScores
-            : getEffectiveScores(data, summaryScoreMode),
-        high: (data) => useWhiskers
-            ? data.featureMaxScores
-            : getEffectiveScores(data, summaryScoreMode),
+        low: (data) => minMax ? data.featureMinScores : getEffectiveScores(data, aggregate),
+        high: (data) => minMax ? data.featureMaxScores : getEffectiveScores(data, aggregate),
     };
 }
 // First index whose instance STARTS at or after `bp`. `starts` is sorted by
@@ -122,18 +118,19 @@ export function computeSpanStats(spans) {
         : undefined;
 }
 /** `computeSpanStats` over the wiggle packer's datasets. */
-export function computeScoreStats(summaryScoreMode, datasets) {
-    return computeSpanStats(datasets.map(d => datasetSpan(d, summaryScoreMode)));
+export function computeScoreStats(aggregate, datasets, extent) {
+    return computeSpanStats(datasets.map(d => datasetSpan(d, aggregate, extent)));
 }
 /**
  * #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 +150,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, aggregate, extent, visibleEntries, }) {
     return autoscaleDomainFromSpans({
         stats,
         quantile,
-        spans: visibleEntries.map(d => datasetSpan(d, summaryScoreMode)),
+        zero,
+        spans: visibleEntries.map(d => datasetSpan(d, aggregate, extent)),
     });
 }
 /**
  * #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) {
-    const spans = visibleEntries.map(d => datasetSpan(d, summaryScoreMode));
+export function computeAutoscaleDomain(quantile, aggregate, visibleEntries, zero, extent = 'none') {
+    const spans = visibleEntries.map(d => datasetSpan(d, aggregate, extent));
     const stats = computeSpanStats(spans);
     return stats
-        ? autoscaleDomainFromSpans({ stats, quantile, spans })
+        ? autoscaleDomainFromSpans({ stats, quantile, zero, spans })
         : undefined;
 }

package/esm/chrome.d.ts

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

package/esm/chrome.js

@@ -3,5 +3,4 @@
 // an adapter or an RPC method never does.
 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';
+export { makeMarkSizeSubMenu } from './pointSizeMenu.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;
@@ -21,4 +20,6 @@ export interface WiggleDataResult {
     zoomRange?: ZoomRange;
     /** The bounds the adapter's values lie in by definition (`getValueDomain`). */
     valueDomain?: [number, number];
+    /** What the adapter's source listing dropped or could not match. */
+    warnings?: string[];
 }

package/esm/index.d.ts

@@ -1,5 +1,5 @@
-export { retiredAxisSpellings, scalesSchema, valueScaleSchema, } from './valueScaleConfigSchema.ts';
-export type { ScalesConfigSchema, ValueScaleConfigSchema, ValueScaleOptions, } from './valueScaleConfigSchema.ts';
+export { retiredAxisSpellings, retiredScaleSpellings, scalesSchema, valueScaleOf, valueScaleSchema, } from './valueScaleConfigSchema.ts';
+export type { ScalesConfigSchema, ValueScaleConfigSchema, ValueScaleOptions, ValueScaleRuleConfig, } from './valueScaleConfigSchema.ts';
 export { getNiceDomain, getNiceScale, getScale } from './scale.ts';
 export type { ScaleOpts } from './scale.ts';
 export { toP } from './formatNumber.ts';
@@ -11,22 +11,21 @@ export { DEFAULT_RULE_COLOR, SCORE_CAPTION_HEIGHT, YSCALEBAR_LABEL_OFFSET, } fro
 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, 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 { 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';
-export { WiggleScoreConfigMixin, wiggleScoreConfigExtraSlots, } from './WiggleScoreConfigMixin.ts';
+export { WiggleScoreConfigMixin } from './WiggleScoreConfigMixin.ts';
 export type { WiggleScoreConfigHost } from './WiggleScoreConfigMixin.ts';
-export { ScoreFieldConfigMixin } from './ScoreFieldConfigMixin.ts';
-export { DEFAULT_SCORE_FIELD, scoreFieldConfigSchemaFields, } from './scoreFieldConfigSchemaFields.ts';
+export { YFieldConfigMixin } from './YFieldConfigMixin.ts';
+export { DEFAULT_SCORE_FIELD, yFieldConfigSchemaFields, } from './yFieldConfigSchemaFields.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';

package/esm/index.js

@@ -1,4 +1,4 @@
-export { retiredAxisSpellings, scalesSchema, valueScaleSchema, } from './valueScaleConfigSchema.js';
+export { retiredAxisSpellings, retiredScaleSpellings, scalesSchema, valueScaleOf, 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, } from './normalize.js';
@@ -11,17 +11,16 @@ 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, 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';
-export { ScoreFieldConfigMixin } from './ScoreFieldConfigMixin.js';
-export { DEFAULT_SCORE_FIELD, scoreFieldConfigSchemaFields, } from './scoreFieldConfigSchemaFields.js';
+export { WiggleScoreConfigMixin } from './WiggleScoreConfigMixin.js';
+export { YFieldConfigMixin } from './YFieldConfigMixin.js';
+export { DEFAULT_SCORE_FIELD, yFieldConfigSchemaFields, } from './yFieldConfigSchemaFields.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';

package/esm/pointSizeMenu.d.ts

@@ -1,32 +1,20 @@
-import type { ConfigModelForFields } from '@jbrowse/core/configuration';
 import type { MenuItem } from '@jbrowse/core/ui';
-/** 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;
+import type { ElementType } from 'react';
 /**
- * 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.
+ * A top-level submenu holding a mark's size slider, or nothing where the plot
+ * draws no such mark, 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 & {
+export declare function makeMarkSizeSubMenu({ label, title, icon, applies, value, isDefault, set, min, max, step, }: {
     label: string;
+    title?: string;
+    icon?: ElementType;
     applies: boolean;
+    value: () => number;
+    isDefault: boolean;
+    set: (n?: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
 }): MenuItem[];

package/esm/pointSizeMenu.js

@@ -1,37 +1,26 @@
-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);
-        },
-    };
-}
-/**
- * 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.
+ * A top-level submenu holding a mark's size slider, or nothing where the plot
+ * draws no such mark, 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, }) {
+export function makeMarkSizeSubMenu({ label, title = 'Point size', icon = ScatterPlotIcon, applies, value, isDefault, set, min, max, step, }) {
     return applies
         ? [
             {
                 label,
-                icon: ScatterPlotIcon,
+                icon,
                 subMenu: [
                     makeSizeMenu({
                         label,
-                        title: 'Point size',
+                        title,
+                        min,
+                        max,
+                        step,
                         getValue: value,
-                        isDefault: value() === defaultValue,
+                        isDefault,
                         onChange: set,
                         onReset: () => {
                             set();

package/esm/renderingBackendTypes.d.ts

@@ -41,6 +41,7 @@ export interface SourceRenderData {
     colorsAbgr?: Uint32Array;
     negColor?: [number, number, number];
     gapLimitBp?: number;
+    gapScore?: number;
     band?: {
         minScores: Float32Array;
     };

package/esm/renderingBackendTypes.js

@@ -27,6 +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
+// The most cuts a threshold color parts a plot at: the shader's uniform
 // block holds this many.
 export const MAX_WIGGLE_CUTS = GENERATED_MAX_WIGGLE_CUTS;

package/esm/scale.d.ts

@@ -37,10 +37,11 @@ export declare function getScale({ domain, range, scaleType, symlogConstant, nic
 /**
  * #api
  * 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.
+ * domain to 0 (`scales.y.zero`, ADR-182); a log domain has no 0, so a min at
+ * or below it floors to a positive value and a positive min stays where the
+ * data put it. 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, which the `log-floor` rule reports.
  *
  * 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

package/esm/scale.js

@@ -65,10 +65,11 @@ export function getScale({ domain, range, scaleType, symlogConstant, nice = true
 /**
  * #api
  * 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.
+ * domain to 0 (`scales.y.zero`, ADR-182); a log domain has no 0, so a min at
+ * or below it floors to a positive value and a positive min stays where the
+ * data put it. 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, which the `log-floor` rule reports.
  *
  * 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
@@ -92,11 +93,6 @@ export function getNiceDomain({ scaleType, domain, bounds, zero, }) {
             min = 0;
         }
     }
-    if (scaleType === 'log') {
-        if (min >= 0 && max > 1) {
-            min = 1;
-        }
-    }
     if (minScore !== undefined) {
         min = minScore;
     }
@@ -147,7 +143,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,
+                });
+            }
+        },
     };
 }