@kubit-ui-web/react-charts 1.10.0 → 1.11.1

package/dist/esm/charts/constants/chartDefaults.js

@@ -1,96 +1,19 @@
-/**
- * Shared default configuration constants for chart components.
- *
- * These constants provide standardized default values that are common across
- * different chart types, as well as type-specific constants with clear naming.
- */
-/**
- * Default canvas dimensions used as fallback when invalid dimensions are provided
- */
-export const CHART_CANVAS_DEFAULTS = {
-    /** Default canvas height when invalid height is provided */
-    SAFE_HEIGHT: 100,
-    /** Default canvas width when invalid width is provided */
-    SAFE_WIDTH: 100,
-};
-/**
- * Axis validation constants for tick values and positioning
- */
-export const AXIS_VALIDATION = {
-    /** Minimum number of tick values required for a valid axis */
-    MIN_TICK_COUNT: 2,
-    /** Number used to detect when all tick values are identical */
-    UNIQUE_VALUE_THRESHOLD: 1,
-};
-/**
- * Default spacing and positioning values
- */
-export const CHART_SPACING_DEFAULTS = {
-    /** Default spacing value when no spacing is specified */
-    DEFAULT_SPACE: 0,
-};
-/**
- * Break axis default values
- */
-export const BREAK_AXIS_DEFAULTS = {
-    /** Default value when no custom break axis is specified */
-    DEFAULT_BREAK_VALUE: 0,
-};
-/**
- * Shared fallback data points used across different chart types
- */
-export const SHARED_FALLBACK_DATA = {
-    /** First fallback primary key value (used for axis labels) */
-    FALLBACK_PKEY_FIRST: '0',
-    /** Second fallback primary key value (used for axis labels) */
-    FALLBACK_PKEY_SECOND: '1',
-};
-/**
- * Bar Chart specific default configuration values
- */
-export const BAR_CHART_DEFAULTS = {
-    /** Default width for bar elements when not specified */
-    BAR_WIDTH: 20,
-};
-/**
- * Bar Chart specific fallback data points used when bar chart data is invalid or empty
- */
-export const BAR_CHART_FALLBACK_DATA = {
-    /** Default x value for fallback data points */
-    DEFAULT_X_VALUE: 0,
-    /** Generic secondary key for fallback data when dataKey is needed */
-    FALLBACK_SECONDARY_KEY: 'fallbackData',
-};
-/**
- * Line Chart specific fallback data points used when line chart data is invalid or empty
- */
-export const LINE_CHART_FALLBACK_DATA = {
-    /** First X value for line chart fallback data */
-    FALLBACK_X_FIRST: '0',
-    /** Second X value for line chart fallback data */
-    FALLBACK_X_SECOND: '1',
-    /** First Y value for line chart fallback data */
-    FALLBACK_Y_FIRST: 0,
-    /** Second Y value for line chart fallback data */
-    FALLBACK_Y_SECOND: 1,
-};
-/**
- * Pie Chart specific default configuration values
- */
-export const PIE_CHART_DEFAULTS = {
-    /** Default radius percentage when not specified */
-    DEFAULT_RADIUS_PERCENTAGE: 50,
-    /** Minimum number of segments required for a valid pie chart */
-    MIN_SEGMENTS: 1,
-};
-/**
- * Pie Chart specific fallback data points used when pie chart data is invalid or empty
- */
-export const PIE_CHART_FALLBACK_DATA = {
-    /** Generic data key for fallback data */
-    FALLBACK_DATA_KEY: 'fallbackSegments',
-    /** Default segment name for fallback data */
-    FALLBACK_SEGMENT_NAME: 'fallback',
-    /** Default segment value for fallback data */
-    FALLBACK_SEGMENT_VALUE: 100,
-};
+const CHART_CANVAS_DEFAULTS = {
+	SAFE_HEIGHT: 100,
+	SAFE_WIDTH: 100
+}, AXIS_VALIDATION = {
+	MIN_TICK_COUNT: 2,
+	UNIQUE_VALUE_THRESHOLD: 1
+}, CHART_SPACING_DEFAULTS = { DEFAULT_SPACE: 0 }, BREAK_AXIS_DEFAULTS = { DEFAULT_BREAK_VALUE: 0 }, SHARED_FALLBACK_DATA = {
+	FALLBACK_PKEY_FIRST: "0",
+	FALLBACK_PKEY_SECOND: "1"
+}, BAR_CHART_DEFAULTS = { BAR_WIDTH: 20 }, BAR_CHART_FALLBACK_DATA = {
+	DEFAULT_X_VALUE: 0,
+	FALLBACK_SECONDARY_KEY: "fallbackData"
+}, LINE_CHART_FALLBACK_DATA = {
+	FALLBACK_X_FIRST: "0",
+	FALLBACK_X_SECOND: "1",
+	FALLBACK_Y_FIRST: 0,
+	FALLBACK_Y_SECOND: 1
+};
+export { AXIS_VALIDATION, BAR_CHART_DEFAULTS, BAR_CHART_FALLBACK_DATA, BREAK_AXIS_DEFAULTS, CHART_CANVAS_DEFAULTS, CHART_SPACING_DEFAULTS, LINE_CHART_FALLBACK_DATA, SHARED_FALLBACK_DATA };

