@c2n/chart 0.0.7

package/types/src/chart-base.d.ts

@@ -0,0 +1,265 @@
+import { LitElement, type CSSResultGroup, type PropertyValues, type TemplateResult } from 'lit';
+import type { TypedAddEventListener, TypedRemoveEventListener } from '@c2n/core/event-helper.js';
+import { ChartFrameBuilder, type NormalizeContext } from './chart-data.js';
+import { ChartThemeController, type ChartTheme } from './chart-theme.js';
+import type { ChartAdapter, ChartBuildContext } from './chart-adapter.js';
+import { type ChartSeries } from './chart-series.js';
+import type { ChartDataSource, ChartFrame, ChartInput, ChartPointEventDetail, ChartRangeEventDetail, ChartSeriesConfig, ChartSeriesToggleEventDetail, ChartTooltipContext } from './chart-types.js';
+/** One row of the legend. `series` and `index` are what a custom `renderLegendItem` is handed. */
+export interface ChartLegendItem {
+    label: string;
+    color: string;
+    visible: boolean;
+    toggle: () => void;
+    series: ChartSeriesConfig;
+    index: number;
+}
+/** Events fired by every chart, keyed for `addEventListener`. */
+export interface ChartEventMap {
+    'chart-ready': CustomEvent<{
+        engine: 'uplot' | 'echarts';
+    }>;
+    'chart-error': CustomEvent<{
+        error: unknown;
+    }>;
+    'point-click': CustomEvent<ChartPointEventDetail>;
+    'point-hover': CustomEvent<ChartPointEventDetail | null>;
+    'range-change': CustomEvent<ChartRangeEventDetail>;
+    'series-toggle': CustomEvent<ChartSeriesToggleEventDetail>;
+}
+export interface ChartBase {
+    addEventListener: TypedAddEventListener<ChartBase, ChartEventMap>;
+    removeEventListener: TypedRemoveEventListener<ChartBase, ChartEventMap>;
+}
+/**
+ * Shared behaviour of every `c2-*-chart`: the chrome and its slots, the resize observer, theme
+ * resolution, data normalisation, and the routing that keeps a realtime update off the expensive path.
+ * It defines no tag and is never registered — the concrete charts extend it.
+ *
+ * **Why the data and presentation inputs are separate.** `data` and `revision` are the only properties on
+ * the data path; everything else is presentation. A change limited to the data path is pushed straight
+ * into the engine from `shouldUpdate`, which returns `false`, so Lit never renders or commits and the
+ * canvas container is not touched. Anything else rebuilds the engine options, which is allowed to be
+ * expensive. That is what makes a streaming tick cost one engine redraw and nothing more.
+ *
+ * **Sizing.** A canvas has no intrinsic size, so the host is sized by `--c2-chart--height` (320px by
+ * default) rather than by its content. Give the host a height — through the variable, a CSS rule, or a
+ * flex parent — or the plot area collapses.
+ *
+ * @slot default - The series definitions: `c2-chart-series` elements. They render nothing themselves.
+ * @slot legend - Replaces the built-in legend. The built-in one is still what `legend` positions.
+ * @slot tooltip - Replaces the built-in tooltip body. The hovered point is available through the `renderTooltip` property when a function is easier than markup.
+ * @slot actions - Controls pinned to the top-right of the plot area, for a range picker or an export button.
+ * @slot empty - Replaces the built-in "no data" message.
+ * @slot loading - Replaces the built-in message shown while `loading` is set.
+ * @slot error - Replaces the built-in message shown when `error` is set.
+ *
+ * @slotcomponent c2-chart-series
+ *
+ * @event {CustomEvent<{ engine: string }>} chart-ready - Fired after the engine has loaded and drawn for the first time. The host also gains `data-chart-ready`, which is what a test should wait on.
+ * @event {CustomEvent<{ error: unknown }>} chart-error - Fired when the engine fails to load or to draw. `detail.error` is the underlying failure.
+ * @event {CustomEvent<ChartPointEventDetail>} point-click - Fired when a datum is clicked. Does not bubble: several components fire point events, so a listener belongs on the element itself.
+ * @event {CustomEvent<ChartPointEventDetail>} point-hover - Fired as the pointer moves between data points, and with a `null` detail when it leaves the plot. Does not bubble.
+ * @event {CustomEvent<ChartRangeEventDetail>} range-change - Fired after the user zooms or brushes. `detail.min` and `detail.max` are the new x bounds. Does not bubble.
+ * @event {CustomEvent<ChartSeriesToggleEventDetail>} series-toggle - Fired when a legend entry is toggled. Does not bubble.
+ *
+ * @csspart frame - The outer flex column holding the legend and the plot area.
+ * @csspart plot-area - The positioned box the engine draws into.
+ * @csspart plot - The engine's container element. Carries no Lit bindings, so the canvas survives every update.
+ * @csspart overlay - The non-interactive layer above the canvas that holds the tooltip and the actions.
+ * @csspart tooltip - The tooltip bubble.
+ * @csspart actions - The container for the `actions` slot.
+ * @csspart state - The empty, loading or error message layer.
+ * @csspart legend - The legend container.
+ * @csspart legend-item - One legend entry, a toggle button.
+ * @csspart legend-marker - The colour swatch inside a legend entry.
+ *
+ * @cssproperty {length} [--c2-chart--width=100%] - Width of the host. The plot is absolutely positioned and has no intrinsic width, so a chart used as a flex item would otherwise collapse to its legend.
+ * @cssproperty {pixel} [--c2-chart--height=320px] - Height of the host. A canvas has no intrinsic size, so this is what gives the chart a box.
+ * @cssproperty {color} [--c2-chart--background=#ffffff] - Background of the chart surface.
+ * @cssproperty {color} [--c2-chart--color=#18181b] - Primary text colour.
+ * @cssproperty {font-family} [--c2-chart--font-family=inherit] - Font family used for the chart chrome and the labels the engine draws.
+ * @cssproperty {font-size} [--c2-chart--font-size=12px] - Base font size.
+ * @cssproperty {padding} [--c2-chart--padding=12px] - Padding around the whole chart.
+ *
+ * @cssproperty {border} [--c2-chart--border-top=1px solid #e4e4e7] - Top border.
+ * @cssproperty {border} [--c2-chart--border-right=1px solid #e4e4e7] - Right border.
+ * @cssproperty {border} [--c2-chart--border-bottom=1px solid #e4e4e7] - Bottom border.
+ * @cssproperty {border} [--c2-chart--border-left=1px solid #e4e4e7] - Left border.
+ * @cssproperty {border-radius} [--c2-chart--border-top-left-radius=8px] - Top-left corner radius.
+ * @cssproperty {border-radius} [--c2-chart--border-top-right-radius=8px] - Top-right corner radius.
+ * @cssproperty {border-radius} [--c2-chart--border-bottom-left-radius=8px] - Bottom-left corner radius.
+ * @cssproperty {border-radius} [--c2-chart--border-bottom-right-radius=8px] - Bottom-right corner radius.
+ *
+ * @cssproperty {color} [--c2-chart__series-1--color=#0265dc] - Colour of the first series.
+ * @cssproperty {color} [--c2-chart__series-2--color=#ea580c] - Colour of the second series.
+ * @cssproperty {color} [--c2-chart__series-3--color=#0f766e] - Colour of the third series.
+ * @cssproperty {color} [--c2-chart__series-4--color=#db2777] - Colour of the fourth series.
+ * @cssproperty {color} [--c2-chart__series-5--color=#a16207] - Colour of the fifth series.
+ * @cssproperty {color} [--c2-chart__series-6--color=#7c3aed] - Colour of the sixth series.
+ * @cssproperty {color} [--c2-chart__series-7--color=#0891b2] - Colour of the seventh series.
+ * @cssproperty {color} [--c2-chart__series-8--color=#52525b] - Colour of the eighth series. Series beyond the eighth reuse the palette from the start.
+ *
+ * @cssproperty {pixel} [--c2-chart__line--width=2px] - Stroke width of a line series.
+ * @cssproperty {pixel} [--c2-chart__point--radius=2.5px] - Radius of a data point marker.
+ * @cssproperty {opacity} [--c2-chart__area--opacity=0.15] - Opacity of the fill under an area series.
+ *
+ * @cssproperty {color} [--c2-chart__axis--color=#71717a] - Colour of the axis lines and tick labels.
+ * @cssproperty {font-size} [--c2-chart__axis--font-size=12px] - Font size of the tick labels.
+ * @cssproperty {color} [--c2-chart__grid--color=#e4e4e7] - Colour of the grid lines.
+ * @cssproperty {pixel} [--c2-chart__grid--width=1px] - Width of the grid lines.
+ * @cssproperty {color} [--c2-chart__crosshair--color=#a1a1aa] - Colour of the cursor crosshair.
+ * @cssproperty {pixel} [--c2-chart__crosshair--width=1px] - Width of the cursor crosshair.
+ *
+ * @cssproperty {color} [--c2-chart__surface--color=#ffffff] - Surface colour handed to the engine, for marker borders and label backdrops.
+ * @cssproperty {color} [--c2-chart__muted--color=#71717a] - Secondary text colour.
+ * @cssproperty {color} [--c2-chart__positive--color=#16a34a] - Colour for a rising value, used by the candlestick and gauge charts.
+ * @cssproperty {color} [--c2-chart__negative--color=#dc2626] - Colour for a falling value, used by the candlestick and gauge charts.
+ *
+ * @cssproperty {pixel} [--c2-chart__legend--gap=12px] - Gap between legend entries.
+ * @cssproperty {padding} [--c2-chart__legend--padding=8px 0 0] - Padding around the legend.
+ * @cssproperty {color} [--c2-chart__legend--color=#71717a] - Legend text colour.
+ * @cssproperty {font-size} [--c2-chart__legend--font-size=12px] - Legend font size.
+ * @cssproperty {opacity} [--c2-chart__legend__disabled--opacity=0.38] - Opacity of a legend entry whose series is hidden.
+ * @cssproperty {pixel} [--c2-chart__legend-marker--size=10px] - Size of the legend colour swatch.
+ * @cssproperty {border-radius} [--c2-chart__legend-marker--border-radius=999px] - Corner radius of the legend colour swatch.
+ *
+ * @cssproperty {color} [--c2-chart__tooltip--background-color=#18181b] - Tooltip background.
+ * @cssproperty {color} [--c2-chart__tooltip--color=#fafafa] - Tooltip text colour.
+ * @cssproperty {font-size} [--c2-chart__tooltip--font-size=12px] - Tooltip font size.
+ * @cssproperty {padding} [--c2-chart__tooltip--padding=8px 10px] - Tooltip padding.
+ * @cssproperty {border-radius} [--c2-chart__tooltip--border-radius=6px] - Tooltip corner radius.
+ * @cssproperty {box-shadow} [--c2-chart__tooltip--box-shadow=0 8px 24px rgba(24, 24, 27, 0.08)] - Tooltip shadow.
+ * @cssproperty {pixel} [--c2-chart__tooltip--gap=6px] - Gap between tooltip rows.
+ *
+ * @cssproperty {color} [--c2-chart__state--color=#71717a] - Colour of the empty, loading and error text.
+ * @cssproperty {font-size} [--c2-chart__state--font-size=14px] - Font size of the empty, loading and error text.
+ */
+export declare abstract class ChartBase extends LitElement {
+    #private;
+    static styles: CSSResultGroup;
+    protected plotElement: HTMLElement | null;
+    private tooltipElement;
+    /**
+     * The data to plot. Row objects, a bare `number[]`, columnar `[xs, ys…]`, or an already-normalised
+     * frame. Compared by identity: replace the array, or bump `revision` after mutating it in place.
+     */
+    data?: ChartInput;
+    /** Bump after mutating `data` in place. The cheap escape hatch for a large buffer you own. */
+    revision: number;
+    /** Lazy or streaming source used instead of `data`. Property only. */
+    dataSource?: ChartDataSource;
+    /** Series definitions, as an alternative to `c2-chart-series` children. Children win when both are set. */
+    series?: ChartSeriesConfig[];
+    /** Row field holding the x value; may be a dotted path. Defaults to the row index. */
+    xField: string;
+    /** Row field holding the category label, for charts that name their slices. */
+    labelField: string;
+    /** How x values are interpreted, which decides the axis and the tooltip format. */
+    xType: 'time' | 'linear' | 'category';
+    /**
+     * Where the legend sits, or `none` to hide it. Shown by default: a chart with more than one series is
+     * unreadable without one, and a single-series chart simply renders a one-entry legend.
+     */
+    legend: 'none' | 'top' | 'bottom' | 'start' | 'end';
+    /** Whether the tooltip follows the whole x position or only the hovered datum. */
+    tooltip: 'none' | 'item' | 'axis';
+    /**
+     * Whether the engine animates entry and updates. `none` by default: a chart fed by a live source should
+     * not animate every tick. Named `animation` rather than `animate` because `HTMLElement.animate()` is a
+     * method every element already has, and shadowing it breaks the Web Animations API on the host.
+     */
+    animation: 'none' | 'auto';
+    /** BCP 47 locale for the axis and tooltip formatting. Defaults to the browser locale. */
+    locale?: string;
+    /** Shows the loading state instead of the plot. */
+    loading: boolean;
+    /** Shows an error message instead of the plot. */
+    error: string;
+    /** Replaces the built-in "no data" text. */
+    emptyMessage: string;
+    /** Caps how many points a streaming chart keeps; older points fall off the front. `0` keeps everything. */
+    maxPoints: number;
+    /** Defers loading the engine until the host first scrolls into view. */
+    lazyRender: boolean;
+    /** Renders the tooltip body from a function instead of the `tooltip` slot. Property only. */
+    renderTooltip?: (context: ChartTooltipContext) => unknown;
+    /** Renders one legend entry from a function instead of the `legend` slot. Property only. */
+    renderLegendItem?: (series: ChartSeriesConfig, index: number) => unknown;
+    protected seriesElements: ChartSeries[];
+    protected hiddenSeries: Set<number>;
+    protected hoverContext: ChartTooltipContext | null;
+    private engineFailed;
+    protected themeController: ChartThemeController;
+    protected frameBuilder: ChartFrameBuilder;
+    protected frame?: ChartFrame;
+    protected adapter?: ChartAdapter;
+    /** Which engine this chart draws with. */
+    protected abstract readonly engineName: 'uplot' | 'echarts';
+    /** Loads the engine and returns a fresh adapter. */
+    protected abstract createAdapter(): Promise<ChartAdapter>;
+    /** Builds the engine options from the theme and the resolved series. Never sees raw data. */
+    protected abstract buildOptions(context: ChartBuildContext): unknown;
+    /** Projects the normalised frame into the shape this engine consumes. */
+    protected abstract projectData(frame: ChartFrame, context: ChartBuildContext): unknown;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * The fast path. A change confined to `data`/`revision` on a live chart is pushed into the engine here
+     * and `false` is returned, so Lit skips render and commit entirely and the canvas is never touched.
+     */
+    protected shouldUpdate(changed: PropertyValues): boolean;
+    protected willUpdate(changed: PropertyValues): void;
+    protected updated(changed: PropertyValues): void;
+    /**
+     * Replaces the data without going through the update queue. Equivalent to assigning `data`, but skips
+     * Lit's scheduling — worth it in a tight loop.
+     */
+    updateData(next: ChartInput): void;
+    /**
+     * Appends one point across every series at a shared x. The frame grows in place, so nothing is
+     * re-normalised and no Lit update is scheduled: a 10 Hz feed costs one engine redraw per tick.
+     */
+    appendPoint(x: number, values: readonly (number | null)[]): void;
+    /** Shows or hides one series, as the legend does. */
+    setSeriesVisible(index: number, visible: boolean): void;
+    /** The series in draw order: `c2-chart-series` children when present, otherwise the `series` property. */
+    get resolvedSeries(): ChartSeriesConfig[];
+    /**
+     * The series to draw when nothing was declared: every numeric field of the first row except the ones
+     * already spoken for by `x-field` and `label-field`.
+     *
+     * This reads `data` rather than the normalised frame on purpose. Deriving it from the frame would be
+     * circular — the frame is built *from* the series list — and naming the results positionally would be
+     * worse than circular: the next normalisation would look up a field that does not exist in the rows and
+     * quietly read every value as a gap.
+     */
+    protected inferredSeries(): ChartSeriesConfig[];
+    /** The colour a series draws with: its own `color`, else its palette slot. */
+    protected colorOf(series: ChartSeriesConfig, index: number, theme?: ChartTheme): string;
+    protected normalizeContext(): NormalizeContext;
+    protected buildContext(): ChartBuildContext;
+    private handleThemeChange;
+    /** Formats an x value for the tooltip. Time charts get a date, everything else a number. */
+    protected formatX(value: number): string;
+    /**
+     * How much time the chart currently covers, in milliseconds, or `0` when that is not a meaningful question.
+     * Axis labels are chosen from it: a day of five-minute samples and a year of daily ones want different ticks.
+     */
+    protected xSpan(): number;
+    /** Formats a y value for the tooltip and the built-in labels. */
+    protected formatValue(value: number): string;
+    protected render(): TemplateResult;
+    /** Named slot, then the renderer property, then the built-in rows — the library's three-layer fallback. */
+    private renderTooltipBody;
+    private defaultTooltip;
+    private renderState;
+    /**
+     * What the legend lists. One entry per series for every cartesian chart — but a chart whose data is one
+     * dimensional overrides this: a pie has a single series and many slices, and listing "Revenue" above a
+     * four-slice donut tells the reader nothing.
+     */
+    protected legendItems(): ChartLegendItem[];
+    private renderLegend;
+}
+//# sourceMappingURL=chart-base.d.ts.map

