@c2n/chart 0.0.7

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

@@ -0,0 +1 @@
+{"version":3,"file":"chart.d.ts","sourceRoot":"","sources":["../../src/chart.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,iBAAiB,CAAA;AACxB,OAAO,iBAAiB,CAAA;AACxB,OAAO,gBAAgB,CAAA;AACvB,OAAO,gBAAgB,CAAA;AACvB,OAAO,gBAAgB,CAAA;AACvB,OAAO,mBAAmB,CAAA;AAE1B,OAAO,EAAE,SAAS,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/D,OAAO,EAAE,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACpE,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACvF,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,YAAY,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACpG,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC7F,YAAY,EACV,WAAW,EACX,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,UAAU,EACV,qBAAqB,EACrB,qBAAqB,EACrB,QAAQ,EACR,iBAAiB,EACjB,4BAA4B,EAC5B,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA"}

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

@@ -0,0 +1,28 @@
+import { ChartBase } from './chart-base.js';
+import type { ChartAdapter, ChartBuildContext } from './chart-adapter.js';
+import type { EchartsFeature } from './engines/echarts-loader.js';
+import type { ChartFrame } from './chart-types.js';
+/**
+ * The ECharts half of the hierarchy. A concrete chart declares the engine modules it needs and how one
+ * series is configured; everything else — theme, text styles, the disabled built-in tooltip and legend —
+ * is settled here.
+ *
+ * Defines no tag and is never registered.
+ */
+export declare abstract class EchartsChartBase extends ChartBase {
+    protected readonly engineName: "echarts";
+    /** Which ECharts renderer to use. SVG prints and scales crisply; canvas is faster with many marks. */
+    renderer: 'canvas' | 'svg';
+    /** The ECharts modules this chart type needs registered. Keeps the rest of the library unloaded. */
+    protected abstract readonly features: readonly EchartsFeature[];
+    /** The option object for one series. */
+    protected abstract seriesOption(index: number, context: ChartBuildContext): Record<string, unknown>;
+    /** Grid and axes for a cartesian chart. The pie and gauge charts override this to contribute neither. */
+    protected coordinateSystem(context: ChartBuildContext): Record<string, unknown>;
+    protected createAdapter(): Promise<ChartAdapter>;
+    protected projectData(frame: ChartFrame, context: ChartBuildContext): unknown;
+    /** Cartesian charts want `[x, y]` pairs; the labelled ones want `{ name, value }`. */
+    protected dataShape(_context: ChartBuildContext): 'pairs' | 'values' | 'named';
+    protected buildOptions(context: ChartBuildContext): unknown;
+}
+//# sourceMappingURL=echarts-chart-base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"echarts-chart-base.d.ts","sourceRoot":"","sources":["../../src/echarts-chart-base.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAEzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD;;;;;;GAMG;AACH,8BAAsB,gBAAiB,SAAQ,SAAS;IACtD,mBAA4B,UAAU,EAAG,SAAS,CAAS;IAE3D,sGAAsG;IAC1E,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAW;IAEjE,oGAAoG;IACpG,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAA;IAE/D,wCAAwC;IACxC,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAEnG,yGAAyG;IACzG,SAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;cAW5D,aAAa,IAAI,OAAO,CAAC,YAAY,CAAC;cAMtC,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO;IAItF,sFAAsF;IACtF,SAAS,CAAC,SAAS,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO;cAI3D,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO;CAsBrE"}

package/types/src/engines/echarts-adapter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ECharts behind the {@link ChartAdapter} contract.
+ *
+ * The split the interface asks for maps cleanly here: `setOption` with `notMerge: false` merges, so
+ * `setData` can send a *series-data-only* option object and ECharts skips normalising everything else.
+ * `lazyUpdate` coalesces bursts into the next frame, and `silent` stops a programmatic update firing the
+ * event storm a user interaction would.
+ */
+import type { EChartsCoreOption } from 'echarts/core';
+import { type EchartsFeature } from './echarts-loader.js';
+import type { ChartAdapter } from '../chart-adapter.js';
+/** The option shape the element builds; `series` is the only part `setData` replaces. */
+export interface EchartsOptions extends EChartsCoreOption {
+    series?: Record<string, unknown>[];
+}
+export declare function createEchartsAdapter(features: readonly EchartsFeature[], renderer: 'canvas' | 'svg'): Promise<ChartAdapter<EchartsOptions, unknown[]>>;
+//# sourceMappingURL=echarts-adapter.d.ts.map

package/types/src/engines/echarts-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"echarts-adapter.d.ts","sourceRoot":"","sources":["../../../src/engines/echarts-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAW,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAC9D,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACtE,OAAO,KAAK,EAAE,YAAY,EAAsB,MAAM,qBAAqB,CAAA;AAE3E,yFAAyF;AACzF,MAAM,WAAW,cAAe,SAAQ,iBAAiB;IACvD,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;CACnC;AAED,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,EAAE,QAAQ,EAAE,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAC,YAAY,CAAC,cAAc,EAAE,OAAO,EAAE,CAAC,CAAC,CA6F5J"}

package/types/src/engines/echarts-loader.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Lazy, tree-shaken access to ECharts.
+ *
+ * ECharts is large, so only the pieces a given chart type needs are registered: a page showing a gauge
+ * never evaluates the pie code. Every specifier below is **static** — a computed `import(name)` would
+ * defeat the bundler's module graph and pull the whole library back in.
+ */
+import type * as echarts from 'echarts/core';
+/** A registerable ECharts module, keyed by the chart type or component that needs it. */
+export type EchartsFeature = 'pie' | 'gauge' | 'scatter' | 'heatmap' | 'candlestick' | 'bar' | 'line' | 'grid' | 'legend' | 'tooltip' | 'visualMap' | 'dataZoom';
+/**
+ * Loads `echarts/core`, registers `features` and the chosen renderer, and returns the core namespace.
+ * Registration is idempotent and deduped, so calling this per element is cheap after the first.
+ */
+export declare function loadECharts(features: readonly EchartsFeature[], renderer: 'canvas' | 'svg'): Promise<typeof echarts>;
+//# sourceMappingURL=echarts-loader.d.ts.map

package/types/src/engines/echarts-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"echarts-loader.d.ts","sourceRoot":"","sources":["../../../src/engines/echarts-loader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAE5C,yFAAyF;AACzF,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAA;AAuBhK;;;GAGG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,EAAE,QAAQ,EAAE,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAC,OAAO,OAAO,CAAC,CA0B1H"}

package/types/src/engines/uplot-adapter.d.ts

@@ -0,0 +1,4 @@
+import type { AlignedData, Options } from 'uplot';
+import type { ChartAdapter } from '../chart-adapter.js';
+export declare function createUplotAdapter(): Promise<ChartAdapter<Options, AlignedData>>;
+//# sourceMappingURL=uplot-adapter.d.ts.map

package/types/src/engines/uplot-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uplot-adapter.d.ts","sourceRoot":"","sources":["../../../src/engines/uplot-adapter.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAsB,MAAM,qBAAqB,CAAA;AAE3E,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,YAAY,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAkGtF"}

package/types/src/engines/uplot-loader.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Lazy access to uPlot.
+ *
+ * The library is never imported by an element file, only from inside this function — so importing
+ * `c2-line-chart` pulls in no engine, nothing runs at module scope, and the module is safe to evaluate
+ * during SSR. `uplot` is a peer dependency and stays external at build time.
+ */
+import type uPlot from 'uplot';
+/**
+ * Loads uPlot once per page. Ten sparklines mounting at the same time share one request and one module
+ * evaluation, because every caller awaits the same promise.
+ */
+export declare function loadUplot(): Promise<typeof uPlot>;
+/**
+ * The module, for callers that cannot await it — the path builders, which are read while an option object
+ * is being built. `undefined` until the load resolves; every chart builds its options from inside an
+ * adapter that already awaited {@link loadUplot}, so by then this is set.
+ */
+export declare function loadedUplot(): typeof uPlot | undefined;
+//# sourceMappingURL=uplot-loader.d.ts.map

package/types/src/engines/uplot-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uplot-loader.d.ts","sourceRoot":"","sources":["../../../src/engines/uplot-loader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAK9B;;;GAGG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAAC,OAAO,KAAK,CAAC,CAOjD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,OAAO,KAAK,GAAG,SAAS,CAEtD"}

package/types/src/engines/uplot-paths.d.ts

@@ -0,0 +1,25 @@
+import type { Series } from 'uplot';
+export type ChartCurve = 'linear' | 'smooth' | 'step';
+/**
+ * The path builder for a curve, or `undefined` for `linear` — uPlot's default is already a straight line,
+ * and passing `undefined` keeps the fastest path.
+ */
+export declare function linePaths(curve: ChartCurve): Series.PathBuilder | undefined;
+/**
+ * Applies an alpha to a resolved colour, for the fill under an area series.
+ *
+ * The theme controller always hands back a computed `rgb(…)` or `rgba(…)`, so this only has to handle those
+ * two plus a hex literal a consumer may have set directly on a series.
+ */
+export declare function withAlpha(color: string, alpha: number): string;
+/**
+ * The bars path builder for one series of a chart: `width` is the share of the band the whole group takes
+ * and `gap` the share of each bar's slot given up to the gutter between grouped bars. Memoised on all four
+ * arguments, since uPlot wants one builder reused rather than a fresh one per option rebuild.
+ *
+ * uPlot draws every series' bars on the same x, so a second series would sit exactly on top of the first.
+ * Grouping is therefore ours to do: `disp` gives uPlot an explicit left edge and width per bar — in data
+ * units, which is what it reads when no `unit` is set — placing each series in its own slot of the band.
+ */
+export declare function barPaths(width: number, gap: number, index: number, count: number): Series.PathBuilder | undefined;
+//# sourceMappingURL=uplot-paths.d.ts.map

package/types/src/engines/uplot-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uplot-paths.d.ts","sourceRoot":"","sources":["../../../src/engines/uplot-paths.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAA;AAGnC,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAA;AAIrD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAAC,WAAW,GAAG,SAAS,CAa3E;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAa9D;AAOD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,WAAW,GAAG,SAAS,CAyBjH"}

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

@@ -0,0 +1,40 @@
+import type { TypedAddEventListener, TypedRemoveEventListener } from '@c2n/core/event-helper.js';
+import { UplotChartBase, type UplotSeriesStyle } from './uplot-chart-base.js';
+import type { ChartEventMap } from './chart-base.js';
+import type { ChartBuildContext } from './chart-adapter.js';
+import type { ChartSeriesConfig } from './chart-types.js';
+import './chart-series.js';
+export interface LineChart {
+    addEventListener: TypedAddEventListener<LineChart, ChartEventMap>;
+    removeEventListener: TypedRemoveEventListener<LineChart, ChartEventMap>;
+}
+/**
+ * A line chart over a time or numeric x axis, drawn on canvas by uPlot.
+ *
+ * Series are declared as `c2-chart-series` children — the same authoring shape as `c2-table`'s columns —
+ * or through the `series` property. With neither, one line is drawn per numeric key of the first row.
+ *
+ * ```html
+ * <c2-line-chart x-type="time" x-field="t" legend="bottom" data='[{ "t": 1704067200000, "cpu": 12 }]'>
+ *   <c2-chart-series field="cpu" label="CPU"></c2-chart-series>
+ * </c2-line-chart>
+ * ```
+ *
+ * Realtime feeds should call `appendPoint()` rather than reassigning `data`: it writes into the frame's
+ * spare capacity and redraws without a Lit update.
+ *
+ * @tag c2-line-chart
+ */
+export declare class LineChart extends UplotChartBase {
+    /** Interpolation between points. */
+    curve: 'linear' | 'smooth' | 'step';
+    /** When point markers are drawn. `auto` lets uPlot show them once points are far enough apart. */
+    points: 'auto' | 'always' | 'none';
+    protected seriesStyle(series: ChartSeriesConfig, index: number, context: ChartBuildContext): UplotSeriesStyle;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'c2-line-chart': LineChart;
+    }
+}
+//# sourceMappingURL=line-chart.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"line-chart.d.ts","sourceRoot":"","sources":["../../src/line-chart.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAA;AAChG,OAAO,EAAE,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAE7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACzD,OAAO,mBAAmB,CAAA;AAE1B,MAAM,WAAW,SAAS;IACxB,gBAAgB,EAAE,qBAAqB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAA;IACjE,mBAAmB,EAAE,wBAAwB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAA;CACxE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBACa,SAAU,SAAQ,cAAc;IAC3C,oCAAoC;IACR,KAAK,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAW;IAE1E,kGAAkG;IACtE,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAS;cAEpD,WAAW,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,gBAAgB;CAavH;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,eAAe,EAAE,SAAS,CAAA;KAC3B;CACF"}

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

