@tolle_/tolle-ui 18.2.29 → 18.3.0

package/lib/chart.component.d.ts

@@ -0,0 +1,369 @@
+import { EventEmitter, ChangeDetectorRef, ElementRef, OnInit, OnChanges, OnDestroy, AfterViewInit } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { type VariantProps } from 'class-variance-authority';
+import { ChartService, type ChartSeries, type ChartMargin } from './chart.service';
+import * as i0 from "@angular/core";
+export type { ChartSeries, ChartMargin, ChartTick, ChartBand } from './chart.service';
+/**
+ * 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 declare abstract class ChartChild implements OnChanges, OnInit, OnDestroy {
+    /**
+     * 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(): void;
+    protected readonly chart: ChartService;
+    protected readonly cdr: ChangeDetectorRef;
+    protected readonly subscriptions: 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: number) => number;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Hook for parts that need to influence the shared scales before first paint. */
+    protected register(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartChild, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ChartChild, never, never, {}, {}, never, never, false, never>;
+}
+/**
+ * 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 declare class ChartTooltipComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * 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(): void;
+    /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */
+    trackByIndex: (index: number) => number;
+    /** Distance in px the tooltip sits from the crosshair. @default 12 */
+    offset: number;
+    /** Assumed tooltip width in px, used to flip it near the right edge. @default 160 */
+    estimatedWidth: number;
+    /** Extra Tailwind classes merged onto the tooltip via `cn()` (last-wins). */
+    class: string;
+    private readonly chart;
+    private readonly cdr;
+    private readonly subscriptions;
+    /** Row index the tooltip is describing, or null when nothing is hovered. */
+    index: number | null;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get xLabel(): string;
+    /** One row per series: colour key, label, and the formatted value. */
+    get rows(): {
+        label: string;
+        value: string;
+        color: string;
+    }[];
+    get left(): number;
+    get top(): number;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartTooltipComponent, "tolle-chart-tooltip", never, { "offset": { "alias": "offset"; "required": false; }; "estimatedWidth": { "alias": "estimatedWidth"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare const chartLegendVariants: (props?: ({
+    align?: "start" | "end" | "center" | null | undefined;
+    size?: "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ChartLegendProps = VariantProps<typeof chartLegendVariants>;
+/**
+ * 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 declare class ChartLegendComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * 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(): void;
+    /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */
+    trackByIndex: (index: number) => number;
+    /** Horizontal alignment of the legend row. @default 'center' */
+    align: ChartLegendProps['align'];
+    /** Text size of the legend. @default 'default' */
+    size: ChartLegendProps['size'];
+    /** Extra Tailwind classes merged onto the legend via `cn()` (last-wins). */
+    class: string;
+    private readonly chart;
+    private readonly cdr;
+    private readonly subscriptions;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** One entry per series, coloured by series identity. */
+    get entries(): {
+        label: string;
+        color: string;
+    }[];
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartLegendComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartLegendComponent, "tolle-chart-legend", never, { "align": { "alias": "align"; "required": false; }; "size": { "alias": "size"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare const chartTableVariants: (props?: ({
+    visible?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ChartTableProps = VariantProps<typeof chartTableVariants>;
+/**
+ * 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 declare class ChartTableComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * 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(): void;
+    /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */
+    trackByIndex: (index: number) => number;
+    /** Shows the table instead of hiding it from sighted readers. @default false */
+    visible: boolean;
+    /** Id applied to the wrapper, for the chart's `aria-describedby`. @default '' */
+    tableId: string;
+    /** Column header for the x category. @default 'Category' */
+    xHeader: string;
+    /** Accessible caption for the table. @default 'Chart data' */
+    caption: string;
+    /** Extra Tailwind classes merged onto the table via `cn()` (last-wins). */
+    class: string;
+    protected readonly chart: ChartService;
+    private readonly cdr;
+    private readonly subscriptions;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** One row per x position, with a formatted cell per series. */
+    get rows(): {
+        label: string;
+        cells: string[];
+    }[];
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartTableComponent, "tolle-chart-table", never, { "visible": { "alias": "visible"; "required": false; }; "tableId": { "alias": "tableId"; "required": false; }; "xHeader": { "alias": "xHeader"; "required": false; }; "caption": { "alias": "caption"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare const chartVariants: (props?: ({
+    variant?: "default" | "card" | null | undefined;
+    density?: "default" | "compact" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ChartProps = VariantProps<typeof chartVariants>;
+/**
+ * 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 declare class ChartComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {
+    /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */
+    trackByIndex: (index: number) => number;
+    /** Rows to plot, in x order. @default [] */
+    data: Record<string, any>[];
+    /** Series to draw, in the order they take palette steps `--chart-1`..`--chart-5`. @default [] */
+    series: ChartSeries[];
+    /** Row key holding each row's x category label. @default '' */
+    xKey: string;
+    /** Height of the chart in px. @default 260 */
+    height: number;
+    /** Space reserved around the plot for axis labels. @default { top: 8, right: 8, bottom: 24, left: 44 } */
+    margin: ChartMargin;
+    /** Accessible name for the chart, used as the svg `<title>`. @default '' */
+    ariaLabel: string;
+    /** Longer summary used as the svg `<desc>`. Falls back to `ariaLabel`. @default '' */
+    description: string;
+    /** Stacks marks on a shared baseline instead of grouping them. @default false */
+    stacked: boolean;
+    /** Renders the crosshair, hit layer and shared tooltip. @default true */
+    hover: boolean;
+    /** Shows the data table instead of leaving it visually hidden. @default false */
+    showTable: boolean;
+    /** Column header the table fallback gives the x category. @default 'Category' */
+    xHeader: string;
+    /** Visual treatment of the chart frame. @default 'default' */
+    variant: ChartProps['variant'];
+    /** Text density of the chart chrome. @default 'default' */
+    density: ChartProps['density'];
+    /** Extra Tailwind classes merged onto the chart via `cn()` (last-wins). */
+    class: string;
+    /** Emitted with the hovered row index, or null when the pointer leaves. */
+    activeIndexChange: EventEmitter<number | null>;
+    plotRef?: ElementRef<HTMLElement>;
+    protected readonly chart: ChartService;
+    private readonly cdr;
+    private readonly subscriptions;
+    private resizeObserver?;
+    /** Width used until the container has been measured. */
+    static readonly fallbackWidth = 600;
+    /** Id of the table fallback, referenced by the svg's `aria-describedby`. */
+    readonly tableId: string;
+    /** X of the crosshair, or null when nothing is hovered or the scale is banded. */
+    crosshairX: number | null;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private measure;
+    private push;
+    get viewBox(): string;
+    /**
+     * 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(): import("./chart.service").ChartBand[];
+    onEnterBand(index: number): void;
+    onPointerLeave(): void;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartComponent, "tolle-chart", never, { "data": { "alias": "data"; "required": false; }; "series": { "alias": "series"; "required": false; }; "xKey": { "alias": "xKey"; "required": false; }; "height": { "alias": "height"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "description": { "alias": "description"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "hover": { "alias": "hover"; "required": false; }; "showTable": { "alias": "showTable"; "required": false; }; "xHeader": { "alias": "xHeader"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "density": { "alias": "density"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "activeIndexChange": "activeIndexChange"; }, never, ["*"], true, never>;
+}
+/** Horizontal rules at the y ticks, with optional vertical rules at the x positions. */
+export declare class ChartGridComponent extends ChartChild {
+    /** Also draws a rule at every x position. @default false */
+    vertical: boolean;
+    /** Extra Tailwind classes merged onto each rule via `cn()` (last-wins). */
+    class: string;
+    get verticalXs(): number[];
+    get lineClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartGridComponent, "svg:g[tolle-chart-grid]", never, { "vertical": { "alias": "vertical"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** X-axis tick labels, thinned so they never collide. */
+export declare class ChartXAxisComponent extends ChartChild {
+    /** Approximate px per character, used to decide when labels would collide. @default 7 */
+    charWidth: number;
+    /** Extra Tailwind classes merged onto each label via `cn()` (last-wins). */
+    class: string;
+    /**
+     * 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(): number;
+    get visibleTicks(): {
+        x: number;
+        label: string;
+    }[];
+    get labelY(): number;
+    get labelClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartXAxisComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartXAxisComponent, "svg:g[tolle-chart-x-axis]", never, { "charWidth": { "alias": "charWidth"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** Y-axis tick labels at the nice tick values. */
+export declare class ChartYAxisComponent extends ChartChild {
+    /** Gap in px between the labels and the plot edge. @default 8 */
+    offset: number;
+    /** Extra Tailwind classes merged onto each label via `cn()` (last-wins). */
+    class: string;
+    get labelX(): number;
+    get labelClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartYAxisComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartYAxisComponent, "svg:g[tolle-chart-y-axis]", never, { "offset": { "alias": "offset"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** A line mark for one series, optionally monotone-smoothed and dotted. */
+export declare class ChartLineComponent extends ChartChild {
+    /** Key of the series to draw. @default '' */
+    seriesKey: string;
+    /** Interpolation between points; smooth is monotone cubic, so it never overshoots. @default 'linear' */
+    curve: 'linear' | 'smooth';
+    /** Draws a marker at every point. @default false */
+    showDots: boolean;
+    /** Marker radius in px; 4 gives the 8px minimum diameter. @default 4 */
+    dotRadius: number;
+    /** Extra Tailwind classes merged onto the path via `cn()` (last-wins). */
+    class: string;
+    get path(): string;
+    get color(): string;
+    get dots(): {
+        x: number;
+        y: number;
+        index: number;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartLineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartLineComponent, "svg:g[tolle-chart-line]", never, { "seriesKey": { "alias": "seriesKey"; "required": false; }; "curve": { "alias": "curve"; "required": false; }; "showDots": { "alias": "showDots"; "required": false; }; "dotRadius": { "alias": "dotRadius"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** A filled area for one series: a low-opacity wash under a 2px stroke. */
+export declare class ChartAreaComponent extends ChartChild {
+    /** Key of the series to draw. @default '' */
+    seriesKey: string;
+    /** Interpolation between points. @default 'linear' */
+    curve: 'linear' | 'smooth';
+    /** Opacity of the fill — a wash, never a saturated block. @default 0.1 */
+    fillOpacity: number;
+    /** Extra Tailwind classes merged onto the stroke via `cn()` (last-wins). */
+    class: string;
+    /** An area is anchored to a baseline, so zero has to be in the domain. */
+    protected register(): void;
+    get areaPath(): string;
+    get linePath(): string;
+    get color(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartAreaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartAreaComponent, "svg:g[tolle-chart-area]", never, { "seriesKey": { "alias": "seriesKey"; "required": false; }; "curve": { "alias": "curve"; "required": false; }; "fillOpacity": { "alias": "fillOpacity"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Builds a bar whose data end is rounded and whose baseline end stays square.
+ * Handles both directions, so a negative value rounds downward.
+ */
+export declare function barPath(x: number, width: number, yBase: number, yValue: number, radius: number): string;
+/**
+ * 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 declare class ChartBarComponent extends ChartChild {
+    /** Key of the series to draw. @default '' */
+    seriesKey: string;
+    /** Corner radius on the data end in px. @default 4 */
+    radius: number;
+    /** Largest bar thickness in px; a wider band becomes air, not a fatter bar. @default 24 */
+    maxWidth: number;
+    /** Gap in px between adjacent bars and between stacked segments. @default 2 */
+    gap: number;
+    /** Extra Tailwind classes merged onto each bar via `cn()` (last-wins). */
+    class: string;
+    /** Index currently hovered, so the bar under the pointer can lift. */
+    activeIndex: number | null;
+    /** Bars need a band scale and a zero baseline; both belong to the whole chart. */
+    protected register(): void;
+    ngOnInit(): void;
+    get color(): string;
+    /** Geometry for every bar this series contributes. */
+    get bars(): {
+        d: string;
+        active: boolean;
+        x: number;
+        width: number;
+        yBase: number;
+        yValue: number;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartBarComponent, "svg:g[tolle-chart-bar]", never, { "seriesKey": { "alias": "seriesKey"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/chart.service.d.ts

@@ -0,0 +1,222 @@
+import * as i0 from "@angular/core";
+/** One plotted series: which key to read off each row, and how to name it. */
+export interface ChartSeries {
+    key: string;
+    label: string;
+}
+/** Space reserved around the plot area for axes and labels. */
+export interface ChartMargin {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/** A y-axis tick: its data value, its resolved svg y, and its formatted label. */
+export interface ChartTick {
+    value: number;
+    y: number;
+    label: string;
+}
+/** A horizontal slice of the plot belonging to one x position. */
+export interface ChartBand {
+    start: number;
+    centre: number;
+    width: number;
+}
+/** How x positions are resolved: discrete bands (bars) or points (line/area). */
+export type ChartScaleMode = 'point' | 'band';
+/** Number of chart palette steps that exist. A 6th series does not get a colour. */
+export declare 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 declare 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 declare class ChartColorScale {
+    private readonly slots;
+    private next;
+    /** Reserves slots for `keys` in order, leaving already-known keys alone. */
+    register(keys: string[]): void;
+    /** Paint for `key`, registering it on first sight. */
+    colorFor(key: string): string;
+    /** True when `key` fell past the palette and renders neutral. */
+    isOverflow(key: string): boolean;
+    /** Slot index assigned to `key`, or undefined when it is unknown. */
+    slotOf(key: string): number | undefined;
+}
+/**
+ * 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 declare class ChartService {
+    /** Rows being plotted, in x order. */
+    data: Record<string, any>[];
+    /** Series definitions, in the order they should take palette steps. */
+    series: ChartSeries[];
+    /** Row key holding the x category/label. */
+    xKey: string;
+    /** Whether marks stack on a shared baseline rather than sitting side by side. */
+    stacked: boolean;
+    /** Full svg width in px, tracked from the container's ResizeObserver. */
+    width: number;
+    /** Full svg height in px. */
+    height: number;
+    /** Space reserved around the plot area. */
+    margin: ChartMargin;
+    /** Fraction of a band's step spent on padding, split either side. */
+    bandPadding: number;
+    private scaleMode;
+    private zeroRequired;
+    private domainMin;
+    private domainMax;
+    private tickValues;
+    private tickStep;
+    /** Palette assignment, keyed by series identity. */
+    private readonly colors;
+    private readonly layoutSubject;
+    /** Emits a version number whenever scales, dimensions or data change. */
+    readonly layout$: import("rxjs").Observable<number>;
+    private readonly activeIndexSubject;
+    /** Index of the x position under the pointer, or null when not hovering. */
+    readonly activeIndex$: import("rxjs").Observable<number | null>;
+    private layoutVersion;
+    private emitScheduled;
+    get plotLeft(): number;
+    get plotTop(): number;
+    get plotWidth(): number;
+    get plotHeight(): number;
+    get plotRight(): number;
+    get plotBottom(): number;
+    /** Number of x positions. */
+    get count(): number;
+    /** How x is currently resolved. Bars flip this to 'band'. */
+    get mode(): ChartScaleMode;
+    /** Resolved y ticks, with svg coordinates and formatted labels. */
+    get ticks(): ChartTick[];
+    /** Current y domain as [min, max]. */
+    get domain(): [number, number];
+    /** The x-axis category labels, one per row. */
+    get xLabels(): string[];
+    /**
+     * Replaces the chart's configuration and recomputes the scales.
+     * Called by the container on input changes and on resize.
+     */
+    configure(config: Partial<Pick<ChartService, 'data' | 'series' | 'xKey' | 'stacked' | 'width' | 'height' | 'margin' | 'bandPadding'>>): void;
+    /** Switches x to a band scale. Bars call this; it also forces zero into the domain. */
+    useBandScale(): void;
+    /** Forces zero into the y domain, for marks anchored to a baseline. */
+    requireZero(): void;
+    /** Reserves palette slots in series order, leaving known keys untouched. */
+    private syncColorSlots;
+    /**
+     * 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: string): string;
+    /** True when this series fell past the palette and renders neutral. */
+    isOverflowSeries(seriesKey: string): boolean;
+    /** Reads a series value off a row, or null when it is missing/non-numeric. */
+    valueAt(seriesKey: string, index: number): number | null;
+    /** Sum of every series below `seriesKey` at `index`, for stacked marks. */
+    stackBase(seriesKey: string, index: number): number;
+    /** Sum of every series at `index`. */
+    stackTotal(index: number): number;
+    /**
+     * 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: number): number;
+    /** The svg y of the zero line, clamped into the plot. */
+    get baselineY(): number;
+    /** Width of one band, excluding its padding. Meaningful in band mode. */
+    get bandWidth(): number;
+    /** Distance between adjacent band starts. Bands tile the plot exactly. */
+    get bandStep(): number;
+    /** Geometry of the band at `index`. */
+    bandFor(index: number): ChartBand;
+    /** x of the data point at `index` on the point scale. */
+    pointX(index: number): number;
+    /** x of `index` under whichever scale the chart is currently using. */
+    xFor(index: number): number;
+    /**
+     * 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: number): ChartBand;
+    /** Index currently under the pointer, or null. */
+    get activeIndex(): number | null;
+    setActiveIndex(index: number | null): void;
+    private recompute;
+    /** Everything a subscriber would render differently, flattened for comparison. */
+    private lastSignature;
+    private layoutSignature;
+    /**
+     * 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.
+     */
+    private scheduleEmit;
+    /** Formats a value for a tick label at the current tick step's precision. */
+    formatValue(value: number): string;
+    /** Straight-segment path through the series' defined points. */
+    linePath(seriesKey: string): string;
+    /** Monotone-cubic path through the series' defined points. */
+    smoothPath(seriesKey: string): string;
+    /**
+     * 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: string, smooth: boolean): string;
+    /** Resolved svg points for a series, skipping rows where it has no value. */
+    pointsFor(seriesKey: string): {
+        x: number;
+        y: number;
+        index: number;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChartService>;
+}
+/** Decimal places worth showing for a given tick step. */
+export declare function decimalsFor(step: number): number;
+/**
+ * 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 declare function niceStep(rawStep: number): number;
+/**
+ * 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 declare function niceScale(values: number[], targetTicks?: number): [number, number, number, number[]];
+/**
+ * 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 declare function monotoneTangents(xs: number[], ys: number[]): number[];
+/** Turns resolved points into an svg path, optionally monotone-smoothed. */
+export declare function buildPath(points: {
+    x: number;
+    y: number;
+}[], smooth: boolean): string;

package/lib/checkpoint.component.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter, OnChanges } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+declare const checkpointPillVariants: (props?: ({
+    active?: boolean | null | undefined;
+    size?: "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type CheckpointProps = VariantProps<typeof checkpointPillVariants>;
+/**
+ * A labelled marker in a conversation that the user can rewind to. Renders as a
+ * horizontal rule with a centred, clickable pill.
+ *
+ * ```html
+ * <tolle-checkpoint label="Before refactor" timestamp="14:02" (restore)="rewind()"></tolle-checkpoint>
+ * ```
+ * @new
+ */
+export declare class CheckpointComponent implements OnChanges {
+    private readonly cdr;
+    /**
+     * 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(): void;
+    /** Name of the checkpoint shown in the pill. @default 'Checkpoint' */
+    label: string;
+    /** Pre-formatted time shown after the label. @default '' */
+    timestamp: string;
+    /** Highlights this checkpoint as the one currently restored to. @default false */
+    active: boolean;
+    /** Prevents the pill from being activated. @default false */
+    disabled: boolean;
+    /** Verb used to build the pill's accessible name. @default 'Restore checkpoint' */
+    restoreLabel: string;
+    /** Overrides the pill's accessible name entirely. @default '' */
+    ariaLabel: string;
+    /** Remixicon class shown before the label. @default 'ri-history-line' */
+    icon: string;
+    /** Size of the pill. @default 'default' */
+    size: CheckpointProps['size'];
+    /** Extra Tailwind classes merged onto the row via `cn()` (last-wins). */
+    class: string;
+    /** Emitted when the user asks to restore this checkpoint. */
+    restore: EventEmitter<void>;
+    get computedClass(): string;
+    get pillClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckpointComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckpointComponent, "tolle-checkpoint", never, { "label": { "alias": "label"; "required": false; }; "timestamp": { "alias": "timestamp"; "required": false; }; "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "restoreLabel": { "alias": "restoreLabel"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "size": { "alias": "size"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "restore": "restore"; }, never, ["*"], true, never>;
+}
+export {};