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

package/dist/cjs/utils/buildErrors/constants/errors/pieChartErrors.js

@@ -1,25 +1 @@
-import { PieChartErrorMessages } from '../errorMessages/pieChartErrorMessages';
-export const PieChartErrors = {
-    // Data Validation Errors
-    PIE_CHART_EMPTY_DATA: 'PIE_CHART_EMPTY_DATA',
-    // Radius Errors
-    PIE_CHART_INNER_RADIUS_OUT_OF_RANGE: 'PIE_CHART_INNER_RADIUS_OUT_OF_RANGE',
-    // Canvas & Context Errors
-    PIE_CHART_INVALID_CANVAS_DIMENSIONS: 'PIE_CHART_INVALID_CANVAS_DIMENSIONS',
-    // Data Validation Errors
-    PIE_CHART_INVALID_DATA_KEY: 'PIE_CHART_INVALID_DATA_KEY',
-    // Radius Errors
-    PIE_CHART_INVALID_INNER_RADIUS: 'PIE_CHART_INVALID_INNER_RADIUS',
-    PIE_CHART_INVALID_RADIUS: 'PIE_CHART_INVALID_RADIUS',
-    // Segment Errors
-    PIE_CHART_INVALID_SEGMENT_VALUE: 'PIE_CHART_INVALID_SEGMENT_VALUE',
-    // Data Validation Errors
-    PIE_CHART_INVALID_TOTAL: 'PIE_CHART_INVALID_TOTAL',
-    // Segment Errors
-    PIE_CHART_MISSING_SEGMENT_NAME: 'PIE_CHART_MISSING_SEGMENT_NAME',
-    PIE_CHART_NEGATIVE_SEGMENT_VALUE: 'PIE_CHART_NEGATIVE_SEGMENT_VALUE',
-};
-export const PieChartErrorsRecord = Object.entries(PieChartErrorMessages).reduce((acc, [key, message]) => {
-    acc[key] = new Error(message);
-    return acc;
-}, {});
+const e=require(`../errorMessages/pieChartErrorMessages.js`),t={PIE_CHART_EMPTY_DATA:`PIE_CHART_EMPTY_DATA`,PIE_CHART_INNER_RADIUS_OUT_OF_RANGE:`PIE_CHART_INNER_RADIUS_OUT_OF_RANGE`,PIE_CHART_INVALID_CANVAS_DIMENSIONS:`PIE_CHART_INVALID_CANVAS_DIMENSIONS`,PIE_CHART_INVALID_DATA_KEY:`PIE_CHART_INVALID_DATA_KEY`,PIE_CHART_INVALID_INNER_RADIUS:`PIE_CHART_INVALID_INNER_RADIUS`,PIE_CHART_INVALID_RADIUS:`PIE_CHART_INVALID_RADIUS`,PIE_CHART_INVALID_SEGMENT_VALUE:`PIE_CHART_INVALID_SEGMENT_VALUE`,PIE_CHART_INVALID_TOTAL:`PIE_CHART_INVALID_TOTAL`,PIE_CHART_MISSING_SEGMENT_NAME:`PIE_CHART_MISSING_SEGMENT_NAME`,PIE_CHART_NEGATIVE_SEGMENT_VALUE:`PIE_CHART_NEGATIVE_SEGMENT_VALUE`},n=Object.entries(e.PieChartErrorMessages).reduce((e,[t,n])=>(e[t]=Error(n),e),{});exports.PieChartErrors=t,exports.PieChartErrorsRecord=n;

package/dist/cjs/utils/buildTickValues/buildTickValues.js

