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

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

@@ -1,55 +1,42 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.prepareFieldsFromMergedRow = exports.mergeRowsForAllFields = exports.isValidDataForColumns = exports.isInternalField = exports.generateColumnsFromData = void 0;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-var _assignWith = _interopRequireDefault(require("lodash-es/assignWith"));
-var _forEach = _interopRequireDefault(require("lodash-es/forEach"));
-var _get = _interopRequireDefault(require("lodash-es/get"));
-var _isArray = _interopRequireDefault(require("lodash-es/isArray"));
-var _pickBy = _interopRequireDefault(require("lodash-es/pickBy"));
-var _startCase = _interopRequireDefault(require("lodash-es/startCase"));
-var _columnBuilder = require("./columnBuilder");
-var _constants = require("./constants");
-var _index = require("./index");
-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; }
-/**
- * List of internal WaveMaker field prefixes that should be excluded
- * from dynamic column generation
- */
-var INTERNAL_FIELD_PATTERNS = ["_wm",
-// All fields starting with _wm (like _wmTableRowId, _wmListItemId, etc.)
-"__" // Double underscore fields (system fields)
+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 { DYNAMIC_COLUMNS_CONFIG } from "./constants";
+import { INTERNAL_PROPERTIES } from "./index";
+const INTERNAL_FIELD_PATTERNS = [
+  "_wm",
+  // All fields starting with _wm (like _wmTableRowId, _wmListItemId, etc.)
+  "__"
+  // Double underscore fields (system fields)
 ];
-
-/**
- * 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
- */
-var isInternalField = exports.isInternalField = function isInternalField(fieldName) {
-  // Check exact matches from INTERNAL_PROPERTIES
-  if (_index.INTERNAL_PROPERTIES.includes(fieldName)) {
+const isInternalField = (fieldName) => {
+  if (INTERNAL_PROPERTIES.includes(fieldName)) {
     return true;
   }
-
-  // Check pattern-based exclusions
-  return INTERNAL_FIELD_PATTERNS.some(function (pattern) {
-    return fieldName.startsWith(pattern);
-  });
+  return INTERNAL_FIELD_PATTERNS.some((pattern) => fieldName.startsWith(pattern));
 };
-
-/**
- * Infer column type from data value
- */
-var inferColumnType = function inferColumnType(value) {
-  if (value === null || value === undefined) {
+const inferColumnType = (value) => {
+  if (value === null || value === void 0) {
     return "string";
   }
   if (typeof value === "number") {
@@ -62,161 +49,129 @@ var inferColumnType = function inferColumnType(value) {
     return "date";
   }
   if (typeof value === "string") {
-    // Check if it looks like a date
     if (!isNaN(Date.parse(value)) && value.match(/^\d{4}-\d{2}-\d{2}/)) {
       return "date";
     }
-    // Check if it looks like a number
     if (!isNaN(Number(value)) && value.trim() !== "") {
       return "number";
     }
   }
   return "string";
 };
-
-/** Plain object suitable for recursive field discovery (excludes Date, etc.) */
-var isPlainRecord = function isPlainRecord(value) {
-  return (0, _typeof2["default"])(value) === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
-};
-var MAX_FIELD_DEPTH = 12;
-
-/**
- * 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.
- */
-var mergeRowsForAllFields = exports.mergeRowsForAllFields = function mergeRowsForAllFields(data) {
+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;
-  var first = data[0];
-  if (first === null || (0, _typeof2["default"])(first) !== "object") return null;
-  var merged = _objectSpread({}, first);
-  var limit = Math.min(10, data.length);
-  for (var i = 1; i < limit; i++) {
-    var row = data[i];
-    if (row && (0, _typeof2["default"])(row) === "object") {
-      (0, _assignWith["default"])(merged, row, function (objVal, srcVal) {
-        return objVal === null || objVal === undefined ? srcVal : objVal;
-      });
+  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;
 };
-var PATH_SEGMENT_WITH_INDEX = /^(.+)\[(\d+)]$/;
-
-/** Caption for one binding path segment (e.g. `children[0]` → `Children[0]`). */
+const PATH_SEGMENT_WITH_INDEX = /^(.+)\[(\d+)]$/;
 function displayNameForFieldPath(fieldPath) {
-  return fieldPath.split(".").map(function (seg) {
-    var m = PATH_SEGMENT_WITH_INDEX.exec(seg);
-    return m ? "".concat((0, _startCase["default"])(m[1]), "[").concat(m[2], "]") : (0, _startCase["default"])(seg);
+  return fieldPath.split(".").map((seg) => {
+    const m = PATH_SEGMENT_WITH_INDEX.exec(seg);
+    return m ? `${startCase(m[1])}[${m[2]}]` : startCase(seg);
   }).join(" ");
 }
-
-/** Keys like `table.column` become related metadata (Angular widget-utils parity). */
 function relatedFieldsFromKey(rawKey) {
   if (!rawKey.includes(".")) return {};
-  var parts = rawKey.split(".");
-  return {
-    relatedTable: parts[0],
-    relatedField: parts[1]
-  };
+  const parts = rawKey.split(".");
+  return { relatedTable: parts[0], relatedField: parts[1] };
 }
 function isLeafColumnValue(value) {
-  return value === null || value === undefined || (0, _typeof2["default"])(value) !== "object" || value instanceof Date || (0, _isArray["default"])(value) && !value[0];
+  return value === null || value === void 0 || typeof value !== "object" || value instanceof Date || isArray(value) && !value[0];
 }
-
-/**
- * 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.
- */
-var prepareFieldsFromMergedRow = exports.prepareFieldsFromMergedRow = function prepareFieldsFromMergedRow(mergedRow) {
-  var upperBound = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _constants.DYNAMIC_COLUMNS_CONFIG.maxColumns;
-  var terminals = [];
-  var columnCount = 0;
-  var pushTerminal = function pushTerminal(fieldPath, relatedTable, relatedField) {
+const prepareFieldsFromMergedRow = (mergedRow, upperBound = DYNAMIC_COLUMNS_CONFIG.maxColumns) => {
+  const terminals = [];
+  let columnCount = 0;
+  const pushTerminal = (fieldPath, relatedTable, relatedField) => {
     if (columnCount >= upperBound) return;
-    var displayName = displayNameForFieldPath(fieldPath);
+    const displayName = displayNameForFieldPath(fieldPath);
     terminals.push({
-      displayName: displayName,
+      displayName,
       field: fieldPath,
       binding: fieldPath,
-      relatedTable: relatedTable,
-      relatedField: relatedField !== null && relatedField !== void 0 ? relatedField : displayName
+      relatedTable,
+      relatedField: relatedField != null ? relatedField : displayName
     });
     columnCount += 1;
   };
-  var _pushFieldDef = function pushFieldDef(node, prefix, depth) {
+  const pushFieldDef = (node, prefix, depth) => {
     if (columnCount >= upperBound || depth > MAX_FIELD_DEPTH || node == null) return;
     if (!isPlainRecord(node)) return;
-    var visible = (0, _pickBy["default"])(node, function (_v, k) {
-      return !isInternalField(String(k));
-    });
-    (0, _forEach["default"])(visible, function (value, rawKey) {
+    const visible = pickBy(node, (_v, k) => !isInternalField(String(k)));
+    forEach(visible, (value, rawKey) => {
       if (columnCount >= upperBound) return;
-      var path = prefix ? "".concat(prefix, ".").concat(rawKey) : rawKey;
-      var rel = relatedFieldsFromKey(rawKey);
+      const path = prefix ? `${prefix}.${rawKey}` : rawKey;
+      const rel = relatedFieldsFromKey(rawKey);
       if (isLeafColumnValue(value)) {
         pushTerminal(path, rel.relatedTable, rel.relatedField);
         return;
       }
-      if ((0, _isArray["default"])(value)) {
-        var first = value[0];
+      if (isArray(value)) {
+        const first = value[0];
         if (isPlainRecord(first)) {
-          _pushFieldDef(first, "".concat(path, "[0]"), depth + 1);
+          pushFieldDef(first, `${path}[0]`, depth + 1);
         } else {
           pushTerminal(path, rel.relatedTable, rel.relatedField);
         }
         return;
       }
       if (isPlainRecord(value)) {
-        _pushFieldDef(value, path, depth + 1);
+        pushFieldDef(value, path, depth + 1);
       }
     });
   };
-  _pushFieldDef(mergedRow, "", 0);
+  pushFieldDef(mergedRow, "", 0);
   return terminals;
 };
 function sampleValueAtField(data, fieldPath) {
-  var limit = Math.min(10, data.length);
-  for (var i = 0; i < limit; i++) {
-    var row = data[i];
-    if (!row || (0, _typeof2["default"])(row) !== "object") continue;
-    var v = (0, _get["default"])(row, fieldPath);
-    if (v !== null && v !== undefined) return v;
+  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 undefined;
+  return void 0;
 }
-
-/**
- * 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).
- */
-var generateColumnsFromData = exports.generateColumnsFromData = function generateColumnsFromData(data) {
+const generateColumnsFromData = (data) => {
   if (!data || data.length === 0) {
     return [];
   }
-  var merged = mergeRowsForAllFields(data);
+  const merged = mergeRowsForAllFields(data);
   if (!merged) {
     return [];
   }
-  var terminals = prepareFieldsFromMergedRow(merged, _constants.DYNAMIC_COLUMNS_CONFIG.maxColumns);
+  const terminals = prepareFieldsFromMergedRow(merged, DYNAMIC_COLUMNS_CONFIG.maxColumns);
   if (terminals.length === 0) {
     return [];
   }
-  return terminals.map(function (t, index) {
-    var firstNonNullValue = sampleValueAtField(data, t.field);
-    var inferredType = inferColumnType(firstNonNullValue);
-    return (0, _columnBuilder.createDefaultColumnProps)(t.field, t.displayName, inferredType, index);
+  return terminals.map((t, index) => {
+    const firstNonNullValue = sampleValueAtField(data, t.field);
+    const inferredType = inferColumnType(firstNonNullValue);
+    return createDefaultColumnProps(t.field, t.displayName, inferredType, index);
   });
 };
-
-/**
- * Check if data is valid for column generation
- */
-var isValidDataForColumns = exports.isValidDataForColumns = function isValidDataForColumns(data) {
-  return Array.isArray(data) && data.length > 0 && data.some(function (row) {
-    return row && (0, _typeof2["default"])(row) === "object" && Object.keys(row).length > 0;
-  });
-};
+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
+};

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

@@ -1,22 +1,11 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.hasTableGroups = exports.generateHeaderRows = exports.calculateMaxDepth = exports.calculateColspan = void 0;
-/**
- * Calculate the colspan for a group based on visible child columns
- */
-var calculateColspan = exports.calculateColspan = function calculateColspan(group) {
-  var _countVisibleColumns = function countVisibleColumns(items) {
-    var count = 0;
-    items.forEach(function (item) {
+const calculateColspan = (group) => {
+  const countVisibleColumns = (items) => {
+    let count = 0;
+    items.forEach((item) => {
       if ("isGroup" in item && item.isGroup) {
-        // Recursively count columns in nested groups
-        count += _countVisibleColumns(item.columns);
+        count += countVisibleColumns(item.columns);
       } else {
-        // It's a column - check if it's visible
-        var column = item;
+        const column = item;
         if (column.show !== false) {
           count++;
         }
@@ -24,79 +13,65 @@ var calculateColspan = exports.calculateColspan = function calculateColspan(grou
     });
     return count;
   };
-  var colspan = _countVisibleColumns(group.columns);
-  return colspan || 1; // Return at least 1 to avoid invalid colspan
+  const colspan = countVisibleColumns(group.columns);
+  return colspan || 1;
 };
-
-/**
- * Calculate the maximum depth of the hierarchical structure
- */
-var _calculateMaxDepth = exports.calculateMaxDepth = function calculateMaxDepth(structure) {
-  var maxDepth = 1;
-  structure.forEach(function (item) {
+const calculateMaxDepth = (structure) => {
+  let maxDepth = 1;
+  structure.forEach((item) => {
     if ("isGroup" in item && item.isGroup) {
-      var groupDepth = 1 + _calculateMaxDepth(item.columns);
+      const groupDepth = 1 + calculateMaxDepth(item.columns);
       maxDepth = Math.max(maxDepth, groupDepth);
     }
   });
   return maxDepth;
 };
-
-/**
- * Generate header rows with proper colspan and rowspan values
- */
-var generateHeaderRows = exports.generateHeaderRows = function generateHeaderRows(structure, maxDepth) {
-  var headerRows = [];
-
-  // Initialize empty rows
-  for (var i = 0; i < maxDepth; i++) {
+const generateHeaderRows = (structure, maxDepth) => {
+  const headerRows = [];
+  for (let i = 0; i < maxDepth; i++) {
     headerRows.push([]);
   }
-  var _processStructure = function processStructure(items) {
-    var currentLevel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    items.forEach(function (item) {
+  const processStructure = (items, currentLevel = 0) => {
+    items.forEach((item) => {
       if ("isGroup" in item && item.isGroup) {
-        // It's a group - add to current level with colspan
-        var groupItem = item;
-        var colspan = calculateColspan(groupItem);
+        const groupItem = item;
+        const colspan = calculateColspan(groupItem);
         headerRows[currentLevel].push({
           isGroup: true,
           field: groupItem.field,
           displayName: groupItem.displayName || "",
-          colspan: colspan,
+          colspan,
           textAlignment: groupItem.textAlignment,
           backgroundColor: groupItem.backgroundColor,
-          "class": groupItem["class"],
+          class: groupItem.class,
           colClass: groupItem.colClass,
           styles: groupItem.styles
         });
-
-        // Process children at next level
-        _processStructure(groupItem.columns, currentLevel + 1);
+        processStructure(groupItem.columns, currentLevel + 1);
       } else {
-        // It's a column - add with rowspan to reach bottom
-        var column = item;
+        const column = item;
         if (column.show !== false) {
-          var rowspan = maxDepth - currentLevel;
+          const rowspan = maxDepth - currentLevel;
           headerRows[currentLevel].push({
             isGroup: false,
             field: column.field || column.binding || "",
             displayName: column.caption || column.displayName || "",
-            rowspan: rowspan,
-            column: column
+            rowspan,
+            column
           });
         }
       }
     });
   };
-  _processStructure(structure);
+  processStructure(structure);
   return headerRows;
 };
-/**
- * Check if the table has any groups
- */
-var hasTableGroups = exports.hasTableGroups = function hasTableGroups(structure) {
-  return structure.some(function (item) {
-    return "isGroup" in item && item.isGroup;
-  });
-};
+const hasTableGroups = (structure) => {
+  return structure.some((item) => "isGroup" in item && item.isGroup);
+};
+export {
+  calculateColspan,
+  calculateMaxDepth,
+  generateHeaderRows,
+  hasTableGroups
+};

package/components/data/table/utils/index.d.ts

@@ -3,6 +3,13 @@ import { WmTableColumnProps, WmTableRowActionProps, WmTableRowProps, WmTableActi
 declare const formWidgets: readonly ["WmText", "WmTextarea", "WmCheckbox", "WmSlider", "WmCurrency", "WmSwitch", "WmSelect", "WmCheckboxSet", "WmRadioSet", "WmDate", "WmTime", "WmTimestamp", "WmRating", "WmDatetime", "WmSearch", "WmChips", "WmColorPicker"];
 type FormWidgetType = (typeof formWidgets)[number];
 export type EditWidgetType = FormWidgetType;
+/**
+ * Angular behavior: when a dataset is a non-array object (e.g. a REST API response
+ * like { users: [...], total: 100 }), return the first array-valued property as the
+ * actual row data.  If the value is already an array it is returned as-is; if no
+ * array property is found (e.g. a params snapshot) an empty array is returned.
+ */
+export declare const extractDataArray: (dataset: any) => any[];
 /**
  * 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.
@@ -17,11 +24,7 @@ export declare const addUniqueRowIds: (dataset: any, options?: {
     type?: "table" | "list";
     idProperty?: string;
 }) => any[];
-export declare const getWidgetMappingForType: (widgetType: string) => string;
-export declare const getBooleanDataset: () => {
-    key: boolean;
-    value: string;
-}[];
+export { getWidgetMappingForType, getBooleanDataset } from "./widgetMapping";
 export declare const isColumnVisibleForViewport: (column: WmTableColumnProps, viewportWidth: number) => boolean;
 export interface TableGroup {
     isGroup: true;