@envisiongroup/porygon 0.1.0-rc.1

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

@@ -0,0 +1,98 @@
+import { jsx as r, jsxs as L } from "react/jsx-runtime";
+import { Text as V } from "@fluentui/react-components";
+import { Edit20Regular as q } from "@fluentui/react-icons";
+import { getErrorMessage as p } from "../../../../commons/utils.js";
+import { mergeButtonProps as S, generateFormProps as U } from "../../components/EFWTableCommandBar/EFWTableCommandBar.utils.js";
+import { useFormController as G } from "../../../../forms/EFWForm/EFWForm.hooks.js";
+import { EFWForm as H } from "../../../../forms/EFWForm/EFWForm.js";
+const ee = (m = {}) => {
+  const { formRef: f, getValues: g, validateForm: E, addMessageBar: a, setDisabled: i, removeAllMessagesBar: h } = G(), C = S({
+    enabled: !0,
+    props: {
+      children: "Editar",
+      icon: /* @__PURE__ */ r(q, {}),
+      drawerConfig: {
+        title: "Editar elemento",
+        size: "small",
+        position: "end"
+      }
+    }
+  }, m), { enabled: z, props: F, form: b } = C, { children: l, appearance: x, icon: c, drawerConfig: w } = F || {}, { title: v, size: B, position: k } = w || {};
+  return {
+    enabled: z,
+    kind: "EFWDrawerButton",
+    props: {
+      icon: c,
+      children: l,
+      appearance: x,
+      onClick: (J, M, P) => {
+        const { selectedRows: t, tableMethods: d } = P, R = d.getFields(), y = /* @__PURE__ */ L(V, { children: [
+          "Complete los campos requeridos para crear un nuevo elemento en la tabla. Los campos marcados con asterisco (",
+          /* @__PURE__ */ r("span", { style: { color: "#c00" }, children: "*" }),
+          ") son obligatorios."
+        ] }), u = t.length === 1 ? t[0].item : {}, T = t.map((o) => o.index), W = U(R, b);
+        M({
+          size: B,
+          title: v,
+          position: k,
+          deferContentRendering: !0,
+          content: /* @__PURE__ */ r(H, { initialValues: u, formRef: f, description: y, ...W }),
+          buttons: [
+            {
+              kind: "EFWButton",
+              props: {
+                icon: c,
+                children: l,
+                appearance: "primary",
+                autoLoading: !0,
+                loadingText: "Actualizando...",
+                successConfig: {
+                  text: "¡Actualizado!"
+                },
+                onClick: async (o, s) => {
+                  if (E()) {
+                    const A = g(), D = i(!0);
+                    h();
+                    try {
+                      const e = await d.updateItem(T[0], { ...u, ...A });
+                      if (e.failed?.length) {
+                        const I = e.failed.map((n) => p(n.error)), _ = e.failed.length > 1;
+                        return a({
+                          id: "update-operation-error",
+                          intent: "error",
+                          title: _ ? "Error al intentar actualizar elementos:" : "Error al intentar actualizar elemento:",
+                          message: /* @__PURE__ */ r("ul", { children: I.map((n, j) => /* @__PURE__ */ r("li", { children: n }, j)) })
+                        }), { success: !1 };
+                      }
+                      return setTimeout(s, 100), { success: !0 };
+                    } catch (e) {
+                      return i(!1, D), console.error("Error durante actualización:", e), a({
+                        id: "update-unexpected-error",
+                        intent: "error",
+                        title: "Error al intentar actualizar elemento",
+                        message: p(e)
+                      }), { success: !1 };
+                    }
+                  } else
+                    return { success: !1 };
+                }
+              }
+            },
+            {
+              kind: "EFWButton",
+              props: {
+                children: "Cancelar",
+                onClick: (o, s) => {
+                  s();
+                }
+              }
+            }
+          ]
+        });
+      }
+    }
+  };
+};
+export {
+  ee as useDefaultUpdateButton
+};

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

@@ -0,0 +1,4 @@
+import { EFWFormFieldProps } from '../../../../forms/EFWForm';
+import { UseTableController } from './useTableController.types';
+
+export declare const useTableController: (initialFields?: EFWFormFieldProps[]) => UseTableController;

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