@@ -1,47 +1 @@
-/**
- * Returns the divisor for a given number.
- * The divisor is determined based on the number's divisibility by 2, 3, 4, or 5.
- * If the number is not divisible by any of these, the divisor is set to 1.
- *
- * @param number - The number for which to determine the divisor.
- * @returns The divisor for the given number.
- */
-export const getDivisor = (number) => {
-    if (number % 3 === 0) {
-        return 3;
-    }
-    if (number % 4 === 0) {
-        return 4;
-    }
-    if (number % 5 === 0) {
-        return 5;
-    }
-    if (number % 2 === 0) {
-        return 2;
-    }
-    return 1;
-};
-/**
- * Builds the tick values for YAxis of a chart based on the provided data.
- * This is a fallback function that is used just in case no tickValues are provided as prop
- * Users should provide tickValues as prop to avoid using this basic fallback function
- *
- * @param data - An array of string values representing the data points.
- * @returns An object containing the numeric fallback tickValues for the YAxis of the chart.
- */
-export const buildTickValues = (data) => {
-    if (data.length === 0) {
-        return { numeric: { max: 2, min: 0, step: 1 } };
-    }
-    const yMin = Math.min(...data.map(d => parseFloat(d)));
-    const yMax = Math.max(...data.map(d => parseFloat(d)));
-    const yRange = Math.abs(yMax - yMin);
-    const step = yRange / 2;
-    return {
-        numeric: {
-            max: yMax,
-            min: yMin,
-            step,
-        },
-    };
-};
+exports.buildTickValues=e=>{if(e.length===0)return{numeric:{max:2,min:0,step:1}};let t=Math.min(...e.map(e=>parseFloat(e))),n=Math.max(...e.map(e=>parseFloat(e)));return{numeric:{max:n,min:t,step:Math.abs(n-t)/2}}};

package/dist/cjs/utils/createErrorAccumulator/createErrorAccumulator.js

@@ -1,54 +1 @@
-export const createErrorAccumulator = (onErrors) => {
-    const errors = new Map();
-    const getAccumulatedErrors = () => {
-        const result = {};
-        // Return all errors by type as arrays (internal format)
-        errors.forEach((errorArray, errorType) => {
-            result[errorType] = errorArray;
-        });
-        return result;
-    };
-    const addError = (errorType, error) => {
-        if (!error) {
-            return;
-        }
-        // Create complete error with type
-        const completeError = { ...error, type: errorType };
-        // Get existing errors for this type or create new array
-        const existingErrors = errors.get(errorType) || [];
-        // Add new error to the array
-        existingErrors.push(completeError);
-        // Set the updated array back to the Map
-        errors.set(errorType, existingErrors);
-        // Call onErrors callback immediately if provided
-        if (onErrors) {
-            const accumulatedErrors = getAccumulatedErrors();
-            // BACKWARDS COMPATIBILITY: Detect if callback expects legacy format
-            // If there's only one error per type, we offer compatibility with previous format
-            const compatibleErrors = {};
-            Object.entries(accumulatedErrors).forEach(([key, errorArray]) => {
-                const keyType = key;
-                // If it's an error array and has only one, it might be compatible with legacy format
-                if (Array.isArray(errorArray) && errorArray.length === 1) {
-                    // Try to determine if callback expects legacy format
-                    // For maximum compatibility, we offer the array but could also
-                    // offer the single element depending on context
-                    compatibleErrors[keyType] = errorArray;
-                }
-                else {
-                    // Multiple errors - only array format
-                    compatibleErrors[keyType] = errorArray;
-                }
-            });
-            onErrors(compatibleErrors);
-        }
-    };
-    const clearErrors = () => {
-        errors.clear();
-        // Call onErrors with empty object when clearing if callback is provided
-        if (onErrors) {
-            onErrors({});
-        }
-    };
-    return { addError, clearErrors, getAccumulatedErrors };
-};
+exports.createErrorAccumulator=e=>{let t=new Map,n=()=>{let e={};return t.forEach((t,n)=>{e[n]=t}),e};return{addError:(r,i)=>{if(!i)return;let a={...i,type:r},o=t.get(r)||[];if(o.push(a),t.set(r,o),e){let t=n(),r={};Object.entries(t).forEach(([e,t])=>{let n=e;r[n]=t}),e(r)}},clearErrors:()=>{t.clear(),e&&e({})},getAccumulatedErrors:n}};

package/dist/cjs/utils/cssGradientToSvg/cssGradientToSvg.js