@@ -0,0 +1,59 @@
+import type { TypedAddEventListener, TypedRemoveEventListener } from '@c2n/core/event-helper.js';
+import { EchartsChartBase } from './echarts-chart-base.js';
+import type { ChartLegendItem } from './chart-base.js';
+import type { ChartEventMap } from './chart-base.js';
+import type { ChartBuildContext } from './chart-adapter.js';
+import type { EchartsFeature } from './engines/echarts-loader.js';
+import './chart-series.js';
+export interface PieChart {
+    addEventListener: TypedAddEventListener<PieChart, ChartEventMap>;
+    removeEventListener: TypedRemoveEventListener<PieChart, ChartEventMap>;
+}
+/**
+ * A pie or donut chart, drawn by ECharts. `label-field` names each slice and the single series supplies
+ * its value, so one row is one slice.
+ *
+ * ```html
+ * <c2-pie-chart label-field="channel" inner-radius="0.6" legend="end"
+ *   data='[{ "channel": "Direct", "revenue": 4200 }, { "channel": "Search", "revenue": 3100 }]'>
+ *   <c2-chart-series field="revenue"></c2-chart-series>
+ * </c2-pie-chart>
+ * ```
+ *
+ * @tag c2-pie-chart
+ *
+ * @cssproperty {border} [--c2-chart__slice--border=2px solid #ffffff] - Border drawn between adjacent slices.
+ */
+export declare class PieChart extends EchartsChartBase {
+    protected readonly features: readonly EchartsFeature[];
+    /** Hole in the middle, from 0 (a full pie) to 1. Anything above 0 makes it a donut. */
+    innerRadius: number;
+    /** Outer edge as a share of the available box, from 0 to 1. */
+    outerRadius: number;
+    /** Angle the first slice starts at, in degrees, counter-clockwise from three o'clock. */
+    startAngle: number;
+    /** Where the slice labels are drawn, or `none` to leave them off. */
+    labels: 'none' | 'inside' | 'outside';
+    /** Orders the slices by value rather than keeping the data order. */
+    sort: 'none' | 'asc' | 'desc';
+    constructor();
+    /** Slices the reader has switched off from the legend, by label. */
+    private hiddenSlices;
+    /** A pie has no grid and no axes at all: contributing them would draw an empty cartesian frame. */
+    protected coordinateSystem(): Record<string, unknown>;
+    /**
+     * A pie's legend is its slices, not its series: there is only ever one series, so the inherited legend
+     * would render a single entry ("Revenue") above a four-slice donut.
+     */
+    protected legendItems(): ChartLegendItem[];
+    /** Shows or hides one slice, as the legend does. ECharts selects by name, which is the slice's label. */
+    setSliceVisible(label: string, visible: boolean): void;
+    protected dataShape(): 'pairs' | 'values' | 'named';
+    protected seriesOption(_index: number, context: ChartBuildContext): Record<string, unknown>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'c2-pie-chart': PieChart;
+    }
+}
+//# sourceMappingURL=pie-chart.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pie-chart.d.ts","sourceRoot":"","sources":["../../src/pie-chart.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAA;AAChG,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AACjE,OAAO,mBAAmB,CAAA;AAE1B,MAAM,WAAW,QAAQ;IACvB,gBAAgB,EAAE,qBAAqB,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAA;IAChE,mBAAmB,EAAE,wBAAwB,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAA;CACvE;AAED;;;;;;;;;;;;;;GAcG;AACH,qBACa,QAAS,SAAQ,gBAAgB;IAC5C,mBAA4B,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAU;IAEzE,uFAAuF;IAChC,WAAW,SAAI;IAEtE,+DAA+D;IACR,WAAW,SAAO;IAEzE,yFAAyF;IACnC,UAAU,SAAK;IAErE,qEAAqE;IACzC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAS;IAE1E,qEAAqE;IACzC,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,CAAS;;IASlE,oEAAoE;IAC3D,OAAO,CAAC,YAAY,CAAoB;IAEjD,mGAAmG;cAChF,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAI9D;;;OAGG;cACgB,WAAW,IAAI,eAAe,EAAE;IAenD,yGAAyG;IACzG,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;cAQnC,SAAS,IAAI,OAAO,GAAG,QAAQ,GAAG,OAAO;cAIzC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAoBrG;AAYD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,cAAc,EAAE,QAAQ,CAAA;KACzB;CACF"}

