@envisiongroup/porygon 1.0.2 → 1.0.4

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

@@ -433,7 +433,16 @@ export interface EFWTableProps<T extends readonly EFWFormFieldProps[] = EFWFormF
      * Se ejecuta antes de que los elementos se agreguen a la tabla local. Útil para validaciones,
      * persistencia en BD, transformaciones de datos o control de flujo.
      *
-     * @param {EFWTableItem[]} items - Elementos que se van a agregar (ya incluyen ID generado)
+     * **Semántica de propiedad omitida**: los items llegan tal como los provee el
+     * usuario (payload parcial). Si el formulario de creación pide un subconjunto
+     * de fields, las columnas no renderizadas (típicamente las asignadas por el
+     * backend: `status`, `createdBy`, timestamps) **no estarán presentes** en el
+     * item, para que el backend pueda aplicar sus propios defaults. EFWTable
+     * completa los valores vacíos (`''`, `null`, `[]`, `false`) **solo** sobre
+     * los items que finalmente se guardan localmente, preservando esta semántica
+     * para el consumidor. Accede únicamente a las keys que tu formulario pide.
+     *
+     * @param {EFWTableItem[]} items - Elementos que se van a agregar (ya incluyen ID generado). Pueden ser parciales si el form de creación usa un subconjunto de fields.
      * @param {EFWTableMethods} tableMethods - Métodos de la tabla para operaciones adicionales
      * @returns {Promise<OperationResult<EFWTableItem> | void>}
      *   - `void`: Continúa con la operación normal de agregar

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

