@fundar/data-chart-telling 1.1.0 → 1.2.0

package/dist/phases/statistics/StatisticsPhase.js

@@ -53,7 +53,12 @@ export class StatisticsPhase {
             ? (state.processedGroups ?? []).map((group) => group.series)
             : resolvedSeries;
         return [
-            ...Statistics.buildForPlot({ series: measured, statistics, colorFor: colorForSeries }),
+            ...Statistics.buildForPlot({
+                series: measured,
+                statistics,
+                valueAxis,
+                colorFor: colorForSeries
+            }),
             ...Statistics.expandMarkers(AuthorMarkers.prepare(positioned, {
                 grouping: inheritGrouping ? state.grouping : undefined,
                 color: inheritGrouping ? state.color : undefined,
@@ -61,7 +66,7 @@ export class StatisticsPhase {
                 flat,
                 resolvedSeries,
                 scopedGroups: state.scopedGroups
-            }), flat)
+            }), flat, valueAxis)
         ];
     }
 }

package/dist/phases/statistics/methods/BollingerStatistic.d.ts

@@ -5,5 +5,5 @@ import { type StatisticSource } from '../../../types/phases/statistics/source';
 export declare class BollingerStatistic {
     static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: Extract<StatisticConfig, {
         type: 'bollinger';
-    }>): BollingerMarkerConfig;
+    }>): BollingerMarkerConfig[];
 }

package/dist/phases/statistics/methods/BollingerStatistic.js

@@ -2,17 +2,19 @@ import { STATISTIC_FALLBACK_COLOR } from '../../../types/phases/statistics/sourc
 /** Bollinger bands over the source, drawn as a `bollinger` marker (svelteplot computes them at render time). */
 export class BollingerStatistic {
     static build(source, config) {
-        return {
-            type: 'bollinger',
-            data: source.data,
-            x: source.x,
-            y: source.y,
-            n: config.n,
-            k: config.k,
-            styles: {
-                ...config.styles,
-                stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+        return [
+            {
+                type: 'bollinger',
+                data: source.data,
+                x: source.x,
+                y: source.y,
+                n: config.n,
+                k: config.k,
+                styles: {
+                    ...config.styles,
+                    stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+                }
             }
-        };
+        ];
     }
 }

package/dist/phases/statistics/methods/BoxStatistic.d.ts

@@ -5,5 +5,5 @@ import { type StatisticSource } from '../../../types/phases/statistics/source';
 export declare class BoxStatistic {
     static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: Extract<StatisticConfig, {
         type: 'box';
-    }>): BoxMarkerConfig;
+    }>): BoxMarkerConfig[];
 }

package/dist/phases/statistics/methods/BoxStatistic.js

@@ -2,17 +2,19 @@ import { STATISTIC_FALLBACK_COLOR } from '../../../types/phases/statistics/sourc
 /** Box-and-whisker summary of the source, drawn as a `box` marker. */
 export class BoxStatistic {
     static build(source, config) {
-        return {
-            type: 'box',
-            data: source.data,
-            x: source.x,
-            y: source.y,
-            sort: config.sort,
-            bar: { fill: source.color ?? STATISTIC_FALLBACK_COLOR, ...config.bar },
-            rule: config.rule,
-            dot: config.dot,
-            tickMedian: config.tickMedian,
-            tickMinMax: config.tickMinMax
-        };
+        return [
+            {
+                type: 'box',
+                data: source.data,
+                x: source.x,
+                y: source.y,
+                sort: config.sort,
+                bar: { fill: source.color ?? STATISTIC_FALLBACK_COLOR, ...config.bar },
+                rule: config.rule,
+                dot: config.dot,
+                tickMedian: config.tickMedian,
+                tickMinMax: config.tickMinMax
+            }
+        ];
     }
 }

package/dist/phases/statistics/methods/Density2dStatistic.d.ts

