@envisiongroup/porygon 1.0.0-rc.8 → 1.0.0

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

@@ -0,0 +1,339 @@
+import { jsx as O, Fragment as Re } from "react/jsx-runtime";
+import { makeStyles as Fe, tokens as P, mergeClasses as Pe, Text as Me, Input as De } from "@fluentui/react-components";
+import { useId as ke, useRef as U, useMemo as E, useCallback as D, useState as j } from "react";
+import { stripFormatting as k, getNumberInputFormattedValue as H, isValidNumber as pe, applyFormatting as $, createNumberPayloadCharTester as Te } from "./EFWNumberInput.utils.js";
+import { computeCaretAfterReformat as Be } from "../../commons/caretPositioning.js";
+import { useIsomorphicLayoutEffect as We } from "../../hooks/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.js";
+import { useFieldsLocaleText as ze } from "../../i18n/PorygonI18nProvider.js";
+const Le = Fe({
+  EFWNumberInputError: {
+    backgroundColor: P.colorPaletteRedBackground1,
+    "::after": {
+      borderBottomColor: P.colorPaletteRedBorder2,
+      borderBottomStyle: "solid",
+      borderBottomWidth: "2px"
+    }
+  },
+  EFWNumberInput: {
+    "& [disabled]": {
+      backgroundColor: P.colorNeutralBackground3,
+      color: P.colorNeutralForeground2,
+      "&::placeholder": {
+        color: "transparent"
+      }
+    },
+    "&:has(span + [disabled])": {
+      backgroundColor: P.colorNeutralBackground3
+    }
+  }
+}), Ae = () => {
+  const i = /* @__PURE__ */ new Map();
+  return (o, g) => {
+    const a = `${o}-${g}`;
+    if (!i.has(a)) {
+      const N = o.replace(
+        /[.*+?^${}()|[\]\\]/g,
+        "\\$&"
+      ), V = g.replace(
+        /[.*+?^${}()|[\]\\]/g,
+        "\\$&"
+      );
+      i.set(a, {
+        validation: new RegExp(
+          `^-?[\\d${N}]*${V}?\\d*$`
+        ),
+        thousandSeparator: new RegExp(`^\\d+${N}0{1,2}$`),
+        progressPatterns: [
+          /^-?$/,
+          new RegExp(`^-?\\d+${V}$`),
+          new RegExp(`^-?\\d+${V}0+$`),
+          new RegExp(`^-?[\\d${N}]+${V}$`),
+          new RegExp(`^-?[\\d${N}]+${V}0+$`)
+        ]
+      });
+    }
+    return i.get(a);
+  };
+}, Oe = Ae(), fe = (i, o) => o.some((g) => g.test(i)), Ue = (i, o) => i.includes(o) && (i.endsWith("0") || i.endsWith(o) || /\.\d*0$/.test(i.replace(o, "."))), Ze = (i) => {
+  const {
+    value: o,
+    defaultValue: g,
+    onChange: a,
+    editable: N = !0,
+    disabled: V = !1,
+    className: be = "",
+    autoComplete: ge = "off",
+    contentBefore: Ve,
+    contentAfter: he,
+    formatType: c = "number",
+    maxValue: C,
+    minValue: I,
+    validationState: ve = "none",
+    setParentComponentState: m,
+    enableFormatting: q = !0,
+    thousandSeparator: y = ",",
+    decimalSeparator: p = ".",
+    labels: G,
+    readOnlyRenderer: Ne,
+    validationMessages: T
+  } = i, w = g ?? null, J = Le(), K = ke(), Q = U(null), B = U(
+    null
+  ), W = o !== void 0, M = W ? o ?? null : g ?? null, l = E(
+    () => ({
+      enableFormatting: q,
+      thousandSeparator: y,
+      decimalSeparator: p
+    }),
+    [q, y, p]
+  ), X = ze(), Y = X.numberInput.labels, z = X.numberInput.validationMessages, Z = Y.placeholder, _ = Y.emptyState, ee = G?.placeholder, te = G?.emptyState, re = E(() => ({
+    placeholder: ee ?? Z,
+    emptyState: te ?? _
+  }), [
+    ee,
+    te,
+    Z,
+    _
+  ]), ae = z.invalidNumber, le = z.minValue, ne = z.maxValue, oe = T?.invalidNumber, se = T?.minValue, ue = T?.maxValue, S = E(() => ({
+    invalidNumber: oe ?? ae,
+    minValue: se ?? le,
+    maxValue: ue ?? ne
+  }), [
+    oe,
+    se,
+    ue,
+    ae,
+    le,
+    ne
+  ]), R = D(
+    (t) => t === null ? "" : k(t.toString(), c, l),
+    [c, l]
+  ), ye = E(
+    () => R(M),
+    [R, M]
+  ), we = E(
+    () => R(w),
+    [R, w]
+  ), xe = E(
+    () => H(w, l),
+    [w, l]
+  ), [d, b] = j(() => H(M, l)), [L, h] = j(!1), [x, ce] = j(!1), n = U({
+    prevValue: M,
+    lastValidatedValue: "",
+    rawValue: ye
+  }), v = Oe(y, p), F = D(
+    (t) => {
+      if (n.current.lastValidatedValue === t)
+        return L;
+      if (n.current.lastValidatedValue = t, c !== "number" || t.length === 0)
+        return m?.("none", ""), !1;
+      if (!v.validation.test(t))
+        return m?.(
+          "error",
+          S.invalidNumber
+        ), !0;
+      const r = k(t, c, l);
+      if (fe(t, v.progressPatterns))
+        return m?.("none", ""), !1;
+      if (r && !pe(r))
+        return m?.(
+          "error",
+          S.invalidNumber
+        ), !0;
+      if (r) {
+        const e = Number(r);
+        if (I !== void 0 && e < I) {
+          const s = $(
+            I.toString(),
+            "number",
+            l
+          );
+          return m?.(
+            "error",
+            S.minValue(I, s)
+          ), !0;
+        }
+        if (C !== void 0 && e > C) {
+          const s = $(
+            C.toString(),
+            "number",
+            l
+          );
+          return m?.(
+            "error",
+            S.maxValue(C, s)
+          ), !0;
+        }
+      }
+      return m?.("none", ""), !1;
+    },
+    [
+      c,
+      v,
+      m,
+      I,
+      C,
+      l,
+      L,
+      S
+    ]
+  );
+  W ? o !== n.current.prevValue && !x && (n.current.rawValue = R(o ?? null), n.current.prevValue = o ?? null, b(
+    H(o ?? null, l)
+  ), h(!1)) : !x && n.current.prevValue !== w && (n.current.rawValue = we, n.current.prevValue = w, b(xe), h(!1));
+  const Ee = D(() => {
+    if (c !== "number" || !x) return;
+    ce(!1);
+    let t = d;
+    if (t.endsWith(p) && (t = t.slice(0, -1)), t.includes(p)) {
+      const [e, s] = t.split(p);
+      s && /^0+$/.test(s) && (t = e);
+    }
+    const r = k(
+      t,
+      c,
+      l
+    );
+    if (r && pe(r)) {
+      const e = $(
+        r,
+        c,
+        l
+      );
+      n.current.rawValue = r, b(e), h(!1), a?.(Number(r), e);
+    } else d === "" || d === "-" ? (n.current.rawValue = "", b(""), h(!1), a?.(null, "")) : (F(d), h(!0), a?.(null, d));
+  }, [
+    d,
+    c,
+    l,
+    a,
+    p,
+    x,
+    F
+  ]), $e = D(
+    (t, r) => {
+      if (typeof r.value != "string") return;
+      const e = r.value, s = t.currentTarget?.selectionStart;
+      if (B.current = typeof s == "number" ? { caret: s, typed: e } : null, x || ce(!0), b(e), e.length < d.length && d.startsWith(e) && v.thousandSeparator.test(e)) {
+        const u = e.replace(
+          new RegExp(
+            y.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+            "g"
+          ),
+          ""
+        ), A = $(
+          u,
+          c,
+          l
+        ), me = F(A);
+        n.current.rawValue = u, b(A), h(me), a?.(
+          me || !u ? null : Number(u),
+          A
+        );
+        return;
+      }
+      const f = k(
+        e,
+        c,
+        l
+      ), ie = F(e), de = Ue(
+        e,
+        p
+      ), Se = fe(
+        e,
+        v.progressPatterns
+      );
+      if (n.current.rawValue = f, h(ie), ie)
+        if (f && v.validation.test(e))
+          if (de)
+            a?.(Number(f), e);
+          else {
+            const u = $(
+              f,
+              c,
+              l
+            );
+            b(u), a?.(Number(f), u);
+          }
+        else
+          a?.(null, e);
+      else if (f)
+        if (de)
+          a?.(Number(f), e);
+        else {
+          const u = $(
+            f,
+            c,
+            l
+          );
+          b(u), a?.(Number(f), u);
+        }
+      else if (Se) {
+        const u = e.replace(/[^\d-]/g, "");
+        u && u !== "-" ? (n.current.rawValue = u, a?.(Number(u), e)) : (n.current.rawValue = "", a?.(null, e));
+      } else
+        n.current.rawValue = "", a?.(null, "");
+    },
+    [
+      d,
+      x,
+      v,
+      y,
+      c,
+      l,
+      F,
+      p,
+      a
+    ]
+  );
+  We(() => {
+    const t = B.current;
+    if (!t) return;
+    B.current = null;
+    const r = Q.current;
+    if (!r || document.activeElement !== r || r.value === t.typed) return;
+    const e = Be({
+      previousCaret: t.caret,
+      typedValue: t.typed,
+      nextFormatted: r.value,
+      isPayloadChar: Te(y)
+    }), s = Math.max(0, Math.min(e, r.value.length));
+    r.setSelectionRange(s, s);
+  });
+  const Ce = ve === "error" || L, Ie = Pe(
+    be,
+    J.EFWNumberInput,
+    Ce && J.EFWNumberInputError
+  );
+  if (!N) {
+    const t = n.current.rawValue === "" ? null : Number(n.current.rawValue), r = W ? o ?? null : t !== null && Number.isNaN(t) ? null : t, e = d || re.emptyState, s = Ne?.(
+      r,
+      e
+    );
+    return s != null ? /* @__PURE__ */ O(Re, { children: s }) : /* @__PURE__ */ O(Me, { style: d ? void 0 : { opacity: 0.7 }, children: e });
+  }
+  return /* @__PURE__ */ O(
+    De,
+    {
+      ref: Q,
+      className: Ie,
+      id: K,
+      name: K,
+      type: "text",
+      placeholder: re.placeholder,
+      contentBefore: Ve,
+      contentAfter: he,
+      disabled: V,
+      value: d,
+      "data-raw-value": n.current.rawValue,
+      autoComplete: ge,
+      autoCorrect: "off",
+      autoCapitalize: "off",
+      spellCheck: "false",
+      onChange: $e,
+      onBlur: Ee
+    }
+  );
+};
+export {
+  Ze as EFWNumberInput
+};

