@envisiongroup/porygon 0.1.0-rc.2 → 0.1.0-rc.4

package/dist/react-components/tables/EFWTable/EFWTable.js

@@ -1,19 +1,19 @@
-import { jsx as b, jsxs as yt } from "react/jsx-runtime";
-import * as re from "react";
-import { useRef as P, useState as q, useMemo as I, useEffect as T, useCallback as M } from "react";
-import { useReactTable as ce, getSortedRowModel as oe, getFilteredRowModel as ie, getCoreRowModel as ae } from "@tanstack/react-table";
-import { makeStyles as le, tokens as Y, mergeClasses as ue, Checkbox as wt, Card as de } from "@fluentui/react-components";
-import { useTableSelection as fe } from "./hooks/useTableSelection/useTableSelection.js";
-import { renderCellContent as me } from "./utils/index.js";
-import { useDefaultAddButton as he } from "./hooks/useDefaultAddButton/useDefaultAddButton.js";
-import { useDefaultUpdateButton as ge } from "./hooks/useDefaultUpdateButton/useDefaultUpdateButton.js";
-import { useDefaultDeleteButton as pe } from "./hooks/useDefaultDeleteButton/useDefaultDeleteButton.js";
-import { generateId as y } from "./utils/general.js";
-import { EFWTableCommandBar as Se } from "./components/EFWTableCommandBar/EFWTableCommandBar.js";
-import { EFWTableHeader as ye } from "./components/EFWTableHeader/EFWTableHeader.js";
-import { EFWTableBody as we } from "./components/EFWTableBody/EFWTableBody.js";
-import { EFWTableEmpty as xe } from "./components/EFWTableEmpty/EFWTableEmpty.js";
-const j = {}, ze = /* @__PURE__ */ new Set(), be = [], v = [], f = 120, _ = 80, Q = 2500, A = 48, De = 48, Ee = le({
+import { jsx as v, jsxs as Ye } from "react/jsx-runtime";
+import * as xt from "react";
+import { useRef as B, useState as q, useCallback as R, useEffect as T, useMemo as F } from "react";
+import { useReactTable as wt, getSortedRowModel as yt, getFilteredRowModel as It, getCoreRowModel as zt } from "@tanstack/react-table";
+import { makeStyles as bt, tokens as K, mergeClasses as Et, Checkbox as $e, Card as Ct } from "@fluentui/react-components";
+import { useTableSelection as vt } from "./hooks/useTableSelection/useTableSelection.js";
+import { renderCellContent as Rt } from "./utils/index.js";
+import { useDefaultAddButton as Mt } from "./hooks/useDefaultAddButton/useDefaultAddButton.js";
+import { useDefaultUpdateButton as Nt } from "./hooks/useDefaultUpdateButton/useDefaultUpdateButton.js";
+import { useDefaultDeleteButton as Wt } from "./hooks/useDefaultDeleteButton/useDefaultDeleteButton.js";
+import { generateId as E } from "./utils/general.js";
+import { EFWTableCommandBar as kt } from "./components/EFWTableCommandBar/EFWTableCommandBar.js";
+import { EFWTableHeader as Tt } from "./components/EFWTableHeader/EFWTableHeader.js";
+import { EFWTableBody as _t } from "./components/EFWTableBody/EFWTableBody.js";
+import { EFWTableEmpty as At } from "./components/EFWTableEmpty/EFWTableEmpty.js";
+const G = {}, Bt = /* @__PURE__ */ new Set(), qe = [], X = [], x = 120, _ = 80, J = 2500, O = 48, Qt = 48, Ft = bt({
   "efw-table": {},
   /* Transición suave para el box-shadow en las celdas y cabeceras fijas */
   "efw-table-scroll-container": {
@@ -23,7 +23,7 @@ const j = {}, ze = /* @__PURE__ */ new Set(), be = [], v = [], f = 120, _ = 80,
       transform: "translateZ(0)"
     },
     "& .table-header": {
-      boxShadow: `0px 1px 0 0px ${Y.colorNeutralStroke2}`
+      boxShadow: `0px 1px 0 0px ${K.colorNeutralStroke2}`
     },
     "& .header-cell": {
       "&.sticky-column": {
@@ -57,540 +57,621 @@ const j = {}, ze = /* @__PURE__ */ new Set(), be = [], v = [], f = 120, _ = 80,
       }
     }
   }
-}), Le = ({
-  appearance: xt = "outline",
-  style: zt = {},
-  className: bt = "",
-  fields: a,
-  items: B = be,
-  height: V = 700,
-  itemSize: Et = 32,
+}), Ut = ({
+  appearance: Ge = "outline",
+  style: Xe = {},
+  className: Je = "",
+  fields: f,
+  items: te,
+  defaultItems: Ke,
+  height: ne = 700,
+  itemSize: Ve = 32,
   // tableStyle = 'row',
-  enableSelection: S = !0,
-  enableCommandBar: $ = !0,
-  defaultSelectedItems: Rt = ze,
-  onSelectionChange: Mt,
-  onRowClick: G,
-  resizableColumns: X = !1,
-  columnSizing: C = j,
-  useVirtualization: Ct = !1,
-  autoSizeColumns: N = !1,
-  tableRef: Nt,
-  onItemsChange: Wt,
-  onScroll: U,
-  addButtonConfig: kt = j,
-  updateButtonConfig: It = j,
-  deleteButtonConfig: Tt = j,
-  alwaysButtons: tt = v,
-  noSelectionButtons: _t = v,
-  singleSelectionButtons: At = v,
-  multiSelectionButtons: et = v,
-  beforeAddItems: F,
-  beforeUpdateItems: O,
+  enableSelection: I = !0,
+  enableCommandBar: V = !0,
+  defaultSelectedItems: Ze = Bt,
+  onSelectionChange: Qe,
+  onRowClick: Z,
+  resizableColumns: Q = !1,
+  columnSizing: z = G,
+  useVirtualization: Ue = !1,
+  autoSizeColumns: M = !1,
+  tableRef: et,
+  onItemsChange: se,
+  onScroll: re,
+  addButtonConfig: tt = G,
+  updateButtonConfig: nt = G,
+  deleteButtonConfig: st = G,
+  alwaysButtons: ie = X,
+  noSelectionButtons: rt = X,
+  singleSelectionButtons: it = X,
+  multiSelectionButtons: ce = X,
+  beforeAddItems: L,
+  beforeUpdateItems: D,
   beforeDeleteItems: H,
-  columnRenderers: Bt,
-  useDefaultRendererAsFallback: Ft = !0
+  columnRenderers: oe,
+  useDefaultRendererAsFallback: ae = !0
 }) => {
-  const nt = Ee(), Ot = ue(bt, nt["efw-table"]), W = P(!1), [E, Ht] = q(
-    () => B.map((t) => ({
-      ...t,
-      id: t.id || y()
-    }))
-  ), [u, J] = q(() => {
-    const t = {};
-    return a.forEach((e) => {
-      const n = C[e.internalName];
+  const le = Ft(), ct = Et(Je, le["efw-table"]), N = B(!1), ue = te !== void 0, [ot, at] = q(() => (Ke || qe).map((t) => ({
+    ...t,
+    id: t.id || E()
+  }))), b = ue ? te || qe : ot, [S, j] = q(() => {
+    const e = {};
+    return f.forEach((t) => {
+      const n = z[t.internalName];
       if (n?.width) {
-        const s = n.minWidth ?? _, r = n.maxWidth ?? Q;
-        t[e.internalName] = Math.min(Math.max(n.width ?? 0, s), r);
+        const s = n.minWidth ?? _, i = n.maxWidth ?? J;
+        e[t.internalName] = Math.min(Math.max(n.width ?? 0, s), i);
       }
-    }), t;
-  }), [w, st] = q(0), {
-    rowSelection: R,
-    setRowSelection: rt,
+    }), e;
+  }), de = B(z), [C, fe] = q(0), {
+    rowSelection: W,
+    setRowSelection: he,
     // selectedIndexes,
-    deselectAll: ct,
-    selectSingle: ot,
-    toggleMultiple: Dt,
+    deselectAll: me,
+    selectSingle: pe,
+    toggleMultiple: lt,
     // selectMultiple,
-    getSelectedItems: it,
-    getSelectedRows: at
-  } = fe({
-    initialSelection: Rt,
-    onSelectionChange: Mt,
-    enableSelection: S
-  }), K = P(null), h = P(E), lt = P(/* @__PURE__ */ new Set()), ut = I(() => {
-    const t = [], e = {};
+    getSelectedItems: ge,
+    getSelectedRows: Se
+  } = vt({
+    initialSelection: Ze,
+    onSelectionChange: Qe,
+    enableSelection: I
+  }), xe = B(null), [P, ut] = q(null), dt = R((e) => {
+    xe.current = e, ut(e);
+  }, []), p = B(b);
+  T(() => {
+    p.current = b;
+  }, [b]);
+  const U = B(/* @__PURE__ */ new Set()), we = F(() => {
+    const e = [], t = {};
     let n = 0;
-    return S && (t.push("select"), e.select = n, n += A), a.forEach((s) => {
-      const r = C[s.internalName] || {};
-      if (r.sticky) {
-        t.push(s.internalName), e[s.internalName] = n;
-        const c = u[s.internalName] || r.width || f;
-        n += c;
+    return I && (e.push("select"), t.select = n, n += O), f.forEach((s) => {
+      const i = z[s.internalName] || {};
+      if (i.sticky) {
+        e.push(s.internalName), t[s.internalName] = n;
+        const r = S[s.internalName] || i.width || x;
+        n += r;
       }
-    }), { stickyColumns: t, stickyPositions: e };
-  }, [a, S, C, u]), g = I(() => {
-    const t = [];
-    return S && t.push({
+    }), { stickyColumns: e, stickyPositions: t };
+  }, [f, I, z, S]), w = F(() => {
+    const e = [];
+    return I && e.push({
       id: "select",
-      header: ({ table: e }) => /* @__PURE__ */ b(
-        wt,
+      header: ({ table: t }) => /* @__PURE__ */ v(
+        $e,
         {
           shape: "circular",
-          checked: e.getIsAllRowsSelected(),
-          onChange: e.getToggleAllRowsSelectedHandler(),
+          checked: t.getIsAllRowsSelected(),
+          onChange: t.getToggleAllRowsSelectedHandler(),
           "data-checkbox": "true"
         }
       ),
-      cell: ({ row: e }) => /* @__PURE__ */ b(
-        wt,
+      cell: ({ row: t }) => /* @__PURE__ */ v(
+        $e,
         {
           shape: "circular",
-          checked: e.getIsSelected(),
+          checked: t.getIsSelected(),
           onChange: (n) => {
-            n.stopPropagation(), Dt(e.index);
+            n.stopPropagation(), lt(t.index);
           },
           onClick: (n) => n.stopPropagation(),
           "data-checkbox": "true"
         }
       ),
-      size: A,
-      minSize: A,
-      maxSize: A,
+      size: O,
+      minSize: O,
+      maxSize: O,
       enableResizing: !1
-    }), a.forEach((e) => {
-      const n = C[e.internalName] || {}, s = e.typeAsString === "Note" ? f * 2 : f, r = n.width || s, c = n.minWidth || _, o = n.maxWidth || Q;
-      t.push({
-        id: e.internalName,
-        accessorKey: e.internalName,
-        header: e.title || e.internalName,
-        cell: ({ row: i }) => me(
-          e,
-          i.original[e.internalName],
-          i.original,
-          i.index,
-          Bt,
-          Ft
+    }), f.forEach((t) => {
+      const n = z[t.internalName] || {}, s = t.typeAsString === "Note" ? x * 2 : x, i = n.width || s, r = n.minWidth || _, a = n.maxWidth || J;
+      e.push({
+        id: t.internalName,
+        accessorKey: t.internalName,
+        header: t.title || t.internalName,
+        cell: ({ row: c }) => Rt(
+          t,
+          c.original[t.internalName],
+          c.original,
+          c.index,
+          oe,
+          ae
         ),
-        size: Math.min(Math.max(r, c), o),
-        minSize: c,
-        maxSize: o,
-        enableResizing: X
+        size: Math.min(Math.max(i, r), a),
+        minSize: r,
+        maxSize: a,
+        enableResizing: Q
       });
-    }), t;
-  }, [a, S, X, C]), D = I(() => g.reduce((t, e) => {
-    const s = a.find((c) => c.internalName === e.id)?.typeAsString === "Note" ? f * 2 : f, r = u[e.id] || (typeof e.size == "number" ? e.size : s);
-    return t + r;
-  }, 0), [g, u, a]), dt = ce({
-    data: E,
-    columns: g,
+    }), e;
+  }, [
+    f,
+    I,
+    Q,
+    z,
+    oe,
+    ae
+  ]);
+  T(() => {
+    const e = de.current;
+    j((t) => {
+      let n = !1;
+      const s = { ...t }, i = new Set(f.map((r) => r.internalName));
+      return Object.keys(s).forEach((r) => {
+        i.has(r) || (delete s[r], n = !0);
+      }), f.forEach((r) => {
+        const a = r.internalName, c = z[a], o = e[a];
+        if (c?.width !== void 0) {
+          const u = c.minWidth ?? _, h = c.maxWidth ?? J, d = Math.min(Math.max(c.width, u), h);
+          s[a] !== d && (s[a] = d, n = !0);
+        } else o?.width !== void 0 && s[a] !== void 0 && (delete s[a], n = !0);
+      }), n ? s : t;
+    }), de.current = z;
+  }, [z, f]);
+  const Y = F(() => w.reduce((e, t) => {
+    const s = f.find((r) => r.internalName === t.id)?.typeAsString === "Note" ? x * 2 : x, i = S[t.id] || (typeof t.size == "number" ? t.size : s);
+    return e + i;
+  }, 0), [w, S, f]), ye = wt({
+    data: b,
+    columns: w,
     state: {
-      rowSelection: R,
-      columnSizing: u
+      rowSelection: W,
+      columnSizing: S
     },
-    onRowSelectionChange: rt,
-    onColumnSizingChange: (t) => {
-      J((e) => {
-        const n = typeof t == "function" ? t(e) : t, s = {};
-        return Object.keys(n).forEach((r) => {
-          const c = g.find((o) => o.id === r);
-          if (c) {
-            const o = c.minSize || _, i = c.maxSize || Q;
-            W.current ? s[r] = Math.max(n[r], o) : s[r] = Math.min(Math.max(n[r], o), i);
+    onRowSelectionChange: he,
+    onColumnSizingChange: (e) => {
+      j((t) => {
+        const n = typeof e == "function" ? e(t) : e, s = {};
+        return Object.keys(n).forEach((i) => {
+          const r = w.find((a) => a.id === i);
+          if (r) {
+            const a = r.minSize || _, c = r.maxSize || J;
+            N.current ? s[i] = Math.max(n[i], a) : s[i] = Math.min(Math.max(n[i], a), c);
           }
-        }), { ...e, ...s };
+        }), { ...t, ...s };
       });
     },
     //getRowId: row => row.id as string,
-    getCoreRowModel: ae(),
-    getFilteredRowModel: ie(),
-    getSortedRowModel: oe(),
+    getCoreRowModel: zt(),
+    getFilteredRowModel: It(),
+    getSortedRowModel: yt(),
     columnResizeMode: "onChange",
     enableRowSelection: !0,
-    enableMultiRowSelection: S
+    enableMultiRowSelection: I
   });
   T(() => {
-    const t = /* @__PURE__ */ new Set();
-    Object.keys(R).forEach((e) => {
-      if (R[e]) {
-        const n = parseInt(e), s = h.current[n];
-        s?.id && t.add(s.id);
+    const e = /* @__PURE__ */ new Set();
+    Object.keys(W).forEach((t) => {
+      if (W[t]) {
+        const n = parseInt(t), s = p.current[n];
+        s?.id && e.add(s.id);
       }
-    }), lt.current = t;
-  }, [R]);
-  const Lt = M((t) => {
-    U?.(t);
-  }, [U]), l = (t) => {
-    Ht((e) => {
-      const n = typeof t == "function" ? t(e) : t;
-      h.current = n;
-      const s = /* @__PURE__ */ new Set();
-      if (Object.keys(R).forEach((r) => {
-        if (R[r]) {
-          const c = Number(r), o = e[c];
-          o?.id && s.add(o.id);
-        }
-      }), lt.current = s, s.size > 0) {
-        const r = {};
-        n.forEach((c, o) => {
-          c.id && s.has(c.id) && (r[o.toString()] = !0);
-        }), rt(r);
-      }
-      return Wt?.(n), n;
+    }), U.current = e;
+  }, [W]);
+  const ft = R((e) => {
+    re?.(e);
+  }, [re]), Ie = (e) => {
+    const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+    return Object.keys(W).forEach((i) => {
+      if (!W[i])
+        return;
+      const r = Number(i), a = e[r];
+      a && (s.add(r), a.id && t.add(a.id), n.add(a));
+    }), {
+      hasSelection: t.size > 0 || n.size > 0 || s.size > 0,
+      selectedIds: t,
+      selectedRefs: n,
+      selectedIndexes: s,
+      sourceLength: e.length
+    };
+  }, ze = (e, t) => {
+    if (!t.hasSelection)
+      return;
+    const n = t.sourceLength !== e.length, s = {};
+    e.forEach((i, r) => {
+      if (!i)
+        return;
+      const a = i.id ? t.selectedIds.has(i.id) : !1, c = t.selectedRefs.has(i), o = !i.id && !n && t.selectedIndexes.has(r);
+      (a || c || o) && (s[r.toString()] = !0);
+    }), he(s);
+  }, g = (e) => {
+    if (ue) {
+      const t = b, n = typeof e == "function" ? e(t) : e;
+      p.current = n;
+      const s = Ie(t);
+      U.current = s.selectedIds, ze(n, s), se?.(n);
+      return;
+    }
+    at((t) => {
+      const n = typeof e == "function" ? e(t) : e;
+      p.current = n;
+      const s = Ie(t);
+      return U.current = s.selectedIds, ze(n, s), se?.(n), n;
     });
-  }, Pt = M(() => a, [a]), jt = async (t) => {
+  }, be = R(() => f, [f]), Ee = async (e) => {
     try {
-      if (F) {
-        const e = { id: y(), ...t }, n = await F([e], p);
+      if (L) {
+        const t = { id: E(), ...e }, n = await L([t], y);
         if (n) {
           if (n.successful.length > 0) {
-            const s = n.successful.map((r) => {
-              const c = r.item;
-              return c.id ? c : { ...c, id: y() };
+            const s = n.successful.map((i) => {
+              const r = i.item;
+              return r.id ? r : { ...r, id: E() };
             });
-            l((r) => [...s, ...r]);
+            g((i) => [...s, ...i]);
           }
           return n;
         }
-        return l((s) => [e, ...s]), {
-          successful: [{ index: 0, item: e }],
+        return g((s) => [t, ...s]), {
+          successful: [{ index: 0, item: t }],
           failed: []
         };
       } else {
-        const e = { id: y(), ...t };
-        return l((n) => [e, ...n]), {
-          successful: [{ index: 0, item: e }],
+        const t = { id: E(), ...e };
+        return g((n) => [t, ...n]), {
+          successful: [{ index: 0, item: t }],
           failed: []
         };
       }
-    } catch (e) {
+    } catch (t) {
       return {
         successful: [],
-        failed: [{ index: -1, item: t, error: String(e) }]
+        failed: [{ index: -1, item: e, error: String(t) }]
       };
     }
-  }, vt = async (t) => {
-    if (t.length === 0)
+  }, Ce = async (e) => {
+    if (e.length === 0)
       return {
         successful: [],
         failed: []
       };
     try {
-      if (F) {
-        const e = t.map((s) => ({
-          id: y(),
+      if (L) {
+        const t = e.map((s) => ({
+          id: E(),
           ...s
-        })), n = await F(e, p);
+        })), n = await L(t, y);
         if (n) {
           if (n.successful.length > 0) {
-            const s = n.successful.map((r) => {
-              const c = r.item;
-              return c.id ? c : { ...c, id: y() };
+            const s = n.successful.map((i) => {
+              const r = i.item;
+              return r.id ? r : { ...r, id: E() };
             });
-            l((r) => [...s, ...r]);
+            g((i) => [...s, ...i]);
           }
           return n;
         }
-        return l((s) => [...e, ...s]), {
-          successful: e.map((s, r) => ({ index: r, item: s })),
+        return g((s) => [...t, ...s]), {
+          successful: t.map((s, i) => ({ index: i, item: s })),
           failed: []
         };
       } else {
-        const e = t.map((n) => ({
-          id: y(),
+        const t = e.map((n) => ({
+          id: E(),
           ...n
         }));
-        return l((n) => [...e, ...n]), {
-          successful: e.map((n, s) => ({ index: s, item: n })),
+        return g((n) => [...t, ...n]), {
+          successful: t.map((n, s) => ({ index: s, item: n })),
           failed: []
         };
       }
-    } catch (e) {
+    } catch (t) {
       return {
         successful: [],
-        failed: t.map((n, s) => ({
+        failed: e.map((n, s) => ({
           index: s,
           item: n,
-          error: String(e)
+          error: String(t)
         }))
       };
     }
-  }, Yt = async (t, e) => {
+  }, ve = async (e, t) => {
+    const n = p.current;
+    if (e < 0 || e >= n.length)
+      return {
+        successful: [],
+        failed: [{ index: e, item: t, error: "Invalid index" }]
+      };
     try {
-      if (O) {
-        const s = await O([{ index: t, item: e }], p);
-        if (s)
-          return s.successful.length && l((r) => {
-            const c = [...r];
-            return s.successful.forEach(({ index: o, item: i }) => c[o] = i), c;
-          }), s;
+      if (D) {
+        const i = await D([{ index: e, item: t }], y);
+        if (i)
+          return i.successful.length && g((r) => {
+            const a = [...r];
+            return i.successful.forEach(({ index: c, item: o }) => a[c] = o), a;
+          }), i;
       }
-      let n;
-      return l((s) => {
-        if (t < 0 || t >= s.length) return s;
-        n = { ...s[t], ...e };
-        const r = [...s];
-        return r[t] = n, r;
-      }), { successful: [{ index: t, item: n }], failed: [] };
-    } catch (n) {
+      let s;
+      return g((i) => {
+        s = { ...i[e], ...t };
+        const r = [...i];
+        return r[e] = s, r;
+      }), { successful: [{ index: e, item: s }], failed: [] };
+    } catch (s) {
       return {
         successful: [],
-        failed: [{ index: t, item: e, error: String(n) }]
+        failed: [{ index: e, item: t, error: String(s) }]
       };
     }
-  }, $t = async (t) => {
-    if (!t.length) return { successful: [], failed: [] };
+  }, Re = async (e) => {
+    if (!e.length) return { successful: [], failed: [] };
+    const t = p.current, n = (r) => r >= 0 && r < t.length, s = e.filter(({ index: r }) => !n(r)).map(({ index: r, item: a }) => ({ index: r, item: a, error: "Invalid index" })), i = e.filter(({ index: r }) => n(r));
     try {
-      if (O) {
-        const s = await O(t, p);
-        if (s)
-          return s.successful.length && l((r) => {
-            const c = [...r];
-            return s.successful.forEach(({ index: o, item: i }) => c[o] = i), c;
-          }), s;
+      if (D) {
+        const c = await D(e, y);
+        if (c) {
+          const o = c.successful.filter(({ index: l }) => n(l));
+          o.length && g((l) => {
+            const k = [...l];
+            return o.forEach(({ index: m, item: A }) => k[m] = A), k;
+          });
+          const u = new Set(c.failed.map((l) => l.index)), h = [...c.failed];
+          return s.forEach((l) => {
+            u.has(l.index) || h.push(l);
+          }), c.successful.filter(({ index: l }) => !n(l)).map(({ index: l, item: k }) => ({ index: l, item: k, error: "Invalid index" })).forEach((l) => {
+            u.has(l.index) || h.push(l);
+          }), { successful: o, failed: h };
+        }
       }
-      const e = [], n = [];
-      return l((s) => {
-        const r = [...s];
-        return t.forEach(({ index: c, item: o }) => {
-          c >= 0 && c < r.length ? (r[c] = { ...r[c], ...o }, e.push({ index: c, item: r[c] })) : n.push({ index: c, item: o, error: "Invalid index" });
-        }), r;
-      }), { successful: e, failed: n };
-    } catch (e) {
+      const r = [], a = [...s];
+      return g((c) => {
+        const o = [...c];
+        return i.forEach(({ index: u, item: h }) => {
+          o[u] = { ...o[u], ...h }, r.push({ index: u, item: o[u] });
+        }), o;
+      }), { successful: r, failed: a };
+    } catch (r) {
       return {
         successful: [],
-        failed: t.map(({ index: n, item: s }) => ({
-          index: n,
-          item: s,
-          error: String(e)
+        failed: e.map(({ index: a, item: c }) => ({
+          index: a,
+          item: c,
+          error: String(r)
         }))
       };
     }
-  }, Gt = async (t) => {
+  }, Me = async (e) => {
+    const t = p.current;
+    if (e < 0 || e >= t.length)
+      return {
+        successful: [],
+        failed: [{ index: e, error: "Invalid index" }]
+      };
     try {
       if (H) {
-        const n = E[t], s = await H([{ index: t, item: n }], p);
-        if (s)
-          return s.successful.length && l((r) => r.filter((c, o) => o !== t)), s;
+        const s = b[e], i = await H([{ index: e, item: s }], y);
+        if (i)
+          return i.successful.length && g((r) => r.filter((a, c) => c !== e)), i;
       }
-      let e;
-      return l((n) => t < 0 || t >= n.length ? n : (e = n[t], n.filter((s, r) => r !== t))), { successful: [{ index: t, item: e }], failed: [] };
-    } catch (e) {
+      let n;
+      return g((s) => (n = s[e], s.filter((i, r) => r !== e))), { successful: [{ index: e, item: n }], failed: [] };
+    } catch (n) {
       return {
         successful: [],
-        failed: [{ index: t, error: String(e) }]
+        failed: [{ index: e, error: String(n) }]
       };
     }
-  }, Xt = async (t) => {
-    if (!t.length) return { successful: [], failed: [] };
-    const e = new Set(t);
+  }, Ne = async (e) => {
+    if (!e.length) return { successful: [], failed: [] };
+    const t = p.current, n = Array.from(new Set(e)), { validIndexes: s, invalidFailures: i } = n.reduce(
+      (c, o) => (o >= 0 && o < t.length ? c.validIndexes.push(o) : c.invalidFailures.push({ index: o, error: "Invalid index" }), c),
+      { validIndexes: [], invalidFailures: [] }
+    ), r = n.map((c) => ({ index: c, item: b[c] })), a = new Set(s);
     try {
       if (H) {
-        const r = [...e].map((o) => ({ index: o, item: E[o] })), c = await H(r, p);
-        if (c) {
-          if (c.successful.length) {
-            const o = new Set(c.successful.map((i) => i.index));
-            l((i) => i.filter((d, z) => !o.has(z)));
+        const u = await H(r, y);
+        if (u) {
+          const h = u.successful.filter(({ index: m }) => a.has(m));
+          if (h.length) {
+            const m = new Set(h.map((A) => A.index));
+            g((A) => A.filter((Ot, St) => !m.has(St)));
           }
-          return c;
+          const d = new Set(u.failed.map((m) => m.index)), l = [...u.failed];
+          return i.forEach((m) => {
+            d.has(m.index) || l.push(m);
+          }), u.successful.filter(({ index: m }) => !a.has(m)).map(({ index: m }) => ({ index: m, error: "Invalid index" })).forEach((m) => {
+            d.has(m.index) || l.push(m);
+          }), { successful: h, failed: l };
         }
       }
-      const n = [];
-      l((r) => {
-        const c = [];
-        return r.forEach((o, i) => {
-          e.has(i) ? n.push({ index: i, item: o }) : c.push(o);
-        }), c;
-      });
-      const s = t.filter(
-        (r) => r < 0
-        /* o -> i >= prevLen, pero no lo conocemos aquí */
-      ).map((r) => ({ index: r, error: "Invalid index" }));
-      return { successful: n, failed: s };
-    } catch (n) {
+      const c = new Set(s), o = [];
+      return g((u) => {
+        const h = [];
+        return u.forEach((d, l) => {
+          c.has(l) ? o.push({ index: l, item: d }) : h.push(d);
+        }), h;
+      }), { successful: o, failed: i };
+    } catch (c) {
       return {
         successful: [],
-        failed: t.map((s) => ({ index: s, error: String(n) }))
+        failed: n.map((o) => ({ index: o, error: String(c) }))
       };
     }
-  }, ft = M((t) => h.current.find((e) => e.id === t), []), Jt = (t) => h.current[t], Kt = (t) => {
-    l(
-      t.map((e) => ({ ...e, id: e.id ?? y() }))
+  }, We = R((e) => p.current.find((t) => t.id === e), []), ke = (e) => p.current[e], Te = (e) => {
+    g(
+      e.map((t) => ({ ...t, id: t.id ?? E() }))
     );
-  }, Zt = () => {
-    l([]);
-  }, qt = (t) => h.current.findIndex((e) => e.id === t), Qt = (t) => h.current.some((e) => e.id === t), Vt = () => h.current.length, Ut = () => [...h.current], mt = M(() => it(h.current), [it]), ht = M(() => at(h.current), [at]), p = I(() => ({
-    getFields: Pt,
-    addItem: jt,
-    addItems: vt,
-    updateItem: Yt,
-    updateItems: $t,
-    deleteItem: Gt,
-    deleteItems: Xt,
-    getItem: ft,
-    getItemByIndex: Jt,
-    getItems: Ut,
-    getItemsCount: Vt,
-    itemExists: Qt,
-    getItemIndex: qt,
-    replaceAllItems: Kt,
-    clearItems: Zt,
-    deselectAllRows: ct,
-    getSelectedItems: mt,
-    getSelectedRows: ht
+  }, _e = () => {
+    g([]);
+  }, Ae = (e) => p.current.findIndex((t) => t.id === e), Be = (e) => p.current.some((t) => t.id === e), Fe = () => p.current.length, Oe = () => [...p.current], Le = R(() => ge(p.current), [ge]), De = R(() => Se(p.current), [Se]), y = F(() => ({
+    getFields: be,
+    addItem: Ee,
+    addItems: Ce,
+    updateItem: ve,
+    updateItems: Re,
+    deleteItem: Me,
+    deleteItems: Ne,
+    getItem: We,
+    getItemByIndex: ke,
+    getItems: Oe,
+    getItemsCount: Fe,
+    itemExists: Be,
+    getItemIndex: Ae,
+    replaceAllItems: Te,
+    clearItems: _e,
+    deselectAllRows: me,
+    getSelectedItems: Le,
+    getSelectedRows: De
   }), [
-    a,
-    ft,
-    mt,
-    ht,
-    ct
+    Ee,
+    Ce,
+    _e,
+    Me,
+    Ne,
+    me,
+    f,
+    be,
+    We,
+    ke,
+    Ae,
+    Oe,
+    Fe,
+    Le,
+    De,
+    Be,
+    Te,
+    ve,
+    Re
   ]);
-  re.useImperativeHandle(Nt, () => p, [p]), T(() => {
-    (B.length > 0 || E.length === 0) && l(
-      () => B.map((t) => ({
-        ...t,
-        id: t.id || y()
-      }))
-    );
-  }, [B]);
-  const te = M((t, e) => {
-    e?.target && e.target.closest('[data-checkbox="true"]') || (S && ot(t.index), G && G(t.original, t.index));
-  }, [S, G, ot]), gt = I(() => g.map((t) => {
-    const n = a.find((r) => r.internalName === t.id)?.typeAsString === "Note" ? f * 2 : f, s = u[t.id] || (typeof t.size == "number" ? t.size : n);
-    return t.id === "select" ? `${A}px` : `${s}px`;
-  }).join(" "), [g, u, a]);
+  xt.useImperativeHandle(et, () => y, [y]);
+  const ht = R((e, t) => {
+    t?.target && t.target.closest('[data-checkbox="true"]') || (I && pe(e.index), Z && Z(e.original, e.index));
+  }, [I, Z, pe]), He = F(() => w.map((e) => {
+    const n = f.find((i) => i.internalName === e.id)?.typeAsString === "Note" ? x * 2 : x, s = S[e.id] || (typeof e.size == "number" ? e.size : n);
+    return e.id === "select" ? `${O}px` : `${s}px`;
+  }).join(" "), [w, S, f]);
   T(() => {
-    const t = K.current;
-    if (!t) return;
-    const e = new ResizeObserver((n) => {
-      for (const s of n)
-        st(s.contentRect.width);
+    if (!P) return;
+    const e = new ResizeObserver((t) => {
+      for (const n of t)
+        fe(n.contentRect.width);
     });
-    return e.observe(t), st(t.clientWidth), () => e.disconnect();
-  }, []), T(() => {
-    if (!N || w <= 0) return;
-    let t = 0, e = 0;
+    return e.observe(P), fe(P.clientWidth), () => e.disconnect();
+  }, [P]), T(() => {
+    if (!M || C <= 0 || N.current) return;
+    let e = 0, t = 0;
     const n = [];
-    g.forEach((d) => {
-      const k = a.find((x) => x.internalName === d.id)?.typeAsString === "Note" ? f * 2 : f, m = u[d.id] || (typeof d.size == "number" ? d.size : k);
-      d.enableResizing === !1 ? t += m : (e += m, n.push(d));
+    if (w.forEach((o) => {
+      const h = f.find((m) => m.internalName === o.id)?.typeAsString === "Note" ? x * 2 : x, d = S[o.id] || (typeof o.size == "number" ? o.size : h);
+      !(o.id === "select") ? (t += d, n.push(o)) : e += d;
+    }), n.length === 0)
+      return;
+    const s = e + t;
+    if (Math.abs(s - C) < 1) return;
+    const i = C - e, r = i / t, a = { ...S };
+    let c = 0;
+    n.forEach((o, u) => {
+      const h = S[o.id] || (typeof o.size == "number" ? o.size : x), d = o.minSize || _;
+      let l;
+      u === n.length - 1 ? l = i - c : l = Math.round(h * r), l = Math.max(d, l), a[o.id] = l, c += l;
+    }), N.current = !0, j(a), requestAnimationFrame(() => {
+      N.current = !1;
     });
-    const s = t + e;
-    if (Math.abs(s - w) < 1) return;
-    const r = w - t, c = r / e, o = { ...u };
-    let i = 0;
-    n.forEach((d, z) => {
-      const k = u[d.id] || (typeof d.size == "number" ? d.size : f), m = d.minSize || _;
-      let x;
-      z === n.length - 1 ? x = r - i : x = Math.round(k * c), x = Math.max(m, x), o[d.id] = x, i += x;
-    }), W.current = !0, J(o), W.current = !1;
-  }, [N, w, g, a, u]), T(() => {
-    if (N || w <= 0)
+  }, [M, C, w, f]), T(() => {
+    if (M || C <= 0)
       return;
-    const t = w - D;
-    if (Math.abs(t) < 1)
+    const e = C - Y;
+    if (Math.abs(e) < 1)
       return;
-    const e = g.filter((m) => m.id && m.id !== "select");
-    if (e.length === 0) return;
-    const n = e[e.length - 1], s = n.id, c = a.find((m) => m.internalName === s)?.typeAsString === "Note" ? f * 2 : f, i = (u[s] || (typeof n.size == "number" ? n.size : c)) + t, d = n.minSize || _, z = Math.max(d, i), k = u[s];
-    Math.abs(k - z) < 1 || (W.current = !0, J((m) => ({
-      ...m,
-      [s]: z
-    })), W.current = !1);
-  }, [N, w, D, g, a]);
-  const pt = he(kt), St = ge(It), L = pe(Tt), ee = pt ? [pt, ...tt] : tt, Z = [];
-  St && Z.push(St), L && Z.push(L);
-  const ne = [...Z, ...At], se = L ? [L, ...et] : et;
-  return /* @__PURE__ */ yt(
-    de,
+    const t = w.filter((d) => d.id && d.id !== "select");
+    if (t.length === 0) return;
+    const n = t[t.length - 1], s = n.id, r = f.find((d) => d.internalName === s)?.typeAsString === "Note" ? x * 2 : x, c = (S[s] || (typeof n.size == "number" ? n.size : r)) + e, o = n.minSize || _, u = Math.max(o, c), h = S[s];
+    Math.abs(h - u) < 1 || (N.current = !0, j((d) => ({
+      ...d,
+      [s]: u
+    })), N.current = !1);
+  }, [M, C, Y, w, f]);
+  const je = Mt(tt), Pe = Nt(nt), $ = Wt(st), mt = je ? [je, ...ie] : ie, ee = [];
+  Pe && ee.push(Pe), $ && ee.push($);
+  const pt = [...ee, ...it], gt = $ ? [$, ...ce] : ce;
+  return /* @__PURE__ */ Ye(
+    Ct,
     {
       size: "small",
-      appearance: xt,
-      className: Ot,
+      appearance: Ge,
+      className: ct,
       style: {
-        backgroundColor: Y.colorNeutralBackground1,
+        backgroundColor: K.colorNeutralBackground1,
         maxWidth: "100%",
         // margin: "20px 20px",
         padding: "0px",
         gap: "0px",
-        ...zt
+        ...Xe
       },
       children: [
-        $ && /* @__PURE__ */ b(
-          Se,
+        V && /* @__PURE__ */ v(
+          kt,
           {
-            tableMethods: p,
-            alwaysButtons: ee,
-            noSelectionButtons: _t,
-            singleSelectionButtons: ne,
-            multiSelectionButtons: se,
-            selectedRows: p.getSelectedRows()
+            tableMethods: y,
+            alwaysButtons: mt,
+            noSelectionButtons: rt,
+            singleSelectionButtons: pt,
+            multiSelectionButtons: gt,
+            selectedRows: y.getSelectedRows()
           }
         ),
-        E.length > 0 ? /* @__PURE__ */ b(
+        b.length > 0 ? /* @__PURE__ */ v(
           "div",
           {
-            ref: K,
-            onScroll: Lt,
-            className: nt["efw-table-scroll-container"],
+            ref: dt,
+            onScroll: ft,
+            className: le["efw-table-scroll-container"],
             style: {
-              maxHeight: $ ? V - 40 : V,
+              maxHeight: V ? ne - 40 : ne,
               overflowY: "auto",
               overflowX: "auto",
-              border: `1px solid ${Y.colorNeutralStroke2}`,
-              borderTop: $ ? "none" : `1px solid ${Y.colorNeutralStroke2}`,
+              border: `1px solid ${K.colorNeutralStroke2}`,
+              borderTop: V ? "none" : `1px solid ${K.colorNeutralStroke2}`,
               position: "relative"
             },
-            children: /* @__PURE__ */ yt(
+            children: /* @__PURE__ */ Ye(
               "div",
               {
                 className: "table-container",
                 style: {
-                  minWidth: D,
-                  //width: Math.max(totalTableWidth, 300),
-                  width: N ? w : Math.max(D, 300)
+                  minWidth: M ? "100%" : Y,
+                  width: M ? "100%" : Math.max(Y, 300)
                 },
                 children: [
-                  /* @__PURE__ */ b(
-                    ye,
+                  /* @__PURE__ */ v(
+                    Tt,
                     {
-                      table: dt,
-                      gridTemplateColumns: gt,
-                      columnSizing: u,
-                      stickyColumnsInfo: ut,
-                      resizableColumns: X
+                      table: ye,
+                      gridTemplateColumns: He,
+                      columnSizing: S,
+                      stickyColumnsInfo: we,
+                      resizableColumns: Q
                     }
                   ),
-                  /* @__PURE__ */ b(
-                    we,
+                  /* @__PURE__ */ v(
+                    _t,
                     {
-                      table: dt,
-                      fields: a,
-                      tableContainerRef: K,
-                      useVirtualization: Ct,
-                      enableSelection: S,
-                      itemSize: Et,
-                      gridTemplateColumns: gt,
-                      columnSizing: u,
-                      stickyColumnsInfo: ut,
-                      onRowClick: te
+                      table: ye,
+                      fields: f,
+                      tableContainerRef: xe,
+                      useVirtualization: Ue,
+                      enableSelection: I,
+                      itemSize: Ve,
+                      gridTemplateColumns: He,
+                      columnSizing: S,
+                      stickyColumnsInfo: we,
+                      onRowClick: ht
                     }
                   )
                 ]
               }
             )
           }
-        ) : /* @__PURE__ */ b(xe, { height: 300 })
+        ) : /* @__PURE__ */ v(At, { height: 300 })
       ]
     }
   );
 };
 export {
-  f as COLS_DEF_WIDTH,
-  Q as COLS_MAX_WIDTH,
+  x as COLS_DEF_WIDTH,
+  J as COLS_MAX_WIDTH,
   _ as COLS_MIN_WIDTH,
-  Le as EFWTable,
-  De as SELECTOR_CELL_HEIGHT,
-  A as SELECTOR_CELL_WIDTH
+  Ut as EFWTable,
+  Qt as SELECTOR_CELL_HEIGHT,
+  O as SELECTOR_CELL_WIDTH
 };