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

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

@@ -0,0 +1,66 @@
+const fullCircle = Math.PI * 2;
+const normalizeAngleFromStart = (angle, startAngle) => {
+    let normalizedAngle = angle;
+    while (normalizedAngle < startAngle) {
+        normalizedAngle += fullCircle;
+    }
+    while (normalizedAngle >= startAngle + fullCircle) {
+        normalizedAngle -= fullCircle;
+    }
+    return normalizedAngle;
+};
+export const getPieChartInteractionConfig = (interaction) => {
+    if (!interaction) {
+        return {
+            mode: "none",
+            deselectOnOutsidePress: true,
+            onDeselect: undefined,
+            onSelect: undefined
+        };
+    }
+    if (interaction === "tap" || interaction === "none") {
+        return {
+            mode: interaction,
+            deselectOnOutsidePress: true,
+            onDeselect: undefined,
+            onSelect: undefined
+        };
+    }
+    return {
+        mode: interaction.mode ?? "tap",
+        deselectOnOutsidePress: interaction.deselectOnOutsidePress !== false,
+        onDeselect: interaction.onDeselect,
+        onSelect: interaction.onSelect
+    };
+};
+export const isPieChartInteractionEnabled = (config) => config.mode === "tap";
+export const normalizePieChartSelectedIndex = (selectedIndex) => typeof selectedIndex === "number" && Number.isFinite(selectedIndex)
+    ? Math.max(0, Math.floor(selectedIndex))
+    : undefined;
+export const getPieChartSliceAtPoint = ({ arcs, centerX, centerY, innerRadius, locationX, locationY, radius }) => {
+    const dx = locationX - centerX;
+    const dy = locationY - centerY;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    if (distance < innerRadius || distance > radius) {
+        return undefined;
+    }
+    const firstDefinedArc = arcs.find((arc) => arc.defined);
+    if (!firstDefinedArc) {
+        return undefined;
+    }
+    const angle = normalizeAngleFromStart(Math.atan2(dy, dx), firstDefinedArc.startAngle);
+    return arcs.find((arc) => arc.defined && angle >= arc.startAngle && angle <= arc.endAngle);
+};
+export const buildPieChartSelectEvent = (arc) => {
+    if (!arc || !arc.defined) {
+        return undefined;
+    }
+    return {
+        index: arc.index,
+        label: arc.label,
+        value: arc.value,
+        percentage: arc.percentage,
+        ...(arc.color !== undefined ? { color: arc.color } : {}),
+        ...(arc.raw !== undefined ? { raw: arc.raw } : {})
+    };
+};

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

@@ -0,0 +1,15 @@
+import type { CartesianChartPresetRegistry, CartesianChartPresetValue, CartesianChartTheme, ResolvedChartKitThemeMode } from "../../theme/presets";
+import type { PieChartModel, PieChartProps } from "./types";
+type PieChartThemeContextValue = {
+    mode: ResolvedChartKitThemeMode;
+    preset: CartesianChartPresetValue;
+    presets: CartesianChartPresetRegistry;
+    theme: CartesianChartTheme | undefined;
+};
+export declare const buildPieChartModel: <TData extends Record<string, unknown>>({ chartKitTheme, props, selectedIndex }: {
+    chartKitTheme: PieChartThemeContextValue;
+    props: PieChartProps<TData>;
+    selectedIndex?: number | undefined;
+}) => PieChartModel<TData>;
+export {};
+//# sourceMappingURL=model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/charts/pie/model.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,4BAA4B,EAC5B,yBAAyB,EACzB,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,qBAAqB,CAAC;AAgB7B,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE5D,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,yBAAyB,CAAC;IAChC,MAAM,EAAE,yBAAyB,CAAC;IAClC,OAAO,EAAE,4BAA4B,CAAC;IACtC,KAAK,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACxC,CAAC;AAoFF,eAAO,MAAM,kBAAkB,GAAI,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,yCAIvE;IACD,aAAa,EAAE,yBAAyB,CAAC;IACzC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC,KAAG,aAAa,CAAC,KAAK,CA4ItB,CAAC"}

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

