@wavemaker/react-runtime 11.14.1-rc.236

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("../../../form/button");
+var _index = require("../../../input/default/checkbox/index");
+var _label = require("../../../basic/label");
+var _index2 = require("./index");
+var _anchor = require("../../../basic/anchor");
+var _icon = require("../../../basic/icon");
+var _picture = require("../../../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) : "",
+      alt: 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 = (0, _index2.getWidgetMappingForType)(widgetType);
+
+  // 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/selectionUtils.js

@@ -0,0 +1,166 @@
+"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;
+  });
+};
+
+/**
+ * Selection state management functions
+ */
+var selectionStateHelpers = exports.selectionStateHelpers = {
+  // Radio selection
+  setRadioSelection: function setRadioSelection(cellState, rowId) {
+    (0, _hooks.setSelectedRowId)(cellState, rowId);
+  },
+  getRadioSelection: function getRadioSelection(cellState) {
+    return (0, _hooks.getSelectedRowId)(cellState);
+  },
+  // Multi selection
+  addToMultiSelection: function addToMultiSelection(cellState, rowId) {
+    var current = (0, _hooks.getSelectedRowIds)(cellState);
+    if (!current.includes(rowId)) {
+      (0, _hooks.setSelectedRowIds)(cellState, [].concat((0, _toConsumableArray2["default"])(current), [rowId]));
+    }
+  },
+  removeFromMultiSelection: function removeFromMultiSelection(cellState, rowId) {
+    var current = (0, _hooks.getSelectedRowIds)(cellState);
+    (0, _hooks.setSelectedRowIds)(cellState, current.filter(function (id) {
+      return id !== rowId;
+    }));
+  },
+  toggleMultiSelection: function toggleMultiSelection(cellState, rowId) {
+    var current = (0, _hooks.getSelectedRowIds)(cellState);
+    var isSelected = current.includes(rowId);
+    if (isSelected) {
+      selectionStateHelpers.removeFromMultiSelection(cellState, rowId);
+    } else {
+      selectionStateHelpers.addToMultiSelection(cellState, rowId);
+    }
+    return !isSelected;
+  },
+  setAllMultiSelection: function setAllMultiSelection(cellState, rowIds) {
+    (0, _hooks.setSelectedRowIds)(cellState, rowIds);
+  },
+  clearMultiSelection: function clearMultiSelection(cellState) {
+    (0, _hooks.setSelectedRowIds)(cellState, []);
+  },
+  getMultiSelection: function getMultiSelection(cellState) {
+    return (0, _hooks.getSelectedRowIds)(cellState);
+  },
+  // Check selection
+  isRowSelected: function isRowSelected(cellState, rowId, useMultiSelect, useRadioSelect) {
+    if (useMultiSelect) {
+      return (0, _hooks.getSelectedRowIds)(cellState).includes(rowId);
+    } else {
+      // For radio select or default mode (when neither is explicitly enabled),
+      // check radio selection
+      return (0, _hooks.getSelectedRowId)(cellState) === rowId;
+    }
+  }
+};

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/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.js