package/types/src/chart-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-base.d.ts","sourceRoot":"","sources":["../../src/chart-base.ts"],"names":[],"mappings":"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"}

package/types/src/chart-data.d.ts

@@ -0,0 +1,43 @@
+import { type ChartColumn, type ChartFrame, type ChartInput, type ChartSeriesConfig } from './chart-types.js';
+/** What the builder needs to read rows; all of it derived from the element's presentation properties. */
+export interface NormalizeContext {
+    /** Row field holding the x value. Empty means "use the row index". */
+    xField: string;
+    /** Row field holding the category label, for categorical charts. */
+    labelField: string;
+    /** The series, in draw order; only their `field` is read here. */
+    series: ChartSeriesConfig[];
+    /** Changing this forces a re-read of the same input array. */
+    signature: string;
+}
+/** Reads one value out of a column, normalising the two representations to `number | null`. */
+export declare function columnValue(column: ChartColumn, index: number): number | null;
+/**
+ * Builds and caches the normalised form of whatever a consumer assigned, and owns the projections each
+ * engine consumes. One instance per chart element.
+ */
+export declare class ChartFrameBuilder {
+    #private;
+    /**
+     * Normalises `input` into a {@link ChartFrame}. Returns the *same* frame for the same input reference
+     * and signature, so this is safe to call on every update.
+     */
+    build(input: ChartInput | undefined, context: NormalizeContext): ChartFrame | undefined;
+    /**
+     * Appends one x and one value per series in place. Grows geometrically, and drops the oldest points once
+     * `maxPoints` is reached, so a streaming chart holds a bounded ring rather than an unbounded array.
+     */
+    push(frame: ChartFrame, x: number, values: readonly (number | null)[], maxPoints: number): void;
+    /**
+     * uPlot's view: `[xs, ys…]` sliced to `length`. A typed column becomes a `subarray`, which is a view
+     * over the same buffer and costs nothing.
+     */
+    uplotView(frame: ChartFrame): unknown[];
+    /**
+     * ECharts' view, one array per series. `pairs` is `[[x, y], …]` for the cartesian charts, `named` is
+     * `[{ name, value }, …]` for the ones whose marks are labelled rather than positioned (pie, gauge), and
+     * `values` is a bare value list.
+     */
+    echartsView(frame: ChartFrame, shape: 'pairs' | 'values' | 'named'): unknown[];
+}
+//# sourceMappingURL=chart-data.d.ts.map