@@ -0,0 +1,157 @@
+import { buildPieArcs, normalizeLegacyPieData } from "../../../core/index";
+import { resolveCartesianChartThemeConfig } from "../../theme/presets";
+import { buildPieChartArcLabels, getPieChartArcLabelHorizontalReserve, getPieChartArcLabelsVisible, resolvePieChartArcLabelsConfig } from "./arcLabels";
+import { getPieChartActiveSliceGutter, resolvePieChartActiveSliceConfig, shouldReservePieChartActiveSliceGutter } from "./activeSlice";
+import { getPieChartSliceSeparatorGutter, resolvePieChartSliceSeparatorConfig } from "./sliceSeparator";
+const defaultLabelKey = "name";
+const defaultColorKey = "color";
+const defaultLegendHeight = 54;
+const defaultFormatValue = (value) => String(value);
+const defaultFormatPercentage = (percentage) => `${Math.round(percentage * 100)}%`;
+const clamp = (value, min, max) => {
+    if (max < min) {
+        return min;
+    }
+    return Math.min(Math.max(value, min), max);
+};
+const getStringValue = (value, fallback) => typeof value === "string" && value.length > 0 ? value : fallback;
+const getLegendVisible = (legend) => {
+    if (legend === false) {
+        return false;
+    }
+    if (typeof legend === "object") {
+        return legend.visible !== false;
+    }
+    return true;
+};
+const getLegendReservedHeight = (legend) => {
+    if (!getLegendVisible(legend)) {
+        return 0;
+    }
+    const config = typeof legend === "object" ? legend : {};
+    return typeof config.reservedHeight === "number" &&
+        Number.isFinite(config.reservedHeight)
+        ? Math.max(0, config.reservedHeight)
+        : defaultLegendHeight;
+};
+const normalizePieInput = ({ colorKey, colors, data, labelKey, valueKey }) => data.map((item, index) => {
+    const label = getStringValue(item[labelKey ?? defaultLabelKey], `Slice ${index + 1}`);
+    const color = getStringValue(item[colorKey ?? defaultColorKey], colors?.[index] ?? "");
+    const normalized = {
+        ...item,
+        name: label,
+        [valueKey]: item[valueKey]
+    };
+    if (color) {
+        normalized.color = color;
+    }
+    return normalized;
+});
+export const buildPieChartModel = ({ chartKitTheme, props, selectedIndex }) => {
+    const { arcLabels, colors, colorKey, data, formatPercentage = defaultFormatPercentage, formatValue = defaultFormatValue, height, innerRadius, innerRadiusRatio, labelKey, legend, preset, theme, valueKey, width } = props;
+    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 legendVisible = getLegendVisible(legend);
+    const legendReservedHeight = getLegendReservedHeight(legend);
+    const sliceSeparator = resolvePieChartSliceSeparatorConfig({
+        backgroundColor: resolvedTheme.background,
+        sliceSeparator: props.sliceSeparator
+    });
+    const arcLabelConfig = resolvePieChartArcLabelsConfig(arcLabels);
+    const arcLabelsVisible = getPieChartArcLabelsVisible(arcLabels);
+    const chartHeight = Math.max(120, height - legendReservedHeight);
+    const centerX = width / 2;
+    const centerY = chartHeight / 2;
+    const arcLabelHorizontalReserve = arcLabelsVisible
+        ? getPieChartArcLabelHorizontalReserve(arcLabelConfig)
+        : 0;
+    const arcLabelVerticalReserve = arcLabelsVisible
+        ? arcLabelConfig.reservedWidth
+        : 0;
+    const sliceSeparatorGutter = getPieChartSliceSeparatorGutter(sliceSeparator);
+    const availableRadius = Math.max(0, Math.min(Math.max(0, width - arcLabelHorizontalReserve * 2), Math.max(0, chartHeight - arcLabelVerticalReserve * 0.48)) /
+        2 -
+        6 -
+        sliceSeparatorGutter);
+    const activeSlice = resolvePieChartActiveSliceConfig({
+        activeSlice: props.activeSlice,
+        backgroundColor: resolvedTheme.background
+    });
+    const activeSliceGutter = shouldReservePieChartActiveSliceGutter({
+        props,
+        selectedIndex
+    })
+        ? getPieChartActiveSliceGutter({
+            activeSlice,
+            radius: availableRadius
+        })
+        : 0;
+    const radius = Math.max(0, availableRadius - activeSliceGutter);
+    const resolvedInnerRadius = typeof innerRadius === "number" && Number.isFinite(innerRadius)
+        ? innerRadius
+        : radius * clamp(innerRadiusRatio ?? 0, 0, 0.92);
+    const normalized = normalizeLegacyPieData(normalizePieInput({ colorKey, colors, data, labelKey, valueKey }), { accessor: valueKey });
+    const arcs = buildPieArcs({
+        slices: normalized.slices,
+        centerX,
+        centerY,
+        radius,
+        innerRadius: resolvedInnerRadius
+    }).map((arc, index) => {
+        const { color: _color, raw: _raw, ...rest } = arc;
+        const color = arc.color ??
+            resolvedTheme.series[index % resolvedTheme.series.length] ??
+            resolvedTheme.text;
+        const raw = data[arc.index];
+        return {
+            ...rest,
+            color,
+            ...(raw !== undefined ? { raw } : {})
+        };
+    });
+    const total = arcs.reduce((sum, arc) => (arc.value !== null ? sum + arc.value : sum), 0);
+    const legendItems = arcs
+        .filter((arc) => arc.defined)
+        .map((arc) => ({
+        index: arc.index,
+        key: `${arc.index}-${arc.label}`,
+        label: arc.label,
+        valueLabel: formatValue(arc.value ?? 0),
+        percentageLabel: formatPercentage(arc.percentage),
+        color: arc.color ?? resolvedTheme.series[0] ?? resolvedTheme.text,
+        arc
+    }));
+    const resolvedArcLabels = buildPieChartArcLabels({
+        arcs,
+        centerX,
+        centerY,
+        chartHeight,
+        chartWidth: width,
+        config: arcLabelConfig,
+        legendItems,
+        radius,
+        selectedIndex,
+        theme: resolvedTheme
+    });
+    return {
+        arcLabels: resolvedArcLabels,
+        arcLabelsVisible,
+        arcs,
+        centerX,
+        centerY,
+        chartHeight,
+        innerRadius: resolvedInnerRadius,
+        legendItems,
+        legendVisible,
+        radius,
+        resolvedTheme,
+        sliceSeparator,
+        total
+    };
+};

