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

package/utils/transformedDataset-utils.js

@@ -0,0 +1,645 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformFormData = exports.transformDataset = exports.transformDataWithKeys = exports.toggleAllHeaders = exports.setItemByCompare = exports.handleHeaderClick = exports.groupData = exports.getUniqObjsByDataField = exports.getOrderedDataset = exports.extractDataAsArray = exports.datasetItems = exports.convertDataToObject = exports.configureDnD = exports.DataSetItem = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _widgets = require("@wavemaker-ai/react-runtime/utils/widgets");
+var _lodashEs = require("lodash-es");
+var momentLib = _interopRequireWildcard(require("moment"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof3(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+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; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var ALLFIELDS = "All Fields";
+var moment = momentLib["default"] || window["moment"];
+var isDefined = function isDefined(val) {
+  return val !== undefined && val !== null;
+};
+var getFormattedDate = function getFormattedDate(date, format) {
+  return moment(date).format(format);
+};
+var isEqualWithFields = function isEqualWithFields(objA, objB, fieldsStr) {
+  if (!fieldsStr || !(0, _lodashEs.isString)(fieldsStr)) {
+    return (0, _lodashEs.isEqual)(objA, objB); // Fallback to deep comparison if no fields specified
+  }
+  var fields = fieldsStr.split(",").map(function (f) {
+    return f.trim();
+  });
+  if (!objA || !objB) {
+    return objA === objB; // Handle null/undefined cases
+  }
+  var _iterator = _createForOfIteratorHelper(fields),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var field = _step.value;
+      if (!(0, _lodashEs.isEqual)((0, _lodashEs.get)(objA, field), (0, _lodashEs.get)(objB, field))) {
+        return false;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return true;
+};
+var GROUP_BY_OPTIONS = {
+  ALPHABET: "alphabet",
+  WORD: "word",
+  OTHERS: "Others"
+};
+var TIME_ROLLUP_OPTIONS = {
+  HOUR: "hour",
+  DAY: "day",
+  WEEK: "week",
+  MONTH: "month",
+  YEAR: "year"
+};
+
+// Adjusted for moment.js (YYYY for year, DD for day)
+var ROLLUP_PATTERNS = {
+  DAY: "YYYY-MM-DD",
+  WEEK: "wo [Week], YYYY",
+  // Example: 42nd Week, 2023 (moment's week format)
+  MONTH: "MMM, YYYY",
+  YEAR: "YYYY",
+  HOUR: "hh:mm A"
+};
+var DataSetItem = exports.DataSetItem = /*#__PURE__*/(0, _createClass2["default"])(function DataSetItem() {
+  (0, _classCallCheck2["default"])(this, DataSetItem);
+  (0, _defineProperty2["default"])(this, "key", void 0);
+  (0, _defineProperty2["default"])(this, "label", void 0);
+  (0, _defineProperty2["default"])(this, "value", void 0);
+  (0, _defineProperty2["default"])(this, "dataObject", void 0);
+  (0, _defineProperty2["default"])(this, "index", void 0);
+  (0, _defineProperty2["default"])(this, "imgSrc", void 0);
+  (0, _defineProperty2["default"])(this, "selected", void 0);
+  (0, _defineProperty2["default"])(this, "children", void 0);
+  (0, _defineProperty2["default"])(this, "match", void 0);
+  (0, _defineProperty2["default"])(this, "dateformat", void 0);
+});
+var _internalTransformDataset = function _internalTransformDataset(dataset, datafield, displayfield, displaylabel, displayexpression, orderby, groupby, dataPath, itemchildren, match) {
+  return _datasetItems(dataset, datafield, displayfield, displaylabel, displayexpression, orderby, groupby, dataPath, itemchildren, match);
+};
+
+// Custom resolver for memoize to handle multiple arguments correctly
+var resolver = function resolver() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return args.map(function (arg) {
+    if (typeof arg === "function") {
+      return arg.toString();
+    }
+    return JSON.stringify(arg);
+  }).join("|");
+};
+var transformDataset = exports.transformDataset = (0, _lodashEs.memoize)(_internalTransformDataset, resolver);
+
+/**
+ * function to get the ordered dataset based on the given orderby
+ */
+var getOrderedDataset = exports.getOrderedDataset = function getOrderedDataset(dataSet, orderBy, innerItem) {
+  if (!orderBy) {
+    return (0, _lodashEs.cloneDeep)(dataSet);
+  }
+  var items = orderBy.split(",");
+  var fields = [];
+  var directions = [];
+  items.forEach(function (obj) {
+    var item = obj.split(":");
+    fields.push(innerItem ? "".concat(innerItem, ".").concat(item[0]) : item[0]);
+    directions.push(item[1]);
+  });
+  return (0, _lodashEs.orderBy)(dataSet, fields, directions);
+};
+
+/**
+ * Returns an array of object, each object contain the DataSetItem whose key, value, label are extracted from object keys.
+ */
+var transformDataWithKeys = exports.transformDataWithKeys = function transformDataWithKeys(dataSet) {
+  var data = [];
+  if ((0, _lodashEs.isObject)(dataSet[0]) || (0, _lodashEs.isObject)(dataSet) && !(0, _lodashEs.isArray)(dataSet)) {
+    var objectKeys = Object.keys(dataSet[0] || dataSet);
+    (0, _lodashEs.forEach)(objectKeys, function (objKey, index) {
+      data.push({
+        key: objKey,
+        label: objKey,
+        value: objKey,
+        index: (index || 0) + 1 // Ensure index is number
+      });
+    });
+  }
+  return data;
+};
+var extractDataAsArray = exports.extractDataAsArray = function extractDataAsArray(data) {
+  if ((0, _lodashEs.isUndefined)(data) || (0, _lodashEs.isNull)(data) || (0, _lodashEs.isString)(data) && (0, _lodashEs.trim)(data) === "") {
+    return [];
+  }
+  if ((0, _lodashEs.isString)(data)) {
+    data = (0, _lodashEs.split)(data, ",").map(function (str) {
+      return (0, _lodashEs.trim)(str);
+    });
+  }
+  if (!(0, _lodashEs.isArray)(data)) {
+    data = [data];
+  }
+  return data;
+};
+var convertDataToObject = exports.convertDataToObject = function convertDataToObject(dataResult) {
+  if ((0, _lodashEs.isString)(dataResult)) {
+    dataResult = (0, _lodashEs.split)(dataResult, ",").map(function (str) {
+      return (0, _lodashEs.trim)(str);
+    });
+  }
+  return dataResult;
+};
+var isSearchWidget = function isSearchWidget(widgetType) {
+  return widgetType === "wm-search"; // Assuming 'wm-search' is a string identifier
+};
+
+// This function originally used $parseEvent from @wm/core for dynamic expression evaluation.
+// In React, it's highly recommended to pass functions directly as props instead of string expressions.
+// This adapted version provides a placeholder for simple property access and logs a warning for complex cases.
+var setGroupbyKey = function setGroupbyKey(scope, context, dataSetItem, innerItem) {
+  if (scope && isSearchWidget(scope.widgetType)) {
+    if (scope.groupby) {
+      if ((0, _lodashEs.includes)(scope.groupby, "(") || (0, _lodashEs.includes)(scope.groupby, "[")) {
+        // Complex expression detected. Direct evaluation of arbitrary strings is unsafe and not React-idiomatic.
+        // Consider refactoring to pass a pre-compiled function for groupby logic.
+        console.warn("Complex groupby expression \"".concat(scope.groupby, "\" detected for search widget. ") + "This may not work as expected. Refactor to use a function prop.");
+        // Attempting simple property access as a fallback if context and item are available
+        if (dataSetItem.dataObject && context) {
+          try {
+            // This is a very basic attempt and might not cover all original $parseEvent cases.
+            // For example, if scope.groupby was 'item.name.toUpperCase()', this won't work.
+            var value = (0, _lodashEs.get)(dataSetItem.dataObject, scope.groupby);
+            dataSetItem.key = value;
+          } catch (e) {
+            console.error("Failed to evaluate groupby expression (simple access):", scope.groupby, e);
+            dataSetItem.key = GROUP_BY_OPTIONS.OTHERS;
+          }
+        } else {
+          dataSetItem.key = GROUP_BY_OPTIONS.OTHERS; // Fallback
+        }
+      } else {
+        // Simple field name, try to get it from dataObject
+        dataSetItem.key = (0, _lodashEs.get)(dataSetItem.dataObject, scope.groupby);
+      }
+    } else {
+      // if groupby is not defined, set the key as datafield value
+      dataSetItem.key = dataSetItem.value;
+    }
+  } else if (dataSetItem.dataObject && scope && scope.groupby) {
+    // For non-search widgets, if groupby is present
+    dataSetItem.key = (0, _lodashEs.get)(dataSetItem.dataObject, scope.groupby);
+  }
+};
+function resolveDataPath(dataSet, dataPath) {
+  if (!Array.isArray(dataSet)) {
+    dataSet = [dataSet];
+  }
+  if (!dataPath) return dataSet;
+
+  // Remove leading dot if present and filter out empty segments
+  var cleanPath = dataPath.startsWith(".") ? dataPath.substring(1) : dataPath;
+  var pathSegments = cleanPath.split(".").filter(function (segment) {
+    return segment.length > 0;
+  });
+  if (pathSegments.length === 0) return dataSet;
+  var _flatten = function flatten(data, path) {
+    if (path.length === 0) return data;
+    var nextKey = path[0];
+    var remainingPath = path.slice(1);
+    var result = [];
+    var _iterator2 = _createForOfIteratorHelper(data),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var item = _step2.value;
+        if (!item || (0, _typeof2["default"])(item) !== "object") continue;
+        var value = item[nextKey];
+        if (Array.isArray(value)) {
+          var next = _flatten(value, remainingPath);
+          result = result.concat(next);
+        } else if (((0, _typeof2["default"])(value) === "object" || typeof value === "string") && value !== null) {
+          var _next = _flatten([value], remainingPath);
+          result = result.concat(_next);
+        }
+        // else: primitive types or undefined → skip
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    return result;
+  };
+  return _flatten(dataSet, pathSegments);
+}
+var transformFormData = exports.transformFormData = function transformFormData(context, dataSet, myDataField, displayOptions, startIndex, scope, dataPath) {
+  if (dataPath) {
+    dataSet = resolveDataPath(dataSet, dataPath || "");
+  }
+  var data = [];
+  if ((0, _lodashEs.isString)(dataSet)) {
+    dataSet = dataSet.split(",").map(function (str) {
+      return str.trim();
+    });
+    dataSet.forEach(function (option, index) {
+      var dataSetItem = {
+        key: option,
+        value: option,
+        label: isDefined(option) && option !== null ? option.toString() : "",
+        index: (startIndex || 0) + index
+      };
+      setGroupbyKey(scope, context, dataSetItem, "value");
+      data.push(dataSetItem);
+    });
+  } else if ((0, _lodashEs.isArray)(dataSet) && !(0, _lodashEs.isObject)(dataSet[0])) {
+    // array of primitive values only
+    dataSet.forEach(function (option, index) {
+      var dataSetItem = {
+        key: option,
+        value: option,
+        label: isDefined(option) && option !== null ? String(option) : "",
+        index: (startIndex || 0) + index
+      };
+      setGroupbyKey(scope, context, dataSetItem, "value");
+      data.push(dataSetItem);
+    });
+  } else if (!(dataSet instanceof Array) && (0, _lodashEs.isObject)(dataSet)) {
+    var i = 0;
+    (0, _lodashEs.forEach)(dataSet, function (value, key) {
+      // @ts-ignore
+      var dataSetItem = {
+        key: (0, _lodashEs.trim)(key),
+        value: key,
+        label: isDefined(value) && value !== null ? String(value) : "",
+        index: startIndex,
+        dataObject: dataSet
+      };
+      setGroupbyKey(scope, context, dataSetItem, "value");
+      data.push(dataSetItem);
+    });
+  } else {
+    if (!myDataField) {
+      // consider the datafield as 'ALLFIELDS' when datafield is not given.
+      myDataField = ALLFIELDS;
+    }
+    dataSet.forEach(function (option, index) {
+      var key = myDataField === ALLFIELDS ? (startIndex !== null && startIndex !== void 0 ? startIndex : 0) + index : (0, _widgets.getObjValueByKey)(option, myDataField);
+      // Omit all the items whose datafield (key) is null or undefined.
+      if (!(0, _lodashEs.isUndefined)(key) && !(0, _lodashEs.isNull)(key)) {
+        var label = (0, _widgets.getEvaluatedData)(option, {
+          field: displayOptions.displayField,
+          expression: displayOptions.displayExpr,
+          bindExpression: displayOptions.bindDisplayExpr
+        }, option);
+        // If label is empty and there's no displayexpression/displayfield, use datafield value (key) as label
+        var hasDisplayExpr = displayOptions === null || displayOptions === void 0 ? void 0 : displayOptions.displayExpr;
+        var hasDisplayField = displayOptions === null || displayOptions === void 0 ? void 0 : displayOptions.displayField; // Check if displayfield was originally provided
+        var finalLabel = isDefined(label) && label !== null ? label.toString() : !hasDisplayExpr && !hasDisplayField && key !== undefined && key !== null ? String(key) : "";
+        var dataSetItem = {
+          key: key,
+          label: finalLabel,
+          value: myDataField === ALLFIELDS ? option : key,
+          dataObject: option,
+          // represents the object when datafield is ALLFIELDS. This is used as innerItem while grouping the datasetItems.
+          index: (startIndex !== null && startIndex !== void 0 ? startIndex : 0) + index
+        };
+        if (displayOptions.displayImgSrc || displayOptions.bindDisplayImgSrc) {
+          dataSetItem.imgSrc = (0, _widgets.getEvaluatedData)(option, {
+            expression: displayOptions.displayImgSrc,
+            bindExpression: displayOptions.bindDisplayImgSrc
+          }, context);
+        }
+        setGroupbyKey(scope, context, dataSetItem, "dataObject");
+        data.push(dataSetItem);
+      }
+    });
+  }
+  return data;
+};
+var getUniqObjsByDataField = exports.getUniqObjsByDataField = function getUniqObjsByDataField(data, dataField, displayField, allowEmptyFields) {
+  var uniqData;
+  var isAllFields = dataField === ALLFIELDS;
+  uniqData = isAllFields ? (0, _lodashEs.uniqWith)(data, _lodashEs.isEqual) : (0, _lodashEs.uniqBy)(data, "key");
+  if (!displayField || allowEmptyFields) {
+    return uniqData;
+  }
+
+  // return objects having non empty datafield and display field values.
+  return (0, _lodashEs.filter)(uniqData, function (obj) {
+    if (isAllFields) {
+      return (0, _lodashEs.trim)(obj.label);
+    }
+    return (0, _lodashEs.trim)(obj.key) && (0, _lodashEs.trim)(obj.label);
+  });
+};
+var setItemByCompare = exports.setItemByCompare = function setItemByCompare(datasetItems, compareWithDataObj, compareByField) {
+  return datasetItems.find(function (item) {
+    if (item.dataObject) {
+      return isEqualWithFields(compareWithDataObj, item.dataObject, compareByField);
+    }
+    return false;
+  });
+};
+var getSortedGroupedData = function getSortedGroupedData(groupedLiData, groupBy, orderby) {
+  var data = (0, _lodashEs.values)(groupedLiData).map(function (val) {
+    if (orderby) {
+      val.data = getOrderedDataset(val.data, orderby, "dataObject");
+    }
+    return val;
+  });
+  return (0, _lodashEs.sortBy)(data, "data[0].dataObject.".concat(groupBy));
+};
+var _datasetItems = exports.datasetItems = function datasetItems(dataset, datafield, displayfield, displaylabel, displayexpression, orderby, groupby, dataPath, itemchildren, match) {
+  if (!dataset) return [];
+  var items = transformFormData(null, dataset, datafield, {
+    displayField: displayfield || displaylabel,
+    displayExpr: displayexpression
+  }, 0, null, dataPath);
+  items = getUniqObjsByDataField(items, datafield, displayfield || displaylabel, false);
+  if (orderby) {
+    var orderFields = orderby.split(",");
+    items.sort(function (a, b) {
+      var _iterator3 = _createForOfIteratorHelper(orderFields),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _a$dataObject, _b$dataObject;
+          var orderField = _step3.value;
+          var _orderField$split = orderField.split(":"),
+            _orderField$split2 = (0, _slicedToArray2["default"])(_orderField$split, 2),
+            field = _orderField$split2[0],
+            order = _orderField$split2[1];
+          var aVal = String(((_a$dataObject = a.dataObject) === null || _a$dataObject === void 0 ? void 0 : _a$dataObject[field]) || a.label || "");
+          var bVal = String(((_b$dataObject = b.dataObject) === null || _b$dataObject === void 0 ? void 0 : _b$dataObject[field]) || b.label || "");
+          var comparison = order === "desc" ? bVal.localeCompare(aVal, "en", {
+            numeric: true
+          }) : aVal.localeCompare(bVal, "en", {
+            numeric: true
+          });
+          if (comparison !== 0) return comparison;
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return 0;
+    });
+  }
+  var _iterator4 = _createForOfIteratorHelper(items),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var item = _step4.value;
+      var children = void 0;
+      if (typeof itemchildren === "function") {
+        var _itemchildren;
+        children = (_itemchildren = itemchildren(item === null || item === void 0 ? void 0 : item.dataObject)) !== null && _itemchildren !== void 0 ? _itemchildren : itemchildren(item);
+        if (Array.isArray(children)) {
+          var sortedChildren = _datasetItems(children, datafield, displayfield, displaylabel, displayexpression, orderby, groupby, dataPath, itemchildren, match);
+          if (itemchildren(item === null || item === void 0 ? void 0 : item.dataObject)) {
+            if (item.dataObject) item.dataObject.children = sortedChildren;
+          } else if (itemchildren(item)) {
+            item.children = sortedChildren;
+          }
+        }
+      } else {
+        var _item$dataObject$item, _item$dataObject;
+        children = (_item$dataObject$item = item === null || item === void 0 || (_item$dataObject = item.dataObject) === null || _item$dataObject === void 0 ? void 0 : _item$dataObject[itemchildren]) !== null && _item$dataObject$item !== void 0 ? _item$dataObject$item : item === null || item === void 0 ? void 0 : item[itemchildren];
+        if (Array.isArray(children)) {
+          var _item$dataObject2;
+          var _sortedChildren = _datasetItems(children, datafield, displayfield, displaylabel, displayexpression, orderby, groupby, dataPath, itemchildren, match);
+          if (item !== null && item !== void 0 && (_item$dataObject2 = item.dataObject) !== null && _item$dataObject2 !== void 0 && _item$dataObject2[itemchildren]) {
+            item.dataObject.children = _sortedChildren;
+          } else if (item !== null && item !== void 0 && item[itemchildren]) {
+            item.children = _sortedChildren;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  if (groupby) {
+    items = groupData(null, items, groupby, match || "word", "", "");
+  }
+  return items;
+};
+var groupData = exports.groupData = function groupData(compRef, data, groupby, match, orderby, dateformat) {
+  var innerItem = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : "dataObject";
+  var AppDefaults = arguments.length > 7 ? arguments[7] : undefined;
+  if (!groupby || !data || !data.length) {
+    return [];
+  }
+  var groupedData = getGroupedData(data, groupby, match, orderby, dateformat, innerItem, AppDefaults);
+  return getSortedGroupedData(groupedData, groupby, orderby);
+};
+var getGroupedData = function getGroupedData(fieldDefs, groupby, match, orderby, dateFormat, innerItem, AppDefaults) {
+  var mappedData = fieldDefs.map(function (item) {
+    var groupByKey = groupDataByField(groupby, match, innerItem, dateFormat, /*datePipe,*/AppDefaults, item);
+    return {
+      groupByKey: groupByKey,
+      data: item
+    };
+  });
+  var groupedData = (0, _lodashEs.groupBy)(mappedData, "groupByKey");
+
+  // Format for final structure {key: groupName, data: [items]}
+  var result = {};
+  (0, _lodashEs.forEach)(groupedData, function (value, key) {
+    result[key] = {
+      key: key,
+      data: value.map(function (v) {
+        return v.data;
+      })
+    };
+  });
+  return result;
+};
+var filterDateReact = function filterDateReact(value, format, defaultFormat) {
+  if (!isDefined(value) || value === "") {
+    return "";
+  }
+  var mDate = moment(value);
+  if (mDate.isValid()) {
+    return mDate.format(format || defaultFormat);
+  }
+  return String(value); // Return original if not a valid date
+};
+var getTimeRolledUpString = function getTimeRolledUpString(concatStr, rollUp, dateformat, AppDefaults) {
+  if (!isDefined(concatStr) || concatStr === "") {
+    return GROUP_BY_OPTIONS.OTHERS;
+  }
+  var mDate = moment(concatStr);
+  if (!mDate.isValid()) {
+    return GROUP_BY_OPTIONS.OTHERS;
+  }
+  var appDateFormat = AppDefaults && AppDefaults.dateFormat ? AppDefaults.dateFormat : "yyyy-MM-dd";
+  var calendarDayFormats = {
+    lastDay: "[Yesterday]",
+    lastWeek: "[Last] dddd",
+    nextDay: "[Tomorrow]",
+    nextWeek: "dddd",
+    sameDay: "[Today]",
+    sameElse: appDateFormat.replace(/y/g, "Y").replace(/d/g, "D") // Adjust to moment format tokens
+  };
+  if (rollUp === TIME_ROLLUP_OPTIONS.DAY) {
+    return mDate.calendar(null, calendarDayFormats);
+  }
+  if (rollUp === TIME_ROLLUP_OPTIONS.WEEK) {
+    // Example: 'Week 1, 2023' or use specific format from ROLLUP_PATTERNS
+    return mDate.format(ROLLUP_PATTERNS.WEEK || "wo [Week], YYYY");
+  }
+  if (rollUp === TIME_ROLLUP_OPTIONS.MONTH) {
+    return mDate.format(ROLLUP_PATTERNS.MONTH || "MMM, YYYY");
+  }
+  if (rollUp === TIME_ROLLUP_OPTIONS.YEAR) {
+    return mDate.format(ROLLUP_PATTERNS.YEAR || "YYYY");
+  }
+  if (rollUp === TIME_ROLLUP_OPTIONS.HOUR) {
+    // Check if it's today to show 'Today, 09:00 AM', else 'YYYY-MM-DD, 09:00 AM'
+    var baseFormat = ROLLUP_PATTERNS.HOUR || "hh:mm A";
+    if (mDate.isSame(moment(), "day")) {
+      return "[Today], ".concat(mDate.format(baseFormat));
+    }
+    return mDate.format("".concat(ROLLUP_PATTERNS.DAY, ", ").concat(baseFormat));
+  }
+
+  // Default if no rollup matched, or for custom date formats if applicable
+  if (dateformat) {
+    return filterDateReact(mDate.toDate(), dateformat, appDateFormat);
+  }
+  return mDate.format(appDateFormat.replace(/y/g, "Y").replace(/d/g, "D"));
+};
+var groupDataByField = function groupDataByField(groupby, match, innerItem, dateFormat, AppDefaults, liData) {
+  var concatStr = (0, _lodashEs.get)(innerItem ? liData[innerItem] : liData, groupby);
+  if ((0, _lodashEs.isUndefined)(concatStr) || (0, _lodashEs.isNull)(concatStr) || (0, _lodashEs.isString)(concatStr) && concatStr.toString().trim() === "") {
+    return GROUP_BY_OPTIONS.OTHERS;
+  }
+  if (match === GROUP_BY_OPTIONS.ALPHABET) {
+    return String(concatStr).substr(0, 1).toUpperCase();
+  }
+  if (match === GROUP_BY_OPTIONS.WORD) {
+    return String(concatStr);
+  }
+  if ((0, _lodashEs.includes)((0, _lodashEs.values)(TIME_ROLLUP_OPTIONS), match)) {
+    return getTimeRolledUpString(String(concatStr), match, dateFormat, AppDefaults);
+  }
+  return String(concatStr);
+};
+
+/**
+ * Utility functions for list group operations
+ */
+
+/**
+ * Toggle all list items in all groups
+ * @param containerRef - Reference to the container element
+ * @returns void
+ */
+var toggleAllHeaders = exports.toggleAllHeaders = function toggleAllHeaders(containerRef) {
+  var groups = containerRef.querySelectorAll(".item-group");
+  groups.forEach(function (group) {
+    var listItems = group.querySelectorAll(".group-list-item");
+    var icon = group.querySelector("li.list-group-header .app-icon");
+    listItems.forEach(function (item) {
+      // Toggle visibility
+      var currentDisplay = window.getComputedStyle(item).display;
+      item.style.display = currentDisplay === "none" ? "block" : "none";
+    });
+    if (icon) {
+      if (icon.classList.contains("wi-chevron-down")) {
+        icon.classList.remove("wi-chevron-down");
+        icon.classList.add("wi-chevron-up");
+      } else {
+        icon.classList.remove("wi-chevron-up");
+        icon.classList.add("wi-chevron-down");
+      }
+    }
+  });
+};
+
+/**
+ * Handle click on a group header
+ * @param event - Click event
+ * @returns void
+ */
+var handleHeaderClick = exports.handleHeaderClick = function handleHeaderClick(event) {
+  var target = event.target;
+  var selectedGroup = target.closest(".item-group");
+  if (!selectedGroup) return;
+  var selectedAppIcon = selectedGroup.querySelector("li.list-group-header .app-icon");
+  var listItems = selectedGroup.querySelectorAll(".group-list-item");
+  if (selectedAppIcon) {
+    if (selectedAppIcon.classList.contains("wi-chevron-down")) {
+      selectedAppIcon.classList.remove("wi-chevron-down");
+      selectedAppIcon.classList.add("wi-chevron-up");
+    } else {
+      selectedAppIcon.classList.remove("wi-chevron-up");
+      selectedAppIcon.classList.add("wi-chevron-down");
+    }
+  }
+  listItems.forEach(function (item) {
+    var currentDisplay = window.getComputedStyle(item).display;
+    item.style.display = currentDisplay === "none" ? "block" : "none";
+  });
+};
+/**
+ * Configure drag and drop functionality
+ * Note: This is a basic implementation. For production use, consider using modern libraries like react-beautiful-dnd
+ * @param element - Element to make sortable
+ * @param options - Sortable options
+ * @param onDragStart - Callback when drag starts
+ * @param onUpdate - Callback when sorting ends and DOM position changes
+ * @param onSort - Optional callback during sorting
+ */
+var configureDnD = exports.configureDnD = function configureDnD(element) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var onDragStart = arguments.length > 2 ? arguments[2] : undefined;
+  var onUpdate = arguments.length > 3 ? arguments[3] : undefined;
+  var onSort = arguments.length > 4 ? arguments[4] : undefined;
+  var defaultOptions = {
+    containment: element,
+    delay: 100,
+    opacity: 0.8,
+    helper: "clone",
+    zIndex: 1050,
+    tolerance: "pointer"
+  };
+  var finalOptions = _objectSpread(_objectSpread({}, defaultOptions), options);
+
+  // Add drag and drop event listeners
+  element.addEventListener("dragstart", onDragStart);
+  element.addEventListener("dragend", onUpdate);
+  if (onSort) {
+    element.addEventListener("drag", onSort);
+  }
+
+  // Make children draggable
+  var draggableItems = element.children;
+  Array.from(draggableItems).forEach(function (item) {
+    item.draggable = true;
+    item.style.userSelect = "none";
+    if (finalOptions.opacity) {
+      item.style.opacity = "1";
+    }
+  });
+};

package/utils/widget-cleanup-util.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Removes widgets from page context, cleans up registry, and returns the new context.
+ * Returns prev unchanged if no widgets were present.
+ *
+ * @param prev - Current page context
+ * @param names - Widget names to remove
+ * @returns New context with widgets removed, or prev if no changes
+ */
+export declare function removeWidgetsFromContext(context: any, proxy: any, names: string[]): any;
+/**
+ * Configuration for the widget cleanup utility
+ */
+export interface WidgetCleanupConfig {
+    /** Function to update the page context state */
+    setPageContext: (updater: (prev: any) => any) => void;
+    /** Reference to the proxy object (optional) */
+    proxyRef?: React.MutableRefObject<any>;
+    /** Debounce delay in milliseconds (default: 100) */
+    debounceDelay?: number;
+}
+/**
+ * Creates a debounced widget cleanup utility function
+ * This eliminates code duplication between WidgetProvider and BasePage
+ *
+ * @param config - Configuration object for the cleanup utility
+ * @returns Object containing cleanup function and cleanupRef
+ */
+export declare const createWidgetCleanup: (config: WidgetCleanupConfig) => {
+    cleanup: (name: string) => void;
+    cleanupRef: Set<string>;
+    cancel: () => void;
+};