@@ -0,0 +1,178 @@
+import { useRef as G, useState as m, useCallback as u, useEffect as d } from "react";
+const J = (I) => {
+  const c = G(null), [l, a] = m([]), [i, g] = m(I || []), h = u(() => c.current?.getFields?.() || i, [i]), p = u((t) => {
+    g(t);
+  }, []);
+  d(() => {
+    (() => {
+      const e = c.current?.getItems?.();
+      e && a(e);
+    })();
+  }, [c.current]);
+  const y = u(async (t) => {
+    try {
+      const e = await c.current?.addItem?.(t);
+      return e ? (e.successful.length > 0 && a((r) => [
+        ...e.successful.map((s) => s.item),
+        ...r
+      ]), e) : {
+        successful: [],
+        failed: [{ index: -1, item: t, error: "Table reference not available" }]
+      };
+    } catch (e) {
+      return {
+        successful: [],
+        failed: [{ index: -1, item: t, error: String(e) }]
+      };
+    }
+  }, []), b = u(async (t) => {
+    try {
+      const e = await c.current?.addItems?.(t);
+      return e ? (e.successful.length > 0 && a((r) => [
+        ...e.successful.map((s) => s.item),
+        ...r
+      ]), e) : {
+        successful: [],
+        failed: t.map((r, s) => ({
+          index: s,
+          item: r,
+          error: "Table reference not available"
+        }))
+      };
+    } catch (e) {
+      return {
+        successful: [],
+        failed: t.map((r, s) => ({
+          index: s,
+          item: r,
+          error: String(e)
+        }))
+      };
+    }
+  }, []), w = u(async (t, e) => {
+    try {
+      const r = await c.current?.updateItem?.(t, e);
+      return r ? (r.successful.length > 0 && a((s) => {
+        const o = [...s];
+        return r.successful.forEach(({ index: n, item: f }) => {
+          n >= 0 && n < o.length && (o[n] = f);
+        }), o;
+      }), r) : {
+        successful: [],
+        failed: [{ index: t, item: e, error: "Table reference not available" }]
+      };
+    } catch (r) {
+      return {
+        successful: [],
+        failed: [{ index: t, item: e, error: String(r) }]
+      };
+    }
+  }, []), S = u(async (t) => {
+    try {
+      const e = await c.current?.updateItems?.(t);
+      return e ? (e.successful.length > 0 && a((r) => {
+        const s = [...r];
+        return e.successful.forEach(({ index: o, item: n }) => {
+          o >= 0 && o < s.length && (s[o] = n);
+        }), s;
+      }), e) : {
+        successful: [],
+        failed: t.map(({ index: r, item: s }) => ({
+          index: r,
+          item: s,
+          error: "Table reference not available"
+        }))
+      };
+    } catch (e) {
+      return {
+        successful: [],
+        failed: t.map(({ index: r, item: s }) => ({
+          index: r,
+          item: s,
+          error: String(e)
+        }))
+      };
+    }
+  }, []), E = u(async (t) => {
+    try {
+      const e = await c.current?.deleteItem?.(t);
+      return e ? (e.successful.length > 0 && a((r) => {
+        const s = [...r];
+        return e.successful.map((n) => n.index).sort((n, f) => f - n).forEach((n) => {
+          n >= 0 && n < s.length && s.splice(n, 1);
+        }), s;
+      }), e) : {
+        successful: [],
+        failed: [{ index: t, error: "Table reference not available" }]
+      };
+    } catch (e) {
+      return {
+        successful: [],
+        failed: [{ index: t, error: String(e) }]
+      };
+    }
+  }, []), R = u(async (t) => {
+    try {
+      const e = await c.current?.deleteItems?.(t);
+      return e ? (e.successful.length > 0 && a((r) => {
+        const s = [...r];
+        return e.successful.map((n) => n.index).sort((n, f) => f - n).forEach((n) => {
+          n >= 0 && n < s.length && s.splice(n, 1);
+        }), s;
+      }), e) : {
+        successful: [],
+        failed: t.map((r) => ({
+          index: r,
+          error: "Table reference not available"
+        }))
+      };
+    } catch (e) {
+      return {
+        successful: [],
+        failed: t.map((r) => ({
+          index: r,
+          error: String(e)
+        }))
+      };
+    }
+  }, []), v = u((t) => c.current?.getItem?.(t) || l.find((e) => e.id === t), [l]), T = u((t) => c.current?.getItemByIndex?.(t) || l[t], [l]), C = u((t) => {
+    c.current?.replaceAllItems?.(t), a(t);
+  }, []), x = u(() => {
+    c.current?.clearItems?.(), a([]);
+  }, []), A = u((t) => c.current?.getItemIndex?.(t) ?? l.findIndex((e) => e.id === t), [l]), F = u((t) => c.current?.itemExists?.(t) ?? l.some((e) => e.id === t), [l]), B = u(() => c.current?.getItemsCount?.() ?? l.length, [l.length]), k = u(() => c.current?.getItems?.() ?? l, [l]), j = u(() => {
+    c.current?.deselectAllRows?.();
+  }, []), q = u(() => c.current?.getSelectedItems?.() ?? { items: [], indexes: [] }, []), z = u(() => c.current?.getSelectedRows?.() ?? [], []), D = u(() => c.current !== null, []);
+  return d(() => () => {
+    c.current = null;
+  }, []), {
+    tableRef: c,
+    // Configuración
+    getFields: h,
+    setFieldsConfig: p,
+    isTableReady: D,
+    // Operaciones CRUD
+    addItem: y,
+    addItems: b,
+    updateItem: w,
+    updateItems: S,
+    deleteItem: E,
+    deleteItems: R,
+    // Consultas
+    getItem: v,
+    getItemByIndex: T,
+    getItems: k,
+    getItemsCount: B,
+    getItemIndex: A,
+    itemExists: F,
+    // Manipulación masiva
+    replaceAllItems: C,
+    clearItems: x,
+    // Selección
+    deselectAllRows: j,
+    getSelectedItems: q,
+    getSelectedRows: z
+  };
+};
+export {
+  J as useTableController
+};

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

