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

package/esm/valueScaleConfigSchema.d.ts

@@ -0,0 +1,253 @@
+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?: number;
+    /** `symlogConstant`'s default */
+    symlogConstant?: number;
+}
+declare function valueScaleRuleSchema(): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    readonly value: {
+        type: "number";
+    } & {
+        defaultValue: number;
+    };
+    readonly color: {
+        type: "maybeColor";
+    };
+    readonly label: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
+export type ValueScaleRuleConfig = Instance<ReturnType<typeof valueScaleRuleSchema>>;
+/**
+ * #config ValueScale
+ * #category display
+ * The value scale of a quantitative display, written as `scales.y`: the
+ * wiggle plot, the alignments coverage band and the mark display, the
+ * Manhattan plot among them, each carry one, with the axis guides it draws —
+ * its ticks, its `grid`, its `rules` and its `title`.
+ *
+ * Vega-Lite's spelling: a pinned end is `domainMin` or `domainMax`, an end
+ * left unset autoscales over the loaded regions, and `zero` says whether an
+ * 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
+ * display and at `1` on the coverage band.
+ *
+ * Every scale carries the same guides: `rules`, reference lines at chosen
+ * values, `grid`, a line at every tick, `minimalTicks`, and `title`, the
+ * caption beside the axis. A rule naming no `color` draws in the one colour
+ * the chrome rules every plot in, so a red line is a claim its author makes
+ * rather than a meaning a display assigns.
+ *
+ * #example
+ * A log axis floored at 1:
+ * ```js
+ * {
+ *   type: 'LinearWiggleDisplay',
+ *   scales: { y: { type: 'log', domainMin: 1 } },
+ * }
+ * ```
+ *
+ * #example
+ * A GC line plot whose axis spans the loaded values, 30 to 60%:
+ * ```js
+ * {
+ *   type: 'LinearWiggleDisplay',
+ *   scales: { y: { zero: false } },
+ * }
+ * ```
+ *
+ * #example
+ * The whole visible range, rather than the 99th percentile the wiggle
+ * displays start on:
+ * ```js
+ * {
+ *   type: 'LinearWiggleDisplay',
+ *   scales: { y: { domainQuantile: 1 } },
+ * }
+ * ```
+ *
+ * #example
+ * Three samples' coverage on one axis that still follows the data, each
+ * track's display naming the same group:
+ * ```js
+ * {
+ *   type: 'LinearAlignmentsDisplay',
+ *   scales: { y: { autoscaleGroup: 'depth' } },
+ * }
+ * ```
+ *
+ * #example
+ * A titled axis with a labelled genome-wide threshold over a plain
+ * suggestive one:
+ * ```js
+ * {
+ *   type: 'LinearMarkDisplay',
+ *   scales: {
+ *     y: {
+ *       title: '-log10 p',
+ *       rules: [{ value: 7.3, color: 'red', label: 'p = 5e-8' }, 5],
+ *     },
+ *   },
+ * }
+ * ```
+ */
+export declare function valueScaleSchema({ domainQuantile, symlogConstant, }?: ValueScaleOptions): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    readonly type: {
+        type: "stringEnum";
+    } & {
+        model: import("@jbrowse/mobx-state-tree").ISimpleType<"linear" | "log" | "symlog">;
+    } & {
+        defaultValue: string;
+    };
+    readonly domainMin: {
+        type: "maybeNumber";
+    };
+    readonly domainMax: {
+        type: "maybeNumber";
+    };
+    readonly zero: {
+        type: "boolean";
+    } & {
+        defaultValue: boolean;
+    };
+    readonly autoscaleGroup: {
+        type: "maybeString";
+    };
+    readonly symlogConstant: {
+        type: "number";
+    } & {
+        defaultValue: number;
+    };
+    readonly domainQuantile: {
+        type: "number";
+    } & {
+        defaultValue: number;
+    };
+    readonly grid: {
+        type: "boolean";
+    } & {
+        defaultValue: boolean;
+    };
+    readonly minimalTicks: {
+        type: "boolean";
+    } & {
+        defaultValue: boolean;
+    };
+    readonly title: {
+        type: "maybeString";
+    };
+    readonly rules: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly value: {
+            type: "number";
+        } & {
+            defaultValue: number;
+        };
+        readonly color: {
+            type: "maybeColor";
+        };
+        readonly label: {
+            type: "string";
+        } & {
+            defaultValue: string;
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>>;
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
+export type ValueScaleConfigSchema = ReturnType<typeof valueScaleSchema>;
+/**
+ * The axis guides v4 spelt on the display, as `retired` declares them on each
+ * display whose scale took them over.
+ */
+export declare const retiredAxisSpellings: {
+    displayCrossHatches: (grid: unknown) => {
+        scales: {
+            y: {
+                grid: unknown;
+            };
+        };
+    };
+    minimalTicks: (minimalTicks: unknown) => {
+        scales: {
+            y: {
+                minimalTicks: unknown;
+            };
+        };
+    };
+};
+/**
+ * The `scales` object a display declares, one member per aesthetic the
+ * grammar gives a scale. `y` is the only one so far, and every mark, bar or
+ * bin the display draws is placed through it.
+ */
+export declare function scalesSchema(y: ValueScaleConfigSchema): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    readonly y: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly type: {
+            type: "stringEnum";
+        } & {
+            model: import("@jbrowse/mobx-state-tree").ISimpleType<"linear" | "log" | "symlog">;
+        } & {
+            defaultValue: string;
+        };
+        readonly domainMin: {
+            type: "maybeNumber";
+        };
+        readonly domainMax: {
+            type: "maybeNumber";
+        };
+        readonly zero: {
+            type: "boolean";
+        } & {
+            defaultValue: boolean;
+        };
+        readonly autoscaleGroup: {
+            type: "maybeString";
+        };
+        readonly symlogConstant: {
+            type: "number";
+        } & {
+            defaultValue: number;
+        };
+        readonly domainQuantile: {
+            type: "number";
+        } & {
+            defaultValue: number;
+        };
+        readonly grid: {
+            type: "boolean";
+        } & {
+            defaultValue: boolean;
+        };
+        readonly minimalTicks: {
+            type: "boolean";
+        } & {
+            defaultValue: boolean;
+        };
+        readonly title: {
+            type: "maybeString";
+        };
+        readonly rules: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            readonly value: {
+                type: "number";
+            } & {
+                defaultValue: number;
+            };
+            readonly color: {
+                type: "maybeColor";
+            };
+            readonly label: {
+                type: "string";
+            } & {
+                defaultValue: string;
+            };
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>>;
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
+export type ScalesConfigSchema = ReturnType<typeof scalesSchema>;
+export {};

package/esm/valueScaleConfigSchema.js

@@ -0,0 +1,270 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration';
+import { types } from '@jbrowse/mobx-state-tree';
+export const VALUE_SCALE_TYPES = ['linear', 'log', 'symlog'];
+function valueScaleRuleSchema() {
+    return ConfigurationSchema('ValueScaleRule', {
+        /**
+         * #slot scales.y.rules.value
+         * Where the rule sits on the axis, in the units the axis plots: a
+         * `-log10(p)` over a Manhattan plot, a depth over coverage.
+         */
+        value: {
+            type: 'number',
+            defaultValue: 0,
+            description: 'the value the rule is drawn at',
+        },
+        /**
+         * #slot scales.y.rules.color
+         * The line's colour, and its label's. Unset draws every rule in the one
+         * colour the chrome rules plots in, so a threshold that means something
+         * particular — genome-wide significance, a diploid depth — is one an
+         * author paints, on the plot where it means it.
+         */
+        color: {
+            type: 'maybeColor',
+            description: 'line and label colour; unset is the chrome’s own',
+        },
+        /**
+         * #slot scales.y.rules.label
+         * Free text drawn at the rule's right-hand end. JBrowse assigns it no
+         * meaning: "2 copies" over a coverage plot is a claim only the author
+         * can make, since no ploidy can be assumed.
+         */
+        label: {
+            type: 'string',
+            defaultValue: '',
+            description: "text at the rule's right-hand end",
+        },
+    }, { shorthand: 'value', closed: true });
+}
+/**
+ * #config ValueScale
+ * #category display
+ * The value scale of a quantitative display, written as `scales.y`: the
+ * wiggle plot, the alignments coverage band and the mark display, the
+ * Manhattan plot among them, each carry one, with the axis guides it draws —
+ * its ticks, its `grid`, its `rules` and its `title`.
+ *
+ * Vega-Lite's spelling: a pinned end is `domainMin` or `domainMax`, an end
+ * left unset autoscales over the loaded regions, and `zero` says whether an
+ * 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
+ * display and at `1` on the coverage band.
+ *
+ * Every scale carries the same guides: `rules`, reference lines at chosen
+ * values, `grid`, a line at every tick, `minimalTicks`, and `title`, the
+ * caption beside the axis. A rule naming no `color` draws in the one colour
+ * the chrome rules every plot in, so a red line is a claim its author makes
+ * rather than a meaning a display assigns.
+ *
+ * #example
+ * A log axis floored at 1:
+ * ```js
+ * {
+ *   type: 'LinearWiggleDisplay',
+ *   scales: { y: { type: 'log', domainMin: 1 } },
+ * }
+ * ```
+ *
+ * #example
+ * A GC line plot whose axis spans the loaded values, 30 to 60%:
+ * ```js
+ * {
+ *   type: 'LinearWiggleDisplay',
+ *   scales: { y: { zero: false } },
+ * }
+ * ```
+ *
+ * #example
+ * The whole visible range, rather than the 99th percentile the wiggle
+ * displays start on:
+ * ```js
+ * {
+ *   type: 'LinearWiggleDisplay',
+ *   scales: { y: { domainQuantile: 1 } },
+ * }
+ * ```
+ *
+ * #example
+ * Three samples' coverage on one axis that still follows the data, each
+ * track's display naming the same group:
+ * ```js
+ * {
+ *   type: 'LinearAlignmentsDisplay',
+ *   scales: { y: { autoscaleGroup: 'depth' } },
+ * }
+ * ```
+ *
+ * #example
+ * A titled axis with a labelled genome-wide threshold over a plain
+ * suggestive one:
+ * ```js
+ * {
+ *   type: 'LinearMarkDisplay',
+ *   scales: {
+ *     y: {
+ *       title: '-log10 p',
+ *       rules: [{ value: 7.3, color: 'red', label: 'p = 5e-8' }, 5],
+ *     },
+ *   },
+ * }
+ * ```
+ */
+export function valueScaleSchema({ domainQuantile = 1, symlogConstant = 0, } = {}) {
+    return ConfigurationSchema('ValueScale', {
+        /**
+         * #slot scales.y.type
+         * How the axis reads its domain — the ticks, the cross-hatches and the
+         * renderer's placement all come from it. `log` cannot represent 0 or
+         * negative values and floors the domain above them; `symlog` is log-like
+         * away from zero and linear through it, so a track whose values touch or
+         * cross 0 keeps them.
+         */
+        // #region stringEnumSlot
+        type: {
+            type: 'stringEnum',
+            model: types.enumeration('ValueScaleType', [...VALUE_SCALE_TYPES]),
+            defaultValue: 'linear',
+            description: VALUE_SCALE_TYPES.join(' or '),
+        },
+        // #endregion
+        /**
+         * #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.
+         */
+        domainMin: {
+            type: 'maybeNumber',
+            description: 'pinned bottom of the axis; unset autoscales',
+        },
+        /**
+         * #slot scales.y.domainMax
+         * The top of the axis. Unset autoscales that end.
+         */
+        domainMax: {
+            type: 'maybeNumber',
+            description: 'pinned top of the axis; unset autoscales',
+        },
+        /**
+         * #slot scales.y.zero
+         * Whether an autoscaled linear or symlog axis reaches 0 whatever the
+         * loaded values span, Vega-Lite's `zero`. On, a plot of values between
+         * 30 and 60 draws 0 to 60, and a bar always shows its whole height.
+         * 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.
+         */
+        zero: {
+            type: 'boolean',
+            defaultValue: true,
+            description: 'an autoscaled linear or symlog axis reaches 0; off, it spans the loaded values',
+        },
+        /**
+         * #slot scales.y.autoscaleGroup
+         * 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.
+         */
+        autoscaleGroup: {
+            type: 'maybeString',
+            description: 'tracks naming one group autoscale together',
+        },
+        /**
+         * #slot scales.y.symlogConstant
+         * Width of symlog's linear region around zero. `0` derives it from
+         * the domain, a thousandth of its largest magnitude — right for a
+         * wiggle track, whose units are its own. The coverage band starts
+         * at `1` instead, which makes symlog exactly `log(depth+1)` and
+         * puts the knee at one read.
+         */
+        symlogConstant: {
+            type: 'number',
+            defaultValue: symlogConstant,
+            description: "width of symlog's linear region around zero",
+            advanced: true,
+        },
+        /**
+         * #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.
+         */
+        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',
+        },
+        /**
+         * #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.
+         */
+        grid: {
+            type: 'boolean',
+            defaultValue: false,
+            description: 'rule the plot at the tick positions',
+        },
+        /**
+         * #slot scales.y.minimalTicks
+         * Label only the two ends of the axis.
+         */
+        minimalTicks: {
+            type: 'boolean',
+            defaultValue: false,
+            description: 'label only the ends of the axis',
+            advanced: true,
+        },
+        /**
+         * #slot scales.y.title
+         * The caption beside the axis, naming what it measures, drawn
+         * once however many bands the scale rules and at every zoom.
+         * Optional, as JBrowse's other captions are: unset, `""` or
+         * `null`, the axis has none; some text is that text.
+         */
+        title: {
+            type: 'maybeString',
+            description: 'axis caption; unset draws none',
+        },
+        /**
+         * #slot scales.y.rules
+         * Horizontal reference lines at chosen values, across every band
+         * the scale rules: a significance threshold, a zero line, an
+         * allele-frequency cut. Each is `{ value, color, label }`, or a
+         * bare number for a plain line. An autoscaled end widens to keep
+         * every rule on the axis; a pinned `domainMin` or `domainMax`
+         * that excludes a rule drops it.
+         */
+        rules: types.array(valueScaleRuleSchema()),
+    }, { closed: true });
+}
+/**
+ * The axis guides v4 spelt on the display, as `retired` declares them on each
+ * display whose scale took them over.
+ */
+export const retiredAxisSpellings = {
+    displayCrossHatches: (grid) => ({ scales: { y: { grid } } }),
+    minimalTicks: (minimalTicks) => ({
+        scales: { y: { minimalTicks } },
+    }),
+};
+/**
+ * The `scales` object a display declares, one member per aesthetic the
+ * grammar gives a scale. `y` is the only one so far, and every mark, bar or
+ * bin the display draws is placed through it.
+ */
+export function scalesSchema(y) {
+    return ConfigurationSchema('Scales', { y }, { closed: true });
+}

