@envisiongroup/porygon 0.1.0-rc.1

package/dist/react-components/fields/EFWInput/EFWInput.types.d.ts

@@ -0,0 +1,257 @@
+import { EFWFieldChildrenProps } from '../EFWField/EFWField.types';
+
+/**
+ * Valor que puede contener un componente de entrada EFW.
+ * Representa el valor de texto o null cuando no hay contenido.
+ *
+ * @example
+ * // Valor con texto
+ * const textValue: EFWInputValue = "Texto de ejemplo";
+ *
+ * @example
+ * // Valor vacío
+ * const emptyValue: EFWInputValue = null;
+ *
+ * @example
+ * // En un componente React
+ * const [inputValue, setInputValue] = useState<EFWInputValue>("Valor inicial");
+ */
+export type EFWInputValue = string | null;
+/**
+ * Tipos de formato disponibles para el componente EFWInput.
+ * Determina cómo se formatea y valida el contenido del campo de entrada.
+ *
+ * @example
+ * // Sin formato específico
+ * const basicFormat: FormatType = 'none';
+ *
+ * @example
+ * // Para números de teléfono
+ * const phoneFormat: FormatType = 'phone';
+ *
+ * @example
+ * // Para RUT chileno
+ * const rutFormat: FormatType = 'chileanRut';
+ */
+export type FormatType = 'none' | 'phone' | 'creditCard' | 'chileanRut' | 'date' | 'custom' | 'email';
+/**
+ * Propiedades del componente EFWInput.
+ * Extiende las propiedades básicas de los campos EFW con funcionalidades específicas
+ * para entrada de texto, formateo, validación y personalización visual.
+ *
+ * @interface EFWInputProps
+ * @extends {Partial<EFWFieldChildrenProps>}
+ *
+ * @example
+ * // Uso básico
+ * const basicProps: EFWInputProps = {
+ *   value: "ejemplo@email.com",
+ *   placeholder: "Ingrese su email",
+ *   formatType: "email"
+ * };
+ *
+ * @example
+ * // Uso avanzado con validación personalizada
+ * const advancedProps: EFWInputProps = {
+ *   value: "12345678-9",
+ *   formatType: "chileanRut",
+ *   minLength: 8,
+ *   maxLength: 12,
+ *   editable: true,
+ *   onChange: (value, displayValue) => {
+ *     console.log('Valor crudo:', value);
+ *     console.log('Valor mostrado:', displayValue);
+ *   }
+ * };
+ */
+export interface EFWInputProps extends Partial<EFWFieldChildrenProps> {
+    /**
+     * Contenido mostrado antes del campo de entrada.
+     * Útil para iconos, prefijos o elementos decorativos.
+     *
+     * @example
+     * contentBefore="$"
+     *
+     * @example
+     * contentBefore="https://"
+     */
+    contentBefore?: string;
+    /**
+     * Contenido mostrado después del campo de entrada.
+     * Útil para unidades, sufijos o elementos adicionales.
+     *
+     * @example
+     * contentAfter="kg"
+     *
+     * @example
+     * contentAfter=".com"
+     */
+    contentAfter?: string;
+    /**
+     * Configuración de autocompletado del navegador.
+     * Controla si el navegador puede sugerir valores automáticamente.
+     *
+     * @default off
+     *
+     * @example
+     * autoComplete="on"
+     *
+     * @example
+     * autoComplete="off"
+     */
+    autoComplete?: 'on' | 'off';
+    /**
+     * Valor actual del campo de entrada.
+     * Puede ser una cadena de texto o null para campos vacíos.
+     *
+     * @example
+     * value="Juan Pérez"
+     *
+     * @example
+     * value={null}
+     */
+    value?: EFWInputValue;
+    /**
+     * Tipo de input HTML que determina el comportamiento del campo.
+     * Afecta el teclado virtual en dispositivos móviles y la validación del navegador.
+     *
+     * @default "text"
+     *
+     * @example
+     * type="email"
+     *
+     * @example
+     * type="password"
+     *
+     * @example
+     * type="tel"
+     */
+    type?: 'text' | 'password' | 'email' | 'number' | 'tel';
+    /**
+     * Clases CSS adicionales aplicadas al componente.
+     * Permite personalizar la apariencia del campo de entrada.
+     *
+     * @example
+     * className="mi-input-personalizado"
+     *
+     * @example
+     * className="campo-destacado campo-grande"
+     */
+    className?: string;
+    /**
+     * Texto de sugerencia mostrado cuando el campo está vacío.
+     * Proporciona una pista visual sobre qué tipo de contenido se espera.
+     *
+     * @example
+     * placeholder="Ingrese su nombre completo"
+     *
+     * @example
+     * placeholder="ejemplo@correo.com"
+     */
+    placeholder?: string;
+    /**
+     * Tipo de formato aplicado automáticamente al valor del campo.
+     * Determina cómo se muestra y valida el contenido ingresado.
+     *
+     * @default none
+     *
+     * @example
+     * formatType="chileanRut"
+     *
+     * @example
+     * formatType="phone"
+     *
+     * @example
+     * formatType="email"
+     */
+    formatType?: FormatType;
+    /**
+     * Patrón de expresión regular para validación personalizada.
+     * Se aplica cuando formatType es "custom" o para validaciones adicionales.
+     *
+     * @example
+     * formatPattern="^[A-Z]{2}[0-9]{6}$"
+     *
+     * @example
+     * formatPattern="\\d{4}-\\d{4}-\\d{4}-\\d{4}"
+     */
+    formatPattern?: string;
+    /**
+     * Controla si el usuario puede editar el contenido del campo.
+     * Cuando es false, el campo se muestra como texto de solo lectura.
+     *
+     * @default true
+     *
+     * @example
+     * editable={false}
+     *
+     * @example
+     * editable={userRole === 'admin'}
+     */
+    editable?: boolean;
+    /**
+     * Longitud mínima requerida para el valor del campo.
+     * Se usa para validación y puede mostrar mensajes de error si no se cumple.
+     *
+     * @default 0
+     *
+     * @example
+     * minLength={8}
+     *
+     * @example
+     * minLength={3}
+     */
+    minLength?: number;
+    /**
+     * Longitud máxima permitida para el valor del campo.
+     * Limita la cantidad de caracteres que el usuario puede ingresar.
+     *
+     * @default 250
+     *
+     * @example
+     * maxLength={100}
+     *
+     * @example
+     * maxLength={50}
+     */
+    maxLength?: number;
+    /**
+     * Función personalizada para aplicar formato al valor del campo.
+     * Se ejecuta cuando formatType es "custom" o para lógica de formato específica.
+     *
+     * @param value - Valor actual del campo a formatear
+     * @returns Valor formateado o el valor original si no se puede formatear
+     *
+     * @example
+     * formatFunction={(value) => value?.toUpperCase() || ""}
+     *
+     * @example
+     * formatFunction={(value) => {
+     *   if (!value) return "";
+     *   return value.replace(/\s+/g, "-").toLowerCase();
+     * }}
+     */
+    formatFunction?: (value: EFWInputValue) => EFWInputValue;
+    /**
+     * Callback ejecutado cuando el valor del campo cambia.
+     * Recibe tanto el valor sin formato como el valor mostrado al usuario.
+     *
+     * @param value - Valor crudo sin formato aplicado
+     * @param displayValue - Valor formateado mostrado en el campo
+     *
+     * @example
+     * onChange={(value, displayValue) => {
+     *   console.log('Valor guardado:', value);
+     *   console.log('Valor mostrado:', displayValue);
+     *   setFormData(prev => ({ ...prev, campo: value }));
+     * }}
+     *
+     * @example
+     * onChange={(value) => {
+     *   if (value && value.length >= 3) {
+     *     buscarSugerencias(value);
+     *   }
+     * }}
+     */
+    onChange?: (value: EFWInputValue, displayValue?: string) => void;
+}

