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

package/components/data/table/utils/renderDisplayCell.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { WmTableColumnProps, CellStateReturn } from "../props";
+/**
+ * Renders a table cell based on the widget-type property of the column
+ * @param column - The column configuration
+ * @param rowData - The row data object
+ * @param listener - Optional event listener
+ * @param cellState - Optional cell state manager
+ * @returns React element for the cell content
+ */
+export declare const renderDisplayCell: (column: WmTableColumnProps, rowData: any, listener?: any, cellState?: CellStateReturn) => React.ReactElement;

package/components/data/table/utils/renderDisplayCell.js

@@ -0,0 +1,183 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderDisplayCell = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _react = _interopRequireDefault(require("react"));
+var _button = require("@wavemaker-ai/react-runtime/components/form/button");
+var _index = require("@wavemaker-ai/react-runtime/components/input/default/checkbox/index");
+var _label = require("@wavemaker-ai/react-runtime/components/basic/label");
+var _index2 = require("./index");
+var _anchor = require("@wavemaker-ai/react-runtime/components/basic/anchor");
+var _icon = require("@wavemaker-ai/react-runtime/components/basic/icon");
+var _picture = require("@wavemaker-ai/react-runtime/components/basic/picture");
+var _lodashEs = require("lodash-es");
+var _hooks = require("../hooks");
+var __jsx = _react["default"].createElement;
+/**
+ * Extracts common props from column configuration
+ */
+var extractCellProps = function extractCellProps(column, rowData) {
+  var fieldName = (0, _lodashEs.toString)((0, _lodashEs.get)(column, "field", ""));
+  var value = (0, _lodashEs.get)(rowData, fieldName, "");
+
+  // Extract props from column children if it's a React element
+  var childProps = /*#__PURE__*/_react["default"].isValidElement(column.children) ? (0, _lodashEs.get)(column.children, "props", {}) : {};
+  return {
+    fieldName: fieldName,
+    value: value,
+    caption: (0, _lodashEs.get)(childProps, "caption", value),
+    className: (0, _lodashEs.get)(childProps, "className", ""),
+    iconclass: (0, _lodashEs.get)(childProps, "iconclass", ""),
+    onClick: (0, _lodashEs.get)(childProps, "onClick", _lodashEs.noop)
+  };
+};
+
+/**
+ * Creates common props for all widget components
+ */
+var createBaseProps = function createBaseProps(fieldName, suffix, className, listener) {
+  return {
+    name: "".concat(fieldName, "_").concat(suffix),
+    className: className,
+    listener: listener
+  };
+};
+
+/**
+ * Widget renderer factory functions
+ */
+var widgetRenderers = {
+  WmButton: function WmButton(_ref) {
+    var column = _ref.column,
+      rowData = _ref.rowData,
+      listener = _ref.listener;
+    var _extractCellProps = extractCellProps(column, rowData),
+      fieldName = _extractCellProps.fieldName,
+      caption = _extractCellProps.caption,
+      className = _extractCellProps.className,
+      iconclass = _extractCellProps.iconclass,
+      _onClick = _extractCellProps.onClick;
+    var value = rowData[fieldName] || caption;
+    return __jsx(_button.WmButton, (0, _extends2["default"])({}, createBaseProps(fieldName, "button", className, listener), {
+      iconclass: iconclass,
+      caption: value || "Button",
+      onClick: function onClick(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        _onClick(rowData);
+      }
+    }));
+  },
+  WmCheckbox: function WmCheckbox(_ref2) {
+    var column = _ref2.column,
+      rowData = _ref2.rowData,
+      listener = _ref2.listener,
+      cellState = _ref2.cellState;
+    var _extractCellProps2 = extractCellProps(column, rowData),
+      fieldName = _extractCellProps2.fieldName,
+      value = _extractCellProps2.value,
+      className = _extractCellProps2.className;
+    var rowId = rowData._wmTableRowId || String(rowData.id) || "";
+
+    // Use cell state manager if available, otherwise use the value from data
+    var checkboxValue = cellState ? (0, _hooks.getCellValue)(cellState, rowId, fieldName, !!value) : !!value;
+    return __jsx(_index.WmCheckbox, (0, _extends2["default"])({}, createBaseProps(fieldName, "checkbox", className, listener), {
+      datavalue: checkboxValue,
+      onChange: function onChange(event, widget, newValue) {
+        if (cellState) {
+          (0, _hooks.setCellValue)(cellState, rowId, fieldName, newValue);
+        }
+      }
+    }));
+  },
+  WmAnchor: function WmAnchor(_ref3) {
+    var column = _ref3.column,
+      rowData = _ref3.rowData,
+      listener = _ref3.listener;
+    var _extractCellProps3 = extractCellProps(column, rowData),
+      fieldName = _extractCellProps3.fieldName,
+      className = _extractCellProps3.className,
+      caption = _extractCellProps3.caption;
+    var href = (0, _lodashEs.get)(rowData, column.field);
+    return __jsx(_anchor.WmAnchor, (0, _extends2["default"])({}, createBaseProps(fieldName, "anchor", className, listener), {
+      hyperlink: href || "",
+      caption: caption || href
+    }));
+  },
+  WmIcon: function WmIcon(_ref4) {
+    var column = _ref4.column,
+      rowData = _ref4.rowData,
+      listener = _ref4.listener;
+    var _extractCellProps4 = extractCellProps(column, rowData),
+      fieldName = _extractCellProps4.fieldName,
+      value = _extractCellProps4.value,
+      className = _extractCellProps4.className;
+    return __jsx(_icon.WmIcon, (0, _extends2["default"])({}, createBaseProps(fieldName, "icon", className, listener), {
+      iconclass: !(0, _lodashEs.isUndefined)(value) ? (0, _lodashEs.toString)(value) : "",
+      caption: !(0, _lodashEs.isUndefined)(value) ? (0, _lodashEs.toString)(value) : "Icon"
+    }));
+  },
+  WmPicture: function WmPicture(_ref5) {
+    var column = _ref5.column,
+      rowData = _ref5.rowData,
+      listener = _ref5.listener;
+    var _extractCellProps5 = extractCellProps(column, rowData),
+      fieldName = _extractCellProps5.fieldName,
+      value = _extractCellProps5.value,
+      caption = _extractCellProps5.caption,
+      className = _extractCellProps5.className;
+    return __jsx(_picture.WmPicture, (0, _extends2["default"])({}, createBaseProps(fieldName, "picture", className, listener), {
+      picturesource: !(0, _lodashEs.isUndefined)(value) ? (0, _lodashEs.toString)(value) : "",
+      alttext: caption || "Image alt text not provided"
+    }));
+  },
+  WmLabel: function WmLabel(_ref6) {
+    var column = _ref6.column,
+      rowData = _ref6.rowData,
+      listener = _ref6.listener;
+    var _extractCellProps6 = extractCellProps(column, rowData),
+      fieldName = _extractCellProps6.fieldName,
+      value = _extractCellProps6.value,
+      className = _extractCellProps6.className;
+    return __jsx(_label.WmLabel, (0, _extends2["default"])({}, createBaseProps(fieldName, "label", className, listener), {
+      caption: !(0, _lodashEs.isUndefined)(value) ? (0, _lodashEs.toString)(value) : "Label",
+      type: "p"
+    }));
+  },
+  // Special renderer for dynamic columns - renders raw text like Angular
+  "dynamic-text": function dynamicText(_ref7) {
+    var column = _ref7.column,
+      rowData = _ref7.rowData;
+    var fieldName = (0, _lodashEs.toString)((0, _lodashEs.get)(column, "field", ""));
+    var value = (0, _lodashEs.get)(rowData, fieldName, "");
+
+    // Return raw text content directly (no WmLabel wrapper)
+    return __jsx(_react["default"].Fragment, null, !(0, _lodashEs.isUndefined)(value) ? (0, _lodashEs.toString)(value) : "");
+  }
+};
+
+/**
+ * Renders a table cell based on the widget-type property of the column
+ * @param column - The column configuration
+ * @param rowData - The row data object
+ * @param listener - Optional event listener
+ * @param cellState - Optional cell state manager
+ * @returns React element for the cell content
+ */
+var renderDisplayCell = exports.renderDisplayCell = function renderDisplayCell(column, rowData, listener, cellState) {
+  var widgetType = (0, _lodashEs.get)(column, "widgetType", "label");
+  var mappedWidgetType = column.field ? (0, _index2.getWidgetMappingForType)(widgetType) : "dynamic-text";
+
+  // Get the appropriate renderer, defaulting to WmLabel
+  var renderer = (0, _lodashEs.get)(widgetRenderers, mappedWidgetType) || widgetRenderers.WmLabel;
+  return renderer({
+    column: column,
+    rowData: rowData,
+    listener: listener,
+    cellState: cellState
+  });
+};