package/types/src/chart-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-data.d.ts","sourceRoot":"","sources":["../../src/chart-data.ts"],"names":[],"mappings":"AAaA,OAAO,EAAgB,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAiB,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAE1I,yGAAyG;AACzG,MAAM,WAAW,gBAAgB;IAC/B,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAA;IACd,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAA;IAClB,kEAAkE;IAClE,MAAM,EAAE,iBAAiB,EAAE,CAAA;IAC3B,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAA;CAClB;AA+CD,+FAA+F;AAC/F,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG7E;AAqBD;;;GAGG;AACH,qBAAa,iBAAiB;;IAQ5B;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,EAAE,OAAO,EAAE,gBAAgB,GAAG,UAAU,GAAG,SAAS;IAgFvF;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAiC/F;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,EAAE;IAQvC;;;;OAIG;IACH,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,EAAE;CAsB/E"}

package/types/src/chart-series.d.ts

@@ -0,0 +1,51 @@
+import { LitElement, type PropertyValues } from 'lit';
+import type { ChartSeriesConfig } from './chart-types.js';
+/** Fired at the parent chart whenever a series definition changes. */
+export declare const SERIES_CHANGE_EVENT = "c2-chart-series-change";
+/** The tag, so a chart can match a definition by name rather than by class identity. */
+export declare const SERIES_TAG = "c2-chart-series";
+/**
+ * One series of a chart, declared as a light-DOM child. The element renders nothing: it is a definition
+ * the chart reads, the same way `c2-table` reads its `c2-table-column` children. Everything it exposes as
+ * an attribute can also be set as a property, and `format` is property-only.
+ *
+ * ```html
+ * <c2-line-chart x-field="month" data='[{ "month": 1, "revenue": 120, "cost": 80 }]'>
+ *   <c2-chart-series field="revenue" label="Revenue"></c2-chart-series>
+ *   <c2-chart-series field="cost" label="Cost" color="#ea580c"></c2-chart-series>
+ * </c2-line-chart>
+ * ```
+ *
+ * @tag c2-chart-series
+ */
+export declare class ChartSeries extends LitElement implements ChartSeriesConfig {
+    #private;
+    static styles: import("lit").CSSResult;
+    /** Key of the value in the row object; may be a dotted path such as `stats.cpu`. */
+    field: string;
+    /** Legend and tooltip label. Falls back to the field name. */
+    label?: string;
+    /** Explicit colour. Falls back to this series' slot in the chart's palette. */
+    color?: string;
+    /** Stroke width in pixels. Falls back to `--c2-chart__line--width`. */
+    lineWidth?: number;
+    /** Which y axis the series is drawn against. */
+    axis: 'left' | 'right';
+    /** Joins across gaps instead of breaking the line. */
+    spanGaps: boolean;
+    /** Leaves the series out of the chart without removing the definition. */
+    hidden: boolean;
+    /** Formats this series' values for the tooltip. Property only. */
+    format?: (value: number) => string;
+    /** A plain snapshot of this definition, so the chart never holds a reference to the element. */
+    toConfig(): ChartSeriesConfig;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(_changed: PropertyValues): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'c2-chart-series': ChartSeries;
+    }
+}
+//# sourceMappingURL=chart-series.d.ts.map

