@dou-ui/chart 0.0.0-stage → 0.1.0-alpha.1

package/dist/types/chart.vue.d.ts

@@ -0,0 +1,24 @@
+import type { ChartExpose, ChartProps, ChartPointEvent, ChartSlots } from './types';
+type __VLS_Slots = ChartSlots;
+declare const __VLS_base: import("vue").DefineComponent<ChartProps, ChartExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (event: ChartPointEvent) => any;
+    hover: (event: ChartPointEvent | null) => any;
+    "update:table": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<ChartProps> & Readonly<{
+    onSelect?: ((event: ChartPointEvent) => any) | undefined;
+    onHover?: ((event: ChartPointEvent | null) => any) | undefined;
+    "onUpdate:table"?: ((value: boolean) => any) | undefined;
+}>, {
+    data: import(".").ChartData;
+    legend: boolean;
+    height: string | number;
+    ssrWidth: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/area.vue.d.ts

@@ -0,0 +1,16 @@
+import type { ChartAreaProps } from '../types';
+type __VLS_Props = ChartAreaProps;
+type __VLS_ModelProps = {
+    /** Turned off in the legend. */
+    'hidden'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hidden": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hidden"?: ((value: boolean) => any) | undefined;
+}>, {
+    dots: boolean | "auto";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/axis.vue.d.ts

@@ -0,0 +1,8 @@
+import type { ChartAxisProps } from '../types';
+declare const __VLS_export: import("vue").DefineComponent<ChartAxisProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartAxisProps> & Readonly<{}>, {
+    nice: boolean;
+    grid: boolean;
+    zero: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/bar.vue.d.ts

@@ -0,0 +1,14 @@
+import type { ChartBarProps } from '../types';
+type __VLS_Props = ChartBarProps;
+type __VLS_ModelProps = {
+    /** Turned off in the legend. */
+    'hidden'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hidden": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hidden"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/boxplot.vue.d.ts

@@ -0,0 +1,14 @@
+import type { ChartBoxplotProps } from '../types';
+type __VLS_Props = ChartBoxplotProps;
+type __VLS_ModelProps = {
+    /** Turned off in the legend. */
+    'hidden'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hidden": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hidden"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/brush.vue.d.ts

@@ -0,0 +1,22 @@
+import type { ChartBrushEvent, ChartBrushProps, ChartInterval } from '../types';
+type __VLS_Props = ChartBrushProps;
+type __VLS_ModelProps = {
+    /** The stretch of x selected; `null` for none. */
+    'x'?: ChartInterval | null;
+    /** The stretch of values selected; `null` for none. */
+    'y'?: ChartInterval | null;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (event: ChartBrushEvent) => any;
+    "update:x": (value: ChartInterval | null) => any;
+    "update:y": (value: ChartInterval | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSelect?: ((event: ChartBrushEvent) => any) | undefined;
+    "onUpdate:x"?: ((value: ChartInterval | null) => any) | undefined;
+    "onUpdate:y"?: ((value: ChartInterval | null) => any) | undefined;
+}>, {
+    dim: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/funnel.vue.d.ts

@@ -0,0 +1,14 @@
+import type { ChartFunnelProps } from '../types';
+type __VLS_Props = ChartFunnelProps;
+type __VLS_ModelProps = {
+    /** Turned off in the legend. */
+    'hidden'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hidden": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hidden"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/gauge.vue.d.ts

@@ -0,0 +1,17 @@
+import type { ChartGaugeProps, ChartGaugeSlots } from '../types';
+type __VLS_Slots = ChartGaugeSlots;
+declare const __VLS_base: import("vue").DefineComponent<ChartGaugeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartGaugeProps> & Readonly<{}>, {
+    max: number;
+    min: number;
+    innerRadius: number;
+    endAngle: number;
+    startAngle: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/heatmap.vue.d.ts

@@ -0,0 +1,14 @@
+import type { ChartHeatmapProps } from '../types';
+type __VLS_Props = ChartHeatmapProps;
+type __VLS_ModelProps = {
+    /** Turned off in the legend. */
+    'hidden'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hidden": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hidden"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/histogram.vue.d.ts

@@ -0,0 +1,14 @@
+import type { ChartHistogramProps } from '../types';
+type __VLS_Props = ChartHistogramProps;
+type __VLS_ModelProps = {
+    /** Turned off in the legend. */
+    'hidden'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hidden": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hidden"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/line.vue.d.ts

@@ -0,0 +1,16 @@
+import type { ChartLineProps } from '../types';
+type __VLS_Props = ChartLineProps;
+type __VLS_ModelProps = {
+    /** Turned off in the legend. */
+    'hidden'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hidden": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hidden"?: ((value: boolean) => any) | undefined;
+}>, {
+    dots: boolean | "auto";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/marker.vue.d.ts

@@ -0,0 +1,6 @@
+import type { ChartMarkerProps } from '../types';
+declare const __VLS_export: import("vue").DefineComponent<ChartMarkerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartMarkerProps> & Readonly<{}>, {
+    dashed: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/pie.vue.d.ts

@@ -0,0 +1,23 @@
+import type { ChartPieProps, ChartPieSlots } from '../types';
+type __VLS_Props = ChartPieProps;
+type __VLS_Slots = ChartPieSlots;
+type __VLS_ModelProps = {
+    /** The labels of the slices turned off in the legend. */
+    'hidden'?: string[];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hidden": (value: string[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hidden"?: ((value: string[]) => any) | undefined;
+}>, {
+    innerRadius: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/radar.vue.d.ts

@@ -0,0 +1,16 @@
+import type { ChartRadarProps } from '../types';
+type __VLS_Props = ChartRadarProps;
+type __VLS_ModelProps = {
+    /** Turned off in the legend. */
+    'hidden'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hidden": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hidden"?: ((value: boolean) => any) | undefined;
+}>, {
+    dots: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/range.vue.d.ts

@@ -0,0 +1,12 @@
+import type { ChartInterval } from '../types';
+type __VLS_ModelProps = {
+    /** The stretch of x shown; `null` for all of it. The same as `DouChartZoom`'s `v-model:x`. */
+    modelValue?: ChartInterval | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: ChartInterval | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: ChartInterval | null) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/scatter.vue.d.ts

@@ -0,0 +1,14 @@
+import type { ChartScatterProps } from '../types';
+type __VLS_Props = ChartScatterProps;
+type __VLS_ModelProps = {
+    /** Turned off in the legend. */
+    'hidden'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hidden": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hidden"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/sunburst.vue.d.ts

@@ -0,0 +1,17 @@
+import type { ChartSunburstProps, ChartSunburstSlots } from '../types';
+type __VLS_Slots = ChartSunburstSlots;
+declare const __VLS_base: import("vue").DefineComponent<ChartSunburstProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartSunburstProps> & Readonly<{}>, {
+    label: import("..").ChartAccessor;
+    labels: boolean | import("..").ChartLabelFormat;
+    value: import("..").ChartAccessor;
+    children: import("..").ChartAccessor;
+    innerRadius: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/tooltip.vue.d.ts

@@ -0,0 +1,13 @@
+import type { ChartTooltipProps, ChartTooltipSlots } from '../types';
+type __VLS_Slots = ChartTooltipSlots;
+declare const __VLS_base: import("vue").DefineComponent<ChartTooltipProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartTooltipProps> & Readonly<{}>, {
+    crosshair: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/treemap.vue.d.ts

@@ -0,0 +1,8 @@
+declare const __VLS_export: import("vue").DefineComponent<import("..").ChartTreeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("..").ChartTreeProps> & Readonly<{}>, {
+    label: import("..").ChartAccessor;
+    labels: boolean | import("..").ChartLabelFormat;
+    value: import("..").ChartAccessor;
+    children: import("..").ChartAccessor;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/waterfall.vue.d.ts

@@ -0,0 +1,16 @@
+import type { ChartWaterfallProps } from '../types';
+type __VLS_Props = ChartWaterfallProps;
+type __VLS_ModelProps = {
+    /** Turned off in the legend. */
+    'hidden'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hidden": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hidden"?: ((value: boolean) => any) | undefined;
+}>, {
+    connectors: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/zoom.vue.d.ts

@@ -0,0 +1,18 @@
+import type { ChartInterval, ChartZoomProps } from '../types';
+type __VLS_Props = ChartZoomProps;
+type __VLS_ModelProps = {
+    /** The stretch of x shown; `null` for all of it. */
+    'x'?: ChartInterval | null;
+    /** The stretch of values shown; `null` for all of them. */
+    'y'?: ChartInterval | null;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:x": (value: ChartInterval | null) => any;
+    "update:y": (value: ChartInterval | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:x"?: ((value: ChartInterval | null) => any) | undefined;
+    "onUpdate:y"?: ((value: ChartInterval | null) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/context.d.ts

@@ -0,0 +1,87 @@
+import { type InjectionKey, type Ref, type VNodeChild } from 'vue';
+import type { ChartData } from './core/data';
+import type { ChartMessages } from './locale';
+import type { ChartSeriesKind, ChartSeriesProps } from './core/series';
+import type { ChartAxisProps, ChartBrushEvent, ChartBrushProps, ChartInterval, ChartMarkerProps, ChartPieProps, ChartSunburstProps, ChartTooltipProps, ChartTooltipSlots, ChartZoomProps } from './types';
+/** A child component as the chart keeps it. */
+export interface ChartPart<P> {
+    props: P;
+    /** The child's place in the page, which orders the children as written. */
+    el: () => Node | null;
+}
+export interface SeriesPart extends ChartPart<ChartSeriesProps & Record<string, unknown>> {
+    kind: ChartSeriesKind<any>;
+    /** Turned off in the legend (`v-model:hidden`). */
+    hidden: Ref<boolean>;
+}
+export interface PiePart extends ChartPart<ChartPieProps> {
+    /** What goes in the hole of a donut. */
+    center: () => VNodeChild;
+    /** The labels of the slices turned off in the legend (`v-model:hidden`). */
+    hidden: Ref<string[]>;
+    /**
+     * For a gauge, drawn as a pie of its value and the rest of its track:
+     * the value, its range and its text. It has no legend nor tooltip.
+     */
+    gauge?: () => {
+        value: number;
+        min: number;
+        max: number;
+        text: string;
+    };
+}
+export interface TreePart extends ChartPart<ChartSunburstProps> {
+    /** A treemap fills a rectangle; a sunburst draws rings round a center. */
+    shape: 'treemap' | 'sunburst';
+    /** What goes in a sunburst's hole. */
+    center?: () => VNodeChild;
+}
+export interface TooltipPart extends ChartPart<ChartTooltipProps> {
+    /** The tooltip's slot, if one is given. */
+    content: () => ChartTooltipSlots['default'];
+}
+export type AxisPart = ChartPart<ChartAxisProps>;
+/** A stretch of x and of the values; `null` (or left out) for none. */
+export interface IntervalModels {
+    x: Ref<ChartInterval | null | undefined>;
+    y: Ref<ChartInterval | null | undefined>;
+}
+export interface ZoomPart extends ChartPart<ChartZoomProps>, IntervalModels {
+}
+export interface BrushPart extends ChartPart<ChartBrushProps>, IntervalModels {
+    /** A stretch was selected: tells the page. */
+    select: (event: ChartBrushEvent) => void;
+}
+export interface RangePart extends ChartPart<Record<string, never>> {
+    x: Ref<ChartInterval | null | undefined>;
+}
+export type MarkerPart = ChartPart<ChartMarkerProps>;
+export interface ChartRegistry {
+    addSeries(part: SeriesPart): () => void;
+    addAxis(part: AxisPart): () => void;
+    addPie(part: PiePart): () => void;
+    addTooltip(part: TooltipPart): () => void;
+    addZoom(part: ZoomPart): () => void;
+    addBrush(part: BrushPart): () => void;
+    addRange(part: RangePart): () => void;
+    addMarker(part: MarkerPart): () => void;
+    addTree(part: TreePart): () => void;
+    /** The chart's `data`, for a part that works its rows out from it (a histogram's bins). */
+    data(): ChartData | undefined;
+    /** The chart's locale, for numbers a part writes itself (a gauge's value). */
+    locale(): string;
+    /** The chart's messages, for a part that names something itself (a histogram's count). */
+    messages(): ChartMessages;
+}
+export declare const chartKey: InjectionKey<ChartRegistry>;
+/**
+ * The render of a part: it draws nothing itself. A comment in the page on
+ * the server and in the browser alike, so taking over a server-rendered
+ * page finds each part where it expects it (an empty template renders
+ * nothing at all on the server).
+ */
+export declare const renderNothing: () => null;
+/** Registers a child (a series, an axis) with the surrounding chart while it is mounted. */
+export declare function useChartPart(name: string, add: (registry: ChartRegistry) => () => void): void;
+/** The node a renderless child leaves in the page. */
+export declare function useOwnNode(): () => Node | null;

package/dist/types/core/bar.d.ts

@@ -0,0 +1,38 @@
+import type { Painter } from './painter';
+import type { ChartLabelAnchor, ChartSeries, ChartSeriesKind, ChartView } from './series';
+export interface BarStyle {
+    /** Corner radius of the bar's end, in px. */
+    radius?: number;
+    labelPosition?: 'outside' | 'inside';
+}
+/**
+ * Where a series' bars go in each x band: the offset of their near edge
+ * from the band's center, and their width, in px.
+ */
+export declare function barPlacement(band: number, slot: {
+    index: number;
+    count: number;
+} | null): {
+    offset: number;
+    width: number;
+};
+/**
+ * Draws bars from 0 (or from the slice of the stack below) to each value.
+ * The end away from 0 is rounded; in a stack, only the outermost slice's.
+ * Bars narrower than a pixel and a half are merged per pixel column into
+ * one bar from the lowest to the highest value there, which looks the
+ * same and keeps a million bars as cheap as a few hundred.
+ */
+export declare function drawBars(painter: Painter, series: ChartSeries<BarStyle>, view: ChartView, placement?: {
+    offset: number;
+    width: number;
+}): void;
+/**
+ * Where bars' labels go: past each bar's end, or in its middle (stacked
+ * bars, by default), with the bar to fit in.
+ */
+export declare function barLabels(series: ChartSeries<BarStyle>, view: ChartView, placement?: {
+    offset: number;
+    width: number;
+}): ChartLabelAnchor[];
+export declare const barKind: ChartSeriesKind<BarStyle>;

package/dist/types/core/box.d.ts

@@ -0,0 +1,25 @@
+import { type ChartAccessor, type ChartData } from './data';
+import type { ChartSeries, ChartSeriesKind } from './series';
+export interface BoxStyle {
+    /** How far whiskers reach, in box lengths past the box: `1.5` by default, `Infinity` for all the values. */
+    whisker?: number;
+}
+export interface BoxStats {
+    /** The ends of the whiskers. */
+    low: number;
+    high: number;
+    q1: number;
+    median: number;
+    q3: number;
+    /** The values past the whiskers. */
+    outliers: number[];
+    /** How many values there are. */
+    count: number;
+}
+/** Sums up a group of values; `null` when none is a number. */
+export declare function boxStats(values: unknown, whisker?: number): BoxStats | null;
+/** Each row's numbers, worked out once for the same rows, accessor and whisker. */
+export declare function boxesOf(rows: ChartData, values: ChartAccessor, whisker?: number): Array<BoxStats | null>;
+/** A box plot series' numbers by row. */
+export declare const boxes: (series: Pick<ChartSeries<BoxStyle>, "rows" | "props">) => (BoxStats | null)[];
+export declare const boxKind: ChartSeriesKind<BoxStyle>;

package/dist/types/core/colors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Canvas drawing needs real colors, while the theme speaks in CSS
+ * variables (`var(--dou-color-chart-2)`, `color-mix(…)`). A hidden probe
+ * inside the chart lets the browser work them out, as they apply there.
+ */
+export interface ColorResolver {
+    (css: string): string;
+    /** Forget what was worked out (the theme changed). */
+    clear(): void;
+}
+export declare function createColorResolver(host: () => HTMLElement | null | undefined): ColorResolver;
+/**
+ * Calls `onChange` when the page's theme may have changed: the theme
+ * attribute or class on `<html>` / `<body>`, or the system color scheme.
+ */
+export declare function observeTheme(onChange: () => void): () => void;

package/dist/types/core/data.d.ts

@@ -0,0 +1,72 @@
+/** A row of chart data: usually an object, read through accessors. */
+export type ChartRow = any;
+/**
+ * Data given by column instead of by row: a list of values for each key,
+ * all as long as each other. Typed arrays (`Float64Array`) are read
+ * fastest; a key reads its column, a function gets a row put together
+ * from all the columns.
+ */
+export type ChartColumns = Readonly<Record<string, ArrayLike<unknown>>>;
+/** Data as rows (objects), or as columns. */
+export type ChartData = readonly ChartRow[] | ChartColumns;
+/** Whether `data` is given by column. */
+export declare const byColumn: (data: ChartData) => data is ChartColumns;
+/** How many rows `data` has: the length of its first column, when by column. */
+export declare function rowCount(data: ChartData): number;
+/**
+ * Row `i` of `data`. A row of columns is put together when first asked
+ * for, and is then the same object each time.
+ */
+export declare function rowOf(data: ChartData, i: number): ChartRow;
+/**
+ * Picks a value from a row: a key of the row, or a function of the row and
+ * its index. Prefer keys for large data: a function written inline in the
+ * template is new on every render, so its column can't be cached.
+ */
+export type ChartAccessor<V = unknown> = string | ((row: ChartRow, index: number) => V);
+/** How x values are read: numbers, points in time (ms), or categories. */
+export type XKind = 'linear' | 'time' | 'category';
+export interface XColumn {
+    kind: XKind;
+    /** Numbers, times in ms, or the index of each row's category in `categories`. */
+    values: Float64Array;
+    /** For `category`: the categories in the order they first appear. */
+    categories: string[];
+    /** Whether `values` never go down, so the visible part can be found by bisection. */
+    sorted: boolean;
+}
+/**
+ * A point in time in ms, or `NaN`. Dates without a zone (`'2026-10-31'`,
+ * `'2026-10-31 09:30'`) are read in local time, the way people write them.
+ */
+export declare function toTime(value: unknown): number;
+/** Reads `accessor` from `row`. */
+export declare function read(row: ChartRow, accessor: ChartAccessor, index: number): unknown;
+/** Places rows by their index when there is no x. */
+export declare const byIndex: ChartAccessor;
+/** Guesses how x values are meant from the first one that is there. */
+export declare function inferXKind(rows: ChartData, accessor: ChartAccessor): XKind;
+/**
+ * How `rows` carries on from `before`: how many rows of `before` are gone
+ * from its start (`dropped`) and how many are kept (`kept`, the start of
+ * `rows`). `null` when it doesn't carry on from it.
+ */
+export declare function carriesOn(rows: readonly ChartRow[], before: readonly ChartRow[]): {
+    dropped: number;
+    kept: number;
+} | null;
+/**
+ * The x values of `rows` as one typed array. Built once per data array,
+ * accessor and kind: replace the array (don't change it in place) for the
+ * chart to see new data.
+ */
+export declare function xColumn(rows: ChartData, accessor: ChartAccessor, kind: XKind): XColumn;
+/**
+ * The y values of `rows` as one typed array; anything that isn't a finite
+ * number (`null`, a gap) is `NaN`.
+ */
+export declare function yColumn(rows: ChartData, accessor: ChartAccessor): Float64Array;
+/** The smallest and largest number in `values` (skipping `NaN`), or `null`. */
+export declare function extent(values: ArrayLike<number>, from?: number, to?: number): [number, number] | null;
+/** The first index whose value is `>= target`, in a sorted array (`NaN`s aside). */
+export declare function bisect(values: ArrayLike<number>, target: number, lo?: number, hi?: number): number;

package/dist/types/core/decimate.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Picks the points worth drawing. A pixel column can't show more than its
+ * first, lowest, highest and last point, so a line of a million points is
+ * drawn from at most four per column and looks exactly the same.
+ */
+/** Marks a break in the line: a gap in the data. */
+export declare const BREAK = -1;
+interface Level {
+    /** Points per block. */
+    size: number;
+    /** The row of the lowest and the highest y in each block. */
+    low: Int32Array;
+    high: Int32Array;
+    /** Whether a block has a gap (a `NaN` x or y). */
+    gap: Uint8Array;
+}
+/** Makes the summaries of a sorted line long enough to need them, finest first. */
+export declare function summarize(xs: Float64Array, ys: Float64Array): Level[] | null;
+/**
+ * The indices from `from` to `to` (exclusive) to draw, in order, with
+ * `BREAK` between runs that a gap (a `NaN` y) splits. With `connect`, gaps
+ * are skipped instead. Columns are whole pixels of the x scale `x * k + b`.
+ *
+ * The returned array is reused by the next call: use it before calling again.
+ */
+export declare function decimate(xs: Float64Array, ys: Float64Array, from: number, to: number, 
+/** Pixel of x is `x * k + b`. */
+k: number, b: number, connect?: boolean, 
+/** Whether `xs` goes up from start to end: long lines can then skip whole blocks. */
+sorted?: boolean): {
+    indices: Int32Array;
+    length: number;
+};
+/**
+ * The part of a sorted x column that is on screen, widened by one point on
+ * each side so lines run to the edge.
+ */
+export declare function visibleRange(xs: ArrayLike<number>, sorted: boolean, lo: number, hi: number): [number, number];
+export {};