minerva-design 1.3.0 → 1.5.0

package/dist/uni/shape-chart-types.js

@@ -0,0 +1,305 @@
+// Booleans default to `undefined` (not Vue's `false`) so the engine
+// defaults apply when they are omitted.
+/** Size and scrolling of every shape chart */
+export const shapeFrameProps = {
+    /** Height of the chart (the legend included); numbers are pixels, strings any CSS length (rpx included) */
+    height: { type: [Number, String], default: 320 },
+    /** Width of the chart; numbers are pixels */
+    width: {
+        type: [Number, String],
+        default: "100%",
+    },
+    /** Keeps the page from scrolling while a finger moves on the chart */
+    disableScroll: { type: Boolean, default: undefined },
+};
+/** Props shared by PieChart, DonutChart, RadarChart, GaugeChart, FunnelChart and TreemapChart */
+export const shapeCommonProps = {
+    ...shapeFrameProps,
+    /** Colors of the marks without `color` (defaults to the `--chart-series-1..8` tokens) */
+    palette: Array,
+    /** Legend; tapping an item hides / shows its slice, stage or series */
+    legend: {
+        type: [Boolean, Object],
+        default: undefined,
+    },
+    /** Tooltip drawn on the canvas; `false` disables it (`render` may return a string) */
+    tooltip: {
+        type: [Boolean, Object],
+        default: undefined,
+    },
+    /** Formats the values of the labels and the tooltip (compact numbers by default) */
+    format: Function,
+    /** Formats the shares (0-1) of the labels and the tooltip (one decimal by default) */
+    percentFormat: Function,
+    /** Hidden entries by index (controlled: legend taps then only emit `toggle`) */
+    hidden: Array,
+    /** Entry and update animations (default `true`) */
+    animation: { type: Boolean, default: undefined },
+    /** Space around the drawing, in pixels (default 8 on every side) */
+    padding: Object,
+    /** Accessible name of the chart (default: the chart type, e.g. "Donut chart") */
+    ariaLabel: String,
+    /**
+     * Locale of the built-in texts and of the numbers (tooltip rows, "No data").
+     * Mini-programs have no `<html lang>`: pass the app language (default: the
+     * system language when the runtime has `navigator.language`, else English)
+     */
+    locale: String,
+    /** Overrides of the built-in texts of the `locale` */
+    texts: Object,
+};
+/** Props of PieChart / DonutChart (besides the common ones) */
+export const pieChartProps = {
+    /** Slices: a name, a value and an optional color */
+    data: { type: Array, required: true },
+    /** Inner radius as a fraction of the outer radius: 0 = pie (DonutChart: 0.62) */
+    innerRadius: Number,
+    /** Angle of the first slice, degrees clockwise from 12 o'clock */
+    startAngle: Number,
+    /** Gap between the slices, in pixels */
+    padAngle: Number,
+    /** Corner radius of the slices, in pixels */
+    cornerRadius: Number,
+    /** Nightingale rose: the radius shows the value */
+    rose: { type: Boolean, default: undefined },
+    /** Slice labels: outside with leader lines, inside the slices, or none */
+    labels: String,
+    /** What a label shows: name, value, percent */
+    labelContent: Array,
+    /** Big text in the hole of a donut */
+    centerValue: String,
+    /** Small text under `centerValue` */
+    centerLabel: String,
+};
+/** Props of RadarChart (besides the common ones) */
+export const radarChartProps = {
+    /** Axes of the chart, clockwise from 12 o'clock */
+    indicators: {
+        type: Array,
+        required: true,
+    },
+    /** Polygons: one value per indicator */
+    series: { type: Array, required: true },
+    /** Grid shape (default "polygon") */
+    shape: String,
+    /** Number of grid rings (default 4) */
+    levels: Number,
+    /** Dots on the vertices (default `true`) */
+    dots: { type: Boolean, default: undefined },
+};
+/** Props of GaugeChart (besides the common ones) */
+export const gaugeChartProps = {
+    /** Value shown by the arc */
+    value: { type: Number, required: true },
+    /** Value at the start of the arc (default 0) */
+    min: Number,
+    /** Value at the end of the arc (default 100) */
+    max: Number,
+    /** Caption under the value */
+    label: String,
+    /** Total angle of the arc, degrees (default 240) */
+    sweep: Number,
+    /** Thickness of the arc as a fraction of the radius (default 0.16) */
+    thickness: Number,
+    /** Colored ranges of the track */
+    bands: Array,
+    /** Color of the value arc (when there are no bands) */
+    color: String,
+    /** Draws a needle (default `false`) */
+    needle: { type: Boolean, default: undefined },
+    /** Tick labels at the ends and at the band bounds (default `true`) */
+    ticks: { type: Boolean, default: undefined },
+};
+/** Props of FunnelChart (besides the common ones) */
+export const funnelChartProps = {
+    /** Stages: a name, a value and an optional color */
+    data: { type: Array, required: true },
+    /** Order of the stages (default "none": data order) */
+    sort: String,
+    /** Vertical gap between the stages, in pixels (default 4) */
+    gap: Number,
+    /** Shows the conversion rate from the previous stage (default `true`) */
+    conversion: { type: Boolean, default: undefined },
+    /** Trapezoids that narrow to the next stage, or centered bars */
+    shape: String,
+};
+/** Props of TreemapChart (besides the common ones) */
+export const treemapChartProps = {
+    /** Nodes: leaves carry a value, parents sum their children */
+    data: { type: Array, required: true },
+    /** Gap between the cells, in pixels (default 2) */
+    gap: Number,
+    /** Draws the names of the parents above their children (default `true`) */
+    headers: { type: Boolean, default: undefined },
+};
+/** Props of SankeyChart (besides the common ones) */
+export const sankeyChartProps = {
+    /** Nodes, in their initial order; nodes only named by a link are appended */
+    nodes: Array,
+    /** Flows between the nodes (by name or index); links closing a cycle are ignored */
+    links: { type: Array, required: true },
+    /** Width of the node bars, in pixels (default 12) */
+    nodeWidth: Number,
+    /** Vertical gap between the nodes of a column, in pixels (default 12) */
+    nodePadding: Number,
+    /** Column of the nodes without a `column` (default "justify") */
+    align: String,
+    /** Relaxation passes that straighten the flows (default 32) */
+    iterations: Number,
+    /** Color of the links without `color` (default "gradient") */
+    linkColor: String,
+    /** Opacity of the links, 0-1 (default 0.4) */
+    linkOpacity: Number,
+    /** Node labels (default `true`) */
+    labels: { type: Boolean, default: undefined },
+    /** Shows the value after the name in the labels (default `true`) */
+    labelValues: { type: Boolean, default: undefined },
+};
+/** Props of SunburstChart (besides the common ones) */
+export const sunburstChartProps = {
+    /** Nodes: leaves carry a value, parents sum their children */
+    data: { type: Array, required: true },
+    /** Radius of the center circle as a fraction of the outer radius (default 0.26) */
+    innerRadius: Number,
+    /** Rings shown at once below the focused node (default every level) */
+    levels: Number,
+    /** Angle of the first node, degrees clockwise from 12 o'clock (default 0) */
+    startAngle: Number,
+    /** Gap between the sectors, in pixels (default 1) */
+    padAngle: Number,
+    /** Corner radius of the sectors, in pixels (default 2) */
+    cornerRadius: Number,
+    /** Sector labels (default "auto") */
+    labels: String,
+    /** Tapping a parent zooms into it, the center goes back up (default `true`) */
+    drill: { type: Boolean, default: undefined },
+    /** Names from the root to the focused node; makes the drill-down controlled (listen to `drill`) */
+    drillPath: Array,
+};
+/** Props of RadialBarChart (besides the common ones) */
+export const radialBarChartProps = {
+    /** Bars, from the outermost ring inward: a name, a value, an optional `max` and color */
+    data: { type: Array, required: true },
+    /** Value of a full bar for the data without `max` (default the largest value) */
+    max: Number,
+    /** Radius of the innermost ring's inner edge, as a fraction of the outer radius (default 0.3) */
+    innerRadius: Number,
+    /** Angle where the bars start, degrees clockwise from 12 o'clock (default 0) */
+    startAngle: Number,
+    /** Angle of a full bar, degrees (default 270) */
+    sweep: Number,
+    /** Gap between the rings, as a fraction of a ring's slot (default 0.28) */
+    gap: Number,
+    /** Background tracks behind the bars (default `true`) */
+    track: { type: Boolean, default: undefined },
+    /** Rounded bar ends (default `true`) */
+    rounded: { type: Boolean, default: undefined },
+    /** Labels before the start of the bars */
+    labels: { type: Boolean, default: undefined },
+    /** What a label shows: name, value, percent (default ["name", "value"]) */
+    labelContent: Array,
+    /** Big text in the center */
+    centerValue: String,
+    /** Small text under `centerValue` */
+    centerLabel: String,
+};
+/** Props of CalendarHeatmap (besides the common ones) */
+export const calendarHeatmapProps = {
+    /** Daily values (several entries of the same day add up) */
+    data: { type: Array, required: true },
+    /** Days shown: a year (`2026`) or an inclusive `[start, end]` range */
+    range: [Number, Array],
+    /** `weeks` (default) or `months` */
+    layout: String,
+    /** First day of the week, 0 = Sunday … 6 = Saturday (default from `locale`) */
+    weekStart: Number,
+    /** BCP 47 locale of the month and weekday names and of the tooltip dates */
+    locale: String,
+    /** Color of the highest level (default the first palette color) */
+    color: String,
+    /** Colors of the levels, lowest first */
+    colors: Array,
+    /** Number of color levels above the empty days (default 4) */
+    levels: Number,
+    /** Upper bounds of the levels but the last, ascending */
+    thresholds: Array,
+    /** Gap between the cells, in pixels (default 3) */
+    gap: Number,
+    /** Corner radius of the cells, in pixels (default 2) */
+    radius: Number,
+    /** Largest cell size, in pixels (default 16 weeks, 28 months) */
+    maxCellSize: Number,
+    /** Month names around the cells (default `true`) */
+    monthLabels: { type: Boolean, default: undefined },
+    /** Weekday names beside or above the cells (default `true`) */
+    weekdayLabels: { type: Boolean, default: undefined },
+};
+/** Props of BulletChart (besides the common ones) */
+export const bulletChartProps = {
+    /** Rows (columns when vertical): name, value, target, ranges and scale */
+    data: { type: Array, required: true },
+    /** Horizontal rows (default) or vertical columns */
+    orientation: String,
+    /** Qualitative ranges of the rows without `ranges`: upper bounds, ascending */
+    ranges: Array,
+    /** Names of the qualitative ranges, lowest first (tooltip) */
+    rangeLabels: Array,
+    /** Colors of the qualitative ranges, lowest first */
+    rangeColors: Array,
+    /** Thickness of the value bar as a fraction of the ranges' thickness (default 0.4) */
+    barSize: Number,
+    /** Color of the target markers (default the text color) */
+    targetColor: String,
+    /** Tick labels of the scales (default `true`) */
+    ticks: { type: Boolean, default: undefined },
+};
+/** Props of ChordChart (besides the common ones) */
+export const chordChartProps = {
+    /** Groups (names or `{ name, color }`) in their order around the circle; groups only named by `links` are appended */
+    groups: Array,
+    /** Square flow matrix: `matrix[i][j]` flows from group `i` to group `j` (used when `links` is absent) */
+    matrix: Array,
+    /** Flows as a list (by group name or index); takes precedence over `matrix` */
+    links: Array,
+    /** One ribbon per direction, arcs sized by the outgoing plus the incoming flows (default `false`) */
+    directed: { type: Boolean, default: undefined },
+    /** Arrowheads at the target end of the ribbons (default `true` when `directed`) */
+    arrows: { type: Boolean, default: undefined },
+    /** Gap between the groups, in degrees (default 2) */
+    padAngle: Number,
+    /** Angle of the first group, degrees clockwise from 12 o'clock (default 0) */
+    startAngle: Number,
+    /** Order of the groups around the circle (default "none") */
+    sortGroups: String,
+    /** Order of the ribbon ends along an arc (default "auto": fewest crossings) */
+    sortSubgroups: String,
+    /** Color of the ribbons without `color` (default "gradient") */
+    ribbonColor: String,
+    /** Opacity of the ribbons, 0-1 (default 0.65) */
+    ribbonOpacity: Number,
+    /** Thickness of the group arcs, in pixels (default 6% of the radius, 8-18 px) */
+    arcWidth: Number,
+    /** Value ticks outside the arcs; a number sets the step (default `true` when large enough) */
+    ticks: {
+        type: [Boolean, Number],
+        default: undefined,
+    },
+    /** Formats the tick labels (default compact numbers of the `locale`) */
+    tickFormat: Function,
+    /** Group labels along the arc or the radius (default "auto") */
+    labels: String,
+};
+/** Height computed from the type and the data when the `height` prop is omitted */
+export const autoHeightProp = {
+    /** Height of the chart; numbers are pixels, strings any CSS length (rpx included); computed from the type / data by default */
+    height: {
+        type: [Number, String],
+        default: undefined,
+    },
+};
+/** Props of ShapeChart (any shape type of the engine) */
+export const shapeChartProps = {
+    ...shapeFrameProps,
+    /** Options of the chart, by `type` (pie, radar, gauge, funnel, treemap...) */
+    options: { type: Object, required: true },
+};