package/types/src/chart-series.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-series.d.ts","sourceRoot":"","sources":["../../src/chart-series.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAO,KAAK,cAAc,EAAE,MAAM,KAAK,CAAA;AAG1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEzD,sEAAsE;AACtE,eAAO,MAAM,mBAAmB,2BAA2B,CAAA;AAE3D,wFAAwF;AACxF,eAAO,MAAM,UAAU,oBAAoB,CAAA;AAE3C;;;;;;;;;;;;;GAaG;AACH,qBACa,WAAY,SAAQ,UAAW,YAAW,iBAAiB;;IACtE,OAAgB,MAAM,0BAIrB;IAED,oFAAoF;IACxD,KAAK,SAAK;IAEtC,8DAA8D;IAClC,KAAK,CAAC,EAAE,MAAM,CAAA;IAE1C,+EAA+E;IACnD,KAAK,CAAC,EAAE,MAAM,CAAA;IAE1C,uEAAuE;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAEvE,gDAAgD;IACpB,IAAI,EAAE,MAAM,GAAG,OAAO,CAAS;IAE3D,sDAAsD;IACD,QAAQ,UAAQ;IAErE,0EAA0E;IACrB,MAAM,UAAQ;IAEnE,kEAAkE;IAClC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IAElE,gGAAgG;IAChG,QAAQ,IAAI,iBAAiB;IAapB,iBAAiB,IAAI,IAAI;IAKzB,oBAAoB,IAAI,IAAI;cAKlB,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;CAQ3D;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,iBAAiB,EAAE,WAAW,CAAA;KAC/B;CACF"}