package/esm/visibleStatsDomain.d.ts

@@ -17,7 +17,7 @@ export interface VisibleEntry<T> {
  * `coarseDynamicBlocks`: over the empty initial coarse list every walker below
  * yields no entries, and no entries is not a stale domain but the caller's
  * `[0, 1]` fallback — a bigwig line track drew blank and a density track solid.
- * ARCHITECTURE.md, "Every fetch autorun runs on the leading edge".
+ * reference/FETCH_SKELETON.md, "Every fetch autorun runs on the leading edge".
  */
 export interface SettledBlocksView {
     initialized: boolean;
@@ -34,7 +34,7 @@ export interface SettledBlocksView {
  * are in scope, how those pieces reduce to stats, and what an autoscale mode
  * makes of the stats.
  */
-export interface VisibleStatsDomainSpec<Payload, Item, Stats> {
+export interface VisibleStatsRangeSpec<Payload, Item, Stats> {
     /** false when the band this domain scales is not drawn: nothing is walked */
     active: boolean;
     view: SettledBlocksView;
@@ -44,16 +44,28 @@ export interface VisibleStatsDomainSpec<Payload, Item, Stats> {
     accumulate: (entries: VisibleEntry<Item>[]) => Stats | undefined;
     /** stats to a raw `[min, max]`, before bounds and nice-rounding */
     range: (stats: Stats, entries: VisibleEntry<Item>[]) => [number, number];
+}
+/** {@link VisibleStatsRangeSpec} and what nice-rounds its range into a domain. */
+export interface VisibleStatsDomainSpec<Payload, Item, Stats> extends VisibleStatsRangeSpec<Payload, Item, Stats> {
     /** `ScoreScaleMixin`'s resolved bounds; `undefined` autoscales that end */
     bounds: readonly [number | undefined, number | undefined];
     scaleType: string;
+    /** whether a linear or symlog domain reaches 0 (`scales.y.zero`) */
+    zero: boolean;
 }
 /**
  * #api
- * The visible score domain four displays derive identically: walk the settled
- * blocks, accumulate the stats of what each one shows, and nice-round the
- * autoscaled range inside the configured bounds. `undefined` while there is
- * nothing to scale against — no data, a hidden band, or a view that has not
- * initialized — which every caller distinguishes from a domain.
+ * The raw autoscaled range the displays with a value scale derive
+ * identically: walk the settled blocks, accumulate the stats of what each one
+ * shows, and reduce them to `[min, max]` before any bound or nice-rounding.
+ * `undefined` while there is nothing to scale against — no data, a hidden
+ * band, or a view that has not initialized — which every caller distinguishes
+ * from a range.
+ */
+export declare function visibleStatsRange<Payload, Item, Stats>({ active, view, payloadFor, itemsFor, accumulate, range, }: VisibleStatsRangeSpec<Payload, Item, Stats>): [number, number] | undefined;
+/**
+ * #api
+ * {@link visibleStatsRange} nice-rounded inside the configured bounds: the
+ * domain of a display whose range is its own alone.
  */
-export declare function visibleStatsDomain<Payload, Item, Stats>({ active, view, payloadFor, itemsFor, accumulate, range, bounds, scaleType, }: VisibleStatsDomainSpec<Payload, Item, Stats>): [number, number] | undefined;
+export declare function visibleStatsDomain<Payload, Item, Stats>({ bounds, scaleType, zero, ...spec }: VisibleStatsDomainSpec<Payload, Item, Stats>): [number, number] | undefined;

package/esm/visibleStatsDomain.js

@@ -1,33 +1,38 @@
 import { getNiceDomain } from './scale.js';
 /**
  * #api
- * The visible score domain four displays derive identically: walk the settled
- * blocks, accumulate the stats of what each one shows, and nice-round the
- * autoscaled range inside the configured bounds. `undefined` while there is
- * nothing to scale against — no data, a hidden band, or a view that has not
- * initialized — which every caller distinguishes from a domain.
+ * The raw autoscaled range the displays with a value scale derive
+ * identically: walk the settled blocks, accumulate the stats of what each one
+ * shows, and reduce them to `[min, max]` before any bound or nice-rounding.
+ * `undefined` while there is nothing to scale against — no data, a hidden
+ * band, or a view that has not initialized — which every caller distinguishes
+ * from a range.
  */
-export function visibleStatsDomain({ active, view, payloadFor, itemsFor, accumulate, range, bounds, scaleType, }) {
-    let domain;
-    if (active && view.initialized) {
-        const entries = view.settledDynamicBlocks.flatMap(block => {
-            const payload = block.displayedRegionIndex === undefined
-                ? undefined
-                : payloadFor(block.displayedRegionIndex);
-            const visStart = Math.floor(block.start);
-            const visEnd = Math.ceil(block.end);
-            return payload
-                ? itemsFor(payload).map(data => ({ visStart, visEnd, data }))
-                : [];
-        });
-        const stats = accumulate(entries);
-        if (stats) {
-            domain = getNiceDomain({
-                domain: range(stats, entries),
-                bounds,
-                scaleType,
-            });
-        }
+export function visibleStatsRange({ active, view, payloadFor, itemsFor, accumulate, range, }) {
+    if (!active || !view.initialized) {
+        return undefined;
     }
-    return domain;
+    const entries = view.settledDynamicBlocks.flatMap(block => {
+        const payload = block.displayedRegionIndex === undefined
+            ? undefined
+            : payloadFor(block.displayedRegionIndex);
+        const visStart = Math.floor(block.start);
+        const visEnd = Math.ceil(block.end);
+        return payload
+            ? itemsFor(payload).map(data => ({ visStart, visEnd, data }))
+            : [];
+    });
+    const stats = accumulate(entries);
+    return stats ? range(stats, entries) : undefined;
+}
+/**
+ * #api
+ * {@link visibleStatsRange} nice-rounded inside the configured bounds: the
+ * domain of a display whose range is its own alone.
+ */
+export function visibleStatsDomain({ bounds, scaleType, zero, ...spec }) {
+    const range = visibleStatsRange(spec);
+    return range
+        ? getNiceDomain({ domain: range, bounds, scaleType, zero })
+        : undefined;
 }

package/esm/wiggleRenderModes.generated.d.ts

@@ -3,7 +3,6 @@ export declare const RENDERING_TYPE_DENSITY = 1;
 export declare const RENDERING_TYPE_LINE = 2;
 export declare const RENDERING_TYPE_SCATTER = 3;
 export declare const RENDERING_TYPE_LINE_CENTER = 4;
-export declare const SCALE_TYPE_LOG = 1;
-export declare const SCALE_TYPE_SYMLOG = 2;
 export declare const NO_PREV_START = 4294967295;
 export declare const MIN_FILL_WIDTH_PX = 1.5;
+export declare const MAX_WIGGLE_CUTS = 8;

package/esm/wiggleRenderModes.generated.js

@@ -5,7 +5,6 @@ export const RENDERING_TYPE_DENSITY = 1;
 export const RENDERING_TYPE_LINE = 2;
 export const RENDERING_TYPE_SCATTER = 3;
 export const RENDERING_TYPE_LINE_CENTER = 4;
-export const SCALE_TYPE_LOG = 1;
-export const SCALE_TYPE_SYMLOG = 2;
 export const NO_PREV_START = 4294967295;
 export const MIN_FILL_WIDTH_PX = 1.5;
+export const MAX_WIGGLE_CUTS = 8;