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

package/dist/v2/react-native/theme/presets.js

@@ -0,0 +1,298 @@
+export const defaultCartesianChartTypography = {
+    axisLabelSize: 11,
+    legendLabelSize: 11
+};
+const resolveCartesianChartTooltipTheme = (theme, tooltip) => ({
+    background: tooltip?.background ?? theme.plotBackground,
+    border: tooltip?.border ?? theme.axis,
+    text: tooltip?.text ?? theme.text,
+    mutedText: tooltip?.mutedText ?? theme.mutedText,
+    shadowColor: tooltip?.shadowColor ?? "#020617",
+    shadowOpacity: tooltip?.shadowOpacity ?? 0.16,
+    shadowOffsetX: tooltip?.shadowOffsetX ?? 0,
+    shadowOffsetY: tooltip?.shadowOffsetY ?? 3,
+    borderRadius: tooltip?.borderRadius ?? 8,
+    padding: tooltip?.padding ?? 10,
+    fontSize: tooltip?.fontSize ?? theme.typography.legendLabelSize,
+    labelFontSize: tooltip?.labelFontSize ?? theme.typography.legendLabelSize
+});
+const createResolvedCartesianChartTheme = (theme) => ({
+    ...theme,
+    tooltip: resolveCartesianChartTooltipTheme(theme, theme.tooltip)
+});
+const defaultLightTheme = {
+    background: "#ffffff",
+    plotBackground: "#ffffff",
+    grid: "#e5e7eb",
+    axis: "#e5e7eb",
+    text: "#0f172a",
+    mutedText: "#64748b",
+    series: ["#2563eb", "#0891b2", "#7c3aed", "#16a34a"],
+    typography: defaultCartesianChartTypography
+};
+const defaultDarkTheme = {
+    background: "#0f172a",
+    plotBackground: "#111827",
+    grid: "#334155",
+    axis: "#475569",
+    text: "#e5e7eb",
+    mutedText: "#94a3b8",
+    series: ["#38bdf8", "#a78bfa", "#22c55e", "#f59e0b"],
+    typography: defaultCartesianChartTypography
+};
+const resolvedDefaultThemes = {
+    light: createResolvedCartesianChartTheme(defaultLightTheme),
+    dark: createResolvedCartesianChartTheme(defaultDarkTheme)
+};
+export const builtInCartesianChartPresets = {
+    default: {
+        light: defaultLightTheme,
+        dark: defaultDarkTheme
+    },
+    spectrum: {
+        light: {
+            background: "#ffffff",
+            plotBackground: "#ffffff",
+            grid: "#dbe5f1",
+            axis: "#cfdae8",
+            text: "#102033",
+            mutedText: "#55708d",
+            series: ["#2563eb", "#10b981", "#f59e0b", "#7c3aed"],
+            typography: defaultCartesianChartTypography
+        },
+        dark: {
+            background: "#07111f",
+            plotBackground: "#0b1627",
+            grid: "#1d3554",
+            axis: "#2d4867",
+            text: "#e8f1ff",
+            mutedText: "#9db2cb",
+            series: ["#60a5fa", "#34d399", "#fbbf24", "#c084fc"],
+            typography: defaultCartesianChartTypography
+        }
+    },
+    aurora: {
+        light: {
+            background: "#f8fbff",
+            plotBackground: "#ffffff",
+            grid: "#d9e5f2",
+            axis: "#c6d6e6",
+            text: "#08111f",
+            mutedText: "#52667d",
+            series: ["#0284c7", "#8b5cf6", "#14b8a6", "#f97316"],
+            typography: defaultCartesianChartTypography
+        },
+        dark: {
+            background: "#020617",
+            plotBackground: "#0c1424",
+            grid: "#1e3a5f",
+            axis: "#2c5078",
+            text: "#f8fafc",
+            mutedText: "#9fb6d1",
+            series: ["#38bdf8", "#a78bfa", "#2dd4bf", "#fb923c"],
+            typography: defaultCartesianChartTypography
+        }
+    },
+    verdant: {
+        light: {
+            background: "#fbfefc",
+            plotBackground: "#ffffff",
+            grid: "#dbeee5",
+            axis: "#c9dfd4",
+            text: "#10221a",
+            mutedText: "#5f776b",
+            series: ["#059669", "#e11d48", "#0ea5e9", "#84cc16"],
+            typography: defaultCartesianChartTypography
+        },
+        dark: {
+            background: "#07130f",
+            plotBackground: "#0b1c15",
+            grid: "#214638",
+            axis: "#315b4c",
+            text: "#eefbf4",
+            mutedText: "#a8c7b7",
+            series: ["#34d399", "#fb7185", "#38bdf8", "#bef264"],
+            typography: defaultCartesianChartTypography
+        }
+    },
+    cupertino: {
+        light: {
+            background: "#f9f9fb",
+            plotBackground: "#ffffff",
+            grid: "#e5e5ea",
+            axis: "#d1d1d6",
+            text: "#1c1c1e",
+            mutedText: "#6e6e73",
+            series: ["#007aff", "#34c759", "#ff9500", "#ff2d55"],
+            typography: defaultCartesianChartTypography
+        },
+        dark: {
+            background: "#000000",
+            plotBackground: "#1c1c1e",
+            grid: "#38383a",
+            axis: "#48484a",
+            text: "#f5f5f7",
+            mutedText: "#aeaeb2",
+            series: ["#0a84ff", "#30d158", "#ff9f0a", "#ff375f"],
+            typography: defaultCartesianChartTypography
+        }
+    },
+    material: {
+        light: {
+            background: "#fffbfe",
+            plotBackground: "#ffffff",
+            grid: "#e7e0ec",
+            axis: "#cac4d0",
+            text: "#1d1b20",
+            mutedText: "#625b71",
+            series: ["#6750a4", "#006a6a", "#b3261e", "#7d5260"],
+            typography: defaultCartesianChartTypography
+        },
+        dark: {
+            background: "#141218",
+            plotBackground: "#1d1b20",
+            grid: "#49454f",
+            axis: "#5d5668",
+            text: "#e6e0e9",
+            mutedText: "#cac4d0",
+            series: ["#d0bcff", "#4fd8d8", "#ffb4ab", "#efb8c8"],
+            typography: defaultCartesianChartTypography
+        }
+    },
+    graphite: {
+        light: {
+            background: "#ffffff",
+            plotBackground: "#ffffff",
+            grid: "#eceff3",
+            axis: "#e2e6ec",
+            text: "#111827",
+            mutedText: "#6b7280",
+            series: ["#111827", "#64748b", "#94a3b8", "#cbd5e1"],
+            typography: defaultCartesianChartTypography
+        },
+        dark: {
+            background: "#0b0d10",
+            plotBackground: "#111418",
+            grid: "#2a2f36",
+            axis: "#3a4048",
+            text: "#f3f4f6",
+            mutedText: "#a1a8b3",
+            series: ["#f8fafc", "#cbd5e1", "#94a3b8", "#64748b"],
+            typography: defaultCartesianChartTypography
+        }
+    },
+    contrast: {
+        light: {
+            background: "#ffffff",
+            plotBackground: "#ffffff",
+            grid: "#111827",
+            axis: "#111827",
+            text: "#000000",
+            mutedText: "#1f2937",
+            series: ["#005fcc", "#d0006f", "#008a00", "#a15c00"],
+            typography: {
+                axisLabelSize: 12,
+                legendLabelSize: 12
+            }
+        },
+        dark: {
+            background: "#000000",
+            plotBackground: "#050505",
+            grid: "#f9fafb",
+            axis: "#f9fafb",
+            text: "#ffffff",
+            mutedText: "#e5e7eb",
+            series: ["#7dd3fc", "#f0abfc", "#86efac", "#fde68a"],
+            typography: {
+                axisLabelSize: 12,
+                legendLabelSize: 12
+            }
+        }
+    },
+    midnight: {
+        light: {
+            background: "#f6f8fb",
+            plotBackground: "#ffffff",
+            grid: "#d8e0eb",
+            axis: "#c7d2df",
+            text: "#0b1220",
+            mutedText: "#53657a",
+            series: ["#0f766e", "#2563eb", "#9333ea", "#ea580c"],
+            typography: defaultCartesianChartTypography
+        },
+        dark: {
+            background: "#020617",
+            plotBackground: "#07111f",
+            grid: "#1e293b",
+            axis: "#334155",
+            text: "#e2e8f0",
+            mutedText: "#94a3b8",
+            series: ["#22d3ee", "#34d399", "#f59e0b", "#f472b6"],
+            typography: defaultCartesianChartTypography
+        }
+    }
+};
+export const createChartPreset = (preset) => preset;
+const isModePreset = (preset) => "light" in preset || "dark" in preset;
+const getPresetTheme = ({ mode, preset, registry }) => {
+    const presetInput = typeof preset === "string"
+        ? (registry[preset] ?? builtInCartesianChartPresets.default)
+        : preset;
+    if (!presetInput) {
+        return builtInCartesianChartPresets.default[mode];
+    }
+    if (isModePreset(presetInput)) {
+        return (presetInput[mode] ??
+            presetInput.light ??
+            presetInput.dark ??
+            builtInCartesianChartPresets.default[mode]);
+    }
+    return presetInput;
+};
+export const mergeCartesianChartTheme = (base, override) => {
+    if (!override) {
+        return base;
+    }
+    const typography = {
+        axisLabelSize: override.typography?.axisLabelSize ?? base.typography.axisLabelSize,
+        legendLabelSize: override.typography?.legendLabelSize ?? base.typography.legendLabelSize
+    };
+    const fontFamily = override.typography?.fontFamily ?? base.typography.fontFamily;
+    if (fontFamily) {
+        typography.fontFamily = fontFamily;
+    }
+    const mergedTheme = {
+        background: override.background ?? base.background,
+        plotBackground: override.plotBackground ?? base.plotBackground,
+        grid: override.grid ?? base.grid,
+        axis: override.axis ?? base.axis,
+        text: override.text ?? base.text,
+        mutedText: override.mutedText ?? base.mutedText,
+        series: override.series ?? base.series,
+        typography
+    };
+    return {
+        ...mergedTheme,
+        tooltip: resolveCartesianChartTooltipTheme(mergedTheme, override.tooltip ?? base.tooltip)
+    };
+};
+export const resolveCartesianChartThemeConfig = ({ mode, preset = "default", presets = {}, theme }) => {
+    const registry = {
+        ...builtInCartesianChartPresets,
+        ...presets
+    };
+    const presetTheme = getPresetTheme({ mode, preset, registry });
+    const baseTheme = resolvedDefaultThemes[mode];
+    const mergedTheme = mergeCartesianChartTheme(mergeCartesianChartTheme(baseTheme, presetTheme), theme);
+    const hasTooltipOverride = presetTheme.tooltip !== undefined || theme?.tooltip !== undefined;
+    const tooltipOverride = hasTooltipOverride
+        ? {
+            ...(presetTheme.tooltip ?? {}),
+            ...(theme?.tooltip ?? {})
+        }
+        : undefined;
+    return {
+        ...mergedTheme,
+        tooltip: resolveCartesianChartTooltipTheme(mergedTheme, tooltipOverride)
+    };
+};

