@bricks-toolkit/toolkit 0.1.1 → 0.1.2

package/dist/chunk-65UZC3FK.mjs

@@ -0,0 +1,312 @@
+import { cn } from './chunk-OCPFOFJ4.mjs';
+import { useState, useRef, useId, useCallback, useEffect, useLayoutEffect } from 'react';
+import { createPortal } from 'react-dom';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var EXIT_DURATION_MS = 150;
+var placementClasses = {
+  top: "-translate-x-1/2 -translate-y-full",
+  bottom: "-translate-x-1/2",
+  left: "-translate-x-full -translate-y-1/2",
+  right: "-translate-y-1/2"
+};
+var arrowPositionClasses = {
+  top: "top-full left-1/2 -translate-x-1/2",
+  bottom: "bottom-full left-1/2 -translate-x-1/2",
+  left: "left-full top-1/2 -translate-y-1/2",
+  right: "right-full top-1/2 -translate-y-1/2"
+};
+var arrowBorderClasses = {
+  top: "border-l-transparent border-r-transparent border-b-transparent",
+  bottom: "border-l-transparent border-r-transparent border-t-transparent",
+  left: "border-t-transparent border-b-transparent border-r-transparent",
+  right: "border-t-transparent border-b-transparent border-l-transparent"
+};
+var entryTranslateClass = {
+  top: "translate-y-1",
+  bottom: "-translate-y-1",
+  left: "translate-x-1",
+  right: "-translate-x-1"
+};
+var sizeClasses = {
+  sm: "px-2 py-1 text-xs rounded-md",
+  md: "px-3 py-1.5 text-sm rounded-lg",
+  lg: "px-4 py-2 text-sm rounded-xl"
+};
+var variantBubbleClasses = {
+  dark: [
+    "bg-gray-900 text-gray-50",
+    "shadow-[0_4px_16px_rgba(0,0,0,0.35)]",
+    "ring-1 ring-white/10"
+  ].join(" "),
+  primary: [
+    "bg-gradient-to-b from-blue-500 to-blue-600 text-white",
+    "shadow-[0_4px_16px_rgba(59,130,246,0.45)]",
+    "ring-1 ring-blue-400/30"
+  ].join(" "),
+  light: [
+    "bg-white text-gray-800",
+    "border border-gray-200/80",
+    "shadow-[0_4px_16px_rgba(0,0,0,0.10)]"
+  ].join(" ")
+};
+var arrowVariantColor = {
+  dark: {
+    top: "border-t-gray-900",
+    bottom: "border-b-gray-900",
+    left: "border-l-gray-900",
+    right: "border-r-gray-900"
+  },
+  primary: {
+    top: "border-t-blue-600",
+    bottom: "border-b-blue-500",
+    left: "border-l-blue-600",
+    right: "border-r-blue-500"
+  },
+  light: {
+    top: "border-t-gray-200",
+    bottom: "border-b-gray-200",
+    left: "border-l-gray-200",
+    right: "border-r-gray-200"
+  }
+};
+function Tooltip({
+  content,
+  children,
+  placement = "top",
+  trigger = "hover",
+  showDelay = 0,
+  hideDelay = 100,
+  size = "md",
+  variant = "dark",
+  open: controlledOpen,
+  disabled = false,
+  maxWidth = 240,
+  className,
+  wrapperClassName
+}) {
+  const [internalOpen, setInternalOpen] = useState(false);
+  const [mounted, setMounted] = useState(false);
+  const [visible, setVisible] = useState(false);
+  const [coords, setCoords] = useState({ top: 0, left: 0 });
+  const [actualPlacement, setActualPlacement] = useState(placement);
+  const isControlled = controlledOpen !== void 0;
+  const isOpen = isControlled ? controlledOpen : internalOpen;
+  const triggerRef = useRef(null);
+  const tooltipRef = useRef(null);
+  const showTimer = useRef(null);
+  const hideTimer = useRef(null);
+  const exitTimer = useRef(null);
+  const tooltipId = useId();
+  const clearTimers = useCallback(() => {
+    if (showTimer.current) clearTimeout(showTimer.current);
+    if (hideTimer.current) clearTimeout(hideTimer.current);
+    if (exitTimer.current) clearTimeout(exitTimer.current);
+  }, []);
+  const show = useCallback(() => {
+    if (disabled || isControlled) return;
+    clearTimers();
+    const open = () => {
+      setInternalOpen(true);
+    };
+    if (showDelay > 0) {
+      showTimer.current = setTimeout(open, showDelay);
+    } else {
+      open();
+    }
+  }, [disabled, isControlled, clearTimers, showDelay]);
+  const hide = useCallback(() => {
+    if (isControlled) return;
+    clearTimers();
+    hideTimer.current = setTimeout(() => {
+      setInternalOpen(false);
+    }, hideDelay);
+  }, [isControlled, clearTimers, hideDelay]);
+  const toggle = useCallback(() => {
+    if (disabled || isControlled) return;
+    setInternalOpen((prev) => !prev);
+  }, [disabled, isControlled]);
+  useEffect(() => {
+    let rafId = null;
+    if (isOpen && !disabled) {
+      clearTimers();
+      rafId = requestAnimationFrame(() => {
+        setMounted(true);
+        rafId = requestAnimationFrame(() => {
+          setVisible(true);
+        });
+      });
+    } else {
+      rafId = requestAnimationFrame(() => {
+        setVisible(false);
+      });
+      exitTimer.current = setTimeout(() => {
+        setMounted(false);
+      }, EXIT_DURATION_MS);
+    }
+    return () => {
+      if (rafId) cancelAnimationFrame(rafId);
+      if (exitTimer.current) clearTimeout(exitTimer.current);
+    };
+  }, [isOpen, disabled, clearTimers]);
+  const updatePosition = useCallback(() => {
+    if (!triggerRef.current || !isOpen) return;
+    const triggerRect = triggerRef.current.getBoundingClientRect();
+    const tooltipElement = tooltipRef.current;
+    const gap = 8;
+    let nextPlacement = placement;
+    const calculateBaseCoords = (p) => {
+      switch (p) {
+        case "top":
+          return { t: triggerRect.top - gap, l: triggerRect.left + triggerRect.width / 2 };
+        case "bottom":
+          return { t: triggerRect.bottom + gap, l: triggerRect.left + triggerRect.width / 2 };
+        case "left":
+          return { t: triggerRect.top + triggerRect.height / 2, l: triggerRect.left - gap };
+        case "right":
+          return { t: triggerRect.top + triggerRect.height / 2, l: triggerRect.right + gap };
+      }
+    };
+    const base = calculateBaseCoords(placement);
+    let top = base.t;
+    let left = base.l;
+    if (tooltipElement) {
+      const tooltipRect = tooltipElement.getBoundingClientRect();
+      const padding = 12;
+      if (placement === "top" && triggerRect.top - tooltipRect.height - gap < padding) {
+        nextPlacement = "bottom";
+      } else if (placement === "bottom" && triggerRect.bottom + tooltipRect.height + gap > window.innerHeight - padding) {
+        nextPlacement = "top";
+      } else if (placement === "left" && triggerRect.left - tooltipRect.width - gap < padding) {
+        nextPlacement = "right";
+      } else if (placement === "right" && triggerRect.right + tooltipRect.width + gap > window.innerWidth - padding) {
+        nextPlacement = "left";
+      }
+      if (nextPlacement !== placement) {
+        const flippedBase = calculateBaseCoords(nextPlacement);
+        top = flippedBase.t;
+        left = flippedBase.l;
+      }
+      const halfWidth = tooltipRect.width / 2;
+      const halfHeight = tooltipRect.height / 2;
+      if (nextPlacement === "top" || nextPlacement === "bottom") {
+        left = Math.max(
+          padding + halfWidth,
+          Math.min(window.innerWidth - padding - halfWidth, left)
+        );
+      } else {
+        top = Math.max(
+          padding + halfHeight,
+          Math.min(window.innerHeight - padding - halfHeight, top)
+        );
+      }
+    }
+    setActualPlacement(nextPlacement);
+    setCoords({ top, left });
+  }, [isOpen, placement]);
+  useLayoutEffect(() => {
+    if (!isOpen) return;
+    let rafId = null;
+    const handleUpdate = () => {
+      rafId = requestAnimationFrame(updatePosition);
+    };
+    handleUpdate();
+    window.addEventListener("resize", handleUpdate);
+    window.addEventListener("scroll", handleUpdate, true);
+    return () => {
+      if (rafId !== null) cancelAnimationFrame(rafId);
+      window.removeEventListener("resize", handleUpdate);
+      window.removeEventListener("scroll", handleUpdate, true);
+    };
+  }, [isOpen, updatePosition]);
+  useEffect(() => {
+    if (!isOpen) return;
+    const handleKey = (e) => {
+      if (e.key === "Escape") {
+        clearTimers();
+        setInternalOpen(false);
+      }
+    };
+    document.addEventListener("keydown", handleKey);
+    return () => {
+      document.removeEventListener("keydown", handleKey);
+    };
+  }, [isOpen, clearTimers]);
+  useEffect(() => clearTimers, [clearTimers]);
+  const triggerProps = {};
+  if (trigger === "hover" || trigger === "focus") {
+    triggerProps.onFocus = show;
+    triggerProps.onBlur = hide;
+  }
+  if (trigger === "hover") {
+    triggerProps.onMouseEnter = show;
+    triggerProps.onMouseLeave = hide;
+  } else if (trigger === "click") {
+    triggerProps.onClick = toggle;
+  }
+  triggerProps.onKeyDown = (e) => {
+    if (e.key === "Enter" || e.key === " ") toggle();
+  };
+  const child = children;
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      ref: triggerRef,
+      className: cn("relative inline-flex isolate z-0", wrapperClassName),
+      "aria-describedby": isOpen && !disabled ? tooltipId : void 0,
+      ...triggerProps,
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "relative z-0", children: child }),
+        mounted && !disabled && createPortal(
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              ref: tooltipRef,
+              className: cn("pointer-events-none fixed z-[9999]", placementClasses[actualPlacement]),
+              style: { top: coords.top, left: coords.left },
+              children: /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  id: tooltipId,
+                  role: "tooltip",
+                  style: { maxWidth, transitionDuration: `${EXIT_DURATION_MS.toString()}ms` },
+                  className: cn(
+                    // Layout & typography
+                    "relative min-w-max whitespace-normal break-words",
+                    "font-sans font-medium tracking-tight text-center leading-snug",
+                    // Smooth enter/exit transition
+                    "transition-[opacity,transform] ease-out",
+                    visible ? "opacity-100 translate-x-0 translate-y-0" : ["opacity-0", entryTranslateClass[actualPlacement]].join(" "),
+                    // Visual styles
+                    variantBubbleClasses[variant],
+                    sizeClasses[size],
+                    className
+                  ),
+                  children: [
+                    /* @__PURE__ */ jsx(
+                      "div",
+                      {
+                        "aria-hidden": "true",
+                        className: cn(
+                          "absolute border-[6px]",
+                          "drop-shadow-sm",
+                          arrowPositionClasses[actualPlacement],
+                          arrowBorderClasses[actualPlacement],
+                          arrowVariantColor[variant][actualPlacement]
+                        )
+                      }
+                    ),
+                    content
+                  ]
+                }
+              )
+            }
+          ),
+          document.body
+        )
+      ]
+    }
+  );
+}
+
+export { Tooltip };

