@fundar/data-chart-telling 0.0.64 → 1.1.0

package/dist/phases/facet/FacetPanels.js

@@ -0,0 +1,95 @@
+/** The field a processed row carries its facet panel under. */
+export const PANEL_KEY = '__panel';
+/**
+ * What the "facet" phase's panels do to the rest of a plot's state: each
+ * series split into one per panel, a state narrowed to some panels, and one
+ * panel's part of a run over every panel.
+ */
+export class FacetPanels {
+    /** The id of a series' part in one facet panel. */
+    static buildSeriesId(panel, name) {
+        return `${panel}\u0000${name}`;
+    }
+    /**
+     * Each series split into one per facet panel, panel by panel: the same
+     * `name` (and so the same color and legend entry), its own `id` and `panel`,
+     * and only that panel's rows. A series with no rows in a panel has no part there.
+     */
+    static splitSeries(series, panels, panelOf) {
+        const rowsByPanel = series.map((s) => {
+            const groups = new Map();
+            for (const row of s.data) {
+                const key = panelOf(row);
+                if (key === undefined)
+                    continue;
+                const bucket = groups.get(key);
+                if (bucket)
+                    bucket.push(row);
+                else
+                    groups.set(key, [row]);
+            }
+            return groups;
+        });
+        return panels.flatMap((panel) => series.flatMap((s, i) => {
+            const rows = rowsByPanel[i].get(panel.key);
+            if (!rows?.length)
+                return [];
+            return [
+                {
+                    ...s,
+                    id: FacetPanels.buildSeriesId(panel.key, s.name),
+                    panel: panel.key,
+                    data: rows
+                }
+            ];
+        }));
+    }
+    /** A state narrowed to one panel's series, rows and processed rows. */
+    static narrowToPanel(state, panel) {
+        return FacetPanels.narrowToPanels(state, [panel]);
+    }
+    /** A state narrowed to some panels' series, rows and processed rows. */
+    static narrowToPanels(state, panels) {
+        const keep = new Set(panels);
+        const has = (panel) => keep.has(panel);
+        const resolvedSeries = state.resolvedSeries?.filter((s) => has(s.panel));
+        const { panelOf } = state;
+        return {
+            ...state,
+            resolvedSeries,
+            flat: panelOf
+                ? state.flat?.filter((row) => has(panelOf(row)))
+                : resolvedSeries?.flatMap((s) => s.data),
+            scopedGroups: state.scopedGroups?.filter((g) => has(g.panel)),
+            groupedSeries: state.groupedSeries?.filter((g) => has(g.series.panel)),
+            processedGroups: state.processedGroups?.filter((g) => has(g.series.panel)),
+            processedData: state.processedData && {
+                ...state.processedData,
+                data: state.processedData.data.filter((row) => has(row[PANEL_KEY]))
+            }
+        };
+    }
+    /**
+     * One facet panel's part of a run of the data phases over every panel: its
+     * series, rows, processed rows and markers, without the facet itself, ready
+     * for the phases each panel runs on its own.
+     */
+    static buildPanelState(state, panel) {
+        const narrowed = FacetPanels.narrowToPanel(state, panel);
+        const markers = state.markers?.flatMap((marker) => {
+            const own = marker;
+            if (own[PANEL_KEY] === undefined)
+                return [marker];
+            if (own[PANEL_KEY] !== panel)
+                return [];
+            const untagged = { ...own };
+            delete untagged[PANEL_KEY];
+            return [untagged];
+        });
+        const out = { ...narrowed, markers };
+        delete out.facet;
+        delete out.panels;
+        delete out.panelOf;
+        return out;
+    }
+}

package/dist/phases/facet/FacetPhase.d.ts

@@ -0,0 +1,11 @@
+import type { FacetStageState, PhaseStage } from '../../types/phases';
+/**
+ * The "facet" phase: the panels the plot's `facet` lays its rows out in, and
+ * which panel each row belongs to. It runs first, so the "data" phase builds
+ * every series already split by panel. A plot drawn from pre-built `series`
+ * has no rows to split, so its facet is ignored.
+ */
+export declare class FacetPhase<TState extends FacetStageState> implements PhaseStage<TState> {
+    readonly phase: "facet";
+    run: (state: TState) => TState;
+}