@@ -1,46 +1 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { logger } from '../logger/logger';
-/**
- * Converts a CSS linear gradient string into an SVG linear gradient.
- *
- * This function parses a CSS gradient string, extracts its angle and color stops,
- * and then generates an SVG element with a corresponding linear gradient definition.
- * The SVG element is hidden and can be used within an SVG image or as a reference
- * for fill patterns. Currently, it supports gradients at angles of 90, 180, and 270 degrees.
- *
- * @param cssGradient - A string representing the CSS linear gradient. The string should
- *                      start with the gradient angle (in degrees) followed by color stops,
- *                      where each color stop is defined by its color and optional offset.
- *                      Example: "180, red, blue 50%".
- * @param id - An optional string that specifies the ID attribute for the generated
- *             linearGradient element. This ID can be used to reference the gradient
- *             from other SVG elements. Defaults to 'gradientePath'.
- * @returns An SVG element containing a linearGradient definition based on the provided
- *          CSS gradient string. If the angle is not supported, it returns an empty
- *          React fragment.
- */
-export const cssGradientToSVG = (cssGradient, id = 'gradientePath') => {
-    const parts = cssGradient.split(',').map(part => part.trim());
-    const angle = parseInt(parts[0], 10); // Extract the angle
-    const stops = parts.slice(1).map(part => {
-        const [color, offset] = part.split(' ');
-        return { color, offset };
-    });
-    const y1 = '0%';
-    let x1 = '0%', x2 = '0%', y2 = '0%';
-    switch (angle) {
-        case 180:
-            y2 = '100%';
-            break;
-        case 90:
-            x2 = '100%';
-            break;
-        case 270:
-            x1 = '100%';
-            break;
-        default:
-            logger.warn(`Unsupported gradient angle: ${angle}°. Supported angles are 90, 180, 270.`);
-            return _jsx(_Fragment, {}); // Return an empty fragment for unsupported angles
-    }
-    return (_jsx("defs", { children: _jsx("linearGradient", { id: id, x1: x1, x2: x2, y1: y1, y2: y2, children: stops.map((stop, index) => (_jsx("stop", { offset: stop.offset, stopColor: stop.color }, `${index}-${stop.offset}`.toString()))) }) }));
-};
+const e=require(`../logger/logger.js`);let t=require(`react/jsx-runtime`);exports.cssGradientToSVG=(n,r=`gradientePath`)=>{let i=n.split(`,`).map(e=>e.trim()),a=parseInt(i[0],10),o=i.slice(1).map(e=>{let[t,n]=e.split(` `);return{color:t,offset:n}}),s=`0%`,c=`0%`,l=`0%`;switch(a){case 180:l=`100%`;break;case 90:c=`100%`;break;case 270:s=`100%`;break;default:return e.logger.warn(`Unsupported gradient angle: ${a}°. Supported angles are 90, 180, 270.`),(0,t.jsx)(t.Fragment,{})}return(0,t.jsx)(`defs`,{children:(0,t.jsx)(`linearGradient`,{id:r,x1:s,x2:c,y1:`0%`,y2:l,children:o.map((e,n)=>(0,t.jsx)(`stop`,{offset:e.offset,stopColor:e.color},`${n}-${e.offset}`.toString()))})})};

package/dist/cjs/utils/cursorNear/isNear.js

@@ -1,3 +1 @@
-export const isNear = (cursor, position, extraArea = 1) => {
-    return cursor >= position - extraArea && cursor <= position + extraArea;
-};
+exports.isNear=(e,t,n=1)=>e>=t-n&&e<=t+n;

package/dist/cjs/utils/getCanvasDimensions/getCanvasDimensions.js