package/dist/chunk-6CC5KIA5.cjs

@@ -0,0 +1,148 @@
+'use strict';
+
+var chunkR72GDCWE_cjs = require('./chunk-R72GDCWE.cjs');
+var chunkL5VQZZVR_cjs = require('./chunk-L5VQZZVR.cjs');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+var sizeClasses = {
+  xs: "h-6 px-2.5 text-xs",
+  sm: "h-8 px-3 text-sm",
+  md: "h-10 px-4 text-sm",
+  lg: "h-11 px-6 text-base",
+  xl: "h-12 px-8 text-lg"
+};
+var iconSizeClasses = {
+  xs: "w-3 h-3",
+  sm: "w-3.5 h-3.5",
+  md: "w-4 h-4",
+  lg: "w-5 h-5",
+  xl: "w-5 h-5"
+};
+var variantClasses = {
+  primary: "bg-primary text-text-inverse hover:bg-primary-hover hover:shadow-xl hover:shadow-primary/20 active:scale-95 border border-transparent shadow-md focus-visible:ring-primary/40 transition-all duration-normal",
+  secondary: "bg-secondary text-text hover:bg-secondary-hover border border-transparent focus-visible:ring-primary/40",
+  outline: "bg-transparent text-text border border-border hover:bg-hover hover:text-text focus-visible:ring-primary/40",
+  ghost: "bg-transparent text-text border border-transparent hover:bg-hover hover:text-text focus-visible:ring-primary/40",
+  danger: "bg-error text-text-inverse hover:bg-error/90 border border-transparent shadow-sm focus-visible:ring-error/40",
+  success: "bg-success text-text-inverse hover:bg-success/90 border border-transparent shadow-sm focus-visible:ring-success/40",
+  warning: "bg-warning text-text-inverse hover:bg-warning/90 border border-transparent shadow-sm focus-visible:ring-warning/40",
+  info: "bg-info text-text-inverse hover:bg-info/90 border border-transparent shadow-sm focus-visible:ring-info/40"
+};
+var disabledClasses = "opacity-50 cursor-not-allowed shadow-none";
+var Button = react.forwardRef(function Button2({
+  children,
+  className,
+  variant = "primary",
+  size = "md",
+  fullWidth = false,
+  isLoading = false,
+  loadingText,
+  disabled = false,
+  leftIcon,
+  rightIcon,
+  tooltip,
+  tooltipPlacement = "top",
+  type = "button",
+  ...rest
+}, ref) {
+  const isDisabled = disabled || isLoading;
+  const spinnerElement = /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chunkL5VQZZVR_cjs.cn("relative flex items-center justify-center", iconSizeClasses[size]), children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute inset-0 rounded-full border-1 border-current opacity-20 animate-ping" }),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "svg",
+      {
+        className: "animate-spin relative z-10 w-full h-full",
+        xmlns: "http://www.w3.org/2000/svg",
+        fill: "none",
+        viewBox: "0 0 24 24",
+        role: "status",
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "circle",
+            {
+              className: "opacity-25",
+              cx: "12",
+              cy: "12",
+              r: "10",
+              stroke: "currentColor",
+              strokeWidth: "4"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "path",
+            {
+              className: "opacity-90",
+              fill: "currentColor",
+              d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+            }
+          )
+        ]
+      }
+    )
+  ] });
+  const buttonElement = /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      ref,
+      type,
+      disabled: isDisabled,
+      "aria-disabled": isDisabled,
+      "aria-busy": isLoading,
+      className: chunkL5VQZZVR_cjs.cn(
+        "relative inline-flex items-center justify-center gap-2 font-bold rounded-md transition-[background-color,border-color,color,box-shadow,transform,opacity] duration-normal focus:outline-none focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:ring-offset-surface",
+        sizeClasses[size],
+        variantClasses[variant],
+        fullWidth ? "w-full" : "",
+        isDisabled ? disabledClasses : "",
+        className
+      ),
+      ...rest,
+      children: isLoading && loadingText ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        spinnerElement,
+        /* @__PURE__ */ jsxRuntime.jsx("span", { children: loadingText })
+      ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        leftIcon && /* @__PURE__ */ jsxRuntime.jsx(
+          "span",
+          {
+            className: chunkL5VQZZVR_cjs.cn(
+              "inline-flex shrink-0",
+              isLoading && "invisible opacity-0"
+              // Hide icons but keep layout width when loading without text
+            ),
+            children: leftIcon
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "span",
+          {
+            className: chunkL5VQZZVR_cjs.cn(
+              "truncate flex items-center justify-center",
+              // Added flex centering for icons
+              isLoading && "invisible opacity-0"
+              // Hide content but keep layout width
+            ),
+            children
+          }
+        ),
+        rightIcon && /* @__PURE__ */ jsxRuntime.jsx("span", { className: chunkL5VQZZVR_cjs.cn("inline-flex shrink-0", isLoading && "invisible opacity-0"), children: rightIcon }),
+        isLoading && !loadingText && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "absolute inset-0 flex items-center justify-center", children: spinnerElement })
+      ] })
+    }
+  );
+  if (tooltip) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      chunkR72GDCWE_cjs.Tooltip,
+      {
+        content: tooltip,
+        placement: tooltipPlacement,
+        wrapperClassName: fullWidth ? "w-full" : "",
+        children: buttonElement
+      }
+    );
+  }
+  return buttonElement;
+});
+Button.displayName = "Button";
+
+exports.Button = Button;