package/dist/vue/charts-global.d.ts

@@ -0,0 +1,48 @@
+import type * as Minerva from "./charts.js";
+declare module "vue" {
+    interface GlobalComponents {
+        MnAreaChart: typeof Minerva.AreaChart;
+        MnBar3DChart: typeof Minerva.Bar3DChart;
+        MnBarChart: typeof Minerva.BarChart;
+        MnBoxPlotChart: typeof Minerva.BoxPlotChart;
+        MnBubbleChart: typeof Minerva.BubbleChart;
+        MnBulletChart: typeof Minerva.BulletChart;
+        MnCalendarHeatmap: typeof Minerva.CalendarHeatmap;
+        MnCandlestickChart: typeof Minerva.CandlestickChart;
+        MnChart: typeof Minerva.Chart;
+        MnChordChart: typeof Minerva.ChordChart;
+        MnDependencyGraph: typeof Minerva.DependencyGraph;
+        MnDepthChart: typeof Minerva.DepthChart;
+        MnDonutChart: typeof Minerva.DonutChart;
+        MnFunnelChart: typeof Minerva.FunnelChart;
+        MnGanttChart: typeof Minerva.GanttChart;
+        MnGaugeChart: typeof Minerva.GaugeChart;
+        MnGraphChart: typeof Minerva.GraphChart;
+        MnHeatmapChart: typeof Minerva.HeatmapChart;
+        MnHistogramChart: typeof Minerva.HistogramChart;
+        MnHorizontalBarChart: typeof Minerva.HorizontalBarChart;
+        MnLine3DChart: typeof Minerva.Line3DChart;
+        MnLineChart: typeof Minerva.LineChart;
+        MnMixedChart: typeof Minerva.MixedChart;
+        MnOrderBook: typeof Minerva.OrderBook;
+        MnOrderBookHeatmap: typeof Minerva.OrderBookHeatmap;
+        MnPieChart: typeof Minerva.PieChart;
+        MnQuadrantChart: typeof Minerva.QuadrantChart;
+        MnRadarChart: typeof Minerva.RadarChart;
+        MnRadialBarChart: typeof Minerva.RadialBarChart;
+        MnRangeAreaChart: typeof Minerva.RangeAreaChart;
+        MnSankeyChart: typeof Minerva.SankeyChart;
+        MnScatter3DChart: typeof Minerva.Scatter3DChart;
+        MnScatterChart: typeof Minerva.ScatterChart;
+        MnShapeChart: typeof Minerva.ShapeChart;
+        MnSparkline: typeof Minerva.Sparkline;
+        MnSunburstChart: typeof Minerva.SunburstChart;
+        MnSurface3DChart: typeof Minerva.Surface3DChart;
+        MnTimeAndSales: typeof Minerva.TimeAndSales;
+        MnTradingChart: typeof Minerva.TradingChart;
+        MnTreeChart: typeof Minerva.TreeChart;
+        MnTreemapChart: typeof Minerva.TreemapChart;
+        MnWaterfallChart: typeof Minerva.WaterfallChart;
+    }
+}
+export {};

