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

package/dist/esm/utils/getCanvasDimensions/getCanvasDimensions.js

@@ -1,108 +1,39 @@
-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,
+import { safeDocument, safeGetComputedStyle } from "../ssr/ssr.js";
+import { Unit } from "../../types/unit.enum.js";
+var stringToUnit = {
+	[Unit.PERCENTAGE]: Unit.PERCENTAGE,
+	[Unit.REM]: Unit.REM
+}, Dimension = {
+	HEIGHT: "HEIGHT",
+	WIDTH: "WIDTH"
+}, UNIT_VALUE_REGEX = /^(\d+(\.\d+)?)(px|rem|%)?$/, MATCH_VALUE_INDEX = 1, MATCH_UNIT_INDEX = 3, parseDimensionValue = (e) => {
+	if (typeof e == "number") return {
+		unit: void 0,
+		value: e
+	};
+	let t = e.match(UNIT_VALUE_REGEX);
+	if (!t) throw Error(`Invalid string format: "${e}"`);
+	let n = parseFloat(t[MATCH_VALUE_INDEX]);
+	return {
+		unit: stringToUnit[t[MATCH_UNIT_INDEX]],
+		value: n
+	};
+}, calculatePercentage = (e, t, n) => {
+	let r = n.parentElement;
+	if (!r) return 0;
+	let a = t === Dimension.WIDTH ? r.clientWidth : r.clientHeight;
+	return e / 100 * a;
+}, calculateRem = (n) => {
+	let r = safeDocument();
+	if (!r) return n * 16;
+	let i = safeGetComputedStyle(r.documentElement);
+	return i ? n * (parseFloat(i.fontSize) || 16) : n * 16;
 };