package/types/src/sparkline.d.ts

@@ -0,0 +1,56 @@
+import type { TypedAddEventListener, TypedRemoveEventListener } from '@c2n/core/event-helper.js';
+import type { Options } from 'uplot';
+import { UplotChartBase, type UplotSeriesStyle } from './uplot-chart-base.js';
+import type { ChartEventMap } from './chart-base.js';
+import type { ChartBuildContext } from './chart-adapter.js';
+import type { ChartSeriesConfig } from './chart-types.js';
+export interface Sparkline {
+    addEventListener: TypedAddEventListener<Sparkline, ChartEventMap>;
+    removeEventListener: TypedRemoveEventListener<Sparkline, ChartEventMap>;
+}
+/**
+ * A chromeless trend line sized for a table cell, a list row or the `trend` slot of a `c2-stat`: no axes,
+ * no grid, no legend and no tooltip, so the whole box is the data.
+ *
+ * It takes the bare `number[]` shape as well as rows, which is usually all a cell has:
+ *
+ * ```html
+ * <c2-sparkline data="[3, 5, 4, 8, 6, 11]" tone="auto"></c2-sparkline>
+ * ```
+ *
+ * uPlot is what makes a sparkline per row affordable — the engine loads once for the page, and each
+ * instance is a single canvas.
+ *
+ * @tag c2-sparkline
+ *
+ * @cssproperty {color} [--c2-chart__tone-positive--color=#16a34a] - Stroke when `tone` resolves to positive.
+ * @cssproperty {color} [--c2-chart__tone-negative--color=#dc2626] - Stroke when `tone` resolves to negative.
+ */
+export declare class Sparkline extends UplotChartBase {
+    static styles: import("lit").CSSResult[];
+    /** How the line is drawn. */
+    type: 'line' | 'area';
+    /**
+     * Colours the line by direction. `auto` compares the last value with the first and uses the positive or
+     * negative tone; `neutral` keeps the palette colour.
+     */
+    tone: 'auto' | 'positive' | 'negative' | 'neutral';
+    constructor();
+    protected seriesStyle(series: ChartSeriesConfig, index: number, context: ChartBuildContext): UplotSeriesStyle;
+    /**
+     * Strips every remaining pixel of chrome, so the line fills the whole box.
+     *
+     * The axes are left alone on purpose: `this.axes = 'none'` already builds them with `show: false`, which
+     * is what makes uPlot skip both the axis element and its gutter. Handing it `axes: []` would do the
+     * opposite — uPlot fills a short array back up to two axes with its own defaults, which are *visible* —
+     * and a 120x32 sparkline would spend 52px of its width on a y axis it never asked for.
+     */
+    protected decorateOptions(options: Options, _context: ChartBuildContext): Options;
+    private resolveTone;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'c2-sparkline': Sparkline;
+    }
+}
+//# sourceMappingURL=sparkline.d.ts.map

