@wavemaker/react-native-echarts 1.0.0-dev.0

package/column/column-chart.js

@@ -0,0 +1,481 @@
+import { withResponsiveContainer } from '../chart-container';
+import { useChartTheme, withChartTheme } from '../chart-theme.context';
+import { SkiaChart, SkiaRenderer } from '@wuba/react-native-echarts';
+import { BarChart as EChartsBarChart } from 'echarts/charts';
+import { GridComponent, LegendComponent, TooltipComponent, } from 'echarts/components';
+import * as echarts from 'echarts/core';
+import React, { useEffect, useMemo, useRef } from 'react';
+import { getAxis } from '../axis';
+echarts.use([
+    TooltipComponent,
+    GridComponent,
+    LegendComponent,
+    SkiaRenderer,
+    EChartsBarChart,
+]);
+const ChartComponent = ({ data, width = 220, height = 350, boundaryGap = true, cornerRadius = [4, 4, 0, 0], horizontal = false, stack, stackNormalize = false, activeIndex, activeColor, barInsideLabelPosition = 'start', barInsideLabelFormatter, barOutsideLabelPosition = 'start', barOutsideLabelFormatter, itemStyle, showXAxis = true, showXAxisTicks = true, showYAxis = true, showYAxisTicks = true, showXAxisSplitLines = true, showYAxisSplitLines = true, grid, showLegend = false, showHighlighter = true, xAxisTickLabelFormatter, yAxisTickLabelFormatter, xAxisTicks, xAxisLabel, yAxisLabel, onSelect, ...props }) => {
+    const { theme } = useChartTheme(props.theme, props.colors);
+    const chartRef = useRef(null);
+    const onSelectRef = useRef(onSelect);
+    onSelectRef.current = onSelect;
+    const selectContextRef = useRef({ displaySeries: [], labelOverlayDuplicate: false });
+    const normalizedSeries = useMemo(() => {
+        let normalizedData = [];
+        if (!Array.isArray(data) || data.length === 0)
+            return normalizedData;
+        const first = data[0];
+        if (typeof first === 'number') {
+            normalizedData = [
+                {
+                    name: 'Series 1',
+                    data: data.map((value, index) => [String(index), value]),
+                },
+            ];
+        }
+        else if (Array.isArray(first) && first.length === 2) {
+            normalizedData = [{ name: 'Series 1', data: data }];
+        }
+        else {
+            normalizedData = JSON.parse(JSON.stringify(data))
+                .filter((item) => item.data && item.data.length > 0)
+                .map((item, index) => {
+                const firstItem = item.data[0];
+                if (typeof firstItem === 'number') {
+                    item.data = item.data.map((value, i) => [
+                        String(i),
+                        value,
+                    ]);
+                }
+                return {
+                    name: item.name || 'Series ' + (index + 1),
+                    data: [...item.data],
+                };
+            });
+        }
+        return normalizedData;
+    }, [data]);
+    const hasNamedSeries = useMemo(() => normalizedSeries.some((s) => 'name' in s && s.name), [normalizedSeries]);
+    const displaySeries = useMemo(() => {
+        if (!stackNormalize || normalizedSeries.length <= 1)
+            return normalizedSeries;
+        const len = normalizedSeries[0]?.data?.length ?? 0;
+        if (len === 0)
+            return normalizedSeries;
+        return normalizedSeries.map((s) => {
+            const rawData = s.data;
+            const sumsAt = new Array(len).fill(0);
+            normalizedSeries.forEach((other) => {
+                const d = 'data' in other ? other.data : [];
+                d.forEach((v, i) => {
+                    if (i < len)
+                        sumsAt[i] += typeof v === 'number' ? v : v[1];
+                });
+            });
+            const normalizedData = rawData.map((v, i) => {
+                const val = typeof v === 'number' ? v : v[1];
+                const sum = sumsAt[i] || 1;
+                return sum > 0 ? (val / sum) * 100 : 0;
+            });
+            return {
+                name: s.name,
+                data: rawData.map((v, i) => [v[0], normalizedData[i]]),
+            };
+        });
+    }, [normalizedSeries, stackNormalize]);
+    const showLabelInside = barInsideLabelFormatter != null;
+    const showLabelOutside = barOutsideLabelFormatter != null;
+    const isSingleSeries = displaySeries.length === 1;
+    const labelOverlayDuplicate = showLabelInside && showLabelOutside && isSingleSeries;
+    selectContextRef.current = { displaySeries, labelOverlayDuplicate };
+    const option = useMemo(() => {
+        const categories = (displaySeries[0]?.data ?? []).map((item) => String(item[0]));
+        const dataPoints = displaySeries.flatMap((s) => s.data.map((d) => d[1]));
+        const xAxisData = xAxisTicks != null && xAxisTicks.length > 0
+            ? xAxisTicks
+            : categories.length > 0
+                ? categories
+                : getAxis(dataPoints).map(String);
+        const tooltipConfig = showHighlighter
+            ? {
+                trigger: 'axis',
+                axisPointer: {
+                    type: 'shadow',
+                    shadowStyle: {
+                        color: 'rgba(0,0,0,0.08)',
+                    },
+                },
+            }
+            : { trigger: 'axis' };
+        const categoryAxisConfig = {
+            type: 'category',
+            data: xAxisData,
+            boundaryGap,
+            ...((horizontal ? yAxisLabel : xAxisLabel) != null && (horizontal ? yAxisLabel : xAxisLabel) !== '' && {
+                name: horizontal ? yAxisLabel : xAxisLabel,
+                nameLocation: 'middle',
+                nameGap: 25,
+                nameTextStyle: { color: horizontal ? theme.axis.y.tickLabelColor : theme.axis.x.tickLabelColor },
+            }),
+            axisLabel: {
+                show: showXAxis || xAxisTickLabelFormatter != null,
+                color: theme.axis.x.tickLabelColor,
+                formatter: xAxisTickLabelFormatter ?? undefined,
+            },
+            axisLine: showXAxis
+                ? {
+                    show: true,
+                    lineStyle: {
+                        color: theme.axis.x.lineColor,
+                        width: theme.axis.x.lineWidth,
+                    },
+                }
+                : { show: false },
+            axisTick: {
+                show: showXAxis && showXAxisTicks,
+                lineStyle: {
+                    color: theme.axis.x.tickColor,
+                    width: theme.axis.x.tickWidth,
+                },
+            },
+            splitLine: {
+                show: showXAxisSplitLines,
+                lineStyle: {
+                    color: theme.axis.x.splitLineColor,
+                    width: theme.axis.x.splitLineWidth,
+                },
+            },
+        };
+        const valueAxisConfig = {
+            type: 'value',
+            ...(stackNormalize &&
+                displaySeries.length > 1 && {
+                min: 0,
+                max: 100,
+            }),
+            ...((horizontal ? xAxisLabel : yAxisLabel) != null && (horizontal ? xAxisLabel : yAxisLabel) !== '' && {
+                name: horizontal ? xAxisLabel : yAxisLabel,
+                nameLocation: 'middle',
+                nameGap: 40,
+                nameTextStyle: { color: horizontal ? theme.axis.x.tickLabelColor : theme.axis.y.tickLabelColor },
+            }),
+            axisLabel: {
+                show: showYAxis || yAxisTickLabelFormatter != null,
+                color: theme.axis.y.tickLabelColor,
+                formatter: yAxisTickLabelFormatter ??
+                    (stackNormalize && displaySeries.length > 1
+                        ? (value) => `${value}%`
+                        : undefined),
+            },
+            axisLine: showYAxis
+                ? {
+                    show: true,
+                    lineStyle: {
+                        color: theme.axis.y.lineColor,
+                        width: theme.axis.y.lineWidth,
+                    },
+                }
+                : { show: false },
+            axisTick: {
+                show: showYAxis && showYAxisTicks,
+                lineStyle: {
+                    color: theme.axis.y.tickColor,
+                    width: theme.axis.y.tickWidth,
+                },
+            },
+            splitLine: {
+                show: showYAxisSplitLines,
+                lineStyle: {
+                    color: theme.axis.y.splitLineColor,
+                    width: theme.axis.y.splitLineWidth,
+                },
+            },
+        };
+        const xAxisConfig = horizontal ? valueAxisConfig : categoryAxisConfig;
+        const yAxisConfig = horizontal ? categoryAxisConfig : valueAxisConfig;
+        const legendConfig = showLegend && hasNamedSeries
+            ? {
+                data: normalizedSeries
+                    .filter((s) => 'name' in s && s.name)
+                    .map((s) => s.name),
+                textStyle: {
+                    color: theme.legend.textColor,
+                    fontSize: theme.legend.fontSize,
+                },
+                backgroundColor: theme.legend.backgroundColor,
+            }
+            : undefined;
+        const isDefaultVerticalRadius = Array.isArray(cornerRadius) &&
+            cornerRadius[0] === 4 &&
+            cornerRadius[1] === 4 &&
+            cornerRadius[2] === 0 &&
+            cornerRadius[3] === 0;
+        const effectiveCornerRadius = horizontal
+            ? isDefaultVerticalRadius
+                ? [0, 4, 4, 0]
+                : Array.isArray(cornerRadius)
+                    ? cornerRadius
+                    : [0, cornerRadius, cornerRadius, 0]
+            : Array.isArray(cornerRadius)
+                ? cornerRadius
+                : [cornerRadius, cornerRadius, cornerRadius, cornerRadius];
+        const isStacked = (stack !== undefined && stack !== false) ||
+            (stackNormalize && displaySeries.length > 1);
+        const showLabelInside = barInsideLabelFormatter != null;
+        const showLabelOutside = barOutsideLabelFormatter != null;
+        const isSingleSeries = displaySeries.length === 1;
+        const insideLabelPositionMap = horizontal
+            ? { start: 'insideLeft', middle: 'inside', end: 'insideRight' }
+            : { start: 'insideLeft', middle: 'inside', end: 'insideRight' };
+        const outsideLabelPositionMap = horizontal
+            ? { start: 'right', end: 'left' }
+            : { start: 'top', end: 'bottom' };
+        const resolveInsidePosition = (value, index, category) => {
+            const pos = typeof barInsideLabelPosition === 'function'
+                ? barInsideLabelPosition(value, index, category)
+                : barInsideLabelPosition;
+            return insideLabelPositionMap[pos] ?? 'insideLeft';
+        };
+        const resolveOutsidePosition = (value, index, category) => {
+            const pos = typeof barOutsideLabelPosition === 'function'
+                ? barOutsideLabelPosition(value, index, category)
+                : barOutsideLabelPosition;
+            return outsideLabelPositionMap[pos] ?? (horizontal ? 'right' : 'top');
+        };
+        const echartsInsidePosition = typeof barInsideLabelPosition === 'function'
+            ? undefined
+            : (insideLabelPositionMap[barInsideLabelPosition] ?? 'insideLeft');
+        const echartsOutsidePosition = typeof barOutsideLabelPosition === 'function'
+            ? undefined
+            : (outsideLabelPositionMap[barOutsideLabelPosition] ?? (horizontal ? 'right' : 'top'));
+        const seriesConfig = displaySeries.map((s, index) => {
+            const seriesColor = theme.series[index % theme.series.length].color;
+            const isEndBar = index === displaySeries.length - 1;
+            const barBorderRadius = isStacked && !isEndBar ? [0, 0, 0, 0] : effectiveCornerRadius;
+            const isSingle = displaySeries.length === 1;
+            const showActive = isSingle &&
+                activeIndex != null &&
+                activeIndex >= 0 &&
+                activeIndex < s.data.length;
+            const effectiveActiveColor = activeColor ?? seriesColor;
+            const useItemStyleFn = isSingle && itemStyle != null;
+            const baseItemStyle = {
+                color: seriesColor,
+                borderRadius: barBorderRadius,
+            };
+            const barData = showActive
+                ? s.data.map((d, i) => {
+                    const value = d[1];
+                    if (i === activeIndex) {
+                        return {
+                            value,
+                            itemStyle: {
+                                color: effectiveActiveColor,
+                                borderColor: effectiveActiveColor,
+                                borderWidth: 2,
+                                borderType: 'dashed',
+                                borderRadius: barBorderRadius,
+                            },
+                        };
+                    }
+                    const override = itemStyle ? itemStyle(value, i) : {};
+                    return {
+                        value,
+                        itemStyle: { ...baseItemStyle, ...override },
+                    };
+                })
+                : useItemStyleFn
+                    ? s.data.map((d, i) => {
+                        const value = d[1];
+                        const override = itemStyle(value, i);
+                        return {
+                            value,
+                            itemStyle: { ...baseItemStyle, ...override },
+                        };
+                    })
+                    : s.data.map((d) => d[1]);
+            const labelConfig = {};
+            if (showLabelInside && isSingleSeries && barInsideLabelFormatter) {
+                labelConfig.show = true;
+                labelConfig.position =
+                    typeof barInsideLabelPosition === 'function'
+                        ? (params) => resolveInsidePosition(params.value, params.dataIndex, categories[params.dataIndex])
+                        : echartsInsidePosition;
+                labelConfig.color = '#fff';
+                labelConfig.formatter = (params) => barInsideLabelFormatter(params.value, params.dataIndex, categories[params.dataIndex]);
+            }
+            else if (showLabelOutside &&
+                isSingleSeries &&
+                barOutsideLabelFormatter &&
+                !(showLabelInside && barInsideLabelFormatter)) {
+                labelConfig.show = true;
+                labelConfig.position =
+                    typeof barOutsideLabelPosition === 'function'
+                        ? (params) => resolveOutsidePosition(params.value, params.dataIndex, categories[params.dataIndex])
+                        : echartsOutsidePosition;
+                labelConfig.formatter = (params) => barOutsideLabelFormatter(params.value, params.dataIndex, categories[params.dataIndex]);
+            }
+            const barSeries = {
+                type: 'bar',
+                data: barData,
+                itemStyle: showActive || useItemStyleFn
+                    ? undefined
+                    : {
+                        color: seriesColor,
+                        borderRadius: barBorderRadius,
+                    },
+                emphasis: showHighlighter
+                    ? {
+                        focus: 'self',
+                        itemStyle: {
+                            color: seriesColor,
+                            borderColor: '#fff',
+                            borderWidth: 1,
+                        },
+                    }
+                    : { focus: 'none' },
+            };
+            if (Object.keys(labelConfig).length > 0)
+                barSeries.label = labelConfig;
+            if (s.name)
+                barSeries.name = s.name;
+            if (stack !== undefined && stack !== false) {
+                barSeries.stack = typeof stack === 'string' ? stack : 'total';
+            }
+            else if (stackNormalize && displaySeries.length > 1) {
+                barSeries.stack = 'total';
+            }
+            return barSeries;
+        });
+        // When both inside and outside formatters are set, add a second series for outside labels (transparent bars)
+        if (showLabelInside && showLabelOutside && isSingleSeries && seriesConfig.length > 0) {
+            const first = seriesConfig[0];
+            const labelOnlySeries = {
+                type: 'bar',
+                data: first.data,
+                barGap: '-100%',
+                itemStyle: { color: 'transparent', borderColor: 'transparent' },
+                label: {
+                    show: true,
+                    position: typeof barOutsideLabelPosition === 'function'
+                        ? (params) => resolveOutsidePosition(params.value, params.dataIndex, categories[params.dataIndex])
+                        : echartsOutsidePosition,
+                    color: theme.axis.x?.tickLabelColor ?? '#333',
+                    formatter: (params) => barOutsideLabelFormatter(params.value, params.dataIndex, categories[params.dataIndex]),
+                },
+                emphasis: { focus: 'none' },
+                tooltip: { show: false },
+            };
+            seriesConfig.push(labelOnlySeries);
+        }
+        const config = {
+            tooltip: tooltipConfig,
+            xAxis: xAxisConfig,
+            yAxis: yAxisConfig,
+            series: seriesConfig,
+        };
+        if (legendConfig)
+            config.legend = legendConfig;
+        if (grid)
+            config.grid = grid;
+        return config;
+    }, [
+        theme,
+        normalizedSeries,
+        displaySeries,
+        boundaryGap,
+        cornerRadius,
+        horizontal,
+        stack,
+        stackNormalize,
+        activeIndex,
+        activeColor,
+        barInsideLabelPosition,
+        barInsideLabelFormatter,
+        barOutsideLabelPosition,
+        barOutsideLabelFormatter,
+        itemStyle,
+        showXAxis,
+        showXAxisTicks,
+        showYAxis,
+        showYAxisTicks,
+        showXAxisSplitLines,
+        showYAxisSplitLines,
+        grid,
+        showLegend,
+        hasNamedSeries,
+        showHighlighter,
+        xAxisTickLabelFormatter,
+        yAxisTickLabelFormatter,
+        xAxisTicks,
+        xAxisLabel,
+        yAxisLabel,
+    ]);
+    useEffect(() => {
+        let chart;
+        if (chartRef.current) {
+            try {
+                chart = echarts.init(chartRef.current, 'light', { width, height });
+                chart.setOption(option);
+                const handleSeriesClick = (params) => {
+                    const cb = onSelectRef.current;
+                    if (typeof cb !== 'function')
+                        return;
+                    if (params.componentType !== 'series')
+                        return;
+                    if (params.seriesType !== 'bar')
+                        return;
+                    let seriesIndex = params.seriesIndex;
+                    const dataIndex = params.dataIndex;
+                    if (typeof seriesIndex !== 'number' ||
+                        typeof dataIndex !== 'number' ||
+                        dataIndex < 0) {
+                        return;
+                    }
+                    const { displaySeries: ds, labelOverlayDuplicate: overlay } = selectContextRef.current;
+                    if (overlay && seriesIndex === 1)
+                        seriesIndex = 0;
+                    const s = ds[seriesIndex];
+                    if (!s?.data || !Array.isArray(s.data))
+                        return;
+                    const row = s.data[dataIndex];
+                    if (row === undefined)
+                        return;
+                    const seriesName = s.name != null && s.name !== ''
+                        ? String(s.name)
+                        : `Series ${seriesIndex + 1}`;
+                    if (!Array.isArray(row) || row.length < 2)
+                        return;
+                    const x = row[0];
+                    const y = Number(row[1]);
+                    const event = {
+                        seriesIndex,
+                        dataIndex,
+                        seriesName,
+                        x,
+                        y,
+                    };
+                    cb(event);
+                };
+                chart.on('click', handleSeriesClick);
+            }
+            catch (error) {
+                console.warn('Chart initialization error:', error);
+            }
+        }
+        return () => {
+            if (chart) {
+                try {
+                    chart.dispose();
+                }
+                catch (error) {
+                    console.warn('Chart disposal error:', error);
+                }
+            }
+        };
+    }, [option, width, height]);
+    return <SkiaChart ref={chartRef} useRNGH/>;
+};
+const ColumnChartComponent = withResponsiveContainer(withChartTheme(ChartComponent));
+export const ColumnChart = Object.assign(ColumnChartComponent, {
+    displayName: 'ColumnChart',
+});