package/dist/vue/charts.d.ts

@@ -0,0 +1,18 @@
+import { App, Component } from 'vue';
+import { MinervaVueOptions } from './plugin.js';
+export * from './groups/charts.js';
+/** Options of the `MinervaVueCharts` plugin (same as `MinervaVue`) */
+export type MinervaVueChartsOptions = MinervaVueOptions;
+/** Every chart component registered by `MinervaVueCharts`, by export name */
+export declare function chartComponents(): Record<string, Component>;
+/**
+ * Vue plugin registering the chart components globally:
+ * `app.use(MinervaVueCharts)` -> `<MnLineChart>`, `<MnPieChart>`... (add
+ * `"types": ["minerva-design/vue/charts-global"]` to tsconfig for Volar
+ * typings). Named imports (`import { LineChart } from
+ * "minerva-design/vue/charts"`) need no plugin.
+ */
+export declare const MinervaVueCharts: {
+    install(app: App, options?: MinervaVueChartsOptions): void;
+};
+export default MinervaVueCharts;

package/dist/vue/charts.js

@@ -0,0 +1,56 @@
+import { useChartEngine as e } from "./components/Chart/engine.js";
+import t from "./components/Chart/Chart.vue.js";
+import n from "./components/Chart/LineChart.vue.js";
+import r from "./components/Chart/AreaChart.vue.js";
+import i from "./components/Chart/BarChart.vue.js";
+import a from "./components/Chart/ScatterChart.vue.js";
+import o from "./components/Chart/CandlestickChart.vue.js";
+import s from "./components/Chart/HeatmapChart.vue.js";
+import c from "./components/Chart/Sparkline.vue.js";
+import l from "./components/Chart/QuadrantChart.vue.js";
+import u from "./components/Chart/ShapeChart.vue.js";
+import d from "./components/Chart/PieChart.vue.js";
+import f from "./components/Chart/DonutChart.vue.js";
+import p from "./components/Chart/RadarChart.vue.js";
+import m from "./components/Chart/GaugeChart.vue.js";
+import h from "./components/Chart/FunnelChart.vue.js";
+import g from "./components/Chart/TreemapChart.vue.js";
+import _ from "./components/Chart/HorizontalBarChart.vue.js";
+import v from "./components/Chart/RangeAreaChart.vue.js";
+import y from "./components/Chart/MixedChart.vue.js";
+import b from "./components/Chart/BubbleChart.vue.js";
+import x from "./components/Chart/HistogramChart.vue.js";
+import S from "./components/Chart/BoxPlotChart.vue.js";
+import C from "./components/Chart/WaterfallChart.vue.js";
+import w from "./components/Chart/GanttChart.vue.js";
+import T from "./components/Chart/SankeyChart.vue.js";
+import E from "./components/Chart/SunburstChart.vue.js";
+import D from "./components/Chart/RadialBarChart.vue.js";
+import O from "./components/Chart/CalendarHeatmap.vue.js";
+import k from "./components/Chart/BulletChart.vue.js";
+import A from "./components/Chart/TradingChart.vue.js";
+import j from "./components/Chart/DepthChart.vue.js";
+import M from "./components/Chart/OrderBook.vue.js";
+import N from "./components/Chart/OrderBookHeatmap.vue.js";
+import P from "./components/Chart/TimeAndSales.vue.js";
+import F from "./components/Chart/Scatter3DChart.vue.js";
+import I from "./components/Chart/Line3DChart.vue.js";
+import L from "./components/Chart/Surface3DChart.vue.js";
+import R from "./components/Chart/Bar3DChart.vue.js";
+import z from "./components/Chart/ChordChart.vue.js";
+import B from "./components/Chart/GraphChart.vue.js";
+import V from "./components/Chart/DependencyGraph.vue.js";
+import H from "./components/Chart/TreeChart.vue.js";
+import { charts_exports as U } from "./groups/charts.js";
+import { collectComponents as W, registerComponents as G } from "./internal/register.js";
+//#region src/charts.ts
+function K() {
+	return W([U]);
+}
+var q = { install(e, t = {}) {
+	G(e, K(), t.prefix);
+} };
+//#endregion
+export { r as AreaChart, R as Bar3DChart, i as BarChart, S as BoxPlotChart, b as BubbleChart, k as BulletChart, O as CalendarHeatmap, o as CandlestickChart, t as Chart, z as ChordChart, V as DependencyGraph, j as DepthChart, f as DonutChart, h as FunnelChart, w as GanttChart, m as GaugeChart, B as GraphChart, s as HeatmapChart, x as HistogramChart, _ as HorizontalBarChart, I as Line3DChart, n as LineChart, q as MinervaVueCharts, q as default, y as MixedChart, M as OrderBook, N as OrderBookHeatmap, d as PieChart, l as QuadrantChart, p as RadarChart, D as RadialBarChart, v as RangeAreaChart, T as SankeyChart, F as Scatter3DChart, a as ScatterChart, u as ShapeChart, c as Sparkline, E as SunburstChart, L as Surface3DChart, P as TimeAndSales, A as TradingChart, H as TreeChart, g as TreemapChart, C as WaterfallChart, K as chartComponents, e as useChartEngine };
+
+//# sourceMappingURL=charts.js.map

