@lowdefy/blocks-aggrid 5.6.0 → 6.0.0

package/dist/processColDefs.js

@@ -16,7 +16,7 @@
 import { type } from '@lowdefy/helpers';
 import { getCellRenderer } from './cellRenderers/index.js';
 import createEllipsisCell from './cellRenderers/EllipsisCell.js';
-function applyEllipsis(colDef, ellipsis) {
+function applyEllipsis(colDef, ellipsis, makeEllipsisRenderer) {
     if (!type.isInt(ellipsis) || ellipsis < 1) return colDef;
     const clampClass = `lf-ellipsis-${Math.min(ellipsis, 6)}`;
     const existingClass = colDef.cellClass;
@@ -34,7 +34,7 @@ function applyEllipsis(colDef, ellipsis) {
     // ag-grid's internal cell wrappers. Skip if a cellRenderer is already set
     // (user or built-in cell.type takes precedence and can opt in via CSS).
     if (!colDef.cellRenderer) {
-        next.cellRenderer = createEllipsisCell(ellipsis);
+        next.cellRenderer = makeEllipsisRenderer();
     }
     return next;
 }
@@ -66,41 +66,76 @@ function applyAlignment(colDef, cell) {
         headerClass
     };
 }
-function buildCellRenderer({ cell, methods, components }) {
-    const Renderer = getCellRenderer(cell?.type);
-    if (!Renderer) return undefined;
-    // ag-grid calls the renderer as a React function component when returned directly.
-    return function CellRendererAdapter(params) {
-        return Renderer({
-            ...params,
-            cellConfig: cell,
-            methods,
-            components
-        });
-    };
+// A cellRenderer is a React element type, so a new function is a different
+// component: CellCtrl.refreshCellRenderer bails when `cellRendererClass !==
+// componentClass`, and the React cell comp re-keys. Building the renderers fresh on
+// every render therefore unmounted every cell whenever anything re-rendered the
+// block, destroying whatever a cell was holding — an open popup, a focused input, a
+// half-typed value in the selector / textInput / paragraphInput cells.
+//
+// So the adapter installed on the colDef is created once per column and kept, and
+// the closure it calls is replaced in place. ag-grid keeps the cell; the cell
+// renders the current config.
+function stableRenderer(entry, slot, render) {
+    let stable = entry[slot];
+    if (!stable) {
+        const box = {
+            render
+        };
+        // ag-grid calls the renderer as a React function component when returned directly.
+        function CellRendererAdapter(params) {
+            return box.render(params);
+        }
+        stable = {
+            box,
+            Adapter: CellRendererAdapter
+        };
+        entry[slot] = stable;
+    }
+    stable.box.render = render;
+    return stable.Adapter;
+}
+// Keyed by colId or field so an adapter survives a column reorder, falling back to
+// position for columns that declare neither. A key already taken in this pass gets a
+// suffix, so two columns sharing a field do not share an adapter.
+function colKey(col, index, prefix, seen) {
+    const id = type.isString(col.colId) ? col.colId : type.isString(col.field) ? col.field : `${index}`;
+    const base = `${prefix}${id}`;
+    let key = base;
+    let n = 1;
+    while(seen.has(key)){
+        key = `${base}#${n}`;
+        n += 1;
+    }
+    seen.add(key);
+    return key;
 }
-function recProcessColDefs(columnDefs, methods, components) {
-    return columnDefs.map((col)=>{
+function recProcessColDefs(columnDefs, methods, components, cache, seen, prefix) {
+    return columnDefs.map((col, index)=>{
+        const key = colKey(col, index, prefix, seen);
+        const entry = cache.get(key) ?? {};
+        cache.set(key, entry);
         const newColDef = {};
         if (type.isArray(col.children)) {
-            newColDef.children = recProcessColDefs(col.children, methods, components);
+            newColDef.children = recProcessColDefs(col.children, methods, components, cache, seen, `${key}/`);
         }
         if (type.isObject(col.cell) && type.isString(col.cell.type)) {
-            const renderer = buildCellRenderer({
-                cell: col.cell,
-                methods,
-                components
-            });
-            if (renderer) {
-                newColDef.cellRenderer = renderer;
+            const Renderer = getCellRenderer(col.cell.type);
+            if (Renderer) {
+                const cell = col.cell;
+                newColDef.cellRenderer = stableRenderer(entry, 'cell', (params)=>Renderer({
+                        ...params,
+                        cellConfig: cell,
+                        methods,
+                        components
+                    }));
             }
         } else if (type.isFunction(col.cellRenderer)) {
-            newColDef.cellRenderer = (params)=>{
-                return renderHtml({
-                    html: col.cellRenderer(params),
+            const cellRenderer = col.cellRenderer;
+            newColDef.cellRenderer = stableRenderer(entry, 'cell', (params)=>renderHtml({
+                    html: cellRenderer(params),
                     methods
-                });
-            };
+                }));
         }
         const merged = {
             ...col,
@@ -110,10 +145,18 @@ function recProcessColDefs(columnDefs, methods, components) {
         delete merged.cell;
         delete merged.ellipsis;
         const aligned = applyAlignment(merged, col.cell);
-        return applyEllipsis(aligned, col.ellipsis);
+        return applyEllipsis(aligned, col.ellipsis, ()=>stableRenderer(entry, 'ellipsis', createEllipsisCell(col.ellipsis)));
     });
 }
-function processColDefs(columnDefs = [], methods, components) {
-    return recProcessColDefs(columnDefs, methods, components);
+function processColDefs(columnDefs = [], methods, components, cache = new Map()) {
+    const seen = new Set();
+    const processed = recProcessColDefs(columnDefs, methods, components, cache, seen, '');
+    // Drop columns that are no longer defined, so a grid whose columns come and go does
+    // not accumulate adapters. A column that returns gets a fresh one, which is correct
+    // — its cells were unmounted with it.
+    for (const key of cache.keys()){
+        if (!seen.has(key)) cache.delete(key);
+    }
+    return processed;
 }
 export default processColDefs;

package/dist/useColDefs.js

@@ -0,0 +1,65 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { useEffect, useRef } from 'react';
+import { type } from '@lowdefy/helpers';
+import processColDefs from './processColDefs.js';
+// Fingerprint the authored columnDefs, functions included. JSON.stringify drops
+// function values unless a replacer returns something for them, and a cellRenderer or
+// valueGetter built by an operator is a new function on every evaluation — so identity
+// is the only signal available that one of them changed.
+function fingerprint(columnDefs) {
+    const functions = [];
+    const json = JSON.stringify(columnDefs, (_key, value)=>{
+        if (type.isFunction(value)) {
+            functions.push(value);
+            return `__fn__${functions.length - 1}`;
+        }
+        return value;
+    });
+    return {
+        json,
+        functions
+    };
+}
+function unchanged(previous, next) {
+    if (!previous) return false;
+    if (previous.json !== next.json) return false;
+    if (previous.functions.length !== next.functions.length) return false;
+    return previous.functions.every((fn, index)=>fn === next.functions[index]);
+}
+// Cell renderers keep their identity across renders (see processColDefs), which is
+// what stops ag-grid destroying a cell mid-interaction — but it also means nothing
+// replaces a cell when its column definition changes. ag-grid refreshes body cells on
+// a data change; it does not listen for colDefChanged. So ask it: refreshCells
+// re-renders the mounted cells in place with the new definition. It passes
+// `newData: false`, so React keeps the instances, and with them whatever the cell
+// was holding.
+function useColDefs({ columnDefs, methods, components, gridRef }) {
+    const cache = useRef(new Map());
+    const previous = useRef();
+    const processed = processColDefs(columnDefs, methods, components, cache.current);
+    useEffect(()=>{
+        const next = fingerprint(columnDefs);
+        const first = previous.current === undefined;
+        const same = unchanged(previous.current, next);
+        previous.current = next;
+        if (first || same) return;
+        gridRef.current?.api?.refreshCells({
+            force: true
+        });
+    });
+    return processed;
+}
+export default useColDefs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/blocks-aggrid",
-  "version": "5.6.0",
+  "version": "6.0.0",
   "license": "Apache-2.0",
   "description": "AgGrid Blocks for Lowdefy.",
   "homepage": "https://lowdefy.com",
@@ -44,25 +44,25 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/block-utils": "5.6.0",
-    "@lowdefy/blocks-antd": "5.6.0",
-    "@lowdefy/helpers": "5.6.0",
+    "@lowdefy/block-utils": "6.0.0",
+    "@lowdefy/blocks-antd": "6.0.0",
+    "@lowdefy/helpers": "6.0.0",
     "ag-grid-community": "33.3.2",
     "ag-grid-react": "33.3.2"
   },
   "peerDependencies": {
-    "@ant-design/icons": ">=6",
+    "@ant-design/icons": "6.1.0",
     "antd": ">=6",
-    "dayjs": ">=1.11",
+    "dayjs": "1.11.20",
     "react": ">=18",
     "react-dom": ">=18"
   },
   "devDependencies": {
-    "@lowdefy/block-dev-e2e": "5.6.0",
-    "@lowdefy/e2e-utils": "5.6.0",
-    "@playwright/test": "1.50.1",
-    "@swc/cli": "0.8.0",
-    "@swc/core": "1.15.18",
+    "@lowdefy/block-dev-e2e": "6.0.0",
+    "@lowdefy/e2e-utils": "6.0.0",
+    "@playwright/test": "1.59.1",
+    "@swc/cli": "0.8.1",
+    "@swc/core": "1.15.32",
     "copyfiles": "2.4.1"
   },
   "publishConfig": {
@@ -71,7 +71,7 @@
   "scripts": {
     "build": "swc src --out-dir dist --config-file ../../../../.swcrc --cli-config-file ../../../../.swc-cli.json && pnpm copyfiles",
     "clean": "rm -rf dist",
-    "copyfiles": "copyfiles -u 1 \"./src/**/*\" dist -e \"./src/**/*.js\" -e \"./src/**/*.yaml\" -e \"./src/**/*.snap\"",
+    "copyfiles": "copyfiles -u 1 \"./src/**/*\" dist -e \"./src/**/*.js\" -e \"./src/**/*.snap\"",
     "e2e": "playwright test --config e2e/playwright.config.js",
     "e2e:ui": "playwright test --config e2e/playwright.config.js --ui"
   }