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

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

@@ -0,0 +1,129 @@
+const TABLE_CSS_CLASSES = {
+  tableRow: "app-datagrid-row",
+  headerCell: "app-datagrid-header-cell",
+  groupHeaderCell: "app-datagrid-group-header-cell",
+  tableCell: "app-datagrid-cell",
+  grid: "",
+  gridDefault: "table",
+  gridBody: "app-datagrid-body",
+  gridFooter: "app-datagrid-footer",
+  deleteRow: "danger",
+  ascIcon: "asc wi wi-long-arrow-up",
+  descIcon: "desc wi wi-long-arrow-down",
+  selectedColumn: "selected-column",
+  rowExpandIcon: "wi wi-minus-square",
+  rowCollapseIcon: "wi wi-plus-square",
+  gridRowExpansionClass: "table-row-expansion",
+  expandedRowClass: "expanded"
+};
+const TABLE_DATA_STATES = {
+  loading: "Loading...",
+  ready: "",
+  error: "An error occurred in loading the data.",
+  nodata: "No data found."
+};
+const TABLE_MESSAGES = {
+  // Delete dialog messages
+  deleteConfirmTitle: "Delete Record",
+  deleteConfirmMessage: "Are you sure you want to delete this record?",
+  deleteOkText: "Ok",
+  deleteCancelText: "Cancel",
+  // Toast messages
+  deleteSuccess: "Record deleted successfully",
+  deleteError: "Failed to delete record",
+  insertSuccess: "Record added successfully",
+  updateSuccess: "Record updated successfully",
+  operationError: "An error occurred",
+  // Table states
+  noDataMessage: "No data found",
+  loadingMessage: "Loading...",
+  errorStateMessage: "An error occurred",
+  // Selection
+  radioSelectAriaLabel: "Select row",
+  multiSelectAriaLabel: "Select all rows"
+};
+const INTERACTIVE_CLASSES = [
+  // MUI base components
+  "MuiInputBase",
+  "MuiSelect",
+  "MuiButton",
+  "MuiCheckbox",
+  "MuiRadio",
+  "MuiSlider",
+  "MuiSwitch",
+  "MuiTextField",
+  "MuiAutocomplete",
+  "MuiChip",
+  "MuiRating",
+  "MuiToggleButton",
+  // Date/time pickers
+  "MuiPickersDay",
+  "MuiDatePicker",
+  "MuiTimePicker",
+  "MuiDateTimePicker",
+  "MuiCalendarPicker",
+  "MuiClockPicker",
+  // Color picker
+  "MuiColorPicker",
+  // Form controls
+  "MuiFormControl",
+  "MuiFormGroup",
+  "MuiFormControlLabel",
+  // WaveMaker specific widgets
+  "app-text",
+  "app-textarea",
+  "app-checkbox",
+  "app-slider",
+  "app-currency",
+  "app-switch",
+  "app-select",
+  "app-checkboxset",
+  "app-radioset",
+  "app-date",
+  "app-time",
+  "app-timestamp",
+  "app-rating",
+  "app-datetime",
+  "app-search",
+  "app-chips",
+  "app-colorpicker",
+  "app-calendar",
+  "app-editor"
+];
+const INTERACTIVE_ROLES = ["button", "textbox", "combobox", "listbox"];
+const INTERACTIVE_DATA_ROLES = [
+  "input",
+  "select",
+  "date",
+  "time",
+  "color",
+  "editor",
+  "checkbox",
+  "radio",
+  "slider",
+  "chips",
+  "rating"
+];
+const INTERACTIVE_TAG_NAMES = [
+  "INPUT",
+  "BUTTON",
+  "SELECT",
+  "TEXTAREA",
+  "A",
+  "LABEL"
+];
+const UNSUPPORTED_STATE_PERSISTENCE_TYPES = [
+  "Scroll",
+  "On-Demand",
+  "Inline"
+];
+export {
+  INTERACTIVE_CLASSES,
+  INTERACTIVE_DATA_ROLES,
+  INTERACTIVE_ROLES,
+  INTERACTIVE_TAG_NAMES,
+  TABLE_CSS_CLASSES,
+  TABLE_DATA_STATES,
+  TABLE_MESSAGES,
+  UNSUPPORTED_STATE_PERSISTENCE_TYPES
+};

