@wavemaker-ai/react-runtime 1.0.0-next.27766

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

@@ -0,0 +1,733 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import {
+  forEach,
+  entries,
+  size,
+  isEmpty,
+  isArray,
+  map,
+  get,
+  trim,
+  startsWith,
+  findIndex,
+  assign,
+  floor,
+  ceil,
+  max,
+  omit,
+  isObject,
+  isNil,
+  transform,
+  sum,
+  round,
+  mean,
+  min
+} from "lodash-es";
+import React from "react";
+import { TABLE_CSS_CLASSES } from "./constants";
+const formWidgets = [
+  "WmText",
+  "WmTextarea",
+  "WmCheckbox",
+  "WmSlider",
+  "WmCurrency",
+  "WmSwitch",
+  "WmSelect",
+  "WmCheckboxSet",
+  "WmRadioSet",
+  "WmDate",
+  "WmTime",
+  "WmTimestamp",
+  "WmRating",
+  "WmDatetime",
+  "WmSearch",
+  "WmChips",
+  "WmColorPicker"
+];
+const hashString = (str, index) => {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i);
+    hash = hash & hash;
+  }
+  return `row_${Math.abs(hash)}_${index}`;
+};
+const generateDeterministicHash = (obj, index) => {
+  const hashSource = index.toString() + (isObject(obj) ? transform(
+    omit(obj, "_wmTableRowId"),
+    (result, value, key) => {
+      if (!isNil(value)) {
+        result.push(`${key}:${isObject(value) ? JSON.stringify(value) : String(value)}`);
+      }
+    },
+    []
+  ).sort().join("|") : String(obj));
+  return hashString(hashSource, index);
+};
+const extractDataArray = (dataset) => {
+  if (isArray(dataset)) return dataset;
+  if (dataset !== null && dataset !== void 0 && typeof dataset === "object") {
+    const firstArray = Object.values(dataset).find((v) => isArray(v));
+    return firstArray != null ? firstArray : [];
+  }
+  return [];
+};
+const addUniqueRowIds = (dataset, options = {}) => {
+  if (!isArray(dataset)) {
+    return [];
+  }
+  const idProperty = options.idProperty || (options.type === "list" ? "_wmListItemId" : "_wmTableRowId");
+  const isListWidget = options.type === "list";
+  return map(dataset, (item, index) => {
+    if (typeof item !== "object" || item === null || isArray(item)) {
+      return item;
+    }
+    const getProperty = (propName) => {
+      const direct = get(item, propName);
+      if (direct !== void 0) return direct;
+      const withoutArrayPrefix = propName.replace(/^[^.[]+\[\d+\]\./, "");
+      if (withoutArrayPrefix !== propName) {
+        return get(item, withoutArrayPrefix);
+      }
+      return void 0;
+    };
+    if (item[idProperty]) {
+      return item.getProperty ? item : __spreadProps(__spreadValues({}, item), { getProperty });
+    }
+    const rowId = item.id || item.ID || item.Id || generateDeterministicHash(item, index);
+    const rowIdAndGetProperty = {
+      [idProperty]: rowId,
+      getProperty
+    };
+    if (isListWidget) {
+      Object.assign(item, rowIdAndGetProperty);
+      return item;
+    }
+    return __spreadValues(__spreadValues({}, item), rowIdAndGetProperty);
+  });
+};
+import { getWidgetMappingForType, getBooleanDataset } from "./widgetMapping";
+const isColumnVisibleForViewport = (column, viewportWidth) => {
+  if (!column || typeof viewportWidth !== "number" || viewportWidth < 0) {
+    return true;
+  }
+  const MOBILE_BREAKPOINT = 576;
+  const TABLET_BREAKPOINT = 768;
+  const DESKTOP_BREAKPOINT = 992;
+  const isMobile = viewportWidth < MOBILE_BREAKPOINT;
+  const isTablet = viewportWidth >= MOBILE_BREAKPOINT && viewportWidth < DESKTOP_BREAKPOINT;
+  const isDesktop = viewportWidth >= DESKTOP_BREAKPOINT;
+  const mobiledisplay = column.mobiledisplay !== false;
+  const tabletdisplay = column.tabletdisplay !== false;
+  const pcdisplay = column.pcdisplay !== false;
+  if (isMobile && !mobiledisplay) {
+    return false;
+  }
+  if (isTablet && !tabletdisplay) {
+    return false;
+  }
+  if (isDesktop && !pcdisplay) {
+    return false;
+  }
+  return true;
+};
+function transformExpression(exp) {
+  if (typeof exp === "string") {
+    let transformedExp = exp.replace(
+      /(?:[\w$]+(?:\?\.|\.))*getProperty(?:\?\.)?\(\s*(['"])(.*?)\1\s*\)/g,
+      (_, quote, key) => `rowData['${key}']`
+    );
+    const parts = transformedExp.split(/(".*?"|'.*?')/);
+    return parts.map((part) => {
+      if (part.startsWith('"') || part.startsWith("'")) {
+        return part;
+      }
+      return part.replace(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g, (match) => {
+        const 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['${match}']`;
+      });
+    }).join("");
+  }
+  return exp;
+}
+function getChildComponentDisplayName(child) {
+  if (!(child == null ? void 0 : child.type)) return "";
+  const type = child.type;
+  const name = type.displayName || type.name || "";
+  const inner = type.type || type.render;
+  if (inner) {
+    return inner.displayName || inner.name || name;
+  }
+  return name;
+}
+const parseTableColumns = (children, dataset) => {
+  const columns = [];
+  React.Children.forEach(children, (child) => {
+    if (child && child.props && child.props.name && (child.props.name.includes("wm_table_column") || child.props.name.includes("col_"))) {
+      const props = get(child, "props", {});
+      const binding = get(props, "binding");
+      const aggregate = getAggregateFunctions(dataset, binding);
+      columns.push(__spreadProps(__spreadValues({}, props), {
+        field: get(props, "binding"),
+        caption: get(props, "caption"),
+        displayName: get(props, "caption"),
+        show: get(props, "show", true) !== false,
+        sortable: get(props, "sortable", true) !== false,
+        textalignment: get(props, "textalignment", "left"),
+        backgroundcolor: get(props, "backgroundcolor"),
+        textcolor: get(props, "textcolor"),
+        width: get(props, "width"),
+        editWidgetType: get(props, "editWidgetType", "WmText"),
+        widgetType: get(props, "widgetType", "label"),
+        required: get(props, "required") === true || get(props, "required") === "true",
+        defaultvalue: get(props, "defaultvalue"),
+        disabled: transformExpression(get(props, "disabled")),
+        readonly: get(props, "readonly") || get(props, "readonly") === "true",
+        placeholder: get(props, "placeholder"),
+        sortby: get(props, "sortby"),
+        aggregate,
+        colClass: get(props, "colClass")
+      }));
+    }
+  });
+  return columns;
+};
+const getAggregateFunctions = (dataset, binding) => {
+  function _getColumnData() {
+    return map(dataset, binding);
+  }
+  const aggregate = {
+    sum: () => {
+      return sum(_getColumnData());
+    },
+    average: (precision = 2) => {
+      return round(mean(_getColumnData()), precision);
+    },
+    count: () => {
+      return _getColumnData().length;
+    },
+    minimum: () => {
+      return min(_getColumnData());
+    },
+    maximum: () => {
+      return max(_getColumnData());
+    },
+    percent: (value, precision = 2) => {
+      return round(sum(_getColumnData()) / value * 100, precision);
+    }
+  };
+  return aggregate;
+};
+const parseTableStructureWithGroups = (children) => {
+  const structure = [];
+  React.Children.forEach(children, (child) => {
+    if (!child || !child.props) return;
+    const childName = get(child, "props.name", "");
+    const displayName = getChildComponentDisplayName(child);
+    if (childName.includes("group")) {
+      const props = get(child, "props", {});
+      const group = {
+        isGroup: true,
+        field: get(props, "name", ""),
+        displayName: get(props, "caption", ""),
+        textAlignment: get(props, "textalignment"),
+        backgroundColor: get(props, "backgroundcolor"),
+        class: get(props, "class"),
+        colClass: get(props, "col-class"),
+        styles: get(props, "styles"),
+        columns: parseTableStructureWithGroups(child.props.children)
+        // Recursive for nested groups
+      };
+      structure.push(group);
+    } else if (childName.includes("wm_table_column") || childName.includes("col_") || (displayName == null ? void 0 : displayName.includes("WmTableColumn"))) {
+      const props = get(child, "props", {});
+      const column = __spreadValues({
+        field: get(props, "binding"),
+        caption: get(props, "caption"),
+        displayName: get(props, "caption"),
+        show: get(props, "show", true) !== false,
+        sortable: get(props, "sortable", true) !== false,
+        textalignment: get(props, "textalignment", "left"),
+        backgroundcolor: get(props, "backgroundcolor"),
+        textcolor: get(props, "textcolor"),
+        width: get(props, "width"),
+        editWidgetType: get(props, "editWidgetType", "WmText"),
+        widgetType: get(props, "widgetType", "label"),
+        required: get(props, "required") === true || get(props, "required") === "true",
+        defaultvalue: get(props, "defaultvalue"),
+        disabled: get(props, "disabled") === true || get(props, "disabled") === "true",
+        placeholder: get(props, "placeholder"),
+        sortby: get(props, "sortby")
+      }, props);
+      structure.push(column);
+    }
+  });
+  return structure;
+};
+const flattenTableStructure = (structure) => {
+  const columns = [];
+  structure.forEach((item) => {
+    if ("isGroup" in item && item.isGroup) {
+      columns.push(...flattenTableStructure(item.columns));
+    } else {
+      columns.push(item);
+    }
+  });
+  return columns;
+};
+const isTableChildOfType = (child, namePattern, componentToken) => {
+  var _a;
+  if (!((_a = child == null ? void 0 : child.props) == null ? void 0 : _a.name)) return false;
+  const propName = child.props.name;
+  const displayName = getChildComponentDisplayName(child);
+  return propName.includes(namePattern) || displayName.includes(componentToken);
+};
+const parseTableChildActions = (children, namePattern, componentToken) => {
+  const actions = [];
+  React.Children.forEach(children, (child) => {
+    if (isTableChildOfType(child, namePattern, componentToken)) {
+      const props = get(child, "props", {});
+      const actionProps = assign({}, props);
+      if (child.key) {
+        actionProps.key = child.key;
+      }
+      actions.push(actionProps);
+    }
+  });
+  return actions;
+};
+const parseTableRowActions = (children) => parseTableChildActions(children, "wm_table_row_action", "WmTableRowAction");
+const parseTableActions = (children) => parseTableChildActions(children, "wm_table_action", "WmTableAction");
+function isTableRowComponent(child) {
+  if (!(child == null ? void 0 : child.type)) return false;
+  const name = child.type.displayName || child.type.name || "";
+  if (name === "WmTableRow" || name.includes("WmTableRow") && !name.includes("WmTableRowAction"))
+    return true;
+  const inner = child.type.type || child.type.render;
+  if (inner) {
+    const innerName = inner.displayName || inner.name || "";
+    if (innerName.includes("WmTableRow") && !innerName.includes("WmTableRowAction")) return true;
+  }
+  return false;
+}
+const getRowExpansionConfig = (config, rowId, rowData) => {
+  if (!config) return null;
+  const overrides = typeof config.tableRowProps === "function" && rowData !== void 0 ? config.tableRowProps(rowData) : {};
+  return __spreadValues(__spreadValues({}, config), overrides);
+};
+const parseTableRowExpansion = (children) => {
+  let rowExpansionConfig = null;
+  React.Children.forEach(children, (child) => {
+    if (isTableRowComponent(child)) {
+      const props = get(child, "props", {});
+      if (props.rowType === "expansion" || typeof props.renderPartial === "function" || props.content) {
+        rowExpansionConfig = props;
+      }
+    } else if (child && child.props && child.props.name) {
+      const name = child.props.name;
+      if (name.startsWith("wm_table_row_") && !name.includes("_action")) {
+        const props = get(child, "props", {});
+        rowExpansionConfig = props;
+      }
+    }
+  });
+  return rowExpansionConfig;
+};
+const isEditAction = (actionKey) => actionKey === "updaterow";
+const isDeleteAction = (actionKey) => actionKey === "deleterow";
+const isAddNewAction = (actionKey) => actionKey === "addNewRow";
+const getActionButtonClass = (action) => {
+  const actionKey = get(action, "key") || get(action, "name") || get(action, "action");
+  if (isEditAction(actionKey)) {
+    const updateRowClasses = get(action, "className", "");
+    return `row-action row-action-button btn-transparent edit edit-row-button ${updateRowClasses}`;
+  }
+  if (isDeleteAction(actionKey) || actionKey === "delete") {
+    const deleteRowClasses = get(action, "className", "");
+    return `row-action row-action-button btn-transparent delete delete-row-button ${TABLE_CSS_CLASSES.deleteRow} ${deleteRowClasses}`;
+  }
+  return `row-action row-action-button ${get(action, "className", "btn-transparent")}`;
+};
+const getTableActionButtonClass = (action) => {
+  return `btn ${get(action, "className", "btn-primary")} ${isAddNewAction(get(action, "key")) ? "add-action" : ""}`;
+};
+const validateEditingFields = (fieldRefs, editingRowId) => {
+  const invalidElements = [];
+  const invalidFieldKeys = [];
+  const shouldValidateField = (fieldKey) => {
+    if (!editingRowId) return true;
+    return startsWith(fieldKey, `${editingRowId}_`);
+  };
+  forEach(entries(fieldRefs), ([fieldKey, fieldElement]) => {
+    if (!shouldValidateField(fieldKey) || !fieldElement) {
+      return;
+    }
+    let isInvalid = false;
+    const inputs = fieldElement.querySelectorAll("input, select, textarea");
+    forEach(inputs, (input) => {
+      if (input && !input.validity.valid && input.hasAttribute("required")) {
+        invalidElements.push(input);
+        isInvalid = true;
+      }
+      if (input && input.classList.contains("ng-invalid")) {
+        invalidElements.push(input);
+        isInvalid = true;
+      }
+      if (input && input.hasAttribute("required") && !trim(input.value)) {
+        invalidElements.push(input);
+        isInvalid = true;
+      }
+    });
+    if (fieldElement.hasAttribute("required")) {
+      const inputEl = fieldElement.querySelector("input, textarea, select");
+      if (inputEl && !trim(inputEl.value)) {
+        invalidElements.push(inputEl);
+        isInvalid = true;
+      }
+    }
+    if (isInvalid) {
+      invalidFieldKeys.push(fieldKey);
+    }
+  });
+  if (size(invalidElements) > 0) {
+    const logPrefix = editingRowId ? `[${editingRowId}]` : "[Validation]";
+    console.log(`${logPrefix} Validation failed: Found ${size(invalidElements)} invalid elements`);
+    const firstInvalidElement = get(invalidElements, "[0]");
+    if (firstInvalidElement) {
+      const cell = firstInvalidElement.closest("td, .app-datagrid-cell, .form-field");
+      if (cell) {
+        const focusTarget = cell.querySelector(
+          "[focus-target], input, textarea, select"
+        );
+        if (focusTarget) {
+          setTimeout(() => {
+            focusTarget.focus();
+            console.log(`${logPrefix} Focused first invalid field:`, focusTarget);
+          }, 0);
+        }
+      } else {
+        setTimeout(() => {
+          firstInvalidElement.focus();
+        }, 0);
+      }
+    }
+  }
+  return {
+    isValid: isEmpty(invalidElements),
+    invalidElements,
+    invalidFieldKeys,
+    firstInvalidElement: size(invalidElements) > 0 ? get(invalidElements, "[0]") : void 0
+  };
+};
+const getButtonClasses = (action, spacing = "normal", isGridEditMode = false, isLoading = false) => {
+  const baseClass = `btn ${get(action, "className", "btn-primary")} ${isAddNewAction(get(action, "key")) ? "add-action" : ""}`;
+  const spacingClass = spacing === "condensed" ? "btn-sm" : "";
+  const disabledClass = get(action, "key") === "addNewRow" && (isGridEditMode || isLoading) ? "disabled-new" : "";
+  return trim(`${baseClass} ${spacingClass} ${disabledClass}`);
+};
+const getSpacingClasses = (spacing = "normal") => {
+  const classes = [];
+  if (spacing === "condensed") {
+    classes.push("table-condensed");
+  }
+  return classes.join(" ");
+};
+const shouldShowPagination = ({
+  shownavigation,
+  onDemandLoad,
+  internalDataset,
+  pagesize,
+  allowpagesizechange,
+  datasource,
+  showrecordcount = false
+}) => {
+  var _a;
+  if (!shownavigation) return false;
+  if (((_a = datasource == null ? void 0 : datasource.pagination) == null ? void 0 : _a.totalElements) > 0) return true;
+  if (allowpagesizechange) return true;
+  if (showrecordcount) return true;
+  return onDemandLoad || size(internalDataset) > pagesize;
+};
+const shouldShowPanelHeading = (title, subheading, iconclass, exportformat = [], headerActions = []) => {
+  return !isEmpty(title) || !isEmpty(subheading) || !isEmpty(iconclass) || size(exportformat) > 0 || size(headerActions) > 0;
+};
+const handleNewRowNavigation = (tableRef, newRecord, internalDataset) => {
+  if (!get(tableRef, "current")) return;
+  const table = get(tableRef, "current");
+  const sortingState = get(table.getState(), "sorting");
+  const hasSorting = sortingState && size(sortingState) > 0;
+  if (hasSorting) {
+    setTimeout(() => {
+      const sortedRows = get(table.getSortedRowModel(), "rows", []);
+      const newRecordIndex = findIndex(
+        sortedRows,
+        (row) => get(row, "original._wmTableRowId") === get(newRecord, "_wmTableRowId")
+      );
+      if (newRecordIndex !== -1) {
+        const currentPageSize = get(table.getState(), "pagination.pageSize");
+        const targetPage = floor(newRecordIndex / currentPageSize);
+        table.setPageIndex(targetPage);
+      }
+    }, 0);
+  } else {
+    const currentPageSize = get(table.getState(), "pagination.pageSize");
+    const newDatasetLength = size(internalDataset) + 1;
+    const totalPages = ceil(newDatasetLength / currentPageSize);
+    table.setPageIndex(max([0, totalPages - 1]));
+  }
+};
+const 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"
+];
+const INTERNAL_FIELD_SUFFIXES = ["_formWidget"];
+const cleanRowData = (data) => {
+  if (!data) return data;
+  if (isArray(data)) {
+    return data.map((item) => cleanRowData(item));
+  }
+  if (typeof data === "object") {
+    const result = {};
+    for (const key of Object.keys(data)) {
+      if (INTERNAL_PROPERTIES.includes(key)) {
+        continue;
+      }
+      if (INTERNAL_FIELD_SUFFIXES.some((suffix) => key.endsWith(suffix))) {
+        continue;
+      }
+      const value = data[key];
+      if (value && typeof value === "object") {
+        result[key] = cleanRowData(value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  return data;
+};
+const parseWidth = (width, fallbackSize = 150) => {
+  let columnSize = fallbackSize;
+  const styleWidth = width;
+  if (typeof styleWidth === "string") {
+    if (styleWidth.endsWith("%")) {
+      const percentage = parseFloat(styleWidth);
+      columnSize = Math.round(percentage / 100 * 1200);
+    } else if (styleWidth.endsWith("px")) {
+      columnSize = parseInt(styleWidth);
+    } else {
+      columnSize = parseInt(styleWidth);
+    }
+  }
+  return columnSize;
+};
+function isColumnDomHidden(meta) {
+  return !!(meta == null ? void 0 : meta.domHidden);
+}
+function getDomHiddenColStyle(meta) {
+  if (!isColumnDomHidden(meta)) {
+    return void 0;
+  }
+  return {
+    display: "none",
+    width: 0,
+    minWidth: 0,
+    maxWidth: 0
+  };
+}
+function getDomHiddenCellStyle(meta) {
+  if (!isColumnDomHidden(meta)) {
+    return void 0;
+  }
+  return {
+    display: "none",
+    width: 0,
+    minWidth: 0,
+    maxWidth: 0,
+    padding: 0
+  };
+}
+const getColClass = (colClass, rowData, columnName) => {
+  if (!colClass || typeof colClass !== "string") {
+    return "";
+  }
+  const trimmedClass = trim(colClass);
+  if (!trimmedClass) {
+    return "";
+  }
+  const hasExpressionOperators = /[?&|<>!=]/.test(trimmedClass) || trimmedClass.includes("(") || trimmedClass.includes("&&") || trimmedClass.includes("||") || trimmedClass.includes("===") || trimmedClass.includes("!==");
+  const hasRowDataReference = trimmedClass.includes("rowData");
+  const hasColumnNameReference = trimmedClass.includes("columnName");
+  const isExpression = hasExpressionOperators || hasRowDataReference || hasColumnNameReference;
+  if (!isExpression) {
+    return trimmedClass;
+  }
+  try {
+    let expressionToEvaluate = trimmedClass;
+    const evaluated = new Function("rowData", "columnName", `return ${expressionToEvaluate}`)(
+      rowData,
+      columnName
+    );
+    if (evaluated === null || evaluated === void 0) {
+      return "";
+    }
+    if (typeof evaluated === "boolean") {
+      return evaluated ? String(evaluated) : "";
+    }
+    return String(evaluated);
+  } catch (error) {
+    console.warn("Failed to evaluate colClass expression:", trimmedClass, error);
+    return "";
+  }
+};
+import {
+  TABLE_CSS_CLASSES as TABLE_CSS_CLASSES2,
+  TABLE_DATA_STATES,
+  TABLE_MESSAGES,
+  INTERACTIVE_CLASSES,
+  INTERACTIVE_ROLES,
+  INTERACTIVE_DATA_ROLES,
+  INTERACTIVE_TAG_NAMES,
+  UNSUPPORTED_STATE_PERSISTENCE_TYPES
+} from "./constants";
+import { renderDisplayCell } from "./renderDisplayCell";
+import { buildSelectionColumns } from "./buildSelectionColumns";
+import { validateField, resetValidationState, updateValidationErrors } from "./validation";
+import {
+  hasInteractiveClass,
+  hasInteractiveAttributes,
+  isInteractiveElement,
+  getRowIdsFromDataset,
+  rowExistsInDataset,
+  selectionStateHelpers
+} from "./selectionUtils";
+import {
+  createRowIndexColumn,
+  createDataColumn,
+  createDataColumns,
+  createEditingActionButtons,
+  createDefaultColumnProps,
+  getActionColumnSize
+} from "./columnBuilder";
+import { isDataColumn, hasExplicitWidth, distributeColumnWidths } from "./columnWidthDistribution";
+import {
+  saveTableState,
+  getTableState,
+  clearTableState,
+  convertFilterArrayToObject,
+  convertFilterObjectToArray
+} from "./table-helpers";
+export {
+  INTERACTIVE_CLASSES,
+  INTERACTIVE_DATA_ROLES,
+  INTERACTIVE_ROLES,
+  INTERACTIVE_TAG_NAMES,
+  INTERNAL_PROPERTIES,
+  TABLE_CSS_CLASSES2 as TABLE_CSS_CLASSES,
+  TABLE_DATA_STATES,
+  TABLE_MESSAGES,
+  UNSUPPORTED_STATE_PERSISTENCE_TYPES,
+  addUniqueRowIds,
+  buildSelectionColumns,
+  cleanRowData,
+  clearTableState,
+  convertFilterArrayToObject,
+  convertFilterObjectToArray,
+  createDataColumn,
+  createDataColumns,
+  createDefaultColumnProps,
+  createEditingActionButtons,
+  createRowIndexColumn,
+  distributeColumnWidths,
+  extractDataArray,
+  flattenTableStructure,
+  getActionButtonClass,
+  getActionColumnSize,
+  getAggregateFunctions,
+  getBooleanDataset,
+  getButtonClasses,
+  getChildComponentDisplayName,
+  getColClass,
+  getDomHiddenCellStyle,
+  getDomHiddenColStyle,
+  getRowExpansionConfig,
+  getRowIdsFromDataset,
+  getSpacingClasses,
+  getTableActionButtonClass,
+  getTableState,
+  getWidgetMappingForType,
+  handleNewRowNavigation,
+  hasExplicitWidth,
+  hasInteractiveAttributes,
+  hasInteractiveClass,
+  isAddNewAction,
+  isColumnDomHidden,
+  isColumnVisibleForViewport,
+  isDataColumn,
+  isDeleteAction,
+  isEditAction,
+  isInteractiveElement,
+  parseTableActions,
+  parseTableColumns,
+  parseTableRowActions,
+  parseTableRowExpansion,
+  parseTableStructureWithGroups,
+  parseWidth,
+  renderDisplayCell,
+  resetValidationState,
+  rowExistsInDataset,
+  saveTableState,
+  selectionStateHelpers,
+  shouldShowPagination,
+  shouldShowPanelHeading,
+  updateValidationErrors,
+  validateEditingFields,
+  validateField
+};