cuenti-dna 0.1.0-beta.1

package/dist/index.js

@@ -0,0 +1,1295 @@
+// src/components/inputs/button.tsx
+import { cva } from "class-variance-authority";
+
+// src/utils/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/components/inputs/button.tsx
+import { jsx } from "react/jsx-runtime";
+var baseStyles = "inline-flex items-center justify-center gap-2 whitespace-nowrap text-base transition-all duration-300 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] cursor-pointer disabled:bg-neutral-600 disabled:text-neutral-700 font-bold disabled:cursor-not-allowed";
+var variants = {
+  primary: "bg-primary text-primary-foreground hover:bg-primary-600 active:bg-primary-400 aria-pressed:bg-primary-400",
+  alt: "bg-primary-400 text-primary-foreground hover:bg-primary-500 active:bg-primary-300 aria-pressed:bg-primary-300",
+  secondary: "bg-secondary text-secondary-foreground hover:bg-secondary-600 active:bg-secondary-400 aria-pressed:bg-secondary-400",
+  ghost: "bg-transparent hover:bg-neutral-400 active:bg-neutral-500 aria-pressed:bg-neutral-500 text-muted-foreground hover:text-neutral-800",
+  "primary-ghost": "bg-transparent hover:bg-primary-50 active:bg-primary-100 aria-pressed:bg-primary-100 text-primary hover:text-primary-600",
+  link: "bg-transparent underline-offset-4 hover:underline text-neutral-700 hover:text-info active:text-info-400 aria-pressed:text-info-400",
+  destructive: "bg-destructive text-destructive-foreground hover:bg-destructive-600 active:bg-destructive-400 aria-pressed:bg-destructive-400",
+  success: "bg-success text-success-foreground hover:bg-success-600 active:bg-success-400 aria-pressed:bg-success-400",
+  accent: "bg-accent text-accent-foreground hover:bg-accent-600 active:bg-accent-400 aria-pressed:bg-accent-400 font-bold",
+  outline: "border-2 border-neutral-500 bg-transparent text-neutral-700 hover:border-neutral-600 hover:bg-neutral-300 active:bg-neutral-300 active:border-neutral-600 aria-pressed:bg-neutral-300 aria-pressed:border-neutral-600 disabled:bg-transparent disabled:border-neutral-400 disabled:text-neutral-600",
+  "secondary-outline": "border-2 border-neutral-500 bg-transparent text-neutral-700 hover:border-secondary-300 hover:bg-secondary-25 hover:text-secondary-300 active:bg-secondary-50 active:border-secondary-200 active:text-secondary-300 aria-pressed:bg-secondary-50 aria-pressed:border-secondary-200 aria-pressed:text-secondary-300 disabled:bg-transparent disabled:border-neutral-400 disabled:text-neutral-600"
+};
+var sizes = {
+  md: "h-12 px-5 has-[>svg]:px-3 rounded-md",
+  sm: "h-10 gap-1.5 px-5 has-[>svg]:px-3 rounded-sm",
+  lg: "h-13 px-5 has-[>svg]:px-5 rounded-lg",
+  icon: "size-12 aspect-square rounded-md",
+  "icon-sm": "size-10 aspect-square rounded-sm",
+  "icon-lg": "size-13 aspect-square rounded-lg"
+};
+var buttonVariants = cva(baseStyles, {
+  variants: {
+    variant: variants,
+    size: sizes
+  },
+  defaultVariants: {
+    variant: "primary",
+    size: "md"
+  }
+});
+function Button({
+  variant,
+  size,
+  className,
+  children,
+  type = "button",
+  ...props
+}) {
+  const classes = cn(buttonVariants({ variant, size }), className);
+  return /* @__PURE__ */ jsx("button", { className: classes, type, ...props, children });
+}
+
+// src/components/inputs/checkbox.tsx
+import { cva as cva2 } from "class-variance-authority";
+import { useEffect, useId, useRef } from "react";
+
+// src/components/icons/interface/check.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function Check({ className, ...props }) {
+  return /* @__PURE__ */ jsx2(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      fill: "none",
+      viewBox: "0 0 20 20",
+      className,
+      ...props,
+      children: /* @__PURE__ */ jsx2(
+        "path",
+        {
+          stroke: "currentColor",
+          strokeLinecap: "round",
+          strokeLinejoin: "round",
+          strokeWidth: "2",
+          d: "m5 10 3.54 3.54 7.07-7.08"
+        }
+      )
+    }
+  );
+}
+
+// src/components/icons/interface/minus.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function Minus({ ...props }) {
+  return /* @__PURE__ */ jsx3(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      fill: "none",
+      viewBox: "0 0 24 24",
+      ...props,
+      children: /* @__PURE__ */ jsx3(
+        "path",
+        {
+          stroke: "currentColor",
+          strokeLinecap: "round",
+          strokeLinejoin: "round",
+          strokeWidth: "2",
+          d: "M6 12h12"
+        }
+      )
+    }
+  );
+}
+
+// src/components/inputs/checkbox.tsx
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+var baseStyles2 = "size-6 shrink-0 appearance-none border-2 border-neutral-600 bg-transparent transition-all duration-200 outline-none disabled:border-neutral-400 disabled:bg-transparent focus-visible:ring-2 focus-visible:bg-neutral-400 focus-visible:ring-offset-1 cursor-pointer disabled:cursor-not-allowed group-data-[readonly=true]/checkbox:cursor-default";
+var variants2 = {
+  default: "hover:border-info-500 hover:bg-info-50 focus-visible:border-info-500 focus-visible:ring-info-500/20 focus-visible:checked:border-info-500 focus-visible:checked:bg-info-500 checked:border-info-500 checked:bg-info-500 checked:hover:border-info-600 checked:hover:bg-info-600 indeterminate:border-info-500 indeterminate:bg-info-500 indeterminate:hover:border-info-600 indeterminate:hover:bg-info-600 disabled:hover:border-neutral-400 disabled:hover:bg-transparent",
+  success: "hover:border-success-500 hover:bg-success-50 focus-visible:border-success-500 focus-visible:ring-success-500/20 focus-visible:checked:border-success-500 focus-visible:checked:bg-success-500 checked:border-success-500 checked:bg-success-500 checked:hover:border-success-600 checked:hover:bg-success-600 indeterminate:border-success-500 indeterminate:bg-success-500 indeterminate:hover:border-success-600 indeterminate:hover:bg-success-600 disabled:hover:border-neutral-400 disabled:hover:bg-transparent"
+};
+var sizes2 = {
+  square: "rounded-[8px]",
+  rounded: "rounded-full"
+};
+var checkboxVariants = cva2(baseStyles2, {
+  variants: {
+    variant: variants2,
+    size: sizes2
+  },
+  defaultVariants: {
+    variant: "default",
+    size: "square"
+  }
+});
+function Checkbox({
+  variant,
+  size,
+  indeterminate = false,
+  children,
+  className,
+  classNames,
+  readOnly,
+  onClick,
+  onChange,
+  disabled,
+  ...props
+}) {
+  const inputRef = useRef(null);
+  const generatedId = useId();
+  const id = props.id || generatedId;
+  const isReadOnly = Boolean(readOnly);
+  useEffect(() => {
+    if (inputRef.current) {
+      inputRef.current.indeterminate = indeterminate;
+    }
+  }, [indeterminate]);
+  const classes = cn(
+    checkboxVariants({ variant, size }),
+    className,
+    classNames?.input
+  );
+  const handleClick = (event) => {
+    if (isReadOnly || disabled) {
+      event.preventDefault();
+      return;
+    }
+    onClick?.(event);
+  };
+  const handleChange = (event) => {
+    if (isReadOnly || disabled) {
+      event.preventDefault();
+      return;
+    }
+    onChange?.(event);
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-slot": "checkbox",
+      "data-disabled": disabled ? "true" : void 0,
+      "data-readonly": isReadOnly ? "true" : void 0,
+      className: cn(
+        "group/checkbox inline-flex cursor-pointer items-center gap-3 data-[disabled=true]:cursor-not-allowed data-[readonly=true]:cursor-default",
+        classNames?.root
+      ),
+      children: [
+        /* @__PURE__ */ jsxs("span", { className: "group/control relative flex size-6 shrink-0 items-center justify-center text-white", children: [
+          /* @__PURE__ */ jsx4(
+            "input",
+            {
+              ref: inputRef,
+              id,
+              type: "checkbox",
+              "aria-checked": indeterminate ? "mixed" : void 0,
+              "aria-readonly": isReadOnly || void 0,
+              className: classes,
+              readOnly: isReadOnly,
+              disabled,
+              onClick: handleClick,
+              onChange: handleChange,
+              ...props
+            }
+          ),
+          /* @__PURE__ */ jsx4(
+            Check,
+            {
+              "aria-hidden": "true",
+              className: "pointer-events-none absolute z-10 size-5 opacity-0 transition-opacity group-has-checked/control:opacity-100 group-has-indeterminate/control:opacity-0"
+            }
+          ),
+          /* @__PURE__ */ jsx4(
+            Minus,
+            {
+              "aria-hidden": "true",
+              className: "pointer-events-none absolute z-10 size-5 opacity-0 transition-opacity group-has-indeterminate/control:opacity-100"
+            }
+          )
+        ] }),
+        children ? /* @__PURE__ */ jsx4(
+          "label",
+          {
+            "data-slot": "checkbox-label",
+            htmlFor: id,
+            className: cn(
+              "cursor-pointer transition-colors group-data-[disabled=true]/checkbox:cursor-not-allowed group-data-[readonly=true]/checkbox:cursor-default group-data-[disabled=true]/checkbox:text-neutral-600",
+              classNames?.label
+            ),
+            children
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/components/inputs/input/input.tsx
+import { cva as cva3 } from "class-variance-authority";
+
+// src/components/inputs/input/money-input.tsx
+import { useCallback } from "react";
+
+// src/hooks/use-formatted-numeric-input.ts
+import { useEffect as useEffect2, useState } from "react";
+function useFormattedNumericInput({
+  value,
+  defaultValue,
+  onChange,
+  onBlur,
+  onFocus,
+  normalizeRawValue,
+  rawToEditableValue,
+  rawToDisplayValue,
+  editableToRawValue,
+  sanitizeEditableValue
+}) {
+  const initialRawValue = normalizeRawValue(value ?? defaultValue);
+  const [isFocused, setIsFocused] = useState(false);
+  const [rawValue, setRawValue] = useState(initialRawValue);
+  const [displayValue, setDisplayValue] = useState(
+    () => rawToDisplayValue(initialRawValue)
+  );
+  useEffect2(() => {
+    if (value === void 0) {
+      return;
+    }
+    const nextRawValue = normalizeRawValue(value);
+    setRawValue(nextRawValue);
+    setDisplayValue(
+      isFocused ? rawToEditableValue(nextRawValue) : rawToDisplayValue(nextRawValue)
+    );
+  }, [
+    value,
+    isFocused,
+    normalizeRawValue,
+    rawToEditableValue,
+    rawToDisplayValue
+  ]);
+  useEffect2(() => {
+    if (value !== void 0) {
+      return;
+    }
+    setDisplayValue(
+      isFocused ? rawToEditableValue(rawValue) : rawToDisplayValue(rawValue)
+    );
+  }, [value, isFocused, rawValue, rawToEditableValue, rawToDisplayValue]);
+  const normalizeEditableValue = (editableValue) => sanitizeEditableValue ? sanitizeEditableValue(editableValue) : editableValue;
+  const emitRawValue = (event, nextRawValue) => {
+    event.currentTarget.value = nextRawValue;
+  };
+  const handleFocus = (event) => {
+    setIsFocused(true);
+    setDisplayValue(rawToEditableValue(rawValue));
+    onFocus?.(event);
+  };
+  const handleChange = (event) => {
+    const editableValue = normalizeEditableValue(event.currentTarget.value);
+    const nextRawValue = editableToRawValue(editableValue);
+    setRawValue(nextRawValue);
+    setDisplayValue(editableValue);
+    emitRawValue(event, nextRawValue);
+    onChange?.(event);
+  };
+  const handleBlur = (event) => {
+    const editableValue = normalizeEditableValue(displayValue);
+    const nextRawValue = editableToRawValue(editableValue);
+    setRawValue(nextRawValue);
+    setIsFocused(false);
+    setDisplayValue(rawToDisplayValue(nextRawValue));
+    emitRawValue(event, nextRawValue);
+    onBlur?.(event);
+  };
+  return {
+    rawValue,
+    displayValue,
+    isFocused,
+    handleFocus,
+    handleChange,
+    handleBlur
+  };
+}
+
+// src/utils/input/keyboard.ts
+var NAVIGATION_KEYS = /* @__PURE__ */ new Set([
+  "Backspace",
+  "Delete",
+  "ArrowLeft",
+  "ArrowRight",
+  "Home",
+  "End",
+  "Tab"
+]);
+var isControlShortcut = (event) => event.ctrlKey || event.metaKey;
+var isNavigationKey = (key) => NAVIGATION_KEYS.has(key);
+var buildNextValue = (currentValue, selectionStart, selectionEnd, nextText) => `${currentValue.slice(0, selectionStart)}${nextText}${currentValue.slice(selectionEnd)}`;
+
+// src/utils/input/money.ts
+var DEFAULT_MONEY_SYMBOL = "$";
+var MONEY_MAX_DECIMALS = 4;
+var MONEY_INPUT_PATTERN = "^([0-9]+)(,[0-9]{0,4})?$";
+var MONEY_ALLOWED_CHAR_REGEX = /[0-9,]/;
+var MONEY_PASTE_REGEX = /^[0-9,]+$/;
+var isAllowedMoneyCharacter = (key) => MONEY_ALLOWED_CHAR_REGEX.test(key);
+var isValidMoneyPaste = (value) => MONEY_PASTE_REGEX.test(value);
+var sanitizeMoneyEditableValue = (value) => {
+  const cleaned = value.replace(/[^\d,]/g, "");
+  const [integerPart = "", ...decimalParts] = cleaned.split(",");
+  const mergedDecimals = decimalParts.join("").slice(0, MONEY_MAX_DECIMALS);
+  const normalizedInteger = integerPart.replace(/^0+(?=\d)/, "");
+  if (decimalParts.length > 0) {
+    return `${normalizedInteger},${mergedDecimals}`;
+  }
+  return normalizedInteger;
+};
+var editableMoneyToRawValue = (editableValue) => {
+  if (!editableValue) {
+    return "";
+  }
+  const [integerPart = "", decimalPart] = editableValue.split(",");
+  const normalizedInteger = integerPart || "0";
+  if (decimalPart === void 0 || decimalPart.length === 0) {
+    return normalizedInteger;
+  }
+  return `${normalizedInteger}.${decimalPart}`;
+};
+var rawMoneyToEditableValue = (rawValue) => {
+  if (!rawValue) {
+    return "";
+  }
+  const [integerPart = "", decimalPart] = rawValue.split(".");
+  if (decimalPart === void 0 || decimalPart.length === 0) {
+    return integerPart;
+  }
+  return `${integerPart},${decimalPart.slice(0, MONEY_MAX_DECIMALS)}`;
+};
+var normalizeMoneyRawValue = (value) => {
+  const normalized = Array.isArray(value) ? value[0] : value;
+  if (normalized === void 0 || normalized === null) {
+    return "";
+  }
+  const asString = String(normalized).trim();
+  if (!asString) {
+    return "";
+  }
+  const fromRaw = asString.match(/^(\d+)(?:[.,](\d{0,4}))?$/);
+  if (fromRaw) {
+    const integerPart = fromRaw[1] ?? "";
+    const decimalPart = fromRaw[2] ?? "";
+    if (!decimalPart) {
+      return integerPart;
+    }
+    return `${integerPart}.${decimalPart}`;
+  }
+  return editableMoneyToRawValue(sanitizeMoneyEditableValue(asString));
+};
+var formatMoneyValue = (rawValue, moneySymbol) => {
+  if (!rawValue) {
+    return "";
+  }
+  const [integerPart = "0", decimalPart = ""] = rawValue.split(".");
+  const integerWithGrouping = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+  const decimalSection = decimalPart ? `,${decimalPart}` : "";
+  const prefix = moneySymbol.trim();
+  if (!prefix) {
+    return `${integerWithGrouping}${decimalSection}`;
+  }
+  return `${prefix} ${integerWithGrouping}${decimalSection}`;
+};
+
+// src/components/inputs/input/money-input.tsx
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+function MoneyInput({
+  size: _size,
+  classNames,
+  moneySymbol,
+  reset,
+  ...props
+}) {
+  const {
+    value,
+    defaultValue,
+    onChange,
+    onKeyDown,
+    onBlur,
+    onFocus,
+    onPaste,
+    className,
+    inputMode,
+    pattern,
+    name,
+    disabled,
+    ...restProps
+  } = props;
+  const symbol = moneySymbol ?? DEFAULT_MONEY_SYMBOL;
+  const rawToDisplayValue = useCallback(
+    (rawValue2) => formatMoneyValue(rawValue2, symbol),
+    [symbol]
+  );
+  const {
+    rawValue,
+    displayValue,
+    isFocused,
+    handleFocus,
+    handleChange,
+    handleBlur
+  } = useFormattedNumericInput({
+    value,
+    defaultValue,
+    onChange,
+    onBlur,
+    onFocus,
+    normalizeRawValue: normalizeMoneyRawValue,
+    rawToEditableValue: rawMoneyToEditableValue,
+    rawToDisplayValue,
+    editableToRawValue: editableMoneyToRawValue,
+    sanitizeEditableValue: sanitizeMoneyEditableValue
+  });
+  const resolvedPattern = pattern ?? (isFocused ? MONEY_INPUT_PATTERN : void 0);
+  const handleKeyDown = (event) => {
+    if (!isControlShortcut(event) && !isNavigationKey(event.key)) {
+      const isAllowed = isAllowedMoneyCharacter(event.key);
+      if (!isAllowed) {
+        event.preventDefault();
+      }
+    }
+    onKeyDown?.(event);
+  };
+  const handlePaste = (event) => {
+    const pastedText = event.clipboardData.getData("text");
+    if (!isValidMoneyPaste(pastedText)) {
+      event.preventDefault();
+    }
+    onPaste?.(event);
+  };
+  if (reset) {
+    return /* @__PURE__ */ jsx5("div", { className: cn("w-fit", classNames?.root), children: /* @__PURE__ */ jsx5("input", { ...props, className: cn(classNames?.input, className) }) });
+  }
+  return /* @__PURE__ */ jsxs2("div", { className: cn("w-fit", classNames?.root), children: [
+    /* @__PURE__ */ jsx5(
+      "input",
+      {
+        ...restProps,
+        type: "text",
+        name: void 0,
+        value: displayValue,
+        disabled,
+        inputMode: inputMode ?? "decimal",
+        pattern: resolvedPattern,
+        onFocus: handleFocus,
+        onChange: handleChange,
+        onBlur: handleBlur,
+        onKeyDown: handleKeyDown,
+        onPaste: handlePaste,
+        className: cn(classNames?.input, className)
+      }
+    ),
+    name ? /* @__PURE__ */ jsx5("input", { type: "hidden", name, value: rawValue, disabled }) : null
+  ] });
+}
+
+// src/utils/input/number.ts
+var NUMBER_INPUT_PATTERN = "^([0-9]{1,3}(\\.[0-9]{3})*|[0-9]+)?(,[0-9]*)?$";
+var NUMBER_ALLOWED_CHAR_REGEX = /[0-9.,]/;
+var NUMBER_INPUT_REGEX = /^(\d{1,3}(\.\d{3})*|\d+)?(,\d*)?$/;
+var NUMBER_RAW_REGEX = /^\d+(?:\.\d+)?$/;
+var isAllowedNumberCharacter = (key) => NUMBER_ALLOWED_CHAR_REGEX.test(key);
+var isValidNumberInput = (value) => NUMBER_INPUT_REGEX.test(value);
+var displayNumberToRawValue = (displayValue) => {
+  if (!displayValue) {
+    return "";
+  }
+  const cleaned = displayValue.replace(/[^\d.,]/g, "");
+  const [integerPart = "", ...decimalParts] = cleaned.split(",");
+  const integerWithoutGrouping = integerPart.replace(/\./g, "");
+  const decimalPart = decimalParts.join("");
+  if (!integerWithoutGrouping && !decimalPart) {
+    return "";
+  }
+  if (!decimalPart) {
+    return integerWithoutGrouping;
+  }
+  return `${integerWithoutGrouping || "0"}.${decimalPart}`;
+};
+var rawNumberToDisplayValue = (rawValue) => {
+  if (!rawValue) {
+    return "";
+  }
+  const [integerPart = "0", decimalPart = ""] = rawValue.split(".");
+  const integerWithGrouping = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+  if (!decimalPart) {
+    return integerWithGrouping;
+  }
+  return `${integerWithGrouping},${decimalPart}`;
+};
+var rawNumberToEditableValue = (rawValue) => {
+  if (!rawValue) {
+    return "";
+  }
+  const [integerPart = "", decimalPart] = rawValue.split(".");
+  if (decimalPart === void 0 || decimalPart.length === 0) {
+    return integerPart;
+  }
+  return `${integerPart},${decimalPart}`;
+};
+var normalizeNumberRawValue = (value) => {
+  const normalized = Array.isArray(value) ? value[0] : value;
+  if (normalized === void 0 || normalized === null) {
+    return "";
+  }
+  const asString = String(normalized).trim();
+  if (!asString) {
+    return "";
+  }
+  if (NUMBER_RAW_REGEX.test(asString)) {
+    return asString;
+  }
+  if (NUMBER_INPUT_REGEX.test(asString)) {
+    return displayNumberToRawValue(asString);
+  }
+  return displayNumberToRawValue(asString);
+};
+
+// src/components/inputs/input/number-input.tsx
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+function NumberInput({
+  size: _size,
+  classNames,
+  reset,
+  ...props
+}) {
+  const {
+    value,
+    defaultValue,
+    onChange,
+    onBlur,
+    onFocus,
+    onKeyDown,
+    onPaste,
+    inputMode,
+    pattern,
+    className,
+    name,
+    disabled,
+    ...restProps
+  } = props;
+  const { rawValue, displayValue, handleFocus, handleChange, handleBlur } = useFormattedNumericInput({
+    value,
+    defaultValue,
+    onChange,
+    onBlur,
+    onFocus,
+    normalizeRawValue: normalizeNumberRawValue,
+    rawToEditableValue: rawNumberToEditableValue,
+    rawToDisplayValue: rawNumberToDisplayValue,
+    editableToRawValue: displayNumberToRawValue
+  });
+  const handleKeyDown = (event) => {
+    if (!isControlShortcut(event) && !isNavigationKey(event.key)) {
+      const isAllowedChar = isAllowedNumberCharacter(event.key);
+      if (!isAllowedChar) {
+        event.preventDefault();
+      } else {
+        const inputElement = event.currentTarget;
+        const selectionStart = inputElement.selectionStart ?? 0;
+        const selectionEnd = inputElement.selectionEnd ?? selectionStart;
+        const nextValue = buildNextValue(
+          inputElement.value,
+          selectionStart,
+          selectionEnd,
+          event.key
+        );
+        if (!isValidNumberInput(nextValue)) {
+          event.preventDefault();
+        }
+      }
+    }
+    onKeyDown?.(event);
+  };
+  const handlePaste = (event) => {
+    const pastedText = event.clipboardData.getData("text");
+    const inputElement = event.currentTarget;
+    const selectionStart = inputElement.selectionStart ?? 0;
+    const selectionEnd = inputElement.selectionEnd ?? selectionStart;
+    const nextValue = buildNextValue(
+      inputElement.value,
+      selectionStart,
+      selectionEnd,
+      pastedText
+    );
+    if (!isValidNumberInput(nextValue)) {
+      event.preventDefault();
+    }
+    onPaste?.(event);
+  };
+  if (reset) {
+    return /* @__PURE__ */ jsx6("div", { className: cn("w-fit", classNames?.root), children: /* @__PURE__ */ jsx6(
+      "input",
+      {
+        ...props,
+        type: "number",
+        className: cn(classNames?.input, className)
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsxs3("div", { className: cn("w-fit", classNames?.root), children: [
+    /* @__PURE__ */ jsx6(
+      "input",
+      {
+        ...restProps,
+        type: "text",
+        name: void 0,
+        value: displayValue,
+        disabled,
+        inputMode: inputMode ?? "decimal",
+        pattern: pattern ?? NUMBER_INPUT_PATTERN,
+        onFocus: handleFocus,
+        onChange: handleChange,
+        onBlur: handleBlur,
+        onKeyDown: handleKeyDown,
+        onPaste: handlePaste,
+        className: cn(classNames?.input, className)
+      }
+    ),
+    name ? /* @__PURE__ */ jsx6("input", { type: "hidden", name, value: rawValue, disabled }) : null
+  ] });
+}
+
+// src/components/inputs/input/password-input.tsx
+import { Eye, EyeOff } from "lucide-react";
+import { useState as useState2 } from "react";
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+var buttonSizeClasses = {
+  sm: "size-8 rounded-sm",
+  md: "size-10 rounded-sm",
+  lg: "size-11 rounded-md"
+};
+var iconSizeClasses = {
+  sm: "size-4",
+  md: "size-5",
+  lg: "size-6"
+};
+function PasswordInput({
+  size,
+  classNames,
+  ...props
+}) {
+  const [viewPassword, setViewPassword] = useState2(false);
+  const EyeIcon = viewPassword ? Eye : EyeOff;
+  const { className, ...restProps } = props;
+  const currentSize = size ?? "md";
+  return /* @__PURE__ */ jsxs4("div", { className: cn("relative w-fit", classNames?.root), children: [
+    /* @__PURE__ */ jsx7(
+      "input",
+      {
+        ...restProps,
+        type: viewPassword ? "text" : "password",
+        className: cn(
+          "placeholder:tracking-normal [[type='password']]:tracking-[0.16em]",
+          classNames?.input,
+          className
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx7(
+      Button,
+      {
+        variant: "ghost",
+        size: "icon",
+        className: cn(
+          "absolute top-1/2 right-1 -translate-y-1/2",
+          buttonSizeClasses[currentSize]
+        ),
+        type: "button",
+        "aria-label": viewPassword ? "Hide password" : "Show password",
+        title: viewPassword ? "Ocultar contrase\xF1a" : "Mostrar contrase\xF1a",
+        onClick: () => setViewPassword((prev) => !prev),
+        children: /* @__PURE__ */ jsx7(
+          EyeIcon,
+          {
+            "aria-hidden": "true",
+            className: cn(iconSizeClasses[currentSize])
+          }
+        )
+      }
+    )
+  ] });
+}
+
+// src/types/atoms/inputs/input/input.ts
+var inputTypes = [
+  "text",
+  "password",
+  "email",
+  "number",
+  "money"
+];
+
+// src/components/inputs/input/input.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+var baseStyles3 = [
+  "bg-transparent transition-colors duration-200 ease-in-out disabled:bg-neutral-200 disabled:text-neutral-600 disabled:border-neutral-400 disabled:cursor-not-allowed"
+];
+var variants3 = {
+  default: [
+    "border border-neutral-500 text-foreground",
+    "placeholder:text-neutral-500",
+    "hover:border-neutral-700",
+    "focus:border-info-500 focus:ring-0 focus:outline-none"
+  ],
+  error: [
+    "border border-destructive text-foreground",
+    "placeholder:text-destructive-400/70",
+    "hover:border-destructive-600",
+    "focus:border-destructive-400 focus:ring-0 focus:outline-none"
+  ],
+  success: [
+    "border border-success text-foreground",
+    "placeholder:text-success/60",
+    "hover:border-success-600",
+    "focus:border-success-400 focus:ring-0 focus:outline-none"
+  ]
+};
+var sizes3 = {
+  sm: ["h-10 rounded-[14px] px-3 py-2.5 font-normal text-sm"],
+  md: ["h-12 rounded-md px-3 pt-3 pb-3.5 text-base"],
+  lg: ["h-13 rounded-lg px-3 py-[15px] text-base"]
+};
+var switchVariants = cva3(baseStyles3, {
+  variants: {
+    variant: variants3,
+    size: sizes3
+  },
+  defaultVariants: {
+    variant: "default",
+    size: "md"
+  }
+});
+function Input({
+  variant,
+  size,
+  classNames,
+  moneySymbol,
+  type,
+  ...props
+}) {
+  const inputClasses = cn(switchVariants({ variant, size }), props.className);
+  const specializedClassNames = {
+    input: cn(inputClasses, classNames?.input),
+    root: classNames?.root
+  };
+  if (type && !inputTypes.includes(type)) {
+    throw new Error(
+      `Invalid input type: ${type}. Allowed types are: ${inputTypes.join(", ")}`
+    );
+  }
+  if (type !== "password" && type !== "number" && type !== "money") {
+    return /* @__PURE__ */ jsx8("div", { className: cn("w-fit", classNames?.root), children: /* @__PURE__ */ jsx8(
+      "input",
+      {
+        ...props,
+        type,
+        className: cn(inputClasses, classNames?.input)
+      }
+    ) });
+  }
+  if (type === "password") {
+    return /* @__PURE__ */ jsx8(
+      PasswordInput,
+      {
+        size,
+        classNames: specializedClassNames,
+        ...props
+      }
+    );
+  }
+  if (type === "number") {
+    return /* @__PURE__ */ jsx8(NumberInput, { size, classNames: specializedClassNames, ...props });
+  }
+  if (type === "money") {
+    return /* @__PURE__ */ jsx8(
+      MoneyInput,
+      {
+        size,
+        moneySymbol,
+        classNames: specializedClassNames,
+        ...props
+      }
+    );
+  }
+}
+
+// src/components/inputs/radio.tsx
+import { cva as cva4 } from "class-variance-authority";
+
+// src/hooks/use-radio.ts
+import { useId as useId2 } from "react";
+
+// src/hooks/context/radio-group.ts
+import { createContext, useContext } from "react";
+var RadioGroupContext = createContext(null);
+function useRadioGroupContext() {
+  const context = useContext(RadioGroupContext);
+  if (!context) {
+    throw new Error("RadioItem must be used within a RadioGroup");
+  }
+  return context;
+}
+
+// src/hooks/use-radio.ts
+function useRadio({
+  variant,
+  readOnly,
+  disabled,
+  value,
+  onClick,
+  onChange,
+  id
+}) {
+  const context = useRadioGroupContext();
+  const generatedId = useId2();
+  const finalId = id || generatedId;
+  const resolvedVariant = variant || context.variant;
+  const isReadOnly = Boolean(readOnly || context.readOnly);
+  const isDisabled = Boolean(disabled || context.disabled);
+  const isChecked = context.value === value;
+  const name = context.name;
+  const handleClick = (event) => {
+    if (isReadOnly || isDisabled) {
+      event.preventDefault();
+      return;
+    }
+    onClick?.(event);
+  };
+  const handleChange = (event) => {
+    if (isReadOnly || isDisabled) {
+      event.preventDefault();
+      return;
+    }
+    context.onValueChange(value);
+    onChange?.(event);
+  };
+  return {
+    id: finalId,
+    name,
+    resolvedVariant,
+    isReadOnly,
+    isDisabled,
+    isChecked,
+    handleClick,
+    handleChange
+  };
+}
+
+// src/hooks/use-radio-group.ts
+import { useCallback as useCallback2, useId as useId3, useMemo, useState as useState3 } from "react";
+function useRadioGroup({
+  value,
+  defaultValue,
+  onValueChange,
+  name,
+  variant = "default",
+  disabled = false,
+  readOnly = false
+}) {
+  const generatedName = useId3();
+  const groupName = name || generatedName;
+  const [internalValue, setInternalValue] = useState3(defaultValue);
+  const isControlled = value !== void 0;
+  const selectedValue = isControlled ? value : internalValue;
+  const handleValueChange = useCallback2(
+    (nextValue) => {
+      if (disabled || readOnly) {
+        return;
+      }
+      if (!isControlled) {
+        setInternalValue(nextValue);
+      }
+      onValueChange?.(nextValue);
+    },
+    [disabled, readOnly, isControlled, onValueChange]
+  );
+  const contextValue = useMemo(
+    () => ({
+      name: groupName,
+      value: selectedValue,
+      variant,
+      disabled,
+      readOnly,
+      onValueChange: handleValueChange
+    }),
+    [groupName, selectedValue, variant, disabled, readOnly, handleValueChange]
+  );
+  return {
+    contextValue
+  };
+}
+
+// src/providers/radio-group-provider.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function RadioGroupProvider({ value, children }) {
+  return /* @__PURE__ */ jsx9(RadioGroupContext.Provider, { value, children });
+}
+
+// src/components/inputs/radio.tsx
+import { jsx as jsx10, jsxs as jsxs5 } from "react/jsx-runtime";
+var baseStyles4 = "size-6 shrink-0 appearance-none rounded-full border-2 border-neutral-600 bg-transparent transition-all duration-200 outline-none disabled:border-neutral-400 disabled:bg-transparent focus-visible:ring-2 focus-visible:ring-offset-1 cursor-pointer disabled:cursor-not-allowed group-data-[readonly=true]/radio:cursor-default";
+var variants4 = {
+  default: "hover:border-info-500 hover:bg-info-50 focus-visible:border-info-500 focus-visible:ring-info-500/20 checked:border-info-500 checked:hover:border-info-600 disabled:hover:border-neutral-400 disabled:hover:bg-transparent",
+  success: "hover:border-success-500 hover:bg-success-50 focus-visible:border-success-500 focus-visible:ring-success-500/20 checked:border-success-500 checked:hover:border-success-600 disabled:hover:border-neutral-400 disabled:hover:bg-transparent"
+};
+var indicatorVariants = cva4(
+  "pointer-events-none absolute z-10 size-3 rounded-full opacity-0 transition-opacity group-has-checked/control:opacity-100",
+  {
+    variants: {
+      variant: {
+        default: "bg-info-500",
+        success: "bg-success-500"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+var radioVariants = cva4(baseStyles4, {
+  variants: {
+    variant: variants4
+  },
+  defaultVariants: {
+    variant: "default"
+  }
+});
+function RadioGroup({
+  value,
+  defaultValue,
+  onValueChange,
+  name,
+  variant = "default",
+  disabled = false,
+  readOnly = false,
+  className,
+  children,
+  ...props
+}) {
+  const { contextValue } = useRadioGroup({
+    value,
+    defaultValue,
+    onValueChange,
+    name,
+    variant,
+    disabled,
+    readOnly
+  });
+  return /* @__PURE__ */ jsx10(RadioGroupProvider, { value: contextValue, children: /* @__PURE__ */ jsx10(
+    "div",
+    {
+      role: "radiogroup",
+      "aria-disabled": contextValue.disabled || void 0,
+      "aria-readonly": contextValue.readOnly || void 0,
+      "data-slot": "radio-group",
+      "data-disabled": contextValue.disabled ? "true" : void 0,
+      "data-readonly": contextValue.readOnly ? "true" : void 0,
+      className: cn("flex flex-col gap-4", className),
+      ...props,
+      children
+    }
+  ) });
+}
+function RadioItem({
+  variant,
+  children,
+  className,
+  classNames,
+  readOnly,
+  onClick,
+  onChange,
+  disabled,
+  value,
+  id: propId,
+  ...props
+}) {
+  const {
+    handleChange,
+    handleClick,
+    id,
+    isChecked,
+    isDisabled,
+    isReadOnly,
+    resolvedVariant,
+    name
+  } = useRadio({
+    variant,
+    readOnly,
+    disabled,
+    value,
+    onClick,
+    onChange,
+    id: propId
+  });
+  const classes = cn(
+    radioVariants({ variant: resolvedVariant }),
+    className,
+    classNames?.input
+  );
+  return /* @__PURE__ */ jsxs5(
+    "label",
+    {
+      "data-slot": "radio",
+      "data-state": isChecked ? "checked" : "unchecked",
+      "data-disabled": isDisabled ? "true" : void 0,
+      "data-readonly": isReadOnly ? "true" : void 0,
+      className: cn(
+        "group/radio inline-flex w-fit cursor-pointer items-center gap-3 data-[disabled=true]:cursor-not-allowed data-[readonly=true]:cursor-default",
+        classNames?.root
+      ),
+      children: [
+        /* @__PURE__ */ jsxs5(
+          "span",
+          {
+            role: "presentation",
+            className: "group/control relative flex size-6 shrink-0 items-center justify-center",
+            children: [
+              /* @__PURE__ */ jsx10(
+                "input",
+                {
+                  id,
+                  type: "radio",
+                  name,
+                  value,
+                  checked: isChecked,
+                  className: classes,
+                  readOnly: isReadOnly,
+                  disabled: isDisabled,
+                  onClick: handleClick,
+                  onChange: handleChange,
+                  ...props
+                }
+              ),
+              /* @__PURE__ */ jsx10(
+                "span",
+                {
+                  "aria-hidden": "true",
+                  role: "presentation",
+                  className: cn(
+                    indicatorVariants({ variant: resolvedVariant }),
+                    classNames?.indicator
+                  )
+                }
+              )
+            ]
+          }
+        ),
+        children ? /* @__PURE__ */ jsx10(
+          "span",
+          {
+            "data-slot": "radio-label",
+            className: cn(
+              "cursor-pointer transition-colors group-data-[disabled=true]/radio:cursor-not-allowed group-data-[readonly=true]/radio:cursor-default group-data-[disabled=true]/radio:text-neutral-600",
+              classNames?.label
+            ),
+            children
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/components/inputs/switch.tsx
+import { cva as cva5 } from "class-variance-authority";
+import { useId as useId4 } from "react";
+import { jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
+var baseStyles5 = [
+  "group relative inline-flex h-6 w-11 items-center rounded-sm p-0.5 transition-colors duration-300",
+  "[&_>span]:block [&_>span]:size-5 [&_>span]:rounded-full [&_>span]:transition-all [&_>span]:duration-300 [&_>span]:group-has-checked:translate-x-full",
+  "bg-neutral-300 group-hover:bg-neutral-400",
+  "[&_>span]:bg-neutral-500 group-hover:[&_>span]:bg-neutral-600",
+  "group-has-checked:[&_>span]:bg-neutral-300 group-has-checked:group-hover:[&_>span]:bg-neutral-300",
+  "outline-info-500/20 group-has-focus-visible:outline-3 group-has-focus-visible:ring-0",
+  "group-has-disabled:bg-neutral-200 group-has-disabled:cursor-not-allowed",
+  "group-has-disabled:group-hover:bg-neutral-200 group-has-disabled:[&_>span]:bg-neutral-400 group-has-disabled:group-hover:[&_>span]:bg-neutral-400",
+  "group-has-disabled:group-has-checked:[&_>span]:bg-neutral-200 group-has-disabled:group-has-checked:group-hover:[&_>span]:bg-neutral-200"
+];
+var variants5 = {
+  default: [
+    "group-has-checked:bg-info-500 group-has-checked:group-hover:bg-info-700",
+    "group-has-disabled:group-has-checked:bg-info-50 group-has-disabled:group-has-checked:group-hover:bg-info-50"
+  ],
+  alt: [
+    "group-has-checked:bg-alt2-500 group-has-checked:group-hover:bg-alt2-700",
+    "group-has-disabled:group-has-checked:bg-alt2-50 group-has-disabled:group-has-checked:group-hover:bg-alt2-50"
+  ]
+};
+var switchVariants2 = cva5(baseStyles5, {
+  variants: {
+    variant: variants5
+  },
+  defaultVariants: {
+    variant: "default"
+  }
+});
+function Switch({
+  variant,
+  classNames,
+  id: propsId,
+  children,
+  className,
+  ...props
+}) {
+  const generatedId = useId4();
+  const id = propsId || generatedId;
+  const classes = cn(switchVariants2({ variant }), classNames?.input);
+  return /* @__PURE__ */ jsxs6(
+    "label",
+    {
+      htmlFor: id,
+      className: cn(
+        "group inline-flex items-center gap-2",
+        props.disabled ? "cursor-not-allowed text-neutral-700" : "cursor-pointer",
+        className,
+        classNames?.root
+      ),
+      children: [
+        /* @__PURE__ */ jsxs6("span", { className: classes, children: [
+          /* @__PURE__ */ jsx11("input", { ...props, id, type: "checkbox", className: "sr-only" }),
+          /* @__PURE__ */ jsx11("span", { "aria-hidden": "true", className: cn(classNames?.indicator) })
+        ] }),
+        children
+      ]
+    }
+  );
+}
+
+// src/components/surfaces/card.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function Card({ as = "div", className, interactive, ...props }) {
+  const cardClassName = cn(
+    "flex flex-col gap-5 rounded-lg bg-card p-4 text-card-foreground",
+    interactive && "cursor-pointer transition-shadow focus-within:ring-2 focus-within:ring-ring/40 hover:shadow-lg",
+    className
+  );
+  if (as === "article") {
+    return /* @__PURE__ */ jsx12("article", { "data-slot": "card", className: cardClassName, ...props });
+  }
+  if (as === "section") {
+    return /* @__PURE__ */ jsx12("section", { "data-slot": "card", className: cardClassName, ...props });
+  }
+  return /* @__PURE__ */ jsx12("div", { "data-slot": "card", className: cardClassName, ...props });
+}
+function CardHeader({ className, ...props }) {
+  return /* @__PURE__ */ jsx12(
+    "header",
+    {
+      "data-slot": "card-header",
+      className: cn(
+        "@container/card-header grid auto-rows-min grid-rows-[auto_auto] items-start gap-1 has-data-[slot=card-action]:grid-cols-[1fr_auto] [.border-b]:pb-6",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function CardTitle({ className, ...props }) {
+  return /* @__PURE__ */ jsx12(
+    "h3",
+    {
+      "data-slot": "card-title",
+      className: cn("font-semibold leading-none", className),
+      ...props
+    }
+  );
+}
+function CardDescription({ className, ...props }) {
+  return /* @__PURE__ */ jsx12(
+    "p",
+    {
+      "data-slot": "card-description",
+      className: cn("text-neutral-700 text-sm", className),
+      ...props
+    }
+  );
+}
+function CardAction({ className, ...props }) {
+  return /* @__PURE__ */ jsx12(
+    "div",
+    {
+      "data-slot": "card-action",
+      className: cn(
+        "col-start-2 row-span-2 row-start-1 self-start justify-self-end",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function CardContent({ className, ...props }) {
+  return /* @__PURE__ */ jsx12("section", { "data-slot": "card-content", className: cn(className), ...props });
+}
+function CardFooter({ className, ...props }) {
+  return /* @__PURE__ */ jsx12(
+    "footer",
+    {
+      "data-slot": "card-footer",
+      className: cn("flex items-center px-6 [.border-t]:pt-6", className),
+      ...props
+    }
+  );
+}
+
+// src/components/icons/menu/closeX.tsx
+import { jsx as jsx13 } from "react/jsx-runtime";
+function CloseX({ className, ...props }) {
+  return /* @__PURE__ */ jsx13(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      fill: "none",
+      viewBox: "0 0 24 24",
+      className,
+      ...props,
+      children: /* @__PURE__ */ jsx13(
+        "path",
+        {
+          stroke: "currentColor",
+          strokeLinecap: "round",
+          strokeLinejoin: "round",
+          d: "m18 18-6-6m0 0L6 6m6 6 6-6m-6 6-6 6"
+        }
+      )
+    }
+  );
+}
+export {
+  Button,
+  Card,
+  CardAction,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+  Check,
+  Checkbox,
+  CloseX,
+  Input,
+  Minus,
+  MoneyInput,
+  NumberInput,
+  PasswordInput,
+  RadioItem as Radio,
+  RadioGroup,
+  RadioItem,
+  Switch,
+  cn,
+  inputTypes,
+  useFormattedNumericInput,
+  useRadio,
+  useRadioGroup
+};
+//# sourceMappingURL=index.js.map