package/dist/vue/charts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"charts.js","names":["charts","Chart_default","LineChart_default","AreaChart_default","BarChart_default","ScatterChart_default","CandlestickChart_default","HeatmapChart_default","Sparkline_default","QuadrantChart_default","ShapeChart_default","PieChart_default","DonutChart_default","RadarChart_default","GaugeChart_default","FunnelChart_default","TreemapChart_default","HorizontalBarChart_default","RangeAreaChart_default","MixedChart_default","BubbleChart_default","HistogramChart_default","BoxPlotChart_default","WaterfallChart_default","GanttChart_default","SankeyChart_default","SunburstChart_default","RadialBarChart_default","CalendarHeatmap_default","BulletChart_default","TradingChart_default","DepthChart_default","OrderBook_default","OrderBookHeatmap_default","TimeAndSales_default","Scatter3DChart_default","Line3DChart_default","Surface3DChart_default","Bar3DChart_default","ChordChart_default","GraphChart_default","DependencyGraph_default","TreeChart_default","chartComponents","collectComponents","charts_exports","MinervaVueCharts","app","options","useChartEngine"],"sources":["../../../vue/src/charts.ts"],"sourcesContent":["// minerva-design/vue/charts: the chart components of the Vue renderer\n// (thin wrappers of the engine of minerva-design/charts/core) and the opt-in\n// `MinervaVueCharts` plugin registering them globally. Kept out of the\n// `MinervaVue` plugin so that apps without charts never load the engine.\nimport type { App, Component } from \"vue\";\nimport * as charts from \"./groups/charts\";\nimport { collectComponents, registerComponents } from \"./internal/register\";\nimport type { MinervaVueOptions } from \"./plugin\";\n\nexport * from \"./groups/charts\";\n\n/** Options of the `MinervaVueCharts` plugin (same as `MinervaVue`) */\nexport type MinervaVueChartsOptions = MinervaVueOptions;\n\n/** Every chart component registered by `MinervaVueCharts`, by export name */\nexport function chartComponents(): Record<string, Component> {\n  return collectComponents([charts]);\n}\n\n/**\n * Vue plugin registering the chart components globally:\n * `app.use(MinervaVueCharts)` -> `<MnLineChart>`, `<MnPieChart>`... (add\n * `\"types\": [\"minerva-design/vue/charts-global\"]` to tsconfig for Volar\n * typings). Named imports (`import { LineChart } from\n * \"minerva-design/vue/charts\"`) need no plugin.\n */\nexport const MinervaVueCharts = {\n  install(app: App, options: MinervaVueChartsOptions = {}): void {\n    registerComponents(app, chartComponents(), options.prefix);\n  },\n};\n\nexport default MinervaVueCharts;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeA,SAAgB2C,IAA6C;CAC3D,OAAOC,EAAkB,CAAC5C,CAAM,CAAC;AACnC;AASA,IAAa8C,IAAmB,EAC9B,QAAQ,GAAU,IAAmC,CAAC,GAAS;CAC7D,EAAmBC,GAAKJ,EAAgB,GAAGK,EAAQ,MAAM;AAC3D,EACF"}