package/dist/react-components/fields/EFWInput/EFWInput.utils.d.ts

@@ -0,0 +1,20 @@
+import { EFWInputValue, FormatType } from './EFWInput.types';
+
+interface FormatOptions {
+    formatPattern?: string;
+    formatFunction?: (value: EFWInputValue) => EFWInputValue;
+}
+export declare const formatChileanRut: (rawValue: string) => string;
+export declare const validateChileanRut: (rutCompleto: string) => boolean;
+export declare const validateEmail: (email: string) => boolean;
+export declare const formatNumber: (number: string | number, prefix?: string, thousand_separator?: string, decimal_separator?: string) => string;
+export declare const stripFormatNumber: (value?: string) => string;
+/**
+ * Quita el formato de un valor según el tipo especificado
+ */
+export declare const stripFormatting: (value: string, formatType: FormatType) => string;
+/**
+ * Aplica formato a un valor según el tipo y opciones especificadas
+ */
+export declare const applyFormatting: (value: string, formatType: FormatType, options?: FormatOptions) => string;
+export {};

package/dist/react-components/fields/EFWInput/EFWInput.utils.js

@@ -0,0 +1,84 @@
+const p = (t) => {
+  const n = (t || "").toString(), r = n.replace(/^0+/, "");
+  let e = "";
+  if (r != "" && r.length > 1) {
+    const l = r.replace(/\./g, "").replace(/-/g, ""), s = l.substring(0, l.length - 1);
+    let c = 0, o = 1;
+    for (c = s.length - 1; c >= 0; c--)
+      e = s.charAt(c) + e, o % 3 == 0 && o <= s.length - 1 && (e = "." + e), o++;
+    const g = l.substring(l.length - 1);
+    return e = e + "-" + g, e;
+  } else
+    return n;
+}, u = (t) => {
+  if (t = t || "", t = t.replace(/\./g, ""), !/^[0-9]+[-|‐]{1}[0-9kK]{1}$/.test(t))
+    return !1;
+  const n = t.split("-");
+  let r = n[1];
+  const e = n[0], i = function(l) {
+    let s = 0, c = 1;
+    for (; l; l = Math.floor(l / 10))
+      c = (c + l % 10 * (9 - s++ % 6)) % 11;
+    return c ? c - 1 : "k";
+  };
+  return r == "K" && (r = "k"), i(e) == r;
+}, d = (t) => /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/.test(t), m = (t, n, r = ",", e = ".") => {
+  if (t == null) return "";
+  typeof t == "number" && (t = t.toString(), Number.isInteger(t) || (t = t.replace(".", e))), r = r || ",", e = e || ".";
+  const i = new RegExp("[^" + e + "\\d]", "g"), s = t.replace(i, "").toString().split(e), c = s[0].length % 3;
+  let o = s[0].substr(0, c);
+  const g = s[0].substr(c).match(/\d{3}/g);
+  return g && (o += (c ? r : "") + g.join(r)), o = s[1] != null ? o + e + s[1] : o, n == null ? o : o ? n + o : "";
+}, $ = (t = "") => {
+  const n = t.toString().replace(/[^\d.]/g, "");
+  return isNaN(Number(n)) || n === "" ? "" : n;
+}, f = {
+  none: (t) => t,
+  email: (t) => t,
+  phone: (t) => t.replace(/\D/g, ""),
+  creditCard: (t) => t.replace(/\D/g, ""),
+  chileanRut: (t) => {
+    console.log("value", t, typeof t);
+    const n = t.replace(/[^\dkK-]/gi, ""), r = n.includes("-"), e = n.replace(/-/g, "");
+    if (r && e.length >= 2) {
+      const i = e.length - 1;
+      return e.slice(0, i) + "-" + e.slice(i);
+    }
+    return e;
+  },
+  date: (t) => t.replace(/\D/g, ""),
+  //number: (value) => stripFormatNumber(value || ''),
+  custom: (t) => t.replace(/\D/g, "")
+  // Por defecto, podría personalizarse
+}, a = {
+  none: (t) => t,
+  email: (t) => t,
+  phone: (t) => t.length <= 3 ? t : t.length <= 6 ? `(${t.slice(0, 3)}) ${t.slice(3)}` : `(${t.slice(0, 3)}) ${t.slice(3, 6)}-${t.slice(6, 10)}`,
+  creditCard: (t) => t.replace(/(\d{4})(?=\d)/g, "$1 ").trim(),
+  chileanRut: (t) => p(t),
+  date: (t) => t.length <= 2 ? t : t.length <= 4 ? `${t.slice(0, 2)}/${t.slice(2)}` : `${t.slice(0, 2)}/${t.slice(2, 4)}/${t.slice(4, 8)}`,
+  // number: (value) => {
+  // 	if (isNaN(Number(value))) return value; // Si no es un número válido, retornar el valor original
+  // 	return formatNumber(value)
+  // },
+  custom: (t, n = {}) => {
+    if (n.formatFunction)
+      return n.formatFunction(t) || t;
+    if (n.formatPattern) {
+      let r = "", e = 0;
+      for (let i = 0; i < n.formatPattern.length && e < t.length; i++)
+        n.formatPattern[i] === "#" ? (r += t[e], e++) : (r += n.formatPattern[i], n.formatPattern[i] === t[e] && e++);
+      return r;
+    }
+    return t;
+  }
+}, F = (t, n) => t ? (console.log("FormatType", n), (f[n] || f.none)(t)) : "", y = (t, n, r = {}) => t ? (a[n] || a.none)(t, r) : "";
+export {
+  y as applyFormatting,
+  p as formatChileanRut,
+  m as formatNumber,
+  $ as stripFormatNumber,
+  F as stripFormatting,
+  u as validateChileanRut,
+  d as validateEmail
+};