@@ -5,5 +5,5 @@ import { type StatisticSource } from '../../../types/phases/statistics/source';
 export declare class Density2dStatistic {
     static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: Extract<StatisticConfig, {
         type: 'density2d';
-    }>): DensityMarkerConfig;
+    }>): DensityMarkerConfig[];
 }

package/dist/phases/statistics/methods/Density2dStatistic.js

@@ -2,17 +2,19 @@ import { STATISTIC_FALLBACK_COLOR } from '../../../types/phases/statistics/sourc
 /** 2D kernel density over the source's `x` and `y`, drawn as a `density` marker. */
 export class Density2dStatistic {
     static build(source, config) {
-        return {
-            type: 'density',
-            data: source.data,
-            x: source.x,
-            y: source.y,
-            bandwidth: config.bandwidth,
-            thresholds: config.thresholds,
-            styles: {
-                ...config.styles,
-                stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+        return [
+            {
+                type: 'density',
+                data: source.data,
+                x: source.x,
+                y: source.y,
+                bandwidth: config.bandwidth,
+                thresholds: config.thresholds,
+                styles: {
+                    ...config.styles,
+                    stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+                }
             }
-        };
+        ];
     }
 }

package/dist/phases/statistics/methods/DensityStatistic.d.ts

@@ -8,5 +8,5 @@ export declare class DensityStatistic {
      * `x` is the value and `y` the density, so it draws on the plot's axes as-is.
      * The output is one derived row per estimate point rather than one per input row.
      */
-    static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: DensityStatisticOptions): AreaMarkerConfig;
+    static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: DensityStatisticOptions): AreaMarkerConfig[];
 }

package/dist/phases/statistics/methods/DensityStatistic.js

@@ -15,15 +15,17 @@ export class DensityStatistic {
             kernel: config.kernel,
             bandwidth: config.bandwidth
         });
-        return {
-            type: 'area',
-            data: result.data,
-            x: result.x,
-            y: result.y,
-            styles: {
-                ...config.styles,
-                fill: config.styles?.fill ?? source.color ?? STATISTIC_FALLBACK_COLOR
+        return [
+            {
+                type: 'area',
+                data: result.data,
+                x: result.x,
+                y: result.y,
+                styles: {
+                    ...config.styles,
+                    fill: config.styles?.fill ?? source.color ?? STATISTIC_FALLBACK_COLOR
+                }
             }
-        };
+        ];
     }
 }

package/dist/phases/statistics/methods/DeviationStatistic.d.ts

@@ -0,0 +1,8 @@
+import type { DeviationStatisticOptions } from '../../../types/layout/statistics';
+import type { AxisBasedMarkersConfig } from '../../../types/markers/common';
+import { type StatisticSource } from '../../../types/phases/statistics/source';
+/** An estimator of the source's values along the plot's value axis and a band around it, drawn as a `rect` and a `rule` marker, each optionally labelled by a `text` marker. */
+export declare class DeviationStatistic {
+    #private;
+    static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: DeviationStatisticOptions): AxisBasedMarkersConfig[];
+}

package/dist/phases/statistics/methods/DeviationStatistic.js