package/types/src/chart-theme.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Turns the element's own CSS custom properties into plain values a canvas engine can use.
+ *
+ * This is the one place the package has to work around the fact that a chart is not DOM: `::part()` and
+ * `var()` never reach a canvas, so the theme has to be *read* and handed over as strings and numbers.
+ *
+ * Colours are read through hidden probe elements rather than `getPropertyValue`, because a custom
+ * property whose value is a `var()` chain or a `color-mix()` comes back from `getPropertyValue` as the
+ * author's literal text — which no engine can parse. The computed `color` of a probe is always a resolved
+ * `rgb(…)`. The probes live in the shadow root under `display: none`, so they cost no layout.
+ */
+import { type ReactiveController, type ReactiveControllerHost } from 'lit';
+/** The slice of the host this controller needs: a reactive element with a shadow root to probe. */
+type ThemeHost = ReactiveControllerHost & HTMLElement & {
+    readonly renderRoot?: ParentNode;
+};
+/** Number of series colours in the palette; matches `--c2-chart__series-1…8--color`. */
+export declare const PALETTE_SIZE = 8;
+/**
+ * The colours the probe block exposes, in DOM order. `chart.scss` emits one `i:nth-child(n)` rule per
+ * entry, so this list and that loop must stay in step.
+ */
+export declare const PROBE_COLORS: readonly ["series-1", "series-2", "series-3", "series-4", "series-5", "series-6", "series-7", "series-8", "axis", "grid", "text", "muted", "tooltip-background", "tooltip-text", "crosshair", "positive", "negative", "surface"];
+/** Resolved, engine-ready theme values. Every colour is a computed `rgb(…)`. */
+export interface ChartTheme {
+    /** The categorical series palette, longest-lived of the chart tokens. */
+    palette: string[];
+    /** Primary text colour, used for labels the chart draws itself. */
+    color: string;
+    /** Secondary text colour, used for axis tick labels. */
+    mutedColor: string;
+    axisColor: string;
+    gridColor: string;
+    surface: string;
+    tooltipBackground: string;
+    tooltipColor: string;
+    crosshairColor: string;
+    /** Colours for charts with an inherent direction (candlestick, gauge thresholds). */
+    positive: string;
+    negative: string;
+    fontFamily: string;
+    fontSize: number;
+    lineWidth: number;
+    pointRadius: number;
+}
+/**
+ * Resolves and caches the host's chart theme, and invalidates it whenever the page's colour scheme moves.
+ *
+ * Three independent triggers, because an app may use any of them: the `data-theme` / `class` attribute on
+ * `<html>` (what a site toggle sets), the OS preference, and the `c2n-theme-change` event the docs site
+ * happens to fire. None of them is required for the component to work.
+ */
+export declare class ChartThemeController implements ReactiveController {
+    #private;
+    constructor(host: ThemeHost, onChange: () => void);
+    /** The resolved theme, computed on first read after each invalidation. */
+    get theme(): ChartTheme;
+    /** Drops the cached theme and tells the host to rebuild its engine options. */
+    invalidate(): void;
+    hostConnected(): void;
+    hostDisconnected(): void;
+}
+export {};
+//# sourceMappingURL=chart-theme.d.ts.map