@@ -0,0 +1,124 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateField = exports.updateValidationErrors = exports.resetValidationState = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _lodashEs = require("lodash-es");
+/**
+ * Validates a single field and updates validation state
+ */
+var validateField = exports.validateField = function validateField(rowId, fieldName, value, column, validationState) {
+  var _cellUpdateCallbacks$5, _cellUpdateCallbacks$6;
+  var fieldKey = "".concat(rowId, "_").concat(fieldName);
+  var fieldRefs = validationState.fieldRefs,
+    fieldValidationErrors = validationState.fieldValidationErrors,
+    cellUpdateCallbacks = validationState.cellUpdateCallbacks;
+
+  // Check required validation
+  if (column !== null && column !== void 0 && column.required && (value === undefined || value === null || value === "")) {
+    var _cellUpdateCallbacks$, _cellUpdateCallbacks$2;
+    fieldValidationErrors.current[fieldKey] = true;
+    (_cellUpdateCallbacks$ = (_cellUpdateCallbacks$2 = cellUpdateCallbacks.current)[fieldKey]) === null || _cellUpdateCallbacks$ === void 0 || _cellUpdateCallbacks$.call(_cellUpdateCallbacks$2);
+    return false;
+  }
+
+  // Check HTML5 validation
+  var fieldElement = fieldRefs.current[fieldKey];
+  if (fieldElement) {
+    var input = fieldElement.querySelector("input, textarea, select");
+    if (input && !input.validity.valid) {
+      var _cellUpdateCallbacks$3, _cellUpdateCallbacks$4;
+      fieldValidationErrors.current[fieldKey] = true;
+      (_cellUpdateCallbacks$3 = (_cellUpdateCallbacks$4 = cellUpdateCallbacks.current)[fieldKey]) === null || _cellUpdateCallbacks$3 === void 0 || _cellUpdateCallbacks$3.call(_cellUpdateCallbacks$4);
+      return false;
+    }
+  }
+
+  // Mark as valid
+  fieldValidationErrors.current[fieldKey] = false;
+  (_cellUpdateCallbacks$5 = (_cellUpdateCallbacks$6 = cellUpdateCallbacks.current)[fieldKey]) === null || _cellUpdateCallbacks$5 === void 0 || _cellUpdateCallbacks$5.call(_cellUpdateCallbacks$6);
+  return true;
+};
+
+/**
+ * Resets validation state for specific context
+ */
+var resetValidationState = exports.resetValidationState = function resetValidationState(context, editingRowId, validationState) {
+  var fieldRefs = validationState.fieldRefs,
+    fieldValidationErrors = validationState.fieldValidationErrors,
+    cellUpdateCallbacks = validationState.cellUpdateCallbacks;
+  if (context === "editing" && editingRowId) {
+    // Clear only editing row fields
+    (0, _lodashEs.forEach)((0, _lodashEs.keys)(fieldRefs.current), function (key) {
+      if (key.startsWith("".concat(editingRowId, "_"))) {
+        delete fieldRefs.current[key];
+        delete fieldValidationErrors.current[key];
+        delete cellUpdateCallbacks.current[key];
+      }
+    });
+  } else if (context === "new-row") {
+    // Clear only new row fields
+    (0, _lodashEs.forEach)((0, _lodashEs.keys)(fieldRefs.current), function (key) {
+      if (key.startsWith("new-row_")) {
+        delete fieldRefs.current[key];
+        delete fieldValidationErrors.current[key];
+        delete cellUpdateCallbacks.current[key];
+      }
+    });
+  } else {
+    // Clear all
+    (0, _lodashEs.forEach)((0, _lodashEs.keys)(fieldRefs.current), function (key) {
+      delete fieldRefs.current[key];
+    });
+    fieldValidationErrors.current = {};
+    cellUpdateCallbacks.current = {};
+  }
+};
+
+/**
+ * Updates validation errors for fields based on validation results
+ */
+var updateValidationErrors = exports.updateValidationErrors = function updateValidationErrors(validationResult, relevantFieldRefs, validationState) {
+  var fieldValidationErrors = validationState.fieldValidationErrors,
+    cellUpdateCallbacks = validationState.cellUpdateCallbacks;
+
+  // Initialize all fields as valid
+  var errors = {};
+  (0, _lodashEs.forEach)((0, _lodashEs.keys)(relevantFieldRefs), function (fieldKey) {
+    errors[fieldKey] = false;
+  });
+
+  // If we have the invalidFieldKeys property, use it directly
+  if (validationResult.invalidFieldKeys && validationResult.invalidFieldKeys.length > 0) {
+    (0, _lodashEs.forEach)(validationResult.invalidFieldKeys, function (fieldKey) {
+      errors[fieldKey] = true;
+    });
+  } else {
+    // Fallback to the previous method using invalidElements
+    validationResult.invalidElements.forEach(function (invalidElement) {
+      (0, _lodashEs.forEach)((0, _lodashEs.entries)(relevantFieldRefs), function (_ref) {
+        var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+          fieldKey = _ref2[0],
+          fieldElement = _ref2[1];
+        if (fieldElement === invalidElement || fieldElement !== null && fieldElement !== void 0 && fieldElement.contains(invalidElement)) {
+          errors[fieldKey] = true;
+        }
+      });
+    });
+  }
+
+  // Update validation errors for each field key
+  (0, _lodashEs.forEach)((0, _lodashEs.entries)(errors), function (_ref3) {
+    var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
+      fieldKey = _ref4[0],
+      hasError = _ref4[1];
+    if (fieldValidationErrors.current[fieldKey] !== hasError) {
+      var _cellUpdateCallbacks$7, _cellUpdateCallbacks$8;
+      fieldValidationErrors.current[fieldKey] = hasError;
+      (_cellUpdateCallbacks$7 = (_cellUpdateCallbacks$8 = cellUpdateCallbacks.current)[fieldKey]) === null || _cellUpdateCallbacks$7 === void 0 || _cellUpdateCallbacks$7.call(_cellUpdateCallbacks$8);
+    }
+  });
+};