@@ -0,0 +1,111 @@
+import { deviation, extent, mean, median } from 'd3-array';
+import { resolveAccessor } from '../../../utils/accessors';
+import { STATISTIC_FALLBACK_COLOR } from '../../../types/phases/statistics/source';
+/** Scales a median absolute deviation to the standard deviation of a normal distribution. */
+const MAD_SCALE = 1.4826;
+const DEFAULT_BAND_OPACITY = 0.15;
+const LABEL_FONT_SIZE = 10;
+/** Pixels between a label and the line it names, and between it and the plot's edge. */
+const LABEL_GAP = 4;
+/** An estimator of the source's values along the plot's value axis and a band around it, drawn as a `rect` and a `rule` marker, each optionally labelled by a `text` marker. */
+export class DeviationStatistic {
+    static build(source, config) {
+        const axis = source.axis ?? 'y';
+        const read = resolveAccessor(source[axis]);
+        const values = source.data
+            .map((d) => {
+            const v = read(d);
+            return v instanceof Date ? v.getTime() : typeof v === 'number' ? v : NaN;
+        })
+            .filter(Number.isFinite);
+        if (!values.length)
+            return [];
+        const center = DeviationStatistic.#estimate(values, config.estimator ?? 'mean');
+        const spread = DeviationStatistic.#spread(values, config.spread ?? 'stdev');
+        const half = (config.k ?? 1) * spread;
+        const color = source.color ?? STATISTIC_FALLBACK_COLOR;
+        const markers = [];
+        if (config.band !== false) {
+            const { label, ...style } = config.band ?? {};
+            const [lo, hi] = [center - half, center + half];
+            markers.push({
+                type: 'rect',
+                data: [{ lo, hi }],
+                ...(axis === 'x' ? { x1: 'lo', x2: 'hi' } : { y1: 'lo', y2: 'hi' }),
+                styles: { fillOpacity: DEFAULT_BAND_OPACITY, ...style, fill: style.fill ?? color }
+            });
+            if (label) {
+                const own = label === true ? {} : label;
+                const lower = own.edge === 'lower';
+                const outside = own.position === 'outside';
+                markers.push(DeviationStatistic.#label(axis, lower ? lo : hi, color, lower === outside, {
+                    text: own.text ?? (config.spread === 'mad' ? 'MAD' : 'STDEV'),
+                    styles: own.styles
+                }));
+            }
+        }
+        if (config.rule !== false) {
+            const { label, ...style } = config.rule ?? {};
+            markers.push({
+                type: 'rule',
+                axis,
+                value: center,
+                styles: { ...style, stroke: style.stroke ?? color }
+            });
+            if (label) {
+                const own = label === true ? {} : label;
+                markers.push(DeviationStatistic.#label(axis, center, color, axis === 'x', {
+                    text: own.text ?? (config.estimator ?? 'mean').toUpperCase(),
+                    styles: own.styles
+                }));
+            }
+        }
+        return markers;
+    }
+    /**
+     * A label beside the line at `position`, against the plot's start edge: a
+     * vertical line's reads down from the top, a horizontal line's ends at the
+     * right. `towardLower` puts its body on the side of lower values (left of a
+     * vertical line, below a horizontal one).
+     */
+    static #label(axis, position, color, towardLower, label) {
+        const vertical = axis === 'x';
+        const fontSize = label.styles?.fontSize ?? LABEL_FONT_SIZE;
+        const sign = towardLower ? -1 : 1;
+        // A vertical line's text is centred on its own point, so its half-height plus the gap clears the line.
+        const gap = LABEL_GAP + (vertical ? fontSize / 2 : 0);
+        const [dx, dy] = vertical ? [sign * gap, LABEL_GAP] : [-LABEL_GAP, -sign * gap];
+        return {
+            type: 'text',
+            text: label.text,
+            ...(vertical ? { x: position } : { y: position }),
+            frameAnchor: vertical ? 'top' : 'right',
+            styles: {
+                fill: color,
+                fontSize,
+                ...(vertical
+                    ? { rotate: 90, textAnchor: 'start', lineAnchor: 'middle' }
+                    : { textAnchor: 'end', lineAnchor: towardLower ? 'top' : 'bottom' }),
+                ...label.styles,
+                dx: dx + (label.styles?.dx ?? 0),
+                dy: dy + (label.styles?.dy ?? 0)
+            }
+        };
+    }
+    static #estimate(values, estimator) {
+        if (estimator === 'median')
+            return median(values);
+        if (estimator === 'midrange') {
+            const [lo, hi] = extent(values);
+            return (lo + hi) / 2;
+        }
+        return mean(values);
+    }
+    static #spread(values, spread) {
+        if (spread === 'mad') {
+            const mid = median(values);
+            return MAD_SCALE * median(values.map((v) => Math.abs(v - mid)));
+        }
+        return deviation(values) ?? 0;
+    }
+}