package/components/data/table/utils/script-page-size-broadcast.d.ts

@@ -0,0 +1,2 @@
+export declare function subscribeToScriptPageSizeBroadcast(name: string, storageKey: string, onUpdate: (value: number) => void): () => void;
+export declare function broadcastScriptPageSize(name: string, callerStorageKey: string, value: number): void;

package/components/data/table/utils/script-page-size-broadcast.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.broadcastScriptPageSize = broadcastScriptPageSize;
+exports.subscribeToScriptPageSizeBroadcast = subscribeToScriptPageSizeBroadcast;
+/**
+ * When script calls selectPageSize on one tab's table, the widget name is shared
+ * so only the last-mounted table receives the call. This broadcasts the value
+ * to all tables with the same name so the first/active tab also gets the update.
+ */
+
+var listenersByTableName = new Map();
+function subscribeToScriptPageSizeBroadcast(name, storageKey, onUpdate) {
+  var key = name;
+  if (!listenersByTableName.has(key)) {
+    listenersByTableName.set(key, new Set());
+  }
+  var entry = {
+    storageKey: storageKey,
+    cb: function cb(value, callerStorageKey) {
+      if (callerStorageKey !== storageKey) {
+        onUpdate(value);
+      }
+    }
+  };
+  var listeners = listenersByTableName.get(name);
+  if (listeners) {
+    listeners.add(entry);
+  }
+  return function () {
+    var _listenersByTableName;
+    (_listenersByTableName = listenersByTableName.get(key)) === null || _listenersByTableName === void 0 || _listenersByTableName["delete"](entry);
+  };
+}
+function broadcastScriptPageSize(name, callerStorageKey, value) {
+  var entries = listenersByTableName.get(name);
+  if (entries) {
+    entries.forEach(function (_ref) {
+      var cb = _ref.cb;
+      return cb(value, callerStorageKey);
+    });
+  }
+}

