twico-ui 1.36.0 → 1.36.1

package/dist/index.d.cts

@@ -1927,7 +1927,9 @@ interface DatatableProps<T = any> extends Omit<React.HTMLAttributes<HTMLDivEleme
   /** #339: let end-users build their own combined columns at runtime. Adds a **"Combine columns…"** item to
    *  each column's ⋮ menu that opens an editor to fold other columns' data into that column (they show in its
    *  cell and their own columns hide); layout (inline/stacked) + labels are configurable, and "Uncombine"
-   *  restores them. The result is the same as a declarative `column.combine` and persists via `stateKey`.
+   *  restores them. The result is like a declarative `column.combine` and persists via `stateKey` — except a
+   *  runtime combine also applies the source-join value + render over a target's own `valueGetter`/`renderCell`
+   *  (so a synthetic getter-backed column can still be a target), which a declarative `combine` defers to (#369).
    *  @default false */
   columnCombining?: boolean;
   /** Make all columns editable by default (double-click a cell to edit; per-column `editable` overrides). @default false */
@@ -2179,7 +2181,11 @@ interface DatatableColumn<T = any> {
    *  (label-prefixed when `labels`), while the **cell render** additionally applies each source column's
    *  `valueFormatter`. The combined value is synthetic, so the column is display-only (never inline-editable).
    *  Supplying your own `valueGetter` and/or `renderCell` overrides the derived one(s) independently —
-   *  override `valueGetter` alone and the cell shows that value (not the source-join). */
+   *  override `valueGetter` alone and the cell shows that value (not the source-join). **This precedence is
+   *  for a *declarative* `combine` only.** A *runtime* combine the user builds via `columnCombining` (the ⋮ →
+   *  "Combine columns…" editor) is an explicit action, so it applies the source-join value + render even when
+   *  the target column has its own `valueGetter`/`renderCell` — a synthetic getter-backed column can still be
+   *  a combine target (#369). Uncombining restores the column's own value/render. */
   combine?: string[] | { fields: string[]; layout?: "inline" | "stack"; separator?: string; labels?: boolean };
   /** Header label. @default field ("Actions" for actions columns) */
   headerName?: string;

package/dist/index.d.ts

@@ -1927,7 +1927,9 @@ interface DatatableProps<T = any> extends Omit<React.HTMLAttributes<HTMLDivEleme
   /** #339: let end-users build their own combined columns at runtime. Adds a **"Combine columns…"** item to
    *  each column's ⋮ menu that opens an editor to fold other columns' data into that column (they show in its
    *  cell and their own columns hide); layout (inline/stacked) + labels are configurable, and "Uncombine"
-   *  restores them. The result is the same as a declarative `column.combine` and persists via `stateKey`.
+   *  restores them. The result is like a declarative `column.combine` and persists via `stateKey` — except a
+   *  runtime combine also applies the source-join value + render over a target's own `valueGetter`/`renderCell`
+   *  (so a synthetic getter-backed column can still be a target), which a declarative `combine` defers to (#369).
    *  @default false */
   columnCombining?: boolean;
   /** Make all columns editable by default (double-click a cell to edit; per-column `editable` overrides). @default false */
@@ -2179,7 +2181,11 @@ interface DatatableColumn<T = any> {
    *  (label-prefixed when `labels`), while the **cell render** additionally applies each source column's
    *  `valueFormatter`. The combined value is synthetic, so the column is display-only (never inline-editable).
    *  Supplying your own `valueGetter` and/or `renderCell` overrides the derived one(s) independently —
-   *  override `valueGetter` alone and the cell shows that value (not the source-join). */
+   *  override `valueGetter` alone and the cell shows that value (not the source-join). **This precedence is
+   *  for a *declarative* `combine` only.** A *runtime* combine the user builds via `columnCombining` (the ⋮ →
+   *  "Combine columns…" editor) is an explicit action, so it applies the source-join value + render even when
+   *  the target column has its own `valueGetter`/`renderCell` — a synthetic getter-backed column can still be
+   *  a combine target (#369). Uncombining restores the column's own value/render. */
   combine?: string[] | { fields: string[]; layout?: "inline" | "stack"; separator?: string; labels?: boolean };
   /** Header label. @default field ("Actions" for actions columns) */
   headerName?: string;

package/dist/index.mjs

@@ -9360,7 +9360,7 @@ function Datatable({
       for (const c of columnsProp) if (c && c.field != null) byField[c.field] = c;
       return [DIFF_OP_COLUMN, ...columnsProp.map((c) => {
         const cfg = combineCfg(userCombine[c.field] || c.combine);
-        const base = cfg && !c.valueGetter ? { ...c, valueGetter: combineValueGetter(combineSrcCols(cfg, byField), cfg) } : c;
+        const base = cfg && (!!userCombine[c.field] || !c.valueGetter) ? { ...c, valueGetter: combineValueGetter(combineSrcCols(cfg, byField), cfg) } : c;
         return { ...base, renderCell: (val, row) => renderDiffCell(base, val, row) };
       })];
     },
@@ -9411,15 +9411,17 @@ function Datatable({
       const cfg = combineCfg(userCombine[c.field] || c.combine);
       if (!cfg) continue;
       const srcCols = combineSrcCols(cfg, byField);
+      const explicit = !!userCombine[c.field];
+      const useJoin = explicit || !c.valueGetter;
       out[i] = {
         ...c,
         editable: false,
         // the combined value is synthetic — inline editing would write to a phantom field
-        valueGetter: c.valueGetter || combineValueGetter(srcCols, cfg),
-        // Consumer renderCell wins. If they overrode only valueGetter, fall back to the DEFAULT cell render
-        // (renderCell: undefined) so the cell shows THEIR value — keeping display in sync with what
-        // sort/filter/search/export use — rather than the auto source-join. Otherwise render the combined cell.
-        renderCell: c.renderCell || (c.valueGetter ? void 0 : ((value, row) => renderCombined(srcCols, row, cfg)))
+        valueGetter: useJoin ? combineValueGetter(srcCols, cfg) : c.valueGetter,
+        // In diff mode the diff `columns` memo already wrapped renderCell in renderDiffCell (over the enriched
+        // combined value) — keep that wrapper, or an EXPLICIT combine's `!explicit` short-circuit would strip the
+        // diff arrows / old→new styling (#369 review). Declarative diff already preserved it (c.renderCell truthy).
+        renderCell: isDiff ? c.renderCell : !explicit && c.renderCell || (useJoin ? ((value, row) => renderCombined(srcCols, row, cfg)) : void 0)
       };
     }
     return out;