package/dist/vue/components/Chart/AreaChart.vue.d.ts

@@ -0,0 +1,124 @@
+import { PropType } from 'vue';
+import { ChartCurve, ChartHoverEvent, ChartPlotClickEvent, ChartRendererKind, ChartView } from '../../../charts/core.js';
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** Shape of the edges: straight, smooth (monotone) or steps (default `smooth`) */
+    curve: {
+        type: PropType<ChartCurve>;
+        default: string;
+    };
+    stacked: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    percent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    series: {
+        readonly type: PropType<readonly import('../../../charts/core.js').ChartSeries[]>;
+        readonly required: true;
+    };
+    xAxis: PropType<import('../../../charts/core.js').ChartAxisOptions>;
+    yAxis: PropType<import('../../../charts/core.js').ChartAxisOptions>;
+    renderer: PropType<import('../../../charts/core.js').ChartRendererPreference>;
+    legend: {
+        type: PropType<boolean | import('../../../charts/core.js').ChartLegendOptions>;
+        default: undefined;
+    };
+    tooltip: {
+        type: PropType<boolean | import('../../../charts/core.js').ChartTooltipOptions>;
+        default: undefined;
+    };
+    crosshair: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    annotations: PropType<readonly import('../../../charts/core.js').ChartAnnotation[]>;
+    interaction: {
+        type: PropType<boolean | import('../../../charts/core.js').ChartInteractionOptions>;
+        default: undefined;
+    };
+    padding: PropType<import('../../../charts/core.js').ChartPadding>;
+    palette: PropType<readonly string[]>;
+    ariaLabel: StringConstructor;
+    locale: StringConstructor;
+    labels: PropType<import('../../../charts/core.js').ChartOptions["labels"]>;
+    height: PropType<number | string>;
+    width: PropType<number | string>;
+    deep: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, import('./types.js').ChartHandle, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    zoom: (view: ChartView) => any;
+    hover: (event: ChartHoverEvent | null) => any;
+    plotClick: (event: ChartPlotClickEvent) => any;
+    pointClick: (event: ChartHoverEvent) => any;
+    rendererChange: (renderer: ChartRendererKind) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** Shape of the edges: straight, smooth (monotone) or steps (default `smooth`) */
+    curve: {
+        type: PropType<ChartCurve>;
+        default: string;
+    };
+    stacked: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    percent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    series: {
+        readonly type: PropType<readonly import('../../../charts/core.js').ChartSeries[]>;
+        readonly required: true;
+    };
+    xAxis: PropType<import('../../../charts/core.js').ChartAxisOptions>;
+    yAxis: PropType<import('../../../charts/core.js').ChartAxisOptions>;
+    renderer: PropType<import('../../../charts/core.js').ChartRendererPreference>;
+    legend: {
+        type: PropType<boolean | import('../../../charts/core.js').ChartLegendOptions>;
+        default: undefined;
+    };
+    tooltip: {
+        type: PropType<boolean | import('../../../charts/core.js').ChartTooltipOptions>;
+        default: undefined;
+    };
+    crosshair: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    annotations: PropType<readonly import('../../../charts/core.js').ChartAnnotation[]>;
+    interaction: {
+        type: PropType<boolean | import('../../../charts/core.js').ChartInteractionOptions>;
+        default: undefined;
+    };
+    padding: PropType<import('../../../charts/core.js').ChartPadding>;
+    palette: PropType<readonly string[]>;
+    ariaLabel: StringConstructor;
+    locale: StringConstructor;
+    labels: PropType<import('../../../charts/core.js').ChartOptions["labels"]>;
+    height: PropType<number | string>;
+    width: PropType<number | string>;
+    deep: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onZoom?: ((view: ChartView) => any) | undefined;
+    onHover?: ((event: ChartHoverEvent | null) => any) | undefined;
+    onPlotClick?: ((event: ChartPlotClickEvent) => any) | undefined;
+    onPointClick?: ((event: ChartHoverEvent) => any) | undefined;
+    onRendererChange?: ((renderer: ChartRendererKind) => any) | undefined;
+}>, {
+    tooltip: boolean | import('../../../charts/core.js').ChartTooltipOptions;
+    legend: boolean | import('../../../charts/core.js').ChartLegendOptions;
+    crosshair: boolean;
+    stacked: boolean;
+    percent: boolean;
+    deep: boolean;
+    curve: ChartCurve;
+    interaction: boolean | import('../../../charts/core.js').ChartInteractionOptions;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/vue/components/Chart/AreaChart.vue.js

@@ -0,0 +1,7 @@
+import e from "./AreaChart.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/Chart/AreaChart.vue
+var t = e;
+//#endregion
+export { t as default };
+
+//# sourceMappingURL=AreaChart.vue.js.map

package/dist/vue/components/Chart/AreaChart.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AreaChart.vue.js","names":["_sfc_main","AreaChart_vue_vue_type_script_setup_true_lang_default","AreaChart_default"],"sources":["../../../../../vue/src/components/Chart/AreaChart.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport type { PropType } from \"vue\";\nimport type {\n  ChartCurve,\n  ChartHoverEvent,\n  ChartPlotClickEvent,\n  ChartRendererKind,\n  ChartView,\n} from \"minerva-design/charts/core\";\nimport { engineOptions, useCartesianChart, withSeriesType } from \"./cartesian\";\nimport {\n  chartAxisProps,\n  chartCommonProps,\n  chartSeriesProps,\n  chartStackProps,\n} from \"./props\";\n\n/** Area chart: smooth by default, stacked or 100% stacked */\ndefineOptions({ name: \"AreaChart\" });\nconst props = defineProps({\n  ...chartCommonProps,\n  ...chartAxisProps,\n  ...chartSeriesProps,\n  ...chartStackProps,\n  /** Shape of the edges: straight, smooth (monotone) or steps (default `smooth`) */\n  curve: { type: String as PropType<ChartCurve>, default: \"smooth\" },\n});\nconst emit = defineEmits<{\n  /** The hovered (or keyboard-focused) points changed (`null`: none) */\n  hover: [event: ChartHoverEvent | null];\n  /** A point was clicked */\n  pointClick: [event: ChartHoverEvent];\n  /** The plot area was clicked where there is no point */\n  plotClick: [event: ChartPlotClickEvent];\n  /** The user zoomed or panned */\n  zoom: [view: ChartView];\n  /** The backend is ready (or fell back after a GPU loss) */\n  rendererChange: [renderer: ChartRendererKind];\n}>();\nconst { setContainer, rootStyle, handle } = useCartesianChart(\n  props,\n  () =>\n    engineOptions(\n      props,\n      withSeriesType(\n        props.series,\n        \"area\",\n        props.stacked || props.percent ? \"stack\" : undefined,\n        props.curve,\n      ),\n      props.percent ? \"percent\" : undefined,\n    ),\n  {\n    hover: (event) => emit(\"hover\", event),\n    click: (event) => emit(\"pointClick\", event),\n    plotClick: (event) => emit(\"plotClick\", event),\n    zoom: (view) => emit(\"zoom\", view),\n    renderer: (renderer) => emit(\"rendererChange\", renderer),\n  },\n);\ndefineExpose(handle);\n</script>\n\n<template>\n  <div class=\"mn-chart\" data-minerva=\"chart\" :style=\"rootStyle\">\n    <div :ref=\"setContainer\" style=\"position: absolute; inset: 0\"></div>\n  </div>\n</template>\n"],"mappings":""}