@@ -0,0 +1,4 @@
+import { EFWFormFieldProps } from '../../../../forms/EFWForm';
+import { UseTableController } from './useTableController.types';
+
+export declare const useTableController: (initialFields?: EFWFormFieldProps[]) => UseTableController;

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

@@ -0,0 +1,178 @@
+import { useRef as G, useState as m, useCallback as u, useEffect as d } from "react";
+const J = (I) => {
+  const c = G(null), [l, a] = m([]), [i, g] = m(I || []), h = u(() => c.current?.getFields?.() || i, [i]), p = u((t) => {
+    g(t);
+  }, []);
+  d(() => {
+    (() => {
+      const e = c.current?.getItems?.();
+      e && a(e);
+    })();
+  }, [c.current]);
+  const y = u(async (t) => {
+    try {
+      const e = await c.current?.addItem?.(t);
+      return e ? (e.successful.length > 0 && a((r) => [
+        ...e.successful.map((s) => s.item),
+        ...r
+      ]), e) : {
+        successful: [],
+        failed: [{ index: -1, item: t, error: "Table reference not available" }]
+      };
+    } catch (e) {
+      return {
+        successful: [],
+        failed: [{ index: -1, item: t, error: String(e) }]
+      };
+    }
+  }, []), b = u(async (t) => {
+    try {
+      const e = await c.current?.addItems?.(t);
+      return e ? (e.successful.length > 0 && a((r) => [
+        ...e.successful.map((s) => s.item),
+        ...r
+      ]), e) : {
+        successful: [],
+        failed: t.map((r, s) => ({
+          index: s,
+          item: r,
+          error: "Table reference not available"
+        }))
+      };
+    } catch (e) {
+      return {
+        successful: [],
+        failed: t.map((r, s) => ({
+          index: s,
+          item: r,
+          error: String(e)
+        }))
+      };
+    }
+  }, []), w = u(async (t, e) => {
+    try {
+      const r = await c.current?.updateItem?.(t, e);
+      return r ? (r.successful.length > 0 && a((s) => {
+        const o = [...s];
+        return r.successful.forEach(({ index: n, item: f }) => {
+          n >= 0 && n < o.length && (o[n] = f);
+        }), o;
+      }), r) : {
+        successful: [],
+        failed: [{ index: t, item: e, error: "Table reference not available" }]
+      };
+    } catch (r) {
+      return {
+        successful: [],
+        failed: [{ index: t, item: e, error: String(r) }]
+      };
+    }
+  }, []), S = u(async (t) => {
+    try {
+      const e = await c.current?.updateItems?.(t);
+      return e ? (e.successful.length > 0 && a((r) => {
+        const s = [...r];
+        return e.successful.forEach(({ index: o, item: n }) => {
+          o >= 0 && o < s.length && (s[o] = n);
+        }), s;
+      }), e) : {
+        successful: [],
+        failed: t.map(({ index: r, item: s }) => ({
+          index: r,
+          item: s,
+          error: "Table reference not available"
+        }))
+      };
+    } catch (e) {
+      return {
+        successful: [],
+        failed: t.map(({ index: r, item: s }) => ({
+          index: r,
+          item: s,
+          error: String(e)
+        }))
+      };
+    }
+  }, []), E = u(async (t) => {
+    try {
+      const e = await c.current?.deleteItem?.(t);
+      return e ? (e.successful.length > 0 && a((r) => {
+        const s = [...r];
+        return e.successful.map((n) => n.index).sort((n, f) => f - n).forEach((n) => {
+          n >= 0 && n < s.length && s.splice(n, 1);
+        }), s;
+      }), e) : {
+        successful: [],
+        failed: [{ index: t, error: "Table reference not available" }]
+      };
+    } catch (e) {
+      return {
+        successful: [],
+        failed: [{ index: t, error: String(e) }]
+      };
+    }
+  }, []), R = u(async (t) => {
+    try {
+      const e = await c.current?.deleteItems?.(t);
+      return e ? (e.successful.length > 0 && a((r) => {
+        const s = [...r];
+        return e.successful.map((n) => n.index).sort((n, f) => f - n).forEach((n) => {
+          n >= 0 && n < s.length && s.splice(n, 1);
+        }), s;
+      }), e) : {
+        successful: [],
+        failed: t.map((r) => ({
+          index: r,
+          error: "Table reference not available"
+        }))
+      };
+    } catch (e) {
+      return {
+        successful: [],
+        failed: t.map((r) => ({
+          index: r,
+          error: String(e)
+        }))
+      };
+    }
+  }, []), v = u((t) => c.current?.getItem?.(t) || l.find((e) => e.id === t), [l]), T = u((t) => c.current?.getItemByIndex?.(t) || l[t], [l]), C = u((t) => {
+    c.current?.replaceAllItems?.(t), a(t);
+  }, []), x = u(() => {
+    c.current?.clearItems?.(), a([]);
+  }, []), A = u((t) => c.current?.getItemIndex?.(t) ?? l.findIndex((e) => e.id === t), [l]), F = u((t) => c.current?.itemExists?.(t) ?? l.some((e) => e.id === t), [l]), B = u(() => c.current?.getItemsCount?.() ?? l.length, [l.length]), k = u(() => c.current?.getItems?.() ?? l, [l]), j = u(() => {
+    c.current?.deselectAllRows?.();
+  }, []), q = u(() => c.current?.getSelectedItems?.() ?? { items: [], indexes: [] }, []), z = u(() => c.current?.getSelectedRows?.() ?? [], []), D = u(() => c.current !== null, []);
+  return d(() => () => {
+    c.current = null;
+  }, []), {
+    tableRef: c,
+    // Configuración
+    getFields: h,
+    setFieldsConfig: p,
+    isTableReady: D,
+    // Operaciones CRUD
+    addItem: y,
+    addItems: b,
+    updateItem: w,
+    updateItems: S,
+    deleteItem: E,
+    deleteItems: R,
+    // Consultas
+    getItem: v,
+    getItemByIndex: T,
+    getItems: k,
+    getItemsCount: B,
+    getItemIndex: A,
+    itemExists: F,
+    // Manipulación masiva
+    replaceAllItems: C,
+    clearItems: x,
+    // Selección
+    deselectAllRows: j,
+    getSelectedItems: q,
+    getSelectedRows: z
+  };
+};
+export {
+  J as useTableController
+};

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