package/components/data/types.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MatchMode = exports.FormWidgetType = exports.DataType = exports.DataSource = void 0;
+var Operation = /*#__PURE__*/function (Operation) {
+  Operation["LIST_RECORDS"] = "listRecords";
+  Operation["UPDATE_RECORD"] = "updateRecord";
+  Operation["INSERT_RECORD"] = "insertRecord";
+  Operation["DELETE_RECORD"] = "deleteRecord";
+  Operation["INVOKE"] = "invoke";
+  Operation["UPDATE"] = "update";
+  Operation["NOTIFY"] = "notify";
+  Operation["IS_API_AWARE"] = "isApiAware";
+  Operation["SUPPORTS_CRUD"] = "supportsCRUD";
+  Operation["SUPPORTS_DISTINCT_API"] = "supportsDistinctAPI";
+  Operation["IS_PAGEABLE"] = "isPageable";
+  Operation["IS_SORTABLE"] = "isSortable";
+  Operation["GET_OPERATION_TYPE"] = "getOperationType";
+  Operation["GET_RELATED_PRIMARY_KEYS"] = "getRelatedTablePrimaryKeys";
+  Operation["GET_ENTITY_NAME"] = "getEntityName";
+  Operation["SET_INPUT"] = "setinput";
+  Operation["GET_RELATED_TABLE_DATA"] = "getRelatedTableData";
+  Operation["GET_DISTINCT_DATA_BY_FIELDS"] = "getDistinctDataByFields";
+  Operation["GET_AGGREGATED_DATA"] = "getAggregatedData";
+  Operation["GET_MATCH_MODE"] = "getMatchMode";
+  Operation["DOWNLOAD"] = "download";
+  Operation["GET_NAME"] = "getName";
+  Operation["GET_PROPERTIES_MAP"] = "getPropertiesMap";
+  Operation["GET_PRIMARY_KEY"] = "getPrimaryKey";
+  Operation["GET_BLOB_URL"] = "getBlobURL";
+  Operation["SUPPORTS_SERVER_FILTER"] = "supportsServerFilter";
+  Operation["GET_OPTIONS"] = "getOptions";
+  Operation["SEARCH_RECORDS"] = "searchRecords";
+  Operation["GET_REQUEST_PARAMS"] = "getRequestParams";
+  Operation["GET_PAGING_OPTIONS"] = "getPagingOptions";
+  Operation["FETCH_DISTINCT_VALUES"] = "fetchDistinctValues";
+  Operation["GET_UNIQUE_IDENTIFIER"] = "getUniqueIdentifier";
+  Operation["GET_CONTEXT_IDENTIFIER"] = "getContextIdentifier";
+  Operation["IS_UPDATE_REQUIRED"] = "isUpdateRequired";
+  Operation["ADD_ITEM"] = "addItem";
+  Operation["SET_ITEM"] = "setItem";
+  Operation["REMOVE_ITEM"] = "removeItem";
+  Operation["IS_BOUND_TO_LOCALE"] = "isBoundToLocale";
+  Operation["GET_DEFAULT_LOCALE"] = "getDefaultLocale";
+  Operation["CANCEL"] = "cancel";
+  Operation["SET_PAGINATION"] = "setPagination";
+  return Operation;
+}(Operation || {});
+var DataSource = exports.DataSource = {
+  Operation: Operation
+};
+var MatchMode = exports.MatchMode = /*#__PURE__*/function (MatchMode) {
+  MatchMode["BETWEEN"] = "between";
+  MatchMode["GREATER"] = "greaterthanequal";
+  MatchMode["LESSER"] = "lessthanequal";
+  MatchMode["NULL"] = "null";
+  MatchMode["EMPTY"] = "empty";
+  MatchMode["NULLOREMPTY"] = "nullorempty";
+  MatchMode["EQUALS"] = "exact";
+  return MatchMode;
+}({});
+var FormWidgetType = exports.FormWidgetType = /*#__PURE__*/function (FormWidgetType) {
+  FormWidgetType["AUTOCOMPLETE"] = "autocomplete";
+  FormWidgetType["CHECKBOX"] = "checkbox";
+  FormWidgetType["CHECKBOXSET"] = "checkboxset";
+  FormWidgetType["CHIPS"] = "chips";
+  FormWidgetType["COLORPICKER"] = "colorpicker";
+  FormWidgetType["CURRENCY"] = "currency";
+  FormWidgetType["CUSTOMWIDGET"] = "custom-widget";
+  FormWidgetType["DATE"] = "date";
+  FormWidgetType["DATETIME"] = "datetime";
+  FormWidgetType["NUMBER"] = "number";
+  FormWidgetType["PASSWORD"] = "password";
+  FormWidgetType["RADIOSET"] = "radioset";
+  FormWidgetType["RATING"] = "rating";
+  FormWidgetType["RICHTEXT"] = "richtext";
+  FormWidgetType["SELECT"] = "select";
+  FormWidgetType["TOGGLE"] = "toggle";
+  FormWidgetType["SLIDER"] = "slider";
+  FormWidgetType["SWITCH"] = "switch";
+  FormWidgetType["TEXT"] = "text";
+  FormWidgetType["TEXTAREA"] = "textarea";
+  FormWidgetType["TIME"] = "time";
+  FormWidgetType["TIMESTAMP"] = "timestamp";
+  FormWidgetType["TYPEAHEAD"] = "typeahead";
+  FormWidgetType["UPLOAD"] = "upload";
+  return FormWidgetType;
+}({});
+var DataType = exports.DataType = /*#__PURE__*/function (DataType) {
+  DataType["INTEGER"] = "integer";
+  DataType["BIG_INTEGER"] = "big_integer";
+  DataType["SHORT"] = "short";
+  DataType["FLOAT"] = "float";
+  DataType["BIG_DECIMAL"] = "big_decimal";
+  DataType["DOUBLE"] = "double";
+  DataType["LONG"] = "long";
+  DataType["BYTE"] = "byte";
+  DataType["STRING"] = "string";
+  DataType["CHARACTER"] = "character";
+  DataType["TEXT"] = "text";
+  DataType["DATE"] = "date";
+  DataType["TIME"] = "time";
+  DataType["TIMESTAMP"] = "timestamp";
+  DataType["DATETIME"] = "datetime";
+  DataType["LOCALDATETIME"] = "localdatetime";
+  DataType["BOOLEAN"] = "boolean";
+  DataType["LIST"] = "list";
+  DataType["CLOB"] = "clob";
+  DataType["BLOB"] = "blob";
+  return DataType;
+}({});