react-native-chart-kit 7.0.0-next.1 → 7.0.0-next.3

package/dist/v2/react-native/charts/line/useChartModel.d.ts

@@ -0,0 +1,103 @@
+import { type ChartKitThemeContextValue } from "../../theme";
+import type { LineChartProps, LineChartSelectionModel } from "./types";
+import { type LineChartInteractionPoint } from "./interaction";
+export declare const useChartModel: <TData extends Record<string, unknown>>({ data, xKey, yKey, yKeys, series, width, height, theme, preset, decimation, curve, connectNulls, area, areaFill, showDots, dots, selectedIndex, activeDot, crosshair, tooltip, referenceBands, referenceLines, showHorizontalGridLines, showVerticalGridLines, legend, labelStrategy, labelRotation, labelMinGap, edgeLabelPolicy, yDomain, yAxisLabelWidth, formatXLabel, formatYLabel, chartKitTheme, dataIndexOffset, selectionPointer, stableYAxisData }: LineChartProps<TData> & {
+    chartKitTheme: ChartKitThemeContextValue;
+    dataIndexOffset?: number;
+    selectionPointer?: {
+        index: number;
+        x: number;
+        y: number;
+    } | undefined;
+    stableYAxisData?: TData[] | undefined;
+}) => {
+    boxes: import("../../../core/index").ChartBoxes;
+    geometries: {
+        style: {
+            strokeWidth: number;
+            strokeStyle: import("./options").ResolvedLineChartStrokeStyle;
+            dot: import("./options").ResolvedLineChartDotConfig;
+            color: string;
+            areaFill: import("./options").ResolvedLineChartAreaFillConfig;
+            threshold: import("./options").ResolvedLineChartThresholdStyle | undefined;
+        };
+        geometry: import("../../../core/index").LineSeriesGeometry<TData>;
+    }[];
+    interactionPoints: LineChartInteractionPoint<TData>[];
+    legendModel: {
+        config: import("./types").ResolvedLineChartLegendConfig;
+        renderProps: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            position: import("./types").LineChartLegendPosition;
+            align: import("./types").LineChartLegendAlign;
+            theme: import("../../theme").ResolvedCartesianChartTheme;
+            items: ({
+                labelColor: string;
+                labelGap: number;
+                paddingHorizontal: number;
+                paddingVertical: number;
+                strokeDasharray: readonly number[] | undefined;
+                strokeLinecap: import("./options").LineChartStrokeLinecap;
+                strokeOpacity: number;
+                strokeWidth: number;
+                fontFamily: string;
+                index: number;
+                key: string;
+                label: string;
+                color: string;
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+                contentX: number;
+                contentY: number;
+                contentWidth: number;
+                contentHeight: number;
+                markerSize: number;
+                marker: import("./types").LineChartLegendMarker;
+                fontSize: number;
+            } | {
+                labelColor: string;
+                labelGap: number;
+                paddingHorizontal: number;
+                paddingVertical: number;
+                strokeDasharray: readonly number[] | undefined;
+                strokeLinecap: import("./options").LineChartStrokeLinecap;
+                strokeOpacity: number;
+                strokeWidth: number;
+                fontFamily?: never;
+                index: number;
+                key: string;
+                label: string;
+                color: string;
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+                contentX: number;
+                contentY: number;
+                contentWidth: number;
+                contentHeight: number;
+                markerSize: number;
+                marker: import("./types").LineChartLegendMarker;
+                fontSize: number;
+            })[];
+        };
+    } | undefined;
+    referenceBandModels: import("./references").LineChartReferenceBandModel[];
+    referenceLineModels: import("./references").LineChartReferenceLineModel[];
+    resolvedTheme: import("../../theme").ResolvedCartesianChartTheme;
+    showHorizontalGridLines: boolean;
+    showVerticalGridLines: boolean;
+    crosshairConfig: import("./options").ResolvedLineChartCrosshairConfig;
+    selectionModel: LineChartSelectionModel<TData> | undefined;
+    xLabelLayout: import("./xLabels").XLabelLayout;
+    yScale: import("../../../core/index").LinearScale;
+    yTicks: number[];
+    formatYLabel: (value: number) => string;
+};
+export type LineChartModel<TData extends Record<string, unknown>> = ReturnType<typeof useChartModel<TData>>;
+//# sourceMappingURL=useChartModel.d.ts.map