package/column/column-chart.props.d.ts

@@ -0,0 +1,83 @@
+import type { CartesianChartProps } from '../props/cartesian';
+import type { SeriesData } from '../area/area-chart.props';
+/**
+ * Props for ColumnChart.
+ * common -> cartesian -> column
+ */
+export interface ColumnChartProps extends CartesianChartProps {
+    /**
+     * Chart data. Same shape as area: single series, with labels, or multiple named series.
+     */
+    data: SeriesData;
+    /**
+     * Whether to leave gaps at the start and end of the axis.
+     * @default true
+     */
+    boundaryGap?: boolean;
+    /**
+     * Bar corner radius: number (all corners) or [topLeft, topRight, bottomRight, bottomLeft].
+     * @default [4, 4, 0, 0]
+     */
+    cornerRadius?: number | [number, number, number, number];
+    /**
+     * When true, bars are horizontal (categories on Y-axis, values on X-axis).
+     * Bar chart is the horizontal orientation of column chart.
+     * @default false
+     */
+    horizontal?: boolean;
+    /**
+     * Stack ID for stacking multiple series.
+     */
+    stack?: string | false;
+    /**
+     * When true with stack, show stacked bars as percentages (0–100%).
+     * @default false
+     */
+    stackNormalize?: boolean;
+    /**
+     * Zero-based index of the bar to highlight (active state). Only applies to single series.
+     * The active bar uses activeColor and a dashed border.
+     */
+    activeIndex?: number;
+    /**
+     * Color for the active bar when activeIndex is set.
+     * @default darker shade of series color
+     */
+    activeColor?: string;
+    /**
+     * Position of the label inside the bar.
+     * @default 'start'
+     */
+    barInsideLabelPosition?: 'start' | 'middle' | 'end' | ((value: number, index: number, category?: string) => 'start' | 'middle' | 'end');
+    /**
+     * Formatter for the label inside the bar.
+     * @default undefined
+     */
+    barInsideLabelFormatter?: (value: number, index: number, category?: string) => string;
+    /**
+     * Position of the label outside the bar.
+     * @default 'start'
+     */
+    barOutsideLabelPosition?: 'start' | 'end' | ((value: number, index: number, category?: string) => 'start' | 'end');
+    /**
+     * Formatter for the label outside the bar.
+     * @default undefined
+     */
+    barOutsideLabelFormatter?: (value: number, index: number, category?: string) => string;
+    /**
+     * Per-bar item style override. When provided for single series, called for each bar with (value, index).
+     * Returned object is merged over the base itemStyle (e.g. color, borderColor, borderRadius).
+     */
+    itemStyle?: (value: number, index: number) => BarItemStyle;
+}
+/**
+ * Per-bar style overrides (ECharts itemStyle subset).
+ */
+export interface BarItemStyle {
+    color?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    borderType?: 'solid' | 'dashed' | 'dotted';
+    borderRadius?: number | number[];
+}
+//# sourceMappingURL=column-chart.props.d.ts.map

