@kubit-ui-web/react-charts 1.11.0 → 1.11.2

package/dist/esm/charts/pieChart/fragments/pieChartSegment.js

@@ -1,90 +1,42 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext, useEffect } from 'react';
-import { Path } from '../../../components/path/path';
-import { buildInnerRadiusOutOfRangeError, buildInvalidGroupError, buildInvalidInnerRadiusError, buildInvalidRadiusError, buildSegmentNegativeValueError, buildSegmentValueError, } from '../../../utils/buildErrors/buildErrors';
-import { PieChartContext } from '../context/pieChartContext';
-import { calculateSegmentPath } from '../utils/calculateSegmentPath';
-/**
- * Renders a segment of a pie chart.
- *
- * @param total - The total value of the pie chart.
- * @param startAngle - The starting angle of the segment.
- * @param canvasWidth - The width of the canvas.
- * @param canvasHeight - The height of the canvas.
- * @param innerRadius - The inner radius of the segment.
- * @param gap - The gap between segments.
- * @param radius - The radius of the segment.
- * @param value - The value of the segment.
- * @param color - The color of the segment (default: 'blue').
- * @param props - Additional props to pass to the Path component.
- * @returns A React element representing the pie chart segment.
- */
-export const PieChartSegment = ({ canvasHeight, canvasWidth, color = 'blue', dataKey, gap, halfChart, index, innerRadius, name, radius, singleStroke, startAngle, total, value, ...props }) => {
-    const { addError } = useContext(PieChartContext);
-    // Convert values to primitives for stable dependencies
-    const numericValue = Number(value);
-    const numericRadius = radius !== undefined ? Number(radius) : undefined;
-    const numericInnerRadius = innerRadius !== undefined ? Number(innerRadius) : undefined;
-    const trimmedName = name?.trim() || '';
-    // Segment error validations
-    useEffect(() => {
-        // Validate segment has non-empty name property
-        if (!trimmedName) {
-            addError?.('PIE_CHART_SEGMENT_ERROR', {
-                error: buildInvalidGroupError(dataKey || 'unknown', index || 0, 'name'),
-            });
-        }
-        // Validate segment value is numeric
-        if (isNaN(numericValue)) {
-            addError?.('PIE_CHART_SEGMENT_ERROR', {
-                error: buildSegmentValueError(value, trimmedName || `segment-${index}`),
-            });
-            return;
-        }
-        // Validate non-negative values
-        if (numericValue < 0) {
-            addError?.('PIE_CHART_SEGMENT_ERROR', {
-                error: buildSegmentNegativeValueError(numericValue, trimmedName || `segment-${index}`),
-            });
-        }
-        // Validate radius if provided
-        if (numericRadius !== undefined) {
-            if (isNaN(numericRadius) || numericRadius <= 0) {
-                addError?.('PIE_CHART_SEGMENT_ERROR', {
-                    error: buildInvalidRadiusError(radius),
-                });
-            }
-        }
-        // Validate innerRadius if provided
-        if (numericInnerRadius !== undefined) {
-            if (isNaN(numericInnerRadius) || numericInnerRadius < 0) {
-                addError?.('PIE_CHART_SEGMENT_ERROR', {
-                    error: buildInvalidInnerRadiusError(innerRadius),
-                });
-            }
-            // Validate innerRadius < radius
-            if (numericRadius !== undefined) {
-                if (!isNaN(numericRadius) && !isNaN(numericInnerRadius)) {
-                    if (numericInnerRadius >= numericRadius) {
-                        addError?.('PIE_CHART_SEGMENT_ERROR', {
-                            error: buildInnerRadiusOutOfRangeError(numericInnerRadius, numericRadius),
-                        });
-                    }
-                }
-            }
-        }
-    }, [dataKey, index, numericInnerRadius, numericRadius, numericValue, trimmedName]);
-    const pathData = calculateSegmentPath({
-        canvasHeight,
-        canvasWidth,
-        customRadius: radius,
-        gap: gap,
-        halfChart,
-        innerRadius: innerRadius,
-        singleStroke,
-        startAngle,
-        total,
-        value,
-    });
-    return (_jsx(Path, { ...props, d: pathData, dataValue: value, fill: color }));
+import { buildInnerRadiusOutOfRangeError, buildInvalidGroupError, buildInvalidInnerRadiusError, buildInvalidRadiusError, buildSegmentNegativeValueError, buildSegmentValueError } from "../../../utils/buildErrors/charts/buildPieChartErrors.js";
+import { Path } from "../../../components/path/path2.js";
+import { PieChartContext } from "../context/pieChartContext.js";
+import { calculateSegmentPath } from "../utils/calculateSegmentPath.js";
+import { useContext, useEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+const PieChartSegment = ({ canvasHeight: e, canvasWidth: t, color: n = "blue", dataKey: r, gap: i, halfChart: a, index: o, innerRadius: s, name: c, radius: l, singleStroke: u, startAngle: d, total: f, value: p, ...m }) => {
+	let { addError: h } = useContext(PieChartContext), g = Number(p), _ = l === void 0 ? void 0 : Number(l), v = s === void 0 ? void 0 : Number(s), y = c?.trim() || "";
+	useEffect(() => {
+		if (y || h?.("PIE_CHART_SEGMENT_ERROR", { error: buildInvalidGroupError(r || "unknown", o || 0, "name") }), isNaN(g)) {
+			h?.("PIE_CHART_SEGMENT_ERROR", { error: buildSegmentValueError(p, y || `segment-${o}`) });
+			return;
+		}
+		g < 0 && h?.("PIE_CHART_SEGMENT_ERROR", { error: buildSegmentNegativeValueError(g, y || `segment-${o}`) }), _ !== void 0 && (isNaN(_) || _ <= 0) && h?.("PIE_CHART_SEGMENT_ERROR", { error: buildInvalidRadiusError(l) }), v !== void 0 && ((isNaN(v) || v < 0) && h?.("PIE_CHART_SEGMENT_ERROR", { error: buildInvalidInnerRadiusError(s) }), _ !== void 0 && !isNaN(_) && !isNaN(v) && v >= _ && h?.("PIE_CHART_SEGMENT_ERROR", { error: buildInnerRadiusOutOfRangeError(v, _) }));
+	}, [
+		r,
+		o,
+		v,
+		_,
+		g,
+		y
+	]);
+	let b = calculateSegmentPath({
+		canvasHeight: e,
+		canvasWidth: t,
+		customRadius: l,
+		gap: i,
+		halfChart: a,
+		innerRadius: s,
+		singleStroke: u,
+		startAngle: d,
+		total: f,
+		value: p
+	});
+	return /* @__PURE__ */ jsx(Path, {
+		...m,
+		d: b,
+		dataValue: p,
+		fill: n
+	});
 };
+export { PieChartSegment };

package/dist/esm/charts/pieChart/index.js

@@ -1 +1 @@
-export * from './pieChart';
+export * from './pieChart.js';

package/dist/esm/charts/pieChart/pieChart.js

@@ -1,9 +1,8 @@
-import { PieChartForeign } from './fragments/pieChartForeign';
-import { PieChartPath } from './fragments/pieChartPath';
-import { PieChartStructure } from './pieChartStructure';
-const PieChart = Object.assign(PieChartStructure, {
-    Foreign: PieChartForeign,
-    Path: PieChartPath,
+import { PieChartForeign } from "./fragments/pieChartForeign.js";
+import { PieChartPath } from "./fragments/pieChartPath.js";
+import { PieChartStructure } from "./pieChartStructure.js";
+var PieChart = Object.assign(PieChartStructure, {
+	Foreign: PieChartForeign,
+	Path: PieChartPath
 });
 export { PieChart };
-export * from './pieChart.type';

package/dist/esm/charts/pieChart/pieChartStructure.js

@@ -1,76 +1,58 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useMemo } from 'react';
-import { SvgContainer } from '../../components/svgContainer/svgContainer';
-import { useId } from '../../hooks/useId/useId';
-import { useResponsiveCanvas } from '../../hooks/useResponsiveCanvas/useResponsiveCanvas';
-import { DefaultCanvasConfig } from '../../types/canvas.type';
-import { createErrorAccumulator } from '../../utils/createErrorAccumulator';
-import { getDataFingerprint } from '../../utils/getDataFingerprint/getDataFingerprint';
-import { buildPieContextValue } from './context/buildPieContextValue';
-import { PieChartContext } from './context/pieChartContext';
-/**
- * Renders a pie chart component.
- *
- * @component
- * @example
- * ```tsx
- * <PieChart
- *   caption="Pie Chart"
- *   canvasConfig={DefaultCanvasConfig}
- *   dataTestId="pie-chart"
- *   width="100%"
- *   height="100%"
- *   classNames="pie-chart"
- *   data={chartData}
- * >
- *   {chartChildren}
- * </PieChart>
- * ```
- *
- * @param {PieChartProps} props - The props for the PieChart component.
- * @param {string} props.caption - The caption for the pie chart.
- * @param {DefaultCanvasConfig} props.canvasConfig - The canvas configuration for the pie chart.
- * @param {string} props.dataTestId - The data test ID for the pie chart.
- * @param {string} props.width - The width of the pie chart.
- * @param {string} props.height - The height of the pie chart.
- * @param {string} props.classNames - The class names for the pie chart.
- * @param {ReactNode} props.children - The children components of the pie chart.
- * @param {ChartData[]} props.data - The data for the pie chart.
- * @returns {ReactElement} The rendered pie chart component.
- */
-export const PieChartStructure = ({ ariaHidden, ariaLabel, canvasConfig = DefaultCanvasConfig, caption, children, classNames, data, dataTestId: dataTestIdProp = 'pie-chart', halfChart, height = '100%', onErrors, radius = '50%', role, tabIndex, width = '100%', ...props }) => {
-    const dataTestId = useId(dataTestIdProp);
-    // Use the responsive canvas hook for dimension management
-    const { parsedCanvas, viewBox } = useResponsiveCanvas({
-        canvasConfig,
-        dataTestId,
-        height,
-        width,
-    });
-    const parsedCanvasWidth = parsedCanvas.width;
-    const parsedCanvasHeight = parsedCanvas.height;
-    const errorAccumulator = useMemo(() => createErrorAccumulator(onErrors), [onErrors]);
-    // Create a fingerprint of the data to avoid unnecessary contextValue updates
-    const dataFingerprint = getDataFingerprint(data);
-    const contextValue = useMemo(() => {
-        // Clear previous errors before building new context
-        errorAccumulator.clearErrors();
-        return buildPieContextValue({
-            addError: (errorType, error) => {
-                errorAccumulator.addError(errorType, error);
-            },
-            canvasHeight: parsedCanvasHeight,
-            canvasWidth: parsedCanvasWidth,
-            children,
-            halfChart,
-        });
-    }, [parsedCanvasHeight, parsedCanvasWidth, halfChart, dataFingerprint, errorAccumulator]);
-    return (_jsx(SvgContainer, { ariaHidden: ariaHidden, ariaLabel: ariaLabel, caption: caption, className: classNames, dataTestId: dataTestId, height: height, radius: radius, role: role, tabIndex: tabIndex, viewBox: viewBox, width: width, ...props, children: _jsx(PieChartContext.Provider, { value: {
-                ...contextValue,
-                canvasHeight: parsedCanvasHeight,
-                canvasWidth: parsedCanvasWidth,
-                data,
-                dataTestId,
-                halfChart,
-            }, children: children }) }));
+import { SvgContainer } from "../../components/svgContainer/svgContainer.js";
+import { useId } from "../../hooks/useId/useId.js";
+import { useResponsiveCanvas } from "../../hooks/useResponsiveCanvas/useResponsiveCanvas.js";
+import { DefaultCanvasConfig } from "../../types/canvas.type.js";
+import { createErrorAccumulator } from "../../utils/createErrorAccumulator/createErrorAccumulator.js";
+import { getDataFingerprint } from "../../utils/getDataFingerprint/getDataFingerprint.js";
+import { PieChartContext } from "./context/pieChartContext.js";
+import { buildPieContextValue } from "./context/buildPieContextValue.js";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+const PieChartStructure = ({ ariaHidden: n, ariaLabel: r, canvasConfig: i = DefaultCanvasConfig, caption: a, children: o, classNames: s, data: c, dataTestId: l = "pie-chart", halfChart: u, height: d = "100%", onErrors: f, radius: p = "50%", role: m, tabIndex: h, width: g = "100%", ..._ }) => {
+	let v = useId(l), { parsedCanvas: y, viewBox: b } = useResponsiveCanvas({
+		canvasConfig: i,
+		dataTestId: v,
+		height: d,
+		width: g
+	}), x = y.width, S = y.height, C = useMemo(() => createErrorAccumulator(f), [f]), w = useMemo(() => (C.clearErrors(), buildPieContextValue({
+		addError: (e, t) => {
+			C.addError(e, t);
+		},
+		canvasHeight: S,
+		canvasWidth: x,
+		children: o,
+		halfChart: u
+	})), [
+		S,
+		x,
+		u,
+		getDataFingerprint(c),
+		C
+	]);
+	return /* @__PURE__ */ jsx(SvgContainer, {
+		ariaHidden: n,
+		ariaLabel: r,
+		caption: a,
+		className: s,
+		dataTestId: v,
+		height: d,
+		radius: p,
+		role: m,
+		tabIndex: h,
+		viewBox: b,
+		width: g,
+		..._,
+		children: /* @__PURE__ */ jsx(PieChartContext.Provider, {
+			value: {
+				...w,
+				canvasHeight: S,
+				canvasWidth: x,
+				data: c,
+				dataTestId: v,
+				halfChart: u
+			},
+			children: o
+		})
+	});
 };
+export { PieChartStructure };

package/dist/esm/charts/pieChart/utils/accessibility.js

@@ -1,21 +1,11 @@
-// Template keys for accessibility labels
-export const PIE_CHART_TEMPLATE_KEYS = {
-    DATA_KEY: '{{dataKey}}',
-    INDEX: '{{index}}',
-    GROUP_NAME: '{{groupName}}',
-    GROUP_VALUE: '{{groupValue}}',
-};
-export const buildAriaLabel = ({ ariaLabel, dataKey, index, groupName, groupValue, }) => {
-    if (!ariaLabel) {
-        return undefined;
-    }
-    const dataKeyRegExp = new RegExp(PIE_CHART_TEMPLATE_KEYS.DATA_KEY, 'g');
-    const indexRegExp = new RegExp(PIE_CHART_TEMPLATE_KEYS.INDEX, 'g');
-    const groupNameRegExp = new RegExp(PIE_CHART_TEMPLATE_KEYS.GROUP_NAME, 'g');
-    const groupValueRegExp = new RegExp(PIE_CHART_TEMPLATE_KEYS.GROUP_VALUE, 'g');
-    return ariaLabel
-        .replace(dataKeyRegExp, dataKey)
-        .replace(indexRegExp, String(index))
-        .replace(groupNameRegExp, groupName)
-        .replace(groupValueRegExp, String(groupValue));
+const PIE_CHART_TEMPLATE_KEYS = {
+	DATA_KEY: "{{dataKey}}",
+	INDEX: "{{index}}",
+	GROUP_NAME: "{{groupName}}",
+	GROUP_VALUE: "{{groupValue}}"
+}, buildAriaLabel = ({ ariaLabel: e, dataKey: t, index: n, groupName: r, groupValue: i }) => {
+	if (!e) return;
+	let a = new RegExp(PIE_CHART_TEMPLATE_KEYS.DATA_KEY, "g"), o = new RegExp(PIE_CHART_TEMPLATE_KEYS.INDEX, "g"), s = new RegExp(PIE_CHART_TEMPLATE_KEYS.GROUP_NAME, "g"), c = new RegExp(PIE_CHART_TEMPLATE_KEYS.GROUP_VALUE, "g");
+	return e.replace(a, t).replace(o, String(n)).replace(s, r).replace(c, String(i));
 };
+export { buildAriaLabel };

package/dist/esm/charts/pieChart/utils/buildL.js

@@ -1,9 +1,4 @@
-export const buildL = ({ center, innerEnd, innerRadius, singleStroke, }) => {
-    if (singleStroke) {
-        return undefined;
-    }
-    if (innerRadius > 0) {
-        return `L ${innerEnd.x},${innerEnd.y}`;
-    }
-    return `L ${center.x},${center.y}`;
+const buildL = ({ center: e, innerEnd: t, innerRadius: n, singleStroke: r }) => {
+	if (!r) return n > 0 ? `L ${t.x},${t.y}` : `L ${e.x},${e.y}`;
 };
+export { buildL };

package/dist/esm/charts/pieChart/utils/calculatePoint.js

@@ -1,13 +1,5 @@
-/**
- * Calculates the coordinates of a point on a circle given the center, radius, and angle.
- * @param center - The coordinates of the center of the circle.
- * @param radius - The radius of the circle.
- * @param angle - The angle in radians.
- * @returns The coordinates of the calculated point.
- */
-export const calculatePoint = (center, radius, angle) => {
-    return {
-        x: center.x + radius * Math.cos(angle),
-        y: center.y + radius * Math.sin(angle),
-    };
-};
+const calculatePoint = (e, t, n) => ({
+	x: e.x + t * Math.cos(n),
+	y: e.y + t * Math.sin(n)
+});
+export { calculatePoint };

package/dist/esm/charts/pieChart/utils/calculateSegmentPath.js

@@ -1,57 +1,29 @@
-import { calculatePoint } from './calculatePoint';
-import { drawSegmentPath } from './drawSegmentPath';
-import { rotationDirection } from './rotationDirection';
-/**
- * Calculates the SVG path for a segment of a pie chart.
- *
- * @param {Object} params - The parameters for the segment path calculation.
- * @param {number} params.value - The value of the segment.
- * @param {number} params.total - The total value of all segments.
- * @param {Object} params.startAngle - The starting angle for the segment.
- * @param {number} params.canvasWidth - The width of the canvas.
- * @param {number} params.canvasHeight - The height of the canvas.
- * @param {number} params.innerRadius - The inner radius of the segment.
- * @param {number} params.gap - The gap between segments.
- * @param {number} [params.customRadius] - A custom radius for the segment.
- * @param {boolean} params.singleStroke - Whether the segment is a single stroke.
- * @param {boolean} params.halfChart - Whether the chart is a half chart.
- * @param {string} params.rotateDirection - The direction of rotation for the segment.
- * @returns {string} The SVG path for the segment.
- */
-export const calculateSegmentPath = ({ canvasHeight, canvasWidth, customRadius, gap, halfChart, innerRadius, rotateDirection, singleStroke, startAngle, total, value, }) => {
-    const segmentCanvasHeight = halfChart ? canvasHeight * 2 : canvasHeight;
-    const maxRadius = Math.min(canvasWidth, segmentCanvasHeight) / 2;
-    const radius = customRadius && customRadius < maxRadius ? customRadius : maxRadius;
-    const maxAngle = halfChart ? Math.PI : 2 * Math.PI; // ? 180deg : 360deg
-    const center = { x: canvasWidth / 2, y: halfChart ? canvasHeight : canvasHeight / 2 };
-    // Total * 2 is needed when a single stroke is used, to prevent the segment from being drawn as a full circle
-    const segmentTotal = singleStroke ? total * 2 : total;
-    const piePortion = (value * 100) / segmentTotal;
-    const angleEquivalent = (piePortion * maxAngle) / 100;
-    const gapAngle = gap / radius;
-    const { carryAngle, finalAngle, initialAngle } = rotationDirection({
-        angleEquivalent,
-        direction: rotateDirection,
-        gapAngle,
-        startAngle: startAngle.current,
-    });
-    startAngle.current = carryAngle;
-    const segmentAngle = (maxAngle * value) / segmentTotal;
-    const largeArcFlag = segmentAngle - gapAngle <= Math.PI ? '0' : '1';
-    const innerStart = calculatePoint(center, innerRadius, initialAngle);
-    const innerEnd = calculatePoint(center, innerRadius, finalAngle);
-    const outerStart = calculatePoint(center, radius, initialAngle);
-    const outerEnd = calculatePoint(center, radius, finalAngle);
-    return drawSegmentPath({
-        center,
-        innerEnd,
-        innerRadius,
-        innerStart,
-        largeArcFlag,
-        outerEnd,
-        outerStart,
-        radius,
-        rotateDirection,
-        singleStroke,
-    });
+import { calculatePoint } from "./calculatePoint.js";
+import { rotationDirection } from "./rotationDirection.js";
+import { drawSegmentPath } from "./drawSegmentPath.js";
+const calculateSegmentPath = ({ canvasHeight: e, canvasWidth: t, customRadius: n, gap: r, halfChart: i, innerRadius: a, rotateDirection: o, singleStroke: s, startAngle: c, total: l, value: u }) => {
+	let d = i ? e * 2 : e, f = Math.min(t, d) / 2, p = n && n < f ? n : f, m = i ? Math.PI : 2 * Math.PI, h = {
+		x: t / 2,
+		y: i ? e : e / 2
+	}, g = s ? l * 2 : l, _ = u * 100 / g * m / 100, v = r / p, { carryAngle: y, finalAngle: b, initialAngle: x } = rotationDirection({
+		angleEquivalent: _,
+		direction: o,
+		gapAngle: v,
+		startAngle: c.current
+	});
+	c.current = y;
+	let S = m * u / g - v <= Math.PI ? "0" : "1", C = calculatePoint(h, a, x), w = calculatePoint(h, a, b), T = calculatePoint(h, p, x);
+	return drawSegmentPath({
+		center: h,
+		innerEnd: w,
+		innerRadius: a,
+		innerStart: C,
+		largeArcFlag: S,
+		outerEnd: calculatePoint(h, p, b),
+		outerStart: T,
+		radius: p,
+		rotateDirection: o,
+		singleStroke: s
+	});
 };
+export { calculateSegmentPath };

package/dist/esm/charts/pieChart/utils/drawSegmentPath.js

@@ -1,41 +1,29 @@
-import { buildL } from './buildL';
-import { RotateDirection } from './rotationDirection';
-export const drawSegmentPath = ({ center, innerEnd, innerRadius, innerStart, largeArcFlag, outerEnd, outerStart, radius, rotateDirection, singleStroke, }) => {
-    let M, A, L, m, AA, MR, AR, mR, AAR, Z;
-    if (rotateDirection === RotateDirection.CLOCKWISE) {
-        M = `M ${outerStart.x},${outerStart.y}`;
-        A = `A ${radius},${radius} 0 ${largeArcFlag} 1 ${outerEnd.x}, ${outerEnd.y}`;
-        L = buildL({ center, innerEnd: innerEnd, innerRadius, singleStroke });
-        m = singleStroke ? `M ${innerEnd.x},${innerEnd.y}` : undefined;
-        AA =
-            innerRadius > 0
-                ? `A ${innerRadius},${innerRadius} 0 ${largeArcFlag} 0 ${innerStart.x},${innerStart.y}`
-                : undefined;
-        // mirror rounder value, needed for a single circle
-        MR = `M ${outerStart.x},${outerStart.y}`;
-        mR = `M ${innerEnd.x},${innerEnd.y}`;
-        AR = `A ${radius},${radius} 0 ${largeArcFlag} 0 ${outerEnd.x},${outerEnd.y}`;
-        AAR = `A ${innerRadius},${innerRadius} 0 ${largeArcFlag} 1 ${innerStart.x},${innerStart.y}`;
-        Z = singleStroke ? undefined : 'Z';
-    }
-    else {
-        M = `M ${outerStart.x} ${outerStart.y}`;
-        A = `A ${radius},${radius} 0 ${largeArcFlag},0 ${outerEnd.x}, ${outerEnd.y}`;
-        L = buildL({ center, innerEnd, innerRadius, singleStroke });
-        m = singleStroke ? `M ${innerEnd.x},${innerEnd.y}` : undefined;
-        AA =
-            innerRadius > 0
-                ? `A ${innerRadius}, ${innerRadius} 0 ${largeArcFlag},1 ${innerStart.x},${innerStart.y}`
-                : undefined;
-        // mirror rounder value, needed for a single circle
-        MR = `M ${outerStart.x},${outerStart.y}`;
-        mR = `M ${innerEnd.x},${innerEnd.y}`;
-        AR = `A ${radius},${radius} 0 ${largeArcFlag} 1 ${outerEnd.x},${outerEnd.y}`;
-        AAR = `A ${innerRadius},${innerRadius} 0 ${largeArcFlag} 0 ${innerStart.x},${innerStart.y}`;
-        Z = singleStroke ? undefined : 'Z';
-    }
-    // values
-    const base = [M, A, L, m, AA, Z];
-    const mirror = singleStroke ? [MR, AR, mR, AAR] : [];
-    return base.concat(mirror).filter(Boolean).join(' ');
+import { buildL } from "./buildL.js";
+import { RotateDirection } from "./rotationDirection.js";
+const drawSegmentPath = ({ center: e, innerEnd: t, innerRadius: n, innerStart: r, largeArcFlag: i, outerEnd: a, outerStart: o, radius: s, rotateDirection: c, singleStroke: l }) => {
+	let u, d, f, p, m, h, g, _, v, y;
+	return c === RotateDirection.CLOCKWISE ? (u = `M ${o.x},${o.y}`, d = `A ${s},${s} 0 ${i} 1 ${a.x}, ${a.y}`, f = buildL({
+		center: e,
+		innerEnd: t,
+		innerRadius: n,
+		singleStroke: l
+	}), p = l ? `M ${t.x},${t.y}` : void 0, m = n > 0 ? `A ${n},${n} 0 ${i} 0 ${r.x},${r.y}` : void 0, h = `M ${o.x},${o.y}`, _ = `M ${t.x},${t.y}`, g = `A ${s},${s} 0 ${i} 0 ${a.x},${a.y}`, v = `A ${n},${n} 0 ${i} 1 ${r.x},${r.y}`, y = l ? void 0 : "Z") : (u = `M ${o.x} ${o.y}`, d = `A ${s},${s} 0 ${i},0 ${a.x}, ${a.y}`, f = buildL({
+		center: e,
+		innerEnd: t,
+		innerRadius: n,
+		singleStroke: l
+	}), p = l ? `M ${t.x},${t.y}` : void 0, m = n > 0 ? `A ${n}, ${n} 0 ${i},1 ${r.x},${r.y}` : void 0, h = `M ${o.x},${o.y}`, _ = `M ${t.x},${t.y}`, g = `A ${s},${s} 0 ${i} 1 ${a.x},${a.y}`, v = `A ${n},${n} 0 ${i} 0 ${r.x},${r.y}`, y = l ? void 0 : "Z"), [
+		u,
+		d,
+		f,
+		p,
+		m,
+		y
+	].concat(l ? [
+		h,
+		g,
+		_,
+		v
+	] : []).filter(Boolean).join(" ");
 };
+export { drawSegmentPath };

package/dist/esm/charts/pieChart/utils/rotationDirection.js

@@ -1,13 +1,12 @@
-export const RotateDirection = {
-    CLOCKWISE: 'CLOCKWISE',
-    COUNTER_CLOCKWISE: 'COUNTER_CLOCKWISE',
-};
-export const rotationDirection = ({ angleEquivalent, direction, gapAngle, startAngle, }) => {
-    const clockDir = direction === RotateDirection.CLOCKWISE;
-    const initialAngle = clockDir ? startAngle + gapAngle / 2 : startAngle - gapAngle / 2;
-    const finalAngle = clockDir
-        ? startAngle + angleEquivalent - gapAngle / 2
-        : startAngle - angleEquivalent + gapAngle / 2;
-    const carryAngle = clockDir ? startAngle + angleEquivalent : startAngle - angleEquivalent;
-    return { carryAngle, finalAngle, initialAngle };
+const RotateDirection = {
+	CLOCKWISE: "CLOCKWISE",
+	COUNTER_CLOCKWISE: "COUNTER_CLOCKWISE"
+}, rotationDirection = ({ angleEquivalent: e, direction: t, gapAngle: n, startAngle: r }) => {
+	let i = t === RotateDirection.CLOCKWISE, a = i ? r + n / 2 : r - n / 2, o = i ? r + e - n / 2 : r - e + n / 2;
+	return {
+		carryAngle: i ? r + e : r - e,
+		finalAngle: o,
+		initialAngle: a
+	};
 };
+export { RotateDirection, rotationDirection };

package/dist/esm/components/axisChart/utils/filterLineProps/filterLineProps.js

@@ -1,38 +1,24 @@
-/**
- * Filters and extracts line-related properties from a given object.
- *
- * This utility function is designed to take a generic object `props` and extract from it
- * properties that are relevant to rendering a line in SVG. It's particularly useful when
- * you have a component that receives a mix of its own props and props that should be passed
- * directly to a child `<Line>` component.
- *
- * @param props - The input object containing potential line properties.
- * @returns An object containing only the properties relevant to a `<Line>` component.
- *
- * Note: The function uses a type assertion to treat the input `props` as any, allowing for
- * flexible input types. However, this means the function assumes the caller has ensured that
- * the input object contains properties compatible with `LineProps`.
- */
-export const filterLineProps = (props) => {
-    const { ariaLabel, className, dataTestId, opacity, stroke, strokeDasharray, strokeDashoffset, strokeLinecap, strokeLinejoin, strokeOpacity, strokeWidth, style, tabIndex, transform, x1, x2, y1, y2, } = props;
-    return {
-        ariaLabel,
-        className,
-        dataTestId,
-        opacity,
-        stroke,
-        strokeDasharray,
-        strokeDashoffset,
-        strokeLinecap,
-        strokeLinejoin,
-        strokeOpacity,
-        strokeWidth,
-        style,
-        tabIndex,
-        transform,
-        x1,
-        x2,
-        y1,
-        y2,
-    };
+const filterLineProps = (e) => {
+	let { ariaLabel: t, className: n, dataTestId: r, opacity: i, stroke: a, strokeDasharray: o, strokeDashoffset: s, strokeLinecap: c, strokeLinejoin: l, strokeOpacity: u, strokeWidth: d, style: f, tabIndex: p, transform: m, x1: h, x2: g, y1: _, y2: v } = e;
+	return {
+		ariaLabel: t,
+		className: n,
+		dataTestId: r,
+		opacity: i,
+		stroke: a,
+		strokeDasharray: o,
+		strokeDashoffset: s,
+		strokeLinecap: c,
+		strokeLinejoin: l,
+		strokeOpacity: u,
+		strokeWidth: d,
+		style: f,
+		tabIndex: p,
+		transform: m,
+		x1: h,
+		x2: g,
+		y1: _,
+		y2: v
+	};
 };
+export { filterLineProps };