@@ -1,108 +1 @@
-import { safeDocument, safeGetComputedStyle } from '../ssr/ssr';
-import { Unit } from '../../types/unit.enum';
-/**
- * A mapping of string representations of units to their corresponding `Unit` enum values.
- * This is used to convert string-based unit identifiers into their respective `Unit` enum types.
- *
- * @example
- * stringToUnit["%"] // Returns Unit.PERCENT
- * stringToUnit["rem"] // Returns Unit.REM
- */
-const stringToUnit = {
-    [Unit.PERCENTAGE]: Unit.PERCENTAGE,
-    [Unit.REM]: Unit.REM,
-};
-/**
- * An enumeration representing the dimensions of an SVG element.
- * This is used to specify whether the width or height dimension is being referenced.
- *
- * @enum {string}
- * @property {string} WIDTH - Represents the width dimension ('WIDTH').
- * @property {string} HEIGHT - Represents the height dimension ('HEIGHT').
- */
-const Dimension = {
-    HEIGHT: 'HEIGHT',
-    WIDTH: 'WIDTH',
-};
-const UNIT_VALUE_REGEX = /^(\d+(\.\d+)?)(px|rem|%)?$/;
-const MATCH_VALUE_INDEX = 1;
-const MATCH_UNIT_INDEX = 3;
-/**
- * Extracts the numeric value and unit from a regex match result.
- *
- * @param match - The regex match array containing the value and unit.
- * @returns An object containing the numeric value and the unit as a string.
- */
-const parseDimensionValue = (value) => {
-    if (typeof value === 'number') {
-        return { unit: undefined, value };
-    }
-    const match = value.match(UNIT_VALUE_REGEX);
-    if (!match) {
-        throw new Error(`Invalid string format: "${value}"`);
-    }
-    const parsedValue = parseFloat(match[MATCH_VALUE_INDEX]); // match for group (\d+(\.\d+)?)
-    const unit = match[MATCH_UNIT_INDEX]; // match for group (px|rem|%)
-    return { unit: stringToUnit[unit], value: parsedValue };
-};
-/**
- * Calculates the percentage of a value based on the specified dimension (width or height) and the SVG element's dimensions.
- *
- * @param {number} value - The value to be converted to a percentage.
- * @param {`${Dimension}`} dimension - The dimension type (width or height).
- * @param {SVGSVGElement} svgElement - The SVG element to calculate dimensions for.
- * @returns {number} The calculated percentage value.
- */
-const calculatePercentage = (value, dimension, svgElement) => {
-    const svgContainer = svgElement.parentElement;
-    if (!svgContainer) {
-        return 0;
-    }
-    const containerDimension = dimension === Dimension.WIDTH ? svgContainer.clientWidth : svgContainer.clientHeight;
-    return (value / 100) * containerDimension;
-};
-/**
- * Calculates the rem value based on the root font size.
- * SSR-safe: Returns default 16px if not in browser environment.
- *
- * @param {number} value - The value in rem to be converted to pixels.
- * @returns {number} The calculated pixel value.
- */
-const calculateRem = (value) => {
-    const doc = safeDocument();
-    if (!doc) {
-        // SSR fallback: Default browser font size is typically 16px
-        return value * 16;
-    }
-    const style = safeGetComputedStyle(doc.documentElement);
-    if (!style) {
-        return value * 16;
-    }
-    const remValue = parseFloat(style.fontSize);
-    return value * (remValue || 16); // Fallback to 16 if fontSize is invalid
-};
-/**
- * Calculates the dimensions of an SVG element based on the provided width and height values.
- * The width and height can be specified in pixels, percentages, or rem units.
- *
- * @param {GetCanvasDimensionsProps} props - The properties for calculating dimensions.
- * @param {string | number} props.canvasHeight - The height of the canvas (can be a string or number).
- * @param {string | number} props.canvasWidth - The width of the canvas (can be a string or number).
- * @param {SVGSVGElement} props.svgElement - The SVG element to calculate dimensions for.
- * @returns {GetCanvasDimensionsReturn} An object containing the calculated canva's width and height.
- */
-export const getCanvasDimensions = ({ canvasHeight, canvasWidth, svgElement, }) => {
-    const { unit: widthUnit, value: widthValue } = parseDimensionValue(canvasWidth);
-    const parsedCanvasWidth = widthUnit === Unit.PERCENTAGE
-        ? calculatePercentage(widthValue, Dimension.WIDTH, svgElement)
-        : widthUnit === Unit.REM
-            ? calculateRem(widthValue)
-            : widthValue;
-    const { unit: heightUnit, value: heightValue } = parseDimensionValue(canvasHeight);
-    const parsedCanvasHeight = heightUnit === Unit.PERCENTAGE
-        ? calculatePercentage(heightValue, Dimension.HEIGHT, svgElement)
-        : heightUnit === Unit.REM
-            ? calculateRem(heightValue)
-            : heightValue;
-    return { parsedCanvasHeight, parsedCanvasWidth };
-};
+const e=require(`../ssr/ssr.js`),t=require(`../../types/unit.enum.js`);var n={[t.Unit.PERCENTAGE]:t.Unit.PERCENTAGE,[t.Unit.REM]:t.Unit.REM},r={HEIGHT:`HEIGHT`,WIDTH:`WIDTH`},i=/^(\d+(\.\d+)?)(px|rem|%)?$/,a=1,o=3,s=e=>{if(typeof e==`number`)return{unit:void 0,value:e};let t=e.match(i);if(!t)throw Error(`Invalid string format: "${e}"`);let r=parseFloat(t[a]);return{unit:n[t[o]],value:r}},c=(e,t,n)=>{let i=n.parentElement;if(!i)return 0;let a=t===r.WIDTH?i.clientWidth:i.clientHeight;return e/100*a},l=t=>{let n=e.safeDocument();if(!n)return t*16;let r=e.safeGetComputedStyle(n.documentElement);return r?t*(parseFloat(r.fontSize)||16):t*16};exports.getCanvasDimensions=({canvasHeight:e,canvasWidth:n,svgElement:i})=>{let{unit:a,value:o}=s(n),u=a===t.Unit.PERCENTAGE?c(o,r.WIDTH,i):a===t.Unit.REM?l(o):o,{unit:d,value:f}=s(e);return{parsedCanvasHeight:d===t.Unit.PERCENTAGE?c(f,r.HEIGHT,i):d===t.Unit.REM?l(f):f,parsedCanvasWidth:u}};