@@ -43,7 +43,10 @@ const s = [], A = [], Y = I({
   className: E,
   localeText: _
 }) => {
-  const c = Y(), m = O(_), e = n.useMemo(() => r.length, [r]), a = n.useCallback(
+  const c = Y(), m = O(_), e = n.useMemo(
+    () => r.length,
+    [r]
+  ), a = n.useCallback(
     (L, B) => L.map((o, N) => {
       const W = o.enabled === void 0 ? !0 : typeof o.enabled == "boolean" ? o.enabled : o.enabled(r, i), T = B.active && W, l = o.props || {}, v = T ? l.style : { ...l.style, display: "none" }, P = {
         ...l,
@@ -63,25 +66,42 @@ const s = [], A = [], Y = I({
   ), k = M(() => {
     i.deselectAllRows();
   }, [i]), x = n.useMemo(
-    () => a(d, { active: !0, prefix: "always-button" }),
+    () => a(d, {
+      active: !0,
+      prefix: "always-button"
+    }),
     [d, a]
   ), y = n.useMemo(
-    () => a(p, { active: e === 0, prefix: "no-selected-button" }),
+    () => a(p, {
+      active: e === 0,
+      prefix: "no-selected-button"
+    }),
     [a, p, e]
   ), b = n.useMemo(
-    () => a(u, { active: e === 1, prefix: "one-selected-button" }),
+    () => a(u, {
+      active: e === 1,
+      prefix: "one-selected-button"
+    }),
     [a, e, u]
   ), h = n.useMemo(
-    () => a(f, { active: e > 1, prefix: "many-selected-button" }),
+    () => a(f, {
+      active: e > 1,
+      prefix: "many-selected-button"
+    }),
     [a, f, e]
   ), C = n.useMemo(
     () => [
-      ...x,
       ...y,
       ...b,
-      ...h
+      ...h,
+      ...x
     ],
-    [x, h, y, b]
+    [
+      x,
+      h,
+      y,
+      b
+    ]
   );
   return /* @__PURE__ */ t(
     D,
@@ -114,7 +134,9 @@ const s = [], A = [], Y = I({
       ) : null
     }
   );
-}, z = n.memo(w);
+}, z = n.memo(
+  w
+);
 z.displayName = "EFWTableCommandBar";
 export {
   z as EFWTableCommandBar

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

@@ -71,15 +71,50 @@ export interface EFWTableCommandBarProps<T extends readonly EFWFormFieldProps[]
     /** Textos localizados para labels internos del command bar. */
     localeText?: Partial<EFWTableLocaleText>;
 }
-export type DefaultDrawerButtonProps<T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]> = {
+/**
+ * Props del botón por defecto de un drawer (add/update/delete) de la tabla.
+ *
+ * @template T          - Tupla/array de TODOS los fields de la tabla (esquema completo).
+ * @template TFormFields - Tupla/array de fields que renderiza el formulario del drawer.
+ *
+ * `TFormFields` por defecto es `readonly T[number][]` (todos los fields de la
+ * tabla), manteniendo el comportamiento histórico: los callbacks del form
+ * (`onValuesChange`, `fieldLogic`, `onInit`, `defaultValues`) se tipan contra
+ * el esquema completo de la tabla.
+ *
+ * Para que esos callbacks se tipen contra un **subconjunto** (lo habitual cuando
+ * algunas columnas las asigna el backend), anota el tipo explícitamente con la
+ * tupla del subconjunto:
+ *
+ * ```ts
+ * const cfg: DefaultDrawerButtonProps<TableFields, SubsetFields> = {
+ *   form: { fields: subsetFields, onValuesChange: handleSubsetValues },
+ * };
+ * ```
+ *
+ * Nota: a través de `EFWTableProps<T>['addButtonConfig']` la inferencia de
+ * `TFormFields` no es posible (propiedad anidada); en ese punto los callbacks
+ * se tipan contra el esquema completo (backward compatible). Usa anotación
+ * explícita cuando necesites precisión por subconjunto.
+ */
+export type DefaultDrawerButtonProps<T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[], TFormFields extends readonly EFWFormFieldProps[] = readonly T[number][]> = {
     enabled?: boolean | ((selectedRows: EFWTableRow<EFWTableItem<T>>[], tableMethods: EFWTableMethods<T>) => boolean);
     insertPosition?: EFWTableInsertPosition;
-    form?: Omit<EFWFormProps<T>, 'formRef'> & {
-        fields?: T;
+    form?: Omit<EFWFormProps<TFormFields>, 'formRef'> & {
+        /**
+         * Subconjunto válido de los fields de la tabla.
+         *
+         * Permite que el formulario del drawer pida solo un subconjunto de campos
+         * (lo habitual cuando algunas columnas las asigna el backend). Cada
+         * elemento debe ser un field válido de la tabla (`T[number]`); un campo
+         * ajeno se rechaza con error de tipo. Pasar la tupla completa sigue siendo
+         * válido (backward compatible).
+         */
+        fields?: TFormFields;
     };
     props?: EFWDrawerButtonProps & {
         drawerConfig?: Omit<EFWDrawerButtonProps['drawerConfig'], 'buttons'>;
     };
 };
 /** Configuración del botón de filtro. Igual que DefaultDrawerButtonProps sin `insertPosition`. */
-export type DefaultFilterButtonProps<T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]> = Omit<DefaultDrawerButtonProps<T>, 'insertPosition'>;
+export type DefaultFilterButtonProps<T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[], TFormFields extends readonly EFWFormFieldProps[] = readonly T[number][]> = Omit<DefaultDrawerButtonProps<T, TFormFields>, 'insertPosition'>;

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

@@ -3,12 +3,17 @@ import { EFWFormProps, EFWFormFieldProps } from '../../../../forms/EFWForm';
 import { EFWTableProps } from '../../EFWTable.types';
 
 /**
- * Crea la configuración del formulario basada en si tiene sections o fields
+ * Crea la configuración del formulario basada en si tiene sections o fields.
+ *
+ * El tipo de fields del formulario resultante es `TFormFields` (por defecto
+ * `readonly T[number][]`, es decir, todos los fields de la tabla), de modo que
+ * los callbacks internos del form se tipan contra el esquema que realmente se
+ * renderiza y NO se fuerza un cast al esquema completo `T`.
  */
-export declare const generateFormProps: <T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]>(fields?: EFWTableProps<T>["fields"], formProps?: DefaultDrawerButtonProps<T>["form"]) => EFWFormProps<T>;
+export declare const generateFormProps: <T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[], TFormFields extends readonly EFWFormFieldProps[] = readonly T[number][]>(fields?: EFWTableProps<T>["fields"], formProps?: DefaultDrawerButtonProps<T, TFormFields>["form"]) => EFWFormProps<TFormFields>;
 /**
  * Fusiona de manera profunda la configuración predeterminada con la configuración proporcionada,
  * priorizando la configuración proporcionada donde haya solapamientos. Maneja fusiones anidadas
  * para 'props' y 'drawerConfig', y una fusión superficial para 'form' (o vacío si no se proporciona).
  */
-export declare const mergeButtonProps: <T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]>(defaultConfig: DefaultDrawerButtonProps<T>, overrideConfig?: DefaultDrawerButtonProps<T>) => DefaultDrawerButtonProps<T>;
+export declare const mergeButtonProps: <T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[], TFormFields extends readonly EFWFormFieldProps[] = readonly T[number][]>(defaultConfig: DefaultDrawerButtonProps<T, TFormFields>, overrideConfig?: DefaultDrawerButtonProps<T, TFormFields>) => DefaultDrawerButtonProps<T, TFormFields>;

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

@@ -4,9 +4,12 @@ const n = (s = [], e = {}) => e?.sections ? {
   gridTemplateColumns: void 0,
   fields: void 0
 } : {
-  fields: e?.fields ?? s,
   gridTemplateColumns: e?.gridTemplateColumns,
   ...e,
+  // `formProps.fields` puede ser un subconjunto de los fields de la tabla
+  // (ver DefaultDrawerButtonProps['form']['fields']). En runtime se usa el
+  // subconjunto provisto o, por defecto, todos los fields de la tabla.
+  fields: e?.fields ?? s,
   sections: void 0
 }, t = (s, e = {}) => ({
   enabled: e.enabled ?? s.enabled,

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

@@ -2,4 +2,4 @@ import { EFWFormFieldProps } from '../../../../forms/EFWForm';
 import { EFWTableCommandBarButton, DefaultDrawerButtonProps } from '../../components/EFWTableCommandBar/EFWTableCommandBar.types';
 import { EFWTableLocaleText } from '../../../../i18n';
 
-export declare const useDefaultAddButton: <T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]>(addButtonConfig: DefaultDrawerButtonProps<T>, localeText: EFWTableLocaleText) => EFWTableCommandBarButton<T>;
+export declare const useDefaultAddButton: <T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[], TFormFields extends readonly EFWFormFieldProps[] = readonly T[number][]>(addButtonConfig: DefaultDrawerButtonProps<T, TFormFields>, localeText: EFWTableLocaleText) => EFWTableCommandBarButton<T>;

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

@@ -6,20 +6,43 @@ import { mergeButtonProps as q, generateFormProps as G } from "../../components/
 import { useFormController as H } from "../../../../forms/EFWForm/EFWForm.hooks.js";
 import { EFWForm as J } from "../../../../forms/EFWForm/EFWForm.js";
 const te = (p, u) => {
-  const e = u, { formRef: m, getValues: f, validateForm: g, setDisabled: t, addMessageBar: a, removeAllMessagesBar: b } = H(), w = q({
-    enabled: !0,
-    props: {
-      children: e.addButtonLabel,
-      appearance: "primary",
-      icon: /* @__PURE__ */ n($, {}),
-      collapseLabel: "xs",
-      drawerConfig: {
-        title: e.addDrawerTitle,
-        size: "small",
-        position: "end"
+  const e = u, {
+    formRef: m,
+    getValues: f,
+    validateForm: g,
+    setDisabled: t,
+    addMessageBar: a,
+    removeAllMessagesBar: b
+  } = H(), w = q(
+    {
+      enabled: !0,
+      props: {
+        children: e.addButtonLabel,
+        appearance: "primary",
+        icon: /* @__PURE__ */ n($, {}),
+        collapseLabel: "xs",
+        drawerConfig: {
+          title: e.addDrawerTitle,
+          size: "small",
+          position: "end"
+        }
       }
-    }
-  }, p), { enabled: C, props: T, form: x, insertPosition: y = "start" } = w, { children: s, appearance: B, icon: i, collapseLabel: D, drawerConfig: F, style: L, className: R } = T || {}, {
+    },
+    p
+  ), {
+    enabled: C,
+    props: T,
+    form: x,
+    insertPosition: y = "start"
+  } = w, {
+    children: s,
+    appearance: B,
+    icon: i,
+    collapseLabel: D,
+    drawerConfig: F,
+    style: L,
+    className: R
+  } = T || {}, {
     title: h,
     size: E,
     position: k,
@@ -52,7 +75,14 @@ const te = (p, u) => {
             loadingContentText: e.drawerLoadingContentText,
             ...A ?? {}
           },
-          content: /* @__PURE__ */ n(J, { formRef: m, description: S, ...j }),
+          content: /* @__PURE__ */ n(
+            J,
+            {
+              formRef: m,
+              description: S,
+              ...j
+            }
+          ),
           buttons: [
             {
               kind: "EFWButton",
@@ -78,7 +108,9 @@ const te = (p, u) => {
                         id: "add-operation-error",
                         intent: "error",
                         title: `${e.addErrorTitle}:`,
-                        message: c(r.failed[0].error)
+                        message: c(
+                          r.failed[0].error
+                        )
                       }), { success: !1 }) : (setTimeout(o, 100), { success: !0 });
                     } catch (r) {
                       return console.error(r), t(!1, l), a({

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

@@ -6,19 +6,37 @@ import { mergeButtonProps as O, generateFormProps as Q } from "../../components/
 import { useFormController as X } from "../../../../forms/EFWForm/EFWForm.hooks.js";
 import { EFWForm as Y } from "../../../../forms/EFWForm/EFWForm.js";
 const le = (b = {}, w) => {
-  const e = w, { formRef: T, getValues: x, validateForm: C, addMessageBar: l, setDisabled: n, removeAllMessagesBar: h } = X(), y = O({
-    enabled: !0,
-    props: {
-      children: e.updateButtonLabel,
-      icon: /* @__PURE__ */ o(K, {}),
-      collapseLabel: "xs",
-      drawerConfig: {
-        title: e.updateDrawerTitle,
-        size: "small",
-        position: "end"
+  const e = w, {
+    formRef: T,
+    getValues: x,
+    validateForm: C,
+    addMessageBar: l,
+    setDisabled: n,
+    removeAllMessagesBar: h
+  } = X(), y = O(
+    {
+      enabled: !0,
+      props: {
+        children: e.updateButtonLabel,
+        icon: /* @__PURE__ */ o(K, {}),
+        collapseLabel: "xs",
+        drawerConfig: {
+          title: e.updateDrawerTitle,
+          size: "small",
+          position: "end"
+        }
       }
-    }
-  }, b), { enabled: B, props: E, form: D } = y, { children: d, appearance: F, icon: c, collapseLabel: L, drawerConfig: R, style: k, className: M } = E || {}, {
+    },
+    b
+  ), { enabled: B, props: E, form: D } = y, {
+    children: d,
+    appearance: F,
+    icon: c,
+    collapseLabel: L,
+    drawerConfig: R,
+    style: k,
+    className: M
+  } = E || {}, {
     title: v,
     size: z,
     position: P,
@@ -51,7 +69,15 @@ const le = (b = {}, w) => {
             loadingContentText: e.drawerLoadingContentText,
             ...S ?? {}
           },
-          content: /* @__PURE__ */ o(Y, { defaultValues: u, formRef: T, description: j, ...U }),
+          content: /* @__PURE__ */ o(
+            Y,
+            {
+              defaultValues: u,
+              formRef: T,
+              description: j,
+              ...U
+            }
+          ),
           buttons: [
             {
               kind: "EFWButton",
@@ -69,16 +95,21 @@ const le = (b = {}, w) => {
                     const q = x(), m = n(!0);
                     h();
                     try {
-                      const t = await p.updateItem(N[0], { ...u, ...q });
+                      const t = await p.updateItem(
+                        N[0],
+                        { ...u, ...q }
+                      );
                       if (t.failed?.length) {
                         n(!1, m);
-                        const G = t.failed.map((r) => {
-                          const g = f(r.error);
-                          return {
-                            key: `update-error-${r.index}-${g}`,
-                            message: g
-                          };
-                        }), H = t.failed.length > 1;
+                        const G = t.failed.map(
+                          (r) => {
+                            const g = f(r.error);
+                            return {
+                              key: `update-error-${r.index}-${g}`,
+                              message: g
+                            };
+                          }
+                        ), H = t.failed.length > 1;
                         return l({
                           id: "update-operation-error",
                           intent: "error",

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

@@ -1,12 +1,13 @@
 import { EFWFormFieldType, EFWFormFieldProps, EFWFormFieldValue } from '../../../forms/EFWForm';
 import { EFWTableItem, ColumnRenderers } from '../EFWTable.types';
-import * as React from "react";
+import type * as React from 'react';
 /**
  * Renderiza el contenido de una celda con sistema de caché optimizado
  */
 export declare const renderCellContent: <T extends EFWFormFieldType>(field: EFWFormFieldProps<T>, value: EFWFormFieldValue<T>, item: EFWTableItem, rowIndex: number, columnRenderers?: ColumnRenderers, useDefaultAsFallback?: boolean) => React.ReactNode;
 export type { CacheEntry, ResolvedRenderer, CellRendererProps } from './types';
 export { generateId } from './general';
+export { completeItemWithEmptyValues } from './itemCompletion';
 export { addRowId, ensureItemRowId } from './typeHelpers';
 export { setRenderContextVersion, getRenderContextVersion } from './context';
 export { clearRenderCache, getRenderCacheStats } from './cache';

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

@@ -1,27 +1,29 @@
-import { jsx as m } from "react/jsx-runtime";
-import { CellRenderer as x } from "./CellRenderer/CellRenderer.js";
-import { generateId as f } from "./general.js";
-import { addRowId as c, ensureItemRowId as i } from "./typeHelpers.js";
-import { getRenderContextVersion as g, setRenderContextVersion as u } from "./context.js";
-import { clearRenderCache as w, getRenderCacheStats as V } from "./cache.js";
-const C = (e, r, t, o, n, d = !0) => /* @__PURE__ */ m(
-  x,
+import { jsx as d } from "react/jsx-runtime";
+import { CellRenderer as p } from "./CellRenderer/CellRenderer.js";
+import { generateId as C } from "./general.js";
+import { completeItemWithEmptyValues as c } from "./itemCompletion.js";
+import { addRowId as I, ensureItemRowId as u } from "./typeHelpers.js";
+import { getRenderContextVersion as h, setRenderContextVersion as V } from "./context.js";
+import { clearRenderCache as j, getRenderCacheStats as y } from "./cache.js";
+const a = (e, r, t, o, n, m = !0) => /* @__PURE__ */ d(
+  p,
   {
     field: e,
     value: r,
     item: t,
     rowIndex: o,
     columnRenderers: n,
-    useDefaultAsFallback: d
+    useDefaultAsFallback: m
   }
 );
 export {
-  c as addRowId,
-  w as clearRenderCache,
-  i as ensureItemRowId,
-  f as generateId,
-  V as getRenderCacheStats,
-  g as getRenderContextVersion,
-  C as renderCellContent,
-  u as setRenderContextVersion
+  I as addRowId,
+  j as clearRenderCache,
+  c as completeItemWithEmptyValues,
+  u as ensureItemRowId,
+  C as generateId,
+  y as getRenderCacheStats,
+  h as getRenderContextVersion,
+  a as renderCellContent,
+  V as setRenderContextVersion
 };

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

@@ -0,0 +1,32 @@
+import { EFWFormFieldProps } from '../../../forms/EFWForm';
+
+/**
+ * Completa un item con los valores vacíos normalizados para toda field de la
+ * tabla que no esté presente en el item.
+ *
+ * Motivo: cuando el formulario de creación (drawer de add) pide un subconjunto
+ * de fields, `getValues()` solo contiene las keys renderizadas. El item que se
+ * guarda localmente queda entonces con keys ausentes, lo que contradice el tipo
+ * `EFWTableItem<T>` (todas las claves presentes) y puede romper en runtime en
+ * tipos que no toleran `undefined` (p. ej. `Choice`/`MultiChoice`, tipados como
+ * arrays).
+ *
+ * Esta función restaura la coherencia tipo/runtime rellenando las keys
+ * faltantes con el valor vacío correspondiente (`''`, `null`, `[]`, `false`),
+ * usando la misma fuente de verdad que `EFWForm` para los valores iniciales.
+ *
+ * - No sobrescribe keys presentes (respeta los valores que ya trae el item,
+ *   incluido `undefined` explícito).
+ * - No toca `_rowId` (lo gestiona `addRowId` después).
+ * - **Fast-path**: si el item ya trae todas las keys de `fields`, se devuelve
+ *   sin clonar ni recorrer de nuevo (solo el escaneo O(fields), sin
+ *   asignaciones). Esto evita degradar `addItems` en importaciones masivas
+ *   donde los items ya cumplen el contrato tipado.
+ * - Usa `hasOwnKey` (propiedad propia, no `in`) para no considerar claves
+ *   heredadas de `Object.prototype` (`constructor`, `toString`, ...).
+ *
+ * @param fields - Fields de la tabla (esquema completo).
+ * @param item - Item a completar.
+ * @returns El item con todas las claves de `fields` presentes.
+ */
+export declare const completeItemWithEmptyValues: <T extends readonly EFWFormFieldProps[], Item extends Record<string, unknown>>(fields: T, item: Item) => Item;

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

@@ -0,0 +1,23 @@
+import { getEmptyValueForFieldType as l } from "../../../forms/EFWForm/EFWForm.utils.js";
+const a = (t, e) => (
+  // biome-ignore lint/complexity/useObjectHasOwn: el target de tsconfig es < es2022 y Object.hasOwn no está disponible
+  Object.prototype.hasOwnProperty.call(t, e)
+), c = (t, e) => {
+  let n = !1;
+  for (const o of t)
+    if (!a(e, o.internalName)) {
+      n = !0;
+      break;
+    }
+  if (!n)
+    return e;
+  const r = { ...e };
+  for (const o of t) {
+    const s = o.internalName;
+    a(r, s) || (r[s] = l(o.typeAsString));
+  }
+  return r;
+};
+export {
+  c as completeItemWithEmptyValues
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@envisiongroup/porygon",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Librerias de componentes de React creados por la empresa Envision",
   "license": "CC-BY-ND-4.0",
   "main": "./dist/index.js",
@@ -95,7 +95,7 @@
     "@fluentui/react-datepicker-compat": "0.6.24",
     "@fluentui/react-icons": "2.0.319",
     "@griffel/react": "1.5.0",
-    "@storybook/react": "^10.2.13",
+    "@storybook/react": "^10.5.4",
     "@tanstack/react-table": "8.21.3",
     "@tanstack/react-virtual": "3.13.9",
     "@testing-library/jest-dom": "^6.9.1",