package/column/column-chart.props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-chart.props.d.ts","sourceRoot":"","sources":["../../../../components/chart/column/column-chart.props.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D;;;GAGG;AACH,MAAM,WAAW,gBAAiB,SAAQ,mBAAmB;IAC3D;;OAEG;IACH,IAAI,EAAE,UAAU,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACzD;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACvB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,sBAAsB,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC,CAAC;IACxI;;;OAGG;IACH,uBAAuB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACtF;;;OAGG;IACH,uBAAuB,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,KAAK,CAAC,CAAC;IACnH;;;OAGG;IACH,wBAAwB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACvF;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,YAAY,CAAC;CAC5D;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC3C,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAClC"}

package/column/index.d.ts

@@ -0,0 +1,3 @@
+export { ColumnChart } from './column-chart';
+export type { ColumnChartProps, BarItemStyle } from './column-chart.props';
+//# sourceMappingURL=index.d.ts.map

package/column/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../components/chart/column/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC"}

package/column/index.js

@@ -0,0 +1 @@
+export { ColumnChart } from './column-chart';

package/gauge/digital/digital.gauge.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import type { BaseGaugeProps } from '../gauge.types';
+/**
+ * Props for the DigitalGauge component.
+ * A gauge chart with smooth animations built using SVG.
+ */
+interface DigitalGaugeProps extends BaseGaugeProps {
+    /**
+     * Whether to show the inner arc.
+     * @default false
+     */
+    showInnerArc?: boolean;
+    /**
+     * Animation duration in milliseconds.
+     * @default 1000
+     */
+    animationDuration?: number;
+}
+export declare const DigitalGauge: ((props: DigitalGaugeProps & {
+    theme?: Partial<import("../..").ChartTheme>;
+} & {
+    width?: number | string;
+    height?: number | string;
+}) => React.JSX.Element) & {
+    displayName: string;
+};
+export {};
+//# sourceMappingURL=digital.gauge.d.ts.map

package/gauge/digital/digital.gauge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"digital.gauge.d.ts","sourceRoot":"","sources":["../../../../../components/chart/gauge/digital/digital.gauge.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAG3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD;;;GAGG;AACH,UAAU,iBAAkB,SAAQ,cAAc;IAChD;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AA+UD,eAAO,MAAM,YAAY;;;;;;;CAEvB,CAAC"}