react-native-chart-kit 7.0.0-next.0 → 7.0.0-next.2

package/dist/v2/react-native/charts/bar/accessibility.js

@@ -0,0 +1,87 @@
+import { normalizeCartesianData } from "../../../core/index";
+import { defaultFormatBarChartXLabel, defaultFormatBarChartYLabel } from "./modelUtils";
+const pluralize = (count, singular, plural = `${singular}s`) => `${count} ${count === 1 ? singular : plural}`;
+const resolveSeriesInput = (yKey, yKeys, series) => {
+    if (series && series.length > 0) {
+        return series;
+    }
+    if (yKeys && yKeys.length > 0) {
+        return yKeys.map((key) => ({ yKey: key }));
+    }
+    return yKey ? [{ yKey }] : [];
+};
+const getDefinedPoints = (table) => table.rows.flatMap((row) => table.columns.flatMap((column) => {
+    const value = row.values[column.key];
+    return typeof value === "number"
+        ? [
+            {
+                formattedValue: row.formattedValues[column.key] ?? String(value),
+                raw: row.raw,
+                seriesLabel: column.label,
+                value,
+                xLabel: row.xLabel
+            }
+        ]
+        : [];
+}));
+const getMinPoint = (points) => points.reduce((min, point) => (!min || point.value < min.value ? point : min), undefined);
+const getMaxPoint = (points) => points.reduce((max, point) => (!max || point.value > max.value ? point : max), undefined);
+const getPointLabel = ({ point, seriesCount }) => seriesCount > 1 ? `${point.seriesLabel} in ${point.xLabel}` : point.xLabel;
+export const getBarChartDataTable = ({ data, formatXLabel = defaultFormatBarChartXLabel, formatYLabel = defaultFormatBarChartYLabel, series, xKey, yKey, yKeys }) => {
+    const seriesInput = resolveSeriesInput(yKey, yKeys, series);
+    const normalized = normalizeCartesianData({
+        data,
+        xKey,
+        series: seriesInput
+    });
+    return {
+        columns: normalized.series.map((item) => ({
+            key: item.key,
+            label: item.label
+        })),
+        rows: data.map((row, rowIndex) => {
+            const values = {};
+            const formattedValues = {};
+            normalized.series.forEach((seriesItem) => {
+                const value = seriesItem.points[rowIndex]?.value ?? null;
+                values[seriesItem.key] = value;
+                formattedValues[seriesItem.key] =
+                    value === null ? "No value" : formatYLabel(value);
+            });
+            const x = normalized.series[0]?.points[rowIndex]?.x ?? rowIndex;
+            return {
+                index: rowIndex,
+                x,
+                xLabel: formatXLabel(x, rowIndex),
+                values,
+                formattedValues,
+                raw: row
+            };
+        })
+    };
+};
+export const getBarChartAccessibilitySummary = (input) => {
+    const table = getBarChartDataTable(input);
+    if (table.columns.length === 0 || table.rows.length === 0) {
+        return "Bar chart with no data.";
+    }
+    const points = getDefinedPoints(table);
+    if (points.length === 0) {
+        return `Bar chart with ${pluralize(table.rows.length, "category", "categories")} and no defined values.`;
+    }
+    const intro = table.columns.length === 1
+        ? `Bar chart with ${pluralize(points.length, "bar")}.`
+        : `Bar chart with ${pluralize(table.columns.length, "series", "series")} across ${pluralize(table.rows.length, "category", "categories")}.`;
+    const minPoint = getMinPoint(points);
+    const maxPoint = getMaxPoint(points);
+    if (!minPoint || !maxPoint) {
+        return intro;
+    }
+    return `${intro} Highest value is ${getPointLabel({
+        point: maxPoint,
+        seriesCount: table.columns.length
+    })} at ${maxPoint.formattedValue}. Lowest value is ${getPointLabel({
+        point: minPoint,
+        seriesCount: table.columns.length
+    })} at ${minPoint.formattedValue}.`;
+};

package/dist/v2/react-native/charts/bar/interaction.d.ts

