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

package/dist/esm/charts/lineChart/context/buildLineContextValue.js

@@ -1,186 +1,139 @@
-import { ErrorType } from '../../../types/errors.type';
-import { Positions } from '../../../types/position.enum';
-import { getPoints } from '../../../utils/getPoints/getPoints';
-import { BREAK_AXIS_DEFAULTS, CHART_CANVAS_DEFAULTS, LINE_CHART_FALLBACK_DATA, SHARED_FALLBACK_DATA, } from '../../constants/chartDefaults';
-import { getXCoordinates, getYCoordinates } from '../utils/getCoordinates';
-import { getExtraSpacing } from '../utils/getExtraSpacing';
-import { getXTicks, getYTicks } from '../utils/getTicks';
-import { validateCanvasDimensions, validateData, validateXCoordinates, validateXTickValues, validateYCoordinates, validateYTickValues, } from '../utils/validations';
-/**
- * Builds the context value for the line chart.
- *
- * @param {BuildContextValue} options - The options for building the context value.
- * @returns {LineContextValue} - The built context value.
- */
-export const buildLineContextValue = ({ addError, canvasHeight, canvasWidth, children, data, viewBox, xKey, }) => {
-    let error = undefined;
-    const { error: dataError } = validateData({ data, addError });
-    if (dataError) {
-        error = dataError;
-    }
-    const { error: canvasError } = validateCanvasDimensions({
-        canvasWidth,
-        canvasHeight,
-        addError,
-    });
-    if (canvasError) {
-        error = canvasError;
-    }
-    // Use safe defaults for data processing if there are critical errors
-    const safeData = data && data.length > 0
-        ? data
-        : [
-            {
-                [xKey]: LINE_CHART_FALLBACK_DATA.FALLBACK_X_FIRST,
-                y: LINE_CHART_FALLBACK_DATA.FALLBACK_Y_FIRST,
-            },
-            {
-                [xKey]: LINE_CHART_FALLBACK_DATA.FALLBACK_X_SECOND,
-                y: LINE_CHART_FALLBACK_DATA.FALLBACK_Y_SECOND,
-            },
-        ];
-    const safeCanvasWidth = canvasWidth > 0 ? canvasWidth : CHART_CANVAS_DEFAULTS.SAFE_WIDTH;
-    const safeCanvasHeight = canvasHeight > 0 ? canvasHeight : CHART_CANVAS_DEFAULTS.SAFE_HEIGHT;
-    /**
-     * Get the extra spacings for the line chart.
-     */
-    const { xAxisLeftSpacing, xAxisTopSpacing, xAxisRightSpacing, xAxisBottomSpacing, yAxisLeftSpacing, yAxisTopSpacing, yAxisRightSpacing, yAxisBottomSpacing, lineChartXPosition, lineChartYPosition, xAxisText, xBreakAxis, xData, yAxisText, yBreakAxis, yData, } = getExtraSpacing({
-        canvasHeight: safeCanvasHeight,
-        canvasWidth: safeCanvasWidth,
-        children,
-        data: safeData,
-        viewBox,
-        xKey,
-    });
-    const xTickValues = getXTicks({
-        tickValues: xData,
-        maxSpaceAvailable: safeCanvasWidth,
-        xAxisLeftSpacing,
-        xAxisRightSpacing,
-        yAxisLeftSpacing,
-        yAxisRightSpacing,
-    });
-    const { error: xTickError } = validateXTickValues({ xTickValues, addError });
-    if (!error && xTickError) {
-        error = xTickError;
-    }
-    /**
-     * Calculate the tick values for the Y Axis.
-     */
-    const yTickValues = getYTicks({
-        maxSpaceAvailable: safeCanvasHeight,
-        tickValues: yData,
-        xAxisTopSpacing,
-        xAxisBottomSpacing,
-        yAxisTopSpacing,
-        yAxisBottomSpacing,
-    });
-    const { error: yTickError } = validateYTickValues({ yTickValues, addError });
-    if (!error && yTickError) {
-        error = yTickError;
-    }
-    const crossXAxis = lineChartXPosition !== Positions.TOP && lineChartXPosition !== Positions.BOTTOM;
-    const crossYAxis = lineChartYPosition !== Positions.LEFT && lineChartYPosition !== Positions.RIGHT;
-    /**
-     * Calculate the custom breakAxis for the X and Y Axis.
-     */
-    const customBreakXAxis = crossXAxis
-        ? getPoints(yTickValues || [], [String(xBreakAxis)])[0]
-        : BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE;
-    const customBreakYAxis = crossYAxis
-        ? getPoints(xTickValues || [], [String(yBreakAxis)])[0]
-        : BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE;
-    /**
-     * Calculate the X coordinates for the line chart.
-     */
-    const xCoordinates = getXCoordinates({
-        canvasHeight: safeCanvasHeight,
-        canvasWidth: safeCanvasWidth,
-        customBreakAxis: Number(customBreakXAxis),
-        lineChartXPosition,
-        lineChartYPosition,
-        xAxisLeftSpacing,
-        xAxisTopSpacing,
-        xAxisRightSpacing,
-        xAxisBottomSpacing,
-        yAxisLeftSpacing,
-        yAxisTopSpacing,
-        yAxisRightSpacing,
-        yAxisBottomSpacing,
-    });
-    /**
-     * Calculate the Y coordinates for the line chart.
-     */
-    const yCoordinates = getYCoordinates({
-        canvasHeight: safeCanvasHeight,
-        canvasWidth: safeCanvasWidth,
-        customBreakAxis: Number(customBreakYAxis),
-        lineChartXPosition,
-        lineChartYPosition,
-        xAxisLeftSpacing,
-        xAxisTopSpacing,
-        xAxisRightSpacing,
-        xAxisBottomSpacing,
-        yAxisLeftSpacing,
-        yAxisTopSpacing,
-        yAxisRightSpacing,
-        yAxisBottomSpacing,
-    });
-    const { error: xCoordinatesError } = validateXCoordinates({ xCoordinates, addError });
-    if (!error && xCoordinatesError) {
-        error = xCoordinatesError;
-    }
-    const { error: yCoordinatesError } = validateYCoordinates({ yCoordinates, addError });
-    if (!error && yCoordinatesError) {
-        error = yCoordinatesError;
-    }
-    const baseContext = {
-        addError,
-        crossXAxis,
-        crossYAxis,
-        xAxisLeftSpacing,
-        xAxisTopSpacing,
-        xAxisRightSpacing,
-        xAxisBottomSpacing,
-        yAxisLeftSpacing,
-        yAxisTopSpacing,
-        yAxisRightSpacing,
-        yAxisBottomSpacing,
-        xAxisCoordinates: {
-            coordinates: xCoordinates,
-            tickValues: xTickValues ||
-                (error
-                    ? [
-                        {
-                            position: BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE,
-                            value: LINE_CHART_FALLBACK_DATA.FALLBACK_X_FIRST,
-                        },
-                        { position: safeCanvasWidth, value: LINE_CHART_FALLBACK_DATA.FALLBACK_X_SECOND },
-                    ]
-                    : []),
-        },
-        xAxisText,
-        yAxisCoordinates: {
-            coordinates: yCoordinates,
-            tickValues: yTickValues ||
-                (error
-                    ? [
-                        { position: safeCanvasHeight, value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_FIRST },
-                        {
-                            position: BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE,
-                            value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_SECOND,
-                        },
-                    ]
-                    : []),
-        },
-        yAxisText,
-    };
-    // Add error only if it exists
-    if (error) {
-        return {
-            ...baseContext,
-            error: { ...error, type: ErrorType.LINE_CHART_CONTEXT_ERROR },
-        };
-    }
-    return baseContext;
+import { ErrorType } from "../../../types/errors.type.js";
+import { Positions } from "../../../types/position.enum.js";
+import { getPoints } from "../../../utils/getPoints/getPoints.js";
+import { BREAK_AXIS_DEFAULTS, CHART_CANVAS_DEFAULTS, LINE_CHART_FALLBACK_DATA, SHARED_FALLBACK_DATA } from "../../constants/chartDefaults.js";
+import { getXCoordinates, getYCoordinates } from "../utils/getCoordinates.js";
+import { getExtraSpacing } from "../utils/getExtraSpacing.js";
+import { getXTicks, getYTicks } from "../utils/getTicks.js";
+import { validateCanvasDimensions, validateData, validateXCoordinates, validateXTickValues, validateYCoordinates, validateYTickValues } from "../utils/validations.js";
+const buildLineContextValue = ({ addError: e, canvasHeight: t, canvasWidth: n, children: r, data: i, viewBox: a, xKey: o }) => {
+	let s, { error: c } = validateData({
+		data: i,
+		addError: e
+	});
+	c && (s = c);
+	let { error: l } = validateCanvasDimensions({
+		canvasWidth: n,
+		canvasHeight: t,
+		addError: e
+	});
+	l && (s = l);
+	let u = i && i.length > 0 ? i : [{
+		[o]: LINE_CHART_FALLBACK_DATA.FALLBACK_X_FIRST,
+		y: LINE_CHART_FALLBACK_DATA.FALLBACK_Y_FIRST
+	}, {
+		[o]: LINE_CHART_FALLBACK_DATA.FALLBACK_X_SECOND,
+		y: LINE_CHART_FALLBACK_DATA.FALLBACK_Y_SECOND
+	}], d = n > 0 ? n : CHART_CANVAS_DEFAULTS.SAFE_WIDTH, f = t > 0 ? t : CHART_CANVAS_DEFAULTS.SAFE_HEIGHT, { xAxisLeftSpacing: p, xAxisTopSpacing: m, xAxisRightSpacing: h, xAxisBottomSpacing: g, yAxisLeftSpacing: _, yAxisTopSpacing: v, yAxisRightSpacing: y, yAxisBottomSpacing: b, lineChartXPosition: x, lineChartYPosition: S, xAxisText: C, xBreakAxis: w, xData: T, yAxisText: E, yBreakAxis: D, yData: O } = getExtraSpacing({
+		canvasHeight: f,
+		canvasWidth: d,
+		children: r,
+		data: u,
+		viewBox: a,
+		xKey: o
+	}), k = getXTicks({
+		tickValues: T,
+		maxSpaceAvailable: d,
+		xAxisLeftSpacing: p,
+		xAxisRightSpacing: h,
+		yAxisLeftSpacing: _,
+		yAxisRightSpacing: y
+	}), { error: A } = validateXTickValues({
+		xTickValues: k,
+		addError: e
+	});
+	!s && A && (s = A);
+	let j = getYTicks({
+		maxSpaceAvailable: f,
+		tickValues: O,
+		xAxisTopSpacing: m,
+		xAxisBottomSpacing: g,
+		yAxisTopSpacing: v,
+		yAxisBottomSpacing: b
+	}), { error: M } = validateYTickValues({
+		yTickValues: j,
+		addError: e
+	});
+	!s && M && (s = M);
+	let N = x !== Positions.TOP && x !== Positions.BOTTOM, P = S !== Positions.LEFT && S !== Positions.RIGHT, F = N ? getPoints(j || [], [String(w)])[0] : BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE, I = P ? getPoints(k || [], [String(D)])[0] : BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE, L = getXCoordinates({
+		canvasHeight: f,
+		canvasWidth: d,
+		customBreakAxis: Number(F),
+		lineChartXPosition: x,
+		lineChartYPosition: S,
+		xAxisLeftSpacing: p,
+		xAxisTopSpacing: m,
+		xAxisRightSpacing: h,
+		xAxisBottomSpacing: g,
+		yAxisLeftSpacing: _,
+		yAxisTopSpacing: v,
+		yAxisRightSpacing: y,
+		yAxisBottomSpacing: b
+	}), R = getYCoordinates({
+		canvasHeight: f,
+		canvasWidth: d,
+		customBreakAxis: Number(I),
+		lineChartXPosition: x,
+		lineChartYPosition: S,
+		xAxisLeftSpacing: p,
+		xAxisTopSpacing: m,
+		xAxisRightSpacing: h,
+		xAxisBottomSpacing: g,
+		yAxisLeftSpacing: _,
+		yAxisTopSpacing: v,
+		yAxisRightSpacing: y,
+		yAxisBottomSpacing: b
+	}), { error: z } = validateXCoordinates({
+		xCoordinates: L,
+		addError: e
+	});
+	!s && z && (s = z);
+	let { error: B } = validateYCoordinates({
+		yCoordinates: R,
+		addError: e
+	});
+	!s && B && (s = B);
+	let V = {
+		addError: e,
+		crossXAxis: N,
+		crossYAxis: P,
+		xAxisLeftSpacing: p,
+		xAxisTopSpacing: m,
+		xAxisRightSpacing: h,
+		xAxisBottomSpacing: g,
+		yAxisLeftSpacing: _,
+		yAxisTopSpacing: v,
+		yAxisRightSpacing: y,
+		yAxisBottomSpacing: b,
+		xAxisCoordinates: {
+			coordinates: L,
+			tickValues: k || (s ? [{
+				position: BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE,
+				value: LINE_CHART_FALLBACK_DATA.FALLBACK_X_FIRST
+			}, {
+				position: d,
+				value: LINE_CHART_FALLBACK_DATA.FALLBACK_X_SECOND
+			}] : [])
+		},
+		xAxisText: C,
+		yAxisCoordinates: {
+			coordinates: R,
+			tickValues: j || (s ? [{
+				position: f,
+				value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_FIRST
+			}, {
+				position: BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE,
+				value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_SECOND
+			}] : [])
+		},
+		yAxisText: E
+	};
+	return s ? {
+		...V,
+		error: {
+			...s,
+			type: ErrorType.LINE_CHART_CONTEXT_ERROR
+		}
+	} : V;
 };
+export { buildLineContextValue };

package/dist/esm/charts/lineChart/context/lineChartContext.js

@@ -1,2 +1,3 @@
-import { createContext } from 'react';
-export const LineChartContext = createContext({});
+import { createContext } from "react";
+const LineChartContext = createContext({});
+export { LineChartContext };

package/dist/esm/charts/lineChart/fragments/lineChartPath2.js

@@ -0,0 +1,122 @@
+import { BuildError, buildDataKeyNotFoundError, buildError } from "../../../utils/buildErrors/buildErrors.js";
+import { getPoints } from "../../../utils/getPoints/getPoints.js";
+import { pickCustomAttributes } from "../../../utils/pickCustomAttributes/pickCustomAttributes.js";
+import { useIndicator } from "../hook/useIndicator.js";
+import { Node } from "../../../components/node/node.js";
+import { Path } from "../../../components/path/path2.js";
+import { Line } from "../../../components/line/line.js";
+import { LineChartContext } from "../context/lineChartContext.js";
+import { findClosestNumber, findSurroundingNumber } from "../utils/findSurroundingNumber.js";
+import { getPathData } from "../utils/getPathData.js";
+import { handleNodesFocus } from "../utils/handleNodesFocus.js";
+/* empty css              */
+import { LineChartProjection } from "./lineChartProjection.js";
+import { useContext, useEffect, useRef } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var getAxisData = (e, t) => e.map((e) => e[t]);
+const LineChartPath = ({ ariaLabel: i, closestClick: a, curved: o, getNodeFocusInfo: s, getNodesCoords: c, indicatorConfig: l, lineProjection: u, onClick: d, ...f }) => {
+	let { addError: p, xAxisCoordinates: m, yAxisCoordinates: h, ...g } = useContext(LineChartContext), _ = f.dataKey, v = g.data.length > 0, y = g.data[0], b = y ? Object.prototype.hasOwnProperty.call(y, _) : !1, x = g.data.length;
+	useEffect(() => {
+		if (!_ || typeof _ != "string") {
+			p?.("LINE_CHART_PATH_ERROR", { error: buildError(BuildError.LINE_CHART_PATH_INVALID_DATAKEY) });
+			return;
+		}
+		if (v && !b) {
+			p?.("LINE_CHART_PATH_ERROR", { error: buildDataKeyNotFoundError(_) });
+			return;
+		}
+		if (o && x < 2) {
+			p?.("LINE_CHART_PATH_ERROR", { error: buildError(BuildError.LINE_CHART_PATH_INSUFFICIENT_POINTS) });
+			return;
+		}
+		let r = getAxisData(g.data, _);
+		r.length > 0 && r.every((e) => e == null) && p?.("LINE_CHART_PATH_ERROR", { error: buildError(BuildError.LINE_CHART_PATH_ALL_VALUES_NULL) });
+	}, [
+		p,
+		o,
+		_,
+		x,
+		v,
+		b,
+		g.data
+	]);
+	let { indicatorRef: S, pathRef: C } = useIndicator(g.xCursor, !!l), w = !!l && g.xCursor !== -Infinity, T = useRef(null), E = useRef(null), { autoClick: D, lineIndicator: O, ...k } = l || {}, { y1: A, y2: j } = h.coordinates, { x1: M, x2: N } = m.coordinates, P = g.xCursor >= M && g.xCursor <= N, { tickValues: F } = m, { tickValues: I } = h, L = getAxisData(g.data, g.xKey), R = getAxisData(g.data, _), z = getPoints(F, L, !0), B = getPoints(I, R), V = z.map((e, t) => [e, B[t]]), H = getPathData({
+		curved: o,
+		extendToBottom: !1,
+		points: V,
+		svgHeight: h.coordinates.y2
+	}), U = getPathData({
+		curved: o,
+		extendToBottom: !!f.fill || !!f.gradient,
+		points: V,
+		svgHeight: h.coordinates.y2
+	});
+	useEffect(() => {
+		if (!T.current?.path) return;
+		C.current = T.current.path;
+		let e = T.current.main, t = T.current.node, { mount: n, unmount: r } = handleNodesFocus({
+			data: L.map((e, t) => ({
+				x: e,
+				y: R[t]
+			})),
+			getNodeFocusInfo: s,
+			nodes: t,
+			ref: e
+		});
+		return n(), () => r();
+	}, []), useEffect(() => {
+		if (f.nodeConfig && w && D) {
+			let { idx: e, match: t } = findSurroundingNumber(z, g.xCursor);
+			if (t && e !== E.current) {
+				E.current = e;
+				let t = new MouseEvent("click", { bubbles: !0 });
+				t.autoClick = !0, T.current?.node?.[e]?.dispatchEvent(t), navigator?.vibrate?.(200);
+			} else E.current = null;
+		}
+	}, [g.xCursor]), useEffect(() => {
+		c?.(V);
+	}, [V]);
+	let W = (e) => {
+		if (d?.(e), a) {
+			let e = findClosestNumber(z, g.xCursor), t = new MouseEvent("click", { bubbles: !0 });
+			t.autoClick = !1, T.current?.node?.[e]?.dispatchEvent(t);
+		}
+	}, G = pickCustomAttributes(f), K = {
+		...f,
+		...G,
+		...i && { "aria-label": i }
+	};
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(Path, {
+			ref: T,
+			d: H,
+			dFill: U,
+			dataTestId: `${g.dataTestId}path`,
+			dataValue: g.data,
+			points: V,
+			xKey: g.xKey,
+			onClick: W,
+			...K
+		}),
+		u && /* @__PURE__ */ jsx(LineChartProjection, {
+			curved: o,
+			dataKey: f.dataKey,
+			lineProjection: u,
+			points: V,
+			svgHeight: h.coordinates.y2
+		}),
+		w && /* @__PURE__ */ jsxs(Fragment, { children: [!!O && P && /* @__PURE__ */ jsx(Line, {
+			...O,
+			className: "pointer-events-none",
+			x1: g.xCursor,
+			x2: g.xCursor,
+			y1: A,
+			y2: j
+		}), /* @__PURE__ */ jsx("g", {
+			ref: S,
+			className: "pointer-events-none",
+			children: /* @__PURE__ */ jsx(Node, { ...k })
+		})] })
+	] });
+};
+export { LineChartPath };

