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

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

@@ -0,0 +1,849 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  addUniqueRowIds: true,
+  getWidgetMappingForType: true,
+  getBooleanDataset: true,
+  isColumnVisibleForViewport: true,
+  parseTableColumns: true,
+  getAggregateFunctions: true,
+  parseTableStructureWithGroups: true,
+  flattenTableStructure: true,
+  parseTableRowActions: true,
+  parseTableActions: true,
+  parseTableRowExpansion: true,
+  isEditAction: true,
+  isDeleteAction: true,
+  isAddNewAction: true,
+  getActionButtonClass: true,
+  getTableActionButtonClass: true,
+  validateEditingFields: true,
+  getButtonClasses: true,
+  getSpacingClasses: true,
+  shouldShowPagination: true,
+  shouldShowPanelHeading: true,
+  handleNewRowNavigation: true,
+  INTERNAL_PROPERTIES: true,
+  cleanRowData: true,
+  parseWidth: true,
+  getColClass: true
+};
+exports.validateEditingFields = exports.shouldShowPanelHeading = exports.shouldShowPagination = exports.parseWidth = exports.parseTableStructureWithGroups = exports.parseTableRowExpansion = exports.parseTableRowActions = exports.parseTableColumns = exports.parseTableActions = exports.isEditAction = exports.isDeleteAction = exports.isColumnVisibleForViewport = exports.isAddNewAction = exports.handleNewRowNavigation = exports.getWidgetMappingForType = exports.getTableActionButtonClass = exports.getSpacingClasses = exports.getColClass = exports.getButtonClasses = exports.getBooleanDataset = exports.getAggregateFunctions = exports.getActionButtonClass = exports.flattenTableStructure = exports.cleanRowData = exports.addUniqueRowIds = exports.INTERNAL_PROPERTIES = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _lodashEs = require("lodash-es");
+var _react = _interopRequireDefault(require("react"));
+var _constants = require("./constants");
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _constants[key];
+    }
+  });
+});
+var _renderDisplayCell = require("./renderDisplayCell");
+Object.keys(_renderDisplayCell).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _renderDisplayCell[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _renderDisplayCell[key];
+    }
+  });
+});
+var _buildSelectionColumns = require("./buildSelectionColumns");
+Object.keys(_buildSelectionColumns).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _buildSelectionColumns[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _buildSelectionColumns[key];
+    }
+  });
+});
+var _validation = require("./validation");
+Object.keys(_validation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _validation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _validation[key];
+    }
+  });
+});
+var _selectionUtils = require("./selectionUtils");
+Object.keys(_selectionUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _selectionUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _selectionUtils[key];
+    }
+  });
+});
+var _columnBuilder = require("./columnBuilder");
+Object.keys(_columnBuilder).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _columnBuilder[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _columnBuilder[key];
+    }
+  });
+});
+var _columnWidthDistribution = require("./columnWidthDistribution");
+Object.keys(_columnWidthDistribution).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _columnWidthDistribution[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _columnWidthDistribution[key];
+    }
+  });
+});
+var _tableHelpers = require("./table-helpers");
+Object.keys(_tableHelpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _tableHelpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _tableHelpers[key];
+    }
+  });
+});
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var formWidgets = ["WmText", "WmTextarea", "WmCheckbox", "WmSlider", "WmCurrency", "WmSwitch", "WmSelect", "WmCheckboxSet", "WmRadioSet", "WmDate", "WmTime", "WmTimestamp", "WmRating", "WmDatetime", "WmSearch", "WmChips", "WmColorPicker"];
+var hashString = function hashString(str, index) {
+  var hash = 5381;
+  for (var i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i);
+    hash = hash & hash; // Convert to 32bit integer
+  }
+  return "row_".concat(Math.abs(hash), "_").concat(index);
+};
+var generateDeterministicHash = function generateDeterministicHash(obj, index) {
+  var hashSource = index.toString() + ((0, _lodashEs.isObject)(obj) ? (0, _lodashEs.transform)((0, _lodashEs.omit)(obj, "_wmTableRowId"), function (result, value, key) {
+    if (!(0, _lodashEs.isNil)(value)) {
+      result.push("".concat(key, ":").concat((0, _lodashEs.isObject)(value) ? JSON.stringify(value) : String(value)));
+    }
+  }, []).sort().join("|") : String(obj));
+  return hashString(hashSource, index);
+};
+
+/**
+ * Adds unique row IDs to the dataset if they don't already have them.
+ * Uses _wmTableRowId or _wmListItemId as the primary key, falling back to a generated ID.
+ *
+ * @param dataset - The dataset to process
+ * @param options - Options for ID generation
+ * @param options.type - Type of widget ('table' or 'list')
+ * @param options.idProperty - Custom property name for the ID (defaults to _wmTableRowId for table, _wmListItemId for list)
+ * @returns The dataset with unique row IDs added
+ */
+var addUniqueRowIds = exports.addUniqueRowIds = function addUniqueRowIds(dataset) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  // Handle non-array inputs (e.g., empty objects, null, undefined)
+  if (!(0, _lodashEs.isArray)(dataset)) {
+    return [];
+  }
+
+  // Determine the ID property based on type or custom property
+  var idProperty = options.idProperty || (options.type === "list" ? "_wmListItemId" : "_wmTableRowId");
+  var isListWidget = options.type === "list";
+  return (0, _lodashEs.map)(dataset, function (item, index) {
+    // If item is not an object (primitive values like strings, numbers), return as-is
+    if ((0, _typeof2["default"])(item) !== "object" || item === null || (0, _lodashEs.isArray)(item)) {
+      return item;
+    }
+    var getProperty = function getProperty(propName) {
+      return (0, _lodashEs.get)(item, propName);
+    };
+
+    // Skip if the item already has a unique row ID
+    if (item[idProperty]) {
+      return item.getProperty ? item : _objectSpread(_objectSpread({}, item), {}, {
+        getProperty: getProperty
+      });
+    }
+
+    // Generate a unique ID based on existing id field or create a deterministic hash
+    var rowId = item.id || item.ID || item.Id || generateDeterministicHash(item, index);
+    var rowIdAndGetProperty = (0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, idProperty, rowId), "getProperty", getProperty);
+    if (isListWidget) {
+      Object.assign(item, rowIdAndGetProperty);
+      return item;
+    }
+
+    // Table and other callers: immutable row copies (prior React/table behavior)
+    return _objectSpread(_objectSpread({}, item), rowIdAndGetProperty);
+  });
+};
+
+// Widget mapping utilities
+var getWidgetMappingForType = exports.getWidgetMappingForType = function getWidgetMappingForType(widgetType) {
+  var widgetMappings = {
+    text: "WmText",
+    password: "WmPassword",
+    textarea: "WmTextarea",
+    number: "WmNumber",
+    checkbox: "WmCheckbox",
+    toggle: "WmToggle",
+    "switch": "WmSwitch",
+    slider: "WmSlider",
+    richtext: "WmRichtext",
+    richtexteditor: "WmRichtexteditor",
+    currency: "WmCurrency",
+    select: "WmSelect",
+    checkboxset: "WmCheckboxset",
+    radioset: "WmRadioset",
+    date: "WmDate",
+    time: "WmTime",
+    timestamp: "WmTimestamp",
+    datetime: "WmDatetime",
+    rating: "WmRating",
+    autocomplete: "WmAutocomplete",
+    chips: "WmChips",
+    colorpicker: "WmColorpicker",
+    upload: "WmFileupload",
+    label: "WmLabel",
+    button: "WmButton",
+    icon: "WmIcon",
+    image: "WmPicture",
+    anchor: "WmAnchor"
+  };
+  return widgetMappings[widgetType] || widgetType;
+};
+var getBooleanDataset = exports.getBooleanDataset = function getBooleanDataset() {
+  return [{
+    key: true,
+    value: "Yes"
+  }, {
+    key: false,
+    value: "No"
+  }];
+};
+
+// Check if column should be visible based on current viewport
+var isColumnVisibleForViewport = exports.isColumnVisibleForViewport = function isColumnVisibleForViewport(column, viewportWidth) {
+  // Validate inputs
+  if (!column || typeof viewportWidth !== "number" || viewportWidth < 0) {
+    return true; // Default to showing column if invalid inputs
+  }
+
+  // Define breakpoints (matching Bootstrap)
+  var MOBILE_BREAKPOINT = 576;
+  var TABLET_BREAKPOINT = 768;
+  var DESKTOP_BREAKPOINT = 992;
+
+  // Determine current device type
+  var isMobile = viewportWidth < MOBILE_BREAKPOINT;
+  var isTablet = viewportWidth >= MOBILE_BREAKPOINT && viewportWidth < DESKTOP_BREAKPOINT;
+  var isDesktop = viewportWidth >= DESKTOP_BREAKPOINT;
+
+  // Default all display properties to true if not explicitly set
+  var mobiledisplay = column.mobiledisplay !== false;
+  var tabletdisplay = column.tabletdisplay !== false;
+  var pcdisplay = column.pcdisplay !== false;
+
+  // Check visibility based on device type
+  if (isMobile && !mobiledisplay) {
+    return false;
+  }
+  if (isTablet && !tabletdisplay) {
+    return false;
+  }
+  if (isDesktop && !pcdisplay) {
+    return false;
+  }
+  return true;
+};
+function transformExpression(exp) {
+  if (typeof exp === "string") {
+    // First replacing generic getProperty calls with rowData
+    // Matches patterns like: fragment.row?.getProperty?.("key") -> rowData['key']
+    var transformedExp = exp.replace(/(?:[\w$]+(?:\?\.|\.))*getProperty(?:\?\.)?\(\s*(['"])(.*?)\1\s*\)/g, function (_, quote, key) {
+      return "rowData['".concat(key, "']");
+    });
+
+    // Regex to split by string literals (double or single quoted)
+    var parts = transformedExp.split(/(".*?"|'.*?')/);
+    return parts.map(function (part) {
+      // If part is a string literal, return as is
+      if (part.startsWith('"') || part.startsWith("'")) {
+        return part;
+      }
+
+      // Replace identifiers that are not keywords
+      // Identifiers start with letter, _, or $
+      return part.replace(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g, function (match) {
+        var keywords = ["true", "false", "null", "undefined", "NaN", "Infinity", "in", "instanceof", "typeof", "void", "new", "delete", "rowData" // Don't replace rowData if it's already there
+        ];
+        if (keywords.includes(match)) {
+          return match;
+        }
+        return "rowData['".concat(match, "']");
+      });
+    }).join("");
+  }
+  return exp;
+}
+
+// Table structure types for grouping
+
+// Children parsing utilities
+var parseTableColumns = exports.parseTableColumns = function parseTableColumns(children, dataset) {
+  var columns = [];
+  _react["default"].Children.forEach(children, function (child) {
+    if (child && child.props && child.props.name && (child.props.name.includes("wm_table_column") || child.props.name.includes("col_"))) {
+      var props = (0, _lodashEs.get)(child, "props", {});
+      var binding = (0, _lodashEs.get)(props, "binding");
+      var aggregate = getAggregateFunctions(dataset, binding);
+      columns.push(_objectSpread(_objectSpread({}, props), {}, {
+        field: (0, _lodashEs.get)(props, "binding"),
+        caption: (0, _lodashEs.get)(props, "caption"),
+        displayName: (0, _lodashEs.get)(props, "caption"),
+        show: (0, _lodashEs.get)(props, "show", true) !== false,
+        sortable: (0, _lodashEs.get)(props, "sortable", true) !== false,
+        textalignment: (0, _lodashEs.get)(props, "textalignment", "left"),
+        backgroundcolor: (0, _lodashEs.get)(props, "backgroundcolor"),
+        textcolor: (0, _lodashEs.get)(props, "textcolor"),
+        width: (0, _lodashEs.get)(props, "width"),
+        editWidgetType: (0, _lodashEs.get)(props, "editWidgetType", "WmText"),
+        widgetType: (0, _lodashEs.get)(props, "widgetType", "label"),
+        required: (0, _lodashEs.get)(props, "required") === true || (0, _lodashEs.get)(props, "required") === "true",
+        defaultvalue: (0, _lodashEs.get)(props, "defaultvalue"),
+        disabled: transformExpression((0, _lodashEs.get)(props, "disabled")),
+        readonly: (0, _lodashEs.get)(props, "readonly") || (0, _lodashEs.get)(props, "readonly") === "true",
+        placeholder: (0, _lodashEs.get)(props, "placeholder"),
+        sortby: (0, _lodashEs.get)(props, "sortby"),
+        aggregate: aggregate,
+        colClass: (0, _lodashEs.get)(props, "colClass")
+      }));
+    }
+  });
+  return columns;
+};
+var getAggregateFunctions = exports.getAggregateFunctions = function getAggregateFunctions(dataset, binding) {
+  function _getColumnData() {
+    return (0, _lodashEs.map)(dataset, binding);
+  }
+  var aggregate = {
+    sum: function sum() {
+      return (0, _lodashEs.sum)(_getColumnData());
+    },
+    average: function average() {
+      var precision = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 2;
+      return (0, _lodashEs.round)((0, _lodashEs.mean)(_getColumnData()), precision);
+    },
+    count: function count() {
+      return _getColumnData().length;
+    },
+    minimum: function minimum() {
+      return (0, _lodashEs.min)(_getColumnData());
+    },
+    maximum: function maximum() {
+      return (0, _lodashEs.max)(_getColumnData());
+    },
+    percent: function percent(value) {
+      var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+      return (0, _lodashEs.round)((0, _lodashEs.sum)(_getColumnData()) / value * 100, precision);
+    }
+  };
+  return aggregate;
+};
+// Parse table structure with groups support
+var _parseTableStructureWithGroups = exports.parseTableStructureWithGroups = function parseTableStructureWithGroups(children) {
+  var structure = [];
+  _react["default"].Children.forEach(children, function (child) {
+    if (!child || !child.props) return;
+    var childName = (0, _lodashEs.get)(child, "props.name", "");
+
+    // Handle WmTableGroup
+    if (childName.includes("group")) {
+      var props = (0, _lodashEs.get)(child, "props", {});
+      var group = {
+        isGroup: true,
+        field: (0, _lodashEs.get)(props, "name", ""),
+        displayName: (0, _lodashEs.get)(props, "caption", ""),
+        textAlignment: (0, _lodashEs.get)(props, "textalignment"),
+        backgroundColor: (0, _lodashEs.get)(props, "backgroundcolor"),
+        "class": (0, _lodashEs.get)(props, "class"),
+        colClass: (0, _lodashEs.get)(props, "col-class"),
+        styles: (0, _lodashEs.get)(props, "styles"),
+        columns: _parseTableStructureWithGroups(child.props.children) // Recursive for nested groups
+      };
+      structure.push(group);
+    }
+    // Handle WmTableColumn
+    else if (childName.includes("wm_table_column") || childName.includes("col_")) {
+      var _props = (0, _lodashEs.get)(child, "props", {});
+      var column = _objectSpread({
+        field: (0, _lodashEs.get)(_props, "binding"),
+        caption: (0, _lodashEs.get)(_props, "caption"),
+        displayName: (0, _lodashEs.get)(_props, "caption"),
+        show: (0, _lodashEs.get)(_props, "show", true) !== false,
+        sortable: (0, _lodashEs.get)(_props, "sortable", true) !== false,
+        textalignment: (0, _lodashEs.get)(_props, "textalignment", "left"),
+        backgroundcolor: (0, _lodashEs.get)(_props, "backgroundcolor"),
+        textcolor: (0, _lodashEs.get)(_props, "textcolor"),
+        width: (0, _lodashEs.get)(_props, "width"),
+        editWidgetType: (0, _lodashEs.get)(_props, "editWidgetType", "WmText"),
+        widgetType: (0, _lodashEs.get)(_props, "widgetType", "label"),
+        required: (0, _lodashEs.get)(_props, "required") === true || (0, _lodashEs.get)(_props, "required") === "true",
+        defaultvalue: (0, _lodashEs.get)(_props, "defaultvalue"),
+        disabled: (0, _lodashEs.get)(_props, "disabled") === true || (0, _lodashEs.get)(_props, "disabled") === "true",
+        placeholder: (0, _lodashEs.get)(_props, "placeholder"),
+        sortby: (0, _lodashEs.get)(_props, "sortby")
+      }, _props);
+      structure.push(column);
+    }
+  });
+  return structure;
+};
+
+// Flatten hierarchical structure to get all columns
+var _flattenTableStructure = exports.flattenTableStructure = function flattenTableStructure(structure) {
+  var columns = [];
+  structure.forEach(function (item) {
+    if ("isGroup" in item && item.isGroup) {
+      // Recursively flatten groups
+      columns.push.apply(columns, (0, _toConsumableArray2["default"])(_flattenTableStructure(item.columns)));
+    } else {
+      // It's a column
+      columns.push(item);
+    }
+  });
+  return columns;
+};
+var parseTableRowActions = exports.parseTableRowActions = function parseTableRowActions(children) {
+  var actions = [];
+  _react["default"].Children.forEach(children, function (child) {
+    if (child && child.props && child.props.name && child.props.name.includes("wm_table_row_action")) {
+      var props = (0, _lodashEs.get)(child, "props", {});
+      var actionProps = (0, _lodashEs.assign)({}, props);
+      if (child.key) {
+        actionProps.key = child.key;
+      }
+      actions.push(actionProps);
+    }
+  });
+  return actions;
+};
+var parseTableActions = exports.parseTableActions = function parseTableActions(children) {
+  var actions = [];
+  _react["default"].Children.forEach(children, function (child) {
+    if (child && child.props && child.props.name && child.props.name.includes("wm_table_action")) {
+      var props = (0, _lodashEs.get)(child, "props", {});
+      var actionProps = (0, _lodashEs.assign)({}, props);
+      if (child.key) {
+        actionProps.key = child.key;
+      }
+      actions.push(actionProps);
+    }
+  });
+  return actions;
+};
+
+// Parse WmTableRow component for row expansion
+var parseTableRowExpansion = exports.parseTableRowExpansion = function parseTableRowExpansion(children) {
+  var rowExpansionConfig = null;
+  _react["default"].Children.forEach(children, function (child) {
+    if (child && child.type && child.type.displayName === "WmTableRow") {
+      // Check by displayName to ensure we get the right component
+      var props = (0, _lodashEs.get)(child, "props", {});
+      rowExpansionConfig = props;
+    } else if (child && child.props && child.props.name) {
+      // Fallback: check by name but ensure it's not a row action
+      var name = child.props.name;
+      // Match names that start with "wm_table_row_" followed by a hash/id, but not "wm_table_row_action"
+      if (name.startsWith("wm_table_row_") && !name.includes("_action")) {
+        var _props2 = (0, _lodashEs.get)(child, "props", {});
+        rowExpansionConfig = _props2;
+      }
+    }
+  });
+  return rowExpansionConfig;
+};
+
+// Action type checking utilities
+var isEditAction = exports.isEditAction = function isEditAction(actionKey) {
+  return actionKey === "updaterow";
+};
+var isDeleteAction = exports.isDeleteAction = function isDeleteAction(actionKey) {
+  return actionKey === "deleterow";
+};
+var isAddNewAction = exports.isAddNewAction = function isAddNewAction(actionKey) {
+  return actionKey === "addNewRow";
+};
+
+// CSS class utilities
+var getActionButtonClass = exports.getActionButtonClass = function getActionButtonClass(action) {
+  var actionKey = (0, _lodashEs.get)(action, "key") || (0, _lodashEs.get)(action, "name") || (0, _lodashEs.get)(action, "action");
+  if (isEditAction(actionKey)) {
+    var updateRowClasses = (0, _lodashEs.get)(action, "className", "");
+    return "row-action row-action-button btn-transparent edit edit-row-button ".concat(updateRowClasses);
+  }
+  if (isDeleteAction(actionKey) || actionKey === "delete") {
+    var deleteRowClasses = (0, _lodashEs.get)(action, "className", "");
+    return "row-action row-action-button btn-transparent delete delete-row-button ".concat(_constants.TABLE_CSS_CLASSES.deleteRow, " ").concat(deleteRowClasses);
+  }
+  return "row-action row-action-button ".concat((0, _lodashEs.get)(action, "className", "btn-transparent"));
+};
+var getTableActionButtonClass = exports.getTableActionButtonClass = function getTableActionButtonClass(action) {
+  return "btn ".concat((0, _lodashEs.get)(action, "className", "btn-primary"), " ").concat(isAddNewAction((0, _lodashEs.get)(action, "key")) ? "add-action" : "");
+};
+
+// Validation utilities for edit modes
+
+/**
+ * Validates editing fields and focuses first invalid field if validation fails
+ * Can be used across different edit modes (inline, dialog, quick edit)
+ *
+ * @param fieldRefs - Record of field references from editing form
+ * @param editingRowId - Optional ID for logging/debugging purposes
+ * @returns ValidationResult object with validation status and invalid elements
+ */
+var validateEditingFields = exports.validateEditingFields = function validateEditingFields(fieldRefs, editingRowId) {
+  var invalidElements = [];
+  var invalidFieldKeys = [];
+
+  // Helper to determine if a field needs validation based on the rowId prefix
+  var shouldValidateField = function shouldValidateField(fieldKey) {
+    if (!editingRowId) return true; // Validate all if no rowId provided
+    return (0, _lodashEs.startsWith)(fieldKey, "".concat(editingRowId, "_"));
+  };
+
+  // Check each field reference for validity
+  (0, _lodashEs.forEach)((0, _lodashEs.entries)(fieldRefs), function (_ref) {
+    var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+      fieldKey = _ref2[0],
+      fieldElement = _ref2[1];
+    // Skip fields that don't belong to the current editing row
+    if (!shouldValidateField(fieldKey) || !fieldElement) {
+      return;
+    }
+    var isInvalid = false;
+
+    // First check for HTML5 validation
+    var inputs = fieldElement.querySelectorAll("input, select, textarea");
+    (0, _lodashEs.forEach)(inputs, function (input) {
+      // Check HTML5 validation
+      if (input && !input.validity.valid && input.hasAttribute("required")) {
+        invalidElements.push(input);
+        isInvalid = true;
+      }
+
+      // Check for custom validation classes
+      if (input && input.classList.contains("ng-invalid")) {
+        invalidElements.push(input);
+        isInvalid = true;
+      }
+
+      // Check for required fields that are empty
+      if (input && input.hasAttribute("required") && !(0, _lodashEs.trim)(input.value)) {
+        invalidElements.push(input);
+        isInvalid = true;
+      }
+    });
+
+    // Then check for "required" attribute on the field element itself
+    if (fieldElement.hasAttribute("required")) {
+      var inputEl = fieldElement.querySelector("input, textarea, select");
+      if (inputEl && !(0, _lodashEs.trim)(inputEl.value)) {
+        invalidElements.push(inputEl);
+        isInvalid = true;
+      }
+    }
+    if (isInvalid) {
+      invalidFieldKeys.push(fieldKey);
+    }
+  });
+
+  // If invalid elements found, focus the first one
+  if ((0, _lodashEs.size)(invalidElements) > 0) {
+    var logPrefix = editingRowId ? "[".concat(editingRowId, "]") : "[Validation]";
+    console.log("".concat(logPrefix, " Validation failed: Found ").concat((0, _lodashEs.size)(invalidElements), " invalid elements"));
+
+    // Focus the first invalid element
+    var firstInvalidElement = (0, _lodashEs.get)(invalidElements, "[0]");
+    if (firstInvalidElement) {
+      // Find the closest container cell
+      var cell = firstInvalidElement.closest("td, .app-datagrid-cell, .form-field");
+      if (cell) {
+        // Try to find a specific focus-target, or fallback to the input itself
+        var focusTarget = cell.querySelector("[focus-target], input, textarea, select");
+        if (focusTarget) {
+          setTimeout(function () {
+            focusTarget.focus();
+            console.log("".concat(logPrefix, " Focused first invalid field:"), focusTarget);
+          }, 0);
+        }
+      } else {
+        // If we can't find a container, try to focus the element directly
+        setTimeout(function () {
+          firstInvalidElement.focus();
+        }, 0);
+      }
+    }
+  }
+  return {
+    isValid: (0, _lodashEs.isEmpty)(invalidElements),
+    invalidElements: invalidElements,
+    invalidFieldKeys: invalidFieldKeys,
+    firstInvalidElement: (0, _lodashEs.size)(invalidElements) > 0 ? (0, _lodashEs.get)(invalidElements, "[0]") : undefined
+  };
+};
+
+// Panel and button styling utilities
+var getButtonClasses = exports.getButtonClasses = function getButtonClasses(action) {
+  var spacing = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "normal";
+  var isGridEditMode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var isLoading = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var baseClass = "btn ".concat((0, _lodashEs.get)(action, "className", "btn-primary"), " ").concat(isAddNewAction((0, _lodashEs.get)(action, "key")) ? "add-action" : "");
+  var spacingClass = spacing === "condensed" ? "btn-sm" : "";
+  var disabledClass = (0, _lodashEs.get)(action, "key") === "addNewRow" && (isGridEditMode || isLoading) ? "disabled-new" : "";
+  return (0, _lodashEs.trim)("".concat(baseClass, " ").concat(spacingClass, " ").concat(disabledClass));
+};
+var getSpacingClasses = exports.getSpacingClasses = function getSpacingClasses() {
+  var spacing = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "normal";
+  var classes = [];
+  if (spacing === "condensed") {
+    classes.push("table-condensed");
+  }
+  return classes.join(" ");
+};
+
+// Pagination display logic
+var shouldShowPagination = exports.shouldShowPagination = function shouldShowPagination(_ref3) {
+  var _datasource$paginatio;
+  var shownavigation = _ref3.shownavigation,
+    onDemandLoad = _ref3.onDemandLoad,
+    internalDataset = _ref3.internalDataset,
+    pagesize = _ref3.pagesize,
+    allowpagesizechange = _ref3.allowpagesizechange,
+    datasource = _ref3.datasource,
+    _ref3$showrecordcount = _ref3.showrecordcount,
+    showrecordcount = _ref3$showrecordcount === void 0 ? false : _ref3$showrecordcount;
+  // If shownavigation is false, don't show pagination
+  if (!shownavigation) return false;
+
+  // If datasource has pagination metadata, show pagination
+  if ((datasource === null || datasource === void 0 || (_datasource$paginatio = datasource.pagination) === null || _datasource$paginatio === void 0 ? void 0 : _datasource$paginatio.totalElements) > 0) return true;
+
+  // If allowpagesizechange is true, always show pagination
+  if (allowpagesizechange) return true;
+
+  // Show footer (including total records) when record count is enabled, even on a single page
+  if (showrecordcount) return true;
+
+  // If using on-demand load or if dataset is larger than page size, show pagination
+  return onDemandLoad || (0, _lodashEs.size)(internalDataset) > pagesize;
+};
+
+// Panel structure utilities
+var shouldShowPanelHeading = exports.shouldShowPanelHeading = function shouldShowPanelHeading(title, subheading, iconclass) {
+  var exportformat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  var headerActions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+  return !(0, _lodashEs.isEmpty)(title) || !(0, _lodashEs.isEmpty)(subheading) || !(0, _lodashEs.isEmpty)(iconclass) || (0, _lodashEs.size)(exportformat) > 0 || (0, _lodashEs.size)(headerActions) > 0;
+};
+
+/**
+ * Utility function to handle navigation after a new row is added to the table
+ * Used by both inline edit and quick edit modes
+ */
+var handleNewRowNavigation = exports.handleNewRowNavigation = function handleNewRowNavigation(tableRef, newRecord, internalDataset) {
+  if (!(0, _lodashEs.get)(tableRef, "current")) return;
+  var table = (0, _lodashEs.get)(tableRef, "current");
+  var sortingState = (0, _lodashEs.get)(table.getState(), "sorting");
+  var hasSorting = sortingState && (0, _lodashEs.size)(sortingState) > 0;
+  if (hasSorting) {
+    // If sorting is active, find where the new record ends up
+    setTimeout(function () {
+      var sortedRows = (0, _lodashEs.get)(table.getSortedRowModel(), "rows", []);
+      var newRecordIndex = (0, _lodashEs.findIndex)(sortedRows, function (row) {
+        return (0, _lodashEs.get)(row, "original._wmTableRowId") === (0, _lodashEs.get)(newRecord, "_wmTableRowId");
+      });
+      if (newRecordIndex !== -1) {
+        var currentPageSize = (0, _lodashEs.get)(table.getState(), "pagination.pageSize");
+        var targetPage = (0, _lodashEs.floor)(newRecordIndex / currentPageSize);
+        table.setPageIndex(targetPage);
+      }
+    }, 0);
+  } else {
+    // If no sorting, navigate to the last page
+    var currentPageSize = (0, _lodashEs.get)(table.getState(), "pagination.pageSize");
+    // Add 1 because the new record hasn't been added to internalDataset state yet
+    var newDatasetLength = (0, _lodashEs.size)(internalDataset) + 1;
+    var totalPages = (0, _lodashEs.ceil)(newDatasetLength / currentPageSize);
+    table.setPageIndex((0, _lodashEs.max)([0, totalPages - 1]));
+  }
+};
+
+/**
+ * List of internal properties that should be removed from row data
+ * before passing to external handlers or form data
+ */
+var INTERNAL_PROPERTIES = exports.INTERNAL_PROPERTIES = ["_wmTableRowId",
+// Internal row identifier
+"getProperty",
+// Helper function to get property values
+"rowOperations",
+// Internal column for row action buttons
+"rowActions",
+// Internal row actions property
+"_wmListItemId",
+// Internal list item identifier
+"selected",
+// Internal selected property
+"_wm"];
+
+/**
+ * Patterns for internal field names that should be excluded from cleaned data
+ */
+var INTERNAL_FIELD_SUFFIXES = ["_formWidget"];
+
+/**
+ * Cleans row data by removing internal properties
+ * Handles both single objects and arrays of objects
+ * Removes:
+ * - Exact matches from INTERNAL_PROPERTIES list
+ * - Fields ending with internal suffixes (e.g., _formWidget)
+ * - Recursively cleans nested objects
+ * @param data The raw data - can be a single object, array of objects, or primitive
+ * @returns The cleaned data without internal properties
+ */
+var _cleanRowData = exports.cleanRowData = function cleanRowData(data) {
+  if (!data) return data;
+
+  // For arrays, clean each item
+  if ((0, _lodashEs.isArray)(data)) {
+    return data.map(function (item) {
+      return _cleanRowData(item);
+    });
+  }
+
+  // For objects, remove internal properties and clean nested objects
+  if ((0, _typeof2["default"])(data) === "object") {
+    var result = {};
+    var _loop = function _loop() {
+        var key = _Object$keys[_i];
+        // Skip exact matches from INTERNAL_PROPERTIES
+        if (INTERNAL_PROPERTIES.includes(key)) {
+          return 0; // continue
+        }
+
+        // Skip fields ending with internal suffixes
+        if (INTERNAL_FIELD_SUFFIXES.some(function (suffix) {
+          return key.endsWith(suffix);
+        })) {
+          return 0; // continue
+        }
+
+        // Recursively clean nested objects/arrays
+        var value = data[key];
+        if (value && (0, _typeof2["default"])(value) === "object") {
+          result[key] = _cleanRowData(value);
+        } else {
+          result[key] = value;
+        }
+      },
+      _ret;
+    for (var _i = 0, _Object$keys = Object.keys(data); _i < _Object$keys.length; _i++) {
+      _ret = _loop();
+      if (_ret === 0) continue;
+    }
+    return result;
+  }
+
+  // For primitive types, return as is
+  return data;
+};
+
+// Helper function to parse width values
+var parseWidth = exports.parseWidth = function parseWidth(width) {
+  var fallbackSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 150;
+  var columnSize = fallbackSize;
+  var styleWidth = width;
+  if (typeof styleWidth === "string") {
+    // Convert percentage to a pixel value (assuming viewport width)
+    if (styleWidth.endsWith("%")) {
+      var percentage = parseFloat(styleWidth);
+      // Use a base width of 1200px for percentage calculations
+      columnSize = Math.round(percentage / 100 * 1200);
+    } else if (styleWidth.endsWith("px")) {
+      columnSize = parseInt(styleWidth);
+    } else {
+      columnSize = parseInt(styleWidth);
+    }
+  }
+  return columnSize;
+};
+var getColClass = exports.getColClass = function getColClass(colClass, rowData, columnName) {
+  // Return empty string if colClass is not provided or not a string
+  if (!colClass || typeof colClass !== "string") {
+    return "";
+  }
+
+  // Trim whitespace
+  var trimmedClass = (0, _lodashEs.trim)(colClass);
+  if (!trimmedClass) {
+    return "";
+  }
+  var hasExpressionOperators = /[?&|<>!=]/.test(trimmedClass) || trimmedClass.includes("(") || trimmedClass.includes("&&") || trimmedClass.includes("||") || trimmedClass.includes("===") || trimmedClass.includes("!==");
+  var hasRowDataReference = trimmedClass.includes("rowData");
+  var hasColumnNameReference = trimmedClass.includes("columnName");
+  var isExpression = hasExpressionOperators || hasRowDataReference || hasColumnNameReference;
+
+  // If it's not an expression, return as-is
+  if (!isExpression) {
+    return trimmedClass;
+  }
+
+  // Evaluate the expression using Function constructor
+  try {
+    var expressionToEvaluate = trimmedClass;
+    var evaluated = new Function("rowData", "columnName", "return ".concat(expressionToEvaluate))(rowData, columnName);
+
+    // Convert result to string (handles boolean, number, null, undefined)
+    if (evaluated === null || evaluated === undefined) {
+      return "";
+    }
+
+    // If it's a boolean, return empty string (falsy) or convert to string
+    if (typeof evaluated === "boolean") {
+      return evaluated ? String(evaluated) : "";
+    }
+    return String(evaluated);
+  } catch (error) {
+    console.warn("Failed to evaluate colClass expression:", trimmedClass, error);
+    // Return empty string on error to prevent breaking the UI
+    return "";
+  }
+};
+
+// Export utilities