package/types/src/sparkline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparkline.d.ts","sourceRoot":"","sources":["../../src/sparkline.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAA;AAChG,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAEpC,OAAO,EAAE,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAE7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEzD,MAAM,WAAW,SAAS;IACxB,gBAAgB,EAAE,qBAAqB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAA;IACjE,mBAAmB,EAAE,wBAAwB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAA;CACxE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBACa,SAAU,SAAQ,cAAc;IAC3C,OAAgB,MAAM,4BAgBrB;IAED,6BAA6B;IACD,IAAI,EAAE,MAAM,GAAG,MAAM,CAAS;IAE1D;;;OAGG;IACyB,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAAY;;cAavE,WAAW,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,gBAAgB;IAWtH;;;;;;;OAOG;cACgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,iBAAiB,GAAG,OAAO;IAI1F,OAAO,CAAC,WAAW;CAcpB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,cAAc,EAAE,SAAS,CAAA;KAC1B;CACF"}

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

@@ -0,0 +1,50 @@
+import type { Options, Series } from 'uplot';
+import { ChartBase } from './chart-base.js';
+import type { ChartAdapter, ChartBuildContext } from './chart-adapter.js';
+import type { ChartFrame, ChartSeriesConfig } from './chart-types.js';
+/** The per-series drawing options a concrete uPlot chart contributes. */
+export type UplotSeriesStyle = Omit<Series, 'label' | 'show'>;
+/**
+ * The uPlot half of the hierarchy: the cartesian presentation shared by the line, area, bar and sparkline
+ * charts, and the option object built from it. A concrete chart supplies only {@link seriesStyle}, which
+ * is what makes a new uPlot chart type roughly ten lines.
+ *
+ * Defines no tag and is never registered.
+ *
+ * @cssproperty {color} [--c2-chart__axis-line--color=#e4e4e7] - Colour of the axis rules uPlot draws at the plot edges.
+ */
+export declare abstract class UplotChartBase extends ChartBase {
+    protected readonly engineName: "uplot";
+    /**
+     * Which grid lines are drawn. A string rather than a boolean because a boolean attribute reads as `true`
+     * whenever it is present — `grid="false"` in markup would turn the grid *on*, and there would be no way to
+     * turn it off from HTML at all. `y` (the default) draws the horizontal lines, matching `axes`' shape.
+     */
+    grid: 'both' | 'x' | 'y' | 'none';
+    /** Which axes are drawn. */
+    axes: 'both' | 'x' | 'y' | 'none';
+    /** Lower bound of the y scale. Auto-ranged when unset. */
+    yMin?: number;
+    /** Upper bound of the y scale. Auto-ranged when unset. */
+    yMax?: number;
+    /** Lets the user drag horizontally to zoom the x scale. */
+    zoom: boolean;
+    /** The cursor crosshair. */
+    cursor: 'x' | 'none';
+    /** How one series of this chart type is drawn. The only thing a concrete uPlot chart must supply. */
+    protected abstract seriesStyle(series: ChartSeriesConfig, index: number, context: ChartBuildContext): UplotSeriesStyle;
+    /** Last chance to adjust the finished option object; the sparkline strips its chrome here. */
+    protected decorateOptions(options: Options, _context: ChartBuildContext): Options;
+    protected createAdapter(): Promise<ChartAdapter>;
+    protected projectData(frame: ChartFrame): unknown;
+    protected buildOptions(context: ChartBuildContext): unknown;
+    /** A fixed y range when either bound is set, otherwise uPlot's own auto-ranging. */
+    private yRange;
+    /**
+     * Axis tick labels are terser than the tooltip's. The unit comes from the span the chart covers, because a
+     * fixed date format repeats itself once the engine picks sub-day increments: an hour of samples would label
+     * every tick "Jan 1".
+     */
+    protected formatAxisX(value: number): string;
+}
+//# sourceMappingURL=uplot-chart-base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uplot-chart-base.d.ts","sourceRoot":"","sources":["../../src/uplot-chart-base.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAqB,OAAO,EAAE,MAAM,EAAE,MAAM,OAAO,CAAA;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAEzE,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAQrE,yEAAyE;AACzE,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,CAAA;AAE7D;;;;;;;;GAQG;AACH,8BAAsB,cAAe,SAAQ,SAAS;IACpD,mBAA4B,UAAU,EAAG,OAAO,CAAS;IAEzD;;;;OAIG;IACyB,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,CAAM;IAEnE,4BAA4B;IACA,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,CAAS;IAEtE,0DAA0D;IACV,IAAI,CAAC,EAAE,MAAM,CAAA;IAE7D,0DAA0D;IACV,IAAI,CAAC,EAAE,MAAM,CAAA;IAE7D,2DAA2D;IAC9B,IAAI,UAAQ;IAEzC,4BAA4B;IACA,MAAM,EAAE,GAAG,GAAG,MAAM,CAAM;IAEtD,qGAAqG;IACrG,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,gBAAgB;IAEtH,8FAA8F;IAC9F,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,iBAAiB,GAAG,OAAO;cAI9D,aAAa,IAAI,OAAO,CAAC,YAAY,CAAC;cAItC,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;cAIvC,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO;IAyDpE,oFAAoF;IACpF,OAAO,CAAC,MAAM;IAKd;;;;OAIG;IACH,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAO7C"}