package/dist/phases/statistics/methods/MovingAverageStatistic.d.ts

@@ -8,5 +8,5 @@ export declare class MovingAverageStatistic {
      * no dedicated mark for this (unlike `regression`/`bollinger`). `windowY`
      * keeps one output row per input row, so `x` passes straight through.
      */
-    static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: MovingAverageStatisticOptions): LineMarkerConfig;
+    static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: MovingAverageStatisticOptions): LineMarkerConfig[];
 }

package/dist/phases/statistics/methods/MovingAverageStatistic.js

@@ -16,15 +16,17 @@ export class MovingAverageStatistic {
             k: config.k,
             reduce: config.reduce ?? 'mean'
         });
-        return {
-            type: 'line',
-            data: result.data,
-            x: result.x,
-            y: result.y,
-            styles: {
-                ...config.styles,
-                stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+        return [
+            {
+                type: 'line',
+                data: result.data,
+                x: result.x,
+                y: result.y,
+                styles: {
+                    ...config.styles,
+                    stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+                }
             }
-        };
+        ];
     }
 }

package/dist/phases/statistics/methods/RegressionStatistic.d.ts

@@ -5,5 +5,5 @@ import { type StatisticSource } from '../../../types/phases/statistics/source';
 export declare class RegressionStatistic {
     static build<T extends Record<string, unknown>>(source: StatisticSource<T>, config: Extract<StatisticConfig, {
         type: 'regression';
-    }>): RegressionMarkerConfig;
+    }>): RegressionMarkerConfig[];
 }

package/dist/phases/statistics/methods/RegressionStatistic.js