package/dist/vue/components/Chart/AreaChart.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,49 @@
+import { engineOptions as e, useCartesianChart as t, withSeriesType as n } from "./cartesian.js";
+import { chartAxisProps as r, chartCommonProps as i, chartSeriesProps as a, chartStackProps as o } from "./props.js";
+import { createElementBlock as s, createElementVNode as c, defineComponent as l, normalizeStyle as u, openBlock as d, unref as f } from "vue";
+//#region src/components/Chart/AreaChart.vue?vue&type=script&setup=true&lang.ts
+var p = /*@__PURE__*/ l({
+	name: "AreaChart",
+	__name: "AreaChart",
+	props: {
+		...i,
+		...r,
+		...a,
+		...o,
+		curve: {
+			type: String,
+			default: "smooth"
+		}
+	},
+	emits: [
+		"hover",
+		"pointClick",
+		"plotClick",
+		"zoom",
+		"rendererChange"
+	],
+	setup(r, { expose: i, emit: a }) {
+		let o = r, l = a, { setContainer: p, rootStyle: m, handle: h } = t(o, () => e(o, n(o.series, "area", o.stacked || o.percent ? "stack" : void 0, o.curve), o.percent ? "percent" : void 0), {
+			hover: (e) => l("hover", e),
+			click: (e) => l("pointClick", e),
+			plotClick: (e) => l("plotClick", e),
+			zoom: (e) => l("zoom", e),
+			renderer: (e) => l("rendererChange", e)
+		});
+		return i(h), (e, t) => (d(), s("div", {
+			class: "mn-chart",
+			"data-minerva": "chart",
+			style: u(f(m))
+		}, [c("div", {
+			ref: f(p),
+			style: {
+				position: "absolute",
+				inset: "0"
+			}
+		}, null, 512)], 4));
+	}
+});
+//#endregion
+export { p as default };
+
+//# sourceMappingURL=AreaChart.vue_vue_type_script_setup_true_lang.js.map