package/dist/v2/react-native/charts/line/useChartModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChartModel.d.ts","sourceRoot":"","sources":["../../../src/charts/line/useChartModel.ts"],"names":[],"mappings":"AASA,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,aAAa,CAAC;AAwBrB,OAAO,KAAK,EAGV,cAAc,EAEd,uBAAuB,EACxB,MAAM,SAAS,CAAC;AAajB,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,eAAe,CAAC;AAMvB,eAAO,MAAM,aAAa,GAAI,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,+bAsClE,cAAc,CAAC,KAAK,CAAC,GAAG;IACzB,aAAa,EAAE,yBAAyB,CAAC;IACzC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IACvE,eAAe,CAAC,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC;CACvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkYA,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,UAAU,CAC5E,OAAO,aAAa,CAAC,KAAK,CAAC,CAC5B,CAAC"}

package/dist/v2/react-native/charts/line/useChartModel.js

@@ -0,0 +1,367 @@
+import { useMemo } from "react";
+import { buildLineSeriesGeometry, calculateAutoPadding, createLinearScale, solveChartBoxes } from "../../../core/index";
+import { resolveCartesianChartThemeConfig } from "../../theme";
+import { getLineChartAreaFillConfig, getLineChartCrosshairConfig, getLineChartDotConfig, getLineChartStrokeStyle, getLineChartTooltipConfig, resolveLineChartDecimationConfig } from "./options";
+import { buildLineChartSeriesStyleMap } from "./seriesStyles";
+import { resolveLineChartYAxisModel } from "./yAxisModel";
+import { getSelectedLineSeries } from "./selection";
+import { getLineChartTooltipModel } from "./tooltip";
+import { buildLegendLayout, getLegendConfig, getLegendX, getLegendY } from "./legend";
+import { buildLineChartReferenceBandModels, buildLineChartReferenceLineModels } from "./references";
+import { getFontFamilyProps, measureLineChartText } from "./text";
+import { defaultLabelRotation, getMaxSize, resolveXLabelLayout, xLabelBaselineOffset } from "./xLabels";
+import { buildXLabelCandidates } from "./xLabelCandidates";
+import { defaultFormatXLabel, defaultFormatYLabel, getSeriesColor } from "./utils";
+import { normalizeLineChartSelectedIndex } from "./interaction";
+import { useSeriesInput } from "./seriesInput";
+import { buildLineChartXScale } from "./xScale";
+const defaultYDomain = { includeZero: true, nice: true };
+export const useChartModel = ({ data, xKey, yKey, yKeys, series, width, height, theme, preset, decimation = "auto", curve = "linear", connectNulls = false, area = false, areaFill, showDots = true, dots, selectedIndex, activeDot, crosshair, tooltip, referenceBands, referenceLines, showHorizontalGridLines = false, showVerticalGridLines = false, legend, labelStrategy = "auto", labelRotation = defaultLabelRotation, labelMinGap = 8, edgeLabelPolicy = "shift", yDomain = defaultYDomain, yAxisLabelWidth, formatXLabel = defaultFormatXLabel, formatYLabel = defaultFormatYLabel, chartKitTheme, dataIndexOffset = 0, selectionPointer, stableYAxisData }) => {
+    const seriesInput = useSeriesInput(yKey, yKeys, series);
+    return useMemo(() => {
+        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 axisTextOptions = {
+            fontSize: resolvedTheme.typography.axisLabelSize,
+            ...getFontFamilyProps(resolvedTheme.typography.fontFamily)
+        };
+        const { normalized, yDomainResolved, yLabelSizes, yTicks } = resolveLineChartYAxisModel({
+            data,
+            formatYLabel,
+            measureText: measureLineChartText,
+            series: seriesInput,
+            stableData: stableYAxisData,
+            textOptions: axisTextOptions,
+            xKey,
+            yAxisLabelWidth,
+            yDomain
+        });
+        const legendConfig = getLegendConfig(legend, normalized.series.length, resolvedTheme);
+        const xValues = normalized.series[0]?.points.map((point) => point.x) ?? [];
+        const xLabelTexts = xValues.map((value, index) => formatXLabel(value, index + dataIndexOffset));
+        const xLabelSizes = xLabelTexts.map((text) => measureLineChartText(text, axisTextOptions));
+        const styleByKey = buildLineChartSeriesStyleMap({
+            areaFill,
+            dots,
+            resolvedTheme,
+            seriesInput,
+            showDots
+        });
+        const legendLayout = legendConfig.visible
+            ? buildLegendLayout({
+                config: legendConfig,
+                items: normalized.series.map((item) => ({
+                    id: item.key,
+                    label: item.label
+                })),
+                maxWidth: width,
+                measureText: measureLineChartText
+            })
+            : undefined;
+        const baseAutoPaddingOptions = {
+            base: { top: 16, right: 18, bottom: 12, left: 10 },
+            leftLabels: yLabelSizes,
+            gap: 8
+        };
+        const withLegendPaddingOptions = (bottomLabelHeight) => legendLayout
+            ? {
+                ...baseAutoPaddingOptions,
+                bottomLabels: bottomLabelHeight > 0
+                    ? [{ width: 1, height: bottomLabelHeight }]
+                    : [],
+                legend: {
+                    width: Math.min(width - 32, legendLayout.width),
+                    height: legendLayout.height,
+                    position: legendLayout.position
+                }
+            }
+            : {
+                ...baseAutoPaddingOptions,
+                bottomLabels: bottomLabelHeight > 0
+                    ? [{ width: 1, height: bottomLabelHeight }]
+                    : []
+            };
+        const initialPadding = calculateAutoPadding(withLegendPaddingOptions(getMaxSize(xLabelSizes).height));
+        const initialBoxes = solveChartBoxes({ width, height }, initialPadding);
+        const initialXScale = buildLineChartXScale({
+            boxes: initialBoxes,
+            xValues
+        });
+        const initialXLabelLayout = resolveXLabelLayout({
+            candidates: buildXLabelCandidates({
+                dataIndexOffset,
+                labelStrategy,
+                series: normalized.series[0],
+                xLabelSizes,
+                xLabelTexts,
+                xScale: initialXScale,
+                xValues
+            }),
+            plotWidth: initialBoxes.plot.width,
+            chartWidth: width,
+            strategy: labelStrategy,
+            rotation: labelRotation,
+            edgeLabelPolicy,
+            minGap: labelMinGap,
+            baseY: initialBoxes.plot.y + initialBoxes.plot.height + xLabelBaselineOffset
+        });
+        const padding = calculateAutoPadding(withLegendPaddingOptions(initialXLabelLayout.height));
+        const boxes = solveChartBoxes({ width, height }, padding);
+        const yScale = createLinearScale({
+            domain: yDomainResolved,
+            range: [boxes.plot.y + boxes.plot.height, boxes.plot.y]
+        });
+        const referenceBandModels = buildLineChartReferenceBandModels({
+            bands: referenceBands,
+            plot: boxes.plot,
+            theme: resolvedTheme,
+            yScale
+        });
+        const xScale = buildLineChartXScale({ boxes, xValues });
+        const pathDecimation = resolveLineChartDecimationConfig({
+            decimation,
+            plotWidth: boxes.plot.width
+        });
+        const baselineValue = yDomainResolved[0] < 0 && yDomainResolved[1] > 0 ? 0 : yDomainResolved[0];
+        const baselineY = yScale.scale(baselineValue);
+        const geometries = normalized.series.map((item, index) => {
+            const style = styleByKey.get(item.key);
+            const wantsArea = style?.area ?? area;
+            const color = item.color ?? style?.color ?? getSeriesColor(resolvedTheme, index);
+            return {
+                style: {
+                    strokeWidth: style?.strokeWidth ?? 3,
+                    strokeStyle: style?.strokeStyle ?? getLineChartStrokeStyle(),
+                    dot: style?.dot ??
+                        getLineChartDotConfig({
+                            dots,
+                            seriesDot: undefined,
+                            showDots
+                        }),
+                    color,
+                    areaFill: style?.areaFill ??
+                        getLineChartAreaFillConfig({ areaFill, seriesColor: color }),
+                    threshold: style?.threshold
+                },
+                geometry: buildLineSeriesGeometry({
+                    series: item,
+                    xScale,
+                    yScale: (value) => yScale.scale(value),
+                    curve: style?.curve ?? curve,
+                    connectNulls,
+                    dataIndexOffset,
+                    pathDecimation,
+                    ...(wantsArea ? { areaBaselineY: baselineY } : {})
+                })
+            };
+        });
+        const referenceLineModels = buildLineChartReferenceLineModels({
+            geometries: geometries.map(({ geometry }) => geometry),
+            lines: referenceLines,
+            plot: boxes.plot,
+            theme: resolvedTheme,
+            yScale
+        });
+        const interactionPoints = geometries[0]?.geometry.points.flatMap((point) => {
+            if (!Number.isFinite(point.x)) {
+                return [];
+            }
+            const dataIndex = point.dataIndex;
+            const xLabel = xLabelTexts[dataIndex - dataIndexOffset] ?? String(point.xValue);
+            const interactionPoint = {
+                dataIndex,
+                x: point.x,
+                xValue: point.xValue,
+                xLabel
+            };
+            return point.raw !== undefined
+                ? [{ ...interactionPoint, raw: point.raw }]
+                : [interactionPoint];
+        }) ?? [];
+        const xLabelLayout = resolveXLabelLayout({
+            candidates: buildXLabelCandidates({
+                dataIndexOffset,
+                labelStrategy,
+                series: normalized.series[0],
+                xLabelSizes,
+                xLabelTexts,
+                xScale,
+                xValues
+            }),
+            plotWidth: boxes.plot.width,
+            chartWidth: width,
+            strategy: labelStrategy,
+            rotation: labelRotation,
+            edgeLabelPolicy,
+            minGap: labelMinGap,
+            baseY: boxes.plot.y + boxes.plot.height + xLabelBaselineOffset
+        });
+        const crosshairConfig = getLineChartCrosshairConfig({
+            crosshair,
+            themeAxisColor: resolvedTheme.axis
+        });
+        const tooltipConfig = getLineChartTooltipConfig({
+            tooltip,
+            themeFontFamily: resolvedTheme.typography.fontFamily,
+            themeTooltip: resolvedTheme.tooltip
+        });
+        const roundedSelectedIndex = normalizeLineChartSelectedIndex(selectedIndex);
+        const selectedDataIndex = roundedSelectedIndex !== undefined &&
+            roundedSelectedIndex >= dataIndexOffset &&
+            roundedSelectedIndex < dataIndexOffset + xValues.length
+            ? roundedSelectedIndex
+            : undefined;
+        const selectedSeries = getSelectedLineSeries({
+            activeDot,
+            formatYLabel,
+            geometries,
+            selectedDataIndex
+        });
+        const selectionBase = selectedDataIndex !== undefined && selectedSeries.length > 0
+            ? {
+                index: selectedDataIndex,
+                x: selectedSeries[0].point.x,
+                y: Math.min(...selectedSeries.map((item) => item.point.y)),
+                xLabel: xLabelTexts[selectedDataIndex - dataIndexOffset] ??
+                    String(selectedDataIndex),
+                series: selectedSeries
+            }
+            : undefined;
+        const selectionModel = selectionBase
+            ? {
+                ...selectionBase,
+                tooltip: getLineChartTooltipModel({
+                    chartHeight: height,
+                    chartWidth: width,
+                    config: tooltipConfig,
+                    measureText: measureLineChartText,
+                    plotX: boxes.plot.x,
+                    plotY: boxes.plot.y,
+                    selection: selectionPointer?.index === selectionBase.index
+                        ? { ...selectionBase, pointer: selectionPointer }
+                        : selectionBase,
+                    theme: resolvedTheme
+                })
+            }
+            : undefined;
+        const legendOrigin = legendLayout && legendLayout.items.length > 0
+            ? {
+                x: getLegendX({
+                    align: legendConfig.align,
+                    boxes,
+                    legendWidth: legendLayout.width,
+                    width
+                }),
+                y: getLegendY({
+                    boxes,
+                    xLabelHeight: xLabelLayout.height,
+                    xLabelLineHeight: getMaxSize(xLabelSizes).height,
+                    legendHeight: legendLayout.height,
+                    position: legendConfig.position
+                })
+            }
+            : undefined;
+        const legendModel = legendLayout && legendOrigin
+            ? {
+                config: legendConfig,
+                renderProps: {
+                    x: legendOrigin.x,
+                    y: legendOrigin.y,
+                    width: legendLayout.width,
+                    height: legendLayout.height,
+                    position: legendConfig.position,
+                    align: legendConfig.align,
+                    theme: resolvedTheme,
+                    items: legendLayout.items.map((item, index) => {
+                        const style = styleByKey.get(item.id);
+                        return {
+                            index,
+                            key: item.id,
+                            label: item.label,
+                            color: style?.color ?? getSeriesColor(resolvedTheme, index),
+                            x: legendOrigin.x + item.x,
+                            y: legendOrigin.y + item.y,
+                            width: item.width,
+                            height: item.height,
+                            contentX: legendOrigin.x + item.contentX,
+                            contentY: legendOrigin.y + item.contentY,
+                            contentWidth: item.contentWidth,
+                            contentHeight: item.contentHeight,
+                            markerSize: item.markerSize ?? legendConfig.markerSize,
+                            marker: legendConfig.marker,
+                            fontSize: legendConfig.fontSize,
+                            ...getFontFamilyProps(legendConfig.fontFamily),
+                            labelColor: legendConfig.labelColor,
+                            labelGap: legendConfig.labelGap,
+                            paddingHorizontal: legendConfig.itemPaddingHorizontal,
+                            paddingVertical: legendConfig.itemPaddingVertical,
+                            strokeDasharray: style?.strokeStyle.strokeDasharray,
+                            strokeLinecap: style?.strokeStyle.strokeLinecap ?? "round",
+                            strokeOpacity: style?.strokeStyle.strokeOpacity ?? 1,
+                            strokeWidth: style?.strokeWidth ?? 3
+                        };
+                    })
+                }
+            }
+            : undefined;
+        return {
+            boxes,
+            geometries,
+            interactionPoints,
+            legendModel,
+            referenceBandModels,
+            referenceLineModels,
+            resolvedTheme,
+            showHorizontalGridLines,
+            showVerticalGridLines,
+            crosshairConfig,
+            selectionModel,
+            xLabelLayout,
+            yScale,
+            yTicks,
+            formatYLabel
+        };
+    }, [
+        area,
+        areaFill,
+        activeDot,
+        connectNulls,
+        crosshair,
+        curve,
+        data,
+        decimation,
+        dataIndexOffset,
+        dots,
+        formatXLabel,
+        formatYLabel,
+        height,
+        edgeLabelPolicy,
+        labelMinGap,
+        labelRotation,
+        labelStrategy,
+        legend,
+        referenceBands,
+        referenceLines,
+        selectedIndex,
+        selectionPointer,
+        seriesInput,
+        showDots,
+        showHorizontalGridLines,
+        showVerticalGridLines,
+        stableYAxisData,
+        theme,
+        preset,
+        chartKitTheme,
+        tooltip,
+        width,
+        xKey,
+        yAxisLabelWidth,
+        yDomain
+    ]);
+};