package/dist/cjs/utils/getChildrenAttr/getChildrenAttr.js

@@ -1,15 +1 @@
-import { Children, isValidElement } from 'react';
-export const getChildrenAttr = ({ attrName, children, originalValue, updateValue, }) => {
-    let combineString = '';
-    Children.toArray(children).forEach((child) => {
-        if (isValidElement(child)) {
-            const attrValue = child.props[attrName];
-            if (attrValue) {
-                combineString += attrValue;
-            }
-        }
-    });
-    if (combineString !== originalValue) {
-        updateValue(combineString);
-    }
-};
+let e=require(`react`);exports.getChildrenAttr=({attrName:t,children:n,originalValue:r,updateValue:i})=>{let a=``;e.Children.toArray(n).forEach(n=>{if((0,e.isValidElement)(n)){let e=n.props[t];e&&(a+=e)}}),a!==r&&i(a)};

package/dist/cjs/utils/getCoordinates/getCoordinates.js

@@ -1,90 +1 @@
-import { Positions } from '../../types/position.enum';
-/**
- * Calculates the X coordinates for drawing lines in a chart.
- * @param position - The position of the line.
- * @param canvasHeight - The height of the canvas.
- * @param canvasWidth - The width of the canvas.
- * @param extraSpaceLeftX - The extra space on the left side of the chart.
- * @param extraSpaceRightX - The extra space on the right side of the chart.
- * @param extraSpaceTopY - The extra space on the top side of the chart.
- * @param extraSpaceBottomY - The extra space on the bottom side of the chart.
- * @param customBreakAxis - The custom break axis value.
- * @returns The X coordinates for drawing lines.
- */
-export const getXCoordinates = ({ canvasHeight, canvasWidth, customBreakAxis, extraSpaceBottomY, extraSpaceLeftX, extraSpaceRightX, extraSpaceTopY, position, }) => {
-    if (position === Positions.TOP) {
-        return {
-            x1: extraSpaceLeftX,
-            x2: canvasWidth - extraSpaceRightX,
-            y1: extraSpaceTopY,
-            y2: extraSpaceTopY,
-        };
-    }
-    if (position === Positions.CENTER) {
-        return {
-            x1: extraSpaceLeftX,
-            x2: canvasWidth - extraSpaceRightX,
-            y1: canvasHeight / 2,
-            y2: canvasHeight / 2,
-        };
-    }
-    if (position === Positions.CUSTOM) {
-        return {
-            x1: extraSpaceLeftX,
-            x2: canvasWidth - extraSpaceRightX,
-            y1: customBreakAxis,
-            y2: customBreakAxis,
-        };
-    }
-    return {
-        x1: extraSpaceLeftX,
-        x2: canvasWidth - extraSpaceRightX,
-        y1: canvasHeight - extraSpaceBottomY,
-        y2: canvasHeight - extraSpaceBottomY,
-    };
-};
-/**
- * Calculates the y-coordinates for drawing lines in a chart.
- *
- * @param position - The position of the line (RIGHT, CENTER, CUSTOM).
- * @param canvasHeight - The height of the canvas.
- * @param canvasWidth - The width of the canvas.
- * @param extraSpaceLeftX - The extra space on the left side of the chart.
- * @param extraSpaceRightX - The extra space on the right side of the chart.
- * @param extraSpaceTopY - The extra space on the top of the chart.
- * @param extraSpaceBottomY - The extra space on the bottom of the chart.
- * @param customBreakAxis - The custom break axis position (used when position is CUSTOM).
- * @returns The y-coordinates for drawing lines in the chart.
- */
-export const getYCoordinates = ({ canvasHeight, canvasWidth, customBreakAxis, extraSpaceBottomY, extraSpaceLeftX, extraSpaceRightX, extraSpaceTopY, position, }) => {
-    if (position === Positions.RIGHT) {
-        return {
-            x1: canvasWidth - extraSpaceRightX,
-            x2: canvasWidth - extraSpaceRightX,
-            y1: extraSpaceTopY,
-            y2: canvasHeight - extraSpaceBottomY,
-        };
-    }
-    if (position === Positions.CENTER) {
-        return {
-            x1: canvasWidth / 2,
-            x2: canvasWidth / 2,
-            y1: extraSpaceTopY,
-            y2: canvasHeight - extraSpaceBottomY,
-        };
-    }
-    if (position === Positions.CUSTOM) {
-        return {
-            x1: customBreakAxis,
-            x2: customBreakAxis,
-            y1: extraSpaceTopY,
-            y2: canvasHeight - extraSpaceBottomY,
-        };
-    }
-    return {
-        x1: extraSpaceLeftX,
-        x2: extraSpaceLeftX,
-        y1: extraSpaceTopY,
-        y2: canvasHeight - extraSpaceBottomY,
-    };
-};
+const e=require(`../../types/position.enum.js`);exports.getXCoordinates=({canvasHeight:t,canvasWidth:n,customBreakAxis:r,extraSpaceBottomY:i,extraSpaceLeftX:a,extraSpaceRightX:o,extraSpaceTopY:s,position:c})=>c===e.Positions.TOP?{x1:a,x2:n-o,y1:s,y2:s}:c===e.Positions.CENTER?{x1:a,x2:n-o,y1:t/2,y2:t/2}:c===e.Positions.CUSTOM?{x1:a,x2:n-o,y1:r,y2:r}:{x1:a,x2:n-o,y1:t-i,y2:t-i},exports.getYCoordinates=({canvasHeight:t,canvasWidth:n,customBreakAxis:r,extraSpaceBottomY:i,extraSpaceLeftX:a,extraSpaceRightX:o,extraSpaceTopY:s,position:c})=>c===e.Positions.RIGHT?{x1:n-o,x2:n-o,y1:s,y2:t-i}:c===e.Positions.CENTER?{x1:n/2,x2:n/2,y1:s,y2:t-i}:c===e.Positions.CUSTOM?{x1:r,x2:r,y1:s,y2:t-i}:{x1:a,x2:a,y1:s,y2:t-i};