package/dist/phases/facet/FacetPhase.js

@@ -0,0 +1,28 @@
+import { buildFacetKeyOf, buildFacetPanels } from '../../layout/facet/config';
+import { PANEL_KEY } from './FacetPanels';
+/**
+ * The "facet" phase: the panels the plot's `facet` lays its rows out in, and
+ * which panel each row belongs to. It runs first, so the "data" phase builds
+ * every series already split by panel. A plot drawn from pre-built `series`
+ * has no rows to split, so its facet is ignored.
+ */
+export class FacetPhase {
+    phase = 'facet';
+    run = (state) => {
+        const { data, series } = state;
+        const facet = state.facet;
+        if (!facet || series || !data)
+            return state;
+        const panels = buildFacetPanels(facet, data).map(({ rows: _rows, ...panel }) => panel);
+        const keys = new Set(panels.map((p) => p.key));
+        const keyOf = buildFacetKeyOf(facet);
+        const panelOf = (row) => {
+            const tagged = row[PANEL_KEY];
+            if (typeof tagged === 'string')
+                return tagged;
+            const key = keyOf(row);
+            return keys.has(key) ? key : undefined;
+        };
+        return { ...state, panels, panelOf };
+    };
+}

package/dist/phases/hover/HoverPhase.d.ts

@@ -0,0 +1,36 @@
+import type { HoverDisplayPoint, HoverPoint } from '../../types/layout/hover';
+import { LegendState } from '../../layout/legend/LegendState.svelte';
+import type { AxisPlotCtx, AxisPlotState, HoverPosition, HoverStageOptions, PhaseStage, ProcessedData } from '../../types/phases';
+type AnyAxisState = AxisPlotState<any, any, any, any>;
+/**
+ * The "hover" phase every axis-based plot shares: what the pointer can match
+ * (`hover`), the rows it hovers over (`hoverRows`) and where each sits
+ * (`hoverPosition`). Candidates are the processed rows (or the kind's own
+ * hover `rows`) of the series the legend shows, except gap rows and rows
+ * outside the legend's narrowed range.
+ */
+export declare class HoverPhase<TState extends AnyAxisState, TCtx extends AxisPlotCtx> implements PhaseStage<TState, TCtx> {
+    #private;
+    readonly phase: "hover";
+    constructor(options?: HoverStageOptions<TState, TCtx>);
+    run: (state: TState, ctx: TCtx) => TState;
+    /**
+     * Hover candidates for a plot's own processed rows: each visible row at its
+     * position (a stacked row's top, a bin's centre), in its series' color. A
+     * series the legend turned off is left out, as is any row `include` rejects.
+     */
+    static buildProcessedHoverPoints<TRow extends Record<string, unknown>>(args: {
+        processed: ProcessedData;
+        colorFor: (seriesName: string) => string;
+        legendInteraction?: LegendState | null;
+        label: (row: TRow) => string;
+        include?: (row: TRow) => boolean;
+        /** The row a hovered point reads as, e.g. with derived fields added. Defaults to the processed row. */
+        row?: (row: TRow) => TRow;
+        /** Fields to add to (or replace on) each point. */
+        decorate?: (row: TRow) => Partial<HoverDisplayPoint>;
+        /** Where a row sits, as is. Defaults to its processed position, with `y` as a number. */
+        position?: HoverPosition;
+    }): HoverPoint<TRow>[];
+}
+export {};

package/dist/phases/hover/HoverPhase.js