package/dist/v2/react-native/charts/line/useDebugLayout.d.ts

@@ -0,0 +1,16 @@
+import type { LayoutDebugModel } from "../../../core/index";
+import type { LineChartYAxisLabelModel } from "./axisLabels";
+import type { LineChartModel } from "./useChartModel";
+export declare const useLineChartDebugLayout: <TData extends Record<string, unknown>>({ enabled, model, onLayoutDebug, tooltip, yAxisLabels }: {
+    enabled: boolean;
+    model: LineChartModel<TData>;
+    onLayoutDebug?: ((model: LayoutDebugModel) => void) | undefined;
+    tooltip?: {
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+    } | undefined;
+    yAxisLabels: LineChartYAxisLabelModel[];
+}) => LayoutDebugModel | undefined;
+//# sourceMappingURL=useDebugLayout.d.ts.map

package/dist/v2/react-native/charts/line/useDebugLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDebugLayout.d.ts","sourceRoot":"","sources":["../../../src/charts/line/useDebugLayout.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAKxD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,eAAO,MAAM,uBAAuB,GAAI,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,yDAM5E;IACD,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC;IAC7B,aAAa,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAChE,OAAO,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IAC9E,WAAW,EAAE,wBAAwB,EAAE,CAAC;CACzC,iCAkDA,CAAC"}

