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

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,73 +1,164 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildLineContextValue = void 0;
-const position_enum_1 = require("../../../types/position.enum");
-const buildErrors_1 = require("../../../utils/buildErrors/buildErrors");
-const getCoordinates_1 = require("../../../utils/getCoordinates/getCoordinates");
-const getPoints_1 = require("../../../utils/getPoints/getPoints");
-const getTicks_1 = require("../../../utils/getTicks/getTicks");
-const getExtraSpacing_1 = require("../utils/getExtraSpacing");
+import { ErrorType } from '../../../types/errors.type';
+import { Positions } from '../../../types/position.enum';
+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.
  *
  * @param {BuildContextValue} options - The options for building the context value.
  * @returns {LineContextValue} - The built context value.
  */
-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, } = (0, getExtraSpacing_1.getExtraSpacing)({
+    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,
     });
     /**
      * Calculate the tick values for the X Axis.
      */
-    const crossXAxis = lineChartXPosition !== position_enum_1.Positions.TOP && lineChartXPosition !== position_enum_1.Positions.BOTTOM;
+    const crossXAxis = lineChartXPosition !== Positions.TOP && lineChartXPosition !== Positions.BOTTOM;
     const yAxisSpace = extraSpaceLeftX + extraSpaceRightX;
-    const xTickValues = (0, getTicks_1.getXTicks)({
+    const xTickValues = getXTicks({
         initPos: extraSpaceLeftX,
-        maxSpaceAvailable: canvasWidth,
+        maxSpaceAvailable: safeCanvasWidth,
         otherAxisSpace: yAxisSpace,
         securitySpace: securityXSpace,
         tickValues: xData,
     });
     if ((xTickValues ?? []).some(({ position }) => isNaN(position))) {
-        error = {
-            error: (0, buildErrors_1.buildError)(buildErrors_1.BuildError.INVALID_X_TICK),
+        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.
      */
-    const crossYAxis = lineChartYPosition !== position_enum_1.Positions.LEFT && lineChartYPosition !== position_enum_1.Positions.RIGHT;
+    const crossYAxis = lineChartYPosition !== Positions.LEFT && lineChartYPosition !== Positions.RIGHT;
     const otherAxisSpace = extraSpaceTopY + extraSpaceBottomY;
-    const yTickValues = (0, getTicks_1.getYTicks)({
-        initPos: canvasHeight - extraSpaceBottomY,
-        maxSpaceAvailable: canvasHeight,
+    const yTickValues = getYTicks({
+        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 ? (0, getPoints_1.getPoints)(yTickValues || [], [String(xBreakAxis)])[0] : 0;
-    const customBreakYAxis = crossYAxis ? (0, getPoints_1.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 = (0, getCoordinates_1.getXCoordinates)({
-        canvasHeight,
-        canvasWidth,
+    const xCoordinates = getXCoordinates({
+        canvasHeight: safeCanvasHeight,
+        canvasWidth: safeCanvasWidth,
         customBreakAxis: Number(customBreakXAxis),
         extraSpaceBottomY,
         extraSpaceLeftX,
@@ -79,9 +170,9 @@ const buildLineContextValue = ({ ajustedX, ajustedY, canvasHeight, canvasWidth,
     /**
      * Calculate the Y coordinates for the line chart.
      */
-    const yCoordinates = (0, getCoordinates_1.getYCoordinates)({
-        canvasHeight,
-        canvasWidth,
+    const yCoordinates = getYCoordinates({
+        canvasHeight: safeCanvasHeight,
+        canvasWidth: safeCanvasWidth,
         customBreakAxis: Number(customBreakYAxis),
         extraSpaceBottomY,
         extraSpaceLeftX,
@@ -90,37 +181,27 @@ const buildLineContextValue = ({ ajustedX, ajustedY, canvasHeight, canvasWidth,
         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,
@@ -129,10 +210,41 @@ const buildLineContextValue = ({ ajustedX, ajustedY, canvasHeight, canvasWidth,
         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;
 };
-exports.buildLineContextValue = buildLineContextValue;

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

@@ -1,7 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LineChartContext = exports.buildLineContextValue = void 0;
-var buildLineContextValue_1 = require("./buildLineContextValue");
-Object.defineProperty(exports, "buildLineContextValue", { enumerable: true, get: function () { return buildLineContextValue_1.buildLineContextValue; } });
-var lineChartContext_1 = require("./lineChartContext");
-Object.defineProperty(exports, "LineChartContext", { enumerable: true, get: function () { return lineChartContext_1.LineChartContext; } });
+export { buildLineContextValue } from './buildLineContextValue';
+export { LineChartContext } from './lineChartContext';

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

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LineChartContext = void 0;
-const react_1 = require("react");
-exports.LineChartContext = (0, react_1.createContext)({});
+import { createContext } from 'react';
+export const LineChartContext = createContext({});

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,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTEXT = void 0;
-exports.CONTEXT = {
+export const CONTEXT = {
+    addError: undefined,
     canvasExtraSpace: 0,
     canvasHeight: 500,
     canvasWidth: 500,

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

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTEXT = void 0;
-var contextData_1 = require("./contextData");
-Object.defineProperty(exports, "CONTEXT", { enumerable: true, get: function () { return contextData_1.CONTEXT; } });
+export { CONTEXT } from './contextData';

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

@@ -1,11 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LineChartYAxis = exports.LineChartXAxis = exports.LineChartSeparator = exports.LineChartPath = void 0;
-var lineChartPath_1 = require("./lineChartPath");
-Object.defineProperty(exports, "LineChartPath", { enumerable: true, get: function () { return lineChartPath_1.LineChartPath; } });
-var lineChartSeparator_1 = require("./lineChartSeparator");
-Object.defineProperty(exports, "LineChartSeparator", { enumerable: true, get: function () { return lineChartSeparator_1.LineChartSeparator; } });
-var lineChartXAxis_1 = require("./lineChartXAxis");
-Object.defineProperty(exports, "LineChartXAxis", { enumerable: true, get: function () { return lineChartXAxis_1.LineChartXAxis; } });
-var lineChartYAxis_1 = require("./lineChartYAxis");
-Object.defineProperty(exports, "LineChartYAxis", { enumerable: true, get: function () { return lineChartYAxis_1.LineChartYAxis; } });
+export { LineChartPath } from './lineChartPath';
+export { LineChartSeparator } from './lineChartSeparator';
+export { LineChartXAxis } from './lineChartXAxis';
+export { LineChartYAxis } from './lineChartYAxis';

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

@@ -1,31 +1,61 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LineChartPath = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const react_1 = require("react");
-const line_1 = require("../../../components/line/line");
-const node_1 = require("../../../components/node/node");
-const path_1 = require("../../../components/path/path");
-const getPoints_1 = require("../../../utils/getPoints/getPoints");
-const pickCustomAttributes_1 = require("../../../utils/pickCustomAttributes/pickCustomAttributes");
-const lineChartContext_1 = require("../context/lineChartContext");
-const useIndicator_1 = require("../hook/useIndicator");
-const findSurroundingNumber_1 = require("../utils/findSurroundingNumber");
-const getPathData_1 = require("../utils/getPathData");
-const handleNodesFocus_1 = require("../utils/handleNodesFocus");
-require("./lineChartPath.css");
-const lineChartProjection_1 = require("./lineChartProjection");
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+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';
+import { useIndicator } from '../hook/useIndicator';
+import { findClosestNumber, findSurroundingNumber } from '../utils/findSurroundingNumber';
+import { getPathData } from '../utils/getPathData';
+import { handleNodesFocus } from '../utils/handleNodesFocus';
+import './lineChartPath.css';
+import { LineChartProjection } from './lineChartProjection';
 const getAxisData = (data, key) => {
     return data.map(dt => dt[key]);
 };
-const LineChartPath = ({ ariaLabel, closestClick, curved, getNodeFocusInfo, getNodesCoords, indicatorConfig, lineProjection, onClick, ...props }) => {
+export const LineChartPath = ({ ariaLabel, closestClick, curved, getNodeFocusInfo, getNodesCoords, indicatorConfig, lineProjection, onClick, ...props }) => {
     // recovery the context values
-    const { xAxisCoordinates, yAxisCoordinates, ...context } = (0, react_1.useContext)(lineChartContext_1.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 } = (0, useIndicator_1.useIndicator)(context.xCursor, !!indicatorConfig);
+    const { indicatorRef, pathRef } = useIndicator(context.xCursor, !!indicatorConfig);
     const showIndicator = !!indicatorConfig && context.xCursor !== -Infinity;
-    const innerRefs = (0, react_1.useRef)(null);
-    const pressedRef = (0, react_1.useRef)(null);
+    const innerRefs = useRef(null);
+    const pressedRef = useRef(null);
     // the projection line logic
     const { autoClick, lineIndicator, ...nodeIndicatorConfig } = indicatorConfig || {};
     // line indicator <Y> coordinates
@@ -36,24 +66,24 @@ const LineChartPath = ({ ariaLabel, closestClick, curved, getNodeFocusInfo, getN
     const { tickValues: yTickValues } = yAxisCoordinates;
     const xData = getAxisData(context.data, context.xKey);
     const yData = getAxisData(context.data, props.dataKey);
-    const xPoints = (0, getPoints_1.getPoints)(xTickValues, xData, true);
-    const yPoints = (0, getPoints_1.getPoints)(yTickValues, yData);
+    const xPoints = getPoints(xTickValues, xData, true);
+    const yPoints = getPoints(yTickValues, yData);
     const points = xPoints.map((x, i) => [x, yPoints[i]]);
     // the path data
-    const dataOnlyLine = (0, getPathData_1.getPathData)({
+    const dataOnlyLine = getPathData({
         curved,
         extendToBottom: false,
         points,
         svgHeight: Number(context.canvasHeight) - context.extraSpaceBottomY,
     });
-    const dataFill = (0, getPathData_1.getPathData)({
+    const dataFill = getPathData({
         curved,
         extendToBottom: !!props.fill || !!props.gradient,
         points,
         svgHeight: Number(context.canvasHeight) - context.extraSpaceBottomY,
     });
     // the ref to the path and handler the nodes focus
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (!innerRefs.current?.path) {
             return;
         }
@@ -61,15 +91,15 @@ const LineChartPath = ({ ariaLabel, closestClick, curved, getNodeFocusInfo, getN
         const main = innerRefs.current.main;
         const nodes = innerRefs.current.node;
         const data = xData.map((d, i) => ({ x: d, y: yData[i] }));
-        const { mount, unmount } = (0, handleNodesFocus_1.handleNodesFocus)({ data, getNodeFocusInfo, nodes, ref: main });
+        const { mount, unmount } = handleNodesFocus({ data, getNodeFocusInfo, nodes, ref: main });
         mount();
         // eslint-disable-next-line consistent-return
         return () => unmount();
     }, []);
     //  the auto click logic
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (props.nodeConfig && showIndicator && autoClick) {
-            const { idx, match } = (0, findSurroundingNumber_1.findSurroundingNumber)(xPoints, context.xCursor);
+            const { idx, match } = findSurroundingNumber(xPoints, context.xCursor);
             if (match && idx !== pressedRef.current) {
                 pressedRef.current = idx;
                 const evt = new MouseEvent('click', { bubbles: true });
@@ -83,27 +113,26 @@ const LineChartPath = ({ ariaLabel, closestClick, curved, getNodeFocusInfo, getN
         }
     }, [context.xCursor]);
     // Return the nodes coordinates
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         getNodesCoords?.(points);
     }, [points]);
     // the click handler
     const handleClick = (data) => {
         onClick?.(data);
         if (closestClick) {
-            const closest = (0, findSurroundingNumber_1.findClosestNumber)(xPoints, context.xCursor);
+            const closest = findClosestNumber(xPoints, context.xCursor);
             const evt = new MouseEvent('click', { bubbles: true });
             evt.autoClick = false;
             innerRefs.current?.node?.[closest]?.dispatchEvent(evt);
         }
     };
     // Extract custom attributes (aria-*, data-*) and handle deprecated ariaLabel
-    const customAttributes = (0, pickCustomAttributes_1.pickCustomAttributes)(props);
+    const customAttributes = pickCustomAttributes(props);
     const mergedProps = {
         ...props,
         ...customAttributes,
         // Handle deprecated ariaLabel - give precedence to ariaLabel for backward compatibility
         ...(ariaLabel && { 'aria-label': ariaLabel }),
     };
-    return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(path_1.Path, { ref: innerRefs, d: dataOnlyLine, dFill: dataFill, dataTestId: `${context.dataTestId}path`, dataValue: context.data, points: points, xKey: context.xKey, onClick: handleClick, ...mergedProps }), lineProjection && ((0, jsx_runtime_1.jsx)(lineChartProjection_1.LineChartProjection, { curved: curved, dataKey: props.dataKey, lineProjection: lineProjection, points: points, svgHeight: Number(context.canvasHeight) - context.extraSpaceBottomY })), showIndicator && ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [!!lineIndicator && ((0, jsx_runtime_1.jsx)(line_1.Line, { ...lineIndicator, className: "pointer-events-none", x1: context.xCursor, x2: context.xCursor, y1: y1, y2: y2 })), (0, jsx_runtime_1.jsx)("g", { ref: indicatorRef, className: "pointer-events-none", children: (0, jsx_runtime_1.jsx)(node_1.Node, { ...nodeIndicatorConfig }) })] }))] }));
+    return (_jsxs(_Fragment, { children: [_jsx(Path, { ref: innerRefs, d: dataOnlyLine, dFill: dataFill, dataTestId: `${context.dataTestId}path`, dataValue: context.data, points: points, xKey: context.xKey, onClick: handleClick, ...mergedProps }), lineProjection && (_jsx(LineChartProjection, { curved: curved, dataKey: props.dataKey, lineProjection: lineProjection, points: points, svgHeight: Number(context.canvasHeight) - context.extraSpaceBottomY })), showIndicator && (_jsxs(_Fragment, { children: [!!lineIndicator && (_jsx(Line, { ...lineIndicator, className: "pointer-events-none", x1: context.xCursor, x2: context.xCursor, y1: y1, y2: y2 })), _jsx("g", { ref: indicatorRef, className: "pointer-events-none", children: _jsx(Node, { ...nodeIndicatorConfig }) })] }))] }));
 };
-exports.LineChartPath = LineChartPath;

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