@wavemaker/react-runtime 11.14.1-rc.236

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

@@ -0,0 +1,607 @@
+"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,
+  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
+};
+exports.validateEditingFields = exports.shouldShowPanelHeading = exports.shouldShowPagination = exports.parseWidth = 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.getButtonClasses = exports.getBooleanDataset = exports.getActionButtonClass = exports.cleanRowData = exports.addUniqueRowIds = exports.INTERNAL_PROPERTIES = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+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");
+  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;
+    }
+
+    // Skip if the item already has a unique row ID
+    if (item[idProperty]) {
+      return item;
+    }
+
+    // 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);
+
+    // Use spread operator for objects to add the ID property
+    return _objectSpread(_objectSpread({}, item), {}, (0, _defineProperty2["default"])({}, idProperty, rowId));
+  });
+};
+
+// 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;
+};
+
+// Children parsing utilities
+var parseTableColumns = exports.parseTableColumns = function parseTableColumns(children) {
+  var columns = [];
+  _react["default"].Children.forEach(children, function (child) {
+    if (child && child.props && child.props.name && child.props.name.includes("wm_table_column")) {
+      var props = (0, _lodashEs.get)(child, "props", {});
+      columns.push(_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));
+    }
+  });
+  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 _props = (0, _lodashEs.get)(child, "props", {});
+        rowExpansionConfig = _props;
+      }
+    }
+  });
+  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)) {
+    return "row-action row-action-button btn-transparent edit edit-row-button";
+  }
+  if (isDeleteAction(actionKey) || actionKey === "delete") {
+    return "row-action row-action-button btn-transparent delete delete-row-button ".concat(_constants.TABLE_CSS_CLASSES.deleteRow);
+  }
+  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) {
+        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;
+  // 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;
+
+  // 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 exportOptions = 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)(exportOptions) > 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
+ */
+var INTERNAL_PROPERTIES = exports.INTERNAL_PROPERTIES = ["_wmTableRowId" // Internal row identifier
+];
+
+/**
+ * Cleans row data by removing internal properties
+ * Handles both single objects and arrays of 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
+  if ((0, _typeof2["default"])(data) === "object") {
+    return (0, _lodashEs.omit)(data, INTERNAL_PROPERTIES);
+  }
+
+  // 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;
+};
+
+// Export utilities