package/dist/v2/react-native/charts/line/useDebugLayout.js

@@ -0,0 +1,35 @@
+import { useEffect, useMemo } from "react";
+import { buildLineChartDebugLayoutModel } from "./debugLayout";
+import { getFontFamilyProps, measureLineChartText } from "./text";
+export const useLineChartDebugLayout = ({ enabled, model, onLayoutDebug, tooltip, yAxisLabels }) => {
+    const { boxes, legendModel, resolvedTheme, xLabelLayout } = model;
+    const debugLayoutModel = useMemo(() => enabled
+        ? buildLineChartDebugLayoutModel({
+            boxes,
+            legendItems: legendModel?.renderProps.items,
+            measureYLabel: (text) => measureLineChartText(text, {
+                fontSize: resolvedTheme.typography.axisLabelSize,
+                ...getFontFamilyProps(resolvedTheme.typography.fontFamily)
+            }),
+            tooltip,
+            xLabels: xLabelLayout.items,
+            yAxisLabelFontSize: resolvedTheme.typography.axisLabelSize,
+            yLabels: yAxisLabels
+        })
+        : undefined, [
+        boxes,
+        enabled,
+        legendModel,
+        resolvedTheme.typography.axisLabelSize,
+        resolvedTheme.typography.fontFamily,
+        tooltip,
+        xLabelLayout.items,
+        yAxisLabels
+    ]);
+    useEffect(() => {
+        if (debugLayoutModel) {
+            onLayoutDebug?.(debugLayoutModel);
+        }
+    }, [debugLayoutModel, onLayoutDebug]);
+    return debugLayoutModel;
+};