package/types/src/chart-theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-theme.d.ts","sourceRoot":"","sources":["../../src/chart-theme.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAA;AAEpF,mGAAmG;AACnG,KAAK,SAAS,GAAG,sBAAsB,GAAG,WAAW,GAAG;IAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAA;CAAE,CAAA;AAE5F,wFAAwF;AACxF,eAAO,MAAM,YAAY,IAAI,CAAA;AAE7B;;;GAGG;AACH,eAAO,MAAM,YAAY,kOAmBf,CAAA;AAEV,gFAAgF;AAChF,MAAM,WAAW,UAAU;IACzB,yEAAyE;IACzE,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAA;IACb,wDAAwD;IACxD,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,iBAAiB,EAAE,MAAM,CAAA;IACzB,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,MAAM,CAAA;IACtB,qFAAqF;IACrF,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB;AAoBD;;;;;;GAMG;AACH,qBAAa,oBAAqB,YAAW,kBAAkB;;gBAOjD,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,IAAI;IAMjD,0EAA0E;IAC1E,IAAI,KAAK,IAAI,UAAU,CAGtB;IAED,+EAA+E;IAC/E,UAAU,IAAI,IAAI;IAKlB,aAAa,IAAI,IAAI;IAarB,gBAAgB,IAAI,IAAI;CAiDzB"}