package/dist/chunk-6R3OYBQ6.cjs

@@ -0,0 +1,209 @@
+'use strict';
+
+var chunkL5VQZZVR_cjs = require('./chunk-L5VQZZVR.cjs');
+var react = require('react');
+var outline = require('@heroicons/react/24/outline');
+var jsxRuntime = require('react/jsx-runtime');
+
+var sizeClasses = {
+  sm: "p-4 text-sm",
+  md: "p-8 text-sm",
+  lg: "p-12 text-base"
+};
+var labelSizeClasses = {
+  sm: "text-xs",
+  md: "text-sm",
+  lg: "text-sm"
+};
+var stateClasses = {
+  default: "border-border hover:border-primary-hover bg-surface focus-within:ring-2 focus-within:ring-primary/20 focus-within:border-primary",
+  error: "border-error bg-error/5 focus-within:ring-2 focus-within:ring-error/20",
+  success: "border-success bg-success/5 focus-within:ring-2 focus-within:ring-success/20",
+  warning: "border-warning bg-warning/5 focus-within:ring-2 focus-within:ring-warning/20"
+};
+var stateMessageClasses = {
+  default: "text-text-muted",
+  error: "text-error font-medium",
+  success: "text-success font-medium",
+  warning: "text-warning font-medium"
+};
+var FileUpload = react.forwardRef(function FileUpload2({
+  label,
+  required = false,
+  helperText,
+  errorMessage,
+  successMessage,
+  warningMessage,
+  size = "md",
+  state = "default",
+  fullWidth = true,
+  wrapperClassName,
+  labelClassName,
+  helperClassName,
+  dropzoneClassName,
+  icon,
+  maxSize,
+  maxFiles,
+  onFilesSelected,
+  accept,
+  multiple,
+  disabled,
+  id: idProp,
+  className,
+  ...rest
+}, ref) {
+  const generatedId = react.useId();
+  const inputId = idProp ?? generatedId;
+  const internalRef = react.useRef(null);
+  const [isDragging, setIsDragging] = react.useState(false);
+  const handleDragOver = (e) => {
+    e.preventDefault();
+    if (!disabled) setIsDragging(true);
+  };
+  const handleDragLeave = () => {
+    setIsDragging(false);
+  };
+  const handleDrop = (e) => {
+    e.preventDefault();
+    setIsDragging(false);
+    if (disabled) return;
+    const droppedFiles = Array.from(e.dataTransfer.files);
+    handleFiles(droppedFiles);
+  };
+  const handleChange = (e) => {
+    if (e.target.files) {
+      handleFiles(Array.from(e.target.files));
+    }
+  };
+  const handleFiles = (files) => {
+    let filteredFiles = files;
+    if (maxFiles && files.length > maxFiles) {
+      filteredFiles = files.slice(0, maxFiles);
+    }
+    if (maxSize) {
+      filteredFiles = filteredFiles.filter((file) => file.size <= maxSize);
+    }
+    if (onFilesSelected) {
+      onFilesSelected(filteredFiles);
+    }
+  };
+  const handleClick = () => {
+    if (internalRef.current) {
+      internalRef.current.click();
+    }
+  };
+  const helperId = `${inputId}-helper`;
+  const stateMessageId = `${inputId}-state`;
+  const stateMsg = state === "error" ? errorMessage : state === "success" ? successMessage : state === "warning" ? warningMessage : void 0;
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" || e.key === " ") {
+      e.preventDefault();
+      handleClick();
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: chunkL5VQZZVR_cjs.cn(
+        "flex flex-col gap-1.5",
+        fullWidth ? "w-full" : "w-fit",
+        wrapperClassName,
+        className
+      ),
+      children: [
+        label && /* @__PURE__ */ jsxRuntime.jsxs(
+          "label",
+          {
+            htmlFor: inputId,
+            className: chunkL5VQZZVR_cjs.cn(
+              "font-black leading-none text-text uppercase tracking-widest",
+              labelSizeClasses[size],
+              labelClassName
+            ),
+            children: [
+              label,
+              required && /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", className: "ml-1 text-error", children: "*" })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            onDragOver: handleDragOver,
+            onDragLeave: handleDragLeave,
+            onDrop: handleDrop,
+            onClick: handleClick,
+            onKeyDown: handleKeyDown,
+            role: "button",
+            tabIndex: disabled ? -1 : 0,
+            "aria-disabled": disabled,
+            className: chunkL5VQZZVR_cjs.cn(
+              "relative flex flex-col items-center justify-center border-2 border-dashed rounded-lg transition-all cursor-pointer group",
+              sizeClasses[size],
+              stateClasses[state],
+              isDragging && "border-primary bg-primary/5 scale-[1.01] shadow-md",
+              disabled && "opacity-50 cursor-not-allowed bg-surface-secondary border-border",
+              dropzoneClassName
+            ),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "input",
+                {
+                  ...rest,
+                  ref: (node) => {
+                    internalRef.current = node;
+                    if (typeof ref === "function") ref(node);
+                    else if (ref) ref.current = node;
+                  },
+                  id: inputId,
+                  type: "file",
+                  accept,
+                  multiple,
+                  disabled,
+                  onChange: handleChange,
+                  className: "sr-only"
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col items-center gap-2 text-center pointer-events-none", children: [
+                icon ?? /* @__PURE__ */ jsxRuntime.jsx(
+                  outline.CloudArrowUpIcon,
+                  {
+                    className: chunkL5VQZZVR_cjs.cn(
+                      "w-10 h-10 mb-2 transition-all duration-normal group-hover:scale-110",
+                      state === "default" ? "text-text-muted" : stateMessageClasses[state]
+                    )
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-bold text-text transition-colors group-hover:text-primary", children: "Click to upload or drag and drop" }),
+                /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-xs text-text-muted font-medium", children: [
+                  accept ? `Available formats: ${accept}` : "Any file type",
+                  maxSize && ` (Max ${String(Math.round(maxSize / 1024 / 1024))}MB)`
+                ] })
+              ] })
+            ]
+          }
+        ),
+        helperText && /* @__PURE__ */ jsxRuntime.jsx(
+          "p",
+          {
+            id: helperId,
+            className: chunkL5VQZZVR_cjs.cn("text-xs text-text-muted font-medium mt-1", helperClassName),
+            children: helperText
+          }
+        ),
+        stateMsg && /* @__PURE__ */ jsxRuntime.jsx(
+          "p",
+          {
+            id: stateMessageId,
+            role: state === "error" ? "alert" : void 0,
+            className: chunkL5VQZZVR_cjs.cn("text-xs font-bold mt-1", stateMessageClasses[state], helperClassName),
+            children: stateMsg
+          }
+        )
+      ]
+    }
+  );
+});
+FileUpload.displayName = "FileUpload";
+
+exports.FileUpload = FileUpload;

package/dist/chunk-6UO72EJA.cjs

@@ -0,0 +1,2 @@
+'use strict';
+