@tolle_/tolle-ui 18.2.29 → 18.2.30

package/esm2022/lib/chart.service.mjs

@@ -0,0 +1,555 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/** Number of chart palette steps that exist. A 6th series does not get a colour. */
+export const CHART_COLOR_LIMIT = 5;
+/**
+ * The paint used for a series past `CHART_COLOR_LIMIT`.
+ *
+ * The palette is validated for lightness, chroma and colour-blind separation at
+ * exactly five steps; generating a sixth would land outside that validation, and
+ * wrapping back to step 1 would make two series share an identity. Both are
+ * worse than dropping to a neutral, so the overflow is explicitly uncoloured.
+ */
+export const CHART_OVERFLOW_COLOR = 'rgb(var(--muted-foreground))';
+/**
+ * Hands out palette steps by entity key rather than by position.
+ *
+ * A key keeps its slot for the lifetime of the scale, which is what makes
+ * colour follow the entity: filtering a series out and back in, or removing an
+ * earlier one, must never repaint the survivors. Past the fifth distinct key
+ * the scale stops colouring rather than inventing a step or wrapping around.
+ */
+export class ChartColorScale {
+    slots = new Map();
+    next = 0;
+    /** Reserves slots for `keys` in order, leaving already-known keys alone. */
+    register(keys) {
+        for (const key of keys) {
+            if (!this.slots.has(key))
+                this.slots.set(key, this.next++);
+        }
+    }
+    /** Paint for `key`, registering it on first sight. */
+    colorFor(key) {
+        let slot = this.slots.get(key);
+        if (slot === undefined) {
+            slot = this.next++;
+            this.slots.set(key, slot);
+        }
+        if (slot >= CHART_COLOR_LIMIT)
+            return CHART_OVERFLOW_COLOR;
+        return 'rgb(var(--chart-' + (slot + 1) + '))';
+    }
+    /** True when `key` fell past the palette and renders neutral. */
+    isOverflow(key) {
+        const slot = this.slots.get(key);
+        return slot !== undefined && slot >= CHART_COLOR_LIMIT;
+    }
+    /** Slot index assigned to `key`, or undefined when it is unknown. */
+    slotOf(key) {
+        return this.slots.get(key);
+    }
+}
+/**
+ * Owns layout, scales and colour assignment for one `tolle-chart`, so every
+ * child draws into the same coordinate space. Renders nothing itself.
+ *
+ * Provided on `ChartComponent`, so each chart gets its own instance.
+ */
+export class ChartService {
+    /** Rows being plotted, in x order. */
+    data = [];
+    /** Series definitions, in the order they should take palette steps. */
+    series = [];
+    /** Row key holding the x category/label. */
+    xKey = '';
+    /** Whether marks stack on a shared baseline rather than sitting side by side. */
+    stacked = false;
+    /** Full svg width in px, tracked from the container's ResizeObserver. */
+    width = 0;
+    /** Full svg height in px. */
+    height = 260;
+    /** Space reserved around the plot area. */
+    margin = { top: 8, right: 8, bottom: 24, left: 40 };
+    /** Fraction of a band's step spent on padding, split either side. */
+    bandPadding = 0.2;
+    scaleMode = 'point';
+    zeroRequired = false;
+    domainMin = 0;
+    domainMax = 1;
+    tickValues = [];
+    tickStep = 1;
+    /** Palette assignment, keyed by series identity. */
+    colors = new ChartColorScale();
+    layoutSubject = new BehaviorSubject(0);
+    /** Emits a version number whenever scales, dimensions or data change. */
+    layout$ = this.layoutSubject.asObservable();
+    activeIndexSubject = new BehaviorSubject(null);
+    /** Index of the x position under the pointer, or null when not hovering. */
+    activeIndex$ = this.activeIndexSubject.asObservable();
+    layoutVersion = 0;
+    emitScheduled = false;
+    // ---------------------------------------------------------------- geometry
+    get plotLeft() {
+        return this.margin.left;
+    }
+    get plotTop() {
+        return this.margin.top;
+    }
+    get plotWidth() {
+        return Math.max(0, this.width - this.margin.left - this.margin.right);
+    }
+    get plotHeight() {
+        return Math.max(0, this.height - this.margin.top - this.margin.bottom);
+    }
+    get plotRight() {
+        return this.plotLeft + this.plotWidth;
+    }
+    get plotBottom() {
+        return this.plotTop + this.plotHeight;
+    }
+    /** Number of x positions. */
+    get count() {
+        return this.data.length;
+    }
+    /** How x is currently resolved. Bars flip this to 'band'. */
+    get mode() {
+        return this.scaleMode;
+    }
+    /** Resolved y ticks, with svg coordinates and formatted labels. */
+    get ticks() {
+        return this.tickValues.map((value) => ({
+            value,
+            y: this.yFor(value),
+            label: this.formatValue(value),
+        }));
+    }
+    /** Current y domain as [min, max]. */
+    get domain() {
+        return [this.domainMin, this.domainMax];
+    }
+    /** The x-axis category labels, one per row. */
+    get xLabels() {
+        return this.data.map((row) => {
+            const raw = row?.[this.xKey];
+            return raw == null ? '' : String(raw);
+        });
+    }
+    // ------------------------------------------------------------ registration
+    /**
+     * Replaces the chart's configuration and recomputes the scales.
+     * Called by the container on input changes and on resize.
+     */
+    configure(config) {
+        Object.assign(this, config);
+        if (config.series)
+            this.syncColorSlots(config.series);
+        this.recompute();
+    }
+    /** Switches x to a band scale. Bars call this; it also forces zero into the domain. */
+    useBandScale() {
+        if (this.scaleMode === 'band' && this.zeroRequired)
+            return;
+        this.scaleMode = 'band';
+        this.zeroRequired = true;
+        this.recompute();
+    }
+    /** Forces zero into the y domain, for marks anchored to a baseline. */
+    requireZero() {
+        if (this.zeroRequired)
+            return;
+        this.zeroRequired = true;
+        this.recompute();
+    }
+    /** Reserves palette slots in series order, leaving known keys untouched. */
+    syncColorSlots(series) {
+        this.colors.register(series.map((item) => item.key));
+    }
+    /**
+     * Paint for a series, keyed by identity rather than by index in the visible
+     * array. Past the fifth distinct key this returns the neutral overflow colour.
+     */
+    colorFor(seriesKey) {
+        return this.colors.colorFor(seriesKey);
+    }
+    /** True when this series fell past the palette and renders neutral. */
+    isOverflowSeries(seriesKey) {
+        return this.colors.isOverflow(seriesKey);
+    }
+    // -------------------------------------------------------------- the scales
+    /** Reads a series value off a row, or null when it is missing/non-numeric. */
+    valueAt(seriesKey, index) {
+        const raw = this.data[index]?.[seriesKey];
+        if (raw == null || raw === '')
+            return null;
+        const num = Number(raw);
+        return Number.isFinite(num) ? num : null;
+    }
+    /** Sum of every series below `seriesKey` at `index`, for stacked marks. */
+    stackBase(seriesKey, index) {
+        if (!this.stacked)
+            return 0;
+        let base = 0;
+        for (const item of this.series) {
+            if (item.key === seriesKey)
+                break;
+            base += this.valueAt(item.key, index) ?? 0;
+        }
+        return base;
+    }
+    /** Sum of every series at `index`. */
+    stackTotal(index) {
+        let total = 0;
+        for (const item of this.series)
+            total += this.valueAt(item.key, index) ?? 0;
+        return total;
+    }
+    /**
+     * Maps a data value to an svg y. SVG y grows downward, so the domain maximum
+     * lands on `plotTop` and the minimum on `plotBottom`.
+     */
+    yFor(value) {
+        const span = this.domainMax - this.domainMin;
+        if (span <= 0)
+            return this.plotBottom;
+        const ratio = (value - this.domainMin) / span;
+        return this.plotBottom - ratio * this.plotHeight;
+    }
+    /** The svg y of the zero line, clamped into the plot. */
+    get baselineY() {
+        const zero = Math.min(Math.max(0, this.domainMin), this.domainMax);
+        return this.yFor(zero);
+    }
+    /** Width of one band, excluding its padding. Meaningful in band mode. */
+    get bandWidth() {
+        if (this.count === 0)
+            return 0;
+        return this.bandStep * (1 - this.bandPadding);
+    }
+    /** Distance between adjacent band starts. Bands tile the plot exactly. */
+    get bandStep() {
+        if (this.count === 0)
+            return 0;
+        return this.plotWidth / this.count;
+    }
+    /** Geometry of the band at `index`. */
+    bandFor(index) {
+        const step = this.bandStep;
+        const width = this.bandWidth;
+        const start = this.plotLeft + index * step + (step - width) / 2;
+        return { start, centre: start + width / 2, width };
+    }
+    /** x of the data point at `index` on the point scale. */
+    pointX(index) {
+        if (this.count === 0)
+            return this.plotLeft;
+        if (this.count === 1)
+            return this.plotLeft + this.plotWidth / 2;
+        return this.plotLeft + (index * this.plotWidth) / (this.count - 1);
+    }
+    /** x of `index` under whichever scale the chart is currently using. */
+    xFor(index) {
+        return this.scaleMode === 'band' ? this.bandFor(index).centre : this.pointX(index);
+    }
+    /**
+     * The pointer catchment area for `index` — deliberately wider than the mark.
+     * In band mode it is the whole band step; on the point scale it runs to the
+     * midpoints of the neighbouring points, so the pointer only has to be nearest.
+     */
+    hitBandFor(index) {
+        if (this.scaleMode === 'band') {
+            const step = this.bandStep;
+            const start = this.plotLeft + index * step;
+            return { start, centre: start + step / 2, width: step };
+        }
+        const x = this.pointX(index);
+        const prev = index > 0 ? this.pointX(index - 1) : this.plotLeft - (this.plotRight - this.plotLeft);
+        const next = index < this.count - 1 ? this.pointX(index + 1) : this.plotRight + (this.plotRight - this.plotLeft);
+        const start = Math.max(this.plotLeft, (prev + x) / 2);
+        const end = Math.min(this.plotRight, (x + next) / 2);
+        return { start, centre: x, width: Math.max(0, end - start) };
+    }
+    // --------------------------------------------------------------- hovering
+    /** Index currently under the pointer, or null. */
+    get activeIndex() {
+        return this.activeIndexSubject.value;
+    }
+    setActiveIndex(index) {
+        if (this.activeIndexSubject.value === index)
+            return;
+        this.activeIndexSubject.next(index);
+    }
+    // ----------------------------------------------------------------- domains
+    recompute() {
+        const values = [];
+        if (this.stacked) {
+            for (let i = 0; i < this.count; i++)
+                values.push(this.stackTotal(i));
+            // A stack still has to show its own floor when a series goes negative.
+            for (const item of this.series) {
+                for (let i = 0; i < this.count; i++) {
+                    const v = this.valueAt(item.key, i);
+                    if (v != null && v < 0)
+                        values.push(v);
+                }
+            }
+        }
+        else {
+            for (const item of this.series) {
+                for (let i = 0; i < this.count; i++) {
+                    const v = this.valueAt(item.key, i);
+                    if (v != null)
+                        values.push(v);
+                }
+            }
+        }
+        if (this.zeroRequired)
+            values.push(0);
+        const [min, max, step, ticks] = niceScale(values);
+        this.domainMin = min;
+        this.domainMax = max;
+        this.tickStep = step;
+        this.tickValues = ticks;
+        // Only tell subscribers when something they would draw differently actually
+        // changed. `configure()` is called from ngOnChanges, and an app binding
+        // `[data]="items.filter(...)"` hands us a fresh array reference on every
+        // change-detection pass — an ordinary thing to write. Emitting on every call
+        // made subscribers markForCheck, which scheduled another pass, which called
+        // configure again: the cycle never closed and the page locked up.
+        const signature = this.layoutSignature(values);
+        if (signature === this.lastSignature)
+            return;
+        this.lastSignature = signature;
+        this.scheduleEmit();
+    }
+    /** Everything a subscriber would render differently, flattened for comparison. */
+    lastSignature = '';
+    layoutSignature(values) {
+        return [
+            this.count,
+            this.xKey,
+            this.stacked,
+            this.width,
+            this.height,
+            this.bandPadding,
+            this.scaleMode,
+            this.zeroRequired,
+            this.margin.top, this.margin.right, this.margin.bottom, this.margin.left,
+            this.domainMin, this.domainMax, this.tickStep,
+            this.tickValues.join(','),
+            this.series.map((s) => s.key + ':' + s.label).join(','),
+            this.xLabels.join('
'),
+            values.join(','),
+        ].join('');
+    }
+    /**
+     * Coalesces layout notifications into a microtask, so several children
+     * registering in the same change-detection pass produce one emission after
+     * they have all settled rather than one each mid-pass.
+     */
+    scheduleEmit() {
+        this.layoutVersion++;
+        if (this.emitScheduled)
+            return;
+        this.emitScheduled = true;
+        queueMicrotask(() => {
+            this.emitScheduled = false;
+            this.layoutSubject.next(this.layoutVersion);
+        });
+    }
+    /** Formats a value for a tick label at the current tick step's precision. */
+    formatValue(value) {
+        const decimals = decimalsFor(this.tickStep);
+        return value.toLocaleString('en-US', {
+            minimumFractionDigits: decimals,
+            maximumFractionDigits: decimals,
+        });
+    }
+    // ------------------------------------------------------------------- paths
+    /** Straight-segment path through the series' defined points. */
+    linePath(seriesKey) {
+        return buildPath(this.pointsFor(seriesKey), false);
+    }
+    /** Monotone-cubic path through the series' defined points. */
+    smoothPath(seriesKey) {
+        return buildPath(this.pointsFor(seriesKey), true);
+    }
+    /**
+     * Filled-area path: the series' line, closed back along its baseline. When
+     * stacked, the floor is the top of the series below rather than zero.
+     */
+    areaPath(seriesKey, smooth) {
+        const points = this.pointsFor(seriesKey);
+        if (points.length === 0)
+            return '';
+        const top = buildPath(points, smooth);
+        const floor = points
+            .map((p) => {
+            const base = this.stacked ? this.stackBase(seriesKey, p.index) : 0;
+            return { x: p.x, y: this.yFor(base), index: p.index };
+        })
+            .reverse();
+        const bottom = buildPath(floor, smooth);
+        // Re-enter the reversed floor with a line, then close.
+        return top + ' L ' + floor[0].x + ' ' + floor[0].y + ' ' + bottom.replace(/^M/, 'L') + ' Z';
+    }
+    /** Resolved svg points for a series, skipping rows where it has no value. */
+    pointsFor(seriesKey) {
+        const points = [];
+        for (let i = 0; i < this.count; i++) {
+            const v = this.valueAt(seriesKey, i);
+            if (v == null)
+                continue;
+            const stacked = this.stacked ? this.stackBase(seriesKey, i) + v : v;
+            points.push({ x: this.xFor(i), y: this.yFor(stacked), index: i });
+        }
+        return points;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartService, decorators: [{
+            type: Injectable
+        }] });
+// ------------------------------------------------------------- pure helpers
+/** Decimal places worth showing for a given tick step. */
+export function decimalsFor(step) {
+    if (!Number.isFinite(step) || step <= 0)
+        return 0;
+    return Math.max(0, Math.min(6, -Math.floor(Math.log10(step))));
+}
+/**
+ * Rounds a raw step up to the next 1/2/5 x 10^n.
+ *
+ * Dividing the range by a tick count instead would produce steps like 19.4 and
+ * so axis labels like 19.4 / 38.8 / 58.2, which nobody can read a value off.
+ */
+export function niceStep(rawStep) {
+    if (!Number.isFinite(rawStep) || rawStep <= 0)
+        return 1;
+    const magnitude = Math.pow(10, Math.floor(Math.log10(rawStep)));
+    const normalised = rawStep / magnitude;
+    let multiplier;
+    if (normalised <= 1)
+        multiplier = 1;
+    else if (normalised <= 2)
+        multiplier = 2;
+    else if (normalised <= 5)
+        multiplier = 5;
+    else
+        multiplier = 10;
+    return multiplier * magnitude;
+}
+/**
+ * Builds a readable y scale over `values`: returns `[min, max, step, ticks]`
+ * with the domain snapped outward to whole steps.
+ *
+ * Degenerate inputs (empty, all-identical) still produce a usable one-unit
+ * domain rather than a zero-height plot.
+ */
+export function niceScale(values, targetTicks = 5) {
+    const finite = values.filter((v) => Number.isFinite(v));
+    let min = finite.length ? Math.min(...finite) : 0;
+    let max = finite.length ? Math.max(...finite) : 1;
+    if (min === max) {
+        // A flat or single-point domain has no span to divide; open it to one unit
+        // around the value so the mark sits on a real axis instead of on the floor.
+        if (min === 0) {
+            min = 0;
+            max = 1;
+        }
+        else if (min > 0) {
+            min = Math.min(0, min);
+            max = max === 0 ? 1 : max;
+            if (min === max)
+                max = min + 1;
+        }
+        else {
+            max = Math.max(0, max);
+            if (min === max)
+                min = max - 1;
+        }
+    }
+    const step = niceStep((max - min) / targetTicks);
+    // Nudge before rounding outward: 100/20 lands a hair above 5 in binary
+    // floating point, which would otherwise add a phantom tick at 120.
+    const epsilon = 1e-9;
+    const niceMin = Math.floor(min / step + epsilon) * step;
+    const niceMax = Math.ceil(max / step - epsilon) * step;
+    const decimals = decimalsFor(step);
+    const ticks = [];
+    const total = Math.round((niceMax - niceMin) / step);
+    for (let i = 0; i <= total; i++) {
+        ticks.push(Number((niceMin + i * step).toFixed(decimals)));
+    }
+    return [Number(niceMin.toFixed(decimals)), Number(niceMax.toFixed(decimals)), step, ticks];
+}
+/**
+ * Monotone-cubic tangents (Fritsch-Carlson). Limiting each tangent to the
+ * neighbouring secants is what stops the curve overshooting: a plain
+ * Catmull-Rom spline bulges past the data and invents peaks that were never
+ * measured, which on a chart is a false statement about the numbers.
+ */
+export function monotoneTangents(xs, ys) {
+    const n = xs.length;
+    if (n < 2)
+        return new Array(n).fill(0);
+    const secants = [];
+    for (let i = 0; i < n - 1; i++) {
+        const dx = xs[i + 1] - xs[i];
+        secants.push(dx === 0 ? 0 : (ys[i + 1] - ys[i]) / dx);
+    }
+    const m = new Array(n);
+    m[0] = secants[0];
+    m[n - 1] = secants[n - 2];
+    for (let i = 1; i < n - 1; i++)
+        m[i] = (secants[i - 1] + secants[i]) / 2;
+    for (let i = 0; i < n - 1; i++) {
+        if (secants[i] === 0) {
+            // Flat segment: both ends must be flat or the curve leaves the data range.
+            m[i] = 0;
+            m[i + 1] = 0;
+            continue;
+        }
+        const a = m[i] / secants[i];
+        const b = m[i + 1] / secants[i];
+        // Negative ratios mean the tangent points away from the secant.
+        if (a < 0)
+            m[i] = 0;
+        if (b < 0)
+            m[i + 1] = 0;
+        const sum = a * a + b * b;
+        if (sum > 9) {
+            const t = 3 / Math.sqrt(sum);
+            m[i] = t * a * secants[i];
+            m[i + 1] = t * b * secants[i];
+        }
+    }
+    return m;
+}
+/** Turns resolved points into an svg path, optionally monotone-smoothed. */
+export function buildPath(points, smooth) {
+    if (points.length === 0)
+        return '';
+    if (points.length === 1)
+        return 'M ' + points[0].x + ' ' + points[0].y;
+    const head = 'M ' + points[0].x + ' ' + points[0].y;
+    if (!smooth) {
+        return head + points.slice(1).map((p) => ' L ' + p.x + ' ' + p.y).join('');
+    }
+    const xs = points.map((p) => p.x);
+    const ys = points.map((p) => p.y);
+    const m = monotoneTangents(xs, ys);
+    let d = head;
+    for (let i = 0; i < points.length - 1; i++) {
+        const dx = xs[i + 1] - xs[i];
+        const c1x = xs[i] + dx / 3;
+        const c1y = ys[i] + (m[i] * dx) / 3;
+        const c2x = xs[i + 1] - dx / 3;
+        const c2y = ys[i + 1] - (m[i + 1] * dx) / 3;
+        d += ' C ' + c1x + ' ' + c1y + ' ' + c2x + ' ' + c2y + ' ' + xs[i + 1] + ' ' + ys[i + 1];
+    }
+    return d;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.service.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/chart.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\n\n/** One plotted series: which key to read off each row, and how to name it. */\nexport interface ChartSeries {\n  key: string;\n  label: string;\n}\n\n/** Space reserved around the plot area for axes and labels. */\nexport interface ChartMargin {\n  top: number;\n  right: number;\n  bottom: number;\n  left: number;\n}\n\n/** A y-axis tick: its data value, its resolved svg y, and its formatted label. */\nexport interface ChartTick {\n  value: number;\n  y: number;\n  label: string;\n}\n\n/** A horizontal slice of the plot belonging to one x position. */\nexport interface ChartBand {\n  start: number;\n  centre: number;\n  width: number;\n}\n\n/** How x positions are resolved: discrete bands (bars) or points (line/area). */\nexport type ChartScaleMode = 'point' | 'band';\n\n/** Number of chart palette steps that exist. A 6th series does not get a colour. */\nexport const CHART_COLOR_LIMIT = 5;\n\n/**\n * The paint used for a series past `CHART_COLOR_LIMIT`.\n *\n * The palette is validated for lightness, chroma and colour-blind separation at\n * exactly five steps; generating a sixth would land outside that validation, and\n * wrapping back to step 1 would make two series share an identity. Both are\n * worse than dropping to a neutral, so the overflow is explicitly uncoloured.\n */\nexport const CHART_OVERFLOW_COLOR = 'rgb(var(--muted-foreground))';\n\n/**\n * Hands out palette steps by entity key rather than by position.\n *\n * A key keeps its slot for the lifetime of the scale, which is what makes\n * colour follow the entity: filtering a series out and back in, or removing an\n * earlier one, must never repaint the survivors. Past the fifth distinct key\n * the scale stops colouring rather than inventing a step or wrapping around.\n */\nexport class ChartColorScale {\n  private readonly slots = new Map<string, number>();\n  private next = 0;\n\n  /** Reserves slots for `keys` in order, leaving already-known keys alone. */\n  register(keys: string[]): void {\n    for (const key of keys) {\n      if (!this.slots.has(key)) this.slots.set(key, this.next++);\n    }\n  }\n\n  /** Paint for `key`, registering it on first sight. */\n  colorFor(key: string): string {\n    let slot = this.slots.get(key);\n    if (slot === undefined) {\n      slot = this.next++;\n      this.slots.set(key, slot);\n    }\n    if (slot >= CHART_COLOR_LIMIT) return CHART_OVERFLOW_COLOR;\n    return 'rgb(var(--chart-' + (slot + 1) + '))';\n  }\n\n  /** True when `key` fell past the palette and renders neutral. */\n  isOverflow(key: string): boolean {\n    const slot = this.slots.get(key);\n    return slot !== undefined && slot >= CHART_COLOR_LIMIT;\n  }\n\n  /** Slot index assigned to `key`, or undefined when it is unknown. */\n  slotOf(key: string): number | undefined {\n    return this.slots.get(key);\n  }\n}\n\n/**\n * Owns layout, scales and colour assignment for one `tolle-chart`, so every\n * child draws into the same coordinate space. Renders nothing itself.\n *\n * Provided on `ChartComponent`, so each chart gets its own instance.\n */\n@Injectable()\nexport class ChartService {\n  /** Rows being plotted, in x order. */\n  data: Record<string, any>[] = [];\n  /** Series definitions, in the order they should take palette steps. */\n  series: ChartSeries[] = [];\n  /** Row key holding the x category/label. */\n  xKey = '';\n  /** Whether marks stack on a shared baseline rather than sitting side by side. */\n  stacked = false;\n  /** Full svg width in px, tracked from the container's ResizeObserver. */\n  width = 0;\n  /** Full svg height in px. */\n  height = 260;\n  /** Space reserved around the plot area. */\n  margin: ChartMargin = { top: 8, right: 8, bottom: 24, left: 40 };\n  /** Fraction of a band's step spent on padding, split either side. */\n  bandPadding = 0.2;\n\n  private scaleMode: ChartScaleMode = 'point';\n  private zeroRequired = false;\n\n  private domainMin = 0;\n  private domainMax = 1;\n  private tickValues: number[] = [];\n  private tickStep = 1;\n\n  /** Palette assignment, keyed by series identity. */\n  private readonly colors = new ChartColorScale();\n\n  private readonly layoutSubject = new BehaviorSubject<number>(0);\n  /** Emits a version number whenever scales, dimensions or data change. */\n  readonly layout$ = this.layoutSubject.asObservable();\n\n  private readonly activeIndexSubject = new BehaviorSubject<number | null>(null);\n  /** Index of the x position under the pointer, or null when not hovering. */\n  readonly activeIndex$ = this.activeIndexSubject.asObservable();\n\n  private layoutVersion = 0;\n  private emitScheduled = false;\n\n  // ---------------------------------------------------------------- geometry\n\n  get plotLeft(): number {\n    return this.margin.left;\n  }\n\n  get plotTop(): number {\n    return this.margin.top;\n  }\n\n  get plotWidth(): number {\n    return Math.max(0, this.width - this.margin.left - this.margin.right);\n  }\n\n  get plotHeight(): number {\n    return Math.max(0, this.height - this.margin.top - this.margin.bottom);\n  }\n\n  get plotRight(): number {\n    return this.plotLeft + this.plotWidth;\n  }\n\n  get plotBottom(): number {\n    return this.plotTop + this.plotHeight;\n  }\n\n  /** Number of x positions. */\n  get count(): number {\n    return this.data.length;\n  }\n\n  /** How x is currently resolved. Bars flip this to 'band'. */\n  get mode(): ChartScaleMode {\n    return this.scaleMode;\n  }\n\n  /** Resolved y ticks, with svg coordinates and formatted labels. */\n  get ticks(): ChartTick[] {\n    return this.tickValues.map((value) => ({\n      value,\n      y: this.yFor(value),\n      label: this.formatValue(value),\n    }));\n  }\n\n  /** Current y domain as [min, max]. */\n  get domain(): [number, number] {\n    return [this.domainMin, this.domainMax];\n  }\n\n  /** The x-axis category labels, one per row. */\n  get xLabels(): string[] {\n    return this.data.map((row) => {\n      const raw = row?.[this.xKey];\n      return raw == null ? '' : String(raw);\n    });\n  }\n\n  // ------------------------------------------------------------ registration\n\n  /**\n   * Replaces the chart's configuration and recomputes the scales.\n   * Called by the container on input changes and on resize.\n   */\n  configure(config: Partial<Pick<ChartService,\n    'data' | 'series' | 'xKey' | 'stacked' | 'width' | 'height' | 'margin' | 'bandPadding'>>): void {\n    Object.assign(this, config);\n    if (config.series) this.syncColorSlots(config.series);\n    this.recompute();\n  }\n\n  /** Switches x to a band scale. Bars call this; it also forces zero into the domain. */\n  useBandScale(): void {\n    if (this.scaleMode === 'band' && this.zeroRequired) return;\n    this.scaleMode = 'band';\n    this.zeroRequired = true;\n    this.recompute();\n  }\n\n  /** Forces zero into the y domain, for marks anchored to a baseline. */\n  requireZero(): void {\n    if (this.zeroRequired) return;\n    this.zeroRequired = true;\n    this.recompute();\n  }\n\n  /** Reserves palette slots in series order, leaving known keys untouched. */\n  private syncColorSlots(series: ChartSeries[]): void {\n    this.colors.register(series.map((item) => item.key));\n  }\n\n  /**\n   * Paint for a series, keyed by identity rather than by index in the visible\n   * array. Past the fifth distinct key this returns the neutral overflow colour.\n   */\n  colorFor(seriesKey: string): string {\n    return this.colors.colorFor(seriesKey);\n  }\n\n  /** True when this series fell past the palette and renders neutral. */\n  isOverflowSeries(seriesKey: string): boolean {\n    return this.colors.isOverflow(seriesKey);\n  }\n\n  // -------------------------------------------------------------- the scales\n\n  /** Reads a series value off a row, or null when it is missing/non-numeric. */\n  valueAt(seriesKey: string, index: number): number | null {\n    const raw = this.data[index]?.[seriesKey];\n    if (raw == null || raw === '') return null;\n    const num = Number(raw);\n    return Number.isFinite(num) ? num : null;\n  }\n\n  /** Sum of every series below `seriesKey` at `index`, for stacked marks. */\n  stackBase(seriesKey: string, index: number): number {\n    if (!this.stacked) return 0;\n    let base = 0;\n    for (const item of this.series) {\n      if (item.key === seriesKey) break;\n      base += this.valueAt(item.key, index) ?? 0;\n    }\n    return base;\n  }\n\n  /** Sum of every series at `index`. */\n  stackTotal(index: number): number {\n    let total = 0;\n    for (const item of this.series) total += this.valueAt(item.key, index) ?? 0;\n    return total;\n  }\n\n  /**\n   * Maps a data value to an svg y. SVG y grows downward, so the domain maximum\n   * lands on `plotTop` and the minimum on `plotBottom`.\n   */\n  yFor(value: number): number {\n    const span = this.domainMax - this.domainMin;\n    if (span <= 0) return this.plotBottom;\n    const ratio = (value - this.domainMin) / span;\n    return this.plotBottom - ratio * this.plotHeight;\n  }\n\n  /** The svg y of the zero line, clamped into the plot. */\n  get baselineY(): number {\n    const zero = Math.min(Math.max(0, this.domainMin), this.domainMax);\n    return this.yFor(zero);\n  }\n\n  /** Width of one band, excluding its padding. Meaningful in band mode. */\n  get bandWidth(): number {\n    if (this.count === 0) return 0;\n    return this.bandStep * (1 - this.bandPadding);\n  }\n\n  /** Distance between adjacent band starts. Bands tile the plot exactly. */\n  get bandStep(): number {\n    if (this.count === 0) return 0;\n    return this.plotWidth / this.count;\n  }\n\n  /** Geometry of the band at `index`. */\n  bandFor(index: number): ChartBand {\n    const step = this.bandStep;\n    const width = this.bandWidth;\n    const start = this.plotLeft + index * step + (step - width) / 2;\n    return { start, centre: start + width / 2, width };\n  }\n\n  /** x of the data point at `index` on the point scale. */\n  pointX(index: number): number {\n    if (this.count === 0) return this.plotLeft;\n    if (this.count === 1) return this.plotLeft + this.plotWidth / 2;\n    return this.plotLeft + (index * this.plotWidth) / (this.count - 1);\n  }\n\n  /** x of `index` under whichever scale the chart is currently using. */\n  xFor(index: number): number {\n    return this.scaleMode === 'band' ? this.bandFor(index).centre : this.pointX(index);\n  }\n\n  /**\n   * The pointer catchment area for `index` — deliberately wider than the mark.\n   * In band mode it is the whole band step; on the point scale it runs to the\n   * midpoints of the neighbouring points, so the pointer only has to be nearest.\n   */\n  hitBandFor(index: number): ChartBand {\n    if (this.scaleMode === 'band') {\n      const step = this.bandStep;\n      const start = this.plotLeft + index * step;\n      return { start, centre: start + step / 2, width: step };\n    }\n    const x = this.pointX(index);\n    const prev = index > 0 ? this.pointX(index - 1) : this.plotLeft - (this.plotRight - this.plotLeft);\n    const next =\n      index < this.count - 1 ? this.pointX(index + 1) : this.plotRight + (this.plotRight - this.plotLeft);\n    const start = Math.max(this.plotLeft, (prev + x) / 2);\n    const end = Math.min(this.plotRight, (x + next) / 2);\n    return { start, centre: x, width: Math.max(0, end - start) };\n  }\n\n  // --------------------------------------------------------------- hovering\n\n  /** Index currently under the pointer, or null. */\n  get activeIndex(): number | null {\n    return this.activeIndexSubject.value;\n  }\n\n  setActiveIndex(index: number | null): void {\n    if (this.activeIndexSubject.value === index) return;\n    this.activeIndexSubject.next(index);\n  }\n\n  // ----------------------------------------------------------------- domains\n\n  private recompute(): void {\n    const values: number[] = [];\n\n    if (this.stacked) {\n      for (let i = 0; i < this.count; i++) values.push(this.stackTotal(i));\n      // A stack still has to show its own floor when a series goes negative.\n      for (const item of this.series) {\n        for (let i = 0; i < this.count; i++) {\n          const v = this.valueAt(item.key, i);\n          if (v != null && v < 0) values.push(v);\n        }\n      }\n    } else {\n      for (const item of this.series) {\n        for (let i = 0; i < this.count; i++) {\n          const v = this.valueAt(item.key, i);\n          if (v != null) values.push(v);\n        }\n      }\n    }\n\n    if (this.zeroRequired) values.push(0);\n\n    const [min, max, step, ticks] = niceScale(values);\n    this.domainMin = min;\n    this.domainMax = max;\n    this.tickStep = step;\n    this.tickValues = ticks;\n\n    // Only tell subscribers when something they would draw differently actually\n    // changed. `configure()` is called from ngOnChanges, and an app binding\n    // `[data]=\"items.filter(...)\"` hands us a fresh array reference on every\n    // change-detection pass — an ordinary thing to write. Emitting on every call\n    // made subscribers markForCheck, which scheduled another pass, which called\n    // configure again: the cycle never closed and the page locked up.\n    const signature = this.layoutSignature(values);\n    if (signature === this.lastSignature) return;\n    this.lastSignature = signature;\n\n    this.scheduleEmit();\n  }\n\n  /** Everything a subscriber would render differently, flattened for comparison. */\n  private lastSignature = '';\n\n  private layoutSignature(values: number[]): string {\n    return [\n      this.count,\n      this.xKey,\n      this.stacked,\n      this.width,\n      this.height,\n      this.bandPadding,\n      this.scaleMode,\n      this.zeroRequired,\n      this.margin.top, this.margin.right, this.margin.bottom, this.margin.left,\n      this.domainMin, this.domainMax, this.tickStep,\n      this.tickValues.join(','),\n      this.series.map((s) => s.key + ':' + s.label).join(','),\n      this.xLabels.join('\u0001'),\n      values.join(','),\n    ].join('\u0000');\n  }\n\n  /**\n   * Coalesces layout notifications into a microtask, so several children\n   * registering in the same change-detection pass produce one emission after\n   * they have all settled rather than one each mid-pass.\n   */\n  private scheduleEmit(): void {\n    this.layoutVersion++;\n    if (this.emitScheduled) return;\n    this.emitScheduled = true;\n    queueMicrotask(() => {\n      this.emitScheduled = false;\n      this.layoutSubject.next(this.layoutVersion);\n    });\n  }\n\n  /** Formats a value for a tick label at the current tick step's precision. */\n  formatValue(value: number): string {\n    const decimals = decimalsFor(this.tickStep);\n    return value.toLocaleString('en-US', {\n      minimumFractionDigits: decimals,\n      maximumFractionDigits: decimals,\n    });\n  }\n\n  // ------------------------------------------------------------------- paths\n\n  /** Straight-segment path through the series' defined points. */\n  linePath(seriesKey: string): string {\n    return buildPath(this.pointsFor(seriesKey), false);\n  }\n\n  /** Monotone-cubic path through the series' defined points. */\n  smoothPath(seriesKey: string): string {\n    return buildPath(this.pointsFor(seriesKey), true);\n  }\n\n  /**\n   * Filled-area path: the series' line, closed back along its baseline. When\n   * stacked, the floor is the top of the series below rather than zero.\n   */\n  areaPath(seriesKey: string, smooth: boolean): string {\n    const points = this.pointsFor(seriesKey);\n    if (points.length === 0) return '';\n\n    const top = buildPath(points, smooth);\n    const floor = points\n      .map((p) => {\n        const base = this.stacked ? this.stackBase(seriesKey, p.index) : 0;\n        return { x: p.x, y: this.yFor(base), index: p.index };\n      })\n      .reverse();\n    const bottom = buildPath(floor, smooth);\n    // Re-enter the reversed floor with a line, then close.\n    return top + ' L ' + floor[0].x + ' ' + floor[0].y + ' ' + bottom.replace(/^M/, 'L') + ' Z';\n  }\n\n  /** Resolved svg points for a series, skipping rows where it has no value. */\n  pointsFor(seriesKey: string): { x: number; y: number; index: number }[] {\n    const points: { x: number; y: number; index: number }[] = [];\n    for (let i = 0; i < this.count; i++) {\n      const v = this.valueAt(seriesKey, i);\n      if (v == null) continue;\n      const stacked = this.stacked ? this.stackBase(seriesKey, i) + v : v;\n      points.push({ x: this.xFor(i), y: this.yFor(stacked), index: i });\n    }\n    return points;\n  }\n}\n\n// ------------------------------------------------------------- pure helpers\n\n/** Decimal places worth showing for a given tick step. */\nexport function decimalsFor(step: number): number {\n  if (!Number.isFinite(step) || step <= 0) return 0;\n  return Math.max(0, Math.min(6, -Math.floor(Math.log10(step))));\n}\n\n/**\n * Rounds a raw step up to the next 1/2/5 x 10^n.\n *\n * Dividing the range by a tick count instead would produce steps like 19.4 and\n * so axis labels like 19.4 / 38.8 / 58.2, which nobody can read a value off.\n */\nexport function niceStep(rawStep: number): number {\n  if (!Number.isFinite(rawStep) || rawStep <= 0) return 1;\n  const magnitude = Math.pow(10, Math.floor(Math.log10(rawStep)));\n  const normalised = rawStep / magnitude;\n  let multiplier: number;\n  if (normalised <= 1) multiplier = 1;\n  else if (normalised <= 2) multiplier = 2;\n  else if (normalised <= 5) multiplier = 5;\n  else multiplier = 10;\n  return multiplier * magnitude;\n}\n\n/**\n * Builds a readable y scale over `values`: returns `[min, max, step, ticks]`\n * with the domain snapped outward to whole steps.\n *\n * Degenerate inputs (empty, all-identical) still produce a usable one-unit\n * domain rather than a zero-height plot.\n */\nexport function niceScale(values: number[], targetTicks = 5): [number, number, number, number[]] {\n  const finite = values.filter((v) => Number.isFinite(v));\n\n  let min = finite.length ? Math.min(...finite) : 0;\n  let max = finite.length ? Math.max(...finite) : 1;\n\n  if (min === max) {\n    // A flat or single-point domain has no span to divide; open it to one unit\n    // around the value so the mark sits on a real axis instead of on the floor.\n    if (min === 0) {\n      min = 0;\n      max = 1;\n    } else if (min > 0) {\n      min = Math.min(0, min);\n      max = max === 0 ? 1 : max;\n      if (min === max) max = min + 1;\n    } else {\n      max = Math.max(0, max);\n      if (min === max) min = max - 1;\n    }\n  }\n\n  const step = niceStep((max - min) / targetTicks);\n  // Nudge before rounding outward: 100/20 lands a hair above 5 in binary\n  // floating point, which would otherwise add a phantom tick at 120.\n  const epsilon = 1e-9;\n  const niceMin = Math.floor(min / step + epsilon) * step;\n  const niceMax = Math.ceil(max / step - epsilon) * step;\n  const decimals = decimalsFor(step);\n\n  const ticks: number[] = [];\n  const total = Math.round((niceMax - niceMin) / step);\n  for (let i = 0; i <= total; i++) {\n    ticks.push(Number((niceMin + i * step).toFixed(decimals)));\n  }\n\n  return [Number(niceMin.toFixed(decimals)), Number(niceMax.toFixed(decimals)), step, ticks];\n}\n\n/**\n * Monotone-cubic tangents (Fritsch-Carlson). Limiting each tangent to the\n * neighbouring secants is what stops the curve overshooting: a plain\n * Catmull-Rom spline bulges past the data and invents peaks that were never\n * measured, which on a chart is a false statement about the numbers.\n */\nexport function monotoneTangents(xs: number[], ys: number[]): number[] {\n  const n = xs.length;\n  if (n < 2) return new Array(n).fill(0);\n\n  const secants: number[] = [];\n  for (let i = 0; i < n - 1; i++) {\n    const dx = xs[i + 1] - xs[i];\n    secants.push(dx === 0 ? 0 : (ys[i + 1] - ys[i]) / dx);\n  }\n\n  const m: number[] = new Array(n);\n  m[0] = secants[0];\n  m[n - 1] = secants[n - 2];\n  for (let i = 1; i < n - 1; i++) m[i] = (secants[i - 1] + secants[i]) / 2;\n\n  for (let i = 0; i < n - 1; i++) {\n    if (secants[i] === 0) {\n      // Flat segment: both ends must be flat or the curve leaves the data range.\n      m[i] = 0;\n      m[i + 1] = 0;\n      continue;\n    }\n    const a = m[i] / secants[i];\n    const b = m[i + 1] / secants[i];\n    // Negative ratios mean the tangent points away from the secant.\n    if (a < 0) m[i] = 0;\n    if (b < 0) m[i + 1] = 0;\n    const sum = a * a + b * b;\n    if (sum > 9) {\n      const t = 3 / Math.sqrt(sum);\n      m[i] = t * a * secants[i];\n      m[i + 1] = t * b * secants[i];\n    }\n  }\n\n  return m;\n}\n\n/** Turns resolved points into an svg path, optionally monotone-smoothed. */\nexport function buildPath(points: { x: number; y: number }[], smooth: boolean): string {\n  if (points.length === 0) return '';\n  if (points.length === 1) return 'M ' + points[0].x + ' ' + points[0].y;\n\n  const head = 'M ' + points[0].x + ' ' + points[0].y;\n  if (!smooth) {\n    return head + points.slice(1).map((p) => ' L ' + p.x + ' ' + p.y).join('');\n  }\n\n  const xs = points.map((p) => p.x);\n  const ys = points.map((p) => p.y);\n  const m = monotoneTangents(xs, ys);\n\n  let d = head;\n  for (let i = 0; i < points.length - 1; i++) {\n    const dx = xs[i + 1] - xs[i];\n    const c1x = xs[i] + dx / 3;\n    const c1y = ys[i] + (m[i] * dx) / 3;\n    const c2x = xs[i + 1] - dx / 3;\n    const c2y = ys[i + 1] - (m[i + 1] * dx) / 3;\n    d += ' C ' + c1x + ' ' + c1y + ' ' + c2x + ' ' + c2y + ' ' + xs[i + 1] + ' ' + ys[i + 1];\n  }\n  return d;\n}\n"]}