package/dist/v2/react-native/charts/pie/selectionAnimation.d.ts

@@ -0,0 +1,33 @@
+import { type PieArcModel } from "../../../core/index";
+import type { PieChartSelectionAnimationConfig } from "./types";
+export type PieChartSelectionAnimationState = {
+    fromIndex: number | undefined;
+    toIndex: number | undefined;
+    progress: number;
+};
+export type ResolvedPieChartSelectionAnimationConfig = {
+    enabled: boolean;
+    duration: number;
+};
+export declare const resolvePieChartSelectionAnimationConfig: (animation: boolean | PieChartSelectionAnimationConfig | undefined) => ResolvedPieChartSelectionAnimationConfig;
+export declare const getAnimatedPieSliceOpacity: ({ activeOpacity, inactiveOpacity, index, state }: {
+    activeOpacity: number;
+    inactiveOpacity: number;
+    index: number;
+    state: PieChartSelectionAnimationState;
+}) => number;
+export declare const getAnimatedPieSlicePath: <TData>({ activeOffset, activeScale, arc, centerX, centerY, innerRadius, radius, state }: {
+    activeOffset: number;
+    activeScale: number;
+    arc: PieArcModel<TData>;
+    centerX: number;
+    centerY: number;
+    innerRadius: number;
+    radius: number;
+    state: PieChartSelectionAnimationState;
+}) => string;
+export declare const usePieChartSelectionAnimation: ({ animation, selectedIndex }: {
+    animation: boolean | PieChartSelectionAnimationConfig | undefined;
+    selectedIndex: number | undefined;
+}) => PieChartSelectionAnimationState;
+//# sourceMappingURL=selectionAnimation.d.ts.map