@@ -0,0 +1,16 @@
+import { EFWFormFieldProps } from '../../../../forms/EFWForm';
+import { EFWTableMethods, EFWTableRef } from '../../EFWTable.types';
+
+/**
+ * Interfaz que extiende `EFWFormMethods` y agrega propiedades y métodos específicos para el hook `useFormController`.
+ * Proporciona una forma de interactuar con el componente EFWForm desde un componente React.
+ */
+export interface UseTableController extends EFWTableMethods {
+    /**
+     * Referencia mutable que se pasa al componente EFWForm para exponer sus métodos.
+     * Debe asignarse a la prop `formRef` del componente EFWForm.
+     */
+    tableRef: React.MutableRefObject<EFWTableRef>;
+    setFieldsConfig: (fields: EFWFormFieldProps[]) => void;
+    isTableReady: () => boolean;
+}

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

@@ -0,0 +1,16 @@
+import { EFWFormFieldProps } from '../../../../forms/EFWForm';
+import { EFWTableMethods, EFWTableRef } from '../../EFWTable.types';
+
+/**
+ * Interfaz que extiende `EFWFormMethods` y agrega propiedades y métodos específicos para el hook `useFormController`.
+ * Proporciona una forma de interactuar con el componente EFWForm desde un componente React.
+ */
+export interface UseTableController extends EFWTableMethods {
+    /**
+     * Referencia mutable que se pasa al componente EFWForm para exponer sus métodos.
+     * Debe asignarse a la prop `formRef` del componente EFWForm.
+     */
+    tableRef: React.MutableRefObject<EFWTableRef>;
+    setFieldsConfig: (fields: EFWFormFieldProps[]) => void;
+    isTableReady: () => boolean;
+}

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