package/components/data/table/utils/selectionUtils.d.ts

@@ -0,0 +1,37 @@
+import { CellStateReturn } from "../props";
+/**
+ * Check if an element has any of the interactive classes
+ */
+export declare const hasInteractiveClass: (element: HTMLElement) => boolean;
+/**
+ * Check if an element has interactive attributes
+ */
+export declare const hasInteractiveAttributes: (element: HTMLElement) => boolean;
+/**
+ * Check if element or its ancestors are interactive
+ */
+export declare const isInteractiveElement: (event: React.MouseEvent) => boolean;
+/**
+ * Get row IDs from dataset
+ */
+export declare const getRowIdsFromDataset: (dataset: any[]) => string[];
+/**
+ * Check if a row exists in dataset
+ */
+export declare const rowExistsInDataset: (rowId: string, dataset: any[]) => boolean;
+/**
+ * Unified selection state management functions
+ * Uses a single selectedRowIds array for both radio and multiselect modes:
+ * - Radio select: array contains at most 1 item (replaces on new selection)
+ * - Multiselect: array can contain multiple items (add/remove on selection)
+ */
+export declare const selectionStateHelpers: {
+    getSelection: (cellState: CellStateReturn) => string[];
+    setSelection: (cellState: CellStateReturn, rowId: string) => void;
+    addToSelection: (cellState: CellStateReturn, rowId: string) => void;
+    removeFromSelection: (cellState: CellStateReturn, rowId: string) => void;
+    toggleSelection: (cellState: CellStateReturn, rowId: string) => boolean;
+    setAllSelection: (cellState: CellStateReturn, rowIds: string[]) => void;
+    clearSelection: (cellState: CellStateReturn) => void;
+    isRowSelected: (cellState: CellStateReturn, rowId: string) => boolean;
+};