package/dist/v2/react-native/theme/provider.d.ts

@@ -0,0 +1,20 @@
+import { type PropsWithChildren } from "react";
+import type { CartesianChartPresetRegistry, CartesianChartPresetValue, CartesianChartTheme, ChartKitThemeMode, ResolvedChartKitThemeMode } from "./presets";
+import type { LineChartRenderer } from "../charts/line/types";
+export type ChartKitThemeContextValue = {
+    mode: ResolvedChartKitThemeMode;
+    preset: CartesianChartPresetValue;
+    presets: CartesianChartPresetRegistry;
+    renderer?: LineChartRenderer;
+    theme: CartesianChartTheme | undefined;
+};
+export type ChartKitProviderProps = PropsWithChildren<{
+    mode?: ChartKitThemeMode;
+    preset?: CartesianChartPresetValue;
+    presets?: CartesianChartPresetRegistry;
+    renderer?: LineChartRenderer;
+    theme?: CartesianChartTheme;
+}>;
+export declare const ChartKitProvider: ({ children, mode, preset, presets, renderer, theme }: ChartKitProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useChartKitTheme: () => ChartKitThemeContextValue;
+//# sourceMappingURL=provider.d.ts.map

package/dist/v2/react-native/theme/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/theme/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,OAAO,CAAC;AAGf,OAAO,KAAK,EACV,4BAA4B,EAC5B,yBAAyB,EACzB,mBAAmB,EACnB,iBAAiB,EACjB,yBAAyB,EAC1B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,yBAAyB,CAAC;IAChC,MAAM,EAAE,yBAAyB,CAAC;IAClC,OAAO,EAAE,4BAA4B,CAAC;IACtC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,KAAK,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACxC,CAAC;AAaF,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,CAAC;IACpD,IAAI,CAAC,EAAE,iBAAiB,CAAC;IACzB,MAAM,CAAC,EAAE,yBAAyB,CAAC;IACnC,OAAO,CAAC,EAAE,4BAA4B,CAAC;IACvC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,KAAK,CAAC,EAAE,mBAAmB,CAAC;CAC7B,CAAC,CAAC;AAEH,eAAO,MAAM,gBAAgB,GAAI,sDAO9B,qBAAqB,4CAwBvB,CAAC;AAEF,eAAO,MAAM,gBAAgB,iCAAyC,CAAC"}

package/dist/v2/react-native/theme/provider.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from "react";
+import { useColorScheme } from "react-native";
+const defaultChartKitThemeContext = {
+    mode: "light",
+    preset: "default",
+    presets: {},
+    theme: undefined
+};
+const ChartKitThemeContext = createContext(defaultChartKitThemeContext);
+export const ChartKitProvider = ({ children, mode = "light", preset = "default", presets = {}, renderer, theme }) => {
+    const systemColorScheme = useColorScheme();
+    const resolvedMode = mode === "system"
+        ? systemColorScheme === "dark"
+            ? "dark"
+            : "light"
+        : mode;
+    const value = useMemo(() => ({
+        mode: resolvedMode,
+        preset,
+        presets,
+        ...(renderer ? { renderer } : {}),
+        theme
+    }), [preset, presets, renderer, resolvedMode, theme]);
+    return (_jsx(ChartKitThemeContext.Provider, { value: value, children: children }));
+};
+export const useChartKitTheme = () => useContext(ChartKitThemeContext);

package/dist/v2/react-native/viewport/bounds.d.ts

@@ -0,0 +1,7 @@
+import type { GestureResponderEvent } from "react-native";
+import type { ChartViewportBounds } from "./types";
+export declare const isChartViewportEventInBounds: ({ bounds, event }: {
+    bounds: ChartViewportBounds;
+    event: GestureResponderEvent;
+}) => boolean;
+//# sourceMappingURL=bounds.d.ts.map

package/dist/v2/react-native/viewport/bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounds.d.ts","sourceRoot":"","sources":["../../src/viewport/bounds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD,eAAO,MAAM,4BAA4B,GAAI,mBAG1C;IACD,MAAM,EAAE,mBAAmB,CAAC;IAC5B,KAAK,EAAE,qBAAqB,CAAC;CAC9B,YASA,CAAC"}

package/dist/v2/react-native/viewport/bounds.js

@@ -0,0 +1,7 @@
+export const isChartViewportEventInBounds = ({ bounds, event }) => {
+    const { locationX, locationY } = event.nativeEvent;
+    return (locationX >= bounds.x &&
+        locationX <= bounds.x + bounds.width &&
+        locationY >= bounds.y &&
+        locationY <= bounds.y + bounds.height);
+};

package/dist/v2/react-native/viewport/config.d.ts

@@ -0,0 +1,13 @@
+import type { ChartViewportInteractionConfig, ResolvedChartViewportInteractionConfig } from "./types";
+export declare const resolveChartViewportInteractionConfig: (viewportInteraction?: boolean | ChartViewportInteractionConfig) => ResolvedChartViewportInteractionConfig;
+export declare const getChartViewportPanDeltaPoints: ({ currentLocationX, plotWidth, startLocationX, visibleCount }: {
+    currentLocationX: number;
+    plotWidth: number;
+    startLocationX: number;
+    visibleCount: number;
+}) => number;
+export declare const getChartViewportPinchZoomFactor: ({ scale, sensitivity }: {
+    scale: number;
+    sensitivity: number;
+}) => number;
+//# sourceMappingURL=config.d.ts.map

package/dist/v2/react-native/viewport/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/viewport/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,8BAA8B,EAC9B,sCAAsC,EACvC,MAAM,SAAS,CAAC;AAqBjB,eAAO,MAAM,qCAAqC,GAChD,sBAAsB,OAAO,GAAG,8BAA8B,KAC7D,sCAwDF,CAAC;AAEF,eAAO,MAAM,8BAA8B,GAAI,+DAK5C;IACD,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB,WAMA,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAAI,wBAG7C;IACD,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB,WAYA,CAAC"}

package/dist/v2/react-native/viewport/config.js

@@ -0,0 +1,64 @@
+const defaultMinPanDistance = 6;
+const defaultMinVisiblePoints = 6;
+const defaultPinchSensitivity = 1;
+const normalizeFiniteNumber = (value, fallback, min) => typeof value === "number" && Number.isFinite(value)
+    ? Math.max(min, value)
+    : fallback;
+const normalizePositiveInteger = (value, fallback, min) => Math.floor(normalizeFiniteNumber(value, fallback, min));
+export const resolveChartViewportInteractionConfig = (viewportInteraction) => {
+    if (!viewportInteraction) {
+        return {
+            lockParentScroll: true,
+            maxVisiblePoints: undefined,
+            minPanDistance: defaultMinPanDistance,
+            minVisiblePoints: defaultMinVisiblePoints,
+            onGestureEnd: undefined,
+            onGestureStart: undefined,
+            pan: false,
+            pinchSensitivity: defaultPinchSensitivity,
+            pinchZoom: false
+        };
+    }
+    if (viewportInteraction === true) {
+        return {
+            lockParentScroll: true,
+            maxVisiblePoints: undefined,
+            minPanDistance: defaultMinPanDistance,
+            minVisiblePoints: defaultMinVisiblePoints,
+            onGestureEnd: undefined,
+            onGestureStart: undefined,
+            pan: true,
+            pinchSensitivity: defaultPinchSensitivity,
+            pinchZoom: false
+        };
+    }
+    return {
+        lockParentScroll: viewportInteraction.lockParentScroll !== false,
+        maxVisiblePoints: typeof viewportInteraction.maxVisiblePoints === "number" &&
+            Number.isFinite(viewportInteraction.maxVisiblePoints)
+            ? Math.max(2, Math.floor(viewportInteraction.maxVisiblePoints))
+            : undefined,
+        minPanDistance: typeof viewportInteraction.minPanDistance === "number" &&
+            Number.isFinite(viewportInteraction.minPanDistance)
+            ? Math.max(0, viewportInteraction.minPanDistance)
+            : defaultMinPanDistance,
+        minVisiblePoints: normalizePositiveInteger(viewportInteraction.minVisiblePoints, defaultMinVisiblePoints, 2),
+        onGestureEnd: viewportInteraction.onGestureEnd,
+        onGestureStart: viewportInteraction.onGestureStart,
+        pan: viewportInteraction.pan !== false,
+        pinchSensitivity: normalizeFiniteNumber(viewportInteraction.pinchSensitivity, defaultPinchSensitivity, 0.1),
+        pinchZoom: viewportInteraction.pinchZoom === true
+    };
+};
+export const getChartViewportPanDeltaPoints = ({ currentLocationX, plotWidth, startLocationX, visibleCount }) => {
+    const safePlotWidth = Number.isFinite(plotWidth) && plotWidth > 0 ? plotWidth : 1;
+    const pointSpacing = safePlotWidth / Math.max(1, visibleCount - 1);
+    return Math.round((startLocationX - currentLocationX) / pointSpacing);
+};
+export const getChartViewportPinchZoomFactor = ({ scale, sensitivity }) => {
+    const safeScale = typeof scale === "number" && Number.isFinite(scale)
+        ? Math.max(0.05, scale)
+        : 1;
+    const safeSensitivity = normalizeFiniteNumber(sensitivity, defaultPinchSensitivity, 0.1);
+    return Math.pow(safeScale, safeSensitivity);
+};

package/dist/v2/react-native/viewport/pan.d.ts

@@ -0,0 +1,23 @@
+import type { GestureResponderEvent } from "react-native";
+import { type ResolvedChartViewportWindow } from "../../core/index";
+import type { ChartViewportBounds, ChartViewportChangeEvent, ChartViewportInteractionConfig } from "./types";
+export declare const useChartViewportPan: ({ dataLength, enabled, onViewportChange, plotBounds, preventBrowserSelection, viewportInteraction, viewportWindow }: {
+    dataLength: number;
+    enabled: boolean;
+    onViewportChange: ((event: ChartViewportChangeEvent) => void) | undefined;
+    plotBounds: ChartViewportBounds;
+    preventBrowserSelection: (event: GestureResponderEvent) => void;
+    viewportInteraction: boolean | ChartViewportInteractionConfig | undefined;
+    viewportWindow: ResolvedChartViewportWindow;
+}) => {
+    hasChanged: () => boolean;
+    handleEnd: () => boolean;
+    handleGrant: (event: GestureResponderEvent) => boolean;
+    handleMove: (event: GestureResponderEvent) => boolean;
+    isActive: () => boolean;
+    isEnabled: boolean;
+    shouldBlockTermination: boolean;
+    shouldSetResponder: (event: GestureResponderEvent) => boolean;
+};
+export type ChartViewportPanHandlers = ReturnType<typeof useChartViewportPan>;
+//# sourceMappingURL=pan.d.ts.map

package/dist/v2/react-native/viewport/pan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pan.d.ts","sourceRoot":"","sources":["../../src/viewport/pan.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,iBAAiB,CAAC;AAOzB,OAAO,KAAK,EACV,mBAAmB,EACnB,wBAAwB,EACxB,8BAA8B,EAE/B,MAAM,SAAS,CAAC;AAQjB,eAAO,MAAM,mBAAmB,GAAI,qHAQjC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,gBAAgB,EAAE,CAAC,CAAC,KAAK,EAAE,wBAAwB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAC1E,UAAU,EAAE,mBAAmB,CAAC;IAChC,uBAAuB,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAChE,mBAAmB,EAAE,OAAO,GAAG,8BAA8B,GAAG,SAAS,CAAC;IAC1E,cAAc,EAAE,2BAA2B,CAAC;CAC7C;;;yBAsCW,qBAAqB;wBAmBrB,qBAAqB;;;;gCAxBrB,qBAAqB;CA4GhC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/v2/react-native/viewport/pan.js

@@ -0,0 +1,110 @@
+import { useCallback, useMemo, useRef } from "react";
+import { resolveChartViewportWindowFromPanDelta } from "../../core/index";
+import { isChartViewportEventInBounds } from "./bounds";
+import { getChartViewportPanDeltaPoints, resolveChartViewportInteractionConfig } from "./config";
+const isSameViewportWindow = (first, second) => first.startIndex === second.startIndex && first.endIndex === second.endIndex;
+export const useChartViewportPan = ({ dataLength, enabled, onViewportChange, plotBounds, preventBrowserSelection, viewportInteraction, viewportWindow }) => {
+    const config = useMemo(() => resolveChartViewportInteractionConfig(viewportInteraction), [viewportInteraction]);
+    const panStateRef = useRef(undefined);
+    const canPan = enabled &&
+        config.pan &&
+        onViewportChange !== undefined &&
+        dataLength > viewportWindow.visibleCount &&
+        viewportWindow.visibleCount > 0 &&
+        plotBounds.width > 0;
+    const emitViewportChange = useCallback((nextWindow) => {
+        onViewportChange?.({
+            viewport: {
+                startIndex: nextWindow.startIndex,
+                endIndex: nextWindow.endIndex
+            },
+            startIndex: nextWindow.startIndex,
+            endIndex: nextWindow.endIndex,
+            visibleCount: nextWindow.visibleCount,
+            itemCount: nextWindow.itemCount,
+            isWindowed: nextWindow.isWindowed,
+            source: "mainPlot",
+            interaction: "pan"
+        });
+    }, [onViewportChange]);
+    const shouldSetResponder = useCallback((event) => canPan && isChartViewportEventInBounds({ bounds: plotBounds, event }), [canPan, plotBounds]);
+    const handleGrant = useCallback((event) => {
+        if (!canPan) {
+            return false;
+        }
+        preventBrowserSelection(event);
+        panStateRef.current = {
+            lastWindow: viewportWindow,
+            startLocationX: event.nativeEvent.locationX,
+            startWindow: viewportWindow
+        };
+        config.onGestureStart?.({ interaction: "pan" });
+        return true;
+    }, [canPan, config, preventBrowserSelection, viewportWindow]);
+    const handleMove = useCallback((event) => {
+        const panState = panStateRef.current;
+        if (!canPan || !panState) {
+            return false;
+        }
+        preventBrowserSelection(event);
+        const deltaX = Math.abs(event.nativeEvent.locationX - panState.startLocationX);
+        if (deltaX < config.minPanDistance) {
+            return true;
+        }
+        const deltaPoints = getChartViewportPanDeltaPoints({
+            currentLocationX: event.nativeEvent.locationX,
+            plotWidth: plotBounds.width,
+            startLocationX: panState.startLocationX,
+            visibleCount: panState.startWindow.visibleCount
+        });
+        if (deltaPoints === 0) {
+            return true;
+        }
+        const nextWindow = resolveChartViewportWindowFromPanDelta({
+            currentWindow: panState.startWindow,
+            deltaPoints,
+            itemCount: dataLength
+        });
+        if (isSameViewportWindow(nextWindow, panState.lastWindow)) {
+            return true;
+        }
+        panStateRef.current = {
+            ...panState,
+            lastWindow: nextWindow
+        };
+        emitViewportChange(nextWindow);
+        return true;
+    }, [
+        canPan,
+        config.minPanDistance,
+        dataLength,
+        emitViewportChange,
+        plotBounds.width,
+        preventBrowserSelection
+    ]);
+    const handleEnd = useCallback(() => {
+        if (!panStateRef.current) {
+            return false;
+        }
+        panStateRef.current = undefined;
+        config.onGestureEnd?.({ interaction: "pan" });
+        return true;
+    }, [config]);
+    const isActive = useCallback(() => panStateRef.current !== undefined, []);
+    const hasChanged = useCallback(() => {
+        const panState = panStateRef.current;
+        return panState
+            ? !isSameViewportWindow(panState.startWindow, panState.lastWindow)
+            : false;
+    }, []);
+    return {
+        hasChanged,
+        handleEnd,
+        handleGrant,
+        handleMove,
+        isActive,
+        isEnabled: canPan,
+        shouldBlockTermination: canPan && config.lockParentScroll,
+        shouldSetResponder
+    };
+};

package/dist/v2/react-native/viewport/panResponder.d.ts

@@ -0,0 +1,14 @@
+import type { GestureResponderEvent } from "react-native";
+import { type ResolvedChartViewportWindow } from "../../core/index";
+import type { ChartViewportBounds, ChartViewportChangeEvent, ChartViewportInteractionConfig } from "./types";
+export declare const useChartViewportPanResponder: ({ dataLength, enabled, onPress, onViewportChange, plotBounds, preventBrowserSelection, viewportInteraction, viewportWindow }: {
+    dataLength: number;
+    enabled: boolean;
+    onPress: ((event: GestureResponderEvent) => void) | undefined;
+    onViewportChange: ((event: ChartViewportChangeEvent) => void) | undefined;
+    plotBounds: ChartViewportBounds;
+    preventBrowserSelection: (event: GestureResponderEvent) => void;
+    viewportInteraction: boolean | ChartViewportInteractionConfig | undefined;
+    viewportWindow: ResolvedChartViewportWindow;
+}) => import("react-native").PanResponderInstance;
+//# sourceMappingURL=panResponder.d.ts.map

package/dist/v2/react-native/viewport/panResponder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panResponder.d.ts","sourceRoot":"","sources":["../../src/viewport/panResponder.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,qBAAqB,EAEtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,iBAAiB,CAAC;AAMzB,OAAO,KAAK,EACV,mBAAmB,EACnB,wBAAwB,EACxB,8BAA8B,EAC/B,MAAM,SAAS,CAAC;AAoCjB,eAAO,MAAM,4BAA4B,GAAI,8HAS1C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAC9D,gBAAgB,EAAE,CAAC,CAAC,KAAK,EAAE,wBAAwB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAC1E,UAAU,EAAE,mBAAmB,CAAC;IAChC,uBAAuB,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAChE,mBAAmB,EAAE,OAAO,GAAG,8BAA8B,GAAG,SAAS,CAAC;IAC1E,cAAc,EAAE,2BAA2B,CAAC;CAC7C,gDA2GA,CAAC"}