minerva-design 1.3.0 → 1.4.0

package/dist/uni/manifest.js

@@ -1337,3 +1337,390 @@ export const uniComponentManifest = [
         deviceE2E: false,
     },
 ];
+/**
+ * Chart components (canvas engine of minerva-design/charts). Read by
+ * tools/generate-contracts.mjs (`*ChartManifest`): `beta` on uni-app, `n/a`
+ * for the DOM / GPU widgets, which are not exported.
+ */
+export const uniChartManifest = [
+    {
+        name: "Chart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "LineChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "AreaChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "BarChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "HorizontalBarChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "ScatterChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "QuadrantChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "CandlestickChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "HeatmapChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "Sparkline",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "RangeAreaChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "MixedChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "BubbleChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "HistogramChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "BoxPlotChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "WaterfallChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "GanttChart",
+        scope: 'Cartesian chart drawn on a `<canvas type="2d">` by the DOM-free engine: the web component props mapped to the same presets and engine options, tap / scrub tooltip, legend toggles, pinch zoom, pan and double-tap reset; hover/pointClick/plotClick/zoom events and a template ref handle (resetZoom/getView/setView/getInstance/resize).',
+        limitations: [
+            "No WebGPU / WebGL renderer and no keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/charts.test.ts", "src/named-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "PieChart",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "DonutChart",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "RadarChart",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "GaugeChart",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "FunnelChart",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "TreemapChart",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "SankeyChart",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "SunburstChart",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events and the sunburst drill event; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "RadialBarChart",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "CalendarHeatmap",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "BulletChart",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "ShapeChart",
+        scope: 'Shape chart drawn on a `<canvas type="2d">` by the DOM-free shape engine: legend toggles (controlled hidden), tap to highlight with the canvas tooltip, animations, hover/click/toggle events and the sunburst drill event; ShapeChart takes the options of any shape type.',
+        limitations: [
+            "No keyboard navigation; tooltip.render may only return text.",
+        ],
+        tests: ["src/shape-charts.test.ts"],
+        status: "partial",
+        deviceE2E: false,
+    },
+    {
+        name: "TradingChart",
+        scope: "Not exported: needs a DOM and WebGPU / WebGL (virtualized DOM panels, GPU rendering), which mini-program views do not provide.",
+        limitations: [
+            "Use a web-view page that renders the web component (minerva-design/charts) on mini-programs.",
+        ],
+        tests: ["src/named-charts.test.ts"],
+        status: "n/a",
+        deviceE2E: false,
+    },
+    {
+        name: "DepthChart",
+        scope: "Not exported: needs a DOM and WebGPU / WebGL (virtualized DOM panels, GPU rendering), which mini-program views do not provide.",
+        limitations: [
+            "Use a web-view page that renders the web component (minerva-design/charts) on mini-programs.",
+        ],
+        tests: ["src/named-charts.test.ts"],
+        status: "n/a",
+        deviceE2E: false,
+    },
+    {
+        name: "OrderBook",
+        scope: "Not exported: needs a DOM and WebGPU / WebGL (virtualized DOM panels, GPU rendering), which mini-program views do not provide.",
+        limitations: [
+            "Use a web-view page that renders the web component (minerva-design/charts) on mini-programs.",
+        ],
+        tests: ["src/named-charts.test.ts"],
+        status: "n/a",
+        deviceE2E: false,
+    },
+    {
+        name: "OrderBookHeatmap",
+        scope: "Not exported: needs a DOM and WebGPU / WebGL (virtualized DOM panels, GPU rendering), which mini-program views do not provide.",
+        limitations: [
+            "Use a web-view page that renders the web component (minerva-design/charts) on mini-programs.",
+        ],
+        tests: ["src/named-charts.test.ts"],
+        status: "n/a",
+        deviceE2E: false,
+    },
+    {
+        name: "TimeAndSales",
+        scope: "Not exported: needs a DOM and WebGPU / WebGL (virtualized DOM panels, GPU rendering), which mini-program views do not provide.",
+        limitations: [
+            "Use a web-view page that renders the web component (minerva-design/charts) on mini-programs.",
+        ],
+        tests: ["src/named-charts.test.ts"],
+        status: "n/a",
+        deviceE2E: false,
+    },
+    {
+        name: "Scatter3DChart",
+        scope: "Not exported: needs a DOM and WebGPU / WebGL (virtualized DOM panels, GPU rendering), which mini-program views do not provide.",
+        limitations: [
+            "Use a web-view page that renders the web component (minerva-design/charts) on mini-programs.",
+        ],
+        tests: ["src/named-charts.test.ts"],
+        status: "n/a",
+        deviceE2E: false,
+    },
+    {
+        name: "Surface3DChart",
+        scope: "Not exported: needs a DOM and WebGPU / WebGL (virtualized DOM panels, GPU rendering), which mini-program views do not provide.",
+        limitations: [
+            "Use a web-view page that renders the web component (minerva-design/charts) on mini-programs.",
+        ],
+        tests: ["src/named-charts.test.ts"],
+        status: "n/a",
+        deviceE2E: false,
+    },
+    {
+        name: "Bar3DChart",
+        scope: "Not exported: needs a DOM and WebGPU / WebGL (virtualized DOM panels, GPU rendering), which mini-program views do not provide.",
+        limitations: [
+            "Use a web-view page that renders the web component (minerva-design/charts) on mini-programs.",
+        ],
+        tests: ["src/named-charts.test.ts"],
+        status: "n/a",
+        deviceE2E: false,
+    },
+    {
+        name: "Line3DChart",
+        scope: "Not exported: needs a DOM and WebGPU / WebGL (virtualized DOM panels, GPU rendering), which mini-program views do not provide.",
+        limitations: [
+            "Use a web-view page that renders the web component (minerva-design/charts) on mini-programs.",
+        ],
+        tests: ["src/named-charts.test.ts"],
+        status: "n/a",
+        deviceE2E: false,
+    },
+];

package/dist/uni/named-chart-options.d.ts

@@ -0,0 +1,88 @@
+import { type BinOptions, type BoxplotGroup, type BoxplotStatsOptions, type ChartAxisOptions, type ChartCurve, type ChartOptions, type ChartOrientation, type ChartSeries, type ChartTooltipOptions, type GanttTask, type HeatmapCell, type WaterfallStep } from "./charts-canvas.js";
+import { type ChartOptionProps } from "./chart-canvas.js";
+interface SeriesProps extends ChartOptionProps {
+    series: readonly ChartSeries[];
+}
+export declare function areaChartOptions(props: SeriesProps & {
+    curve?: ChartCurve;
+    stacked?: boolean;
+    percent?: boolean;
+}): ChartOptions;
+export declare function horizontalBarChartOptions(props: SeriesProps & {
+    stacked?: boolean;
+    percent?: boolean;
+    labels?: boolean;
+}): ChartOptions;
+export declare const candlestickChartOptions: (props: SeriesProps) => ChartOptions;
+export declare const rangeAreaChartOptions: (props: SeriesProps & {
+    curve?: ChartCurve;
+}) => ChartOptions;
+export declare const mixedChartOptions: (props: SeriesProps & {
+    yAxis2?: ChartAxisOptions;
+    stackMode?: "normal" | "percent";
+    orientation?: ChartOrientation;
+}) => ChartOptions;
+export declare const bubbleChartOptions: (props: SeriesProps & {
+    minSize?: number;
+    maxSize?: number;
+    maxValue?: number;
+}) => ChartOptions;
+export declare function heatmapOptions(props: ChartOptionProps & {
+    data: readonly HeatmapCell[];
+    xCategories?: readonly string[];
+    yCategories?: readonly string[];
+    colorScale?: readonly string[];
+    valueRange?: readonly [number, number];
+    name?: string;
+    radius?: number;
+    format?: (value: number) => string;
+}): ChartOptions;
+export declare const sparklineChartOptions: (props: {
+    data: ChartSeries["data"];
+    type?: "line" | "area" | "bar";
+    color?: string;
+    curve?: ChartCurve;
+    name?: string;
+    reference?: number;
+    format?: (value: number) => string;
+    tooltip?: boolean | ChartTooltipOptions;
+    palette?: readonly string[];
+    ariaLabel?: string;
+}) => ChartOptions;
+export declare const histogramChartOptions: (props: ChartOptionProps & BinOptions & {
+    values: ArrayLike<number>;
+    name?: string;
+    color?: string;
+    formatBin?: (value: number) => string;
+    series?: readonly ChartSeries[];
+}) => ChartOptions;
+export declare const boxPlotChartOptions: (props: ChartOptionProps & BoxplotStatsOptions & {
+    series?: readonly ChartSeries[];
+    groups?: readonly BoxplotGroup[];
+    name?: string;
+    orientation?: ChartOrientation;
+}) => ChartOptions;
+export declare const waterfallChartOptions: (props: ChartOptionProps & {
+    steps: readonly WaterfallStep[];
+    name?: string;
+    upColor?: string;
+    downColor?: string;
+    totalColor?: string;
+    start?: number;
+    labels?: boolean;
+    format?: (value: number) => string;
+    locale?: string;
+    orientation?: ChartOrientation;
+}) => ChartOptions;
+export declare function ganttChartOptions(props: ChartOptionProps & {
+    tasks: readonly GanttTask[];
+    colors?: readonly string[];
+    taskName?: string;
+    progressName?: string;
+    milestoneName?: string;
+    formatProgress?: (share: number) => string;
+    locale?: string;
+    today?: boolean | number | Date;
+    todayLabel?: string;
+}, mountedAt: number): ChartOptions;
+export {};

package/dist/uni/named-chart-options.js

@@ -0,0 +1,156 @@
+// Engine options of the named cartesian charts from their props (like the
+// web components of minerva-design/charts): the presets of
+// @minerva/charts/canvas applied to plain copies of the reactive props.
+import { toRaw } from "vue";
+import { areaSeries, barSeries, boxplotData, boxplotSeries, bubbleSeries, candlestickSeries, ganttSeries, heatmapChartOptions, histogramSeries, rangeAreaSeries, sparklineOptions, waterfallSeries, } from "./charts-canvas.js";
+import { chartEngineOptions, plain, plainSeries, } from "./chart-canvas.js";
+/** Defined keys only (an undefined key would override an engine default) */
+const defined = (value) => Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+export function areaChartOptions(props) {
+    const stacked = !!props.stacked || !!props.percent;
+    return {
+        ...chartEngineOptions(props, areaSeries(plainSeries(props.series), {
+            curve: props.curve ?? "smooth",
+            stacked,
+        })),
+        ...(props.percent ? { stackMode: "percent" } : {}),
+    };
+}
+export function horizontalBarChartOptions(props) {
+    return {
+        ...chartEngineOptions(props, barSeries(plainSeries(props.series), !!props.stacked || !!props.percent, !!props.labels)),
+        orientation: "horizontal",
+        ...(props.percent ? { stackMode: "percent" } : {}),
+    };
+}
+export const candlestickChartOptions = (props) => chartEngineOptions(props, candlestickSeries(plainSeries(props.series)));
+export const rangeAreaChartOptions = (props) => chartEngineOptions(props, rangeAreaSeries(plainSeries(props.series), props.curve ?? "smooth"));
+export const mixedChartOptions = (props) => ({
+    ...chartEngineOptions(props, plainSeries(props.series)),
+    ...defined({
+        yAxis2: plain(props.yAxis2),
+        stackMode: props.stackMode,
+        orientation: props.orientation,
+    }),
+});
+export const bubbleChartOptions = (props) => chartEngineOptions(props, bubbleSeries(plainSeries(props.series), {
+    minSize: props.minSize,
+    maxSize: props.maxSize,
+    maxValue: props.maxValue,
+}));
+export function heatmapOptions(props) {
+    const base = chartEngineOptions(props, []);
+    return heatmapChartOptions({
+        data: plain(props.data),
+        xCategories: plain(props.xCategories),
+        yCategories: plain(props.yCategories),
+        colorScale: plain(props.colorScale),
+        valueRange: plain(props.valueRange),
+        name: props.name,
+        radius: props.radius,
+        format: props.format,
+    }, base);
+}
+export const sparklineChartOptions = (props) => sparklineOptions({
+    data: toRaw(props.data),
+    type: props.type,
+    color: props.color,
+    curve: props.curve,
+    name: props.name,
+    reference: props.reference,
+    format: props.format,
+}, {
+    tooltip: plain(props.tooltip),
+    palette: plain(props.palette),
+    ariaLabel: props.ariaLabel,
+});
+export const histogramChartOptions = (props) => chartEngineOptions(props, [
+    histogramSeries(toRaw(props.values), {
+        bins: props.bins,
+        domain: plain(props.domain),
+        nice: props.nice,
+        name: props.name,
+        color: props.color,
+        format: props.formatBin,
+    }),
+    ...plainSeries(props.series),
+]);
+export const boxPlotChartOptions = (props) => {
+    const groups = toRaw(props.groups);
+    return {
+        ...chartEngineOptions(props, boxplotSeries([
+            ...(groups?.length
+                ? [
+                    {
+                        id: "boxplot",
+                        name: props.name ?? "Values",
+                        data: boxplotData(groups, { whisker: props.whisker }),
+                    },
+                ]
+                : []),
+            ...plainSeries(props.series),
+        ])),
+        ...defined({ orientation: props.orientation }),
+    };
+};
+export const waterfallChartOptions = (props) => ({
+    ...chartEngineOptions(props, [
+        waterfallSeries(plain(props.steps), {
+            name: props.name,
+            upColor: props.upColor,
+            downColor: props.downColor,
+            totalColor: props.totalColor,
+            start: props.start,
+            labels: props.labels ?? true,
+            format: props.format,
+            locale: props.locale,
+        }),
+    ]),
+    ...defined({ orientation: props.orientation, locale: props.locale }),
+});
+export function ganttChartOptions(props, mountedAt) {
+    const gantt = ganttSeries(plain(props.tasks), {
+        colors: plain(props.colors),
+        taskName: props.taskName,
+        progressName: props.progressName,
+        milestoneName: props.milestoneName,
+        formatProgress: props.formatProgress,
+        locale: props.locale,
+    });
+    const today = props.today ?? false;
+    const now = today === false
+        ? null
+        : today === true
+            ? mountedAt
+            : today instanceof Date
+                ? today.getTime()
+                : today;
+    const lines = now === null
+        ? []
+        : [
+            {
+                type: "line",
+                axis: "y",
+                value: now,
+                color: "var(--danger-color, #dc2626)",
+                dash: [4, 3],
+                label: props.todayLabel,
+            },
+        ];
+    const base = chartEngineOptions(props, gantt.series);
+    return {
+        ...base,
+        ...defined({ locale: props.locale }),
+        orientation: "horizontal",
+        xAxis: { type: "category", categories: gantt.categories, ...base.xAxis },
+        yAxis: {
+            type: "time",
+            min: gantt.domain[0],
+            max: gantt.domain[1],
+            ...base.yAxis,
+        },
+        annotations: [...(base.annotations ?? []), ...lines],
+        interaction: base.interaction ?? { zoom: "y" },
+        legend: base.legend ?? gantt.series.length > 1,
+    };
+}