@@ -0,0 +1,18 @@
+import type { BarChartBarModel, BarChartDeselectEvent, BarChartInteraction, BarChartSelectEvent, BarChartSelectedBar } from "./types";
+export type ResolvedBarChartInteractionConfig<TData = unknown> = {
+    mode: "none" | "tap";
+    deselectOnOutsidePress: boolean;
+    onSelect?: (event: BarChartSelectEvent<TData>) => void;
+    onDeselect?: (event: BarChartDeselectEvent) => void;
+};
+export declare const getBarChartBarKey: (selectedBar: BarChartSelectedBar | undefined) => string | undefined;
+export declare const getBarChartInteractionConfig: <TData>(interaction: BarChartInteraction<TData> | undefined) => ResolvedBarChartInteractionConfig<TData>;
+export declare const isBarChartInteractionEnabled: <TData>(config: ResolvedBarChartInteractionConfig<TData>) => boolean;
+export declare const getBarChartBarAtPoint: <TData>({ bars, hitSlop, locationX, locationY }: {
+    bars: Array<BarChartBarModel<TData>>;
+    hitSlop?: number;
+    locationX: number;
+    locationY: number;
+}) => BarChartBarModel<TData> | undefined;
+export declare const buildBarChartSelectEvent: <TData>(bar: BarChartBarModel<TData> | undefined) => BarChartSelectEvent<TData> | undefined;
+//# sourceMappingURL=interaction.d.ts.map

package/dist/v2/react-native/charts/bar/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../src/charts/bar/interaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,iCAAiC,CAAC,KAAK,GAAG,OAAO,IAAI;IAC/D,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IACrB,sBAAsB,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,mBAAmB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IACvD,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;CACrD,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,aAAa,mBAAmB,GAAG,SAAS,uBAEiC,CAAC;AAEhF,eAAO,MAAM,4BAA4B,GAAI,KAAK,EAChD,aAAa,mBAAmB,CAAC,KAAK,CAAC,GAAG,SAAS,KAClD,iCAAiC,CAAC,KAAK,CAqBzC,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,KAAK,EAChD,QAAQ,iCAAiC,CAAC,KAAK,CAAC,YACvB,CAAC;AAE5B,eAAO,MAAM,qBAAqB,GAAI,KAAK,EAAE,yCAK1C;IACD,IAAI,EAAE,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,wCAyBA,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,KAAK,EAC5C,KAAK,gBAAgB,CAAC,KAAK,CAAC,GAAG,SAAS,KACvC,mBAAmB,CAAC,KAAK,CAAC,GAAG,SAoB/B,CAAC"}

package/dist/v2/react-native/charts/bar/interaction.js

@@ -0,0 +1,62 @@
+export const getBarChartBarKey = (selectedBar) => selectedBar ? `${selectedBar.seriesKey}-${selectedBar.dataIndex}` : undefined;
+export const getBarChartInteractionConfig = (interaction) => {
+    if (!interaction) {
+        return {
+            mode: "none",
+            deselectOnOutsidePress: false
+        };
+    }
+    if (typeof interaction === "string") {
+        return {
+            mode: interaction,
+            deselectOnOutsidePress: interaction !== "none"
+        };
+    }
+    return {
+        mode: interaction.mode ?? "tap",
+        deselectOnOutsidePress: interaction.deselectOnOutsidePress ?? true,
+        ...(interaction.onSelect ? { onSelect: interaction.onSelect } : {}),
+        ...(interaction.onDeselect ? { onDeselect: interaction.onDeselect } : {})
+    };
+};
+export const isBarChartInteractionEnabled = (config) => config.mode !== "none";
+export const getBarChartBarAtPoint = ({ bars, hitSlop = 6, locationX, locationY }) => {
+    const candidates = bars.filter((bar) => {
+        const top = bar.y;
+        const bottom = bar.y + bar.height;
+        return (locationX >= bar.x - hitSlop &&
+            locationX <= bar.x + bar.width + hitSlop &&
+            locationY >= top - hitSlop &&
+            locationY <= bottom + hitSlop);
+    });
+    if (candidates.length <= 1) {
+        return candidates[0];
+    }
+    return candidates
+        .map((bar) => ({
+        bar,
+        distance: Math.abs(locationX - (bar.x + bar.width / 2)) +
+            Math.abs(locationY - (bar.y + bar.height / 2))
+    }))
+        .sort((a, b) => a.distance - b.distance)[0]?.bar;
+};
+export const buildBarChartSelectEvent = (bar) => {
+    if (!bar) {
+        return undefined;
+    }
+    return {
+        color: bar.color,
+        dataIndex: bar.dataIndex,
+        formattedValue: bar.formattedValue,
+        position: {
+            x: bar.x + bar.width / 2,
+            y: bar.y
+        },
+        raw: bar.raw,
+        seriesKey: bar.seriesKey,
+        seriesLabel: bar.seriesLabel,
+        value: bar.value,
+        x: bar.xValue,
+        xLabel: bar.xLabel
+    };
+};

