@wavemaker-ai/react-runtime 1.0.0-rc.309

package/components/data/table/components/index.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AddNewRow", {
+  enumerable: true,
+  get: function get() {
+    return _AddNewRow.AddNewRow;
+  }
+});
+Object.defineProperty(exports, "EditableCell", {
+  enumerable: true,
+  get: function get() {
+    return _EditableCell.EditableCell;
+  }
+});
+Object.defineProperty(exports, "FieldValidationError", {
+  enumerable: true,
+  get: function get() {
+    return _FieldValidationError.FieldValidationError;
+  }
+});
+Object.defineProperty(exports, "GlobalSearchFilter", {
+  enumerable: true,
+  get: function get() {
+    return _TableFilters.GlobalSearchFilter;
+  }
+});
+Object.defineProperty(exports, "RowExpansionButton", {
+  enumerable: true,
+  get: function get() {
+    return _RowExpansionButton.RowExpansionButton;
+  }
+});
+Object.defineProperty(exports, "SummaryCell", {
+  enumerable: true,
+  get: function get() {
+    return _SummaryCell.SummaryCell;
+  }
+});
+Object.defineProperty(exports, "SummaryRow", {
+  enumerable: true,
+  get: function get() {
+    return _SummaryRow.SummaryRow;
+  }
+});
+Object.defineProperty(exports, "SummaryRowFooter", {
+  enumerable: true,
+  get: function get() {
+    return _SummaryRowFooter.SummaryRowFooter;
+  }
+});
+Object.defineProperty(exports, "TableBodyComponent", {
+  enumerable: true,
+  get: function get() {
+    return _TableBody.TableBodyComponent;
+  }
+});
+Object.defineProperty(exports, "TableFilterRow", {
+  enumerable: true,
+  get: function get() {
+    return _TableFilters.TableFilterRow;
+  }
+});
+Object.defineProperty(exports, "TableFooterActions", {
+  enumerable: true,
+  get: function get() {
+    return _TableFooterActions.TableFooterActions;
+  }
+});
+Object.defineProperty(exports, "TableHeaderComponent", {
+  enumerable: true,
+  get: function get() {
+    return _TableHeader.TableHeaderComponent;
+  }
+});
+Object.defineProperty(exports, "TablePanelHeading", {
+  enumerable: true,
+  get: function get() {
+    return _TablePanelHeading.TablePanelHeading;
+  }
+});
+var _TablePanelHeading = require("./TablePanelHeading");
+var _TableFooterActions = require("./TableFooterActions");
+var _AddNewRow = require("./AddNewRow");
+var _EditableCell = require("./EditableCell");
+var _FieldValidationError = require("./FieldValidationError");
+var _TableBody = require("./TableBody");
+var _TableHeader = require("./TableHeader");
+var _RowExpansionButton = require("./RowExpansionButton");
+var _TableFilters = require("./TableFilters");
+var _SummaryRowFooter = require("./SummaryRowFooter");
+var _SummaryRow = require("./SummaryRow");
+var _SummaryCell = require("./SummaryCell");

package/components/data/table/hooks/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./useTableData";
+export * from "./useFormWidget";
+export * from "./useTableEdit";
+export * from "./usePanelStructure";
+export * from "./useTableColumns";
+export * from "./useRowSelection";
+export { useTableState } from "./useTableState";
+export * from "./useCellState";
+export * from "./useEditingState";
+export * from "./useRowHandlers";
+export * from "./usePaginationState";
+export * from "./useTableInitialization";
+export * from "./useRowExpansion";
+export * from "./useServerSideSorting";
+export * from "./useTableEffects";
+export * from "./useTableStateManager";
+export * from "./useTableFilter";
+export * from "./useDynamicColumns";
+export * from "./useCustomExpressionColumns";

package/components/data/table/hooks/index.js