@@ -2,20 +2,22 @@ import { STATISTIC_FALLBACK_COLOR } from '../../../types/phases/statistics/sourc
 /** A regression curve over the source, drawn as a `regression` marker (svelteplot fits it at render time). */
 export class RegressionStatistic {
     static build(source, config) {
-        return {
-            type: 'regression',
-            data: source.data,
-            x: source.x,
-            y: source.y,
-            regressionType: config.regressionType,
-            order: config.order,
-            base: config.base,
-            span: config.span,
-            confidence: config.confidence,
-            styles: {
-                ...config.styles,
-                stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+        return [
+            {
+                type: 'regression',
+                data: source.data,
+                x: source.x,
+                y: source.y,
+                regressionType: config.regressionType,
+                order: config.order,
+                base: config.base,
+                span: config.span,
+                confidence: config.confidence,
+                styles: {
+                    ...config.styles,
+                    stroke: config.styles?.stroke ?? source.color ?? STATISTIC_FALLBACK_COLOR
+                }
             }
-        };
+        ];
     }
 }

package/dist/phases/transforms/ProcessedPositions.js

@@ -1,4 +1,4 @@
-import { resolveAccessor } from '../../plots/utils/accessors';
+import { resolveAccessor } from '../../utils/accessors';
 import { isGapValue } from '../../plots/utils/gaps';
 const POSITION_CHANNELS = {
     x: ['x', 'x1', 'x2'],

package/dist/phases/transforms/TransformsPhase.js

@@ -1,7 +1,9 @@
 import { Transforms } from './Transforms';
+import { ValueSelection } from './ValueSelection';
+import { ProcessedPositions } from './ProcessedPositions';
 import { seriesIdOf } from '../../utils/grouping';
 import { PANEL_KEY } from '../facet/FacetPanels';
-import { resolveAccessor } from '../../plots/utils/accessors';
+import { resolveAccessor } from '../../utils/accessors';
 import { buildGroupedSeries } from '../../plots/utils/segments';
 import { PlotAxes } from '../data/PlotAxes';
 /** The field each processed row carries its series name under, for its color, legend and labels. */
@@ -94,12 +96,56 @@ export class TransformsPhase {
         };
         return this.#withGroups({ ...state, processedData });
     };
-    /** `state` with its processed rows split into the visual groups the kind's marks draw (`processedGroups`). */
+    /**
+     * `state` with its processed rows split into the visual groups the kind's marks
+     * draw (`processedGroups`), and the rows its value labels are written for
+     * (`labelled`).
+     */
     #withGroups(state) {
         const processedGroups = this.#options.groups === 'runs'
             ? TransformsPhase.#buildRuns(state)
             : TransformsPhase.#buildGroups(state, this.#connect);
-        return { ...state, processedGroups };
+        return { ...state, processedGroups, ...this.#labelled(state) };
+    }
+    /**
+     * The rows `styles.values` writes labels for, picked per facet panel - a
+     * panel's own last row, not the last of every panel - by the author's
+     * `select` and `series`, over the plot's own default. Left out while the
+     * labels are off, or when the plot picks no rows.
+     */
+    #labelled(state) {
+        const options = this.#options.labels;
+        const values = state.values;
+        if (!options || !(values?.show ?? options.show))
+            return {};
+        const processed = state.processedData;
+        const valueAxis = PlotAxes.valueOf(state);
+        const select = values?.select ?? options.select;
+        const selections = ValueSelection.transforms(select, values?.series, valueAxis);
+        const position = ProcessedPositions.of(processed, valueAxis);
+        const skip = options.skip?.(state);
+        const channels = {
+            x: position.x,
+            y: position.y,
+            group: options.group === 'category'
+                ? position[PlotAxes.categoryOf(state)]
+                : SERIES_ID_KEY
+        };
+        const panels = new Map();
+        for (const row of processed.data) {
+            if (skip?.(row))
+                continue;
+            const bucket = panels.get(row[PANEL_KEY]);
+            if (bucket)
+                bucket.push(row);
+            else
+                panels.set(row[PANEL_KEY], [row]);
+        }
+        const labelled = new Set([...panels.values()].flatMap((rows) => ValueSelection.pick(rows, selections, channels)));
+        return {
+            labelled: processed.data.filter((row) => labelled.has(row)),
+            labelSelects: ValueSelection.selectors(select)
+        };
     }
     /** What a gap-filled row carries: its interpolated value and the kind of zone that filled it. */
     static #fillTags(fill) {

package/dist/phases/transforms/ValueSelection.d.ts

@@ -0,0 +1,30 @@
+import type { ValueSelect } from '../../types/layout/styles';
+import type { MarkerTransform } from '../../types/transforms';
+import type { ProcessedRow } from '../../types/phases';
+/**
+ * Which rows of a plot a value label is written for: `styles.values.select`
+ * (or the plot's own default) and `series`, run as `filter` and `select`
+ * transforms over the processed rows. The labelled rows are the union of what
+ * each selector picks, returned as the rows themselves, in their own order.
+ */
+export declare class ValueSelection {
+    /** `select` as a list: none is every row. */
+    static selectors(select: ValueSelect | ValueSelect[] | undefined): ValueSelect[];
+    /**
+     * The transforms that pick the rows, one list per selector: the series filter,
+     * then the `select` of that selector, with `'min'` and `'max'` read on
+     * `valueAxis`. Without selectors, one list that only filters the series.
+     */
+    static transforms(select: ValueSelect | ValueSelect[] | undefined, series: string | string[] | undefined, valueAxis: 'x' | 'y'): MarkerTransform[][];
+    /**
+     * The rows of `rows` that any of `selections` picks, grouped by `group`
+     * (a field key or accessor) and compared on `x` and `y` - the value axis'
+     * channel is what `'min'` and `'max'` read. A transform returns copies of its
+     * rows, so each is traced back to the row it came from.
+     */
+    static pick(rows: ProcessedRow[], selections: MarkerTransform[][], channels: {
+        x: unknown;
+        y: unknown;
+        group: unknown;
+    }): ProcessedRow[];
+}