package/dist/v2/react-native/charts/bar/model.d.ts

@@ -0,0 +1,3 @@
+import type { BarChartModel, BuildBarChartModelOptions } from "./types";
+export declare const buildBarChartModel: <TData extends Record<string, unknown>>({ data, xKey, yKey, yKeys, series, width, height, theme, preset, mode, orientation, yDomain, barWidthRatio, barGapRatio, showValuesOnTopOfBars, showHorizontalGridLines, showXAxisLabels, showYAxisLabels, yTickCount, legend, labelStrategy, formatXLabel, formatYLabel, chartKitTheme }: BuildBarChartModelOptions<TData>) => BarChartModel<TData>;
+//# sourceMappingURL=model.d.ts.map

package/dist/v2/react-native/charts/bar/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/charts/bar/model.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAEV,aAAa,EAGb,yBAAyB,EAC1B,MAAM,SAAS,CAAC;AAoEjB,eAAO,MAAM,kBAAkB,GAAI,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,2RAyBvE,yBAAyB,CAAC,KAAK,CAAC,KAAG,aAAa,CAAC,KAAK,CAkUxD,CAAC"}

package/dist/v2/react-native/charts/bar/model.js

@@ -0,0 +1,326 @@
+import { buildBarGeometry, buildHorizontalBarGeometry, calculateAutoPadding, createBandScale, createLinearScale, generateLinearTicks, normalizeCartesianData, resolveNumericDomain, solveChartBoxes } from "../../../core/index";
+import { resolveCartesianChartThemeConfig } from "../../theme/presets";
+import { defaultFormatBarChartXLabel, defaultFormatBarChartYLabel, getBarChartFontTextOptions, getBarChartSeriesColor, getBarChartXKey, getMaxBarChartTextSize, getVisibleBarChartXLabelInterval, getVisibleBarChartYLabelInterval, labelBaselineOffset, measureBarChartText } from "./modelUtils";
+const defaultYDomain = { includeZero: true, nice: true };
+const resolveSeriesInput = (yKey, yKeys, series) => {
+    if (series && series.length > 0) {
+        return series;
+    }
+    if (yKeys && yKeys.length > 0) {
+        return yKeys.map((key) => ({ yKey: key }));
+    }
+    return yKey ? [{ yKey }] : [];
+};
+const getDomainValues = ({ mode, series, yDomain }) => {
+    if (mode === "stacked100" && yDomain === defaultYDomain) {
+        return [0, 100];
+    }
+    if (mode === "grouped") {
+        return series.flatMap((item) => item.points.flatMap((point) => typeof point.value === "number" ? [point.value] : []));
+    }
+    const rowCount = Math.max(0, ...series.map((item) => item.points.length));
+    const values = [];
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+        let positive = 0;
+        let negative = 0;
+        series.forEach((item) => {
+            const value = item.points[rowIndex]?.value;
+            if (typeof value !== "number") {
+                return;
+            }
+            if (value >= 0) {
+                positive += value;
+            }
+            else {
+                negative += value;
+            }
+        });
+        values.push(positive, negative);
+    }
+    return values;
+};
+export const buildBarChartModel = ({ data, xKey, yKey, yKeys, series, width, height, theme, preset, mode = "grouped", orientation = "vertical", yDomain = defaultYDomain, barWidthRatio = 0.72, barGapRatio = 0.12, showValuesOnTopOfBars = false, showHorizontalGridLines = true, showXAxisLabels = true, showYAxisLabels = true, yTickCount = 5, legend, labelStrategy = "auto", formatXLabel = defaultFormatBarChartXLabel, formatYLabel = defaultFormatBarChartYLabel, chartKitTheme }) => {
+    const resolvedTheme = resolveCartesianChartThemeConfig({
+        mode: typeof theme === "string" && theme !== "system"
+            ? theme
+            : chartKitTheme.mode,
+        preset: preset ?? chartKitTheme.preset,
+        presets: chartKitTheme.presets,
+        theme: typeof theme === "object" ? theme : chartKitTheme.theme
+    });
+    const seriesInput = resolveSeriesInput(yKey, yKeys, series);
+    const legendVisible = legend ?? seriesInput.length > 1;
+    const normalized = normalizeCartesianData({
+        data,
+        xKey,
+        series: seriesInput
+    });
+    const xValues = normalized.series[0]?.points.map((point) => point.x) ?? [];
+    const xDomain = xValues.map(getBarChartXKey);
+    const xLabelTexts = xValues.map((value, index) => formatXLabel(value, index));
+    const textOptions = getBarChartFontTextOptions(resolvedTheme);
+    const xLabelSizes = xLabelTexts.map((text) => measureBarChartText(text, textOptions));
+    const isHorizontal = orientation === "horizontal";
+    const domainValues = getDomainValues({
+        mode,
+        series: normalized.series,
+        yDomain
+    });
+    const resolvedYDomain = mode === "stacked100" && yDomain === defaultYDomain
+        ? [0, 100]
+        : resolveNumericDomain(domainValues, yDomain);
+    const yTicks = generateLinearTicks({
+        domain: resolvedYDomain,
+        count: Math.max(2, Math.round(yTickCount))
+    });
+    const yLabelSizes = yTicks.map((tick) => measureBarChartText(formatYLabel(tick), textOptions));
+    const legendFontSize = resolvedTheme.typography.legendLabelSize;
+    const legendMarkerSize = 8;
+    const legendGap = 14;
+    const legendItemsRaw = seriesInput.map((item, index) => ({
+        key: item.key ?? item.yKey,
+        label: item.label ?? item.key ?? item.yKey,
+        color: item.color ?? getBarChartSeriesColor(resolvedTheme, index),
+        width: legendMarkerSize +
+            6 +
+            measureBarChartText(item.label ?? item.key ?? item.yKey, {
+                fontSize: legendFontSize
+            }).width
+    }));
+    const legendHeight = legendVisible && legendItemsRaw.length > 0 ? 18 : 0;
+    const autoPaddingOptions = {
+        base: { top: 18, right: 14, bottom: 12, left: 10 },
+        leftLabels: isHorizontal ? xLabelSizes : yLabelSizes,
+        bottomLabels: isHorizontal
+            ? yLabelSizes
+            : xLabelSizes.length > 0
+                ? [getMaxBarChartTextSize(xLabelSizes)]
+                : [],
+        gap: 8
+    };
+    const basePadding = calculateAutoPadding(legendHeight > 0
+        ? {
+            ...autoPaddingOptions,
+            legend: {
+                height: legendHeight,
+                position: "bottom",
+                width: width - 24
+            }
+        }
+        : autoPaddingOptions);
+    const boxes = solveChartBoxes({ width, height }, basePadding);
+    const yScale = createLinearScale({
+        domain: resolvedYDomain,
+        range: [boxes.plot.y + boxes.plot.height, boxes.plot.y]
+    });
+    const xScale = createBandScale({
+        domain: xDomain,
+        range: [boxes.plot.x, boxes.plot.x + boxes.plot.width],
+        paddingInner: 0.12,
+        paddingOuter: 0.08
+    });
+    const horizontalXScale = createLinearScale({
+        domain: resolvedYDomain,
+        range: [boxes.plot.x, boxes.plot.x + boxes.plot.width]
+    });
+    const horizontalYScale = createBandScale({
+        domain: xDomain,
+        range: [boxes.plot.y, boxes.plot.y + boxes.plot.height],
+        paddingInner: 0.12,
+        paddingOuter: 0.08
+    });
+    const barGeometry = buildBarGeometry({
+        series: normalized.series,
+        mode,
+        xBand: (value) => {
+            const key = getBarChartXKey(value);
+            const x = xScale.scale(key);
+            return x !== undefined ? { x, width: xScale.bandwidth } : undefined;
+        },
+        yScale: (value) => yScale.scale(value),
+        barWidthRatio,
+        barGapRatio
+    });
+    const horizontalBarGeometry = buildHorizontalBarGeometry({
+        series: normalized.series,
+        mode,
+        yBand: (value) => {
+            const key = getBarChartXKey(value);
+            const y = horizontalYScale.scale(key);
+            return y !== undefined
+                ? { y, height: horizontalYScale.bandwidth }
+                : undefined;
+        },
+        xScale: (value) => horizontalXScale.scale(value),
+        barWidthRatio,
+        barGapRatio
+    });
+    const verticalLabelInterval = getVisibleBarChartXLabelInterval({
+        labelStrategy,
+        labelSizes: xLabelSizes,
+        plotWidth: boxes.plot.width
+    });
+    const horizontalLabelInterval = getVisibleBarChartYLabelInterval({
+        labelStrategy,
+        labelSizes: xLabelSizes,
+        plotHeight: boxes.plot.height
+    });
+    const verticalXLabels = xLabelTexts.flatMap((text, index) => {
+        if (index % verticalLabelInterval !== 0) {
+            return [];
+        }
+        const key = xDomain[index];
+        const bandX = key !== undefined ? xScale.scale(key) : undefined;
+        if (bandX === undefined) {
+            return [];
+        }
+        return [
+            {
+                index,
+                text,
+                x: bandX + xScale.bandwidth / 2,
+                y: boxes.plot.y + boxes.plot.height + labelBaselineOffset,
+                textAnchor: "middle"
+            }
+        ];
+    });
+    const verticalYLabels = yTicks.map((tick) => ({
+        key: `tick-${tick}`,
+        text: formatYLabel(tick),
+        x: boxes.plot.x - 8,
+        y: yScale.scale(tick) + resolvedTheme.typography.axisLabelSize / 2 - 2
+    }));
+    const horizontalXLabels = yTicks.map((tick, index) => ({
+        index,
+        text: formatYLabel(tick),
+        x: horizontalXScale.scale(tick),
+        y: boxes.plot.y + boxes.plot.height + labelBaselineOffset,
+        textAnchor: "middle"
+    }));
+    const horizontalYLabels = xLabelTexts.flatMap((text, index) => {
+        if (index % horizontalLabelInterval !== 0) {
+            return [];
+        }
+        const key = xDomain[index];
+        const bandY = key !== undefined ? horizontalYScale.scale(key) : undefined;
+        if (bandY === undefined) {
+            return [];
+        }
+        return [
+            {
+                key: `category-${index}`,
+                text,
+                x: boxes.plot.x - 8,
+                y: bandY +
+                    horizontalYScale.bandwidth / 2 +
+                    resolvedTheme.typography.axisLabelSize / 2 -
+                    2
+            }
+        ];
+    });
+    const verticalBars = barGeometry.bars.map((bar) => ({
+        baselineY: bar.baselineY,
+        color: normalized.series[bar.seriesIndex]?.color ??
+            seriesInput[bar.seriesIndex]?.color ??
+            getBarChartSeriesColor(resolvedTheme, bar.seriesIndex),
+        dataIndex: bar.dataIndex,
+        formattedValue: formatYLabel(bar.value),
+        height: bar.height,
+        key: bar.key,
+        raw: bar.raw,
+        seriesIndex: bar.seriesIndex,
+        seriesKey: bar.seriesKey,
+        seriesLabel: bar.seriesLabel,
+        value: bar.value,
+        width: bar.width,
+        x: bar.x,
+        xLabel: formatXLabel(bar.xValue, bar.dataIndex),
+        xValue: bar.xValue,
+        y: bar.y
+    }));
+    const horizontalBars = horizontalBarGeometry.bars.map((bar) => ({
+        baselineX: bar.baselineX,
+        baselineY: bar.baselineY,
+        color: normalized.series[bar.seriesIndex]?.color ??
+            seriesInput[bar.seriesIndex]?.color ??
+            getBarChartSeriesColor(resolvedTheme, bar.seriesIndex),
+        dataIndex: bar.dataIndex,
+        formattedValue: formatYLabel(bar.value),
+        height: bar.height,
+        key: bar.key,
+        raw: bar.raw,
+        seriesIndex: bar.seriesIndex,
+        seriesKey: bar.seriesKey,
+        seriesLabel: bar.seriesLabel,
+        value: bar.value,
+        width: bar.width,
+        x: bar.x,
+        xLabel: formatXLabel(bar.xValue, bar.dataIndex),
+        xValue: bar.xValue,
+        y: bar.y
+    }));
+    const bars = isHorizontal ? horizontalBars : verticalBars;
+    const valueLabels = showValuesOnTopOfBars
+        ? bars.map((bar) => isHorizontal
+            ? {
+                key: `value-${bar.key}`,
+                text: formatYLabel(bar.value),
+                x: bar.value >= 0
+                    ? Math.min(boxes.plot.x + boxes.plot.width - 2, bar.x + bar.width + 5)
+                    : Math.max(boxes.plot.x + 2, bar.x - 5),
+                y: bar.y +
+                    bar.height / 2 +
+                    resolvedTheme.typography.axisLabelSize / 2 -
+                    2,
+                color: resolvedTheme.mutedText,
+                textAnchor: bar.value >= 0 ? "start" : "end"
+            }
+            : {
+                key: `value-${bar.key}`,
+                text: formatYLabel(bar.value),
+                x: bar.x + bar.width / 2,
+                y: bar.value >= 0
+                    ? Math.max(boxes.plot.y + 10, bar.y - 5)
+                    : Math.min(boxes.plot.y + boxes.plot.height - 2, bar.y +
+                        bar.height +
+                        resolvedTheme.typography.axisLabelSize),
+                color: resolvedTheme.mutedText
+            })
+        : [];
+    const legendWidth = legendItemsRaw.reduce((sum, item) => sum + item.width, 0) +
+        legendGap * Math.max(0, legendItemsRaw.length - 1);
+    const legendStartX = Math.max(8, (width - legendWidth) / 2);
+    const legendY = height - 8;
+    const legendItems = legendVisible
+        ? legendItemsRaw.map((item, index) => {
+            const x = legendStartX +
+                legendItemsRaw
+                    .slice(0, index)
+                    .reduce((sum, previous) => sum + previous.width + legendGap, 0);
+            return {
+                key: item.key,
+                label: item.label,
+                color: item.color,
+                markerX: x,
+                markerY: legendY - legendMarkerSize + 1,
+                labelX: x + legendMarkerSize + 6,
+                labelY: legendY
+            };
+        })
+        : [];
+    return {
+        bars,
+        boxes,
+        mode,
+        orientation,
+        resolvedTheme,
+        legendItems,
+        showHorizontalGridLines,
+        showXAxisLabels,
+        showYAxisLabels,
+        valueLabels,
+        xLabels: isHorizontal ? horizontalXLabels : verticalXLabels,
+        yLabels: isHorizontal ? horizontalYLabels : verticalYLabels,
+        yTicks
+    };
+};

