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

package/dist/esm/components/focusRing/components/FocusRingSeparate.js

@@ -1,45 +1,15 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useFocusRingData } from '../hooks/useFocusRingData';
-import { FocusRingRenderer } from './FocusRingRenderer';
-/**
- * FocusRing component for separate mode (targetRef).
- * Renders only the focus ring, allowing precise z-order control.
- *
- * This component:
- * - Uses a ref to the target element (does not wrap it)
- * - Only renders the focus ring (no children cloning)
- * - Allows precise z-order control by controlling where FocusRing is placed in JSX
- * - Handles both adaptive and bounding-box variants
- *
- * **IMPORTANT NOTE: Z-Order with Adaptive Variant**
- *
- * When using `variant: 'adaptive'` (default), the FocusRing **MUST be rendered BEFORE**
- * the target element in SVG document order. Otherwise, focus ring strokes will cover the element.
- *
- * @param props - FocusRingSeparateProps
- * @returns JSX element with only focus ring, or null if not focused/disabled
- *
- * @example
- * ```tsx
- * const ref = useRef<SVGCircleElement>(null);
- *
- * // CORRECT: FocusRing before element
- * <>
- *   <FocusRingSeparate targetRef={ref} isFocused={true} />
- *   <circle ref={ref} cx={50} cy={50} r={30} />
- * </>
- * ```
- */
-export const FocusRingSeparate = ({ dataTestId = 'focus-ring', disabled = false, focusConfig, isFocused, targetRef, }) => {
-    const { layers } = useFocusRingData({
-        elementRef: targetRef,
-        focusConfig,
-        isFocused,
-    });
-    // Early return if not focused or disabled
-    if (!isFocused || disabled) {
-        return null;
-    }
-    // Render focus ring with unified structure
-    return _jsx(FocusRingRenderer, { dataTestId: dataTestId, layers: layers });
+import { useFocusRingData } from "../hooks/useFocusRingData.js";
+import { FocusRingRenderer } from "./FocusRingRenderer.js";
+import { jsx } from "react/jsx-runtime";
+const FocusRingSeparate = ({ dataTestId: e = "focus-ring", disabled: t = !1, focusConfig: n, isFocused: r, targetRef: i }) => {
+	let { layers: a } = useFocusRingData({
+		elementRef: i,
+		focusConfig: n,
+		isFocused: r
+	});
+	return !r || t ? null : /* @__PURE__ */ jsx(FocusRingRenderer, {
+		dataTestId: e,
+		layers: a
+	});
 };
+export { FocusRingSeparate };

package/dist/esm/components/focusRing/focusRing2.js

@@ -0,0 +1,18 @@
+import { FocusRingInline } from "./components/FocusRingInline.js";
+import { FocusRingSeparate } from "./components/FocusRingSeparate.js";
+/* empty css          */
+import { jsx } from "react/jsx-runtime";
+const FocusRing = ({ children: e, dataTestId: t = "focus-ring", disabled: n = !1, focusConfig: r, isFocused: i, targetRef: a }) => e ? /* @__PURE__ */ jsx(FocusRingInline, {
+	dataTestId: t,
+	disabled: n,
+	focusConfig: r,
+	isFocused: i,
+	children: e
+}) : a ? /* @__PURE__ */ jsx(FocusRingSeparate, {
+	dataTestId: t,
+	disabled: n,
+	focusConfig: r,
+	isFocused: i,
+	targetRef: a
+}) : null;
+export { FocusRing };

package/dist/esm/components/focusRing/hooks/useFocusRingData.js

@@ -1,67 +1,28 @@
-import { useEffect, useMemo, useState } from 'react';
-import { getFocusConfig } from '../../../types/focusConfig.type';
-import { SVG_GEOMETRIC_ATTRIBUTES, createAdaptiveFocusRings, } from '../utils/createAdaptiveFocusRings';
-import { createBoundingBoxFocusRings } from '../utils/createBoundingBoxFocusRings';
-/**
- * Hook that handles all focus ring data calculation logic.
- * Separated from rendering concerns for better testability and reusability.
- *
- * This hook:
- * - Generates layers for both adaptive and bounding-box variants
- * - Both variants return the same FocusRingLayers structure
- * - Only calculates what's needed based on the variant
- * - Manages all the state and effects related to focus ring data
- *
- * @param options - Configuration options for the hook
- * @returns Focus ring data including resolved config and calculated layers
- */
-export function useFocusRingData({ elementRef, focusConfig, isFocused, }) {
-    // Resolve config once at the top
-    const resolvedConfig = useMemo(() => getFocusConfig(focusConfig), [focusConfig]);
-    const [layers, setLayers] = useState(undefined);
-    // Calculation happens when isFocused changes or when focus config changes
-    // MutationObserver watches for geometric attribute changes
-    // to automatically regenerate layers when the element moves or resizes
-    useEffect(() => {
-        if (!elementRef?.current || !isFocused) {
-            setLayers(undefined);
-            return undefined;
-        }
-        const element = elementRef.current;
-        // Function to calculate focus ring layers from current DOM state
-        const calculateRings = () => {
-            // Strategy 1: Adaptive variant - generate layers from DOM element
-            if (resolvedConfig.variant === 'adaptive') {
-                const adaptiveLayers = createAdaptiveFocusRings(element, resolvedConfig);
-                setLayers(adaptiveLayers);
-            }
-            // Strategy 2: Bounding-box variant - detect bounds and calculate layers
-            if (resolvedConfig.variant === 'bounding-box') {
-                const boundingBoxLayers = createBoundingBoxFocusRings(element, resolvedConfig);
-                setLayers(boundingBoxLayers);
-            }
-        };
-        // Calculate layers initially
-        calculateRings();
-        // Set up MutationObserver to detect changes in geometric attributes
-        // This ensures focus ring updates automatically when the element moves or resizes
-        const observer = new MutationObserver(mutations => {
-            const hasGeometricChanges = mutations.some(mutation => mutation.type === 'attributes' &&
-                SVG_GEOMETRIC_ATTRIBUTES.includes(mutation.attributeName ?? ''));
-            if (hasGeometricChanges) {
-                // Recalculate focus rings on relevant attribute changes
-                calculateRings();
-            }
-        });
-        // Observe only geometric attributes that affect position and size
-        observer.observe(element, {
-            attributeFilter: [...SVG_GEOMETRIC_ATTRIBUTES],
-            attributes: true,
-        });
-        return () => observer.disconnect();
-    }, [isFocused, resolvedConfig]);
-    return {
-        layers,
-        resolvedConfig,
-    };
+import { getFocusConfig } from "../../../types/focusConfig.type.js";
+import { SVG_GEOMETRIC_ATTRIBUTES, createAdaptiveFocusRings } from "../utils/createAdaptiveFocusRings.js";
+import { createBoundingBoxFocusRings } from "../utils/createBoundingBoxFocusRings.js";
+import { useEffect, useMemo, useState } from "react";
+function useFocusRingData({ elementRef: r, focusConfig: i, isFocused: a }) {
+	let o = useMemo(() => getFocusConfig(i), [i]), [s, c] = useState(void 0);
+	return useEffect(() => {
+		if (!r?.current || !a) {
+			c(void 0);
+			return;
+		}
+		let e = r.current, t = () => {
+			o.variant === "adaptive" && c(createAdaptiveFocusRings(e, o)), o.variant === "bounding-box" && c(createBoundingBoxFocusRings(e, o));
+		};
+		t();
+		let n = new MutationObserver((e) => {
+			e.some((e) => e.type === "attributes" && SVG_GEOMETRIC_ATTRIBUTES.includes(e.attributeName ?? "")) && t();
+		});
+		return n.observe(e, {
+			attributeFilter: [...SVG_GEOMETRIC_ATTRIBUTES],
+			attributes: !0
+		}), () => n.disconnect();
+	}, [a, o]), {
+		layers: s,
+		resolvedConfig: o
+	};
 }
+export { useFocusRingData };

package/dist/esm/components/focusRing/utils/composeRefs.js

@@ -1,16 +1,8 @@
-/**
- * Composes multiple refs into a single ref callback
- * Allows using both internal and external refs simultaneously
- */
-export function composeRefs(...refs) {
-    return (instance) => {
-        refs.forEach(ref => {
-            if (typeof ref === 'function') {
-                ref(instance);
-            }
-            else if (ref) {
-                ref.current = instance;
-            }
-        });
-    };
+function composeRefs(...e) {
+	return (t) => {
+		e.forEach((e) => {
+			typeof e == "function" ? e(t) : e && (e.current = t);
+		});
+	};
 }
+export { composeRefs };

package/dist/esm/components/focusRing/utils/createAdaptiveFocusRings.js

@@ -1,141 +1,75 @@
-/**
- * SVG geometric attributes that define shape position and dimensions.
- * These attributes are extracted from the original element to create focus rings.
- * Also used by MutationObserver to detect when focus rings need to be regenerated.
- */
-export const SVG_GEOMETRIC_ATTRIBUTES = [
-    // Circle attributes
-    'cx',
-    'cy',
-    'r',
-    // Rectangle and general positioning attributes
-    'x',
-    'y',
-    'width',
-    'height',
-    // Ellipse attributes (cx, cy already included)
-    'rx',
-    'ry',
-    // Path attributes
-    'd',
-    // Polygon and polyline attributes
-    'points',
-    // Line attributes
-    'x1',
-    'y1',
-    'x2',
-    'y2',
+const SVG_GEOMETRIC_ATTRIBUTES = [
+	"cx",
+	"cy",
+	"r",
+	"x",
+	"y",
+	"width",
+	"height",
+	"rx",
+	"ry",
+	"d",
+	"points",
+	"x1",
+	"y1",
+	"x2",
+	"y2"
 ];
-/**
- * SVG presentation attributes that affect stroke appearance.
- * These are preserved for focus rings when they match the original element's style.
- */
-const SVG_STROKE_ATTRIBUTES = [
-    'stroke-dasharray',
-    'stroke-dashoffset',
-    'stroke-linecap',
-    'stroke-linejoin',
-    'stroke-miterlimit',
-    'stroke-opacity',
+var SVG_STROKE_ATTRIBUTES = [
+	"stroke-dasharray",
+	"stroke-dashoffset",
+	"stroke-linecap",
+	"stroke-linejoin",
+	"stroke-miterlimit",
+	"stroke-opacity"
+], SUPPORTED_SVG_TYPES = [
+	"circle",
+	"rect",
+	"ellipse",
+	"path",
+	"polygon",
+	"polyline",
+	"line"
 ];
-/**
- * SVG element types that support adaptive focus rings.
- * These are geometric shapes that can be properly outlined with focus rings.
- */
-const SUPPORTED_SVG_TYPES = ['circle', 'rect', 'ellipse', 'path', 'polygon', 'polyline', 'line'];
-/**
- * Creates adaptive focus ring layers from a DOM SVGElement.
- *
- * This function reads properties directly from the DOM element and creates
- * props objects for rendering new SVG elements with scaled stroke-width for the focus rings.
- * The focus rings adapt to the exact shape of the element (circle → circle, path → path, etc.)
- *
- * This unified approach works for both targetRef and children modes by
- * reading from the mounted DOM element.
- *
- * @param element - The SVG graphics element to create focus rings for
- * @param focusConfig - Focus ring configuration (colors, widths, gap)
- * @returns Focus ring layers (outer and inner props) or null if not supported
- */
-export function createAdaptiveFocusRings(element, focusConfig) {
-    const elementType = element.tagName.toLowerCase();
-    // Validate that we have a valid SVG element
-    if (!SUPPORTED_SVG_TYPES.includes(elementType)) {
-        return undefined;
-    }
-    // Read original stroke width from DOM
-    const strokeWidthAttr = element.getAttribute('stroke-width') || element.getAttribute('strokeWidth');
-    const originalStrokeWidth = parseFloat(strokeWidthAttr || '0');
-    // Read fill attribute to detect open lines
-    const fillAttr = element.getAttribute('fill');
-    const isOpenLine = elementType === 'line' ||
-        elementType === 'polyline' ||
-        (elementType === 'path' && fillAttr === 'none');
-    // Calculate stroke widths for focus rings
-    // IMPORTANT: For ALL shapes, we need to account for the original stroke width
-    // so that focus rings appear OUTSIDE the element's stroke, not covered by it
-    const outerStrokeWidth = originalStrokeWidth + (focusConfig.outlineStrokeWidth + focusConfig.innerStrokeWidth) * 2;
-    const innerStrokeWidth = originalStrokeWidth + focusConfig.innerStrokeWidth * 2;
-    // Read stroke line props for open lines
-    const strokeLinecap = isOpenLine ? element.getAttribute('stroke-linecap') || 'round' : undefined;
-    const strokeLinejoin = isOpenLine ? element.getAttribute('stroke-linejoin') || 'round' : 'miter';
-    const strokeMiterlimit = isOpenLine ? undefined : '10';
-    // Extract relevant attributes from the DOM element
-    // This automatically preserves all geometric attributes (cx, cy, r, x, y, width, height, d, points, etc.)
-    const allAttributes = extractRelevantAttributes(element);
-    // The renderer will create the React elements and add data-testid
-    return {
-        innerRing: {
-            props: {
-                ...allAttributes,
-                className: 'focus-ring-inner',
-                fill: 'none',
-                stroke: focusConfig.innerColor,
-                strokeLinecap,
-                strokeLinejoin,
-                strokeMiterlimit,
-                strokeWidth: innerStrokeWidth,
-            },
-            type: elementType,
-        },
-        outerRing: {
-            props: {
-                ...allAttributes,
-                className: 'focus-ring-outer',
-                fill: 'none',
-                stroke: focusConfig.outlineColor,
-                strokeLinecap,
-                strokeLinejoin,
-                strokeMiterlimit,
-                strokeWidth: outerStrokeWidth,
-            },
-            type: elementType,
-        },
-    };
+function createAdaptiveFocusRings(e, t) {
+	let r = e.tagName.toLowerCase();
+	if (!SUPPORTED_SVG_TYPES.includes(r)) return;
+	let a = e.getAttribute("stroke-width") || e.getAttribute("strokeWidth"), o = parseFloat(a || "0"), s = e.getAttribute("fill"), c = r === "line" || r === "polyline" || r === "path" && s === "none", l = o + (t.outlineStrokeWidth + t.innerStrokeWidth) * 2, u = o + t.innerStrokeWidth * 2, d = c ? e.getAttribute("stroke-linecap") || "round" : void 0, f = c ? e.getAttribute("stroke-linejoin") || "round" : "miter", p = c ? void 0 : "10", m = extractRelevantAttributes(e);
+	return {
+		innerRing: {
+			props: {
+				...m,
+				className: "focus-ring-inner",
+				fill: "none",
+				stroke: t.innerColor,
+				strokeLinecap: d,
+				strokeLinejoin: f,
+				strokeMiterlimit: p,
+				strokeWidth: u
+			},
+			type: r
+		},
+		outerRing: {
+			props: {
+				...m,
+				className: "focus-ring-outer",
+				fill: "none",
+				stroke: t.outlineColor,
+				strokeLinecap: d,
+				strokeLinejoin: f,
+				strokeMiterlimit: p,
+				strokeWidth: l
+			},
+			type: r
+		}
+	};
 }
-/**
- * Extracts relevant SVG attributes from a DOM SVGElement for focus ring creation.
- * Uses an allowlist approach: only geometric and stroke attributes are included.
- * This ensures focus rings inherit the correct shape and appearance while avoiding
- * React-incompatible attributes or those that would cause DOM conflicts.
- *
- * @param element - The SVG element to extract attributes from
- * @returns Object containing only the allowed attributes
- */
-function extractRelevantAttributes(element) {
-    const attrs = {};
-    // Create a Set of allowed attributes for fast lookup
-    const allowedAttributes = new Set([
-        ...SVG_GEOMETRIC_ATTRIBUTES,
-        ...SVG_STROKE_ATTRIBUTES,
-    ]);
-    // Iterate through all attributes of the element
-    for (let i = 0; i < element.attributes.length; i++) {
-        const attr = element.attributes[i];
-        // Only include attributes that are in the allowlist
-        if (allowedAttributes.has(attr.name)) {
-            attrs[attr.name] = attr.value;
-        }
-    }
-    return attrs;
+function extractRelevantAttributes(n) {
+	let r = {}, i = new Set([...SVG_GEOMETRIC_ATTRIBUTES, ...SVG_STROKE_ATTRIBUTES]);
+	for (let e = 0; e < n.attributes.length; e++) {
+		let t = n.attributes[e];
+		i.has(t.name) && (r[t.name] = t.value);
+	}
+	return r;
 }
+export { SVG_GEOMETRIC_ATTRIBUTES, createAdaptiveFocusRings };

package/dist/esm/components/focusRing/utils/createBoundingBoxFocusRings.js

@@ -1,126 +1,73 @@
-/**
- * Calculates the dimensions of the focus outlines (outer and inner) for a bounding-box.
- * This function is used internally by createBoundingBoxFocusRings and always produces
- * rectangular focus rings.
- *
- * @param bounds - Element bounds information from DOM detection
- * @param config - Focus stroke configuration (widths and gap)
- * @returns Rectangle dimensions for outer and inner focus rings
- */
-export const calculateBoundingBoxFocusRings = (bounds, config) => {
-    const { elementHeight, elementPosition, elementStrokeWidth, elementWidth } = bounds;
-    const { gap, innerStrokeWidth, outlineStrokeWidth } = config;
-    // Calculate inner rectangle dimensions
-    // Height and width must grow on both sides to ensure the inner rectangle
-    // is positioned correctly without gaps
-    const innerWidth = elementWidth + elementStrokeWidth + innerStrokeWidth + gap * 2;
-    const innerHeight = elementHeight + elementStrokeWidth + innerStrokeWidth + gap * 2;
-    const innerX = elementPosition.x - innerWidth / 2;
-    const innerY = elementPosition.y - innerHeight / 2;
-    // Calculate outer rectangle dimensions
-    // Must account for the fact that both inner and outer strokes extend outward from their borders
-    // Inner stroke extends innerStrokeWidth/2 on each side, outer stroke extends outlineStrokeWidth/2 on each side
-    const outerWidth = innerWidth + innerStrokeWidth + outlineStrokeWidth;
-    const outerHeight = innerHeight + innerStrokeWidth + outlineStrokeWidth;
-    const outerX = elementPosition.x - outerWidth / 2;
-    const outerY = elementPosition.y - outerHeight / 2;
-    return {
-        inner: {
-            height: innerHeight,
-            width: innerWidth,
-            x: innerX,
-            y: innerY,
-        },
-        outer: {
-            height: outerHeight,
-            width: outerWidth,
-            x: outerX,
-            y: outerY,
-        },
-    };
+const calculateBoundingBoxFocusRings = (e, t) => {
+	let { elementHeight: n, elementPosition: r, elementStrokeWidth: i, elementWidth: a } = e, { gap: o, innerStrokeWidth: s, outlineStrokeWidth: c } = t, l = a + i + s + o * 2, u = n + i + s + o * 2, d = r.x - l / 2, f = r.y - u / 2, p = l + s + c, m = u + s + c, h = r.x - p / 2, g = r.y - m / 2;
+	return {
+		inner: {
+			height: u,
+			width: l,
+			x: d,
+			y: f
+		},
+		outer: {
+			height: m,
+			width: p,
+			x: h,
+			y: g
+		}
+	};
 };
-/**
- * Helper function to detect element bounds from the DOM.
- * Uses getBBox() for accurate measurements including transforms.
- *
- * @param element - SVG element to detect
- * @returns Element bounds information or null if detection fails
- */
-function detectElementBoundsFromDOM(element) {
-    try {
-        const bbox = element.getBBox();
-        if (bbox.width <= 0 || bbox.height <= 0) {
-            return null;
-        }
-        const computedStyle = window.getComputedStyle(element);
-        const strokeWidth = parseFloat(computedStyle.strokeWidth || '0');
-        return {
-            elementHeight: bbox.height,
-            elementPosition: {
-                x: bbox.x + bbox.width / 2,
-                y: bbox.y + bbox.height / 2,
-            },
-            elementStrokeWidth: strokeWidth,
-            elementWidth: bbox.width,
-        };
-    }
-    catch {
-        return null;
-    }
+function detectElementBoundsFromDOM(e) {
+	try {
+		let t = e.getBBox();
+		if (t.width <= 0 || t.height <= 0) return null;
+		let n = window.getComputedStyle(e), r = parseFloat(n.strokeWidth || "0");
+		return {
+			elementHeight: t.height,
+			elementPosition: {
+				x: t.x + t.width / 2,
+				y: t.y + t.height / 2
+			},
+			elementStrokeWidth: r,
+			elementWidth: t.width
+		};
+	} catch {
+		return null;
+	}
 }
-/**
- * Creates bounding-box focus ring layers with calculated dimensions.
- *
- * This function:
- * 1. Detects element bounds from DOM using getBBox()
- * 2. Calculates geometric dimensions using calculateBoundingBoxFocusRings
- * 3. Wraps the result in the same FocusRingLayers structure as createAdaptiveFocusRings
- * 4. Includes all rendering props (colors, strokes, etc.)
- *
- * This provides a unified API for both adaptive and bounding-box strategies.
- *
- * @param element - The SVG graphics element to create focus rings for
- * @param focusConfig - Focus ring configuration (colors, widths, gap)
- * @returns Focus ring layers in the same format as createAdaptiveFocusRings, or null if detection fails
- */
-export function createBoundingBoxFocusRings(element, focusConfig) {
-    // Detect element bounds from DOM
-    const bounds = detectElementBoundsFromDOM(element);
-    if (!bounds) {
-        return undefined;
-    }
-    const dimensions = calculateBoundingBoxFocusRings(bounds, {
-        gap: focusConfig.gap,
-        innerStrokeWidth: focusConfig.innerStrokeWidth,
-        outlineStrokeWidth: focusConfig.outlineStrokeWidth,
-    });
-    // The renderer will create the React elements and add data-testid
-    return {
-        innerRing: {
-            props: {
-                className: 'focus-ring-inner',
-                fill: 'none',
-                height: dimensions.inner.height,
-                stroke: focusConfig.innerColor,
-                strokeWidth: focusConfig.innerStrokeWidth,
-                width: dimensions.inner.width,
-                x: dimensions.inner.x,
-                y: dimensions.inner.y,
-            },
-            type: 'rect',
-        },
-        outerRing: {
-            props: {
-                className: 'focus-ring-outer',
-                fill: 'none',
-                height: dimensions.outer.height,
-                stroke: focusConfig.outlineColor,
-                strokeWidth: focusConfig.outlineStrokeWidth,
-                width: dimensions.outer.width,
-                x: dimensions.outer.x,
-                y: dimensions.outer.y,
-            },
-            type: 'rect',
-        },
-    };
+function createBoundingBoxFocusRings(n, r) {
+	let i = detectElementBoundsFromDOM(n);
+	if (!i) return;
+	let a = calculateBoundingBoxFocusRings(i, {
+		gap: r.gap,
+		innerStrokeWidth: r.innerStrokeWidth,
+		outlineStrokeWidth: r.outlineStrokeWidth
+	});
+	return {
+		innerRing: {
+			props: {
+				className: "focus-ring-inner",
+				fill: "none",
+				height: a.inner.height,
+				stroke: r.innerColor,
+				strokeWidth: r.innerStrokeWidth,
+				width: a.inner.width,
+				x: a.inner.x,
+				y: a.inner.y
+			},
+			type: "rect"
+		},
+		outerRing: {
+			props: {
+				className: "focus-ring-outer",
+				fill: "none",
+				height: a.outer.height,
+				stroke: r.outlineColor,
+				strokeWidth: r.outlineStrokeWidth,
+				width: a.outer.width,
+				x: a.outer.x,
+				y: a.outer.y
+			},
+			type: "rect"
+		}
+	};
 }
+export { createBoundingBoxFocusRings };

package/dist/esm/components/foreignObject/foreignObject.js

@@ -1,4 +1,10 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-export const ForeignObject = ({ children, dataTestId, height, width, x, y, }) => {
-    return (_jsx("foreignObject", { "data-testid": dataTestId, height: height, width: width, x: x, y: y, children: children }));
-};
+import { jsx } from "react/jsx-runtime";
+const ForeignObject = ({ children: e, dataTestId: t, height: n, width: r, x: i, y: a }) => /* @__PURE__ */ jsx("foreignObject", {
+	"data-testid": t,
+	height: n,
+	width: r,
+	x: i,
+	y: a,
+	children: e
+});
+export { ForeignObject };

package/dist/esm/components/line/line.js

@@ -1,9 +1,8 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * `Line` component that renders an SVG line element with customizable properties.
- *
- * @returns A `line` SVG element with the specified properties and attributes.
- */
-export const Line = ({ ariaLabel, className = 'line', dataTestId, ...props }) => {
-    return _jsx("line", { ...props, "aria-label": ariaLabel, className: className, "data-testid": dataTestId });
-};
+import { jsx } from "react/jsx-runtime";
+const Line = ({ ariaLabel: e, className: t = "line", dataTestId: n, ...r }) => /* @__PURE__ */ jsx("line", {
+	...r,
+	"aria-label": e,
+	className: t,
+	"data-testid": n
+});
+export { Line };