package/dist/cjs/utils/getDataFingerprint/getDataFingerprint.js

@@ -1,10 +1 @@
-/**
- * Generates a fingerprint of chart data for use in React.useMemo dependencies
- * @param data - Chart data from LineChart, BarChart, or PieChart
- * @returns JSON string representation of the data
- */
-export const getDataFingerprint = (data) => {
-    // TODO: study and compare performance with other hash libraries or manual methods
-    // ! Data might grow a lot in size, that is because this may be reviewed in the future
-    return JSON.stringify(data);
-};
+exports.getDataFingerprint=e=>JSON.stringify(e);

package/dist/cjs/utils/getPoints/getPoints.js

@@ -1,49 +1 @@
-/**
- * Calculates the positions of data points on the chart based on tick values and data values.
- * @param tickValues - An array of tick data objects.
- * @param data - An array of data values.
- * @param xAxis - Optional parameter indicating whether the points are for the x-axis. Defaults to false.
- * @returns An array of numbers representing the positions of the data points.
- */
-export const getPoints = (tickValues, data, xAxis) => {
-    return data.map(dt => {
-        // IF NOT A NUMBER, FIND THE POSITION OF THE TICK
-        if (isNaN(Number(dt))) {
-            const located = tickValues.find(tick => String(tick.value) === String(dt));
-            return located ? located.position : 0;
-        }
-        // FIND THE CLOSEST TICK
-        const { index, tick } = tickValues.reduce((prev, curr, tickiIndex) => {
-            return Math.abs(Number(curr.value) - Number(dt)) <=
-                Math.abs(Number(prev.tick.value) - Number(dt))
-                ? { index: tickiIndex, tick: curr }
-                : prev;
-        }, { index: 0, tick: tickValues[0] });
-        const dtNumber = Number(dt);
-        const tickValueNumber = Number(tick.value);
-        if (dtNumber !== tickValueNumber) {
-            const currentAxisValues = tickValues.map(tickVal => Number(tickVal.value));
-            const min = Math.min(...currentAxisValues);
-            const max = Math.max(...currentAxisValues);
-            if (dtNumber < min) {
-                return tickValues.at(0)?.position;
-            }
-            if (dtNumber > max) {
-                return tickValues.at(-1)?.position;
-            }
-            const diff = Math.abs(tickValueNumber - dtNumber);
-            const isGreaterThan = dtNumber > tickValueNumber;
-            const closeTick = isGreaterThan ? tickValues[index + 1] : tickValues[index - 1];
-            const diffBetweenTicks = Math.abs(Number(closeTick.value) - tickValueNumber);
-            const diffPercentaje = (diff * 100) / diffBetweenTicks;
-            const posBetweenTicks = Math.abs(tick.position - closeTick.position);
-            const ajustedAmount = (posBetweenTicks * diffPercentaje) / 100;
-            // This is because the X axis is drawn from left to right and the Y axis from top to bottom.
-            if (xAxis) {
-                return isGreaterThan ? tick.position + ajustedAmount : tick.position - ajustedAmount;
-            }
-            return isGreaterThan ? tick.position - ajustedAmount : tick.position + ajustedAmount;
-        }
-        return tick.position;
-    });
-};
+exports.getPoints=(e,t,n)=>t.map(t=>{if(isNaN(Number(t))){let n=e.find(e=>String(e.value)===String(t));return n?n.position:0}let{index:r,tick:i}=e.reduce((e,n,r)=>Math.abs(Number(n.value)-Number(t))<=Math.abs(Number(e.tick.value)-Number(t))?{index:r,tick:n}:e,{index:0,tick:e[0]}),a=Number(t),o=Number(i.value);if(a!==o){let t=e.map(e=>Number(e.value)),s=Math.min(...t),c=Math.max(...t);if(a<s)return e.at(0)?.position;if(a>c)return e.at(-1)?.position;let l=Math.abs(o-a),u=a>o,d=u?e[r+1]:e[r-1],f=Math.abs(Number(d.value)-o),p=l*100/f,m=Math.abs(i.position-d.position)*p/100;return n?u?i.position+m:i.position-m:u?i.position-m:i.position+m}return i.position});