package/components/data/table/utils/selectionUtils.js

@@ -0,0 +1,165 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectionStateHelpers = exports.rowExistsInDataset = exports.isInteractiveElement = exports.hasInteractiveClass = exports.hasInteractiveAttributes = exports.getRowIdsFromDataset = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _hooks = require("../hooks");
+var _constants = require("./constants");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Check if an element has any of the interactive classes
+ */
+var hasInteractiveClass = exports.hasInteractiveClass = function hasInteractiveClass(element) {
+  if (!element.className || typeof element.className !== "string") return false;
+  var className = element.className;
+  var _iterator = _createForOfIteratorHelper(_constants.INTERACTIVE_CLASSES),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var interactiveClass = _step.value;
+      if (className.includes(interactiveClass)) {
+        return true;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return false;
+};
+
+/**
+ * Check if an element has interactive attributes
+ */
+var hasInteractiveAttributes = exports.hasInteractiveAttributes = function hasInteractiveAttributes(element) {
+  // Check contenteditable
+  if (element.getAttribute("contenteditable") === "true") {
+    return true;
+  }
+
+  // Check role attribute
+  var role = element.getAttribute("role");
+  if (role && _constants.INTERACTIVE_ROLES.includes(role)) {
+    return true;
+  }
+
+  // Check data-role attribute
+  var dataRole = element.getAttribute("data-role");
+  if (dataRole) {
+    var _iterator2 = _createForOfIteratorHelper(_constants.INTERACTIVE_DATA_ROLES),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var interactiveRole = _step2.value;
+        if (dataRole.includes(interactiveRole)) {
+          return true;
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+  return false;
+};
+
+/**
+ * Check if element or its ancestors are interactive
+ */
+var isInteractiveElement = exports.isInteractiveElement = function isInteractiveElement(event) {
+  var target = event.target;
+
+  // Check if it's a standard interactive HTML element
+  if (_constants.INTERACTIVE_TAG_NAMES.includes(target.tagName)) {
+    return true;
+  }
+
+  // Check element and its ancestors
+  var element = target;
+  while (element) {
+    if (hasInteractiveClass(element) || hasInteractiveAttributes(element)) {
+      return true;
+    }
+    element = element.parentElement;
+  }
+  return false;
+};
+
+/**
+ * Get row IDs from dataset
+ */
+var getRowIdsFromDataset = exports.getRowIdsFromDataset = function getRowIdsFromDataset(dataset) {
+  return dataset.map(function (row) {
+    return row._wmTableRowId || String(row.id);
+  });
+};
+
+/**
+ * Check if a row exists in dataset
+ */
+var rowExistsInDataset = exports.rowExistsInDataset = function rowExistsInDataset(rowId, dataset) {
+  return dataset.some(function (row) {
+    return row._wmTableRowId === rowId || String(row.id) === rowId;
+  });
+};
+
+/**
+ * Unified selection state management functions
+ * Uses a single selectedRowIds array for both radio and multiselect modes:
+ * - Radio select: array contains at most 1 item (replaces on new selection)
+ * - Multiselect: array can contain multiple items (add/remove on selection)
+ */
+var selectionStateHelpers = exports.selectionStateHelpers = {
+  // Get current selection (works for both modes)
+  getSelection: function getSelection(cellState) {
+    return (0, _hooks.getSelectedRowIds)(cellState);
+  },
+  // Set selection - replaces entire selection (for radio select)
+  setSelection: function setSelection(cellState, rowId) {
+    (0, _hooks.setSelectedRowIds)(cellState, [rowId]);
+  },
+  // Add to selection (for multiselect)
+  addToSelection: function addToSelection(cellState, rowId) {
+    var current = (0, _hooks.getSelectedRowIds)(cellState);
+    if (!current.includes(rowId)) {
+      (0, _hooks.setSelectedRowIds)(cellState, [].concat((0, _toConsumableArray2["default"])(current), [rowId]));
+    }
+  },
+  // Remove from selection (for multiselect)
+  removeFromSelection: function removeFromSelection(cellState, rowId) {
+    var current = (0, _hooks.getSelectedRowIds)(cellState);
+    (0, _hooks.setSelectedRowIds)(cellState, current.filter(function (id) {
+      return id !== rowId;
+    }));
+  },
+  // Toggle selection (for multiselect - adds if not present, removes if present)
+  toggleSelection: function toggleSelection(cellState, rowId) {
+    var current = (0, _hooks.getSelectedRowIds)(cellState);
+    var isSelected = current.includes(rowId);
+    if (isSelected) {
+      selectionStateHelpers.removeFromSelection(cellState, rowId);
+    } else {
+      selectionStateHelpers.addToSelection(cellState, rowId);
+    }
+    return !isSelected;
+  },
+  // Set all selections (for select all in multiselect)
+  setAllSelection: function setAllSelection(cellState, rowIds) {
+    (0, _hooks.setSelectedRowIds)(cellState, rowIds);
+  },
+  // Clear all selections
+  clearSelection: function clearSelection(cellState) {
+    (0, _hooks.setSelectedRowIds)(cellState, []);
+  },
+  // Check if a row is selected
+  isRowSelected: function isRowSelected(cellState, rowId) {
+    return (0, _hooks.getSelectedRowIds)(cellState).includes(rowId);
+  }
+};

package/components/data/table/utils/table-helpers.d.ts

@@ -0,0 +1,62 @@
+import { StorageType } from "@wavemaker-ai/react-runtime/utils/state-persistance";
+export interface TableSearchFilter {
+    field: string;
+    value: string | number | boolean | null | undefined;
+    matchMode: string;
+    type: string;
+}
+export interface FilterFieldObject {
+    value: string | number | boolean | null | undefined;
+    logicalOp: string;
+    matchMode: string;
+    type?: string;
+}
+export type FilterFieldsObject = Record<string, FilterFieldObject>;
+export interface TableSortState {
+    field: string;
+    direction: "asc" | "desc";
+}
+export interface TableStateData {
+    pagination: number;
+    pagesize?: number;
+    actualpagesize?: number;
+    selectedItem: Array<{
+        page: number;
+        index: number;
+    }>;
+    search?: TableSearchFilter[];
+    sort?: TableSortState;
+}
+/**
+ * Save table state
+ * @param name - Table widget name
+ * @param storage - Storage type (session/local)
+ * @param stateToSave - State object to save
+ */
+export declare const saveTableState: (name: string, storage: StorageType, stateToSave: Partial<TableStateData>) => void;
+/**
+ * Get table state from storage
+ * @param name - Table widget name
+ * @param storage - Storage type (session/local)
+ * @returns Table state data or null
+ */
+export declare const getTableState: (name: string, storage: StorageType) => TableStateData | null;
+/**
+ * Clear table state from storage
+ * @param name - Table widget name
+ * @param storage - Storage type (session/local)
+ */
+export declare const clearTableState: (name: string, storage: StorageType) => void;
+/**
+ * Convert filter array format to object format for datasource.invoke
+ * @param filterArray - Array of TableSearchFilter items
+ * @param defaultLogicalOp - Default logical operator (default: 'AND')
+ * @returns FilterFieldsObject for datasource
+ */
+export declare const convertFilterArrayToObject: (filterArray: TableSearchFilter[], defaultLogicalOp?: string) => FilterFieldsObject;
+/**
+ * Convert filter object format to array format for internal state
+ * @param filterObject - FilterFieldsObject from datasource
+ * @returns Array of TableSearchFilter items
+ */
+export declare const convertFilterObjectToArray: (filterObject: FilterFieldsObject) => TableSearchFilter[];

package/components/data/table/utils/table-helpers.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.saveTableState = exports.getTableState = exports.convertFilterObjectToArray = exports.convertFilterArrayToObject = exports.clearTableState = void 0;
+var _statePersistance = require("@wavemaker-ai/react-runtime/utils/state-persistance");
+var _lodashEs = require("lodash-es");
+// Type definition for search/filter item
+
+// Type definition for filter field object format (for datasource)
+
+// Type definition for filter fields object (for datasource.invoke)
+
+// Type definition for sort state
+
+// Type definition for table state
+
+/**
+ * Save table state
+ * @param name - Table widget name
+ * @param storage - Storage type (session/local)
+ * @param stateToSave - State object to save
+ */
+var saveTableState = exports.saveTableState = function saveTableState(name, storage, stateToSave) {
+  // Simply save the provided state
+  (0, _statePersistance.setWidgetState)({
+    name: name,
+    type: "table",
+    storage: storage
+  }, stateToSave);
+};
+
+/**
+ * Get table state from storage
+ * @param name - Table widget name
+ * @param storage - Storage type (session/local)
+ * @returns Table state data or null
+ */
+var getTableState = exports.getTableState = function getTableState(name, storage) {
+  var state = (0, _statePersistance.getWidgetState)({
+    name: name,
+    type: "table",
+    storage: storage
+  });
+  return state;
+};
+
+/**
+ * Clear table state from storage
+ * @param name - Table widget name
+ * @param storage - Storage type (session/local)
+ */
+var clearTableState = exports.clearTableState = function clearTableState(name, storage) {
+  (0, _statePersistance.clearWidgetState)({
+    name: name,
+    storage: storage,
+    type: "table"
+  });
+};
+
+/**
+ * Convert filter array format to object format for datasource.invoke
+ * @param filterArray - Array of TableSearchFilter items
+ * @param defaultLogicalOp - Default logical operator (default: 'AND')
+ * @returns FilterFieldsObject for datasource
+ */
+var convertFilterArrayToObject = exports.convertFilterArrayToObject = function convertFilterArrayToObject(filterArray) {
+  var defaultLogicalOp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "AND";
+  var filterObject = {};
+  (0, _lodashEs.forEach)(filterArray, function (filter) {
+    if (filter.field) {
+      filterObject[filter.field] = {
+        value: filter.value,
+        logicalOp: defaultLogicalOp,
+        matchMode: filter.matchMode || "anywhereignorecase",
+        type: filter.type
+      };
+    }
+  });
+  return filterObject;
+};
+
+/**
+ * Convert filter object format to array format for internal state
+ * @param filterObject - FilterFieldsObject from datasource
+ * @returns Array of TableSearchFilter items
+ */
+var convertFilterObjectToArray = exports.convertFilterObjectToArray = function convertFilterObjectToArray(filterObject) {
+  var filterArray = [];
+  (0, _lodashEs.forEach)(filterObject, function (filter, field) {
+    filterArray.push({
+      field: field,
+      value: filter.value,
+      matchMode: filter.matchMode || "anywhereignorecase",
+      type: filter.type || "string"
+    });
+  });
+  return filterArray;
+};

package/components/data/table/utils/validation.d.ts

@@ -0,0 +1,13 @@
+import { WmTableColumnProps, FieldValidationState } from "../props";
+/**
+ * Validates a single field and updates validation state
+ */
+export declare const validateField: (rowId: string, fieldName: string, value: any, column: WmTableColumnProps | undefined, validationState: FieldValidationState) => boolean;
+/**
+ * Resets validation state for specific context
+ */
+export declare const resetValidationState: (context: "editing" | "new-row" | "all" | undefined, editingRowId: string | null, validationState: FieldValidationState) => void;
+/**
+ * Updates validation errors for fields based on validation results
+ */
+export declare const updateValidationErrors: (validationResult: any, relevantFieldRefs: Record<string, HTMLElement | null>, validationState: FieldValidationState) => void;