package/dist/v2/react-native/charts/line/utils.d.ts

@@ -0,0 +1,10 @@
+import type { ChartXValue } from "../../../core/index";
+import type { ResolvedCartesianChartTheme } from "../../theme";
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const unique: <TValue>(values: TValue[]) => TValue[];
+export declare const getSeriesColor: (theme: ResolvedCartesianChartTheme, index: number) => string;
+export declare const defaultFormatXLabel: (value: ChartXValue) => string;
+export declare const defaultFormatYLabel: (value: number) => string;
+export declare const getXKey: (value: ChartXValue) => string | number;
+export declare const getXScaleType: (values: ChartXValue[]) => "point" | "linear" | "time";
+//# sourceMappingURL=utils.d.ts.map

package/dist/v2/react-native/charts/line/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/charts/line/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAE/D,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,WAM5D,CAAC;AAEF,eAAO,MAAM,MAAM,GAAI,MAAM,EAAE,QAAQ,MAAM,EAAE,aAE9C,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,OAAO,2BAA2B,EAClC,OAAO,MAAM,WAGd,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,OAAO,WAAW,WASrD,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,WAQhD,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,OAAO,WAAW,oBAEzC,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,QAAQ,WAAW,EAAE,gCAUlD,CAAC"}

package/dist/v2/react-native/charts/line/utils.js