package/dist/cjs/utils/getTickTextCoordinate/getTickTextCoordinates.js

@@ -1,30 +1 @@
-import { Positions } from '../../types/position.enum';
-/**
- * Calculates the x-coordinate for the tick text based on the position, x-coordinate, and font size.
- *
- * @param position - The position of the tick text.
- * @param x - The x-coordinate of the tick text.
- * @param fontSize - The font size of the tick text.
- * @returns The calculated x-coordinate for the tick text.
- */
-export const getTickTextXCoordinate = (position, x, fontSize) => {
-    if (position === Positions.RIGHT) {
-        return x + fontSize;
-    }
-    return x - fontSize;
-};
-/**
- * Calculates the y-coordinate for the tick text based on the position, y-coordinate, font size, and security space.
- *
- * @param position - The position of the tick text.
- * @param y - The y-coordinate of the tick text.
- * @param fontSize - The font size of the tick text.
- * @param securitySpace - The security space between the tick text and the chart.
- * @returns The calculated y-coordinate for the tick text.
- */
-export const getTickTextYCoordinate = (position, y, fontSize, securitySpace) => {
-    if (position === Positions.TOP) {
-        return fontSize;
-    }
-    return y + fontSize + securitySpace;
-};
+const e=require(`../../types/position.enum.js`);exports.getTickTextXCoordinate=(t,n,r)=>t===e.Positions.RIGHT?n+r:n-r,exports.getTickTextYCoordinate=(t,n,r,i)=>t===e.Positions.TOP?r:n+r+i;

