@kubit-ui-web/react-charts 1.1.0 → 1.2.0

package/dist/cjs/charts/constants/chartDefaults.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 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 declare const CHART_CANVAS_DEFAULTS: {
+    /** Default canvas height when invalid height is provided */
+    readonly SAFE_HEIGHT: 100;
+    /** Default canvas width when invalid width is provided */
+    readonly SAFE_WIDTH: 100;
+};
+/**
+ * Axis validation constants for tick values and positioning
+ */
+export declare const AXIS_VALIDATION: {
+    /** Minimum number of tick values required for a valid axis */
+    readonly MIN_TICK_COUNT: 2;
+    /** Number used to detect when all tick values are identical */
+    readonly UNIQUE_VALUE_THRESHOLD: 1;
+};
+/**
+ * Default spacing and positioning values
+ */
+export declare const CHART_SPACING_DEFAULTS: {
+    /** Default spacing value when no spacing is specified */
+    readonly DEFAULT_SPACE: 0;
+};
+/**
+ * Break axis default values
+ */
+export declare const BREAK_AXIS_DEFAULTS: {
+    /** Default value when no custom break axis is specified */
+    readonly DEFAULT_BREAK_VALUE: 0;
+};
+/**
+ * Shared fallback data points used across different chart types
+ */
+export declare const SHARED_FALLBACK_DATA: {
+    /** First fallback primary key value (used for axis labels) */
+    readonly FALLBACK_PKEY_FIRST: "0";
+    /** Second fallback primary key value (used for axis labels) */
+    readonly FALLBACK_PKEY_SECOND: "1";
+};
+/**
+ * Bar Chart specific default configuration values
+ */
+export declare const BAR_CHART_DEFAULTS: {
+    /** Default width for bar elements when not specified */
+    readonly BAR_WIDTH: 20;
+};
+/**
+ * Bar Chart specific fallback data points used when bar chart data is invalid or empty
+ */
+export declare const BAR_CHART_FALLBACK_DATA: {
+    /** Default x value for fallback data points */
+    readonly DEFAULT_X_VALUE: 0;
+    /** Generic secondary key for fallback data when dataKey is needed */
+    readonly FALLBACK_SECONDARY_KEY: "fallbackData";
+};
+/**
+ * Line Chart specific fallback data points used when line chart data is invalid or empty
+ */
+export declare const LINE_CHART_FALLBACK_DATA: {
+    /** First X value for line chart fallback data */
+    readonly FALLBACK_X_FIRST: "0";
+    /** Second X value for line chart fallback data */
+    readonly FALLBACK_X_SECOND: "1";
+    /** First Y value for line chart fallback data */
+    readonly FALLBACK_Y_FIRST: 0;
+    /** Second Y value for line chart fallback data */
+    readonly FALLBACK_Y_SECOND: 1;
+};
+//# sourceMappingURL=chartDefaults.d.ts.map

package/dist/cjs/charts/constants/chartDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chartDefaults.d.ts","sourceRoot":"","sources":["../../../../src/charts/constants/chartDefaults.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;IAChC,4DAA4D;;IAE5D,0DAA0D;;CAElD,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,eAAe;IAC1B,8DAA8D;;IAE9D,+DAA+D;;CAEvD,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,sBAAsB;IACjC,yDAAyD;;CAEjD,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,mBAAmB;IAC9B,2DAA2D;;CAEnD,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,oBAAoB;IAC/B,8DAA8D;;IAE9D,+DAA+D;;CAEvD,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,wDAAwD;;CAEhD,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,uBAAuB;IAClC,+CAA+C;;IAE/C,qEAAqE;;CAE7D,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,wBAAwB;IACnC,iDAAiD;;IAEjD,kDAAkD;;IAElD,iDAAiD;;IAEjD,kDAAkD;;CAE1C,CAAC"}

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