@@ -0,0 +1,231 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  useTableState: true
+};
+Object.defineProperty(exports, "useTableState", {
+  enumerable: true,
+  get: function get() {
+    return _useTableState.useTableState;
+  }
+});
+var _useTableData = require("./useTableData");
+Object.keys(_useTableData).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useTableData[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useTableData[key];
+    }
+  });
+});
+var _useFormWidget = require("./useFormWidget");
+Object.keys(_useFormWidget).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useFormWidget[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useFormWidget[key];
+    }
+  });
+});
+var _useTableEdit = require("./useTableEdit");
+Object.keys(_useTableEdit).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useTableEdit[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useTableEdit[key];
+    }
+  });
+});
+var _usePanelStructure = require("./usePanelStructure");
+Object.keys(_usePanelStructure).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _usePanelStructure[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _usePanelStructure[key];
+    }
+  });
+});
+var _useTableColumns = require("./useTableColumns");
+Object.keys(_useTableColumns).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useTableColumns[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useTableColumns[key];
+    }
+  });
+});
+var _useRowSelection = require("./useRowSelection");
+Object.keys(_useRowSelection).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useRowSelection[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useRowSelection[key];
+    }
+  });
+});
+var _useTableState = require("./useTableState");
+var _useCellState = require("./useCellState");
+Object.keys(_useCellState).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useCellState[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useCellState[key];
+    }
+  });
+});
+var _useEditingState = require("./useEditingState");
+Object.keys(_useEditingState).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useEditingState[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useEditingState[key];
+    }
+  });
+});
+var _useRowHandlers = require("./useRowHandlers");
+Object.keys(_useRowHandlers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useRowHandlers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useRowHandlers[key];
+    }
+  });
+});
+var _usePaginationState = require("./usePaginationState");
+Object.keys(_usePaginationState).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _usePaginationState[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _usePaginationState[key];
+    }
+  });
+});
+var _useTableInitialization = require("./useTableInitialization");
+Object.keys(_useTableInitialization).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useTableInitialization[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useTableInitialization[key];
+    }
+  });
+});
+var _useRowExpansion = require("./useRowExpansion");
+Object.keys(_useRowExpansion).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useRowExpansion[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useRowExpansion[key];
+    }
+  });
+});
+var _useServerSideSorting = require("./useServerSideSorting");
+Object.keys(_useServerSideSorting).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useServerSideSorting[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useServerSideSorting[key];
+    }
+  });
+});
+var _useTableEffects = require("./useTableEffects");
+Object.keys(_useTableEffects).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useTableEffects[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useTableEffects[key];
+    }
+  });
+});
+var _useTableStateManager = require("./useTableStateManager");
+Object.keys(_useTableStateManager).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useTableStateManager[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useTableStateManager[key];
+    }
+  });
+});
+var _useTableFilter = require("./useTableFilter");
+Object.keys(_useTableFilter).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useTableFilter[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useTableFilter[key];
+    }
+  });
+});
+var _useDynamicColumns = require("./useDynamicColumns");
+Object.keys(_useDynamicColumns).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useDynamicColumns[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useDynamicColumns[key];
+    }
+  });
+});
+var _useCustomExpressionColumns = require("./useCustomExpressionColumns");
+Object.keys(_useCustomExpressionColumns).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useCustomExpressionColumns[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useCustomExpressionColumns[key];
+    }
+  });
+});

package/components/data/table/hooks/use-edited-rows.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from "react";
+interface EditedRowsContextType {
+    updateCell: (rowId: string, field: string, value: any) => void;
+    getEdits: (rowId: string) => Record<string, any> | undefined;
+    getAllEdits: () => Record<string, Record<string, any>>;
+    subscribe: (rowId: string, callback: () => void) => () => void;
+    subscribeToAll: (callback: () => void) => () => void;
+    removeRowEdits: (rowId: string) => void;
+}
+export declare const EditedRowsProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useEditedRow: (rowId: string) => Record<string, any>;
+export declare const useEditedRowsContext: () => EditedRowsContextType;
+export declare const useUpdateEditedCell: () => (rowId: string, field: string, value: any) => void;
+export {};

package/components/data/table/hooks/use-edited-rows.js