package/dist/v2/react-native/charts/pie/selectionAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionAnimation.d.ts","sourceRoot":"","sources":["../../../src/charts/pie/selectionAnimation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEjE,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,SAAS,CAAC;AAIhE,MAAM,MAAM,+BAA+B,GAAG;IAC5C,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,wCAAwC,GAAG;IACrD,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,uCAAuC,GAClD,WAAW,OAAO,GAAG,gCAAgC,GAAG,SAAS,KAChE,wCAeF,CAAC;AAqCF,eAAO,MAAM,0BAA0B,GAAI,kDAKxC;IACD,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,+BAA+B,CAAC;CACxC,WAeE,CAAC;AAEJ,eAAO,MAAM,uBAAuB,GAAI,KAAK,EAAE,kFAS5C;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,+BAA+B,CAAC;CACxC,WA6CA,CAAC;AAEF,eAAO,MAAM,6BAA6B,GAAI,8BAG3C;IACD,SAAS,EAAE,OAAO,GAAG,gCAAgC,GAAG,SAAS,CAAC;IAClE,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC,KAAG,+BA8DH,CAAC"}

package/dist/v2/react-native/charts/pie/selectionAnimation.js

@@ -0,0 +1,121 @@
+import { useEffect, useRef, useState } from "react";
+import { buildPieArcs } from "../../../core/index";
+const defaultSelectionAnimationDuration = 180;
+export const resolvePieChartSelectionAnimationConfig = (animation) => {
+    if (animation === false) {
+        return { enabled: false, duration: 0 };
+    }
+    const config = typeof animation === "object" ? animation : {};
+    const duration = typeof config.duration === "number" && Number.isFinite(config.duration)
+        ? Math.max(0, config.duration)
+        : defaultSelectionAnimationDuration;
+    return {
+        enabled: true,
+        duration
+    };
+};
+const easeOutCubic = (progress) => {
+    const clampedProgress = Math.min(Math.max(progress, 0), 1);
+    return 1 - Math.pow(1 - clampedProgress, 3);
+};
+const interpolate = (from, to, progress) => from + (to - from) * progress;
+const getSliceSelectedAmount = ({ index, selectedIndex }) => (selectedIndex === index ? 1 : 0);
+const getSliceOpacity = ({ activeOpacity, inactiveOpacity, index, selectedIndex }) => {
+    if (selectedIndex === undefined) {
+        return 1;
+    }
+    return selectedIndex === index ? activeOpacity : inactiveOpacity;
+};
+export const getAnimatedPieSliceOpacity = ({ activeOpacity, inactiveOpacity, index, state }) => interpolate(getSliceOpacity({
+    activeOpacity,
+    inactiveOpacity,
+    index,
+    selectedIndex: state.fromIndex
+}), getSliceOpacity({
+    activeOpacity,
+    inactiveOpacity,
+    index,
+    selectedIndex: state.toIndex
+}), state.progress);
+export const getAnimatedPieSlicePath = ({ activeOffset, activeScale, arc, centerX, centerY, innerRadius, radius, state }) => {
+    const selectedAmount = interpolate(getSliceSelectedAmount({
+        index: arc.index,
+        selectedIndex: state.fromIndex
+    }), getSliceSelectedAmount({ index: arc.index, selectedIndex: state.toIndex }), state.progress);
+    if (selectedAmount <= 0.001) {
+        return arc.path;
+    }
+    const vectorX = arc.centroid.x - centerX;
+    const vectorY = arc.centroid.y - centerY;
+    const length = Math.hypot(vectorX, vectorY);
+    if (length <= 0) {
+        return arc.path;
+    }
+    const offset = activeOffset * selectedAmount;
+    const scale = interpolate(1, activeScale, selectedAmount);
+    const dx = (vectorX / length) * offset;
+    const dy = (vectorY / length) * offset;
+    const shiftedArc = buildPieArcs({
+        centerX: centerX + dx,
+        centerY: centerY + dy,
+        endAngle: arc.endAngle,
+        innerRadius: innerRadius * scale,
+        radius: radius * scale,
+        slices: [
+            {
+                defined: true,
+                index: arc.index,
+                label: arc.label,
+                raw: arc.raw,
+                value: 1
+            }
+        ],
+        startAngle: arc.startAngle
+    })[0];
+    return shiftedArc?.path ?? arc.path;
+};
+export const usePieChartSelectionAnimation = ({ animation, selectedIndex }) => {
+    const config = resolvePieChartSelectionAnimationConfig(animation);
+    const previousTargetRef = useRef(selectedIndex);
+    const [state, setState] = useState({
+        fromIndex: selectedIndex,
+        toIndex: selectedIndex,
+        progress: 1
+    });
+    useEffect(() => {
+        const fromIndex = previousTargetRef.current;
+        if (fromIndex === selectedIndex) {
+            return undefined;
+        }
+        previousTargetRef.current = selectedIndex;
+        if (!config.enabled || config.duration <= 0) {
+            const animationFrame = requestAnimationFrame(() => {
+                setState({
+                    fromIndex: selectedIndex,
+                    toIndex: selectedIndex,
+                    progress: 1
+                });
+            });
+            return () => cancelAnimationFrame(animationFrame);
+        }
+        let animationFrame = 0;
+        let startTime;
+        const tick = (timestamp) => {
+            startTime ?? (startTime = timestamp);
+            const rawProgress = Math.min((timestamp - startTime) / config.duration, 1);
+            const progress = easeOutCubic(rawProgress);
+            setState(rawProgress >= 1
+                ? { fromIndex: selectedIndex, toIndex: selectedIndex, progress: 1 }
+                : { fromIndex, toIndex: selectedIndex, progress });
+            if (rawProgress < 1) {
+                animationFrame = requestAnimationFrame(tick);
+            }
+        };
+        animationFrame = requestAnimationFrame((timestamp) => {
+            setState({ fromIndex, toIndex: selectedIndex, progress: 0 });
+            tick(timestamp);
+        });
+        return () => cancelAnimationFrame(animationFrame);
+    }, [config.duration, config.enabled, selectedIndex]);
+    return state;
+};