-/**
- * 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 getCanvasDimensions = ({ canvasHeight: e, canvasWidth: t, svgElement: r }) => {
+	let { unit: a, value: o } = parseDimensionValue(t), s = a === Unit.PERCENTAGE ? calculatePercentage(o, Dimension.WIDTH, r) : a === Unit.REM ? calculateRem(o) : o, { unit: c, value: l } = parseDimensionValue(e);
+	return {
+		parsedCanvasHeight: c === Unit.PERCENTAGE ? calculatePercentage(l, Dimension.HEIGHT, r) : c === Unit.REM ? calculateRem(l) : l,
+		parsedCanvasWidth: s
+	};
 };
+export { getCanvasDimensions };

package/dist/esm/utils/getChildrenAttr/getChildrenAttr.js

@@ -1,15 +1,11 @@
-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);
-    }
+import { Children, isValidElement } from "react";
+const getChildrenAttr = ({ attrName: n, children: r, originalValue: i, updateValue: a }) => {
+	let o = "";
+	Children.toArray(r).forEach((e) => {
+		if (isValidElement(e)) {
+			let t = e.props[n];
+			t && (o += t);
+		}
+	}), o !== i && a(o);
 };
+export { getChildrenAttr };

package/dist/esm/utils/getCoordinates/getCoordinates.js

@@ -1,90 +1,43 @@
-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,
-    };
+import { Positions } from "../../types/position.enum.js";
+const getXCoordinates = ({ canvasHeight: e, canvasWidth: t, customBreakAxis: n, extraSpaceBottomY: r, extraSpaceLeftX: i, extraSpaceRightX: a, extraSpaceTopY: o, position: s }) => s === Positions.TOP ? {
+	x1: i,
+	x2: t - a,
+	y1: o,
+	y2: o
+} : s === Positions.CENTER ? {
+	x1: i,
+	x2: t - a,
+	y1: e / 2,
+	y2: e / 2
+} : s === Positions.CUSTOM ? {
+	x1: i,
+	x2: t - a,
+	y1: n,
+	y2: n
+} : {
+	x1: i,
+	x2: t - a,
+	y1: e - r,
+	y2: e - r
+}, getYCoordinates = ({ canvasHeight: e, canvasWidth: t, customBreakAxis: n, extraSpaceBottomY: r, extraSpaceLeftX: i, extraSpaceRightX: a, extraSpaceTopY: o, position: s }) => s === Positions.RIGHT ? {
+	x1: t - a,
+	x2: t - a,
+	y1: o,
+	y2: e - r
+} : s === Positions.CENTER ? {
+	x1: t / 2,
+	x2: t / 2,
+	y1: o,
+	y2: e - r
+} : s === Positions.CUSTOM ? {
+	x1: n,
+	x2: n,
+	y1: o,
+	y2: e - r
+} : {
+	x1: i,
+	x2: i,
+	y1: o,
+	y2: e - r
 };
+export { getXCoordinates, getYCoordinates };

package/dist/esm/utils/getDataFingerprint/getDataFingerprint.js

@@ -1,10 +1,2 @@
-/**
- * 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);
-};
+const getDataFingerprint = (e) => JSON.stringify(e);
+export { getDataFingerprint };

package/dist/esm/utils/getPoints/getPoints.js

@@ -1,49 +1,22 @@
-/**
- * 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;
-    });
-};
+const 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;
+});
+export { getPoints };

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

@@ -1,30 +1,3 @@
-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;
-};
+import { Positions } from "../../types/position.enum.js";
+const getTickTextXCoordinate = (e, t, n) => e === Positions.RIGHT ? t + n : t - n, getTickTextYCoordinate = (e, t, n, r) => e === Positions.TOP ? n : t + n + r;
+export { getTickTextXCoordinate, getTickTextYCoordinate };

package/dist/esm/utils/getTicks/getTicks.js

@@ -1,49 +1,14 @@
-/**
- * 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;
+const 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
+	}));
+}, 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
+	}));
 };
+export { getXTicks, getYTicks };

package/dist/esm/utils/logger/logger.js

@@ -1,140 +1,25 @@
-/**
- * Logger utility for @kubit/web-ui-charts
- *
- * Provides a centralized logging system that:
- * - Respects NODE_ENV (disabled in production builds)
- * - Supports different log levels
- * - Can be configured/disabled by consumers
- * - Will be stripped out in production builds via terser
- */
-/**
- * Detect if we're in a production build
- * Uses globalThis to be compatible with different environments (browser, Node, SSR)
- */
-const isProduction = () => {
-    // Check if globalThis.process exists (Node/SSR environments)
-    if (typeof globalThis !== 'undefined' && 'process' in globalThis) {
-        const proc = globalThis.process;
-        return proc?.env?.NODE_ENV === 'production';
-    }
-    // In browser or other environments, assume development unless explicitly set
-    return false;
-};
-const DEFAULT_CONFIG = {
-    enabled: !isProduction(),
-    minLevel: 'info',
-    prefix: '[Kubit Charts]',
-};
-let config = { ...DEFAULT_CONFIG };
-const LOG_LEVELS = {
-    debug: 0,
-    error: 3,
-    info: 1,
-    warn: 2,
-};
-/**
- * Configure the logger behavior
- * @param newConfig - Partial configuration to merge with current settings
- *
- * @example
- * ```ts
- * // Disable all logging
- * configureLogger({ enabled: false });
- *
- * // Enable debug logs in development
- * configureLogger({ minLevel: 'debug' });
- * ```
- */
-export const configureLogger = (newConfig) => {
-    config = { ...config, ...newConfig };
-};
-/**
- * Reset logger to default configuration
- */
-export const resetLogger = () => {
-    config = { ...DEFAULT_CONFIG };
-};
-/**
- * Check if a log level should be output based on configuration
- */
-const shouldLog = (level) => {
-    if (!config.enabled) {
-        return false;
-    }
-    return LOG_LEVELS[level] >= LOG_LEVELS[config.minLevel];
-};
-/**
- * Format log message with prefix
- */
-const formatMessage = (message) => {
-    return `${config.prefix} ${message}`;
-};
-/**
- * Log debug messages (development only)
- * Useful for detailed debugging information
- *
- * @example
- * ```ts
- * logger.debug('Chart dimensions calculated', { width: 400, height: 300 });
- * ```
- */
-const debug = (message, ...args) => {
-    if (shouldLog('debug')) {
-        // eslint-disable-next-line no-console
-        console.debug(formatMessage(message), ...args);
-    }
-};
-/**
- * Log informational messages
- *
- * @example
- * ```ts
- * logger.info('Chart rendered successfully');
- * ```
- */
-const info = (message, ...args) => {
-    if (shouldLog('info')) {
-        // eslint-disable-next-line no-console
-        console.info(formatMessage(message), ...args);
-    }
-};
-/**
- * Log warning messages
- * Use for non-breaking issues that developers should be aware of
- *
- * @example
- * ```ts
- * logger.warn('Invalid gradient angle, falling back to default', angle);
- * ```
- */
-const warn = (message, ...args) => {
-    if (shouldLog('warn')) {
-        // eslint-disable-next-line no-console
-        console.warn(formatMessage(message), ...args);
-    }
-};
-/**
- * Log error messages
- * Use for errors that don't prevent execution but indicate problems
- *
- * @example
- * ```ts
- * logger.error('Failed to calculate text bounds, using fallback', error);
- * ```
- */
-const error = (message, ...args) => {
-    if (shouldLog('error')) {
-        // eslint-disable-next-line no-console
-        console.error(formatMessage(message), ...args);
-    }
-};
-/**
- * Main logger object
- * Export as singleton to ensure consistent configuration
- */
-export const logger = {
-    debug,
-    error,
-    info,
-    warn,
-};
+var config = {
+	enabled: !(typeof globalThis < "u" && "process" in globalThis && globalThis.process?.env?.NODE_ENV === "production"),
+	minLevel: "info",
+	prefix: "[Kubit Charts]"
+}, LOG_LEVELS = {
+	debug: 0,
+	error: 3,
+	info: 1,
+	warn: 2
+}, shouldLog = (n) => config.enabled ? LOG_LEVELS[n] >= LOG_LEVELS[config.minLevel] : !1, formatMessage = (t) => `${config.prefix} ${t}`;
+const logger = {
+	debug: (e, ...t) => {
+		shouldLog("debug") && console.debug(formatMessage(e), ...t);
+	},
+	error: (e, ...t) => {
+		shouldLog("error") && console.error(formatMessage(e), ...t);
+	},
+	info: (e, ...t) => {
+		shouldLog("info") && console.info(formatMessage(e), ...t);
+	},
+	warn: (e, ...t) => {
+		shouldLog("warn") && console.warn(formatMessage(e), ...t);
+	}
+};
+export { logger };