package/dist/phases/transforms/ValueSelection.js

@@ -0,0 +1,53 @@
+import { Transforms } from './Transforms';
+import { SERIES_KEY } from './TransformsPhase';
+/** The field a row carries its place in the rows picked from, under which a transform's copy of it is traced back. */
+const PLACE = '__place';
+/**
+ * Which rows of a plot a value label is written for: `styles.values.select`
+ * (or the plot's own default) and `series`, run as `filter` and `select`
+ * transforms over the processed rows. The labelled rows are the union of what
+ * each selector picks, returned as the rows themselves, in their own order.
+ */
+export class ValueSelection {
+    /** `select` as a list: none is every row. */
+    static selectors(select) {
+        return select === undefined ? [] : Array.isArray(select) ? select : [select];
+    }
+    /**
+     * The transforms that pick the rows, one list per selector: the series filter,
+     * then the `select` of that selector, with `'min'` and `'max'` read on
+     * `valueAxis`. Without selectors, one list that only filters the series.
+     */
+    static transforms(select, series, valueAxis) {
+        const names = series === undefined ? undefined : new Set([series].flat());
+        const filter = names
+            ? [{ type: 'filter', filter: (d) => names.has(String(d[SERIES_KEY])) }]
+            : [];
+        const selectors = ValueSelection.selectors(select);
+        if (selectors.length === 0)
+            return [filter];
+        return selectors.map((selector) => [
+            ...filter,
+            {
+                type: 'select',
+                select: selector === 'min' || selector === 'max' ? { [valueAxis]: selector } : selector
+            }
+        ]);
+    }
+    /**
+     * The rows of `rows` that any of `selections` picks, grouped by `group`
+     * (a field key or accessor) and compared on `x` and `y` - the value axis'
+     * channel is what `'min'` and `'max'` read. A transform returns copies of its
+     * rows, so each is traced back to the row it came from.
+     */
+    static pick(rows, selections, channels) {
+        const placed = rows.map((row, index) => ({ ...row, [PLACE]: index }));
+        const chosen = new Set();
+        for (const transforms of selections) {
+            const picked = Transforms.resolve({ data: placed, ...channels, grouping: channels.group, transforms }, placed);
+            for (const row of picked.data ?? placed)
+                chosen.add(row[PLACE]);
+        }
+        return rows.filter((_, index) => chosen.has(index));
+    }
+}

package/dist/plots/{heatmap → correlation/heatmap}/Plot.svelte

@@ -1,7 +1,10 @@
 <script lang="ts" generics="TData extends Record<string, unknown>">
-	import Plot from '../../layout/plot/Plot.svelte';
+	import Plot from '../../../layout/plot/Plot.svelte';
 	import { buildHeatmapDefaults } from './defaults';