package/dist/v2/react-native/charts/pie/sliceSeparator.d.ts

@@ -0,0 +1,7 @@
+import type { PieChartSliceSeparatorConfig, ResolvedPieChartSliceSeparatorConfig } from "./types";
+export declare const resolvePieChartSliceSeparatorConfig: ({ backgroundColor, sliceSeparator }: {
+    backgroundColor: string;
+    sliceSeparator: boolean | PieChartSliceSeparatorConfig | undefined;
+}) => ResolvedPieChartSliceSeparatorConfig;
+export declare const getPieChartSliceSeparatorGutter: (sliceSeparator: ResolvedPieChartSliceSeparatorConfig) => number;
+//# sourceMappingURL=sliceSeparator.d.ts.map

package/dist/v2/react-native/charts/pie/sliceSeparator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sliceSeparator.d.ts","sourceRoot":"","sources":["../../../src/charts/pie/sliceSeparator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,oCAAoC,EACrC,MAAM,SAAS,CAAC;AAiBjB,eAAO,MAAM,mCAAmC,GAAI,qCAGjD;IACD,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,OAAO,GAAG,4BAA4B,GAAG,SAAS,CAAC;CACpE,KAAG,oCAsBH,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAC1C,gBAAgB,oCAAoC,WACiB,CAAC"}

package/dist/v2/react-native/charts/pie/sliceSeparator.js

@@ -0,0 +1,26 @@
+const defaultSliceSeparatorWidth = 2;
+const clampOpacity = (value, fallback) => typeof value === "number" && Number.isFinite(value)
+    ? Math.max(0, Math.min(1, value))
+    : fallback;
+const resolveNonNegativeNumber = (value, fallback) => typeof value === "number" && Number.isFinite(value)
+    ? Math.max(0, value)
+    : fallback;
+export const resolvePieChartSliceSeparatorConfig = ({ backgroundColor, sliceSeparator }) => {
+    if (sliceSeparator === undefined || sliceSeparator === false) {
+        return {
+            color: backgroundColor,
+            opacity: 1,
+            visible: false,
+            width: 0
+        };
+    }
+    const config = typeof sliceSeparator === "object" ? sliceSeparator : {};
+    const width = resolveNonNegativeNumber(config.width, defaultSliceSeparatorWidth);
+    return {
+        color: config.color ?? backgroundColor,
+        opacity: clampOpacity(config.opacity, 1),
+        visible: config.visible !== false && width > 0,
+        width
+    };
+};
+export const getPieChartSliceSeparatorGutter = (sliceSeparator) => (sliceSeparator.visible ? Math.ceil(sliceSeparator.width / 2) : 0);

package/dist/v2/react-native/charts/pie/slices.d.ts

