@envisiongroup/porygon 1.0.0-rc.9 → 1.0.1

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

@@ -1,195 +1,231 @@
-import { useRef as J, useState as m, useCallback as c, useEffect as d } from "react";
-const M = (g) => {
-  const r = J(null), [l, a] = m([]), [i, I] = m(g || []), y = c(() => r.current?.getFields?.() || i, [i]), h = c((t) => {
-    I(t);
+import { useRef as U, useState as m, useCallback as n, useEffect as g } from "react";
+const te = (d) => {
+  const r = U(null), [a, o] = m([]), [f, I] = m(d || []), S = n(() => r.current?.getFields?.() || f, [f]), h = n((e) => {
+    I(e);
   }, []);
-  d(() => {
+  g(() => {
     (() => {
-      const e = r.current?.getItems?.();
-      e && a(e);
+      const t = r.current?.getItems?.();
+      t && o(t);
     })();
   }, []);
-  const p = c(async (t) => {
+  const y = n(async (e, t = {}) => {
+    const { position: u = "end" } = t;
     try {
-      const e = await r.current?.addItem?.(t);
-      return e ? (e.successful.length > 0 && a((s) => [
-        ...e.successful.map((n) => n.item),
-        ...s
-      ]), e) : {
+      const c = await r.current?.addItem?.(e, t);
+      if (c) {
+        if (c.successful.length > 0) {
+          const l = c.successful.map((s) => s.item);
+          o((s) => [
+            ...u === "start" ? l : s,
+            ...u === "start" ? s : l
+          ]);
+        }
+        return c;
+      }
+      return {
         successful: [],
-        failed: [{ index: -1, item: t, error: "Table reference not available" }]
+        failed: [{ index: -1, item: e, error: "Table reference not available" }]
       };
-    } catch (e) {
+    } catch (c) {
       return {
         successful: [],
-        failed: [{ index: -1, item: t, error: String(e) }]
+        failed: [{ index: -1, item: e, error: String(c) }]
       };
     }
-  }, []), b = c(async (t) => {
+  }, []), b = n(async (e, t = {}) => {
+    const { position: u = "end" } = t;
     try {
-      const e = await r.current?.addItems?.(t);
-      return e ? (e.successful.length > 0 && a((s) => [
-        ...e.successful.map((n) => n.item),
-        ...s
-      ]), e) : {
+      const c = await r.current?.addItems?.(e, t);
+      if (c) {
+        if (c.successful.length > 0) {
+          const l = c.successful.map((s) => s.item);
+          o((s) => [
+            ...u === "start" ? l : s,
+            ...u === "start" ? s : l
+          ]);
+        }
+        return c;
+      }
+      return {
         successful: [],
-        failed: t.map((s, n) => ({
-          index: n,
-          item: s,
+        failed: e.map((l, s) => ({
+          index: s,
+          item: l,
           error: "Table reference not available"
         }))
       };
-    } catch (e) {
+    } catch (c) {
       return {
         successful: [],
-        failed: t.map((s, n) => ({
-          index: n,
-          item: s,
-          error: String(e)
+        failed: e.map((l, s) => ({
+          index: s,
+          item: l,
+          error: String(c)
         }))
       };
     }
-  }, []), w = c(async (t, e) => {
+  }, []), p = n(async (e, t, u) => {
     try {
-      const s = await r.current?.updateItem?.(t, e);
-      return s ? (s.successful.length > 0 && a((n) => {
-        const o = [...n];
-        return s.successful.forEach(({ index: u, item: f }) => {
-          u >= 0 && u < o.length && (o[u] = f);
-        }), o;
-      }), s) : {
+      const c = await r.current?.updateItem?.(e, t, u);
+      return c ? (c.successful.length > 0 && o((l) => {
+        const s = [...l];
+        return c.successful.forEach(({ index: i, item: $ }) => {
+          i >= 0 && i < s.length && (s[i] = $);
+        }), s;
+      }), c) : {
         successful: [],
-        failed: [{ index: t, item: e, error: "Table reference not available" }]
+        failed: [{ index: e, item: t, error: "Table reference not available" }]
       };
-    } catch (s) {
+    } catch (c) {
       return {
         successful: [],
-        failed: [{ index: t, item: e, error: String(s) }]
+        failed: [{ index: e, item: t, error: String(c) }]
       };
     }
-  }, []), S = c(async (t) => {
+  }, []), F = n(async (e, t) => {
     try {
-      const e = await r.current?.updateItems?.(t);
-      return e ? (e.successful.length > 0 && a((s) => {
-        const n = [...s];
-        return e.successful.forEach(({ index: o, item: u }) => {
-          o >= 0 && o < n.length && (n[o] = u);
-        }), n;
-      }), e) : {
+      const u = await r.current?.updateItems?.(e, t);
+      return u ? (u.successful.length > 0 && o((c) => {
+        const l = [...c];
+        return u.successful.forEach(({ index: s, item: i }) => {
+          s >= 0 && s < l.length && (l[s] = i);
+        }), l;
+      }), u) : {
         successful: [],
-        failed: t.map(({ index: s, item: n }) => ({
-          index: s,
-          item: n,
+        failed: e.map(({ index: c, item: l }) => ({
+          index: c,
+          item: l,
           error: "Table reference not available"
         }))
       };
-    } catch (e) {
+    } catch (u) {
       return {
         successful: [],
-        failed: t.map(({ index: s, item: n }) => ({
-          index: s,
-          item: n,
-          error: String(e)
+        failed: e.map(({ index: c, item: l }) => ({
+          index: c,
+          item: l,
+          error: String(u)
         }))
       };
     }
-  }, []), E = c(async (t) => {
+  }, []), w = n(async (e) => {
     try {
-      const e = await r.current?.deleteItem?.(t);
-      return e ? (e.successful.length > 0 && a((s) => {
-        const n = [...s];
-        return e.successful.map((u) => u.index).sort((u, f) => f - u).forEach((u) => {
-          u >= 0 && u < n.length && n.splice(u, 1);
-        }), n;
-      }), e) : {
+      const t = await r.current?.deleteItem?.(e);
+      return t ? (t.successful.length > 0 && o((u) => {
+        const c = [...u];
+        return t.successful.map((s) => s.index).sort((s, i) => i - s).forEach((s) => {
+          s >= 0 && s < c.length && c.splice(s, 1);
+        }), c;
+      }), t) : {
         successful: [],
-        failed: [{ index: t, error: "Table reference not available" }]
+        failed: [{ index: e, error: "Table reference not available" }]
       };
-    } catch (e) {
+    } catch (t) {
       return {
         successful: [],
-        failed: [{ index: t, error: String(e) }]
+        failed: [{ index: e, error: String(t) }]
       };
     }
-  }, []), v = c(async (t) => {
+  }, []), C = n(async (e) => {
     try {
-      const e = await r.current?.deleteItems?.(t);
-      return e ? (e.successful.length > 0 && a((s) => {
-        const n = [...s];
-        return e.successful.map((u) => u.index).sort((u, f) => f - u).forEach((u) => {
-          u >= 0 && u < n.length && n.splice(u, 1);
-        }), n;
-      }), e) : {
+      const t = await r.current?.deleteItems?.(e);
+      return t ? (t.successful.length > 0 && o((u) => {
+        const c = [...u];
+        return t.successful.map((s) => s.index).sort((s, i) => i - s).forEach((s) => {
+          s >= 0 && s < c.length && c.splice(s, 1);
+        }), c;
+      }), t) : {
         successful: [],
-        failed: t.map((s) => ({
-          index: s,
+        failed: e.map((u) => ({
+          index: u,
           error: "Table reference not available"
         }))
       };
-    } catch (e) {
+    } catch (t) {
       return {
         successful: [],
-        failed: t.map((s) => ({
-          index: s,
-          error: String(e)
+        failed: e.map((u) => ({
+          index: u,
+          error: String(t)
         }))
       };
     }
-  }, []), R = c((t) => r.current?.getItem?.(t) || l.find((e) => e._rowId === t), [l]), T = c((t) => r.current?.getItemByIndex?.(t) || l[t], [l]), C = c((t) => {
-    r.current?.replaceAllItems?.(t), a(t);
-  }, []), x = c(() => {
-    r.current?.clearItems?.(), a([]);
-  }, []), A = c((t) => r.current?.getItemIndex?.(t) ?? l.findIndex((e) => e._rowId === t), [l]), F = c((t) => r.current?.itemExists?.(t) ?? l.some((e) => e._rowId === t), [l]), L = c(() => r.current?.getItemsCount?.() ?? l.length, [l.length]), O = c(() => r.current?.getItems?.() ?? l, [l]), _ = c(() => {
+  }, []), v = n((e) => r.current?.getItem?.(e) || a.find((t) => t._rowId === e), [a]), E = n((e) => r.current?.getItemByIndex?.(e) || a[e], [a]), A = n((e) => {
+    r.current?.replaceAllItems?.(e), o(e);
+  }, []), R = n(() => {
+    r.current?.clearItems?.(), o([]);
+  }, []), T = n((e) => r.current?.getItemIndex?.(e) ?? a.findIndex((t) => t._rowId === e), [a]), x = n((e) => r.current?.itemExists?.(e) ?? a.some((t) => t._rowId === e), [a]), L = n(() => r.current?.getItemsCount?.() ?? a.length, [a.length]), O = n(() => r.current?.getItems?.() ?? a, [a]), P = n(() => {
     r.current?.deselectAllRows?.();
-  }, []), B = c(() => r.current?.getSelectedItems?.() ?? { items: [], indexes: [] }, []), P = c(() => r.current?.getSelectedRows?.() ?? [], []), k = c(() => r.current !== null, []), j = c((t, e) => {
-    r.current?.setLoading?.(t, e);
-  }, []), q = c((t, e) => {
-    r.current?.setError?.(t, e);
-  }, []), z = c((t, e) => {
-    r.current?.setPartialLoading?.(t, e);
-  }, []), D = c((t, e) => {
-    r.current?.setEmpty?.(t, e);
-  }, []), G = c(() => {
+  }, []), _ = n(() => r.current?.getSelectedItems?.() ?? { items: [], indexes: [] }, []), B = n(() => r.current?.getSelectedRows?.() ?? [], []), k = n(() => r.current !== null, []), j = n((e, t) => {
+    r.current?.setLoading?.(e, t);
+  }, []), q = n((e, t) => {
+    r.current?.setError?.(e, t);
+  }, []), z = n((e, t) => {
+    r.current?.setPartialLoading?.(e, t);
+  }, []), D = n((e, t) => {
+    r.current?.setEmpty?.(e, t);
+  }, []), G = n(() => {
     r.current?.clearOverlay?.();
-  }, []), H = c(() => r.current?.getOverlayState?.() ?? "none", []);
-  return d(() => () => {
+  }, []), H = n(() => r.current?.getOverlayState?.() ?? "none", []), J = n(() => r.current?.getSortingState?.() ?? [], []), K = n(() => r.current?.getPrimarySortedColumn?.() ?? null, []), M = n(() => r.current?.hasActiveSorting?.() ?? !1, []), N = n((e) => {
+    r.current?.setSortingState?.(e);
+  }, []), Q = n(() => {
+    r.current?.clearSorting?.();
+  }, []), V = n(() => r.current?.getFilterableFields?.() ?? [], []), W = n(() => r.current?.getColumnFilters?.() ?? {}, []), X = n(() => r.current?.hasActiveFilters?.() ?? !1, []), Y = n((e) => {
+    r.current?.setColumnFilters?.(e);
+  }, []), Z = n(() => {
+    r.current?.clearColumnFilters?.();
+  }, []);
+  return g(() => () => {
     r.current = null;
   }, []), {
     tableRef: r,
     // Configuración
-    getFields: y,
+    getFields: S,
     setFieldsConfig: h,
     isTableReady: k,
     // Operaciones CRUD
-    addItem: p,
+    addItem: y,
     addItems: b,
-    updateItem: w,
-    updateItems: S,
-    deleteItem: E,
-    deleteItems: v,
+    updateItem: p,
+    updateItems: F,
+    deleteItem: w,
+    deleteItems: C,
     // Consultas
-    getItem: R,
-    getItemByIndex: T,
+    getItem: v,
+    getItemByIndex: E,
     getItems: O,
     getItemsCount: L,
-    getItemIndex: A,
-    itemExists: F,
+    getItemIndex: T,
+    itemExists: x,
     // Manipulación masiva
-    replaceAllItems: C,
-    clearItems: x,
+    replaceAllItems: A,
+    clearItems: R,
     // Selección
-    deselectAllRows: _,
-    getSelectedItems: B,
-    getSelectedRows: P,
+    deselectAllRows: P,
+    getSelectedItems: _,
+    getSelectedRows: B,
     // Overlay
     setLoading: j,
     setError: q,
     setPartialLoading: z,
     setEmpty: D,
     clearOverlay: G,
-    getOverlayState: H
+    getOverlayState: H,
+    // Sorting
+    getSortingState: J,
+    getPrimarySortedColumn: K,
+    hasActiveSorting: M,
+    setSortingState: N,
+    clearSorting: Q,
+    // Filtrado
+    getFilterableFields: V,
+    getColumnFilters: W,
+    hasActiveFilters: X,
+    setColumnFilters: Y,
+    clearColumnFilters: Z
   };
 };
 export {
-  M as useTableController
+  te as useTableController
 };

package/dist/react-components/tables/EFWTable/hooks/useTableSelection/useTableSelection.d.ts

@@ -1,4 +1,4 @@
 import { EFWTableItem } from '../../EFWTable.types';
 import { UseTableSelection, UseTableSelectionOptions } from './useTableSelection.types';
 
-export declare const useTableSelection: <TItem extends EFWTableItem = EFWTableItem>({ initialSelection, onSelectionChange, enableSelection }?: UseTableSelectionOptions) => UseTableSelection<TItem>;
+export declare const useTableSelection: <TItem extends EFWTableItem = EFWTableItem>({ initialSelection, onSelectionChange, enableSelection, items, getRowId }?: UseTableSelectionOptions<TItem>) => UseTableSelection<TItem>;

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

@@ -1,67 +1,114 @@
-import { useState as h, useRef as R, useMemo as x, useEffect as E, useCallback as o } from "react";
-const M = ({
-  initialSelection: S = /* @__PURE__ */ new Set(),
-  onSelectionChange: f,
-  enableSelection: n = !0
+import { useCallback as l, useMemo as b, useState as z, useRef as T, useEffect as j } from "react";
+const B = ({
+  initialSelection: p = /* @__PURE__ */ new Set(),
+  onSelectionChange: m,
+  enableSelection: f = !0,
+  items: c = [],
+  getRowId: u = (i, a) => a.toString()
 } = {}) => {
-  const [u, c] = h(() => {
-    const e = {};
-    return S.forEach((t) => {
-      e[t.toString()] = !0;
-    }), e;
-  }), l = R(/* @__PURE__ */ new Set()), r = x(() => new Set(
-    Object.keys(u).filter((e) => u[e]).map((e) => parseInt(e))
-  ), [u]);
-  E(() => {
-    (r.size !== l.current.size || [...r].some((t) => !l.current.has(t))) && (l.current = new Set(r), f?.(r));
-  }, [r, f]);
-  const m = o(() => {
-    c({});
-  }, []), a = o((e) => {
-    n && c({
-      [e.toString()]: !0
+  const i = l((t) => {
+    const e = c[t];
+    return e ? u(e, t) : t.toString();
+  }, [u, c]), a = b(() => {
+    const t = /* @__PURE__ */ new Map();
+    return c.forEach((e, r) => {
+      t.set(u(e, r), r);
+    }), t;
+  }, [u, c]), [h, S] = z(() => {
+    const t = {};
+    return p.forEach((e) => {
+      const r = c[e];
+      t[r ? u(r, e) : e.toString()] = !0;
+    }), t;
+  }), g = T(/* @__PURE__ */ new Set()), s = b(() => {
+    const t = /* @__PURE__ */ new Set();
+    return Object.keys(h).filter((e) => h[e]).forEach((e) => {
+      const r = a.get(e);
+      if (r !== void 0) {
+        t.add(r);
+        return;
+      }
+      const n = Number(e);
+      Number.isInteger(n) && n >= 0 && c[n] && t.add(n);
+    }), new Set([...t].sort((e, r) => e - r));
+  }, [c, a, h]);
+  j(() => {
+    S((t) => {
+      let e = !1;
+      const r = {};
+      Object.keys(t).forEach((o) => {
+        if (!t[o])
+          return;
+        if (a.has(o)) {
+          r[o] = !0;
+          return;
+        }
+        const d = Number(o);
+        if (Number.isInteger(d) && d >= 0) {
+          const w = c[d];
+          if (w) {
+            const E = u(w, d);
+            r[E] = !0, e = e || E !== o;
+            return;
+          }
+          r[o] = !0;
+          return;
+        }
+        e = !0;
+      });
+      const n = Object.keys(t).filter((o) => t[o]).length;
+      return !e && Object.keys(r).length === n ? t : r;
     });
-  }, [n]), g = o((e) => {
-    n && c((t) => {
-      const s = e.toString();
-      if (t[s]) {
-        const i = { ...t };
-        return delete i[s], i;
+  }, [u, c, a]), j(() => {
+    (s.size !== g.current.size || [...s].some((e) => !g.current.has(e))) && (g.current = new Set(s), m?.(s));
+  }, [s, m]);
+  const x = l(() => {
+    S({});
+  }, []), C = l((t) => {
+    f && S({
+      [i(t)]: !0
+    });
+  }, [f, i]), I = l((t) => {
+    f && S((e) => {
+      const r = i(t);
+      if (e[r]) {
+        const n = { ...e };
+        return delete n[r], n;
       } else
         return {
-          ...t,
-          [s]: !0
+          ...e,
+          [r]: !0
         };
     });
-  }, [n]), d = o((e) => {
-    n && c((t) => {
-      const s = { ...t };
-      return e.forEach((i) => {
-        s[i.toString()] = !0;
-      }), s;
+  }, [f, i]), M = l((t) => {
+    f && S((e) => {
+      const r = { ...e };
+      return t.forEach((n) => {
+        r[i(n)] = !0;
+      }), r;
     });
-  }, [n]), w = o((e) => {
-    const t = [...r];
+  }, [f, i]), N = l((t) => {
+    const e = [...s];
     return {
-      items: t.map((s) => e[s]).filter(Boolean),
-      indexes: t
+      items: e.map((r) => t[r]).filter(Boolean),
+      indexes: e
     };
-  }, [r]), p = o((e) => [...r].map((t) => ({
-    index: t,
-    item: e[t]
-  })).filter((t) => t.item), [r]);
+  }, [s]), O = l((t) => [...s].map((e) => ({
+    index: e,
+    item: t[e]
+  })).filter((e) => e.item), [s]);
   return {
-    rowSelection: u,
-    setRowSelection: c,
-    selectedIndexes: r,
-    deselectAll: m,
-    selectSingle: a,
-    toggleMultiple: g,
-    selectMultiple: d,
-    getSelectedItems: w,
-    getSelectedRows: p
+    rowSelection: h,
+    setRowSelection: S,
+    selectedIndexes: s,
+    deselectAll: x,
+    selectSingle: C,
+    toggleMultiple: I,
+    selectMultiple: M,
+    getSelectedItems: N,
+    getSelectedRows: O
   };
 };
 export {
-  M as useTableSelection
+  B as useTableSelection
 };

package/dist/react-components/tables/EFWTable/hooks/useTableSelection/useTableSelection.types.d.ts

@@ -1,13 +1,17 @@
 import { RowSelectionState } from '@tanstack/react-table';
 import { EFWTableItem } from '../../EFWTable.types';
 
-export interface UseTableSelectionOptions {
+export interface UseTableSelectionOptions<TItem extends EFWTableItem = EFWTableItem> {
     /** Elementos seleccionados inicialmente por índice */
     initialSelection?: Set<number>;
     /** Callback cuando cambia la selección */
     onSelectionChange?: (selectedIndexes: Set<number>) => void;
     /** Si se permite selección (para mostrar checkboxes) */
     enableSelection?: boolean;
+    /** Items actuales usados para convertir índices públicos a ids internos */
+    items?: TItem[];
+    /** Resolver de identidad estable para TanStack/react-table */
+    getRowId?: (item: TItem, index: number) => string;
 }
 export interface UseTableSelection<TItem extends EFWTableItem = EFWTableItem> {
     /** Estado de selección compatible con react-table */

package/dist/react-components/tables/EFWTable/index.d.ts

@@ -1,5 +1,8 @@
 export { EFWTable } from './EFWTable';
 export { useTableController } from './hooks/useTableController/useTableController';
+export { useDefaultFilterButton } from './hooks/useDefaultFilterButton/useDefaultFilterButton';
 export { EFWTableOverlay, EFWTableEmpty } from './components/EFWTableOverlay';
-export type { EFWTableProps, EFWTableItem, EFWTableRef, EFWTableMethods } from './EFWTable.types';
+export type { EFWTableProps, EFWTableItem, EFWTableAddOptions, EFWTableRef, EFWTableMethods, EFWTableRowAnimationConfig, EFWTableRowAnimationOptions, EFWTableCommandBarButtonInput, EFWTableSort, EFWTableSortingState, EFWTableUpdateOptions, FilterValues, } from './EFWTable.types';
+export type { EFWTableCommandBarButton, DefaultFilterButtonProps } from './components/EFWTableCommandBar';
+export type { EFWTableLocaleText, EFWTableExtendedLocaleText } from '../../i18n';
 export type { EFWTableOverlayProps, EFWTableOverlayConfig, EFWTableOverlayState, EFWTableOverlayDisplayType, EFWTableOverlayStateConfig, EFWTableOverlayCustomization, EFWTableOverlayBaseOptions, EFWTableLoadingOptions, EFWTableErrorOptions, EFWTablePartialLoadingOptions, EFWTableEmptyOptions, EFWTableEmptyProps, } from './components/EFWTableOverlay';

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

@@ -1,9 +1,11 @@
 import { EFWTable as o } from "./EFWTable.js";
-import { useTableController as a } from "./hooks/useTableController/useTableController.js";
-import { EFWTableEmpty as b, EFWTableOverlay as m } from "./components/EFWTableOverlay/EFWTableOverlay.js";
+import { useTableController as l } from "./hooks/useTableController/useTableController.js";
+import { useDefaultFilterButton as f } from "./hooks/useDefaultFilterButton/useDefaultFilterButton.js";
+import { EFWTableEmpty as p, EFWTableOverlay as b } from "./components/EFWTableOverlay/EFWTableOverlay.js";
 export {
   o as EFWTable,
-  b as EFWTableEmpty,
-  m as EFWTableOverlay,
-  a as useTableController
+  p as EFWTableEmpty,
+  b as EFWTableOverlay,
+  f as useDefaultFilterButton,
+  l as useTableController
 };

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

@@ -1,38 +1,41 @@
-import * as c from "react";
-import { createCacheKey as f, getCachedResult as o, setCachedResult as s } from "../cache.js";
-import { resolveRendererForField as R } from "../renderers.js";
-import { areValuesEqual as F } from "../comparison.js";
-import { getEFWFormFieldDisplayText as h } from "../../../../forms/EFWForm/EFWForm.converter.js";
-const D = c.memo(
+import * as f from "react";
+import { createCacheKey as m, getCachedResult as h, setCachedResult as R } from "../cache.js";
+import { resolveRendererForField as F } from "../renderers.js";
+import { areValuesEqual as b } from "../comparison.js";
+import { useFieldsLocaleText as y } from "../../../../i18n/PorygonI18nProvider.js";
+import { getFormFieldDisplayText as T } from "../../../../forms/EFWForm/EFWForm.converter.js";
+const C = f.memo(
   ({
     field: e,
-    value: l,
-    item: a,
-    rowIndex: d,
-    columnRenderers: i,
-    useDefaultAsFallback: u
+    value: t,
+    item: r,
+    rowIndex: i,
+    columnRenderers: o,
+    useDefaultAsFallback: d
   }) => {
-    const m = f(e, l, a, d, i);
-    let t = o(m);
-    if (t === void 0) {
-      const r = R(e, i), n = {
+    const c = y().switch.labels, u = e.typeAsString === "Boolean" ? `switch:${c.checkedText}:${c.uncheckedText}` : "default", s = m(e, t, r, i, o, u);
+    let l = h(s);
+    if (l === void 0) {
+      const a = F(e, o), n = {
         field: e,
-        value: l,
-        item: a,
-        rowIndex: d,
+        value: t,
+        item: r,
+        rowIndex: i,
         columnId: e.internalName
       };
-      r.fieldRenderer ? t = r.fieldRenderer(n) : r.defaultRenderer ? t = r.defaultRenderer(n) : u ? t = h(e, l) : t = null, s(m, t);
+      a.fieldRenderer ? l = a.fieldRenderer(n) : a.defaultRenderer ? l = a.defaultRenderer(n) : d ? l = T(e, t, {
+        switchLabels: c
+      }) : l = null, R(s, l);
     }
-    return t;
+    return l;
   },
   // Función de comparación para React.memo
-  (e, l) => e.field === l.field && e.item === l.item && e.rowIndex === l.rowIndex && e.columnRenderers === l.columnRenderers && e.useDefaultAsFallback === l.useDefaultAsFallback ? F(
+  (e, t) => e.field === t.field && e.item === t.item && e.rowIndex === t.rowIndex && e.columnRenderers === t.columnRenderers && e.useDefaultAsFallback === t.useDefaultAsFallback ? b(
     e.value,
-    l.value,
+    t.value,
     e.field.typeAsString
   ) : !1
 );
 export {
-  D as CellRenderer
+  C as CellRenderer
 };