package/dist/cjs/utils/getTicks/getTicks.js

@@ -1,49 +1 @@
-/**
- * Calculates the tick positions and values for the x-axis of a line chart.
- *
- * @param tickValues - The values to be displayed as ticks on the x-axis.
- * @param maxSpaceAvailable - The maximum space available for the x-axis.
- * @param securitySpace - The space reserved for security purposes.
- * @param crossAxis - The cross axis of the chart.
- * @param otherAxisSpace - The space occupied by the other axis.
- * @param initPos - The initial position of the x-axis.
- * @returns An array of objects containing the tick values and their corresponding positions.
- */
-export const getXTicks = ({ initPos, maxSpaceAvailable, otherAxisSpace, securitySpace, tickValues, }) => {
-    const ticksNumber = tickValues.length - 1;
-    const maxSpace = maxSpaceAvailable - otherAxisSpace - securitySpace;
-    const stepValue = maxSpace / ticksNumber;
-    const ticks = tickValues.map((value, idx) => {
-        const currentStep = idx * stepValue;
-        return {
-            position: initPos + currentStep + securitySpace / 2,
-            value,
-        };
-    });
-    return ticks;
-};
-/**
- * Calculates the tick positions and values for the y-axis of a line chart.
- *
- * @param tickValues - The values to be displayed as ticks on the y-axis.
- * @param maxSpaceAvailable - The maximum space available for the y-axis.
- * @param securitySpace - The space reserved for security purposes.
- * @param crossAxis - The cross axis of the chart.
- * @param otherAxisSpace - The space occupied by the other axis.
- * @param initPos - The initial position of the y-axis.
- * @returns An array of objects containing the tick values and their corresponding positions.
- */
-export const getYTicks = ({ initPos, maxSpaceAvailable, needAjusted, otherAxisSpace, securitySpace, tickValues, }) => {
-    const ticksNumber = tickValues.length - 1;
-    const maxSpace = maxSpaceAvailable - otherAxisSpace - securitySpace;
-    const stepValue = maxSpace / ticksNumber;
-    const additionalSpace = needAjusted ? securitySpace / 2 : 0;
-    const ticks = tickValues.map((value, idx) => {
-        const currentStep = idx * stepValue;
-        return {
-            position: initPos - currentStep - additionalSpace,
-            value,
-        };
-    });
-    return ticks;
-};
+exports.getXTicks=({initPos:e,maxSpaceAvailable:t,otherAxisSpace:n,securitySpace:r,tickValues:i})=>{let a=i.length-1,o=(t-n-r)/a;return i.map((t,n)=>({position:e+n*o+r/2,value:t}))},exports.getYTicks=({initPos:e,maxSpaceAvailable:t,needAjusted:n,otherAxisSpace:r,securitySpace:i,tickValues:a})=>{let o=a.length-1,s=(t-r-i)/o,c=n?i/2:0;return a.map((t,n)=>({position:e-n*s-c,value:t}))};