@@ -0,0 +1,20 @@
+import type { PieArcModel } from "../../../core/index";
+import type { ResolvedCartesianChartTheme } from "../../theme";
+import { type PieChartSelectionAnimationState } from "./selectionAnimation";
+import type { ResolvedPieChartActiveSliceConfig } from "./activeSlice";
+import type { PieChartRenderer, ResolvedPieChartSliceSeparatorConfig } from "./types";
+export declare const PieChartSlices: <TData>({ activeSlice, arcs, centerX, centerY, innerRadius, radius, renderer, resolvedTheme, selectedIndex, selectionAnimationState, sliceSeparator, testID }: {
+    activeSlice: ResolvedPieChartActiveSliceConfig;
+    arcs: Array<PieArcModel<TData>>;
+    centerX: number;
+    centerY: number;
+    innerRadius: number;
+    radius: number;
+    renderer: PieChartRenderer;
+    resolvedTheme: ResolvedCartesianChartTheme;
+    selectedIndex: number | undefined;
+    selectionAnimationState: PieChartSelectionAnimationState;
+    sliceSeparator: ResolvedPieChartSliceSeparatorConfig;
+    testID: string | undefined;
+}) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=slices.d.ts.map

package/dist/v2/react-native/charts/pie/slices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slices.d.ts","sourceRoot":"","sources":["../../../src/charts/pie/slices.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAGL,KAAK,+BAA+B,EACrC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,KAAK,EACV,gBAAgB,EAChB,oCAAoC,EACrC,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,cAAc,GAAI,KAAK,EAAG,uJAapC;IACD,WAAW,EAAE,iCAAiC,CAAC;IAC/C,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,aAAa,EAAE,2BAA2B,CAAC;IAC3C,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,uBAAuB,EAAE,+BAA+B,CAAC;IACzD,cAAc,EAAE,oCAAoC,CAAC;IACrD,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B,4CAqEA,CAAC"}

package/dist/v2/react-native/charts/pie/slices.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { getAnimatedPieSliceOpacity, getAnimatedPieSlicePath } from "./selectionAnimation";
+export const PieChartSlices = ({ activeSlice, arcs, centerX, centerY, innerRadius, radius, renderer, resolvedTheme, selectedIndex, selectionAnimationState, sliceSeparator, testID }) => {
+    const Group = renderer.Group;
+    const Path = renderer.Path;
+    const renderedArcs = selectedIndex === undefined
+        ? arcs
+        : [
+            ...arcs.filter((arc) => arc.index !== selectedIndex),
+            ...arcs.filter((arc) => arc.index === selectedIndex)
+        ];
+    return (_jsx(_Fragment, { children: renderedArcs.map((arc) => {
+            if (!arc.defined) {
+                return null;
+            }
+            const isSelected = selectedIndex === arc.index;
+            const opacity = getAnimatedPieSliceOpacity({
+                activeOpacity: activeSlice.activeOpacity,
+                inactiveOpacity: activeSlice.inactiveOpacity,
+                index: arc.index,
+                state: selectionAnimationState
+            });
+            const path = getAnimatedPieSlicePath({
+                activeOffset: activeSlice.activeOffset,
+                activeScale: activeSlice.activeScale,
+                arc,
+                centerX,
+                centerY,
+                innerRadius,
+                radius,
+                state: selectionAnimationState
+            });
+            const separatorStrokeProps = sliceSeparator.visible
+                ? {
+                    stroke: sliceSeparator.color,
+                    strokeLinejoin: "round",
+                    strokeOpacity: sliceSeparator.opacity,
+                    strokeWidth: sliceSeparator.width
+                }
+                : {};
+            const activeStrokeProps = isSelected && activeSlice.strokeWidth > 0
+                ? {
+                    stroke: activeSlice.strokeColor,
+                    strokeLinejoin: "round",
+                    strokeOpacity: 1,
+                    strokeWidth: activeSlice.strokeWidth
+                }
+                : {};
+            const strokeProps = isSelected
+                ? { ...separatorStrokeProps, ...activeStrokeProps }
+                : separatorStrokeProps;
+            return (_jsx(Group, { opacity: opacity, children: _jsx(Path, { d: path, fill: arc.color ?? resolvedTheme.text, testID: `${testID ?? "pie-chart"}-slice.${arc.index}`, ...strokeProps }) }, `pie-slice-${arc.index}`));
+        }) }));
+};