package/dist/react-components/fields/{EFWNumberInput → NumberInput}/EFWNumberInput.types.d.ts

@@ -1,7 +1,18 @@
-import { EFWFieldChildrenProps } from '../EFWField/EFWField.types';
+import { EFWFieldChildrenProps } from '../_shared/EFWField/EFWField.types';
+import { ReactNode } from 'react';
 
 export type EFWNumberInputValue = number | null;
 export type FormatType = 'number';
+export type EFWNumberInputNonEditableRenderer = (value: EFWNumberInputValue, displayValue: string) => ReactNode;
+export interface EFWNumberInputLabels {
+    placeholder?: string;
+    emptyState?: string;
+}
+export interface EFWNumberInputValidationMessages {
+    invalidNumber?: string;
+    minValue?: (minValue: number, formattedMinValue: string) => string;
+    maxValue?: (maxValue: number, formattedMaxValue: string) => string;
+}
 export interface EFWNumberInputProps extends Partial<EFWFieldChildrenProps> {
     /**
      * Contenido mostrado antes del campo de entrada.
@@ -49,17 +60,6 @@ export interface EFWNumberInputProps extends Partial<EFWFieldChildrenProps> {
      * 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;
     /**
      * Valor actual del campo de entrada.
      * Puede ser un número o null para campos vacíos.
@@ -131,6 +131,25 @@ export interface EFWNumberInputProps extends Partial<EFWFieldChildrenProps> {
      * @returns Valor formateado o el valor original si no se puede formatear
      */
     formatFunction?: (value: EFWNumberInputValue) => EFWNumberInputValue;
+    /**
+     * Textos personalizables de la UI del campo.
+     *
+     * @example
+     * labels={{ placeholder: "Ingrese un monto", emptyState: "Sin datos" }}
+     */
+    labels?: EFWNumberInputLabels;
+    /**
+     * Renderiza contenido custom cuando `editable={false}`.
+     * Si retorna `null` o `undefined`, se utiliza el render no editable por defecto.
+     */
+    readOnlyRenderer?: EFWNumberInputNonEditableRenderer;
+    /**
+     * Mensajes de validación personalizados para reglas numéricas.
+     *
+     * @example
+     * validationMessages={{ invalidNumber: "Número inválido", minValue: (min) => `Mínimo ${min}` }}
+     */
+    validationMessages?: EFWNumberInputValidationMessages;
     /**
      * Callback ejecutado cuando el valor del campo cambia.
      * Recibe tanto el valor sin formato como el valor mostrado al usuario.
@@ -147,8 +166,8 @@ export interface EFWNumberInputProps extends Partial<EFWFieldChildrenProps> {
      *
      * @example
      * onChange={(value) => {
-     *   if (value && value.length >= 3) {
-     *     buscarSugerencias(value);
+     *   if (value !== null && value >= 100) {
+     *     recalcularTotales(value);
      *   }
      * }}
      */

package/dist/react-components/fields/{EFWNumberInput → NumberInput}/EFWNumberInput.utils.d.ts

@@ -1,4 +1,5 @@
-import { FormatType } from './EFWNumberInput.types';
+import { PayloadCharTester } from '../../commons/caretPositioning';
+import { EFWNumberInputValue, FormatType } from './EFWNumberInput.types';
 
 interface FormatOptions {
     /** Habilita o deshabilita el formateo (por defecto: true) */
@@ -23,19 +24,6 @@ interface FormatOptions {
  * formatNumber("-1234.56", undefined, ".", ",") // "-1.234,56"
  */
 export declare const formatNumber: (input: string | number, prefix?: string, thousandSeparator?: string, decimalSeparator?: string) => string;
-/**
- * Elimina el formato numérico de una cadena, normalizando el separador decimal a ".".
- * Maneja prefijos, paréntesis contables y separadores de miles.
- *
- * @param value Cadena con el número formateado (ej. "$1,234.56").
- * @param decimalSeparator Separador decimal usado en la entrada (por defecto: ".").
- * @param thousandSeparator Separador de miles usado en la entrada (por defecto: ",").
- * @returns Cadena con dígitos, un punto decimal y un posible signo negativo; vacía si no es válida.
- * @example
- * stripFormatNumber("$1,234.56") // "1234.56"
- * stripFormatNumber("(1.234,56)", ",", ".") // "-1234.56"
- */
-export declare const stripFormatNumber: (value?: string, decimalSeparator?: string, thousandSeparator?: string) => string;
 /**
  * Elimina el formato de una cadena según el tipo de formato especificado.
  *
@@ -71,4 +59,22 @@ export declare const applyFormatting: (value: string, formatType: FormatType, op
  * isValidNumber("") // false
  */
 export declare const isValidNumber: (str: string) => boolean;
+/**
+ * Crea el predicado de "payload" para inputs numéricos: la única decoración que
+ * el formato inserta/remueve es el separador de miles, por lo que cualquier otro
+ * carácter (dígitos, signo `-`, separador decimal) cuenta como dato real escrito.
+ *
+ * Se usa junto con `computeCaretAfterReformat` (commons) para reubicar el caret
+ * tras un reflujo de separadores y evitar que salte al final del valor.
+ */
+export declare const createNumberPayloadCharTester: (thousandSeparator?: string) => PayloadCharTester;
+/**
+ * Retorna el valor formateado que EFWNumberInput muestra cuando no está en modo editable.
+ * Combina stripFormatting + applyFormatting en una sola llamada.
+ */
+export declare const getNumberInputFormattedValue: (value: EFWNumberInputValue | undefined, options?: {
+    enableFormatting?: boolean;
+    thousandSeparator?: string;
+    decimalSeparator?: string;
+}) => string;
 export {};

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

@@ -0,0 +1,86 @@
+const R = (e, n, i = ",", t = ".") => {
+  const p = (s) => s == null, m = (s) => s.length <= 3 ? s : s.replace(/\B(?=(\d{3})+(?!\d))/g, i), b = (s) => s.replace(/^0+(?=\d)/, "") || "0", d = (s) => /[^0]/.test(s) && s.replace(/0+$/, "") || "0";
+  if (p(e) || typeof e == "number" && !Number.isFinite(e)) return "";
+  if (typeof e == "number") {
+    const s = e < 0, c = Math.abs(e);
+    let [h, g = ""] = c.toString().split(".");
+    if (/[eE]/.test(g)) {
+      const M = c.toFixed(20).replace(/0+$/, "");
+      [h, g = ""] = M.split(".");
+    }
+    h = b(h), g = g && d(g);
+    let a = m(h);
+    return g && (a += t + g), s && (a = "-" + a), n && a && (a = n + a), a;
+  }
+  let r = e.trim();
+  if (!r) return "";
+  let u = !1;
+  /^\(.*\)$/.test(r) && (r = r.slice(1, -1));
+  const $ = r.match(/^-+/);
+  if ($ && (u = $[0].length === 1, r = r.slice($[0].length)), /^[+-]?\d*\.?\d+e[+-]?\d+$/i.test(r)) {
+    const s = Number(r);
+    let c = R(
+      s,
+      void 0,
+      i,
+      t
+    );
+    return /\.\d$/.test(c) && (c = c.replace(new RegExp(`\\${t}0$`), "")), u && (c = "-" + c), n && c && (c = n + c), c;
+  }
+  const l = r.replace(/[^\d.,]/g, "");
+  if (!/\d/.test(l)) return "";
+  const I = l.lastIndexOf(","), w = l.lastIndexOf(".");
+  let o = Math.max(I, w);
+  o > -1 && /^\d{3}$/.test(l.slice(o + 1)) && l.slice(0, o).includes(l[o]) && (o = -1);
+  const D = o === -1 ? l : l.slice(0, o), F = o === -1 ? "" : l.slice(o + 1), E = b(D.replace(/[.,]/g, "")), N = F ? d(F.replace(/[^\d]/g, "")) : "";
+  let f = m(E);
+  return N ? f += t + N : r.endsWith(t) && (f += t), u && (f = "-" + f), n && f && (f = n + f), f;
+}, C = (e = "", n = ".", i = ",") => {
+  if (!e || typeof e != "string") return "";
+  let t = e.trim();
+  if (!t) return "";
+  let p = !1;
+  /^\(.*\)$/.test(t) && (p = !0, t = t.slice(1, -1));
+  const m = t.match(/^-+/);
+  m && (p = m[0].length % 2 === 1, t = t.slice(m[0].length)), t = t.replace(/^[^\d.,-]+|[^\d.,-]+$/g, "");
+  const b = (r) => r.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (i) {
+    const r = new RegExp(b(i), "g");
+    t = t.replace(r, "");
+  }
+  if (n && n !== ".") {
+    const r = new RegExp(b(n), "g"), u = t.lastIndexOf(n);
+    u !== -1 && (t = t.slice(0, u).replace(r, "") + "." + t.slice(u + n.length));
+  }
+  t = t.replace(/[^\d.-]/g, "");
+  const d = t.split(".");
+  return d.length > 2 && (t = d.shift() + "." + d.join("")), t = t.replace(/^-+/, "-").replace(/(?!^)-/g, ""), /^\d+(\.\d+)?$/.test(t.replace(/^-/, "")) ? (t[t.length - 1] === n && (t = t.slice(0, -1)), p && (t = "-" + t), t) : "";
+}, y = {
+  number: (e, n) => C(
+    e || "",
+    n?.decimalSeparator || ".",
+    n?.thousandSeparator || ","
+  )
+}, x = {
+  number: (e, n) => n?.enableFormatting === !1 || isNaN(Number(e)) ? e : R(
+    e,
+    void 0,
+    n?.thousandSeparator || ",",
+    n?.decimalSeparator || "."
+  )
+}, O = (e, n, i = {}) => e ? (y[n] || y.number)(e, i) : "", P = (e, n, i = {}) => e ? (x[n] || x.number)(e, i) : "", V = (e) => {
+  const n = e.trim();
+  return n === "" ? !1 : /^-?\d+(\.\d*)?$/.test(n);
+}, j = (e = ",") => (n) => n !== e, z = (e, n) => {
+  if (e == null) return "";
+  const i = typeof e == "number" ? String(e) : O(String(e), "number", n ?? {});
+  return P(i, "number", n ?? {});
+};
+export {
+  P as applyFormatting,
+  j as createNumberPayloadCharTester,
+  R as formatNumber,
+  z as getNumberInputFormattedValue,
+  V as isValidNumber,
+  O as stripFormatting
+};

package/dist/react-components/fields/NumberInput/EFWNumberInputField.js

@@ -0,0 +1,84 @@
+import { jsx as a } from "react/jsx-runtime";
+import { EFWField as O } from "../_shared/EFWField/EFWField.js";
+import { EFWNumberInput as P } from "./EFWNumberInput.js";
+import { mergeClasses as R } from "@griffel/react";
+const G = (t) => {
+  const {
+    title: n,
+    infoLabel: o,
+    hint: l,
+    className: r,
+    style: i = {},
+    required: s = !1,
+    contentBefore: m,
+    contentAfter: d,
+    minValue: u,
+    maxValue: f,
+    validationState: p,
+    validationMessage: c,
+    validationMessageIcon: b,
+    value: g,
+    defaultValue: h,
+    editable: e = !0,
+    disabled: C = !1,
+    hidden: F = !1,
+    onChange: v,
+    autoComplete: N = "off",
+    formatType: I = "number",
+    formatFunction: V,
+    enableFormatting: x = !0,
+    thousandSeparator: y,
+    decimalSeparator: E,
+    labels: M,
+    readOnlyRenderer: S,
+    validationMessages: W,
+    onValidationChange: w,
+    ...L
+  } = t, j = (A, B) => {
+    v?.(A, B);
+  }, q = R(r, "efw-numberInput-field");
+  return /* @__PURE__ */ a(
+    O,
+    {
+      className: q,
+      style: i,
+      title: n,
+      infoLabel: o,
+      weightLabel: e ? "regular" : "semibold",
+      hint: l,
+      required: s,
+      validationState: p,
+      validationMessage: c,
+      validationMessageIcon: b,
+      onValidationChange: w,
+      hidden: F,
+      ...L,
+      children: /* @__PURE__ */ a(
+        P,
+        {
+          value: g,
+          defaultValue: h,
+          editable: e,
+          onChange: j,
+          disabled: C,
+          autoComplete: N,
+          contentBefore: m,
+          contentAfter: d,
+          formatType: I,
+          formatFunction: V,
+          enableFormatting: x,
+          minValue: u,
+          maxValue: f,
+          thousandSeparator: y,
+          decimalSeparator: E,
+          labels: M,
+          readOnlyRenderer: S,
+          validationMessages: W
+        }
+      )
+    }
+  );
+};
+export {
+  G as EFWNumberInputField
+};

package/dist/react-components/fields/{EFWNumberInputField → NumberInput}/EFWNumberInputField.types.d.ts

@@ -1,5 +1,5 @@
-import { EFWFieldProps } from '../EFWField/EFWField.types';
-import { EFWNumberInputProps, EFWNumberInputValue } from '../EFWNumberInput/EFWNumberInput.types';
+import { EFWFieldProps } from '../_shared/EFWField/EFWField.types';
+import { EFWNumberInputProps, EFWNumberInputValue } from './EFWNumberInput.types';
 
 export type EFWNumberInputFieldValue = EFWNumberInputValue;
 export interface EFWNumberInputFieldProps extends Omit<EFWFieldProps, 'children'>, EFWNumberInputProps {

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

@@ -0,0 +1,5 @@
+export { EFWNumberInput } from './EFWNumberInput';
+export { getNumberInputFormattedValue } from './EFWNumberInput.utils';
+export type { EFWNumberInputProps, EFWNumberInputValue, EFWNumberInputNonEditableRenderer } from './EFWNumberInput.types';
+export { EFWNumberInputField } from './EFWNumberInputField';
+export type { EFWNumberInputFieldProps, EFWNumberInputFieldValue } from './EFWNumberInputField.types';

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

@@ -0,0 +1,8 @@
+import { EFWNumberInput as t } from "./EFWNumberInput.js";
+import { getNumberInputFormattedValue as o } from "./EFWNumberInput.utils.js";
+import { EFWNumberInputField as p } from "./EFWNumberInputField.js";
+export {
+  t as EFWNumberInput,
+  p as EFWNumberInputField,
+  o as getNumberInputFormattedValue
+};