@tolle_/tolle-ui 18.2.29 → 18.2.30

package/esm2022/lib/chart.component.mjs

@@ -0,0 +1,1146 @@
+import { Component, Directive, Input, Output, EventEmitter, ChangeDetectionStrategy, ChangeDetectorRef, ViewChild, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { Subscription } from 'rxjs';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import { ChartService } from './chart.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+let chartId = 0;
+/**
+ * Base for every chart part that has to redraw when the shared scales change.
+ * Parts subscribe to the service rather than reading the container component,
+ * so an OnPush child still updates when the container's inputs or width change.
+ */
+export class ChartChild {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook subclasses keep
+     * rendering the class they were born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    chart = inject(ChartService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    /**
+     * Identity for the mark `*ngFor`s. The collections behind them are rebuilt on
+     * every read, so without this `*ngFor` sees new identities each pass and
+     * replaces every node instead of patching it. Marks are positional, so the
+     * index IS the identity.
+     */
+    trackByIndex = (index) => index;
+    ngOnInit() {
+        this.register();
+        this.subscriptions.add(this.chart.layout$.subscribe(() => this.cdr.markForCheck()));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    /** Hook for parts that need to influence the shared scales before first paint. */
+    register() { }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartChild, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: ChartChild, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartChild, decorators: [{
+            type: Directive
+        }] });
+/**
+ * The floating readout for the hovered x position. Lists every series at that
+ * x, so the pointer never has to land on a particular line to get a value.
+ * Rendered automatically by `tolle-chart` when `hover` is on.
+ */
+export class ChartTooltipComponent {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */
+    trackByIndex = (index) => index;
+    /** Distance in px the tooltip sits from the crosshair. @default 12 */
+    offset = 12;
+    /** Assumed tooltip width in px, used to flip it near the right edge. @default 160 */
+    estimatedWidth = 160;
+    /** Extra Tailwind classes merged onto the tooltip via `cn()` (last-wins). */
+    class = '';
+    chart = inject(ChartService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    /** Row index the tooltip is describing, or null when nothing is hovered. */
+    index = null;
+    ngOnInit() {
+        this.subscriptions.add(this.chart.activeIndex$.subscribe((index) => {
+            this.index = index;
+            this.cdr.markForCheck();
+        }));
+        this.subscriptions.add(this.chart.layout$.subscribe(() => this.cdr.markForCheck()));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    get xLabel() {
+        return this.index === null ? '' : this.chart.xLabels[this.index] ?? '';
+    }
+    /** One row per series: colour key, label, and the formatted value. */
+    get rows() {
+        const index = this.index;
+        if (index === null)
+            return [];
+        return this.chart.series.map((item) => {
+            const value = this.chart.valueAt(item.key, index);
+            return {
+                label: item.label,
+                value: value == null ? '—' : this.chart.formatValue(value),
+                color: this.chart.colorFor(item.key),
+            };
+        });
+    }
+    get left() {
+        if (this.index === null)
+            return 0;
+        const x = this.chart.xFor(this.index);
+        // Flip to the left of the crosshair rather than overflow the container.
+        if (x + this.offset + this.estimatedWidth > this.chart.width) {
+            return Math.max(0, x - this.offset - this.estimatedWidth);
+        }
+        return x + this.offset;
+    }
+    get top() {
+        return this.chart.plotTop;
+    }
+    get computedClass() {
+        return cn('pointer-events-none absolute z-10 min-w-[8rem] rounded-md border border-border bg-popover p-2 text-popover-foreground shadow-md', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartTooltipComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartTooltipComponent, isStandalone: true, selector: "tolle-chart-tooltip", inputs: { offset: "offset", estimatedWidth: "estimatedWidth", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      *ngIf="index !== null"
+      role="status"
+      aria-live="polite"
+      [class]="computedClass"
+      [style.left.px]="left"
+      [style.top.px]="top"
+    >
+      <p class="mb-1 text-xs font-medium text-foreground">{{ xLabel }}</p>
+      <div *ngFor="let row of rows; trackBy: trackByIndex" class="flex items-center gap-2 text-xs">
+        <span class="h-0.5 w-3 shrink-0 rounded-full" [style.background]="row.color"></span>
+        <span class="text-muted-foreground">{{ row.label }}</span>
+        <span class="ml-auto font-medium tabular-nums text-foreground">{{ row.value }}</span>
+      </div>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartTooltipComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-chart-tooltip', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div
+      *ngIf="index !== null"
+      role="status"
+      aria-live="polite"
+      [class]="computedClass"
+      [style.left.px]="left"
+      [style.top.px]="top"
+    >
+      <p class="mb-1 text-xs font-medium text-foreground">{{ xLabel }}</p>
+      <div *ngFor="let row of rows; trackBy: trackByIndex" class="flex items-center gap-2 text-xs">
+        <span class="h-0.5 w-3 shrink-0 rounded-full" [style.background]="row.color"></span>
+        <span class="text-muted-foreground">{{ row.label }}</span>
+        <span class="ml-auto font-medium tabular-nums text-foreground">{{ row.value }}</span>
+      </div>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { offset: [{
+                type: Input
+            }], estimatedWidth: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+const chartLegendVariants = cva('flex flex-wrap items-center gap-x-4 gap-y-1 pt-2', {
+    variants: {
+        align: { start: 'justify-start', center: 'justify-center', end: 'justify-end' },
+        size: { sm: 'text-[11px]', default: 'text-xs' },
+    },
+    defaultVariants: { align: 'center', size: 'default' },
+});
+/**
+ * Swatch and label per series. Rendered automatically by `tolle-chart` whenever
+ * there are two or more series, so identity is never carried by colour alone.
+ * A single series gets no legend — the chart's own label already names it.
+ */
+export class ChartLegendComponent {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */
+    trackByIndex = (index) => index;
+    /** Horizontal alignment of the legend row. @default 'center' */
+    align = 'center';
+    /** Text size of the legend. @default 'default' */
+    size = 'default';
+    /** Extra Tailwind classes merged onto the legend via `cn()` (last-wins). */
+    class = '';
+    chart = inject(ChartService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    ngOnInit() {
+        this.subscriptions.add(this.chart.layout$.subscribe(() => this.cdr.markForCheck()));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    /** One entry per series, coloured by series identity. */
+    get entries() {
+        return this.chart.series.map((item) => ({
+            label: item.label,
+            color: this.chart.colorFor(item.key),
+        }));
+    }
+    get computedClass() {
+        return cn(chartLegendVariants({ align: this.align, size: this.size }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartLegendComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartLegendComponent, isStandalone: true, selector: "tolle-chart-legend", inputs: { align: "align", size: "size", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <ul [class]="computedClass">
+      <li *ngFor="let entry of entries; trackBy: trackByIndex" class="flex items-center gap-1.5">
+        <span class="h-2 w-2 shrink-0 rounded-[2px]" [style.background]="entry.color"></span>
+        <span class="text-muted-foreground">{{ entry.label }}</span>
+      </li>
+    </ul>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartLegendComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-chart-legend', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <ul [class]="computedClass">
+      <li *ngFor="let entry of entries; trackBy: trackByIndex" class="flex items-center gap-1.5">
+        <span class="h-2 w-2 shrink-0 rounded-[2px]" [style.background]="entry.color"></span>
+        <span class="text-muted-foreground">{{ entry.label }}</span>
+      </li>
+    </ul>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { align: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+const chartTableVariants = cva('w-full text-left text-xs', {
+    variants: {
+        visible: {
+            true: 'mt-4 border-collapse',
+            false: 'sr-only',
+        },
+    },
+    defaultVariants: { visible: false },
+});
+/**
+ * The chart's data as a real `<table>`. Visually hidden by default and pointed
+ * at by the svg's `aria-describedby`, so every value the chart encodes in
+ * colour stays reachable without seeing or hovering it. Set `visible` to show it.
+ */
+export class ChartTableComponent {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */
+    trackByIndex = (index) => index;
+    /** Shows the table instead of hiding it from sighted readers. @default false */
+    visible = false;
+    /** Id applied to the wrapper, for the chart's `aria-describedby`. @default '' */
+    tableId = '';
+    /** Column header for the x category. @default 'Category' */
+    xHeader = 'Category';
+    /** Accessible caption for the table. @default 'Chart data' */
+    caption = 'Chart data';
+    /** Extra Tailwind classes merged onto the table via `cn()` (last-wins). */
+    class = '';
+    chart = inject(ChartService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    ngOnInit() {
+        this.subscriptions.add(this.chart.layout$.subscribe(() => this.cdr.markForCheck()));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    /** One row per x position, with a formatted cell per series. */
+    get rows() {
+        return this.chart.xLabels.map((label, i) => ({
+            label,
+            cells: this.chart.series.map((item) => {
+                const value = this.chart.valueAt(item.key, i);
+                return value == null ? '—' : this.chart.formatValue(value);
+            }),
+        }));
+    }
+    get computedClass() {
+        return cn(chartTableVariants({ visible: this.visible }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartTableComponent, isStandalone: true, selector: "tolle-chart-table", inputs: { visible: "visible", tableId: "tableId", xHeader: "xHeader", caption: "caption", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [attr.id]="tableId || null">
+      <table [class]="computedClass">
+        <caption class="sr-only">{{ caption }}</caption>
+        <thead>
+          <tr>
+            <th scope="col" class="border-b border-border px-2 py-1 font-medium text-muted-foreground">
+              {{ xHeader }}
+            </th>
+            <th
+              *ngFor="let item of chart.series; trackBy: trackByIndex"
+              scope="col"
+              class="border-b border-border px-2 py-1 font-medium text-muted-foreground"
+            >
+              {{ item.label }}
+            </th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr *ngFor="let row of rows; trackBy: trackByIndex">
+            <th scope="row" class="border-b border-border px-2 py-1 font-normal text-foreground">
+              {{ row.label }}
+            </th>
+            <td
+              *ngFor="let cell of row.cells; trackBy: trackByIndex"
+              class="border-b border-border px-2 py-1 tabular-nums text-foreground"
+            >
+              {{ cell }}
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartTableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-chart-table', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [attr.id]="tableId || null">
+      <table [class]="computedClass">
+        <caption class="sr-only">{{ caption }}</caption>
+        <thead>
+          <tr>
+            <th scope="col" class="border-b border-border px-2 py-1 font-medium text-muted-foreground">
+              {{ xHeader }}
+            </th>
+            <th
+              *ngFor="let item of chart.series; trackBy: trackByIndex"
+              scope="col"
+              class="border-b border-border px-2 py-1 font-medium text-muted-foreground"
+            >
+              {{ item.label }}
+            </th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr *ngFor="let row of rows; trackBy: trackByIndex">
+            <th scope="row" class="border-b border-border px-2 py-1 font-normal text-foreground">
+              {{ row.label }}
+            </th>
+            <td
+              *ngFor="let cell of row.cells; trackBy: trackByIndex"
+              class="border-b border-border px-2 py-1 tabular-nums text-foreground"
+            >
+              {{ cell }}
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { visible: [{
+                type: Input
+            }], tableId: [{
+                type: Input
+            }], xHeader: [{
+                type: Input
+            }], caption: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+const chartVariants = cva('relative w-full', {
+    variants: {
+        variant: {
+            default: '',
+            card: 'rounded-lg border border-border bg-background p-4',
+        },
+        density: {
+            default: '',
+            compact: 'text-xs',
+        },
+    },
+    defaultVariants: { variant: 'default', density: 'default' },
+});
+/**
+ * Container for a hand-rolled SVG chart. Owns the responsive `<svg>`, the
+ * shared scales (via the `ChartService` it provides), the hover layer, the
+ * legend and the accessible table fallback.
+ *
+ * Marks and axes are projected as SVG children. They use attribute selectors on
+ * `svg:g` rather than element selectors, because a custom element is created in
+ * the HTML namespace and an HTML element inside an `<svg>` never renders its
+ * SVG subtree:
+ *
+ * ```html
+ * <tolle-chart [data]="rows" [series]="series" xKey="month" ariaLabel="Revenue">
+ *   <svg:g tolle-chart-grid></svg:g>
+ *   <svg:g tolle-chart-y-axis></svg:g>
+ *   <svg:g tolle-chart-x-axis></svg:g>
+ *   <svg:g tolle-chart-line seriesKey="revenue" curve="smooth"></svg:g>
+ * </tolle-chart>
+ * ```
+ *
+ * There is deliberately no secondary y-axis: two measures on two scales in one
+ * frame let the author choose where the lines cross, so the reader sees a
+ * relationship the data does not contain. Use two charts, small multiples, or
+ * index both series to a common base instead.
+ * @new
+ */
+export class ChartComponent {
+    /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */
+    trackByIndex = (index) => index;
+    /** Rows to plot, in x order. @default [] */
+    data = [];
+    /** Series to draw, in the order they take palette steps `--chart-1`..`--chart-5`. @default [] */
+    series = [];
+    /** Row key holding each row's x category label. @default '' */
+    xKey = '';
+    /** Height of the chart in px. @default 260 */
+    height = 260;
+    /** Space reserved around the plot for axis labels. @default { top: 8, right: 8, bottom: 24, left: 44 } */
+    margin = { top: 8, right: 8, bottom: 24, left: 44 };
+    /** Accessible name for the chart, used as the svg `<title>`. @default '' */
+    ariaLabel = '';
+    /** Longer summary used as the svg `<desc>`. Falls back to `ariaLabel`. @default '' */
+    description = '';
+    /** Stacks marks on a shared baseline instead of grouping them. @default false */
+    stacked = false;
+    /** Renders the crosshair, hit layer and shared tooltip. @default true */
+    hover = true;
+    /** Shows the data table instead of leaving it visually hidden. @default false */
+    showTable = false;
+    /** Column header the table fallback gives the x category. @default 'Category' */
+    xHeader = 'Category';
+    /** Visual treatment of the chart frame. @default 'default' */
+    variant = 'default';
+    /** Text density of the chart chrome. @default 'default' */
+    density = 'default';
+    /** Extra Tailwind classes merged onto the chart via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the hovered row index, or null when the pointer leaves. */
+    activeIndexChange = new EventEmitter();
+    plotRef;
+    chart = inject(ChartService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    resizeObserver;
+    /** Width used until the container has been measured. */
+    static fallbackWidth = 600;
+    /** Id of the table fallback, referenced by the svg's `aria-describedby`. */
+    tableId = 'chart-table-' + chartId++;
+    /** X of the crosshair, or null when nothing is hovered or the scale is banded. */
+    crosshairX = null;
+    ngOnInit() {
+        this.push();
+        this.subscriptions.add(this.chart.layout$.subscribe(() => this.cdr.markForCheck()));
+        this.subscriptions.add(this.chart.activeIndex$.subscribe((index) => {
+            // Bars carry their own hover state; a crosshair belongs to point scales.
+            this.crosshairX =
+                index != null && this.chart.mode === 'point' ? this.chart.xFor(index) : null;
+            this.activeIndexChange.emit(index);
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnChanges() {
+        this.push();
+        // A bound `class` input is written through Angular's styling path,
+        // which does not mark an OnPush view dirty on its own.
+        this.cdr.markForCheck();
+    }
+    ngAfterViewInit() {
+        const host = this.plotRef?.nativeElement;
+        if (!host)
+            return;
+        this.measure(host);
+        if (typeof ResizeObserver !== 'undefined') {
+            this.resizeObserver = new ResizeObserver(() => {
+                this.measure(host);
+                this.cdr.markForCheck();
+            });
+            this.resizeObserver.observe(host);
+        }
+    }
+    ngOnDestroy() {
+        this.resizeObserver?.disconnect();
+        this.resizeObserver = undefined;
+        this.subscriptions.unsubscribe();
+    }
+    measure(host) {
+        const width = host.clientWidth || ChartComponent.fallbackWidth;
+        if (width === this.chart.width)
+            return;
+        this.chart.configure({ width });
+    }
+    push() {
+        this.chart.configure({
+            data: this.data ?? [],
+            series: this.series ?? [],
+            xKey: this.xKey,
+            stacked: this.stacked,
+            height: this.height,
+            margin: this.margin,
+            width: this.chart.width || ChartComponent.fallbackWidth,
+        });
+    }
+    get viewBox() {
+        return '0 0 ' + (this.chart.width || ChartComponent.fallbackWidth) + ' ' + this.height;
+    }
+    /**
+     * One catchment rect per x position, deliberately wider than the marks it
+     * covers — readers aim at a category, never at a 2px line or an 8px dot.
+     */
+    get hitBands() {
+        if (!this.hover)
+            return [];
+        return this.data.map((_, i) => this.chart.hitBandFor(i));
+    }
+    onEnterBand(index) {
+        this.chart.setActiveIndex(index);
+    }
+    onPointerLeave() {
+        this.chart.setActiveIndex(null);
+    }
+    get computedClass() {
+        return cn(chartVariants({ variant: this.variant, density: this.density }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartComponent, isStandalone: true, selector: "tolle-chart", inputs: { data: "data", series: "series", xKey: "xKey", height: "height", margin: "margin", ariaLabel: "ariaLabel", description: "description", stacked: "stacked", hover: "hover", showTable: "showTable", xHeader: "xHeader", variant: "variant", density: "density", class: "class" }, outputs: { activeIndexChange: "activeIndexChange" }, providers: [ChartService], viewQueries: [{ propertyName: "plotRef", first: true, predicate: ["plot"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass">
+      <div class="relative w-full" #plot>
+        <svg
+          role="img"
+          width="100%"
+          [attr.height]="height"
+          [attr.viewBox]="viewBox"
+          [attr.aria-label]="ariaLabel || null"
+          [attr.aria-describedby]="tableId"
+          class="block w-full overflow-visible"
+          (pointerleave)="onPointerLeave()"
+        >
+          <title>{{ ariaLabel }}</title>
+          <desc>{{ description || ariaLabel }}</desc>
+
+          <svg:g>
+            <ng-content></ng-content>
+          </svg:g>
+
+          <svg:line
+            *ngIf="crosshairX !== null"
+            [attr.x1]="crosshairX"
+            [attr.x2]="crosshairX"
+            [attr.y1]="chart.plotTop"
+            [attr.y2]="chart.plotBottom"
+            class="pointer-events-none stroke-border"
+            stroke-width="1"
+          ></svg:line>
+
+          <svg:rect
+            *ngFor="let band of hitBands; let i = index; trackBy: trackByIndex"
+            [attr.x]="band.start"
+            [attr.y]="chart.plotTop"
+            [attr.width]="band.width"
+            [attr.height]="chart.plotHeight"
+            fill="transparent"
+            (pointerenter)="onEnterBand(i)"
+          ></svg:rect>
+        </svg>
+
+        <tolle-chart-tooltip *ngIf="hover"></tolle-chart-tooltip>
+      </div>
+
+      <tolle-chart-legend *ngIf="series.length > 1"></tolle-chart-legend>
+
+      <tolle-chart-table [tableId]="tableId" [visible]="showTable" [xHeader]="xHeader"></tolle-chart-table>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: ChartTooltipComponent, selector: "tolle-chart-tooltip", inputs: ["offset", "estimatedWidth", "class"] }, { kind: "component", type: ChartLegendComponent, selector: "tolle-chart-legend", inputs: ["align", "size", "class"] }, { kind: "component", type: ChartTableComponent, selector: "tolle-chart-table", inputs: ["visible", "tableId", "xHeader", "caption", "class"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-chart', standalone: true, imports: [CommonModule, ChartTooltipComponent, ChartLegendComponent, ChartTableComponent], providers: [ChartService], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass">
+      <div class="relative w-full" #plot>
+        <svg
+          role="img"
+          width="100%"
+          [attr.height]="height"
+          [attr.viewBox]="viewBox"
+          [attr.aria-label]="ariaLabel || null"
+          [attr.aria-describedby]="tableId"
+          class="block w-full overflow-visible"
+          (pointerleave)="onPointerLeave()"
+        >
+          <title>{{ ariaLabel }}</title>
+          <desc>{{ description || ariaLabel }}</desc>
+
+          <svg:g>
+            <ng-content></ng-content>
+          </svg:g>
+
+          <svg:line
+            *ngIf="crosshairX !== null"
+            [attr.x1]="crosshairX"
+            [attr.x2]="crosshairX"
+            [attr.y1]="chart.plotTop"
+            [attr.y2]="chart.plotBottom"
+            class="pointer-events-none stroke-border"
+            stroke-width="1"
+          ></svg:line>
+
+          <svg:rect
+            *ngFor="let band of hitBands; let i = index; trackBy: trackByIndex"
+            [attr.x]="band.start"
+            [attr.y]="chart.plotTop"
+            [attr.width]="band.width"
+            [attr.height]="chart.plotHeight"
+            fill="transparent"
+            (pointerenter)="onEnterBand(i)"
+          ></svg:rect>
+        </svg>
+
+        <tolle-chart-tooltip *ngIf="hover"></tolle-chart-tooltip>
+      </div>
+
+      <tolle-chart-legend *ngIf="series.length > 1"></tolle-chart-legend>
+
+      <tolle-chart-table [tableId]="tableId" [visible]="showTable" [xHeader]="xHeader"></tolle-chart-table>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], series: [{
+                type: Input
+            }], xKey: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], stacked: [{
+                type: Input
+            }], hover: [{
+                type: Input
+            }], showTable: [{
+                type: Input
+            }], xHeader: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], density: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], activeIndexChange: [{
+                type: Output
+            }], plotRef: [{
+                type: ViewChild,
+                args: ['plot']
+            }] } });
+/** Horizontal rules at the y ticks, with optional vertical rules at the x positions. */
+export class ChartGridComponent extends ChartChild {
+    /** Also draws a rule at every x position. @default false */
+    vertical = false;
+    /** Extra Tailwind classes merged onto each rule via `cn()` (last-wins). */
+    class = '';
+    get verticalXs() {
+        if (!this.vertical)
+            return [];
+        return this.chart.xLabels.map((_, i) => this.chart.xFor(i));
+    }
+    get lineClass() {
+        // Recessive by design: a grid is a reading aid, never a mark.
+        return cn('stroke-border opacity-60', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartGridComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartGridComponent, isStandalone: true, selector: "svg:g[tolle-chart-grid]", inputs: { vertical: "vertical", class: "class" }, usesInheritance: true, ngImport: i0, template: `
+    <svg:line
+      *ngFor="let tick of chart.ticks; trackBy: trackByIndex"
+      [attr.x1]="chart.plotLeft"
+      [attr.x2]="chart.plotRight"
+      [attr.y1]="tick.y"
+      [attr.y2]="tick.y"
+      [class]="lineClass"
+      stroke-width="1"
+    ></svg:line>
+    <svg:line
+      *ngFor="let x of verticalXs; trackBy: trackByIndex"
+      [attr.x1]="x"
+      [attr.x2]="x"
+      [attr.y1]="chart.plotTop"
+      [attr.y2]="chart.plotBottom"
+      [class]="lineClass"
+      stroke-width="1"
+    ></svg:line>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartGridComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'svg:g[tolle-chart-grid]',
+                    standalone: true,
+                    imports: [CommonModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <svg:line
+      *ngFor="let tick of chart.ticks; trackBy: trackByIndex"
+      [attr.x1]="chart.plotLeft"
+      [attr.x2]="chart.plotRight"
+      [attr.y1]="tick.y"
+      [attr.y2]="tick.y"
+      [class]="lineClass"
+      stroke-width="1"
+    ></svg:line>
+    <svg:line
+      *ngFor="let x of verticalXs; trackBy: trackByIndex"
+      [attr.x1]="x"
+      [attr.x2]="x"
+      [attr.y1]="chart.plotTop"
+      [attr.y2]="chart.plotBottom"
+      [class]="lineClass"
+      stroke-width="1"
+    ></svg:line>
+  `,
+                }]
+        }], propDecorators: { vertical: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** X-axis tick labels, thinned so they never collide. */
+export class ChartXAxisComponent extends ChartChild {
+    /** Approximate px per character, used to decide when labels would collide. @default 7 */
+    charWidth = 7;
+    /** Extra Tailwind classes merged onto each label via `cn()` (last-wins). */
+    class = '';
+    /**
+     * Draw every nth label. Derived from the widest label and the space each one
+     * gets, so a dense axis thins out instead of overprinting itself.
+     */
+    get stride() {
+        const labels = this.chart.xLabels;
+        if (labels.length === 0)
+            return 1;
+        const widest = labels.reduce((max, label) => Math.max(max, label.length), 0);
+        const needed = widest * this.charWidth + 8;
+        const perLabel = this.chart.plotWidth / labels.length;
+        if (perLabel <= 0)
+            return 1;
+        return Math.max(1, Math.ceil(needed / perLabel));
+    }
+    get visibleTicks() {
+        const stride = this.stride;
+        return this.chart.xLabels
+            .map((label, i) => ({ label, x: this.chart.xFor(i), i }))
+            .filter((tick) => tick.i % stride === 0);
+    }
+    get labelY() {
+        return this.chart.plotBottom + 8;
+    }
+    get labelClass() {
+        // Text wears a text token, never the series colour.
+        return cn('fill-muted-foreground text-xs', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartXAxisComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartXAxisComponent, isStandalone: true, selector: "svg:g[tolle-chart-x-axis]", inputs: { charWidth: "charWidth", class: "class" }, usesInheritance: true, ngImport: i0, template: `
+    <svg:text
+      *ngFor="let tick of visibleTicks; trackBy: trackByIndex"
+      [attr.x]="tick.x"
+      [attr.y]="labelY"
+      text-anchor="middle"
+      dominant-baseline="hanging"
+      [class]="labelClass"
+    >{{ tick.label }}</svg:text>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartXAxisComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'svg:g[tolle-chart-x-axis]',
+                    standalone: true,
+                    imports: [CommonModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <svg:text
+      *ngFor="let tick of visibleTicks; trackBy: trackByIndex"
+      [attr.x]="tick.x"
+      [attr.y]="labelY"
+      text-anchor="middle"
+      dominant-baseline="hanging"
+      [class]="labelClass"
+    >{{ tick.label }}</svg:text>
+  `,
+                }]
+        }], propDecorators: { charWidth: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** Y-axis tick labels at the nice tick values. */
+export class ChartYAxisComponent extends ChartChild {
+    /** Gap in px between the labels and the plot edge. @default 8 */
+    offset = 8;
+    /** Extra Tailwind classes merged onto each label via `cn()` (last-wins). */
+    class = '';
+    get labelX() {
+        return this.chart.plotLeft - this.offset;
+    }
+    get labelClass() {
+        return cn('fill-muted-foreground text-xs tabular-nums', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartYAxisComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartYAxisComponent, isStandalone: true, selector: "svg:g[tolle-chart-y-axis]", inputs: { offset: "offset", class: "class" }, usesInheritance: true, ngImport: i0, template: `
+    <svg:text
+      *ngFor="let tick of chart.ticks; trackBy: trackByIndex"
+      [attr.x]="labelX"
+      [attr.y]="tick.y"
+      text-anchor="end"
+      dominant-baseline="middle"
+      [class]="labelClass"
+    >{{ tick.label }}</svg:text>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartYAxisComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'svg:g[tolle-chart-y-axis]',
+                    standalone: true,
+                    imports: [CommonModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <svg:text
+      *ngFor="let tick of chart.ticks; trackBy: trackByIndex"
+      [attr.x]="labelX"
+      [attr.y]="tick.y"
+      text-anchor="end"
+      dominant-baseline="middle"
+      [class]="labelClass"
+    >{{ tick.label }}</svg:text>
+  `,
+                }]
+        }], propDecorators: { offset: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** A line mark for one series, optionally monotone-smoothed and dotted. */
+export class ChartLineComponent extends ChartChild {
+    /** Key of the series to draw. @default '' */
+    seriesKey = '';
+    /** Interpolation between points; smooth is monotone cubic, so it never overshoots. @default 'linear' */
+    curve = 'linear';
+    /** Draws a marker at every point. @default false */
+    showDots = false;
+    /** Marker radius in px; 4 gives the 8px minimum diameter. @default 4 */
+    dotRadius = 4;
+    /** Extra Tailwind classes merged onto the path via `cn()` (last-wins). */
+    class = '';
+    get path() {
+        return this.curve === 'smooth'
+            ? this.chart.smoothPath(this.seriesKey)
+            : this.chart.linePath(this.seriesKey);
+    }
+    get color() {
+        return this.chart.colorFor(this.seriesKey);
+    }
+    get dots() {
+        return this.showDots ? this.chart.pointsFor(this.seriesKey) : [];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartLineComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartLineComponent, isStandalone: true, selector: "svg:g[tolle-chart-line]", inputs: { seriesKey: "seriesKey", curve: "curve", showDots: "showDots", dotRadius: "dotRadius", class: "class" }, usesInheritance: true, ngImport: i0, template: `
+    <svg:path
+      [attr.d]="path"
+      fill="none"
+      [attr.stroke]="color"
+      stroke-width="2"
+      stroke-linejoin="round"
+      stroke-linecap="round"
+      [class]="class"
+    ></svg:path>
+    <svg:circle
+      *ngFor="let point of dots; trackBy: trackByIndex"
+      [attr.cx]="point.x"
+      [attr.cy]="point.y"
+      [attr.r]="dotRadius"
+      [attr.fill]="color"
+      class="stroke-background"
+      stroke-width="2"
+    ></svg:circle>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartLineComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'svg:g[tolle-chart-line]',
+                    standalone: true,
+                    imports: [CommonModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <svg:path
+      [attr.d]="path"
+      fill="none"
+      [attr.stroke]="color"
+      stroke-width="2"
+      stroke-linejoin="round"
+      stroke-linecap="round"
+      [class]="class"
+    ></svg:path>
+    <svg:circle
+      *ngFor="let point of dots; trackBy: trackByIndex"
+      [attr.cx]="point.x"
+      [attr.cy]="point.y"
+      [attr.r]="dotRadius"
+      [attr.fill]="color"
+      class="stroke-background"
+      stroke-width="2"
+    ></svg:circle>
+  `,
+                }]
+        }], propDecorators: { seriesKey: [{
+                type: Input
+            }], curve: [{
+                type: Input
+            }], showDots: [{
+                type: Input
+            }], dotRadius: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** A filled area for one series: a low-opacity wash under a 2px stroke. */
+export class ChartAreaComponent extends ChartChild {
+    /** Key of the series to draw. @default '' */
+    seriesKey = '';
+    /** Interpolation between points. @default 'linear' */
+    curve = 'linear';
+    /** Opacity of the fill — a wash, never a saturated block. @default 0.1 */
+    fillOpacity = 0.1;
+    /** Extra Tailwind classes merged onto the stroke via `cn()` (last-wins). */
+    class = '';
+    /** An area is anchored to a baseline, so zero has to be in the domain. */
+    register() {
+        this.chart.requireZero();
+    }
+    get areaPath() {
+        return this.chart.areaPath(this.seriesKey, this.curve === 'smooth');
+    }
+    get linePath() {
+        return this.curve === 'smooth'
+            ? this.chart.smoothPath(this.seriesKey)
+            : this.chart.linePath(this.seriesKey);
+    }
+    get color() {
+        return this.chart.colorFor(this.seriesKey);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartAreaComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartAreaComponent, isStandalone: true, selector: "svg:g[tolle-chart-area]", inputs: { seriesKey: "seriesKey", curve: "curve", fillOpacity: "fillOpacity", class: "class" }, usesInheritance: true, ngImport: i0, template: `
+    <svg:path
+      [attr.d]="areaPath"
+      [attr.fill]="color"
+      [attr.fill-opacity]="fillOpacity"
+      stroke="none"
+    ></svg:path>
+    <svg:path
+      [attr.d]="linePath"
+      fill="none"
+      [attr.stroke]="color"
+      stroke-width="2"
+      stroke-linejoin="round"
+      stroke-linecap="round"
+      [class]="class"
+    ></svg:path>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartAreaComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'svg:g[tolle-chart-area]',
+                    standalone: true,
+                    imports: [CommonModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <svg:path
+      [attr.d]="areaPath"
+      [attr.fill]="color"
+      [attr.fill-opacity]="fillOpacity"
+      stroke="none"
+    ></svg:path>
+    <svg:path
+      [attr.d]="linePath"
+      fill="none"
+      [attr.stroke]="color"
+      stroke-width="2"
+      stroke-linejoin="round"
+      stroke-linecap="round"
+      [class]="class"
+    ></svg:path>
+  `,
+                }]
+        }], propDecorators: { seriesKey: [{
+                type: Input
+            }], curve: [{
+                type: Input
+            }], fillOpacity: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/**
+ * Builds a bar whose data end is rounded and whose baseline end stays square.
+ * Handles both directions, so a negative value rounds downward.
+ */
+export function barPath(x, width, yBase, yValue, radius) {
+    const height = Math.abs(yBase - yValue);
+    const r = Math.max(0, Math.min(radius, width / 2, height));
+    const right = x + width;
+    // Which way the corner curves depends on which side of the baseline we are.
+    const sign = yValue <= yBase ? 1 : -1;
+    const corner = yValue + sign * r;
+    return ('M ' + x + ' ' + yBase +
+        ' L ' + x + ' ' + corner +
+        ' Q ' + x + ' ' + yValue + ' ' + (x + r) + ' ' + yValue +
+        ' L ' + (right - r) + ' ' + yValue +
+        ' Q ' + right + ' ' + yValue + ' ' + right + ' ' + corner +
+        ' L ' + right + ' ' + yBase + ' Z');
+}
+/**
+ * A bar mark for one series. Grouped beside its siblings by default, stacked
+ * when the container's `stacked` is set. The data end carries a 4px radius, the
+ * baseline end stays square, and neighbours are separated by surface, not ink.
+ */
+export class ChartBarComponent extends ChartChild {
+    /** Key of the series to draw. @default '' */
+    seriesKey = '';
+    /** Corner radius on the data end in px. @default 4 */
+    radius = 4;
+    /** Largest bar thickness in px; a wider band becomes air, not a fatter bar. @default 24 */
+    maxWidth = 24;
+    /** Gap in px between adjacent bars and between stacked segments. @default 2 */
+    gap = 2;
+    /** Extra Tailwind classes merged onto each bar via `cn()` (last-wins). */
+    class = '';
+    /** Index currently hovered, so the bar under the pointer can lift. */
+    activeIndex = null;
+    /** Bars need a band scale and a zero baseline; both belong to the whole chart. */
+    register() {
+        this.chart.useBandScale();
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.subscriptions.add(this.chart.activeIndex$.subscribe((index) => {
+            this.activeIndex = index;
+            this.cdr.markForCheck();
+        }));
+    }
+    get color() {
+        return this.chart.colorFor(this.seriesKey);
+    }
+    /** Geometry for every bar this series contributes. */
+    get bars() {
+        const out = [];
+        const seriesCount = Math.max(1, this.chart.series.length);
+        const found = this.chart.series.findIndex((item) => item.key === this.seriesKey);
+        const slotIndex = found < 0 ? 0 : found;
+        for (let i = 0; i < this.chart.count; i++) {
+            const value = this.chart.valueAt(this.seriesKey, i);
+            if (value == null)
+                continue;
+            const band = this.chart.bandFor(i);
+            let x;
+            let width;
+            if (this.chart.stacked) {
+                width = Math.min(this.maxWidth, band.width);
+                x = band.centre - width / 2;
+            }
+            else {
+                const slot = band.width / seriesCount;
+                width = Math.min(this.maxWidth, Math.max(1, slot - this.gap));
+                x = band.start + slot * slotIndex + (slot - width) / 2;
+            }
+            const base = this.chart.stacked ? this.chart.stackBase(this.seriesKey, i) : 0;
+            const yBase = this.chart.yFor(base);
+            let yValue = this.chart.yFor(base + value);
+            // The gap between stacked segments comes off the data end, so what
+            // separates them is surface showing through rather than a stroke.
+            if (this.chart.stacked && Math.abs(yBase - yValue) > this.gap) {
+                yValue += value >= 0 ? this.gap : -this.gap;
+            }
+            out.push({
+                d: barPath(x, width, yBase, yValue, this.radius),
+                active: this.activeIndex === i,
+                x,
+                width,
+                yBase,
+                yValue,
+            });
+        }
+        return out;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartBarComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartBarComponent, isStandalone: true, selector: "svg:g[tolle-chart-bar]", inputs: { seriesKey: "seriesKey", radius: "radius", maxWidth: "maxWidth", gap: "gap", class: "class" }, usesInheritance: true, ngImport: i0, template: `
+    <svg:path
+      *ngFor="let bar of bars; trackBy: trackByIndex"
+      [attr.d]="bar.d"
+      [attr.fill]="color"
+      [attr.fill-opacity]="bar.active ? 1 : 0.85"
+    ></svg:path>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartBarComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'svg:g[tolle-chart-bar]',
+                    standalone: true,
+                    imports: [CommonModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <svg:path
+      *ngFor="let bar of bars; trackBy: trackByIndex"
+      [attr.d]="bar.d"
+      [attr.fill]="color"
+      [attr.fill-opacity]="bar.active ? 1 : 0.85"
+    ></svg:path>
+  `,
+                }]
+        }], propDecorators: { seriesKey: [{
+                type: Input
+            }], radius: [{
+                type: Input
+            }], maxWidth: [{
+                type: Input
+            }], gap: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/chart.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Directive, Input, Output, EventEmitter, ChangeDetectionStrategy, ChangeDetectorRef, ElementRef, ViewChild, OnInit, OnChanges, OnDestroy, AfterViewInit, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { Subscription } from 'rxjs';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\nimport { ChartService, type ChartSeries, type ChartMargin } from './chart.service';\n\nexport type { ChartSeries, ChartMargin, ChartTick, ChartBand } from './chart.service';\n\nlet chartId = 0;\n\n/**\n * Base for every chart part that has to redraw when the shared scales change.\n * Parts subscribe to the service rather than reading the container component,\n * so an OnPush child still updates when the container's inputs or width change.\n */\n@Directive()\nexport abstract class ChartChild implements OnChanges, OnInit, OnDestroy {\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook subclasses keep\n   * rendering the class they were born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  protected readonly chart = inject(ChartService);\n  protected readonly cdr = inject(ChangeDetectorRef);\n  protected readonly subscriptions = new Subscription();\n\n  /**\n   * Identity for the mark `*ngFor`s. The collections behind them are rebuilt on\n   * every read, so without this `*ngFor` sees new identities each pass and\n   * replaces every node instead of patching it. Marks are positional, so the\n   * index IS the identity.\n   */\n  trackByIndex = (index: number): number => index;\n\n  ngOnInit(): void {\n    this.register();\n    this.subscriptions.add(this.chart.layout$.subscribe(() => this.cdr.markForCheck()));\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  /** Hook for parts that need to influence the shared scales before first paint. */\n  protected register(): void {}\n}\n\n/**\n * The floating readout for the hovered x position. Lists every series at that\n * x, so the pointer never has to land on a particular line to get a value.\n * Rendered automatically by `tolle-chart` when `hover` is on.\n */\n@Component({\n  selector: 'tolle-chart-tooltip',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      *ngIf=\"index !== null\"\n      role=\"status\"\n      aria-live=\"polite\"\n      [class]=\"computedClass\"\n      [style.left.px]=\"left\"\n      [style.top.px]=\"top\"\n    >\n      <p class=\"mb-1 text-xs font-medium text-foreground\">{{ xLabel }}</p>\n      <div *ngFor=\"let row of rows; trackBy: trackByIndex\" class=\"flex items-center gap-2 text-xs\">\n        <span class=\"h-0.5 w-3 shrink-0 rounded-full\" [style.background]=\"row.color\"></span>\n        <span class=\"text-muted-foreground\">{{ row.label }}</span>\n        <span class=\"ml-auto font-medium tabular-nums text-foreground\">{{ row.value }}</span>\n      </div>\n    </div>\n  `,\n})\nexport class ChartTooltipComponent implements OnChanges, OnInit, OnDestroy {\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */\n  trackByIndex = (index: number): number => index;\n\n  /** Distance in px the tooltip sits from the crosshair. @default 12 */\n  @Input() offset = 12;\n  /** Assumed tooltip width in px, used to flip it near the right edge. @default 160 */\n  @Input() estimatedWidth = 160;\n  /** Extra Tailwind classes merged onto the tooltip via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly chart = inject(ChartService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  /** Row index the tooltip is describing, or null when nothing is hovered. */\n  index: number | null = null;\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.chart.activeIndex$.subscribe((index) => {\n        this.index = index;\n        this.cdr.markForCheck();\n      })\n    );\n    this.subscriptions.add(this.chart.layout$.subscribe(() => this.cdr.markForCheck()));\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  get xLabel(): string {\n    return this.index === null ? '' : this.chart.xLabels[this.index] ?? '';\n  }\n\n  /** One row per series: colour key, label, and the formatted value. */\n  get rows(): { label: string; value: string; color: string }[] {\n    const index = this.index;\n    if (index === null) return [];\n    return this.chart.series.map((item) => {\n      const value = this.chart.valueAt(item.key, index);\n      return {\n        label: item.label,\n        value: value == null ? '—' : this.chart.formatValue(value),\n        color: this.chart.colorFor(item.key),\n      };\n    });\n  }\n\n  get left(): number {\n    if (this.index === null) return 0;\n    const x = this.chart.xFor(this.index);\n    // Flip to the left of the crosshair rather than overflow the container.\n    if (x + this.offset + this.estimatedWidth > this.chart.width) {\n      return Math.max(0, x - this.offset - this.estimatedWidth);\n    }\n    return x + this.offset;\n  }\n\n  get top(): number {\n    return this.chart.plotTop;\n  }\n\n  get computedClass() {\n    return cn(\n      'pointer-events-none absolute z-10 min-w-[8rem] rounded-md border border-border bg-popover p-2 text-popover-foreground shadow-md',\n      this.class\n    );\n  }\n}\n\nconst chartLegendVariants = cva('flex flex-wrap items-center gap-x-4 gap-y-1 pt-2', {\n  variants: {\n    align: { start: 'justify-start', center: 'justify-center', end: 'justify-end' },\n    size: { sm: 'text-[11px]', default: 'text-xs' },\n  },\n  defaultVariants: { align: 'center', size: 'default' },\n});\n\nexport type ChartLegendProps = VariantProps<typeof chartLegendVariants>;\n\n/**\n * Swatch and label per series. Rendered automatically by `tolle-chart` whenever\n * there are two or more series, so identity is never carried by colour alone.\n * A single series gets no legend — the chart's own label already names it.\n */\n@Component({\n  selector: 'tolle-chart-legend',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <ul [class]=\"computedClass\">\n      <li *ngFor=\"let entry of entries; trackBy: trackByIndex\" class=\"flex items-center gap-1.5\">\n        <span class=\"h-2 w-2 shrink-0 rounded-[2px]\" [style.background]=\"entry.color\"></span>\n        <span class=\"text-muted-foreground\">{{ entry.label }}</span>\n      </li>\n    </ul>\n  `,\n})\nexport class ChartLegendComponent implements OnChanges, OnInit, OnDestroy {\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */\n  trackByIndex = (index: number): number => index;\n\n  /** Horizontal alignment of the legend row. @default 'center' */\n  @Input() align: ChartLegendProps['align'] = 'center';\n  /** Text size of the legend. @default 'default' */\n  @Input() size: ChartLegendProps['size'] = 'default';\n  /** Extra Tailwind classes merged onto the legend via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly chart = inject(ChartService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  ngOnInit(): void {\n    this.subscriptions.add(this.chart.layout$.subscribe(() => this.cdr.markForCheck()));\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  /** One entry per series, coloured by series identity. */\n  get entries(): { label: string; color: string }[] {\n    return this.chart.series.map((item) => ({\n      label: item.label,\n      color: this.chart.colorFor(item.key),\n    }));\n  }\n\n  get computedClass() {\n    return cn(chartLegendVariants({ align: this.align, size: this.size }), this.class);\n  }\n}\n\nconst chartTableVariants = cva('w-full text-left text-xs', {\n  variants: {\n    visible: {\n      true: 'mt-4 border-collapse',\n      false: 'sr-only',\n    },\n  },\n  defaultVariants: { visible: false },\n});\n\nexport type ChartTableProps = VariantProps<typeof chartTableVariants>;\n\n/**\n * The chart's data as a real `<table>`. Visually hidden by default and pointed\n * at by the svg's `aria-describedby`, so every value the chart encodes in\n * colour stays reachable without seeing or hovering it. Set `visible` to show it.\n */\n@Component({\n  selector: 'tolle-chart-table',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [attr.id]=\"tableId || null\">\n      <table [class]=\"computedClass\">\n        <caption class=\"sr-only\">{{ caption }}</caption>\n        <thead>\n          <tr>\n            <th scope=\"col\" class=\"border-b border-border px-2 py-1 font-medium text-muted-foreground\">\n              {{ xHeader }}\n            </th>\n            <th\n              *ngFor=\"let item of chart.series; trackBy: trackByIndex\"\n              scope=\"col\"\n              class=\"border-b border-border px-2 py-1 font-medium text-muted-foreground\"\n            >\n              {{ item.label }}\n            </th>\n          </tr>\n        </thead>\n        <tbody>\n          <tr *ngFor=\"let row of rows; trackBy: trackByIndex\">\n            <th scope=\"row\" class=\"border-b border-border px-2 py-1 font-normal text-foreground\">\n              {{ row.label }}\n            </th>\n            <td\n              *ngFor=\"let cell of row.cells; trackBy: trackByIndex\"\n              class=\"border-b border-border px-2 py-1 tabular-nums text-foreground\"\n            >\n              {{ cell }}\n            </td>\n          </tr>\n        </tbody>\n      </table>\n    </div>\n  `,\n})\nexport class ChartTableComponent implements OnChanges, OnInit, OnDestroy {\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */\n  trackByIndex = (index: number): number => index;\n\n  /** Shows the table instead of hiding it from sighted readers. @default false */\n  @Input() visible = false;\n  /** Id applied to the wrapper, for the chart's `aria-describedby`. @default '' */\n  @Input() tableId = '';\n  /** Column header for the x category. @default 'Category' */\n  @Input() xHeader = 'Category';\n  /** Accessible caption for the table. @default 'Chart data' */\n  @Input() caption = 'Chart data';\n  /** Extra Tailwind classes merged onto the table via `cn()` (last-wins). */\n  @Input() class = '';\n\n  protected readonly chart = inject(ChartService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  ngOnInit(): void {\n    this.subscriptions.add(this.chart.layout$.subscribe(() => this.cdr.markForCheck()));\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  /** One row per x position, with a formatted cell per series. */\n  get rows(): { label: string; cells: string[] }[] {\n    return this.chart.xLabels.map((label, i) => ({\n      label,\n      cells: this.chart.series.map((item) => {\n        const value = this.chart.valueAt(item.key, i);\n        return value == null ? '—' : this.chart.formatValue(value);\n      }),\n    }));\n  }\n\n  get computedClass() {\n    return cn(chartTableVariants({ visible: this.visible }), this.class);\n  }\n}\n\nconst chartVariants = cva('relative w-full', {\n  variants: {\n    variant: {\n      default: '',\n      card: 'rounded-lg border border-border bg-background p-4',\n    },\n    density: {\n      default: '',\n      compact: 'text-xs',\n    },\n  },\n  defaultVariants: { variant: 'default', density: 'default' },\n});\n\nexport type ChartProps = VariantProps<typeof chartVariants>;\n\n/**\n * Container for a hand-rolled SVG chart. Owns the responsive `<svg>`, the\n * shared scales (via the `ChartService` it provides), the hover layer, the\n * legend and the accessible table fallback.\n *\n * Marks and axes are projected as SVG children. They use attribute selectors on\n * `svg:g` rather than element selectors, because a custom element is created in\n * the HTML namespace and an HTML element inside an `<svg>` never renders its\n * SVG subtree:\n *\n * ```html\n * <tolle-chart [data]=\"rows\" [series]=\"series\" xKey=\"month\" ariaLabel=\"Revenue\">\n *   <svg:g tolle-chart-grid></svg:g>\n *   <svg:g tolle-chart-y-axis></svg:g>\n *   <svg:g tolle-chart-x-axis></svg:g>\n *   <svg:g tolle-chart-line seriesKey=\"revenue\" curve=\"smooth\"></svg:g>\n * </tolle-chart>\n * ```\n *\n * There is deliberately no secondary y-axis: two measures on two scales in one\n * frame let the author choose where the lines cross, so the reader sees a\n * relationship the data does not contain. Use two charts, small multiples, or\n * index both series to a common base instead.\n * @new\n */\n@Component({\n  selector: 'tolle-chart',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule, ChartTooltipComponent, ChartLegendComponent, ChartTableComponent],\n  providers: [ChartService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\">\n      <div class=\"relative w-full\" #plot>\n        <svg\n          role=\"img\"\n          width=\"100%\"\n          [attr.height]=\"height\"\n          [attr.viewBox]=\"viewBox\"\n          [attr.aria-label]=\"ariaLabel || null\"\n          [attr.aria-describedby]=\"tableId\"\n          class=\"block w-full overflow-visible\"\n          (pointerleave)=\"onPointerLeave()\"\n        >\n          <title>{{ ariaLabel }}</title>\n          <desc>{{ description || ariaLabel }}</desc>\n\n          <svg:g>\n            <ng-content></ng-content>\n          </svg:g>\n\n          <svg:line\n            *ngIf=\"crosshairX !== null\"\n            [attr.x1]=\"crosshairX\"\n            [attr.x2]=\"crosshairX\"\n            [attr.y1]=\"chart.plotTop\"\n            [attr.y2]=\"chart.plotBottom\"\n            class=\"pointer-events-none stroke-border\"\n            stroke-width=\"1\"\n          ></svg:line>\n\n          <svg:rect\n            *ngFor=\"let band of hitBands; let i = index; trackBy: trackByIndex\"\n            [attr.x]=\"band.start\"\n            [attr.y]=\"chart.plotTop\"\n            [attr.width]=\"band.width\"\n            [attr.height]=\"chart.plotHeight\"\n            fill=\"transparent\"\n            (pointerenter)=\"onEnterBand(i)\"\n          ></svg:rect>\n        </svg>\n\n        <tolle-chart-tooltip *ngIf=\"hover\"></tolle-chart-tooltip>\n      </div>\n\n      <tolle-chart-legend *ngIf=\"series.length > 1\"></tolle-chart-legend>\n\n      <tolle-chart-table [tableId]=\"tableId\" [visible]=\"showTable\" [xHeader]=\"xHeader\"></tolle-chart-table>\n    </div>\n  `,\n})\nexport class ChartComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {\n  /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */\n  trackByIndex = (index: number): number => index;\n\n  /** Rows to plot, in x order. @default [] */\n  @Input() data: Record<string, any>[] = [];\n  /** Series to draw, in the order they take palette steps `--chart-1`..`--chart-5`. @default [] */\n  @Input() series: ChartSeries[] = [];\n  /** Row key holding each row's x category label. @default '' */\n  @Input() xKey = '';\n  /** Height of the chart in px. @default 260 */\n  @Input() height = 260;\n  /** Space reserved around the plot for axis labels. @default { top: 8, right: 8, bottom: 24, left: 44 } */\n  @Input() margin: ChartMargin = { top: 8, right: 8, bottom: 24, left: 44 };\n  /** Accessible name for the chart, used as the svg `<title>`. @default '' */\n  @Input() ariaLabel = '';\n  /** Longer summary used as the svg `<desc>`. Falls back to `ariaLabel`. @default '' */\n  @Input() description = '';\n  /** Stacks marks on a shared baseline instead of grouping them. @default false */\n  @Input() stacked = false;\n  /** Renders the crosshair, hit layer and shared tooltip. @default true */\n  @Input() hover = true;\n  /** Shows the data table instead of leaving it visually hidden. @default false */\n  @Input() showTable = false;\n  /** Column header the table fallback gives the x category. @default 'Category' */\n  @Input() xHeader = 'Category';\n  /** Visual treatment of the chart frame. @default 'default' */\n  @Input() variant: ChartProps['variant'] = 'default';\n  /** Text density of the chart chrome. @default 'default' */\n  @Input() density: ChartProps['density'] = 'default';\n  /** Extra Tailwind classes merged onto the chart via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the hovered row index, or null when the pointer leaves. */\n  @Output() activeIndexChange = new EventEmitter<number | null>();\n\n  @ViewChild('plot') plotRef?: ElementRef<HTMLElement>;\n\n  protected readonly chart = inject(ChartService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n  private resizeObserver?: ResizeObserver;\n\n  /** Width used until the container has been measured. */\n  static readonly fallbackWidth = 600;\n\n  /** Id of the table fallback, referenced by the svg's `aria-describedby`. */\n  readonly tableId = 'chart-table-' + chartId++;\n\n  /** X of the crosshair, or null when nothing is hovered or the scale is banded. */\n  crosshairX: number | null = null;\n\n  ngOnInit(): void {\n    this.push();\n    this.subscriptions.add(this.chart.layout$.subscribe(() => this.cdr.markForCheck()));\n    this.subscriptions.add(\n      this.chart.activeIndex$.subscribe((index) => {\n        // Bars carry their own hover state; a crosshair belongs to point scales.\n        this.crosshairX =\n          index != null && this.chart.mode === 'point' ? this.chart.xFor(index) : null;\n        this.activeIndexChange.emit(index);\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnChanges(): void {\n    this.push();\n  \n    // A bound `class` input is written through Angular's styling path,\n    // which does not mark an OnPush view dirty on its own.\n    this.cdr.markForCheck();\n  }\n\n  ngAfterViewInit(): void {\n    const host = this.plotRef?.nativeElement;\n    if (!host) return;\n    this.measure(host);\n\n    if (typeof ResizeObserver !== 'undefined') {\n      this.resizeObserver = new ResizeObserver(() => {\n        this.measure(host);\n        this.cdr.markForCheck();\n      });\n      this.resizeObserver.observe(host);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.resizeObserver?.disconnect();\n    this.resizeObserver = undefined;\n    this.subscriptions.unsubscribe();\n  }\n\n  private measure(host: HTMLElement): void {\n    const width = host.clientWidth || ChartComponent.fallbackWidth;\n    if (width === this.chart.width) return;\n    this.chart.configure({ width });\n  }\n\n  private push(): void {\n    this.chart.configure({\n      data: this.data ?? [],\n      series: this.series ?? [],\n      xKey: this.xKey,\n      stacked: this.stacked,\n      height: this.height,\n      margin: this.margin,\n      width: this.chart.width || ChartComponent.fallbackWidth,\n    });\n  }\n\n  get viewBox(): string {\n    return '0 0 ' + (this.chart.width || ChartComponent.fallbackWidth) + ' ' + this.height;\n  }\n\n  /**\n   * One catchment rect per x position, deliberately wider than the marks it\n   * covers — readers aim at a category, never at a 2px line or an 8px dot.\n   */\n  get hitBands() {\n    if (!this.hover) return [];\n    return this.data.map((_, i) => this.chart.hitBandFor(i));\n  }\n\n  onEnterBand(index: number): void {\n    this.chart.setActiveIndex(index);\n  }\n\n  onPointerLeave(): void {\n    this.chart.setActiveIndex(null);\n  }\n\n  get computedClass() {\n    return cn(chartVariants({ variant: this.variant, density: this.density }), this.class);\n  }\n}\n\n/** Horizontal rules at the y ticks, with optional vertical rules at the x positions. */\n@Component({\n  selector: 'svg:g[tolle-chart-grid]',\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <svg:line\n      *ngFor=\"let tick of chart.ticks; trackBy: trackByIndex\"\n      [attr.x1]=\"chart.plotLeft\"\n      [attr.x2]=\"chart.plotRight\"\n      [attr.y1]=\"tick.y\"\n      [attr.y2]=\"tick.y\"\n      [class]=\"lineClass\"\n      stroke-width=\"1\"\n    ></svg:line>\n    <svg:line\n      *ngFor=\"let x of verticalXs; trackBy: trackByIndex\"\n      [attr.x1]=\"x\"\n      [attr.x2]=\"x\"\n      [attr.y1]=\"chart.plotTop\"\n      [attr.y2]=\"chart.plotBottom\"\n      [class]=\"lineClass\"\n      stroke-width=\"1\"\n    ></svg:line>\n  `,\n})\nexport class ChartGridComponent extends ChartChild {\n  /** Also draws a rule at every x position. @default false */\n  @Input() vertical = false;\n  /** Extra Tailwind classes merged onto each rule via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get verticalXs(): number[] {\n    if (!this.vertical) return [];\n    return this.chart.xLabels.map((_, i) => this.chart.xFor(i));\n  }\n\n  get lineClass(): string {\n    // Recessive by design: a grid is a reading aid, never a mark.\n    return cn('stroke-border opacity-60', this.class);\n  }\n}\n\n/** X-axis tick labels, thinned so they never collide. */\n@Component({\n  selector: 'svg:g[tolle-chart-x-axis]',\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <svg:text\n      *ngFor=\"let tick of visibleTicks; trackBy: trackByIndex\"\n      [attr.x]=\"tick.x\"\n      [attr.y]=\"labelY\"\n      text-anchor=\"middle\"\n      dominant-baseline=\"hanging\"\n      [class]=\"labelClass\"\n    >{{ tick.label }}</svg:text>\n  `,\n})\nexport class ChartXAxisComponent extends ChartChild {\n  /** Approximate px per character, used to decide when labels would collide. @default 7 */\n  @Input() charWidth = 7;\n  /** Extra Tailwind classes merged onto each label via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /**\n   * Draw every nth label. Derived from the widest label and the space each one\n   * gets, so a dense axis thins out instead of overprinting itself.\n   */\n  get stride(): number {\n    const labels = this.chart.xLabels;\n    if (labels.length === 0) return 1;\n    const widest = labels.reduce((max, label) => Math.max(max, label.length), 0);\n    const needed = widest * this.charWidth + 8;\n    const perLabel = this.chart.plotWidth / labels.length;\n    if (perLabel <= 0) return 1;\n    return Math.max(1, Math.ceil(needed / perLabel));\n  }\n\n  get visibleTicks(): { x: number; label: string }[] {\n    const stride = this.stride;\n    return this.chart.xLabels\n      .map((label, i) => ({ label, x: this.chart.xFor(i), i }))\n      .filter((tick) => tick.i % stride === 0);\n  }\n\n  get labelY(): number {\n    return this.chart.plotBottom + 8;\n  }\n\n  get labelClass(): string {\n    // Text wears a text token, never the series colour.\n    return cn('fill-muted-foreground text-xs', this.class);\n  }\n}\n\n/** Y-axis tick labels at the nice tick values. */\n@Component({\n  selector: 'svg:g[tolle-chart-y-axis]',\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <svg:text\n      *ngFor=\"let tick of chart.ticks; trackBy: trackByIndex\"\n      [attr.x]=\"labelX\"\n      [attr.y]=\"tick.y\"\n      text-anchor=\"end\"\n      dominant-baseline=\"middle\"\n      [class]=\"labelClass\"\n    >{{ tick.label }}</svg:text>\n  `,\n})\nexport class ChartYAxisComponent extends ChartChild {\n  /** Gap in px between the labels and the plot edge. @default 8 */\n  @Input() offset = 8;\n  /** Extra Tailwind classes merged onto each label via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get labelX(): number {\n    return this.chart.plotLeft - this.offset;\n  }\n\n  get labelClass(): string {\n    return cn('fill-muted-foreground text-xs tabular-nums', this.class);\n  }\n}\n\n/** A line mark for one series, optionally monotone-smoothed and dotted. */\n@Component({\n  selector: 'svg:g[tolle-chart-line]',\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <svg:path\n      [attr.d]=\"path\"\n      fill=\"none\"\n      [attr.stroke]=\"color\"\n      stroke-width=\"2\"\n      stroke-linejoin=\"round\"\n      stroke-linecap=\"round\"\n      [class]=\"class\"\n    ></svg:path>\n    <svg:circle\n      *ngFor=\"let point of dots; trackBy: trackByIndex\"\n      [attr.cx]=\"point.x\"\n      [attr.cy]=\"point.y\"\n      [attr.r]=\"dotRadius\"\n      [attr.fill]=\"color\"\n      class=\"stroke-background\"\n      stroke-width=\"2\"\n    ></svg:circle>\n  `,\n})\nexport class ChartLineComponent extends ChartChild {\n  /** Key of the series to draw. @default '' */\n  @Input() seriesKey = '';\n  /** Interpolation between points; smooth is monotone cubic, so it never overshoots. @default 'linear' */\n  @Input() curve: 'linear' | 'smooth' = 'linear';\n  /** Draws a marker at every point. @default false */\n  @Input() showDots = false;\n  /** Marker radius in px; 4 gives the 8px minimum diameter. @default 4 */\n  @Input() dotRadius = 4;\n  /** Extra Tailwind classes merged onto the path via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get path(): string {\n    return this.curve === 'smooth'\n      ? this.chart.smoothPath(this.seriesKey)\n      : this.chart.linePath(this.seriesKey);\n  }\n\n  get color(): string {\n    return this.chart.colorFor(this.seriesKey);\n  }\n\n  get dots(): { x: number; y: number; index: number }[] {\n    return this.showDots ? this.chart.pointsFor(this.seriesKey) : [];\n  }\n}\n\n/** A filled area for one series: a low-opacity wash under a 2px stroke. */\n@Component({\n  selector: 'svg:g[tolle-chart-area]',\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <svg:path\n      [attr.d]=\"areaPath\"\n      [attr.fill]=\"color\"\n      [attr.fill-opacity]=\"fillOpacity\"\n      stroke=\"none\"\n    ></svg:path>\n    <svg:path\n      [attr.d]=\"linePath\"\n      fill=\"none\"\n      [attr.stroke]=\"color\"\n      stroke-width=\"2\"\n      stroke-linejoin=\"round\"\n      stroke-linecap=\"round\"\n      [class]=\"class\"\n    ></svg:path>\n  `,\n})\nexport class ChartAreaComponent extends ChartChild {\n  /** Key of the series to draw. @default '' */\n  @Input() seriesKey = '';\n  /** Interpolation between points. @default 'linear' */\n  @Input() curve: 'linear' | 'smooth' = 'linear';\n  /** Opacity of the fill — a wash, never a saturated block. @default 0.1 */\n  @Input() fillOpacity = 0.1;\n  /** Extra Tailwind classes merged onto the stroke via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** An area is anchored to a baseline, so zero has to be in the domain. */\n  protected override register(): void {\n    this.chart.requireZero();\n  }\n\n  get areaPath(): string {\n    return this.chart.areaPath(this.seriesKey, this.curve === 'smooth');\n  }\n\n  get linePath(): string {\n    return this.curve === 'smooth'\n      ? this.chart.smoothPath(this.seriesKey)\n      : this.chart.linePath(this.seriesKey);\n  }\n\n  get color(): string {\n    return this.chart.colorFor(this.seriesKey);\n  }\n}\n\n/**\n * Builds a bar whose data end is rounded and whose baseline end stays square.\n * Handles both directions, so a negative value rounds downward.\n */\nexport function barPath(\n  x: number,\n  width: number,\n  yBase: number,\n  yValue: number,\n  radius: number\n): string {\n  const height = Math.abs(yBase - yValue);\n  const r = Math.max(0, Math.min(radius, width / 2, height));\n  const right = x + width;\n  // Which way the corner curves depends on which side of the baseline we are.\n  const sign = yValue <= yBase ? 1 : -1;\n  const corner = yValue + sign * r;\n\n  return (\n    'M ' + x + ' ' + yBase +\n    ' L ' + x + ' ' + corner +\n    ' Q ' + x + ' ' + yValue + ' ' + (x + r) + ' ' + yValue +\n    ' L ' + (right - r) + ' ' + yValue +\n    ' Q ' + right + ' ' + yValue + ' ' + right + ' ' + corner +\n    ' L ' + right + ' ' + yBase + ' Z'\n  );\n}\n\n/**\n * A bar mark for one series. Grouped beside its siblings by default, stacked\n * when the container's `stacked` is set. The data end carries a 4px radius, the\n * baseline end stays square, and neighbours are separated by surface, not ink.\n */\n@Component({\n  selector: 'svg:g[tolle-chart-bar]',\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <svg:path\n      *ngFor=\"let bar of bars; trackBy: trackByIndex\"\n      [attr.d]=\"bar.d\"\n      [attr.fill]=\"color\"\n      [attr.fill-opacity]=\"bar.active ? 1 : 0.85\"\n    ></svg:path>\n  `,\n})\nexport class ChartBarComponent extends ChartChild {\n  /** Key of the series to draw. @default '' */\n  @Input() seriesKey = '';\n  /** Corner radius on the data end in px. @default 4 */\n  @Input() radius = 4;\n  /** Largest bar thickness in px; a wider band becomes air, not a fatter bar. @default 24 */\n  @Input() maxWidth = 24;\n  /** Gap in px between adjacent bars and between stacked segments. @default 2 */\n  @Input() gap = 2;\n  /** Extra Tailwind classes merged onto each bar via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Index currently hovered, so the bar under the pointer can lift. */\n  activeIndex: number | null = null;\n\n  /** Bars need a band scale and a zero baseline; both belong to the whole chart. */\n  protected override register(): void {\n    this.chart.useBandScale();\n  }\n\n  override ngOnInit(): void {\n    super.ngOnInit();\n    this.subscriptions.add(\n      this.chart.activeIndex$.subscribe((index) => {\n        this.activeIndex = index;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  get color(): string {\n    return this.chart.colorFor(this.seriesKey);\n  }\n\n  /** Geometry for every bar this series contributes. */\n  get bars(): {\n    d: string;\n    active: boolean;\n    x: number;\n    width: number;\n    yBase: number;\n    yValue: number;\n  }[] {\n    const out: {\n      d: string;\n      active: boolean;\n      x: number;\n      width: number;\n      yBase: number;\n      yValue: number;\n    }[] = [];\n    const seriesCount = Math.max(1, this.chart.series.length);\n    const found = this.chart.series.findIndex((item) => item.key === this.seriesKey);\n    const slotIndex = found < 0 ? 0 : found;\n\n    for (let i = 0; i < this.chart.count; i++) {\n      const value = this.chart.valueAt(this.seriesKey, i);\n      if (value == null) continue;\n\n      const band = this.chart.bandFor(i);\n      let x: number;\n      let width: number;\n\n      if (this.chart.stacked) {\n        width = Math.min(this.maxWidth, band.width);\n        x = band.centre - width / 2;\n      } else {\n        const slot = band.width / seriesCount;\n        width = Math.min(this.maxWidth, Math.max(1, slot - this.gap));\n        x = band.start + slot * slotIndex + (slot - width) / 2;\n      }\n\n      const base = this.chart.stacked ? this.chart.stackBase(this.seriesKey, i) : 0;\n      const yBase = this.chart.yFor(base);\n      let yValue = this.chart.yFor(base + value);\n\n      // The gap between stacked segments comes off the data end, so what\n      // separates them is surface showing through rather than a stroke.\n      if (this.chart.stacked && Math.abs(yBase - yValue) > this.gap) {\n        yValue += value >= 0 ? this.gap : -this.gap;\n      }\n\n      out.push({\n        d: barPath(x, width, yBase, yValue, this.radius),\n        active: this.activeIndex === i,\n        x,\n        width,\n        yBase,\n        yValue,\n      });\n    }\n    return out;\n  }\n}\n"]}