@@ -0,0 +1,76 @@
+/**
+ * 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,
+};

package/dist/cjs/charts/lineChart/context/buildLineContextValue.d.ts

@@ -1,3 +1,4 @@
+import { type ChartError, ErrorType } from '../../../types/errors.type';
 import type { ChildrenType, IDataPoint, LineChartContextType } from '../lineChart.type';
 interface BuildContextValue {
     children: ChildrenType;
@@ -8,6 +9,7 @@ interface BuildContextValue {
     canvasHeight: number;
     canvasWidth: number;
     viewBox: string;
+    addError?: (errorType: keyof typeof ErrorType, error: Omit<ChartError, 'type'>) => void;
 }
 type OmitProps = 'data' | 'xKey' | 'canvasHeight' | 'canvasWidth' | 'canvasExtraSpace' | 'xBreakAxis' | 'yBreakAxis' | 'xCursor' | 'yCursor';
 /**
@@ -16,6 +18,6 @@ type OmitProps = 'data' | 'xKey' | 'canvasHeight' | 'canvasWidth' | 'canvasExtra
  * @param {BuildContextValue} options - The options for building the context value.
  * @returns {LineContextValue} - The built context value.
  */
-export declare const buildLineContextValue: ({ ajustedX, ajustedY, canvasHeight, canvasWidth, children, data, viewBox, xKey, }: BuildContextValue) => Omit<LineChartContextType, OmitProps>;
+export declare const buildLineContextValue: ({ addError, ajustedX, ajustedY, canvasHeight, canvasWidth, children, data, viewBox, xKey, }: BuildContextValue) => Omit<LineChartContextType, OmitProps>;
 export {};
 //# sourceMappingURL=buildLineContextValue.d.ts.map

