@wavemaker/react-runtime 11.14.1-15.6409

package/components/input/chips/utils.js

@@ -0,0 +1,259 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createChipItem = createChipItem;
+exports.createChipItemWithStructure = createChipItemWithStructure;
+exports.generateStableKey = generateStableKey;
+exports.getChipDisplayValue = getChipDisplayValue;
+exports.getItemDisplayValue = getItemDisplayValue;
+exports.isDuplicate = isDuplicate;
+exports.performAddItem = performAddItem;
+exports.performRemoveItem = performRemoveItem;
+exports.processDataset = processDataset;
+exports.updateChipsListAndTriggerEvents = updateChipsListAndTriggerEvents;
+exports.updateMaxSize = updateMaxSize;
+exports.validateAddItem = validateAddItem;
+exports.validateBeforeOperation = validateBeforeOperation;
+exports.validateSearchInput = validateSearchInput;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _lodash = require("lodash");
+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; } // @ts-ignore
+function generateStableKey(item, index, datafield) {
+  if (typeof item === "string" || typeof item === "number" || item === null) {
+    return "chip_".concat(index, "_").concat(String(item));
+  }
+  if ((0, _lodash.isObject)(item)) {
+    var _item$dataObject;
+    if ((_item$dataObject = item.dataObject) !== null && _item$dataObject !== void 0 && _item$dataObject.key) {
+      var _item$dataObject2;
+      return "chip_".concat(index, "_").concat(String((_item$dataObject2 = item.dataObject) === null || _item$dataObject2 === void 0 ? void 0 : _item$dataObject2.key));
+    }
+    if (datafield !== "All Fields" && item[datafield] !== undefined) {
+      return "chip_".concat(index, "_").concat(String(item[datafield]));
+    }
+    return "chip_".concat(index, "_").concat(String(index));
+  }
+  return "chip_".concat(index, "_").concat(String(index));
+}
+function processDataset(data, displayfield, displayexpression, displayimagesrc, datafield, generateStableKeyFn) {
+  if (!data) return [];
+  var normalizedData = [];
+  if (typeof data === "string") {
+    normalizedData = data.split(",").map(function (item) {
+      return item.trim();
+    });
+  } else if (Array.isArray(data)) {
+    normalizedData = data;
+  } else {
+    normalizedData = [data];
+  }
+  return normalizedData.map(function (item, index) {
+    if ((0, _typeof2["default"])(item) === "object" && item !== null) {
+      var displayKey = displayfield || Object.keys(item)[0];
+      return {
+        key: generateStableKeyFn(item, index),
+        value: item,
+        label: item[displayKey] || "",
+        displayValue: displayexpression ? displayexpression(item) : item[displayKey] || "",
+        displayImage: displayimagesrc ? item[displayimagesrc] : null,
+        dataObject: item
+      };
+    } else {
+      return {
+        key: generateStableKeyFn(item, index),
+        value: item,
+        label: String(item),
+        displayValue: String(item),
+        displayImage: null,
+        dataObject: item
+      };
+    }
+  });
+}
+function getChipDisplayValue(chip, datafield) {
+  if (datafield === "All Fields") {
+    return chip.label || chip.displayValue;
+  }
+  return chip.value;
+}
+function getItemDisplayValue(item, datafield) {
+  if (typeof item === "string") {
+    return item;
+  }
+  if (datafield === "All Fields") {
+    return item.label || item.displayValue;
+  }
+  return item.value;
+}
+function isDuplicate(chipsList, item, datafield) {
+  var itemDisplayValue = getItemDisplayValue(item, datafield);
+  return chipsList.some(function (chip) {
+    var chipDisplayValue = getChipDisplayValue(chip, datafield);
+    if (datafield === "All Fields") {
+      return (0, _lodash.toString)(chipDisplayValue).toLowerCase() === (0, _lodash.toString)(itemDisplayValue).toLowerCase();
+    } else {
+      if (typeof item === "string") {
+        return (0, _lodash.toString)(chipDisplayValue) === (0, _lodash.toString)(itemDisplayValue);
+      } else {
+        var item_dataObject = itemDisplayValue.dataObject ? itemDisplayValue.dataObject : itemDisplayValue;
+        return (0, _lodash.isEqual)(chipDisplayValue, item_dataObject);
+      }
+    }
+  });
+}
+function updateMaxSize(maxsize, chipsList, setSaturate) {
+  setSaturate(maxsize > 0 && chipsList.length === maxsize);
+}
+
+// Common functionality for updating chips list and triggering events
+function updateChipsListAndTriggerEvents(newChipsList, newModelByValue, setChipsList, setModelByValue, updateMaxSizeFn, listener, name, event, onChange, onAdd, onRemove, chipItem, oldModelByValue, props) {
+  // Update state
+  setChipsList(newChipsList);
+  setModelByValue(newModelByValue);
+  updateMaxSizeFn(newChipsList.length);
+
+  // Trigger onChange event
+  if (onChange && listener !== null && listener !== void 0 && listener.Widgets && name && name in listener.Widgets) {
+    onChange(event, listener.Widgets[name], newModelByValue, oldModelByValue);
+  }
+
+  // Trigger listener.onChange if available
+  if (listener !== null && listener !== void 0 && listener.onChange) {
+    listener.onChange(name, _objectSpread(_objectSpread({}, props), {}, {
+      datavalue: newModelByValue
+    }));
+  }
+
+  // Trigger specific events (onAdd, onRemove)
+  if (onAdd && chipItem && listener !== null && listener !== void 0 && listener.Widgets && name && name in listener.Widgets) {
+    onAdd(event, listener.Widgets[name], chipItem);
+  }
+  if (onRemove && chipItem && listener !== null && listener !== void 0 && listener.Widgets && name && name in listener.Widgets) {
+    onRemove(event, listener.Widgets[name], chipItem);
+  }
+}
+
+// Common functionality for validation before operations
+function validateBeforeOperation(listener, name, beforeHandler, event, item) {
+  if (beforeHandler && listener !== null && listener !== void 0 && listener.Widgets && name && name in listener.Widgets) {
+    var allowOperation = beforeHandler(event, listener.Widgets[name], item);
+    if (allowOperation === false) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Common functionality for creating chip items
+function createChipItem(itemToAdd, generateUniqueKey, datafield, displayfield, createCustomDataModel) {
+  if (typeof itemToAdd === "string") {
+    if (datafield === "All Fields") {
+      var dataObj = createCustomDataModel(itemToAdd);
+      if (!dataObj) throw new Error("Failed to create custom data model");
+      var newItem = {
+        key: generateUniqueKey(),
+        value: dataObj,
+        label: itemToAdd,
+        displayValue: itemToAdd,
+        displayImage: null,
+        dataObject: dataObj
+      };
+      newItem.iscustom = true;
+      return newItem;
+    } else {
+      var _newItem = {
+        key: generateUniqueKey(),
+        value: itemToAdd,
+        label: itemToAdd,
+        displayValue: itemToAdd,
+        displayImage: null,
+        dataObject: itemToAdd
+      };
+      _newItem.iscustom = true;
+      return _newItem;
+    }
+  } else {
+    return itemToAdd;
+  }
+}
+
+// Common functionality for creating chip items with proper structure
+function createChipItemWithStructure(itemToAdd) {
+  return _objectSpread(_objectSpread({}, itemToAdd), {}, {
+    active: false,
+    isDuplicate: false,
+    imgSrc: itemToAdd.displayImage,
+    iscustom: itemToAdd.iscustom || false
+  });
+}
+
+// Common functionality for validation before adding items
+function validateAddItem(newItem, chipsList, maxsize, datafield) {
+  if (maxsize && chipsList.length >= maxsize) {
+    return false;
+  }
+  if (isDuplicate(chipsList, newItem, datafield)) {
+    return false;
+  }
+  return true;
+}
+
+// Common functionality for search validation
+function validateSearchInput(query, allowonlyselect, maxsize, chipsList) {
+  var trimmedQuery = query.trim();
+  if (!trimmedQuery) return false;
+  if (allowonlyselect) return false;
+  if (maxsize && chipsList.length >= maxsize) return false;
+  return true;
+}
+
+// Common functionality for add item operation
+function performAddItem(newItem, chipsList, modelByValue, setChipsList, setModelByValue, setSearchQuery, updateMaxSizeFn, listener, name, datafield, displayfield, createCustomDataModel, generateUniqueKey, maxsize, onBeforeadd, onChange, onAdd, props) {
+  // Validate before adding
+  if (!validateAddItem(newItem, chipsList, maxsize, datafield)) {
+    setSearchQuery("");
+    return false;
+  }
+
+  // Create item to add
+  var itemToAdd = createChipItem(newItem, generateUniqueKey, datafield, displayfield, createCustomDataModel);
+
+  // Validate before operation
+  if (!validateBeforeOperation(listener, name, onBeforeadd, new MouseEvent("click"), itemToAdd)) {
+    return false;
+  }
+
+  // Create chip item with proper structure
+  var chipItem = createChipItemWithStructure(itemToAdd);
+  var newChipsList = [].concat((0, _toConsumableArray2["default"])(chipsList), [chipItem]);
+  var newModelByValue = [].concat((0, _toConsumableArray2["default"])(modelByValue), [itemToAdd.value]);
+
+  // Update chips list and trigger events
+  updateChipsListAndTriggerEvents(newChipsList, newModelByValue, setChipsList, setModelByValue, updateMaxSizeFn, listener, name, new MouseEvent("change"), onChange, onAdd, undefined, chipItem, modelByValue, props);
+  setSearchQuery("");
+  return true;
+}
+
+// Common functionality for remove item operation
+function performRemoveItem(event, item, index, chipsList, modelByValue, setChipsList, setModelByValue, updateMaxSizeFn, listener, name, onBeforeremove, onChange, onRemove, props) {
+  event.stopPropagation();
+
+  // Validate before operation
+  if (!validateBeforeOperation(listener, name, onBeforeremove, event, item)) {
+    return false;
+  }
+  var newChipsList = (0, _toConsumableArray2["default"])(chipsList);
+  var newModelByValue = (0, _toConsumableArray2["default"])(modelByValue);
+  newChipsList.splice(index, 1);
+  newModelByValue.splice(index, 1);
+
+  // Update chips list and trigger events
+  updateChipsListAndTriggerEvents(newChipsList, newModelByValue, setChipsList, setModelByValue, updateMaxSizeFn, listener, name, event, onChange, undefined, onRemove, item, modelByValue, props);
+  return true;
+}