package/dist/esm/charts/customBackgroundChart/context/customBackgroundChartContext.js

@@ -0,0 +1,3 @@
+import { createContext } from "react";
+const CustomBackgroundChartContext = createContext({});
+export { CustomBackgroundChartContext };

package/dist/esm/charts/customBackgroundChart/customBackgroundChart.js

@@ -0,0 +1,4 @@
+import { CustomBackgroundChartStructure } from "./customBackgroundChartStructure.js";
+import { CustomBackgroundChartPlot } from "./fragments/customBackgroundChartPlot.js";
+var CustomBackgroundChart = Object.assign(CustomBackgroundChartStructure, { Plot: CustomBackgroundChartPlot });
+export { CustomBackgroundChart };

package/dist/esm/charts/customBackgroundChart/customBackgroundChartStructure.js

@@ -0,0 +1,67 @@
+import { SvgContainer } from "../../components/svgContainer/svgContainer.js";
+import { useId } from "../../hooks/useId/useId.js";
+import { createErrorAccumulator } from "../../utils/createErrorAccumulator/createErrorAccumulator.js";
+import { CustomBackgroundChartContext } from "./context/customBackgroundChartContext.js";
+import { useEffect, useMemo } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+const CustomBackgroundChartStructure = ({ ariaHidden: n, ariaLabel: r, backgroundUrl: i, caption: a, children: o, className: s, data: c, dataTestId: l = "custom-background-chart", height: u = "100%", onBlur: d, onClick: f, onDoubleClick: p, onErrors: m, onFocus: h, onKeyDown: g, onKeyUp: _, onMouseEnter: v, onMouseLeave: y, role: b = "img", tabIndex: x, viewBox: S, width: C = "100%", ...w }) => {
+	let T = useId(l), E = `0 0 ${S.width} ${S.height}`, D = useMemo(() => createErrorAccumulator(m), [m]);
+	useEffect(() => {
+		Object.keys(c).length === 0 && D.addError("CUSTOM_BACKGROUND_CHART_CONTEXT_ERROR", { error: /* @__PURE__ */ Error("Data object is empty. At least one data point is required.") }), (!i || i.trim() === "") && D.addError("CUSTOM_BACKGROUND_CHART_CONTEXT_ERROR", { error: /* @__PURE__ */ Error("backgroundUrl is required and cannot be empty.") }), (S.width <= 0 || S.height <= 0) && D.addError("CUSTOM_BACKGROUND_CHART_CONTEXT_ERROR", { error: /* @__PURE__ */ Error(`Invalid viewBox dimensions: width=${S.width}, height=${S.height} (both must be > 0)`) });
+	}, [
+		c,
+		i,
+		S,
+		D
+	]);
+	let O = useMemo(() => ({
+		addError: (e, t) => {
+			D.addError(e, t);
+		},
+		data: c,
+		dataTestId: T,
+		viewBox: S
+	}), [
+		S,
+		c,
+		T,
+		D
+	]);
+	return /* @__PURE__ */ jsx(SvgContainer, {
+		ariaHidden: n,
+		ariaLabel: r,
+		caption: a,
+		className: s,
+		dataTestId: T,
+		height: u,
+		role: b,
+		tabIndex: x,
+		viewBox: E,
+		width: C,
+		onBlur: d,
+		onClick: f,
+		onDoubleClick: p,
+		onFocus: h,
+		onKeyDown: g,
+		onKeyUp: _,
+		onMouseEnter: v,
+		onMouseLeave: y,
+		...w,
+		children: /* @__PURE__ */ jsxs(CustomBackgroundChartContext.Provider, {
+			value: O,
+			children: [/* @__PURE__ */ jsx("image", {
+				"data-testid": `${T}-background`,
+				height: S.height,
+				href: i,
+				preserveAspectRatio: "xMidYMid meet",
+				width: S.width,
+				x: 0,
+				y: 0
+			}), /* @__PURE__ */ jsx("g", {
+				"data-testid": `${T}-plots`,
+				children: o
+			})]
+		})
+	});
+};
+export { CustomBackgroundChartStructure };