-	import type { HeatmapPlotProps, HeatmapPlotCoreProps } from '../../types/plots/heatmap/props';
+	import type {
+		HeatmapPlotProps,
+		HeatmapPlotCoreProps
+	} from '../../../types/plots/correlation/heatmap/props';
 
 	/**
 	 * A categorical grid of value-colored cells. Draws from pre-built `series` or flat `data` rows.

package/dist/plots/{heatmap → correlation/heatmap}/Plot.svelte.d.ts

@@ -1,5 +1,5 @@
-import Plot from '../../layout/plot/Plot.svelte';
-import type { HeatmapPlotProps } from '../../types/plots/heatmap/props';
+import Plot from '../../../layout/plot/Plot.svelte';
+import type { HeatmapPlotProps } from '../../../types/plots/correlation/heatmap/props';
 declare function $$render<TData extends Record<string, unknown>>(): {
     props: HeatmapPlotProps<TData>;
     exports: {};

package/dist/plots/{heatmap → correlation/heatmap}/defaults.d.ts

@@ -1,5 +1,5 @@
-import type { AxisPlotDefaults } from '../../types/phases';
-import type { HeatmapPlotState, HeatmapPlotCtx } from '../../types/plots/heatmap/state';
+import type { AxisPlotDefaults } from '../../../types/phases';
+import type { HeatmapPlotState, HeatmapPlotCtx } from '../../../types/plots/correlation/heatmap/state';
 /**
  * HeatmapPlot on the shared pipeline: both axes are categories. A heatmap's
  * `color` is each cell's numeric value, which the "data" phase reads as a

package/dist/plots/{heatmap → correlation/heatmap}/defaults.js

@@ -1,6 +1,6 @@
-import { resolveColorScale } from '../../utils/color';
-import { resolveOpacityScale } from '../../utils/opacity';
-import { ContinuousDomain } from '../../utils/ContinuousDomain';
+import { ColorRamp } from '../../../utils/color';
+import { OpacityScale } from '../../../utils/OpacityScale';
+import { ContinuousDomain } from '../../../utils/ContinuousDomain';
 import { buildMarks, buildValueLabels } from './markers';
 /**
  * HeatmapPlot's own "scales" output, over the band axes the shared phase laid
@@ -17,7 +17,7 @@ function extendWithColorScales(state, ctx) {
     // active range) keeps the original domain - only which cells are hidden
     // changes (resolved in the "markers" phase).
     const effectiveDomain = ContinuousDomain.ramp(valueDomain, range);
-    const colorScale = resolveColorScale({ ...scales.color, domain: effectiveDomain }, effectiveDomain, [cfg.continuous.min, cfg.continuous.max]);
+    const colorScale = ColorRamp.continuous(cfg, scales.color, effectiveDomain);
     const resolveColor = (row) => colorScale(Number(colorAcc.accessor(row)));
     const opacityAcc = channels.opacity;
     let opacityDomainOut;
@@ -32,7 +32,7 @@ function extendWithColorScales(state, ctx) {
                 : [...new Set(rawVals.map(String))];
             if (allNumeric && rawVals.length)
                 opacityDomainOut = opacityDomain;
-            const opacityScale = resolveOpacityScale(scales.opacity, opacityDomain, cfg.continuous.opacityRange);
+            const opacityScale = OpacityScale.resolve(scales.opacity, opacityDomain, cfg.continuous.opacityRange);
             return (row) => opacityScale(opacityAcc.accessor(row));
         })()
         : undefined;

package/dist/plots/{heatmap → correlation/heatmap}/markers.d.ts

@@ -1,7 +1,7 @@
-import type { TextMarkerConfig } from '../../types/markers/common';
-import type { HeatmapPlotState, HeatmapPlotCtx } from '../../types/plots/heatmap/state';
-import type { ValueLabels } from '../../layout/styles/ValueLabels';
-import type { AxisBasedMarkersConfig } from '../../types/markers/common';
+import type { TextMarkerConfig } from '../../../types/markers/common';
+import type { HeatmapPlotState, HeatmapPlotCtx } from '../../../types/plots/correlation/heatmap/state';
+import type { ValueLabels } from '../../../layout/styles/ValueLabels';
+import type { AxisBasedMarkersConfig } from '../../../types/markers/common';
 /**
  * HeatmapPlot's `styles.values` as one `'text'` marker over the same cells
  * the plot draws, each labelled with its own value and centred on it. Shown

package/dist/plots/{heatmap → correlation/heatmap}/markers.js

@@ -1,6 +1,6 @@
-import { LegendState } from '../../layout/legend/LegendState.svelte';
-import { DisabledStyle } from '../../layout/legend/DisabledStyle';
-import { resolveAccessor } from '../utils/accessors';
+import { LegendState } from '../../../layout/legend/LegendState.svelte';
+import { DisabledStyle } from '../../../layout/legend/DisabledStyle';
+import { resolveAccessor } from '../../../utils/accessors';
 /** A processed channel as a per-row function. */
 function readChannel(channel) {
     return resolveAccessor(channel);