package/vue.d.ts

@@ -0,0 +1,134 @@
+// GENERATED by @c2n/framework-types. Do not edit by hand.
+//
+// Vue template types for the custom elements of @c2n/chart. Import once, anywhere in the program:
+//
+//     import '@c2n/chart/vue'
+//
+// Tell the compiler about the tags as well, or every c2-* tag is resolved as a Vue component and renders
+// nothing: template.compilerOptions.isCustomElement = (tag) => tag.startsWith('c2-') in vite.config.ts.
+
+import type { DefineComponent, HTMLAttributes } from 'vue'
+import type { AreaChart, AreaChartEventMap } from '@c2n/chart/area-chart.js'
+import type { BarChart, BarChartEventMap } from '@c2n/chart/bar-chart.js'
+import type { ChartSeries, ChartSeriesEventMap } from '@c2n/chart/chart-series.js'
+import type { LineChart, LineChartEventMap } from '@c2n/chart/line-chart.js'
+import type { PieChart, PieChartEventMap } from '@c2n/chart/pie-chart.js'
+import type { Sparkline, SparklineEventMap } from '@c2n/chart/sparkline.js'
+
+/** The element's own public properties, plus every attribute Vue understands on a host element. */
+type C2Props<T> = Partial<Omit<T, keyof HTMLElement>> & HTMLAttributes
+
+declare module 'vue' {
+  interface GlobalComponents {
+    'c2-area-chart': DefineComponent<
+      C2Props<AreaChart> & {
+        'fill-opacity'?: unknown
+        'y-min'?: unknown
+        'y-max'?: unknown
+        'x-field'?: unknown
+        'label-field'?: unknown
+        'x-type'?: unknown
+        'empty-message'?: unknown
+        'max-points'?: unknown
+        'lazy-render'?: unknown
+        onSeriesToggle?: (event: AreaChartEventMap['series-toggle']) => void
+        onRangeChange?: (event: AreaChartEventMap['range-change']) => void
+        onChartReady?: (event: AreaChartEventMap['chart-ready']) => void
+        onChartError?: (event: AreaChartEventMap['chart-error']) => void
+        onPointHover?: (event: AreaChartEventMap['point-hover']) => void
+        onPointClick?: (event: AreaChartEventMap['point-click']) => void
+      }
+    >
+    'c2-bar-chart': DefineComponent<
+      C2Props<BarChart> & {
+        'bar-width'?: unknown
+        'bar-gap'?: unknown
+        'y-min'?: unknown
+        'y-max'?: unknown
+        'x-field'?: unknown
+        'label-field'?: unknown
+        'x-type'?: unknown
+        'empty-message'?: unknown
+        'max-points'?: unknown
+        'lazy-render'?: unknown
+        onSeriesToggle?: (event: BarChartEventMap['series-toggle']) => void
+        onRangeChange?: (event: BarChartEventMap['range-change']) => void
+        onChartReady?: (event: BarChartEventMap['chart-ready']) => void
+        onChartError?: (event: BarChartEventMap['chart-error']) => void
+        onPointHover?: (event: BarChartEventMap['point-hover']) => void
+        onPointClick?: (event: BarChartEventMap['point-click']) => void
+      }
+    >
+    'c2-chart-series': DefineComponent<
+      C2Props<ChartSeries> & {
+        'line-width'?: unknown
+        'span-gaps'?: unknown
+        onSERIES_CHANGE_EVENT?: (event: ChartSeriesEventMap['SERIES_CHANGE_EVENT']) => void
+      }
+    >
+    'c2-line-chart': DefineComponent<
+      C2Props<LineChart> & {
+        'y-min'?: unknown
+        'y-max'?: unknown
+        'x-field'?: unknown
+        'label-field'?: unknown
+        'x-type'?: unknown
+        'empty-message'?: unknown
+        'max-points'?: unknown
+        'lazy-render'?: unknown
+        onSeriesToggle?: (event: LineChartEventMap['series-toggle']) => void
+        onRangeChange?: (event: LineChartEventMap['range-change']) => void
+        onChartReady?: (event: LineChartEventMap['chart-ready']) => void
+        onChartError?: (event: LineChartEventMap['chart-error']) => void
+        onPointHover?: (event: LineChartEventMap['point-hover']) => void
+        onPointClick?: (event: LineChartEventMap['point-click']) => void
+      }
+    >
+    'c2-pie-chart': DefineComponent<
+      C2Props<PieChart> & {
+        'inner-radius'?: unknown
+        'outer-radius'?: unknown
+        'start-angle'?: unknown
+        'x-field'?: unknown
+        'label-field'?: unknown
+        'x-type'?: unknown
+        'empty-message'?: unknown
+        'max-points'?: unknown
+        'lazy-render'?: unknown
+        onSeriesToggle?: (event: PieChartEventMap['series-toggle']) => void
+        onRangeChange?: (event: PieChartEventMap['range-change']) => void
+        onChartReady?: (event: PieChartEventMap['chart-ready']) => void
+        onChartError?: (event: PieChartEventMap['chart-error']) => void
+        onPointHover?: (event: PieChartEventMap['point-hover']) => void
+        onPointClick?: (event: PieChartEventMap['point-click']) => void
+      }
+    >
+    'c2-sparkline': DefineComponent<
+      C2Props<Sparkline> & {
+        'y-min'?: unknown
+        'y-max'?: unknown
+        'x-field'?: unknown
+        'label-field'?: unknown
+        'x-type'?: unknown
+        'empty-message'?: unknown
+        'max-points'?: unknown
+        'lazy-render'?: unknown
+        onSeriesToggle?: (event: SparklineEventMap['series-toggle']) => void
+        onRangeChange?: (event: SparklineEventMap['range-change']) => void
+        onChartReady?: (event: SparklineEventMap['chart-ready']) => void
+        onChartError?: (event: SparklineEventMap['chart-error']) => void
+        onPointHover?: (event: SparklineEventMap['point-hover']) => void
+        onPointClick?: (event: SparklineEventMap['point-click']) => void
+      }
+    >
+  }
+}
+
+declare module '@vue/runtime-dom' {
+  interface HTMLAttributes {
+    /** Vue's own definition omits it, and slotting a plain element into a component needs it. */
+    slot?: string
+  }
+}
+
+export {}

package/vue.js

@@ -0,0 +1,3 @@
+// GENERATED by @c2n/framework-types. Do not edit by hand.
+// Types only — see the matching .d.ts.
+export {}