package/dist/esm/charts/customBackgroundChart/fragments/customBackgroundChartPlot.js

@@ -0,0 +1,46 @@
+import { CustomBackgroundChartContext } from "../context/customBackgroundChartContext.js";
+import { Plot } from "../../../components/plot/plot2.js";
+import { buildAriaLabel, formatValue } from "../utils/accessibility.js";
+import { useContext, useEffect, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+const CustomBackgroundChartPlot = ({ ariaLabel: n, dataKey: r, formatAriaValue: i, ...a }) => {
+	let { addError: o, data: s, dataTestId: c, viewBox: l } = useContext(CustomBackgroundChartContext), u = useMemo(() => s[r], [s, r]);
+	useEffect(() => {
+		if (!u) {
+			o?.("CUSTOM_BACKGROUND_CHART_PLOT_ERROR", { error: /* @__PURE__ */ Error(`dataKey "${r}" not found in data object.`) });
+			return;
+		}
+		let { x: e, y: t } = u;
+		(e < 0 || e > l.width || t < 0 || t > l.height) && o?.("CUSTOM_BACKGROUND_CHART_PLOT_ERROR", { error: /* @__PURE__ */ Error(`Plot "${r}" coordinates (${e}, ${t}) are outside viewBox bounds (0-${l.width}, 0-${l.height})`) });
+	}, [
+		u,
+		r,
+		o,
+		l.width,
+		l.height
+	]);
+	let d = useMemo(() => u ? buildAriaLabel({
+		ariaLabel: n,
+		dataKey: r,
+		formattedValue: i ? i(u.value) : formatValue(u.value),
+		name: u.name,
+		x: u.x,
+		y: u.y
+	}) : r, [
+		n,
+		u,
+		r,
+		i
+	]), f = useMemo(() => ({
+		x: u?.x ?? 0,
+		y: u?.y ?? 0
+	}), [u?.x, u?.y]);
+	return u ? /* @__PURE__ */ jsx(Plot, {
+		...a,
+		data: { value: u.value },
+		dataTestId: `${c}-plot-${r}`,
+		label: d,
+		position: f
+	}) : null;
+};
+export { CustomBackgroundChartPlot };

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

@@ -0,0 +1 @@
+export * from './customBackgroundChart.js';

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

@@ -0,0 +1,13 @@
+const PLOT_TEMPLATE_KEYS = {
+	DATA_KEY: "{{dataKey}}",
+	NAME: "{{name}}",
+	VALUE: "{{value}}",
+	X: "{{x}}",
+	Y: "{{y}}"
+}, DEFAULT_ARIA_LABEL_TEMPLATE = `${PLOT_TEMPLATE_KEYS.NAME}, ${PLOT_TEMPLATE_KEYS.VALUE}`;
+var DATA_KEY_REGEXP = new RegExp(PLOT_TEMPLATE_KEYS.DATA_KEY, "g"), NAME_REGEXP = new RegExp(PLOT_TEMPLATE_KEYS.NAME, "g"), VALUE_REGEXP = new RegExp(PLOT_TEMPLATE_KEYS.VALUE, "g"), X_REGEXP = new RegExp(PLOT_TEMPLATE_KEYS.X, "g"), Y_REGEXP = new RegExp(PLOT_TEMPLATE_KEYS.Y, "g");
+const buildAriaLabel = ({ ariaLabel: e, dataKey: t, name: n, formattedValue: r, x: i, y: a }) => {
+	let o = e ?? DEFAULT_ARIA_LABEL_TEMPLATE, s = n ?? t;
+	return o.replace(DATA_KEY_REGEXP, t).replace(NAME_REGEXP, s).replace(VALUE_REGEXP, r).replace(X_REGEXP, String(i)).replace(Y_REGEXP, String(a));
+}, formatValue = (e) => typeof e == "number" ? e.toLocaleString() : typeof e == "string" ? e : JSON.stringify(e);
+export { buildAriaLabel, formatValue };

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 };