package/components/data/table/utils/crud-handlers.d.ts

@@ -0,0 +1,11 @@
+import { ServerOperationOptions, DeleteOperationOptions } from "../props";
+import { LiveVariableConfig } from "@wavemaker-ai/react-runtime/variables/live-variable";
+export declare const refreshDataSource: (datasource: LiveVariableConfig, options: {
+    filterFields?: Record<string, any>;
+    orderBy?: string;
+    page?: number;
+    condition?: string;
+    pagesize?: number;
+}) => Promise<any>;
+export declare const handleServerOperation: (options: ServerOperationOptions) => Promise<boolean>;
+export declare const handleDeleteOperation: (options: DeleteOperationOptions) => Promise<boolean>;

package/components/data/table/utils/crud-handlers.js

@@ -0,0 +1,342 @@
+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 uniqueId from "lodash-es/uniqueId";
+import filter from "lodash-es/filter";
+import findIndex from "lodash-es/findIndex";
+import slice from "lodash-es/slice";
+import forEach from "lodash-es/forEach";
+import some from "lodash-es/some";
+import { DataSource } from "../../types";
+const getDatasourceInfo = async (datasource) => {
+  var _a, _b;
+  const [supportsCrud, isApiAware] = await Promise.all([
+    datasource == null ? void 0 : datasource.execute(DataSource.Operation.SUPPORTS_CRUD),
+    datasource == null ? void 0 : datasource.execute(DataSource.Operation.IS_API_AWARE)
+  ]);
+  const currentPageNum = ((_b = (_a = datasource.pagination) == null ? void 0 : _a.number) != null ? _b : 0) + 1;
+  const shouldUseServer = supportsCrud || !isApiAware || datasource.category === "wm.CrudVariable";
+  return { supportsCrud, isApiAware, currentPageNum, shouldUseServer };
+};
+const handleOperationResult = (operation, response, error, options) => {
+  const { showToast, onSuccess, onRowCallback, message, onError, errormessage, widget } = options;
+  if (error) {
+    showToast == null ? void 0 : showToast(error || errormessage, "Error");
+    onError == null ? void 0 : onError(null, widget, error, operation);
+    return false;
+  }
+  if (!onRowCallback && showToast && message) {
+    showToast(message, "Success");
+  }
+  onSuccess == null ? void 0 : onSuccess(operation, response);
+  onRowCallback == null ? void 0 : onRowCallback(null, widget, response);
+  return true;
+};
+const createCompleteRecord = (editingData, wmTableColumns, serverResponse) => {
+  const completeRecord = {};
+  forEach(wmTableColumns, (column) => {
+    var _a, _b;
+    if (column.field) {
+      completeRecord[column.field] = (_b = (_a = editingData[column.field]) != null ? _a : column.defaultvalue) != null ? _b : "";
+    }
+  });
+  return __spreadProps(__spreadValues(__spreadValues({}, completeRecord), serverResponse), { _wmTableRowId: uniqueId("new_row_") });
+};
+const hasValidData = (record) => some(record, (value) => value !== void 0 && value !== null && value !== "");
+const updateDataset = (isNewRow, rowId, editingData, wmTableColumns, serverResponse, options) => {
+  const {
+    setInternalDataset,
+    onNewRowAdded,
+    onRowUpdate,
+    showToast,
+    insertmessage,
+    updatemessage
+  } = options;
+  if (isNewRow) {
+    const completeRecord = createCompleteRecord(editingData, wmTableColumns, serverResponse);
+    if (!hasValidData(completeRecord)) return false;
+    setInternalDataset((prevDataset) => {
+      const updatedDataset = [...prevDataset, completeRecord];
+      onNewRowAdded == null ? void 0 : onNewRowAdded(completeRecord);
+      if (showToast && insertmessage) showToast(insertmessage, "Success");
+      return updatedDataset;
+    });
+  } else {
+    setInternalDataset((prevDataset) => {
+      const rowIndex = findIndex(prevDataset, (row) => row._wmTableRowId === rowId);
+      const updatedDataset = prevDataset.map(
+        (row) => row._wmTableRowId === rowId ? __spreadValues(__spreadValues(__spreadValues({}, row), editingData), serverResponse) : row
+      );
+      if (onRowUpdate && rowIndex !== -1) {
+        setTimeout(() => onRowUpdate(editingData, rowIndex, updatedDataset), 0);
+      }
+      if (showToast && updatemessage) showToast(updatemessage, "Success");
+      return updatedDataset;
+    });
+  }
+  return true;
+};
+const processFieldValue = (value, column, isNewRow) => {
+  var _a, _b;
+  const fields = column.field.split(".");
+  if (fields.length === 1 && ((_a = column.editWidgetType) == null ? void 0 : _a.toLowerCase()) === "wmupload") return value;
+  if (value === "null") value = null;
+  if (value === null || value === void 0) value = (_b = column.defaultvalue) != null ? _b : "";
+  if (column.editWidgetType === "WmCheckbox" || column.editWidgetType === "WmSwitch")
+    return Boolean(value);
+  if (column.editWidgetType === "WmNumber" || column.editWidgetType === "WmCurrency") {
+    const numValue = Number(value);
+    return isNaN(numValue) ? 0 : numValue;
+  }
+  if (value === null) {
+    if (fields.length > 1) return null;
+    return isNewRow ? null : "";
+  }
+  return value;
+};
+const collectFormData = (currentEditingData, wmTableColumns, isNewRow) => {
+  const formData = {};
+  forEach(wmTableColumns, (column) => {
+    if (!column.field) return;
+    const fields = column.field.split(".");
+    const processedValue = processFieldValue(currentEditingData[column.field], column, isNewRow);
+    if (processedValue === null && fields.length > 1) {
+      formData[fields[0]] = null;
+    } else if (processedValue !== void 0) {
+      formData[column.field] = processedValue;
+    }
+  });
+  return formData;
+};
+const adjustPaginationAfterDelete = async (tableInstance, internalDataset, datasource, isServerSidePagination) => {
+  if (!tableInstance) return { shouldRefresh: false, targetPage: 0 };
+  const {
+    pagination: { pageIndex: currentPage, pageSize }
+  } = tableInstance.getState();
+  if (isServerSidePagination && (datasource == null ? void 0 : datasource.pagination)) {
+    const { numberOfElements, totalElements } = datasource.pagination;
+    if (numberOfElements === 1 && currentPage > 0) {
+      tableInstance.setPageIndex(currentPage - 1);
+      return { shouldRefresh: true, targetPage: currentPage };
+    }
+    if (totalElements === 1) {
+      tableInstance.setPageIndex(0);
+      return { shouldRefresh: true, targetPage: 1 };
+    }
+    return { shouldRefresh: true, targetPage: currentPage + 1 };
+  }
+  const pageItems = slice(internalDataset, currentPage * pageSize, (currentPage + 1) * pageSize);
+  if (pageItems.length === 1 && currentPage > 0) {
+    tableInstance.setPageIndex(currentPage - 1);
+  }
+  return { shouldRefresh: false, targetPage: currentPage };
+};
+const handleNonApiAwareOperation = async (datasource, binddataset, formData, operation) => {
+  const path = binddataset.split(".");
+  const parentIndex = parseInt(path[path.length - 1]);
+  const parentPath = path.slice(0, -1).join(".");
+  return datasource == null ? void 0 : datasource.execute(DataSource.Operation[operation], {
+    item: formData,
+    path: parentPath,
+    parentIndex
+  });
+};
+const refreshDataSource = async (datasource, options) => {
+  if (!datasource) throw new Error("Datasource is required");
+  return datasource == null ? void 0 : datasource.execute(DataSource.Operation.LIST_RECORDS, {
+    filterFields: options.filterFields || {},
+    orderBy: options.orderBy,
+    page: options.page || 1,
+    logicalOp: options.condition || ""
+  });
+};
+const handleServerOperation = async (options) => {
+  var _a, _b;
+  const {
+    datasource,
+    binddataset,
+    isNewRow,
+    rowId,
+    currentEditingData,
+    wmTableColumns,
+    setInternalDataset,
+    onNewRowAdded,
+    onRowUpdate,
+    showToast,
+    insertmessage,
+    updatemessage,
+    onRowinsert,
+    onRowupdate,
+    onSuccess,
+    onError,
+    errormessage,
+    tableInstance,
+    isServerSidePagination,
+    listener,
+    widgetName
+  } = options;
+  const widget = widgetName ? (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[widgetName] : void 0;
+  try {
+    const formData = collectFormData(currentEditingData, wmTableColumns, isNewRow);
+    let response = currentEditingData;
+    if (datasource) {
+      const { isApiAware, currentPageNum, shouldUseServer } = await getDatasourceInfo(datasource);
+      if (shouldUseServer) {
+        if (!isApiAware && binddataset) {
+          await handleNonApiAwareOperation(
+            datasource,
+            binddataset,
+            formData,
+            isNewRow ? "ADD_ITEM" : "SET_ITEM"
+          );
+        } else {
+          response = await (datasource == null ? void 0 : datasource.execute(
+            isNewRow ? DataSource.Operation.INSERT_RECORD : DataSource.Operation.UPDATE_RECORD,
+            { row: formData, skipNotification: true }
+          ));
+          if (response.error) throw response.error;
+          if (isNewRow && isServerSidePagination && datasource.pagination) {
+            const { totalElements, size = 10 } = datasource.pagination;
+            if (totalElements !== void 0 && size > 0) {
+              const lastPage = Math.ceil((totalElements + 1) / size);
+              if (tableInstance && lastPage > currentPageNum) {
+                tableInstance.setPageIndex(lastPage - 1);
+              } else {
+                await refreshDataSource(datasource, { page: currentPageNum, pagesize: size });
+              }
+            }
+          } else {
+            await refreshDataSource(datasource, {
+              page: currentPageNum,
+              pagesize: ((_b = datasource.pagination) == null ? void 0 : _b.size) || 10
+            });
+          }
+        }
+      }
+    }
+    updateDataset(isNewRow, rowId, currentEditingData, wmTableColumns, response, {
+      setInternalDataset,
+      onNewRowAdded,
+      onRowUpdate,
+      showToast,
+      insertmessage,
+      updatemessage
+    });
+    return handleOperationResult(isNewRow ? "insert" : "update", response, null, {
+      showToast,
+      onSuccess,
+      onRowCallback: isNewRow ? onRowinsert : onRowupdate,
+      message: isNewRow ? insertmessage : updatemessage,
+      onError,
+      widget
+    });
+  } catch (error) {
+    return handleOperationResult(isNewRow ? "insert" : "update", null, error, {
+      showToast,
+      onError,
+      errormessage,
+      widget
+    });
+  }
+};
+const handleDeleteOperation = async (options) => {
+  var _a, _b;
+  const {
+    rowData,
+    tableInstance,
+    internalDataset,
+    setInternalDataset,
+    datasource,
+    binddataset,
+    onRowDelete,
+    showToast,
+    deletemessage,
+    onSuccess,
+    onRowdelete,
+    onError,
+    errormessage,
+    isServerSidePagination,
+    listener,
+    widgetName
+  } = options;
+  const widget = widgetName ? (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[widgetName] : void 0;
+  try {
+    const rowIndex = findIndex(
+      internalDataset,
+      (row) => row._wmTableRowId === rowData._wmTableRowId || row.id !== void 0 && row.id === rowData.id
+    );
+    if (rowIndex === -1) {
+      console.warn("Row not found for deletion");
+      return false;
+    }
+    let response = rowData;
+    if (datasource) {
+      const { isApiAware, currentPageNum, shouldUseServer } = await getDatasourceInfo(datasource);
+      if (shouldUseServer) {
+        if (!isApiAware && binddataset) {
+          await handleNonApiAwareOperation(datasource, binddataset, rowData, "REMOVE_ITEM");
+        } else {
+          response = await (datasource == null ? void 0 : datasource.execute(DataSource.Operation.DELETE_RECORD, {
+            row: rowData,
+            skipNotification: true
+          }));
+          if (response.error) throw response.error;
+        }
+      }
+    }
+    const newDataset = filter(
+      internalDataset,
+      (row) => row._wmTableRowId !== rowData._wmTableRowId && (row.id === void 0 || row.id !== rowData.id)
+    );
+    setInternalDataset(() => newDataset);
+    const paginationResult = await adjustPaginationAfterDelete(
+      tableInstance,
+      internalDataset,
+      datasource,
+      isServerSidePagination || false
+    );
+    if (isServerSidePagination && paginationResult.shouldRefresh && datasource) {
+      await (datasource == null ? void 0 : datasource.invoke({
+        page: paginationResult.targetPage,
+        pagesize: ((_b = datasource.pagination) == null ? void 0 : _b.size) || 10
+      }));
+    }
+    onRowDelete == null ? void 0 : onRowDelete(rowData, rowIndex, newDataset);
+    return handleOperationResult("delete", response, null, {
+      showToast,
+      onSuccess,
+      onRowCallback: onRowdelete,
+      message: deletemessage,
+      onError,
+      widget
+    });
+  } catch (error) {
+    return handleOperationResult("delete", null, error, {
+      showToast,
+      onError,
+      errormessage,
+      widget
+    });
+  }
+};
+export {
+  handleDeleteOperation,
+  handleServerOperation,
+  refreshDataSource
+};

package/components/data/table/utils/dynamic-columns.d.ts

@@ -0,0 +1,38 @@
+import { WmTableColumnProps } from "../props";
+/**
+ * Check if a field should be excluded from dynamic column generation
+ * Combines existing INTERNAL_PROPERTIES with pattern-based detection
+ * @param fieldName - The field name to check
+ * @returns true if the field should be excluded
+ */
+export declare const isInternalField: (fieldName: string) => boolean;
+/**
+ * Merge first rows (Angular uses up to 10) so nulls in row 0 are filled from later rows.
+ * Same idea as Angular getMetaDataFromData + assignWith in prepareFieldDefs.
+ */
+export declare const mergeRowsForAllFields: (data: any[]) => Record<string, any> | null;
+export interface PreparedFieldTerminal {
+    displayName: string;
+    field: string;
+    binding: string;
+    relatedTable?: string;
+    relatedField?: string;
+}
+/**
+ * Flatten nested objects/arrays into leaf field paths (e.g. children[0].dataset),
+ * matching Angular's prepareFieldDefs / pushFieldDefs in widget-utils.ts so
+ * onBeforedatarender scripts can toggle columns['children[0].widget'].show etc.
+ *
+ * Uses lodash `pickBy` to drop internal keys in one pass per object; recursion stays shallow.
+ */
+export declare const prepareFieldsFromMergedRow: (mergedRow: Record<string, any>) => PreparedFieldTerminal[];
+/**
+ * Generate column definitions from data array.
+ * Uses Angular-style nested flattening (prepareFieldDefs) so dynamic tables and
+ * onBeforedatarender(column) proxies match WaveMaker Angular (e.g. children[0].name).
+ */
+export declare const generateColumnsFromData: (data: any[]) => WmTableColumnProps[];
+/**
+ * Check if data is valid for column generation
+ */
+export declare const isValidDataForColumns: (data: any[]) => boolean;

package/components/data/table/utils/dynamic-columns.js

@@ -0,0 +1,172 @@
+var __defProp = Object.defineProperty;
+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;
+};
+import assignWith from "lodash-es/assignWith";
+import forEach from "lodash-es/forEach";
+import get from "lodash-es/get";
+import isArray from "lodash-es/isArray";
+import pickBy from "lodash-es/pickBy";
+import startCase from "lodash-es/startCase";
+import { createDefaultColumnProps } from "./columnBuilder";
+import { INTERNAL_PROPERTIES } from "./index";
+const INTERNAL_FIELD_PATTERNS = [
+  "_wm",
+  // All fields starting with _wm (like _wmTableRowId, _wmListItemId, etc.)
+  "__"
+  // Double underscore fields (system fields)
+];
+const isInternalField = (fieldName) => {
+  if (INTERNAL_PROPERTIES.includes(fieldName)) {
+    return true;
+  }
+  return INTERNAL_FIELD_PATTERNS.some((pattern) => fieldName.startsWith(pattern));
+};
+const inferColumnType = (value) => {
+  if (value === null || value === void 0) {
+    return "string";
+  }
+  if (typeof value === "number") {
+    return "number";
+  }
+  if (typeof value === "boolean") {
+    return "boolean";
+  }
+  if (value instanceof Date) {
+    return "date";
+  }
+  if (typeof value === "string") {
+    if (!isNaN(Date.parse(value)) && value.match(/^\d{4}-\d{2}-\d{2}/)) {
+      return "date";
+    }
+    if (!isNaN(Number(value)) && value.trim() !== "") {
+      return "number";
+    }
+  }
+  return "string";
+};
+const isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+const MAX_FIELD_DEPTH = 12;
+const mergeRowsForAllFields = (data) => {
+  if (!Array.isArray(data) || data.length === 0) return null;
+  const first = data[0];
+  if (first === null || typeof first !== "object") return null;
+  const merged = __spreadValues({}, first);
+  const limit = Math.min(10, data.length);
+  for (let i = 1; i < limit; i++) {
+    const row = data[i];
+    if (row && typeof row === "object") {
+      assignWith(
+        merged,
+        row,
+        (objVal, srcVal) => objVal === null || objVal === void 0 ? srcVal : objVal
+      );
+    }
+  }
+  return merged;
+};
+const PATH_SEGMENT_WITH_INDEX = /^(.+)\[(\d+)]$/;
+function displayNameForFieldPath(fieldPath) {
+  return fieldPath.split(".").map((seg) => {
+    const m = PATH_SEGMENT_WITH_INDEX.exec(seg);
+    return m ? `${startCase(m[1])}[${m[2]}]` : startCase(seg);
+  }).join(" ");
+}
+function relatedFieldsFromKey(rawKey) {
+  if (!rawKey.includes(".")) return {};
+  const parts = rawKey.split(".");
+  return { relatedTable: parts[0], relatedField: parts[1] };
+}
+function isLeafColumnValue(value) {
+  return value === null || value === void 0 || typeof value !== "object" || value instanceof Date || isArray(value) && !value[0];
+}
+const prepareFieldsFromMergedRow = (mergedRow) => {
+  const terminals = [];
+  const pushTerminal = (fieldPath, relatedTable, relatedField) => {
+    const displayName = displayNameForFieldPath(fieldPath);
+    terminals.push({
+      displayName,
+      field: fieldPath,
+      binding: fieldPath,
+      relatedTable,
+      relatedField: relatedField != null ? relatedField : displayName
+    });
+  };
+  const pushFieldDef = (node, prefix, depth) => {
+    if (depth > MAX_FIELD_DEPTH || node == null) return;
+    if (!isPlainRecord(node)) return;
+    const visible = pickBy(node, (_v, k) => !isInternalField(String(k)));
+    forEach(visible, (value, rawKey) => {
+      const path = prefix ? `${prefix}.${rawKey}` : rawKey;
+      const rel = relatedFieldsFromKey(rawKey);
+      if (isLeafColumnValue(value)) {
+        pushTerminal(path, rel.relatedTable, rel.relatedField);
+        return;
+      }
+      if (isArray(value)) {
+        const first = value[0];
+        if (isPlainRecord(first)) {
+          pushFieldDef(first, `${path}[0]`, depth + 1);
+        } else {
+          pushTerminal(path, rel.relatedTable, rel.relatedField);
+        }
+        return;
+      }
+      if (isPlainRecord(value)) {
+        pushFieldDef(value, path, depth + 1);
+      }
+    });
+  };
+  pushFieldDef(mergedRow, "", 0);
+  return terminals;
+};
+function sampleValueAtField(data, fieldPath) {
+  const limit = Math.min(10, data.length);
+  for (let i = 0; i < limit; i++) {
+    const row = data[i];
+    if (!row || typeof row !== "object") continue;
+    const v = get(row, fieldPath);
+    if (v !== null && v !== void 0) return v;
+  }
+  return void 0;
+}
+const generateColumnsFromData = (data) => {
+  if (!data || data.length === 0) {
+    return [];
+  }
+  const merged = mergeRowsForAllFields(data);
+  if (!merged) {
+    return [];
+  }
+  const terminals = prepareFieldsFromMergedRow(merged);
+  if (terminals.length === 0) {
+    return [];
+  }
+  return terminals.map((t, index) => {
+    const firstNonNullValue = sampleValueAtField(data, t.field);
+    const inferredType = inferColumnType(firstNonNullValue);
+    return createDefaultColumnProps(t.field, t.displayName, inferredType, index);
+  });
+};
+const isValidDataForColumns = (data) => {
+  return Array.isArray(data) && data.length > 0 && data.some((row) => row && typeof row === "object" && Object.keys(row).length > 0);
+};
+export {
+  generateColumnsFromData,
+  isInternalField,
+  isValidDataForColumns,
+  mergeRowsForAllFields,
+  prepareFieldsFromMergedRow
+};