@@ -0,0 +1,3 @@
+import { UseTableSelection, UseTableSelectionOptions } from './useTableSelection.types';
+
+export declare const useTableSelection: ({ initialSelection, onSelectionChange, enableSelection }?: UseTableSelectionOptions) => UseTableSelection;

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

@@ -0,0 +1,67 @@
+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
+} = {}) => {
+  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
+    });
+  }, [n]), g = o((e) => {
+    n && c((t) => {
+      const s = e.toString();
+      if (t[s]) {
+        const i = { ...t };
+        return delete i[s], i;
+      } else
+        return {
+          ...t,
+          [s]: !0
+        };
+    });
+  }, [n]), d = o((e) => {
+    n && c((t) => {
+      const s = { ...t };
+      return e.forEach((i) => {
+        s[i.toString()] = !0;
+      }), s;
+    });
+  }, [n]), w = o((e) => {
+    const t = [...r];
+    return {
+      items: t.map((s) => e[s]).filter(Boolean),
+      indexes: t
+    };
+  }, [r]), p = o((e) => [...r].map((t) => ({
+    index: t,
+    item: e[t]
+  })).filter((t) => t.item), [r]);
+  return {
+    rowSelection: u,
+    setRowSelection: c,
+    selectedIndexes: r,
+    deselectAll: m,
+    selectSingle: a,
+    toggleMultiple: g,
+    selectMultiple: d,
+    getSelectedItems: w,
+    getSelectedRows: p
+  };
+};
+export {
+  M as useTableSelection
+};

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

@@ -0,0 +1,37 @@
+import { RowSelectionState } from '@tanstack/react-table';
+import { EFWTableItem } from '../../EFWTable.types';
+
+export interface UseTableSelectionOptions {
+    /** 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;
+}
+export interface UseTableSelection {
+    /** Estado de selección compatible con react-table */
+    rowSelection: RowSelectionState;
+    /** Función para actualizar la selección */
+    setRowSelection: React.Dispatch<React.SetStateAction<RowSelectionState>>;
+    /** Set con los índices seleccionados */
+    selectedIndexes: Set<number>;
+    /** Función para deseleccionar todo */
+    deselectAll: () => void;
+    /** Función para seleccionar SOLO un índice (deselecciona otros) - Para clicks en fila */
+    selectSingle: (index: number) => void;
+    /** Función para alternar selección manteniendo otros - Para clicks en checkbox */
+    toggleMultiple: (index: number) => void;
+    /** Función para seleccionar múltiples índices */
+    selectMultiple: (indexes: number[]) => void;
+    /** Función para obtener elementos seleccionados */
+    getSelectedItems: (allItems: EFWTableItem[]) => {
+        items: EFWTableItem[];
+        indexes: number[];
+    };
+    /** Función para obtener filas seleccionadas */
+    getSelectedRows: (allItems: EFWTableItem[]) => Array<{
+        index: number;
+        item: EFWTableItem;
+    }>;
+}

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

@@ -0,0 +1,3 @@
+export { EFWTable } from './EFWTable';
+export { useTableController } from './hooks/useTableController/useTableController';
+export type { EFWTableProps, EFWTableItem, EFWTableMethods } from './EFWTable.types';

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

@@ -0,0 +1,6 @@
+import { EFWTable as r } from "./EFWTable.js";
+import { useTableController as t } from "./hooks/useTableController/useTableController.js";
+export {
+  r as EFWTable,
+  t as useTableController
+};

package/dist/react-components/tables/EFWTable/utils/CellRenderer/CellRenderer.d.ts

@@ -0,0 +1,7 @@
+import { EFWFormFieldType } from '../../../../forms/EFWForm';
+import { CellRendererProps } from './CellRenderer.types';
+import * as React from "react";
+/**
+ * Componente memoizado para renderizar el contenido de una celda
+ */
+export declare const CellRenderer: <T extends EFWFormFieldType>(props: CellRendererProps<T>) => React.ReactElement;

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

@@ -0,0 +1,38 @@
+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(
+  ({
+    field: e,
+    value: l,
+    item: a,
+    rowIndex: d,
+    columnRenderers: i,
+    useDefaultAsFallback: u
+  }) => {
+    const m = f(e, l, a, d, i);
+    let t = o(m);
+    if (t === void 0) {
+      const r = R(e, i), n = {
+        field: e,
+        value: l,
+        item: a,
+        rowIndex: d,
+        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);
+    }
+    return t;
+  },
+  // 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.value,
+    l.value,
+    e.field.typeAsString
+  ) : !1
+);
+export {
+  D as CellRenderer
+};