package/dist/esm/charts/lineChart/fragments/lineChartProjection.js

@@ -1,65 +1,58 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useContext, useEffect } from 'react';
-import { buildProjectionBoundsError, buildProjectionXOutOfRangeError, buildProjectionYOutOfRangeError, } from '../../../utils/buildErrors/charts/buildLineChartErrors';
-import { LineChartContext } from '../context/lineChartContext';
-import { getProjection } from '../utils/getProjection';
-import './lineChartPath.css';
-export const LineChartProjection = ({ curved, lineProjection, points, svgHeight, }) => {
-    const { addError } = useContext(LineChartContext);
-    const { lower, shapeColor, upper } = lineProjection;
-    const { xProjection: xUp, yProjection: yUp, ...upperProps } = upper || {};
-    const { xProjection: xDw, yProjection: yDw, ...lowerProps } = lower || {};
-    const upperProjection = xUp || yUp ? { x: xUp, y: yUp } : undefined;
-    const lowerProjection = xDw || yDw ? { x: xDw, y: yDw } : undefined;
-    // Extract values for stable dependencies
-    const upperY = upperProjection?.y;
-    const lowerY = lowerProjection?.y;
-    const upperX = upperProjection?.x;
-    const lowerX = lowerProjection?.x;
-    // Projection error validations
-    useEffect(() => {
-        // Invalid projection bounds - upper/lower overlap
-        if (upperProjection && lowerProjection) {
-            const upperYVal = upperY || 0;
-            const lowerYVal = lowerY || 0;
-            if (upperYVal >= lowerYVal) {
-                addError?.('LINE_CHART_PROJECTION_ERROR', {
-                    error: buildProjectionBoundsError(upperYVal, lowerYVal),
-                });
-            }
-        }
-        // Projection coordinates outside chart area
-        if (upperProjection) {
-            if (upperX !== undefined && (upperX < 0 || upperX > 100)) {
-                addError?.('LINE_CHART_PROJECTION_ERROR', {
-                    error: buildProjectionXOutOfRangeError(upperX, true),
-                });
-            }
-            if (upperY !== undefined && (upperY < 0 || upperY > svgHeight)) {
-                addError?.('LINE_CHART_PROJECTION_ERROR', {
-                    error: buildProjectionYOutOfRangeError(upperY, svgHeight, true),
-                });
-            }
-        }
-        if (lowerProjection) {
-            if (lowerX !== undefined && (lowerX < 0 || lowerX > 100)) {
-                addError?.('LINE_CHART_PROJECTION_ERROR', {
-                    error: buildProjectionXOutOfRangeError(lowerX, false),
-                });
-            }
-            if (lowerY !== undefined && (lowerY < 0 || lowerY > svgHeight)) {
-                addError?.('LINE_CHART_PROJECTION_ERROR', {
-                    error: buildProjectionYOutOfRangeError(lowerY, svgHeight, false),
-                });
-            }
-        }
-    }, [lowerProjection, lowerX, lowerY, svgHeight, upperProjection, upperX, upperY]);
-    const { downPath, shapePath, upPath } = getProjection({
-        curved,
-        lowerProjection,
-        points,
-        svgHeight,
-        upperProjection,
-    });
-    return (_jsxs("g", { className: "pointer-events-none", children: [_jsx("path", { d: shapePath, fill: shapeColor, stroke: "transparent", strokeWidth: "0.1" }), ";", upPath && _jsx("path", { d: upPath, ...upperProps }), downPath && _jsx("path", { d: downPath, ...lowerProps })] }));
+import { LineChartContext } from "../context/lineChartContext.js";
+/* empty css              */
+import { buildProjectionBoundsError, buildProjectionXOutOfRangeError, buildProjectionYOutOfRangeError } from "../../../utils/buildErrors/charts/buildLineChartErrors.js";
+import { getProjection } from "../utils/getProjection.js";
+import { useContext, useEffect } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+const LineChartProjection = ({ curved: n, lineProjection: r, points: i, svgHeight: a }) => {
+	let { addError: o } = useContext(LineChartContext), { lower: s, shapeColor: c, upper: l } = r, { xProjection: u, yProjection: d, ...f } = l || {}, { xProjection: p, yProjection: m, ...h } = s || {}, g = u || d ? {
+		x: u,
+		y: d
+	} : void 0, _ = p || m ? {
+		x: p,
+		y: m
+	} : void 0, v = g?.y, y = _?.y, b = g?.x, x = _?.x;
+	useEffect(() => {
+		if (g && _) {
+			let e = v || 0, t = y || 0;
+			e >= t && o?.("LINE_CHART_PROJECTION_ERROR", { error: buildProjectionBoundsError(e, t) });
+		}
+		g && (b !== void 0 && (b < 0 || b > 100) && o?.("LINE_CHART_PROJECTION_ERROR", { error: buildProjectionXOutOfRangeError(b, !0) }), v !== void 0 && (v < 0 || v > a) && o?.("LINE_CHART_PROJECTION_ERROR", { error: buildProjectionYOutOfRangeError(v, a, !0) })), _ && (x !== void 0 && (x < 0 || x > 100) && o?.("LINE_CHART_PROJECTION_ERROR", { error: buildProjectionXOutOfRangeError(x, !1) }), y !== void 0 && (y < 0 || y > a) && o?.("LINE_CHART_PROJECTION_ERROR", { error: buildProjectionYOutOfRangeError(y, a, !1) }));
+	}, [
+		_,
+		x,
+		y,
+		a,
+		g,
+		b,
+		v
+	]);
+	let { downPath: S, shapePath: C, upPath: w } = getProjection({
+		curved: n,
+		lowerProjection: _,
+		points: i,
+		svgHeight: a,
+		upperProjection: g
+	});
+	return /* @__PURE__ */ jsxs("g", {
+		className: "pointer-events-none",
+		children: [
+			/* @__PURE__ */ jsx("path", {
+				d: C,
+				fill: c,
+				stroke: "transparent",
+				strokeWidth: "0.1"
+			}),
+			";",
+			w && /* @__PURE__ */ jsx("path", {
+				d: w,
+				...f
+			}),
+			S && /* @__PURE__ */ jsx("path", {
+				d: S,
+				...h
+			})
+		]
+	});
 };
+export { LineChartProjection };