package/dist/v2/react-native/charts/bar/modelUtils.d.ts

@@ -0,0 +1,27 @@
+import type { ChartXValue, Size } from "../../../core/index";
+import type { ResolvedCartesianChartTheme } from "../../theme/presets";
+import type { BarChartProps } from "./types";
+export declare const labelBaselineOffset = 20;
+export declare const measureBarChartText: (text: string, options?: {
+    fontSize?: number;
+}) => Size;
+export declare const getBarChartFontTextOptions: (theme: ResolvedCartesianChartTheme) => {
+    fontFamily?: string;
+    fontSize: number;
+};
+export declare const getBarChartSeriesColor: (theme: ResolvedCartesianChartTheme, index: number) => string;
+export declare const defaultFormatBarChartXLabel: (value: ChartXValue) => string;
+export declare const defaultFormatBarChartYLabel: (value: number) => string;
+export declare const getBarChartXKey: (value: ChartXValue) => string | number;
+export declare const getMaxBarChartTextSize: (sizes: Size[]) => Size;
+export declare const getVisibleBarChartXLabelInterval: ({ labelStrategy, labelSizes, plotWidth }: {
+    labelStrategy: BarChartProps<Record<string, unknown>>["labelStrategy"];
+    labelSizes: Size[];
+    plotWidth: number;
+}) => number;
+export declare const getVisibleBarChartYLabelInterval: ({ labelStrategy, labelSizes, plotHeight }: {
+    labelStrategy: BarChartProps<Record<string, unknown>>["labelStrategy"];
+    labelSizes: Size[];
+    plotHeight: number;
+}) => number;
+//# sourceMappingURL=modelUtils.d.ts.map