@@ -0,0 +1,109 @@
+import { ProcessedPositions } from '../transforms/ProcessedPositions';
+import { GAP_VALUE, SERIES_KEY } from '../transforms/TransformsPhase';
+import { HoverSettings } from '../../layout/hover/HoverSettings';
+import { PlotAxes } from '../data/PlotAxes';
+import { isGapValue } from '../../plots/utils/gaps';
+import { LegendState } from '../../layout/legend/LegendState.svelte';
+/**
+ * The "hover" phase every axis-based plot shares: what the pointer can match
+ * (`hover`), the rows it hovers over (`hoverRows`) and where each sits
+ * (`hoverPosition`). Candidates are the processed rows (or the kind's own
+ * hover `rows`) of the series the legend shows, except gap rows and rows
+ * outside the legend's narrowed range.
+ */
+export class HoverPhase {
+    phase = 'hover';
+    #options;
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    run = (state, ctx) => {
+        const options = this.#options;
+        const valueAxis = PlotAxes.valueOf(state);
+        const raw = options.position?.(state) ??
+            ProcessedPositions.of(state.processedData, valueAxis);
+        // A processed position reads as raw; the hover controller and the plot's
+        // scales want its value as a number, unless that axis lays out categories.
+        const position = options.position || state.axes?.isDiscrete(valueAxis)
+            ? raw
+            : { ...raw, [valueAxis]: (row) => Number(raw[valueAxis](row)) };
+        const label = options.label?.(state) ??
+            ((row) => String(state.channels[valueAxis].accessor(row)));
+        const processed = options.rows
+            ? { ...state.processedData, data: options.rows(state) }
+            : state.processedData;
+        const points = HoverPhase.buildProcessedHoverPoints({
+            processed,
+            colorFor: state.colorForSeries,
+            legendInteraction: ctx.interaction?.legend,
+            label: label,
+            position,
+            include: HoverPhase.#hoverable(state, ctx, raw, valueAxis),
+            row: options.row?.(state),
+            decorate: options.decorate?.(state, ctx)
+        });
+        const hover = HoverSettings.buildConfig({
+            tooltip: state.tooltip,
+            format: options.format?.(state) ?? state.tooltipFormat,
+            sort: options.sort?.(state) ?? state.tooltipSort,
+            markers: state.authorMarkers ?? [],
+            points: points,
+            label: label,
+            defaultStrategy: options.strategy ?? HoverSettings.strategyOf(state.axes),
+            pointMatching: options.pointMatching
+        });
+        const hitAreas = options.hitAreas?.(state, hover, ctx) ?? [];
+        return {
+            ...state,
+            hover,
+            hoverPosition: position,
+            hoverRows: processed.data,
+            ...(hitAreas.length > 0 ? { markers: [...(state.markers ?? []), ...hitAreas] } : {})
+        };
+    };
+    /**
+     * Hover candidates for a plot's own processed rows: each visible row at its
+     * position (a stacked row's top, a bin's centre), in its series' color. A
+     * series the legend turned off is left out, as is any row `include` rejects.
+     */
+    static buildProcessedHoverPoints(args) {
+        const { processed, colorFor, legendInteraction, label, include, row: rowOf, decorate } = args;
+        const processedPosition = ProcessedPositions.of(processed);
+        const position = args.position ?? {
+            x: processedPosition.x,
+            y: (row) => Number(processedPosition.y(row))
+        };
+        const x = position.x;
+        const y = position.y;
+        return processed.data
+            .filter((d) => !legendInteraction?.isOff(d[SERIES_KEY]))
+            .filter((d) => !include || include(d))
+            .map((d) => {
+            const row = d;
+            const seriesName = d[SERIES_KEY];
+            return {
+                x: x(d),
+                y: y(d),
+                row: rowOf ? rowOf(row) : row,
+                label: label(row),
+                series: seriesName,
+                color: colorFor(seriesName),
+                ...decorate?.(row)
+            };
+        });
+    }
+    /**
+     * Which processed rows can be hovered: not a gap (no value where it sits, or
+     * filled in by `styles.gaps`), and, while the legend narrows a continuous
+     * color to a range, not outside it. A dimmed row stays drawn, never matched.
+     */
+    static #hoverable(state, ctx, position, valueAxis) {
+        const range = ctx.interaction?.legend?.range;
+        const color = state.channels?.color?.accessor;
+        return (row) => {
+            if (isGapValue(position[valueAxis](row)) || row[GAP_VALUE] !== undefined)
+                return false;
+            return !range || !color || LegendState.inRange(Number(color(row)), range);
+        };
+    }
+}