package/types/src/chart-types.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Public data and configuration types shared by every `c2-*-chart` element.
+ *
+ * The split this file encodes is the point of the whole package: a {@link ChartSeriesConfig} describes
+ * *presentation* (what a series looks like and which field it reads), while {@link ChartInput} and
+ * {@link ChartDataSource} carry *data*. Nothing in the data path knows about colours, and nothing in the
+ * presentation path knows about buffers, so a source can be reused unchanged across chart types.
+ */
+/** A row is any plain object; values are read by `field`, which may be a dotted path (`stats.cpu`). */
+export type ChartRow = Record<string, unknown>;
+/**
+ * One column per axis: `[xs, ys1, ys2, …]`. This is the shape uPlot draws natively, so handing it in
+ * costs no conversion at all.
+ */
+export type ChartColumnarInput = ArrayLike<number>[];
+/**
+ * Everything a chart accepts as `data`:
+ *
+ * - `number[]` — one series against its own index, the convenient shape for a sparkline.
+ * - {@link ChartRow}`[]` — row objects read through `x-field` and each series' `field`.
+ * - {@link ChartColumnarInput} — already columnar.
+ * - {@link ChartFrame} — already normalised, handed straight through.
+ */
+export type ChartInput = number[] | ChartRow[] | ChartColumnarInput | ChartFrame;
+/**
+ * A column of y values. Dense numeric data is a `Float64Array` (the fast path: appending is O(1) and no
+ * engine has to convert it). A column that contains holes falls back to a plain array, because both
+ * engines detect a gap with `== null` and `NaN` inside a typed array would silently poison the scale
+ * range instead.
+ */
+export type ChartColumn = Float64Array | (number | null)[];
+/**
+ * The normalised form every chart works with internally, produced once per input by `ChartFrameBuilder`.
+ *
+ * The buffers are deliberately longer than `length`: appending a realtime point writes into the spare
+ * capacity and bumps {@link revision} instead of reallocating, which is what makes a streaming tick cost
+ * nothing but the engine redraw.
+ */
+export interface ChartFrame {
+    /** X values, ascending. A time chart stores epoch **milliseconds**. */
+    x: ChartColumn;
+    /** One column per series, each at least `length` long. */
+    columns: ChartColumn[];
+    /** How many entries of `x` and each column are valid. */
+    length: number;
+    /** Allocated capacity of the buffers; `length` grows into it. */
+    capacity: number;
+    /** Bumped on every in-place mutation, so every derived projection cache invalidates at once. */
+    revision: number;
+    /** Category labels, when the x axis is categorical (`x-type="category"`, pie, gauge). */
+    labels?: string[];
+}
+/** Marks a value as a `ChartFrame` without an `instanceof` check surviving a bundler boundary. */
+export declare function isChartFrame(value: unknown): value is ChartFrame;
+/**
+ * One series: which field it reads and how it is drawn. Everything here is presentation except `field`,
+ * which is the single point where a series touches the data.
+ */
+export interface ChartSeriesConfig {
+    /** Key of the value in the row object; may be a dotted path such as `stats.cpu`. */
+    field: string;
+    /** Legend and tooltip label. Falls back to the field name. */
+    label?: string;
+    /** Explicit colour. Falls back to the palette slot for this series' index. */
+    color?: string;
+    /** Stroke width in pixels; falls back to `--c2-chart__line--width`. */
+    lineWidth?: number;
+    /** Draws the series against the secondary (right-hand) axis. */
+    axis?: 'left' | 'right';
+    /** Joins across gaps instead of breaking the line. */
+    spanGaps?: boolean;
+    /** Leaves the series out without removing the definition. */
+    hidden?: boolean;
+    /** Formats a value for the tooltip and the axis. Property only — no attribute equivalent. */
+    format?: (value: number) => string;
+}
+/** What the chart asks a {@link ChartDataSource} for. */
+export interface ChartWindowRequest {
+    /** Inclusive x domain the chart needs. Absent on the first load. */
+    xMin?: number;
+    xMax?: number;
+    /** Points the chart can usefully draw at its current width; a source may decimate to this server-side. */
+    maxPoints: number;
+    /** Aborted when the user keeps panning and this window is no longer wanted. */
+    signal: AbortSignal;
+}
+/** What a {@link ChartDataSource} returns. */
+export interface ChartWindowResult {
+    data: ChartInput;
+    /** Full domain of the dataset, so the chart can size its x scale before it holds every point. */
+    domain?: {
+        min: number;
+        max: number;
+    };
+}
+/**
+ * Lazy point source — the chart's equivalent of `TableDataSource`, used instead of `data`.
+ *
+ * `getWindow` is the pull half (first load, zoom, pan). `subscribe` is the push half: a tick handed to
+ * the listener lands straight in the frame's spare capacity and redraws without a Lit update.
+ */
+export interface ChartDataSource {
+    getWindow(request: ChartWindowRequest): Promise<ChartWindowResult>;
+    subscribe?(listener: (x: number, values: readonly (number | null)[]) => void): () => void;
+}
+/** Identifies one datum, shared by the hover and click event details. */
+export interface ChartPointEventDetail {
+    /** Index of the point within the series. */
+    index: number;
+    /** Index of the series the point belongs to. */
+    seriesIndex: number;
+    /** The series definition. */
+    series: ChartSeriesConfig;
+    /** The x value; epoch milliseconds on a time chart. */
+    x: number;
+    /** The y value, or `null` at a gap. */
+    y: number | null;
+    /** The category label, when the chart is categorical. */
+    label?: string;
+}
+/** One row of the tooltip: a series and its value at the hovered index. */
+export interface ChartTooltipEntry {
+    seriesIndex: number;
+    series: ChartSeriesConfig;
+    value: number | null;
+    /** `value` run through the series' `format`, or the chart's number formatter. */
+    formatted: string;
+    color: string;
+}
+/** What the tooltip slot and `renderTooltip` are handed. */
+export interface ChartTooltipContext {
+    /** Index of the hovered point. */
+    index: number;
+    /** The hovered x value; epoch milliseconds on a time chart. */
+    x: number;
+    /** `x` formatted for display. */
+    formattedX: string;
+    /** Every visible series at this index, in draw order. */
+    entries: ChartTooltipEntry[];
+    /** Position within the plot area, in CSS pixels. */
+    px: number;
+    py: number;
+}
+/** Detail of the `range-change` event. */
+export interface ChartRangeEventDetail {
+    /** New lower bound of the x scale. */
+    min: number;
+    /** New upper bound of the x scale. */
+    max: number;
+}
+/** Detail of the `series-toggle` event. */
+export interface ChartSeriesToggleEventDetail {
+    seriesIndex: number;
+    series: ChartSeriesConfig;
+    /** Whether the series is visible after the toggle. */
+    visible: boolean;
+    /** Indices of every series now hidden. */
+    hidden: number[];
+}
+/** Reads a possibly dotted `field` path out of a row. Re-exported so the package keeps its own subpath. */
+export { getFieldValue } from '@c2n/core/data-helper.js';
+//# sourceMappingURL=chart-types.d.ts.map