package/dist/v2/react-native/charts/bar/modelUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelUtils.d.ts","sourceRoot":"","sources":["../../../src/charts/bar/modelUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,eAAO,MAAM,mBAAmB,GAC9B,MAAM,MAAM,EACZ,UAAS;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,KAClC,IAOF,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,OAAO,2BAA2B;;;CAMlC,CAAC;AAEH,eAAO,MAAM,sBAAsB,GACjC,OAAO,2BAA2B,EAClC,OAAO,MAAM,WAC4C,CAAC;AAE5D,eAAO,MAAM,2BAA2B,GAAI,OAAO,WAAW,WAS7D,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,OAAO,MAAM,WAQxD,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,WAAW,oBACD,CAAC;AAElD,eAAO,MAAM,sBAAsB,GAAI,OAAO,IAAI,EAAE,SAOjD,CAAC;AAEJ,eAAO,MAAM,gCAAgC,GAAI,0CAI9C;IACD,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC;IACvE,UAAU,EAAE,IAAI,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,WAaA,CAAC;AAEF,eAAO,MAAM,gCAAgC,GAAI,2CAI9C;IACD,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC;IACvE,UAAU,EAAE,IAAI,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,WAaA,CAAC"}

package/dist/v2/react-native/charts/bar/modelUtils.js