@@ -0,0 +1,40 @@
+export const clamp = (value, min, max) => {
+    if (max < min) {
+        return min;
+    }
+    return Math.min(Math.max(value, min), max);
+};
+export const unique = (values) => {
+    return values.filter((value, index) => values.indexOf(value) === index);
+};
+export const getSeriesColor = (theme, index) => {
+    return theme.series[index % theme.series.length] ?? "#2563eb";
+};
+export const defaultFormatXLabel = (value) => {
+    if (value instanceof Date) {
+        return value.toLocaleDateString("en-US", {
+            month: "short",
+            day: "numeric"
+        });
+    }
+    return String(value);
+};
+export const defaultFormatYLabel = (value) => {
+    const absolute = Math.abs(value);
+    if (absolute >= 1000) {
+        return `${Number((value / 1000).toFixed(1))}k`;
+    }
+    return String(Number(value.toFixed(2)));
+};
+export const getXKey = (value) => {
+    return value instanceof Date ? value.valueOf() : value;
+};
+export const getXScaleType = (values) => {
+    if (values.every((value) => value instanceof Date)) {
+        return "time";
+    }
+    if (values.every((value) => typeof value === "number")) {
+        return "linear";
+    }
+    return "point";
+};

package/dist/v2/react-native/charts/line/viewportInteraction.d.ts