package/dist/react-components/fields/EFWInput/index.d.ts

@@ -0,0 +1,2 @@
+export { EFWInput } from './EFWInput';
+export type { EFWInputProps, EFWInputValue } from './EFWInput.types';

package/dist/react-components/fields/EFWInput/index.js

@@ -0,0 +1,4 @@
+import { EFWInput as r } from "./EFWInput.js";
+export {
+  r as EFWInput
+};

package/dist/react-components/fields/EFWInputField/EFWInputField.d.ts

@@ -0,0 +1,3 @@
+import { EFWInputFieldProps } from './EFWInputField.types';
+
+export declare const EFWInputField: (props: EFWInputFieldProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react-components/fields/EFWInputField/EFWInputField.js

@@ -0,0 +1,71 @@
+import { jsx as t } from "react/jsx-runtime";
+import { EFWField as q } from "../EFWField/EFWField.js";
+import { EFWInput as w } from "../EFWInput/EFWInput.js";
+const P = (n) => {
+  const {
+    title: a,
+    infoLabel: o,
+    hint: i,
+    style: l = {},
+    size: r,
+    required: d = !1,
+    contentBefore: f,
+    contentAfter: h,
+    minLength: m = 0,
+    maxLength: s = 250,
+    validationState: g,
+    validationMessage: p,
+    value: u = "",
+    editable: e = !0,
+    disabled: c = !1,
+    hidden: C = !1,
+    onChange: F,
+    autoComplete: b = "off",
+    type: x = "text",
+    placeholder: L,
+    formatType: v = "none",
+    formatPattern: y,
+    formatFunction: E,
+    onValidationChange: W
+  } = n;
+  return /* @__PURE__ */ t(
+    q,
+    {
+      style: l,
+      title: a,
+      infoLabel: o,
+      weightLabel: e ? "regular" : "semibold",
+      hint: i,
+      size: r,
+      required: d,
+      validationState: g,
+      validationMessage: p,
+      onValidationChange: W,
+      hidden: C,
+      children: /* @__PURE__ */ t(
+        w,
+        {
+          value: u,
+          editable: e,
+          onChange: (I, j) => {
+            F?.(I, j);
+          },
+          minLength: m,
+          maxLength: s,
+          disabled: c,
+          autoComplete: b,
+          type: x,
+          placeholder: L,
+          contentBefore: f,
+          contentAfter: h,
+          formatType: v,
+          formatPattern: y,
+          formatFunction: E
+        }
+      )
+    }
+  );
+};
+export {
+  P as EFWInputField
+};

package/dist/react-components/fields/EFWInputField/EFWInputField.types.d.ts

@@ -0,0 +1,6 @@
+import { EFWFieldProps } from '../EFWField/EFWField.types';
+import { EFWInputProps, EFWInputValue } from '../EFWInput/EFWInput.types';
+
+export type EFWInputFieldValue = EFWInputValue;
+export interface EFWInputFieldProps extends Omit<EFWFieldProps, 'children'>, EFWInputProps {
+}

package/dist/react-components/fields/EFWInputField/EFWInputField.utils.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/react-components/fields/EFWInputField/index.d.ts

@@ -0,0 +1,2 @@
+export { EFWInputField } from './EFWInputField';
+export type { EFWInputFieldProps, EFWInputFieldValue } from './EFWInputField.types';

package/dist/react-components/fields/EFWInputField/index.js

@@ -0,0 +1,4 @@
+import { EFWInputField as p } from "./EFWInputField.js";
+export {
+  p as EFWInputField
+};

package/dist/react-components/fields/EFWNumberInput/EFWNumberInput.d.ts

@@ -0,0 +1,8 @@
+import { EFWNumberInputProps } from './EFWNumberInput.types';
+
+/**
+ * Componente de entrada numérica personalizada con soporte para formateo y validación.
+ * @param props - Propiedades del componente.
+ * @returns Componente de entrada o texto según el modo editable.
+ */
+export declare const EFWNumberInput: (props: EFWNumberInputProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react-components/fields/EFWNumberInput/EFWNumberInput.js

@@ -0,0 +1,183 @@
+import { jsx as k, Fragment as Z } from "react/jsx-runtime";
+import { makeStyles as ee, tokens as N, mergeClasses as re, Input as te, Text as ne } from "@fluentui/react-components";
+import { useId as ae, useMemo as oe, useState as P, useRef as se, useCallback as B, useEffect as le } from "react";
+import { applyFormatting as p, stripFormatting as x, isValidNumber as H } from "./EFWNumberInput.utils.js";
+const ue = ee({
+  EFWNumberInputError: {
+    backgroundColor: N.colorPaletteRedBackground1,
+    "::after": {
+      borderBottomColor: N.colorPaletteRedBorder2,
+      borderBottomStyle: "solid",
+      borderBottomWidth: "2px"
+    }
+  },
+  EFWNumberInput: {
+    "& [disabled]": {
+      backgroundColor: N.colorNeutralBackground3,
+      color: N.colorNeutralForeground2,
+      "&::placeholder": {
+        color: "transparent"
+      }
+    },
+    "&:has(span + [disabled])": {
+      backgroundColor: N.colorNeutralBackground3
+    }
+  }
+}), ie = () => {
+  const i = /* @__PURE__ */ new Map();
+  return (r, t) => {
+    const $ = `${r}-${t}`;
+    if (!i.has($)) {
+      const E = r.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), g = t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      i.set($, {
+        validation: new RegExp(`^-?[\\d${E}]*${g}?\\d*$`),
+        thousandSeparator: new RegExp(`^\\d+${E}0{1,2}$`),
+        progressPatterns: [
+          new RegExp("^-?$"),
+          new RegExp(`^-?\\d+${g}$`),
+          new RegExp(`^-?\\d+${g}0+$`),
+          new RegExp(`^-?[\\d${E}]+${g}$`),
+          new RegExp(`^-?[\\d${E}]+${g}0+$`)
+        ]
+      });
+    }
+    return i.get($);
+  };
+}, ce = ie(), O = (i, r) => r.some((t) => t.test(i)), de = (i, r) => i.includes(r) && (i.endsWith("0") || i.endsWith(r) || /\.\d*0$/.test(i.replace(r, "."))), he = (i) => {
+  const {
+    value: r,
+    onChange: t,
+    editable: $ = !0,
+    disabled: E = !1,
+    className: g = "",
+    autoComplete: U = "off",
+    placeholder: _,
+    contentBefore: q,
+    contentAfter: G,
+    formatType: a = "number",
+    maxValue: y,
+    minValue: C,
+    validationState: J = "none",
+    setParentComponentState: d,
+    enableFormatting: W = !0,
+    thousandSeparator: v = ",",
+    decimalSeparator: f = "."
+  } = i, D = ue(), T = ae(), o = oe(() => ({
+    enableFormatting: W,
+    thousandSeparator: v,
+    decimalSeparator: f
+  }), [W, v, f]), [c, b] = P(() => p(r ? r.toString() : "", a, o)), [S, w] = P(!1), [V, M] = P(!1), u = se({
+    prevValue: r,
+    lastValidatedValue: "",
+    rawValue: r ? x(r.toString(), a, o) : ""
+  }), h = ce(v, f), F = B((n) => {
+    if (u.current.lastValidatedValue === n)
+      return S;
+    if (u.current.lastValidatedValue = n, a !== "number" || n.length === 0)
+      return d?.("none", ""), !1;
+    if (!h.validation.test(n))
+      return d?.("error", "El valor ingresado no es un número válido."), !0;
+    const s = x(n, a, o);
+    if (O(n, h.progressPatterns))
+      return d?.("none", ""), !1;
+    if (s && !H(s))
+      return d?.("error", "El valor ingresado no es un número válido."), !0;
+    if (s) {
+      const e = Number(s);
+      if (C !== void 0 && e < C)
+        return d?.("error", `El valor debe ser mayor o igual a ${p(C.toString(), "number", o)}.`), !0;
+      if (y !== void 0 && e > y)
+        return d?.("error", `El valor debe ser menor o igual a ${p(y.toString(), "number", o)}.`), !0;
+    }
+    return d?.("none", ""), !1;
+  }, [a, h, d, C, y, o, S]);
+  le(() => {
+    if (r !== u.current.prevValue && !V) {
+      const n = x(r ? r.toString() : "", a, o), s = p(n, a, o);
+      u.current.rawValue = n, u.current.prevValue = r, b(s), w(!1);
+    }
+  }, [r, a, o, V]);
+  const K = B(() => {
+    if (a !== "number" || !V) return;
+    M(!1);
+    let n = c;
+    if (n.endsWith(f) && (n = n.slice(0, -1)), n.includes(f)) {
+      const [e, I] = n.split(f);
+      I && /^0+$/.test(I) && (n = e);
+    }
+    const s = x(n, a, o);
+    if (s && H(s)) {
+      const e = p(s, a, o);
+      u.current.rawValue = s, b(e), w(!1), t?.(Number(s), e);
+    } else (c === "" || c === "-") && (u.current.rawValue = "", b(""), w(!1), t?.(null, ""));
+  }, [c, a, o, t, f, V]), L = B((n, s) => {
+    if (typeof s.value != "string") return;
+    const e = s.value;
+    if (V || M(!0), b(e), e.length < c.length && c.startsWith(e) && h.thousandSeparator.test(e)) {
+      const l = e.replace(new RegExp(v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), ""), R = p(l, a, o), A = F(R);
+      u.current.rawValue = l, b(R), w(A), t?.(A || !l ? null : Number(l), R);
+      return;
+    }
+    const m = x(e, a, o), j = F(e), z = de(e, f), Y = O(e, h.progressPatterns);
+    if (u.current.rawValue = m, w(j), j)
+      if (m && h.validation.test(e))
+        if (z)
+          t?.(Number(m), e);
+        else {
+          const l = p(m, a, o);
+          b(l), t?.(Number(m), l);
+        }
+      else
+        t?.(null, e);
+    else if (m)
+      if (z)
+        t?.(Number(m), e);
+      else {
+        const l = p(m, a, o);
+        b(l), t?.(Number(m), l);
+      }
+    else if (Y) {
+      const l = e.replace(/[^\d-]/g, "");
+      l && l !== "-" ? (u.current.rawValue = l, t?.(Number(l), e)) : (u.current.rawValue = "", t?.(null, e));
+    } else
+      u.current.rawValue = "", t?.(null, "");
+  }, [
+    c,
+    V,
+    h,
+    v,
+    a,
+    o,
+    F,
+    f,
+    t
+  ]), Q = J === "error" || S, X = re(
+    g,
+    D.EFWNumberInput,
+    Q && D.EFWNumberInputError
+  );
+  return /* @__PURE__ */ k(Z, { children: $ ? /* @__PURE__ */ k(
+    te,
+    {
+      className: X,
+      id: T,
+      name: T,
+      type: "text",
+      placeholder: _,
+      contentBefore: q,
+      contentAfter: G,
+      disabled: E,
+      value: c,
+      "data-raw-value": u.current.rawValue,
+      autoComplete: U,
+      autoCorrect: "off",
+      autoCapitalize: "off",
+      spellCheck: "false",
+      onChange: L,
+      onBlur: K
+    }
+  ) : /* @__PURE__ */ k(ne, { style: c ? void 0 : { opacity: 0.7 }, children: c || "Sin datos disponibles" }) });
+};
+export {
+  he as EFWNumberInput
+};