@@ -0,0 +1,58 @@
+export const labelBaselineOffset = 20;
+export const measureBarChartText = (text, options = {}) => {
+    const fontSize = options.fontSize ?? 12;
+    return {
+        width: text.length * fontSize * 0.56,
+        height: 14
+    };
+};
+export const getBarChartFontTextOptions = (theme) => ({
+    fontSize: theme.typography.axisLabelSize,
+    ...(theme.typography.fontFamily
+        ? { fontFamily: theme.typography.fontFamily }
+        : {})
+});
+export const getBarChartSeriesColor = (theme, index) => theme.series[index % theme.series.length] ?? "#2563eb";
+export const defaultFormatBarChartXLabel = (value) => {
+    if (value instanceof Date) {
+        return value.toLocaleDateString("en-US", {
+            month: "short",
+            day: "numeric"
+        });
+    }
+    return String(value);
+};
+export const defaultFormatBarChartYLabel = (value) => {
+    const absolute = Math.abs(value);
+    if (absolute >= 1000) {
+        return `${Number((value / 1000).toFixed(1))}k`;
+    }
+    return String(Number(value.toFixed(2)));
+};
+export const getBarChartXKey = (value) => value instanceof Date ? value.valueOf() : value;
+export const getMaxBarChartTextSize = (sizes) => sizes.reduce((max, size) => ({
+    width: Math.max(max.width, size.width),
+    height: Math.max(max.height, size.height)
+}), { width: 0, height: 0 });
+export const getVisibleBarChartXLabelInterval = ({ labelStrategy, labelSizes, plotWidth }) => {
+    if (labelStrategy === "hide" || labelSizes.length === 0) {
+        return Number.POSITIVE_INFINITY;
+    }
+    if (labelStrategy === "show") {
+        return 1;
+    }
+    const widest = getMaxBarChartTextSize(labelSizes).width;
+    const maxVisibleLabels = Math.max(1, Math.floor(plotWidth / (widest + 10)));
+    return Math.max(1, Math.ceil(labelSizes.length / maxVisibleLabels));
+};
+export const getVisibleBarChartYLabelInterval = ({ labelStrategy, labelSizes, plotHeight }) => {
+    if (labelStrategy === "hide" || labelSizes.length === 0) {
+        return Number.POSITIVE_INFINITY;
+    }
+    if (labelStrategy === "show") {
+        return 1;
+    }
+    const tallest = getMaxBarChartTextSize(labelSizes).height;
+    const maxVisibleLabels = Math.max(1, Math.floor(plotHeight / (tallest + 8)));
+    return Math.max(1, Math.ceil(labelSizes.length / maxVisibleLabels));
+};