package/types/src/chart-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-types.d.ts","sourceRoot":"","sources":["../../src/chart-types.ts"],"names":[],"mappings":"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"}

package/types/src/chart.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The package barrel: registers every chart tag and re-exports the public API.
+ *
+ * Importing a single chart (`@c2n/chart/line-chart.js`) registers only that tag and pulls in only that
+ * engine; this entry exists for an application that wants them all.
+ */
+import './line-chart.js';
+import './area-chart.js';
+import './bar-chart.js';
+import './sparkline.js';
+import './pie-chart.js';
+import './chart-series.js';
+export { ChartBase, type ChartEventMap } from './chart-base.js';
+export { UplotChartBase, type UplotSeriesStyle } from './uplot-chart-base.js';
+export { EchartsChartBase } from './echarts-chart-base.js';
+export { LineChart } from './line-chart.js';
+export { AreaChart } from './area-chart.js';
+export { BarChart } from './bar-chart.js';
+export { Sparkline } from './sparkline.js';
+export { PieChart } from './pie-chart.js';
+export { ChartSeries, SERIES_CHANGE_EVENT } from './chart-series.js';
+export { ChartFrameBuilder, columnValue, type NormalizeContext } from './chart-data.js';
+export { ChartThemeController, PALETTE_SIZE, PROBE_COLORS, type ChartTheme } from './chart-theme.js';
+export type { ChartAdapter, ChartAdapterEvents, ChartBuildContext } from './chart-adapter.js';
+export type { ChartColumn, ChartColumnarInput, ChartDataSource, ChartFrame, ChartInput, ChartPointEventDetail, ChartRangeEventDetail, ChartRow, ChartSeriesConfig, ChartSeriesToggleEventDetail, ChartTooltipContext, ChartTooltipEntry, ChartWindowRequest, ChartWindowResult, } from './chart-types.js';
+export { isChartFrame } from './chart-types.js';
+//# sourceMappingURL=chart.d.ts.map