package/dist/cjs/charts/lineChart/context/buildLineContextValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildLineContextValue.d.ts","sourceRoot":"","sources":["../../../../../src/charts/lineChart/context/buildLineContextValue.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGxF,UAAU,iBAAiB;IACzB,QAAQ,EAAE,YAAY,CAAC;IACvB,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,KAAK,SAAS,GACV,MAAM,GACN,MAAM,GACN,cAAc,GACd,aAAa,GACb,kBAAkB,GAClB,YAAY,GACZ,YAAY,GACZ,SAAS,GACT,SAAS,CAAC;AAEd;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,mFASnC,iBAAiB,KAAG,IAAI,CAAC,oBAAoB,EAAE,SAAS,CA+I1D,CAAC"}
+{"version":3,"file":"buildLineContextValue.d.ts","sourceRoot":"","sources":["../../../../../src/charts/lineChart/context/buildLineContextValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAkBjE,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGxF,UAAU,iBAAiB;IACzB,QAAQ,EAAE,YAAY,CAAC;IACvB,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,OAAO,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC;CACzF;AAED,KAAK,SAAS,GACV,MAAM,GACN,MAAM,GACN,cAAc,GACd,aAAa,GACb,kBAAkB,GAClB,YAAY,GACZ,YAAY,GACZ,SAAS,GACT,SAAS,CAAC;AAEd;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,6FAUnC,iBAAiB,KAAG,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAoR1D,CAAC"}

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

@@ -1,8 +1,10 @@
+import { ErrorType } from '../../../types/errors.type';
 import { Positions } from '../../../types/position.enum';
-import { BuildError, buildError } from '../../../utils/buildErrors/buildErrors';
+import { BuildError, buildCanvasDimensionsError, buildError, } from '../../../utils/buildErrors/buildErrors';
 import { getXCoordinates, getYCoordinates } from '../../../utils/getCoordinates/getCoordinates';
 import { getPoints } from '../../../utils/getPoints/getPoints';
 import { getXTicks, getYTicks } from '../../../utils/getTicks/getTicks';
+import { AXIS_VALIDATION, BREAK_AXIS_DEFAULTS, CHART_CANVAS_DEFAULTS, LINE_CHART_FALLBACK_DATA, SHARED_FALLBACK_DATA, } from '../../constants/chartDefaults';
 import { getExtraSpacing } from '../utils/getExtraSpacing';
 /**
  * Builds the context value for the line chart.
@@ -10,18 +12,56 @@ import { getExtraSpacing } from '../utils/getExtraSpacing';
  * @param {BuildContextValue} options - The options for building the context value.
  * @returns {LineContextValue} - The built context value.
  */
-export const buildLineContextValue = ({ ajustedX, ajustedY, canvasHeight, canvasWidth, children, data, viewBox, xKey, }) => {
+export const buildLineContextValue = ({ addError, ajustedX, ajustedY, canvasHeight, canvasWidth, children, data, viewBox, xKey, }) => {
     let error = undefined;
+    // 1. Validate data exists
+    if (!data || data.length === 0) {
+        const dataError = {
+            error: buildError(BuildError.LINE_CHART_NO_DATA),
+        };
+        addError?.('LINE_CHART_CONTEXT_ERROR', dataError);
+        error = dataError;
+    }
+    if (data && data.length === 1) {
+        const singlePointError = {
+            error: buildError(BuildError.LINE_CHART_SINGLE_POINT),
+        };
+        addError?.('LINE_CHART_CONTEXT_ERROR', singlePointError);
+        error = singlePointError;
+    }
+    // 2. Validate canvas dimensions
+    if (canvasWidth <= 0 || canvasHeight <= 0) {
+        const canvasError = {
+            error: buildCanvasDimensionsError(canvasWidth, canvasHeight),
+        };
+        addError?.('LINE_CHART_CONTEXT_ERROR', 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 { extraSpaceBottomY, extraSpaceLeftX, extraSpaceRightX, extraSpaceTopY, lineChartXPosition, lineChartYPosition, securityXSpace, securityYSpace, xAxisText, xBreakAxis, xData, yAxisText, yBreakAxis, yData, } = getExtraSpacing({
         ajustedX,
         ajustedY,
-        canvasHeight,
-        canvasWidth,
+        canvasHeight: safeCanvasHeight,
+        canvasWidth: safeCanvasWidth,
         children,
-        data,
+        data: safeData,
         viewBox,
         xKey,
     });
@@ -32,15 +72,41 @@ export const buildLineContextValue = ({ ajustedX, ajustedY, canvasHeight, canvas
     const yAxisSpace = extraSpaceLeftX + extraSpaceRightX;
     const xTickValues = getXTicks({
         initPos: extraSpaceLeftX,
-        maxSpaceAvailable: canvasWidth,
+        maxSpaceAvailable: safeCanvasWidth,
         otherAxisSpace: yAxisSpace,
         securitySpace: securityXSpace,
         tickValues: xData,
     });
     if ((xTickValues ?? []).some(({ position }) => isNaN(position))) {
-        error = {
+        const xTickError = {
             error: buildError(BuildError.INVALID_X_TICK),
         };
+        addError?.('LINE_CHART_CONTEXT_ERROR', xTickError);
+        error = xTickError;
+    }
+    // Validate X-axis tick values
+    if (xTickValues) {
+        const hasInsufficientTicks = xTickValues.length < AXIS_VALIDATION.MIN_TICK_COUNT;
+        const hasIdenticalValues = xTickValues.length >= AXIS_VALIDATION.MIN_TICK_COUNT &&
+            new Set(xTickValues.map(tick => tick.value)).size === AXIS_VALIDATION.UNIQUE_VALUE_THRESHOLD;
+        if (hasInsufficientTicks) {
+            const xAxisError = {
+                error: buildError(BuildError.LINE_CHART_X_AXIS_INSUFFICIENT_TICKS),
+            };
+            addError?.('LINE_CHART_X_AXIS_ERROR', xAxisError);
+            if (!error) {
+                error = xAxisError;
+            }
+        }
+        if (hasIdenticalValues) {
+            const xAxisError = {
+                error: buildError(BuildError.LINE_CHART_X_AXIS_IDENTICAL_VALUES),
+            };
+            addError?.('LINE_CHART_X_AXIS_ERROR', xAxisError);
+            if (!error) {
+                error = xAxisError;
+            }
+        }
     }
     /**
      * Calculate the tick values for the Y Axis.
@@ -48,23 +114,51 @@ export const buildLineContextValue = ({ ajustedX, ajustedY, canvasHeight, canvas
     const crossYAxis = lineChartYPosition !== Positions.LEFT && lineChartYPosition !== Positions.RIGHT;
     const otherAxisSpace = extraSpaceTopY + extraSpaceBottomY;
     const yTickValues = getYTicks({
-        initPos: canvasHeight - extraSpaceBottomY,
-        maxSpaceAvailable: canvasHeight,
+        initPos: safeCanvasHeight - extraSpaceBottomY,
+        maxSpaceAvailable: safeCanvasHeight,
         otherAxisSpace,
         securitySpace: securityYSpace,
         tickValues: yData,
     });
+    // Validate Y-axis tick values
+    if (yTickValues) {
+        const hasInsufficientTicks = yTickValues.length < AXIS_VALIDATION.MIN_TICK_COUNT;
+        const hasIdenticalValues = yTickValues.length >= AXIS_VALIDATION.MIN_TICK_COUNT &&
+            new Set(yTickValues.map(tick => tick.value)).size === AXIS_VALIDATION.UNIQUE_VALUE_THRESHOLD;
+        if (hasInsufficientTicks) {
+            const yAxisError = {
+                error: buildError(BuildError.LINE_CHART_Y_AXIS_INSUFFICIENT_TICKS),
+            };
+            addError?.('LINE_CHART_Y_AXIS_ERROR', yAxisError);
+            if (!error) {
+                error = yAxisError;
+            }
+        }
+        if (hasIdenticalValues) {
+            const yAxisError = {
+                error: buildError(BuildError.LINE_CHART_Y_AXIS_IDENTICAL_VALUES),
+            };
+            addError?.('LINE_CHART_Y_AXIS_ERROR', yAxisError);
+            if (!error) {
+                error = yAxisError;
+            }
+        }
+    }
     /**
      * Calculate the custom breakAxis for the X and Y Axis.
      */
-    const customBreakXAxis = crossXAxis ? getPoints(yTickValues || [], [String(xBreakAxis)])[0] : 0;
-    const customBreakYAxis = crossYAxis ? getPoints(xTickValues || [], [String(yBreakAxis)])[0] : 0;
+    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,
-        canvasWidth,
+        canvasHeight: safeCanvasHeight,
+        canvasWidth: safeCanvasWidth,
         customBreakAxis: Number(customBreakXAxis),
         extraSpaceBottomY,
         extraSpaceLeftX,
@@ -77,8 +171,8 @@ export const buildLineContextValue = ({ ajustedX, ajustedY, canvasHeight, canvas
      * Calculate the Y coordinates for the line chart.
      */
     const yCoordinates = getYCoordinates({
-        canvasHeight,
-        canvasWidth,
+        canvasHeight: safeCanvasHeight,
+        canvasWidth: safeCanvasWidth,
         customBreakAxis: Number(customBreakYAxis),
         extraSpaceBottomY,
         extraSpaceLeftX,
@@ -87,37 +181,27 @@ export const buildLineContextValue = ({ ajustedX, ajustedY, canvasHeight, canvas
         position: lineChartYPosition,
         securityYSpace,
     });
-    if (error) {
-        // return fallback context value with error
-        return {
-            crossXAxis,
-            crossYAxis,
-            error,
-            extraSpaceBottomY,
-            extraSpaceLeftX,
-            extraSpaceRightX,
-            extraSpaceTopY,
-            securityXSpace,
-            securityYSpace,
-            xAxisCoordinates: {
-                coordinates: xCoordinates,
-                tickValues: [
-                    { position: 0, value: '0' },
-                    { position: canvasWidth, value: '1' },
-                ],
-            },
-            xAxisText,
-            yAxisCoordinates: {
-                coordinates: yCoordinates,
-                tickValues: [
-                    { position: canvasHeight, value: '0' },
-                    { position: 0, value: '1' },
-                ],
-            },
-            yAxisText,
+    // Validate axis coordinates for zero-length axes
+    if (xCoordinates.x1 === xCoordinates.x2) {
+        const xAxisError = {
+            error: buildError(BuildError.LINE_CHART_X_AXIS_ZERO_LENGTH),
+        };
+        addError?.('LINE_CHART_X_AXIS_ERROR', xAxisError);
+        if (!error) {
+            error = xAxisError;
+        }
+    }
+    if (yCoordinates.y1 === yCoordinates.y2) {
+        const yAxisError = {
+            error: buildError(BuildError.LINE_CHART_Y_AXIS_ZERO_LENGTH),
         };
+        addError?.('LINE_CHART_Y_AXIS_ERROR', yAxisError);
+        if (!error) {
+            error = yAxisError;
+        }
     }
-    return {
+    const baseContext = {
+        addError,
         crossXAxis,
         crossYAxis,
         extraSpaceBottomY,
@@ -126,9 +210,41 @@ export const buildLineContextValue = ({ ajustedX, ajustedY, canvasHeight, canvas
         extraSpaceTopY,
         securityXSpace,
         securityYSpace,
-        xAxisCoordinates: { coordinates: xCoordinates, tickValues: xTickValues },
+        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 },
+        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;
 };

package/dist/cjs/charts/lineChart/fragments/fixture/contextData.d.ts

@@ -1,5 +1,6 @@
 import type { TickData } from '../../../../components/tick/tick.types';
 export declare const CONTEXT: {
+    addError: undefined;
     canvasExtraSpace: number;
     canvasHeight: number;
     canvasWidth: number;

package/dist/cjs/charts/lineChart/fragments/fixture/contextData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextData.d.ts","sourceRoot":"","sources":["../../../../../../src/charts/lineChart/fragments/fixture/contextData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAE7D,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;oBAwBA,QAAQ,EAAE;;;;;;;;;;;;oBAWV,QAAQ,EAAE;;;;CAI7B,CAAC"}
+{"version":3,"file":"contextData.d.ts","sourceRoot":"","sources":["../../../../../../src/charts/lineChart/fragments/fixture/contextData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAE7D,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;oBAyBA,QAAQ,EAAE;;;;;;;;;;;;oBAWV,QAAQ,EAAE;;;;CAI7B,CAAC"}

package/dist/cjs/charts/lineChart/fragments/fixture/contextData.js

@@ -1,4 +1,5 @@
 export const CONTEXT = {
+    addError: undefined,
     canvasExtraSpace: 0,
     canvasHeight: 500,
     canvasWidth: 500,

package/dist/cjs/charts/lineChart/fragments/lineChartPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lineChartPath.d.ts","sourceRoot":"","sources":["../../../../../src/charts/lineChart/fragments/lineChartPath.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,EAAoD,MAAM,OAAO,CAAC;AAUlF,OAAO,KAAK,EAAc,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAIxE,OAAO,qBAAqB,CAAC;AAO7B,eAAO,MAAM,aAAa,EAAE,EAAE,CAAC,kBAAkB,CAiJhD,CAAC"}
+{"version":3,"file":"lineChartPath.d.ts","sourceRoot":"","sources":["../../../../../src/charts/lineChart/fragments/lineChartPath.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,EAAoD,MAAM,OAAO,CAAC;AAWlF,OAAO,KAAK,EAAc,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAIxE,OAAO,qBAAqB,CAAC;AAO7B,eAAO,MAAM,aAAa,EAAE,EAAE,CAAC,kBAAkB,CAwLhD,CAAC"}

package/dist/cjs/charts/lineChart/fragments/lineChartPath.js

@@ -3,6 +3,7 @@ import { useContext, useEffect, useRef } from 'react';
 import { Line } from '../../../components/line/line';
 import { Node } from '../../../components/node/node';
 import { Path } from '../../../components/path/path';
+import { BuildError, buildDataKeyNotFoundError, buildError } from '../../../utils/buildErrors/buildErrors';
 import { getPoints } from '../../../utils/getPoints/getPoints';
 import { pickCustomAttributes } from '../../../utils/pickCustomAttributes/pickCustomAttributes';
 import { LineChartContext } from '../context/lineChartContext';
@@ -17,7 +18,39 @@ const getAxisData = (data, key) => {
 };
 export const LineChartPath = ({ ariaLabel, closestClick, curved, getNodeFocusInfo, getNodesCoords, indicatorConfig, lineProjection, onClick, ...props }) => {
     // recovery the context values
-    const { xAxisCoordinates, yAxisCoordinates, ...context } = useContext(LineChartContext);
+    const { addError, xAxisCoordinates, yAxisCoordinates, ...context } = useContext(LineChartContext);
+    // Path error validations
+    useEffect(() => {
+        // Invalid dataKey validation
+        if (!props.dataKey || typeof props.dataKey !== 'string') {
+            addError?.('LINE_CHART_PATH_ERROR', {
+                error: buildError(BuildError.LINE_CHART_PATH_INVALID_DATAKEY),
+            });
+            return;
+        }
+        // Check if dataKey exists in dataset
+        if (context.data.length > 0 &&
+            !Object.prototype.hasOwnProperty.call(context.data[0], props.dataKey)) {
+            addError?.('LINE_CHART_PATH_ERROR', {
+                error: buildDataKeyNotFoundError(props.dataKey),
+            });
+            return;
+        }
+        // Curved path calculation errors
+        if (curved && context.data.length < 2) {
+            addError?.('LINE_CHART_PATH_ERROR', {
+                error: buildError(BuildError.LINE_CHART_PATH_INSUFFICIENT_POINTS),
+            });
+            return;
+        }
+        // Path rendering errors - validate coordinates
+        const yData = getAxisData(context.data, props.dataKey);
+        if (yData.length > 0 && yData.every(val => val === null || val === undefined)) {
+            addError?.('LINE_CHART_PATH_ERROR', {
+                error: buildError(BuildError.LINE_CHART_PATH_ALL_VALUES_NULL),
+            });
+        }
+    }, [props.dataKey, curved, context.data, addError]);
     // the node indicator logic
     const { indicatorRef, pathRef } = useIndicator(context.xCursor, !!indicatorConfig);
     const showIndicator = !!indicatorConfig && context.xCursor !== -Infinity;

package/dist/cjs/charts/lineChart/fragments/lineChartProjection.d.ts

@@ -1,4 +1,4 @@
-import type { FC } from 'react';
+import { type FC } from 'react';
 import type { LineChartProjectionProps } from '../lineChart.type';
 import './lineChartPath.css';
 export declare const LineChartProjection: FC<LineChartProjectionProps>;

package/dist/cjs/charts/lineChart/fragments/lineChartProjection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lineChartProjection.d.ts","sourceRoot":"","sources":["../../../../../src/charts/lineChart/fragments/lineChartProjection.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC;AAEhC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,qBAAqB,CAAC;AAE7B,eAAO,MAAM,mBAAmB,EAAE,EAAE,CAAC,wBAAwB,CA2B5D,CAAC"}
+{"version":3,"file":"lineChartProjection.d.ts","sourceRoot":"","sources":["../../../../../src/charts/lineChart/fragments/lineChartProjection.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,EAAyB,MAAM,OAAO,CAAC;AASvD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,qBAAqB,CAAC;AAE7B,eAAO,MAAM,mBAAmB,EAAE,EAAE,CAAC,wBAAwB,CA4E5D,CAAC"}

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

@@ -1,12 +1,56 @@
 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;
+    // Projection error validations
+    useEffect(() => {
+        // Invalid projection bounds - upper/lower overlap
+        if (upperProjection && lowerProjection) {
+            const upperY = upperProjection.y || 0;
+            const lowerY = lowerProjection.y || 0;
+            if (upperY >= lowerY) {
+                addError?.('LINE_CHART_PROJECTION_ERROR', {
+                    error: buildProjectionBoundsError(upperY, lowerY),
+                });
+            }
+        }
+        // Projection coordinates outside chart area
+        if (upperProjection) {
+            const { x: upperX, y: upperY } = 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) {
+            const { x: lowerX, y: lowerY } = 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),
+                });
+            }
+        }
+    }, [upperProjection, lowerProjection, svgHeight, addError]);
     const { downPath, shapePath, upPath } = getProjection({
         curved,
         lowerProjection,

package/dist/cjs/charts/lineChart/fragments/lineChartSeparator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lineChartSeparator.d.ts","sourceRoot":"","sources":["../../../../../src/charts/lineChart/fragments/lineChartSeparator.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,EAAiC,MAAM,OAAO,CAAC;AAK/D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAEjE,eAAO,MAAM,kBAAkB,EAAE,EAAE,CAAC,uBAAuB,CAoC1D,CAAC"}
+{"version":3,"file":"lineChartSeparator.d.ts","sourceRoot":"","sources":["../../../../../src/charts/lineChart/fragments/lineChartSeparator.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,EAA4C,MAAM,OAAO,CAAC;AAa1E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAEjE,eAAO,MAAM,kBAAkB,EAAE,EAAE,CAAC,uBAAuB,CA0F1D,CAAC"}