package/dist/v2/react-native/charts/bar/options.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedCartesianChartTheme } from "../../theme/presets";
+import type { BarChartTooltipConfig, ResolvedBarChartTooltipConfig } from "./types";
+export declare const getBarChartTooltipConfig: ({ themeTooltip, tooltip }: {
+    themeTooltip: ResolvedCartesianChartTheme["tooltip"];
+    tooltip: boolean | BarChartTooltipConfig | undefined;
+}) => ResolvedBarChartTooltipConfig;
+//# sourceMappingURL=options.d.ts.map

package/dist/v2/react-native/charts/bar/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/charts/bar/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EACV,qBAAqB,EACrB,6BAA6B,EAC9B,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,wBAAwB,GAAI,2BAGtC;IACD,YAAY,EAAE,2BAA2B,CAAC,SAAS,CAAC,CAAC;IACrD,OAAO,EAAE,OAAO,GAAG,qBAAqB,GAAG,SAAS,CAAC;CACtD,KAAG,6BAkDH,CAAC"}

package/dist/v2/react-native/charts/bar/options.js

@@ -0,0 +1,49 @@
+export const getBarChartTooltipConfig = ({ themeTooltip, tooltip }) => {
+    if (!tooltip) {
+        return {
+            anchor: "bar",
+            backgroundColor: themeTooltip.background,
+            borderColor: themeTooltip.border,
+            borderRadius: themeTooltip.borderRadius,
+            edgePadding: 4,
+            fontFamily: undefined,
+            fontSize: themeTooltip.fontSize,
+            labelColor: themeTooltip.mutedText,
+            labelFontSize: themeTooltip.labelFontSize,
+            offset: 8,
+            padding: themeTooltip.padding,
+            placement: "auto",
+            positionAnimationDuration: 0,
+            shadowColor: themeTooltip.shadowColor,
+            shadowOffsetX: themeTooltip.shadowOffsetX,
+            shadowOffsetY: themeTooltip.shadowOffsetY,
+            shadowOpacity: themeTooltip.shadowOpacity,
+            textColor: themeTooltip.text,
+            visible: false,
+            width: 126
+        };
+    }
+    const config = typeof tooltip === "object" ? tooltip : {};
+    return {
+        anchor: config.anchor ?? "bar",
+        backgroundColor: config.backgroundColor ?? themeTooltip.background,
+        borderColor: config.borderColor ?? themeTooltip.border,
+        borderRadius: config.borderRadius ?? themeTooltip.borderRadius,
+        edgePadding: Math.max(0, config.edgePadding ?? 4),
+        fontFamily: config.fontFamily,
+        fontSize: config.fontSize ?? themeTooltip.fontSize,
+        labelColor: config.labelColor ?? themeTooltip.mutedText,
+        labelFontSize: config.labelFontSize ?? themeTooltip.labelFontSize,
+        offset: Math.max(0, config.offset ?? 8),
+        padding: config.padding ?? themeTooltip.padding,
+        placement: config.placement ?? "auto",
+        positionAnimationDuration: config.positionAnimationDuration ?? 180,
+        shadowColor: config.shadowColor ?? themeTooltip.shadowColor,
+        shadowOffsetX: config.shadowOffsetX ?? themeTooltip.shadowOffsetX,
+        shadowOffsetY: config.shadowOffsetY ?? themeTooltip.shadowOffsetY,
+        shadowOpacity: config.shadowOpacity ?? themeTooltip.shadowOpacity,
+        textColor: config.textColor ?? themeTooltip.text,
+        visible: config.visible ?? true,
+        width: config.width ?? 126
+    };
+};

package/dist/v2/react-native/charts/bar/rendererSafety.d.ts

@@ -0,0 +1,12 @@
+import type { BarChartRenderer } from "./types";
+export declare const getSafeBarChartContentWidth: ({ contentWidth, renderer, scrollable }: {
+    contentWidth: number;
+    renderer: BarChartRenderer | undefined;
+    scrollable: boolean | undefined;
+}) => number;
+export declare const getSafeBarChartRenderer: ({ contentWidth, renderer, scrollable }: {
+    contentWidth: number;
+    renderer: BarChartRenderer | undefined;
+    scrollable: boolean | undefined;
+}) => import("../..").LineChartRenderer | undefined;
+//# sourceMappingURL=rendererSafety.d.ts.map