@@ -0,0 +1,141 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useUpdateEditedCell = exports.useEditedRowsContext = exports.useEditedRow = exports.EditedRowsProvider = void 0;
+var _react = _interopRequireWildcard(require("react"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+var __jsx = _react["default"].createElement;
+var EditedRowsContext = /*#__PURE__*/(0, _react.createContext)({
+  updateCell: function updateCell() {},
+  getEdits: function getEdits() {
+    return undefined;
+  },
+  getAllEdits: function getAllEdits() {
+    return {};
+  },
+  subscribe: function subscribe() {
+    return function () {};
+  },
+  subscribeToAll: function subscribeToAll() {
+    return function () {};
+  },
+  removeRowEdits: function removeRowEdits() {}
+});
+var EditedRowsProvider = exports.EditedRowsProvider = function EditedRowsProvider(_ref) {
+  var children = _ref.children;
+  // Store the actual edited data
+  var editedRowsRef = (0, _react.useRef)({});
+
+  // Registry of listeners: rowId -> Set of callbacks
+  var listenersRef = (0, _react.useRef)({});
+
+  // Global listeners for any change
+  var globalListenersRef = (0, _react.useRef)(new Set());
+  var updateCell = (0, _react.useCallback)(function (rowId, field, value) {
+    // 1. Update the data
+    if (!editedRowsRef.current[rowId]) {
+      editedRowsRef.current[rowId] = {};
+    }
+
+    // Check if value actually changed to avoid unnecessary notifies
+    if (editedRowsRef.current[rowId][field] === value) return;
+    editedRowsRef.current[rowId][field] = value;
+
+    // 2. Notify row listeners
+    if (listenersRef.current[rowId]) {
+      listenersRef.current[rowId].forEach(function (cb) {
+        return cb();
+      });
+    }
+
+    // 3. Notify global listeners
+    if (globalListenersRef.current.size > 0) {
+      globalListenersRef.current.forEach(function (cb) {
+        return cb();
+      });
+    }
+  }, []);
+  var getEdits = (0, _react.useCallback)(function (rowId) {
+    return editedRowsRef.current[rowId];
+  }, []);
+  var getAllEdits = (0, _react.useCallback)(function () {
+    return editedRowsRef.current;
+  }, []);
+  var removeRowEdits = (0, _react.useCallback)(function (rowId) {
+    if (editedRowsRef.current[rowId]) {
+      delete editedRowsRef.current[rowId];
+      // Notify listeners so they can update (e.g. revert to original)
+      if (listenersRef.current[rowId]) {
+        listenersRef.current[rowId].forEach(function (cb) {
+          return cb();
+        });
+      }
+      // Notify global listeners
+      if (globalListenersRef.current.size > 0) {
+        globalListenersRef.current.forEach(function (cb) {
+          return cb();
+        });
+      }
+    }
+  }, []);
+  var subscribe = (0, _react.useCallback)(function (rowId, callback) {
+    if (!listenersRef.current[rowId]) {
+      listenersRef.current[rowId] = new Set();
+    }
+    listenersRef.current[rowId].add(callback);
+
+    // Unsubscribe function
+    return function () {
+      if (listenersRef.current[rowId]) {
+        listenersRef.current[rowId]["delete"](callback);
+        if (listenersRef.current[rowId].size === 0) {
+          delete listenersRef.current[rowId];
+        }
+      }
+    };
+  }, []);
+  var subscribeToAll = (0, _react.useCallback)(function (callback) {
+    globalListenersRef.current.add(callback);
+    return function () {
+      globalListenersRef.current["delete"](callback);
+    };
+  }, []);
+  return __jsx(EditedRowsContext.Provider, {
+    value: {
+      updateCell: updateCell,
+      getEdits: getEdits,
+      getAllEdits: getAllEdits,
+      subscribe: subscribe,
+      subscribeToAll: subscribeToAll,
+      removeRowEdits: removeRowEdits
+    }
+  }, children);
+};
+
+// Hook for components to subscribe to edits for a specific row
+var useEditedRow = exports.useEditedRow = function useEditedRow(rowId) {
+  var context = (0, _react.useContext)(EditedRowsContext);
+
+  // Local state to force re-render when subscription fires
+  // We use a simple counter
+  var _useState = (0, _react.useState)(0),
+    setTick = _useState[1];
+  (0, _react.useEffect)(function () {
+    var unsubscribe = context.subscribe(rowId, function () {
+      setTick(function (t) {
+        return t + 1;
+      });
+    });
+    return unsubscribe;
+  }, [context, rowId]);
+  return context.getEdits(rowId);
+};
+var useEditedRowsContext = exports.useEditedRowsContext = function useEditedRowsContext() {
+  return (0, _react.useContext)(EditedRowsContext);
+};
+var useUpdateEditedCell = exports.useUpdateEditedCell = function useUpdateEditedCell() {
+  return (0, _react.useContext)(EditedRowsContext).updateCell;
+};

package/components/data/table/hooks/useCellState.d.ts

@@ -0,0 +1,10 @@
+import { CellStateReturn } from "../props";
+/**
+ * Generic hook to manage table state
+ * @param tableId - Unique identifier for the table instance (e.g., table name)
+ */
+export declare const useCellState: (tableId: string) => CellStateReturn;
+export declare const getCellValue: <T = any>(state: CellStateReturn, rowId: string, fieldName: string, defaultValue?: T) => T | undefined;
+export declare const setCellValue: (state: CellStateReturn, rowId: string, fieldName: string, value: any) => void;
+export declare const getSelectedRowIds: (state: CellStateReturn) => string[];
+export declare const setSelectedRowIds: (state: CellStateReturn, rowIds: string[]) => void;

package/components/data/table/hooks/useCellState.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCellState = exports.setSelectedRowIds = exports.setCellValue = exports.getSelectedRowIds = exports.getCellValue = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _lodashEs = require("lodash-es");
+var _react = require("react");
+/**
+ * Generic hook to manage table state
+ * @param tableId - Unique identifier for the table instance (e.g., table name)
+ */
+var useCellState = exports.useCellState = function useCellState(tableId) {
+  // Store state with initial structure
+  var stateRef = (0, _react.useRef)({
+    cells: {},
+    selection: {
+      selectedRowIds: []
+    }
+  });
+
+  // Get a value from the state using lodash path
+  var getValue = (0, _react.useCallback)(function (path, defaultValue) {
+    return (0, _lodashEs.get)(stateRef.current, path, defaultValue);
+  }, []);
+
+  // Set a value in the state using lodash path
+  var setValue = (0, _react.useCallback)(function (path, value) {
+    var existingValue = (0, _lodashEs.get)(stateRef.current, path);
+
+    // Only set if different
+    if (!(0, _lodashEs.isEqual)(existingValue, value)) {
+      (0, _lodashEs.set)(stateRef.current, path, value);
+    }
+  }, []);
+
+  // Update multiple fields at once
+  var updateState = (0, _react.useCallback)(function (updates) {
+    if (typeof updates === "function") {
+      stateRef.current = updates((0, _lodashEs.cloneDeep)(stateRef.current));
+    } else {
+      Object.entries(updates).forEach(function (_ref) {
+        var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+          path = _ref2[0],
+          value = _ref2[1];
+        (0, _lodashEs.set)(stateRef.current, path, value);
+      });
+    }
+  }, []);
+
+  // Check if a path exists
+  var hasValue = (0, _react.useCallback)(function (path) {
+    return (0, _lodashEs.has)(stateRef.current, path);
+  }, []);
+
+  // Remove a value
+  var removeValue = (0, _react.useCallback)(function (path) {
+    (0, _lodashEs.unset)(stateRef.current, path);
+  }, []);
+
+  // Clear all state
+  var clearState = (0, _react.useCallback)(function () {
+    stateRef.current = {
+      cells: {},
+      selection: {
+        selectedRowIds: []
+      }
+    };
+  }, []);
+
+  // Get the entire state
+  var getState = (0, _react.useCallback)(function () {
+    return (0, _lodashEs.cloneDeep)(stateRef.current);
+  }, []);
+
+  // Set the entire state
+  var setState = (0, _react.useCallback)(function (state) {
+    stateRef.current = (0, _lodashEs.cloneDeep)(state);
+  }, []);
+  return {
+    getValue: getValue,
+    setValue: setValue,
+    updateState: updateState,
+    hasValue: hasValue,
+    removeValue: removeValue,
+    clearState: clearState,
+    getState: getState,
+    setState: setState,
+    tableId: tableId
+  };
+};
+
+// Helper functions for common operations
+var getCellValue = exports.getCellValue = function getCellValue(state, rowId, fieldName, defaultValue) {
+  return state.getValue(["cells", rowId, fieldName], defaultValue);
+};
+var setCellValue = exports.setCellValue = function setCellValue(state, rowId, fieldName, value) {
+  state.setValue(["cells", rowId, fieldName], value);
+};
+
+// Unified selection helpers - uses single selectedRowIds array for both radio and multiselect
+var getSelectedRowIds = exports.getSelectedRowIds = function getSelectedRowIds(state) {
+  var _state$getValue;
+  return (_state$getValue = state.getValue("selection.selectedRowIds", [])) !== null && _state$getValue !== void 0 ? _state$getValue : [];
+};
+var setSelectedRowIds = exports.setSelectedRowIds = function setSelectedRowIds(state, rowIds) {
+  state.setValue("selection.selectedRowIds", rowIds);
+};

package/components/data/table/hooks/useCustomExpressionColumns.d.ts

@@ -0,0 +1,16 @@
+import { type MutableRefObject } from "react";
+import { type CustomExpressionColumnSource, type CustomExpressionComponent } from "@/utils/custom-expression";
+export type UseCustomExpressionColumnsArgs = {
+    columnSource: CustomExpressionColumnSource;
+    listenerRef: MutableRefObject<unknown>;
+};
+/**
+ * Syncs parsed `customExpression` column renderers with the table column proxy:
+ * signature dedupe, stale async-merge guard, revision bumps for memoized cells.
+ */
+export declare function useCustomExpressionColumns({ columnSource, listenerRef, }: UseCustomExpressionColumnsArgs): {
+    customColumns: Record<string, CustomExpressionComponent>;
+    customColumnsRevision: number;
+    customExpressionSignature: string;
+    mergeParsedCustomColumns: () => Promise<void>;
+};