package/dist/vue/components/Chart/AreaChart.vue_vue_type_script_setup_true_lang.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AreaChart.vue_vue_type_script_setup_true_lang.js","names":["_openBlock","_createElementBlock","_normalizeStyle","_unref","_createElementVNode","AreaChart_vue_vue_type_script_setup_true_lang_default","chartCommonProps","chartAxisProps","chartSeriesProps","chartStackProps","__expose","__emit","props","__props","emit","useCartesianChart","engineOptions","withSeriesType","event","view","renderer","handle","openBlock","createElementBlock","normalizeStyle","unref","rootStyle","createElementVNode","setContainer","\"position\"","\"inset\""],"sources":["../../../../../vue/src/components/Chart/AreaChart.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport type { PropType } from \"vue\";\nimport type {\n  ChartCurve,\n  ChartHoverEvent,\n  ChartPlotClickEvent,\n  ChartRendererKind,\n  ChartView,\n} from \"minerva-design/charts/core\";\nimport { engineOptions, useCartesianChart, withSeriesType } from \"./cartesian\";\nimport {\n  chartAxisProps,\n  chartCommonProps,\n  chartSeriesProps,\n  chartStackProps,\n} from \"./props\";\n\n/** Area chart: smooth by default, stacked or 100% stacked */\ndefineOptions({ name: \"AreaChart\" });\nconst props = defineProps({\n  ...chartCommonProps,\n  ...chartAxisProps,\n  ...chartSeriesProps,\n  ...chartStackProps,\n  /** Shape of the edges: straight, smooth (monotone) or steps (default `smooth`) */\n  curve: { type: String as PropType<ChartCurve>, default: \"smooth\" },\n});\nconst emit = defineEmits<{\n  /** The hovered (or keyboard-focused) points changed (`null`: none) */\n  hover: [event: ChartHoverEvent | null];\n  /** A point was clicked */\n  pointClick: [event: ChartHoverEvent];\n  /** The plot area was clicked where there is no point */\n  plotClick: [event: ChartPlotClickEvent];\n  /** The user zoomed or panned */\n  zoom: [view: ChartView];\n  /** The backend is ready (or fell back after a GPU loss) */\n  rendererChange: [renderer: ChartRendererKind];\n}>();\nconst { setContainer, rootStyle, handle } = useCartesianChart(\n  props,\n  () =>\n    engineOptions(\n      props,\n      withSeriesType(\n        props.series,\n        \"area\",\n        props.stacked || props.percent ? \"stack\" : undefined,\n        props.curve,\n      ),\n      props.percent ? \"percent\" : undefined,\n    ),\n  {\n    hover: (event) => emit(\"hover\", event),\n    click: (event) => emit(\"pointClick\", event),\n    plotClick: (event) => emit(\"plotClick\", event),\n    zoom: (view) => emit(\"zoom\", view),\n    renderer: (renderer) => emit(\"rendererChange\", renderer),\n  },\n);\ndefineExpose(handle);\n</script>\n\n<template>\n  <div class=\"mn-chart\" data-minerva=\"chart\" :style=\"rootStyle\">\n    <div :ref=\"setContainer\" style=\"position: absolute; inset: 0\"></div>\n  </div>\n</template>\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;EAmBA,IAAMY,IAAQC,GAQRC,IAAOH,GAYP,EAAE,iBAAc,cAAW,cAAWI,EAC1CH,SAEEI,EACEJ,GACAK,EACEL,EAAM,QACN,QACAA,EAAM,WAAWA,EAAM,UAAU,UAAU,KAAA,GAC3CA,EAAM,KACR,GACAA,EAAM,UAAU,YAAY,KAAA,CAC9B,GACF;GACE,QAAQ,MAAUE,EAAK,SAASI,CAAK;GACrC,QAAQ,MAAUJ,EAAK,cAAcI,CAAK;GAC1C,YAAY,MAAUJ,EAAK,aAAaI,CAAK;GAC7C,OAAO,MAASJ,EAAK,QAAQK,CAAI;GACjC,WAAW,MAAaL,EAAK,kBAAkBM,CAAQ;EACzD,CACF;SACAV,EAAaW,CAAM,cAIjBrB,EAAA,GAAAC,EAEM,OAAA;GAFD,OAAM;GAAW,gBAAa;GAAS,OAAKC,EAAEC,EAAAuB,CAAA,CAAS;EAC1DtB,GAAAA,CAAAA,EAAoE,OAAA;GAA9D,KAAKD,EAAAyB,CAAA;GAAc,OAAA;IAAAC,UAAA;IAAAC,OAAA;GAAA"}