package/dist/phases/mapping/MappingPhase.d.ts

@@ -0,0 +1,17 @@
+import type { AxisPlotState, AxisPlotCtx, MappingStageOptions, PhaseStage } from '../../types/phases';
+type AnyAxisState = AxisPlotState<any, any, any, any>;
+/**
+ * The "mapping" phase every axis-based plot shares: every channel resolved to
+ * a row accessor. `x`/`y` (and `color`) read the first series' own, falling
+ * back to the plot's props; `grouping` is the key the "data" phase split rows
+ * by (its `seriesGrouping`); any other channel resolves only when
+ * its prop is set, and a size channel given a number stays that literal size.
+ * An unset `x`/`y` reads each row itself, with no `source`.
+ */
+export declare class MappingPhase<TState extends AnyAxisState, TCtx extends AxisPlotCtx> implements PhaseStage<TState, TCtx> {
+    #private;
+    readonly phase: "mapping";
+    constructor(options?: MappingStageOptions<TState, TCtx>);
+    run: (state: TState, ctx: TCtx) => TState;
+}
+export {};

package/dist/phases/mapping/MappingPhase.js

@@ -0,0 +1,40 @@
+import { resolveAccessor } from '../../plots/utils/accessors';
+/**
+ * The "mapping" phase every axis-based plot shares: every channel resolved to
+ * a row accessor. `x`/`y` (and `color`) read the first series' own, falling
+ * back to the plot's props; `grouping` is the key the "data" phase split rows
+ * by (its `seriesGrouping`); any other channel resolves only when
+ * its prop is set, and a size channel given a number stays that literal size.
+ * An unset `x`/`y` reads each row itself, with no `source`.
+ */
+export class MappingPhase {
+    phase = 'mapping';
+    #options;
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    run = (state, ctx) => {
+        const first = state.resolvedSeries?.[0];
+        const identity = { accessor: (d) => d };
+        const size = (value) => typeof value === 'number' ? value : MappingPhase.#channel(value);
+        const channels = {
+            x: MappingPhase.#channel(first?.x ?? state.x) ?? identity,
+            y: MappingPhase.#channel(first?.y ?? state.y) ?? identity,
+            grouping: MappingPhase.#channel(state.seriesGrouping),
+            color: MappingPhase.#channel(first?.color ?? state.color),
+            opacity: MappingPhase.#channel(state.opacity),
+            symbol: MappingPhase.#channel(state.symbol),
+            r: size(state.r),
+            length: size(state.length)
+        };
+        const next = { ...state, channels };
+        return this.#options.extend ? this.#options.extend(next, ctx) : next;
+    };
+    /** A channel prop resolved to a row accessor, keeping it as `source`, or left out when unset. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static #channel(accessor) {
+        return accessor !== undefined
+            ? { accessor: resolveAccessor(accessor), source: accessor }
+            : undefined;
+    }
+}

package/dist/phases/markers/MarkersPhase.d.ts

@@ -0,0 +1,14 @@
+import type { AxisPlotCtx, AxisPlotState, MarkersStageOptions, PhaseStage } from '../../types/phases';
+/**
+ * The shared "markers" phase: everything the plot draws, bottom to top - the
+ * plot kind's own marks, then what the "statistics" phase left in
+ * `state.markers` (the author's markers and the plot's statistics), then its
+ * value labels when `styles.values.show` turns them on, each with what every
+ * label shares ({@link ValueLabels.hooks}).
+ */
+export declare class MarkersPhase<TState extends AxisPlotState<any, any, any, any>, TCtx extends AxisPlotCtx> implements PhaseStage<TState, TCtx> {
+    #private;
+    readonly phase: "markers";
+    constructor(options: MarkersStageOptions<TState, TCtx>);
+    run: (state: TState, ctx: TCtx) => TState;
+}

package/dist/phases/markers/MarkersPhase.js

@@ -0,0 +1,27 @@
+/**
+ * The shared "markers" phase: everything the plot draws, bottom to top - the
+ * plot kind's own marks, then what the "statistics" phase left in
+ * `state.markers` (the author's markers and the plot's statistics), then its
+ * value labels when `styles.values.show` turns them on, each with what every
+ * label shares ({@link ValueLabels.hooks}).
+ */
+export class MarkersPhase {
+    phase = 'markers';
+    #options;
+    constructor(options) {
+        this.#options = options;
+    }
+    run = (state, ctx) => {
+        const options = this.#options;
+        const labels = state.valueLabels;
+        const valueLabels = labels?.show && options.valueLabels
+            ? options
+                .valueLabels(labels, state, ctx)
+                .map((marker) => ({ ...labels.hooks(ctx), ...marker }))
+            : [];
+        return {
+            ...state,
+            markers: [...options.marks(state, ctx), ...(state.markers ?? []), ...valueLabels]
+        };
+    };
+}

package/dist/phases/scales/MarkerAxisValues.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Every finite numeric value a set of markers draws on one axis, read from
+ * each marker's own `data`: its position channel and its range edges (`x1`/`x2`
+ * for `x`), so a rect's or a band's full extent counts, not just its middle.
+ * Markers without their own `data` reuse the plot's rows, which the plot's
+ * domain already covers, so they're skipped. Lets a plot's scale domain grow to
+ * fit derived marks (a density curve's peak, a regression band) instead of
+ * clipping them.
+ */
+export declare class MarkerAxisValues {
+    static of(markers: object[], axis: 'x' | 'y'): number[];
+}

package/dist/phases/scales/MarkerAxisValues.js

@@ -0,0 +1,34 @@
+/**
+ * Every finite numeric value a set of markers draws on one axis, read from
+ * each marker's own `data`: its position channel and its range edges (`x1`/`x2`
+ * for `x`), so a rect's or a band's full extent counts, not just its middle.
+ * Markers without their own `data` reuse the plot's rows, which the plot's
+ * domain already covers, so they're skipped. Lets a plot's scale domain grow to
+ * fit derived marks (a density curve's peak, a regression band) instead of
+ * clipping them.
+ */
+export class MarkerAxisValues {
+    static of(markers, axis) {
+        return markers.flatMap((markerConfig) => {
+            const marker = markerConfig;
+            const rows = marker.data;
+            if (!rows)
+                return [];
+            return [axis, `${axis}1`, `${axis}2`].flatMap((channel) => {
+                const accessor = marker[channel];
+                // A literal edge (a bar anchored at `0`) counts as is.
+                if (typeof accessor === 'number')
+                    return Number.isFinite(accessor) ? [accessor] : [];
+                // svelteplot's own transforms key their output rows by symbols, so a symbol accessor is read like a field key.
+                if (!(typeof accessor === 'string' ||
+                    typeof accessor === 'symbol' ||
+                    typeof accessor === 'function'))
+                    return [];
+                return rows
+                    .map((row) => (typeof accessor === 'function' ? accessor(row) : row[accessor]))
+                    .map(Number)
+                    .filter(Number.isFinite);
+            });
+        });
+    }
+}

package/dist/phases/scales/ScalesPhase.d.ts

@@ -0,0 +1,29 @@
+import { PlotAxes } from '../data/PlotAxes';
+import type { AxisChannelName } from '../../types/layout/mapping';
+import type { AxisPlotState, AxisPlotCtx, PhaseStage, ScalesStageOptions } from '../../types/phases';
+type AnyAxisState = AxisPlotState<any, any, any, any>;
+/**
+ * The shared "scales" phase. Each axis the kind lays out as categories
+ * (`state.axes.bands`) becomes a band scale, padded and ordered as the kind
+ * says; each `symmetric` axis reaches as far below zero as above it; and an
+ * unpinned numeric axis grows to cover derived markers and the ranges the
+ * transforms gave the rows - from zero on the axes `zero` names. The author's
+ * `scales` always win, and a kind adds its own on top (`defaults`, `fit`, `extend`).
+ */
+export declare class ScalesPhase<TState extends AnyAxisState, TCtx extends AxisPlotCtx> implements PhaseStage<TState, TCtx> {
+    #private;
+    readonly phase: "scales";
+    constructor(options?: ScalesStageOptions<TState, TCtx>);
+    /** The axes whose marks grow from zero, in this state. */
+    zeroAxes(state: {
+        axes?: PlotAxes;
+    }): AxisChannelName[];
+    /** The axes that reach as far below zero as above it, in this state. */
+    symmetricAxes(state: {
+        axes?: PlotAxes;
+    }): AxisChannelName[];
+    /** Whether the kind keeps its categories in the order the data gives them. */
+    get keepsDataOrder(): boolean;
+    run: (state: TState, ctx: TCtx) => TState;
+}
+export {};

package/dist/phases/scales/ScalesPhase.js

@@ -0,0 +1,153 @@
+import { ProcessedPositions } from '../transforms/ProcessedPositions';
+import { isGapValue } from '../../plots/utils/gaps';
+import { MarkerAxisValues } from './MarkerAxisValues';
+import { PlotAxes } from '../data/PlotAxes';
+import { NiceTicks } from '../../layout/scales/NiceTicks';
+import { DISCRETE_SCALE_TYPES } from '../../types/layout/scales';
+const AXES = ['x', 'y'];
+const POSITION_CHANNELS = {
+    x: ['x', 'x1', 'x2'],
+    y: ['y', 'y1', 'y2']
+};
+const DISCRETE_TYPES = new Set(DISCRETE_SCALE_TYPES);
+/** The values as finite numbers, or `undefined` when any isn't a number (a band or date axis). */
+function numeric(values) {
+    const present = values.filter((v) => v != null && v !== '');
+    if (!present.every((v) => typeof v === 'number'))
+        return undefined;
+    return present.filter(Number.isFinite);
+}
+/**
+ * The shared "scales" phase. Each axis the kind lays out as categories
+ * (`state.axes.bands`) becomes a band scale, padded and ordered as the kind
+ * says; each `symmetric` axis reaches as far below zero as above it; and an
+ * unpinned numeric axis grows to cover derived markers and the ranges the
+ * transforms gave the rows - from zero on the axes `zero` names. The author's
+ * `scales` always win, and a kind adds its own on top (`defaults`, `fit`, `extend`).
+ */
+export class ScalesPhase {
+    phase = 'scales';
+    #options;
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    /** The axes whose marks grow from zero, in this state. */
+    zeroAxes(state) {
+        return ScalesPhase.#axesOf(this.#options.zero, state);
+    }
+    /** The axes that reach as far below zero as above it, in this state. */
+    symmetricAxes(state) {
+        return ScalesPhase.#axesOf(this.#options.symmetric, state);
+    }
+    /** Whether the kind keeps its categories in the order the data gives them. */
+    get keepsDataOrder() {
+        return this.#options.bandOrder === 'data';
+    }
+    run = (state, ctx) => {
+        const options = this.#options;
+        const { axes, processedData, markers = [] } = state;
+        const defaults = options.defaults?.(state, ctx) ?? {};
+        const symmetric = new Set(this.symmetricAxes(state));
+        const zero = new Set(this.zeroAxes(state));
+        const scales = { ...state.scales };
+        for (const axis of AXES) {
+            const own = ScalesPhase.#defaultsOf(defaults, axis, axes);
+            if (axes?.bands.includes(axis)) {
+                scales[axis] = this.#band(scales[axis], own, processedData, axis);
+                continue;
+            }
+            // The value axis of a plot with categories is never one itself, whatever it was marked as.
+            const stripType = axis === axes?.value &&
+                axes.bands.length > 0 &&
+                DISCRETE_TYPES.has(scales[axis]?.type ?? '');
+            if (Object.keys(own).length || stripType) {
+                const given = { ...scales[axis] };
+                if (stripType)
+                    delete given.type;
+                scales[axis] = { ...own, ...given };
+            }
+            if (symmetric.has(axis) && !scales[axis]?.domain) {
+                const reach = ScalesPhase.#reachOf(state, axis);
+                scales[axis] = { ...scales[axis], domain: [-reach, reach] };
+            }
+        }
+        const fitted = options.fit?.({ ...state, scales }, ctx) ?? {};
+        for (const axis of AXES) {
+            if (fitted[axis])
+                scales[axis] = { ...scales[axis], ...fitted[axis] };
+        }
+        for (const axis of AXES) {
+            if (axes?.bands.includes(axis) || scales[axis]?.domain)
+                continue;
+            const derived = MarkerAxisValues.of(markers, axis);
+            const ranged = POSITION_CHANNELS[axis]
+                .slice(1)
+                .some((name) => processedData?.channels[name] !== undefined);
+            // A transform's own output on an axis from zero (a bin's count) has no baseline row to reach it.
+            const aggregated = (processedData?.transforms.length ?? 0) > 0 && zero.has(axis);
+            if (!derived.length && !ranged && !aggregated)
+                continue;
+            const own = numeric(ProcessedPositions.values(processedData, axis));
+            if (!own)
+                continue;
+            const values = [...own, ...derived, ...(zero.has(axis) ? [0] : [])];
+            const lo = Math.min(...values);
+            const hi = Math.max(...values);
+            const author = scales[axis];
+            // Niced here, with a tolerance, so parts that add up to a whole land on its tick.
+            const niced = author?.nice !== false && author?.ticks == null && hi > lo;
+            scales[axis] = niced
+                ? {
+                    ...author,
+                    domain: NiceTicks.fit(state, axis, lo, hi, author?.niceTolerance),
+                    nice: false
+                }
+                : { ...author, domain: [lo, hi], nice: author?.nice ?? true };
+        }
+        const next = { ...state, scales };
+        return options.extend ? options.extend(next, ctx) : next;
+    };
+    /** A category axis as a band scale: the kind's options under the author's, in the order the kind asks for. */
+    #band(author, own, processed, axis) {
+        const given = author ?? {};
+        const type = given.type === undefined || given.type === 'auto' || given.type === 'categorical'
+            ? 'band'
+            : given.type;
+        const band = { ...own, ...given, type };
+        // A padding the author gives replaces the kind's own inner and outer ones.
+        if (given.padding !== undefined) {
+            if (own.paddingInner !== undefined && given.paddingInner === undefined) {
+                band.paddingInner = given.padding;
+            }
+            if (own.paddingOuter !== undefined && given.paddingOuter === undefined) {
+                band.paddingOuter = given.padding;
+            }
+        }
+        if (this.keepsDataOrder && !band.domain) {
+            band.domain = [...new Set(ProcessedPositions.values(processed, axis))];
+        }
+        return band;
+    }
+    /** The axes `refs` name, by name or by the role they play in this state. */
+    static #axesOf(refs, state) {
+        return (refs ?? []).map((ref) => ref === 'value'
+            ? PlotAxes.valueOf(state)
+            : ref === 'category'
+                ? PlotAxes.categoryOf(state)
+                : ref);
+    }
+    /** The kind's options for one axis: those for its role, then those for it by name. */
+    static #defaultsOf(defaults, axis, axes) {
+        const role = axis === axes?.value ? 'value' : axis === axes?.category ? 'category' : undefined;
+        return { ...(role ? defaults[role] : undefined), ...defaults[axis] };
+    }
+    /** How far an axis reaches from zero: the largest magnitude its rows, and the gaps filled in between them, sit at. */
+    static #reachOf(state, axis) {
+        const rows = ProcessedPositions.values(state.processedData, axis)
+            .filter((v) => !isGapValue(v))
+            .map((v) => Math.abs(Number(v)));
+        const filled = [...(state.gapFillMaps?.values() ?? [])].flatMap((fills) => [...fills.values()].map((fill) => Math.abs(fill.value)));
+        const reach = Math.max(...[...rows, ...filled].filter(Number.isFinite));
+        return Number.isFinite(reach) ? reach : 1;
+    }
+}