@@ -0,0 +1,3 @@
+export { useChartViewportPan as useLineChartViewportPan } from "../../viewport/pan";
+export type { ChartViewportPanHandlers as LineChartViewportPanHandlers } from "../../viewport/pan";
+//# sourceMappingURL=viewportInteraction.d.ts.map

package/dist/v2/react-native/charts/line/viewportInteraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewportInteraction.d.ts","sourceRoot":"","sources":["../../../src/charts/line/viewportInteraction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,IAAI,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AACpF,YAAY,EAAE,wBAAwB,IAAI,4BAA4B,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/v2/react-native/charts/line/viewportInteraction.js

@@ -0,0 +1 @@
+export { useChartViewportPan as useLineChartViewportPan } from "../../viewport/pan";

package/dist/v2/react-native/charts/line/viewportPinchZoom.d.ts

@@ -0,0 +1,2 @@
+export { ChartViewportGesture as LineChartViewportGesture, useChartViewportPinchZoom as useLineChartViewportPinchZoom } from "../../viewport/pinchZoom";
+//# sourceMappingURL=viewportPinchZoom.d.ts.map

package/dist/v2/react-native/charts/line/viewportPinchZoom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewportPinchZoom.d.ts","sourceRoot":"","sources":["../../../src/charts/line/viewportPinchZoom.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,IAAI,wBAAwB,EAChD,yBAAyB,IAAI,6BAA6B,EAC3D,MAAM,0BAA0B,CAAC"}

package/dist/v2/react-native/charts/line/viewportPinchZoom.js

@@ -0,0 +1 @@
+export { ChartViewportGesture as LineChartViewportGesture, useChartViewportPinchZoom as useLineChartViewportPinchZoom } from "../../viewport/pinchZoom";

package/dist/v2/react-native/charts/line/xLabelCandidates.d.ts

@@ -0,0 +1,13 @@
+import type { ChartXValue, NormalizedSeries, ProjectScale, Size } from "../../../core/index";
+import type { LineChartLabelStrategy } from "./types";
+import { type XLabelCandidate } from "./xLabels";
+export declare const buildXLabelCandidates: <TData>({ dataIndexOffset, labelStrategy, series, xLabelSizes, xLabelTexts, xScale, xValues }: {
+    dataIndexOffset: number;
+    labelStrategy: LineChartLabelStrategy;
+    series: NormalizedSeries<TData> | undefined;
+    xLabelSizes: Size[];
+    xLabelTexts: string[];
+    xScale: ProjectScale<TData>;
+    xValues: ChartXValue[];
+}) => XLabelCandidate[];
+//# sourceMappingURL=xLabelCandidates.d.ts.map

package/dist/v2/react-native/charts/line/xLabelCandidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xLabelCandidates.d.ts","sourceRoot":"","sources":["../../../src/charts/line/xLabelCandidates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAChB,YAAY,EACZ,IAAI,EACL,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AAEzE,eAAO,MAAM,qBAAqB,GAAI,KAAK,EAAE,uFAQ1C;IACD,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,sBAAsB,CAAC;IACtC,MAAM,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAC5C,WAAW,EAAE,IAAI,EAAE,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IAC5B,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB,KAAG,eAAe,EAyBlB,CAAC"}

package/dist/v2/react-native/charts/line/xLabelCandidates.js

@@ -0,0 +1,23 @@
+import { dedupeXLabelCandidates } from "./xLabels";
+export const buildXLabelCandidates = ({ dataIndexOffset, labelStrategy, series, xLabelSizes, xLabelTexts, xScale, xValues }) => {
+    const candidates = xValues.flatMap((value, index) => {
+        const point = series?.points[index];
+        const x = point ? xScale(value, point) : undefined;
+        const text = xLabelTexts[index];
+        const size = xLabelSizes[index];
+        if (x === undefined || text === undefined || size === undefined) {
+            return [];
+        }
+        return [
+            {
+                index: index + dataIndexOffset,
+                value,
+                text,
+                x,
+                size
+            }
+        ];
+    });
+    const shouldDedupeLabels = labelStrategy === "auto" || labelStrategy === "skip";
+    return shouldDedupeLabels ? dedupeXLabelCandidates(candidates) : candidates;
+};