@wavemaker/react-runtime 11.14.1-16.6404

package/store/slices/i18nSlice.js

@@ -0,0 +1,206 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setTimezone = exports.setTimeFormat = exports.setSelectedLocaleAndLoadBundle = exports.setDateFormat = exports.setCurrencyCode = exports.setAppLocale = exports.loadLocaleBundle = exports["default"] = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _toolkit = require("@reduxjs/toolkit");
+var _axios = _interopRequireDefault(require("axios"));
+var _toLower = _interopRequireDefault(require("lodash-es/toLower"));
+var _map = _interopRequireDefault(require("lodash-es/map"));
+var _lodashEs = require("lodash-es");
+var _util = require("@wavemaker/react-runtime/core/util");
+var _dom = require("@wavemaker/react-runtime/core/util/dom");
+var _store = require("@wavemaker/react-runtime/store");
+var _appstore = _interopRequireDefault(require("@wavemaker/react-runtime/core/appstore"));
+var APP_LOCALE_ROOT_PATH = "/resources/i18n";
+var RTL_LANGUAGE_CODES = ["ar", "ar-001", "ar-ae", "ar-bh", "ar-dz", "ar-eg", "ar-iq", "ar-jo", "ar-kw", "ar-lb", "ar-ly", "ar-ma", "ar-om", "ar-qa", "ar-sa", "ar-sd", "ar-sy", "ar-tn", "ar-ye", "arc", "bcc", "bqi", "ckb", "dv", "fa", "glk", "he", "ku", "mzn", "pnb", "ps", "sd", "ug", "ur", "yi"];
+var initialState = {
+  selectedLocale: "",
+  defaultSupportedLocale: "en",
+  appLocale: {},
+  dateFormat: "MMM d, y",
+  timeFormat: "h:mm:ss a",
+  dateTimeFormat: "MMM d, y h:mm:ss a",
+  currencyCode: "USD",
+  timezone: "UTC",
+  isLoading: false,
+  error: null,
+  prefabMessages: {}
+};
+
+// check and change the direction
+function updateLocaleDirection(locale) {
+  var direction = "ltr";
+  if (RTL_LANGUAGE_CODES.includes(locale)) {
+    direction = "rtl";
+  }
+  (0, _dom.setCSS)(document.body, "direction", direction);
+}
+
+// Async thunk for loading locale bundle
+var loadLocaleBundle = exports.loadLocaleBundle = (0, _toolkit.createAsyncThunk)("i18n/loadLocaleBundle", /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(_, _ref) {
+    var rejectWithValue, appProperties, getAcceptedLanguages, _acceptLang, _defaultLanguage, preferBrowserLang, _supportedLang, _selectedDefaultLang, sessionLanguage, localLanguage, locale, url, path, response;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          getAcceptedLanguages = function _getAcceptedLanguages() {
+            var _languages;
+            var languages = decodeURIComponent(appProperties.preferredLanguage || "");
+            languages = (_languages = languages) === null || _languages === void 0 || (_languages = _languages.split(",")) === null || _languages === void 0 ? void 0 : _languages.map(function (locale) {
+              return locale === null || locale === void 0 ? void 0 : locale.split(";")[0];
+            });
+            return (0, _map["default"])(languages, _toLower["default"]);
+          };
+          rejectWithValue = _ref.rejectWithValue;
+          appProperties = _store.store.getState().info.appConfig.appProperties;
+          _acceptLang = getAcceptedLanguages();
+          _defaultLanguage = appProperties.defaultLanguage;
+          _acceptLang.push(_defaultLanguage);
+
+          // checks whether user preference is based on browser set languages or default language set in project
+          preferBrowserLang = appProperties.preferBrowserLang;
+          if (!preferBrowserLang) {
+            // when preferBrowserLang is not defined, set to its default value
+            preferBrowserLang = true;
+          } else {
+            // convert stringified boolean values recieved from BE to booleans
+            preferBrowserLang = preferBrowserLang === "true" || preferBrowserLang === true ? true : false;
+          }
+          _supportedLang = (Object === null || Object === void 0 ? void 0 : Object.keys(appProperties.supportedLanguages)) || [initialState.defaultSupportedLocale];
+          _selectedDefaultLang = preferBrowserLang ? undefined : _defaultLanguage;
+          sessionLanguage = (0, _util.getSessionStorageItem)("selectedLocale");
+          localLanguage = (0, _lodashEs.includes)(_supportedLang, sessionLanguage) && sessionLanguage;
+          locale = localLanguage || _selectedDefaultLang || (0, _lodashEs.intersection)(_acceptLang, _supportedLang)[0] || initialState.defaultSupportedLocale;
+          _context.prev = 13;
+          url = _store.store.getState().info.appConfig.url;
+          path = "".concat(url + APP_LOCALE_ROOT_PATH, "/").concat(locale, ".json");
+          _context.next = 18;
+          return _axios["default"].get(path);
+        case 18:
+          response = _context.sent;
+          // update session language
+          (0, _util.setSessionStorageItem)("selectedLocale", locale);
+          // change direction if required
+          updateLocaleDirection(locale);
+          _appstore["default"].set("i18nService", response.data);
+          return _context.abrupt("return", {
+            data: response.data,
+            locale: locale
+          });
+        case 25:
+          _context.prev = 25;
+          _context.t0 = _context["catch"](13);
+          console.warn("Error loading locale resource: ".concat(_context.t0));
+          return _context.abrupt("return", rejectWithValue("Failed to load locale bundle"));
+        case 29:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[13, 25]]);
+  }));
+  return function (_x, _x2) {
+    return _ref2.apply(this, arguments);
+  };
+}());
+
+// Async thunk to set locale and load locale bundle
+var setSelectedLocaleAndLoadBundle = exports.setSelectedLocaleAndLoadBundle = (0, _toolkit.createAsyncThunk)("i18n/setSelectedLocaleAndLoadBundle", /*#__PURE__*/function () {
+  var _ref5 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(_ref3, _ref4) {
+    var locale, dispatch, getState, localeValue, appProperties, supportedLocales, currentLocale;
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          locale = _ref3.locale;
+          dispatch = _ref4.dispatch, getState = _ref4.getState;
+          localeValue = (0, _lodashEs.isObject)(locale) ? locale.datavalue : locale;
+          appProperties = _store.store.getState().info.appConfig.appProperties;
+          supportedLocales = Object.keys(appProperties.supportedLanguages);
+          if ((0, _lodashEs.includes)(supportedLocales, localeValue)) {
+            _context2.next = 7;
+            break;
+          }
+          return _context2.abrupt("return", null);
+        case 7:
+          if (!(!localeValue || localeValue === getState().i18n.selectedLocale)) {
+            _context2.next = 9;
+            break;
+          }
+          return _context2.abrupt("return", null);
+        case 9:
+          currentLocale = (0, _util.getSessionStorageItem)("selectedLocale");
+          if (!(currentLocale === localeValue)) {
+            _context2.next = 12;
+            break;
+          }
+          return _context2.abrupt("return", null);
+        case 12:
+          // Update session storage with new locale
+          (0, _util.setSessionStorageItem)("selectedLocale", localeValue);
+
+          // Change direction if required
+          updateLocaleDirection(localeValue);
+
+          // Load the locale bundle
+          _context2.next = 16;
+          return dispatch(loadLocaleBundle());
+        case 16:
+          return _context2.abrupt("return", localeValue);
+        case 17:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function (_x3, _x4) {
+    return _ref5.apply(this, arguments);
+  };
+}());
+var i18nSlice = (0, _toolkit.createSlice)({
+  name: "i18n",
+  initialState: initialState,
+  reducers: {
+    setTimezone: function setTimezone(state, action) {
+      state.timezone = action.payload;
+    },
+    setAppLocale: function setAppLocale(state, action) {
+      state.appLocale = action.payload;
+    },
+    setDateFormat: function setDateFormat(state, action) {
+      state.dateFormat = action.payload;
+      state.dateTimeFormat = "".concat(action.payload, " ").concat(state.timeFormat);
+    },
+    setTimeFormat: function setTimeFormat(state, action) {
+      state.timeFormat = action.payload;
+      state.dateTimeFormat = "".concat(state.dateFormat, " ").concat(action.payload);
+    },
+    setCurrencyCode: function setCurrencyCode(state, action) {
+      state.currencyCode = action.payload;
+    }
+  },
+  extraReducers: function extraReducers(builder) {
+    builder.addCase(loadLocaleBundle.fulfilled, function (state, action) {
+      var _action$payload$data$, _action$payload$data$2, _action$payload$data$3;
+      state.appLocale = action.payload.data.messages || {};
+      state.dateFormat = ((_action$payload$data$ = action.payload.data.formats) === null || _action$payload$data$ === void 0 ? void 0 : _action$payload$data$.date) || state.dateFormat;
+      state.timeFormat = ((_action$payload$data$2 = action.payload.data.formats) === null || _action$payload$data$2 === void 0 ? void 0 : _action$payload$data$2.time) || state.timeFormat;
+      state.currencyCode = ((_action$payload$data$3 = action.payload.data.formats) === null || _action$payload$data$3 === void 0 ? void 0 : _action$payload$data$3.currency) || state.currencyCode;
+      state.dateTimeFormat = "".concat(state.dateFormat, " ").concat(state.timeFormat);
+      state.prefabMessages = action.payload.data.prefabMessages || {};
+      state.selectedLocale = action.payload.locale || state.selectedLocale;
+    }).addCase(loadLocaleBundle.rejected, function (state, action) {
+      state.error = action.payload;
+    });
+  }
+});
+var _i18nSlice$actions = i18nSlice.actions,
+  setTimezone = exports.setTimezone = _i18nSlice$actions.setTimezone,
+  setAppLocale = exports.setAppLocale = _i18nSlice$actions.setAppLocale,
+  setDateFormat = exports.setDateFormat = _i18nSlice$actions.setDateFormat,
+  setTimeFormat = exports.setTimeFormat = _i18nSlice$actions.setTimeFormat,
+  setCurrencyCode = exports.setCurrencyCode = _i18nSlice$actions.setCurrencyCode;
+var _default = exports["default"] = i18nSlice.reducer;

package/types/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VariableEvents = void 0;
+// Adding index signature to PageContextState
+// Enums and Types
+var VariableEvents = exports.VariableEvents = /*#__PURE__*/function (VariableEvents) {
+  VariableEvents["BEFORE_INVOKE"] = "beforeInvoke";
+  VariableEvents["SUCCESS"] = "success";
+  VariableEvents["ERROR"] = "error";
+  VariableEvents["AFTER_INVOKE"] = "afterInvoke";
+  return VariableEvents;
+}({});

package/utils/dataset-util.js

@@ -0,0 +1,174 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _lodashEs = require("lodash-es");
+var DatasetUtil = exports["default"] = /*#__PURE__*/function () {
+  function DatasetUtil() {
+    (0, _classCallCheck2["default"])(this, DatasetUtil);
+  }
+  (0, _createClass2["default"])(DatasetUtil, null, [{
+    key: "isValidDataset",
+    value: function isValidDataset(dataSet, isList) {
+      if (!dataSet || isList && !(0, _lodashEs.isArray)(dataSet)) {
+        return false;
+      }
+      return dataSet;
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(dataSet, key, index, isList) {
+      index = index || 0;
+      return isList ? dataSet[index][key] : dataSet[key];
+    }
+  }, {
+    key: "setValue",
+    value: function setValue(dataSet, key, value, isList) {
+      if (key && !isList) {
+        dataSet[key] = value;
+      }
+      return dataSet;
+    }
+  }, {
+    key: "getTargetNode",
+    value: function getTargetNode(dataSet, options) {
+      dataSet = options.parentIndex !== undefined ? dataSet[options.parentIndex] : dataSet;
+      return (0, _lodashEs.get)(dataSet, options.path);
+    }
+  }, {
+    key: "getItem",
+    value: function getItem(dataSet, index, isList) {
+      return isList ? dataSet[index] : dataSet;
+    }
+  }, {
+    key: "setItem",
+    value: function setItem(dataSet, i, value, options) {
+      var index;
+      if ((0, _lodashEs.isUndefined)(i) || !options.isList) {
+        return dataSet;
+      }
+      if ((0, _lodashEs.isObject)(i)) {
+        index = (0, _lodashEs.findIndex)(dataSet, i);
+      } else {
+        index = i;
+      }
+      if (options.path) {
+        var innerArray = DatasetUtil.getTargetNode(dataSet, options);
+        var innerElemindex = (0, _lodashEs.findIndex)(innerArray, i);
+        if (innerElemindex > -1) {
+          innerArray[innerElemindex] = value;
+        }
+      } else {
+        if (index > -1) {
+          dataSet[index] = value;
+        }
+      }
+      return dataSet;
+    }
+
+    /**
+     * This method is to get target node options like path, parentIndex and isList
+     * Example: if we have parent dataset as object and we are performing operations on inner list then we have to set isList as true.
+     * So finding the target node type and updating the isList option.
+     */
+  }, {
+    key: "getChildDetails",
+    value: function getChildDetails(dataSet, options, isList) {
+      var parentIndex, path;
+      if (options && options.path) {
+        path = options.path;
+        var targetNode;
+        if (isList) {
+          parentIndex = options.parentIndex || 0;
+          targetNode = (0, _lodashEs.get)(dataSet[parentIndex], options.path);
+        } else {
+          targetNode = (0, _lodashEs.get)(dataSet, options.path);
+        }
+        isList = targetNode ? (0, _lodashEs.isArray)(targetNode) ? true : false : true;
+      }
+      return {
+        path: path,
+        isList: isList,
+        parentIndex: parentIndex
+      };
+    }
+  }, {
+    key: "addItem",
+    value: function addItem(dataSet, value, index, options) {
+      if ((0, _lodashEs.isUndefined)(value) || !options.isList) {
+        return dataSet;
+      }
+      if (options.path) {
+        var innerArray = DatasetUtil.getTargetNode(dataSet, options);
+        if (innerArray) {
+          // check for index sanity
+          index = index !== undefined ? index : innerArray.length;
+          innerArray.splice(index, 0, value);
+        } else {
+          options.parentIndex !== undefined ? (0, _lodashEs.set)(dataSet[options.parentIndex], options.path, [value]) : (0, _lodashEs.set)(dataSet, options.path, [value]);
+        }
+      } else {
+        index = index !== undefined ? index : dataSet.length;
+        dataSet.splice(index, 0, value);
+      }
+      return dataSet;
+    }
+
+    /**
+     *
+     * @param dataSet
+     * @param i, can be index value of the object/element in array
+     *      or
+     * the whole object which needs to be removed
+     * @param exactMatch
+     * @returns {any}
+     */
+  }, {
+    key: "removeItem",
+    value: function removeItem(dataSet, i, options) {
+      var index, exactMatch;
+      i = i !== undefined ? i : dataSet.length - 1;
+      if ((0, _lodashEs.isBoolean)(options)) {
+        exactMatch = options;
+      }
+      if ((0, _lodashEs.isObject)(options)) {
+        // @ts-ignore
+        exactMatch = options.exactMatch;
+      }
+      if ((0, _lodashEs.isObject)(i)) {
+        if (options.path) {
+          var innerArray = DatasetUtil.getTargetNode(dataSet, options);
+          var innerElemindex = (0, _lodashEs.findIndex)(innerArray, i);
+          if (innerElemindex > -1 && (!exactMatch || exactMatch && (0, _lodashEs.isEqual)(innerArray[innerElemindex], i))) {
+            innerArray.splice(innerElemindex, 1);
+          }
+        } else {
+          index = (0, _lodashEs.findIndex)(dataSet, i);
+          // When exactMatch property is set to true delete only when every property values are same*/
+          if (index > -1 && (!exactMatch || exactMatch && (0, _lodashEs.isEqual)(dataSet[index], i))) {
+            dataSet.splice(index, 1);
+          }
+        }
+      } else {
+        dataSet.splice(i, 1);
+      }
+      return dataSet;
+    }
+  }, {
+    key: "getValidDataset",
+    value: function getValidDataset(isList) {
+      return isList ? [] : {};
+    }
+  }, {
+    key: "getCount",
+    value: function getCount(dataSet, isList) {
+      return isList ? dataSet.length : Object.keys(dataSet).length;
+    }
+  }]);
+  return DatasetUtil;
+}();

package/utils/eval-expression.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.evalExp = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _lodashEs = require("lodash-es");
+var evalExp = exports.evalExp = function evalExp(obj, path) {
+  if (!obj || typeof path !== "string") {
+    console.warn("Invalid input: obj is null/undefined or path is not a string.");
+    return null;
+  }
+
+  // Convert  indices to dot notation and split
+  var pathArray = path.replace(/\[(\w+)\]/g, ".$1").split(".");
+
+  // traverse the pathArray and check if the key exists or not
+  var item = pathArray.slice(1, pathArray.length).reduce(function (accumulator, currentKey) {
+    if (!accumulator) {
+      return null;
+    }
+    if ((0, _lodashEs.isArray)(accumulator)) {
+      return accumulator[parseInt(currentKey)];
+    } else if ((0, _typeof2["default"])(accumulator) === "object") {
+      return accumulator[currentKey];
+    }
+    return accumulator;
+  }, obj);
+  return item;
+};

package/utils/form-state.util.js

@@ -0,0 +1,140 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unregisterFormField = exports.shouldRegisterFormField = exports.registerFormFieldSafe = exports.registerFormField = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _get = _interopRequireDefault(require("lodash-es/get"));
+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; } /**
+ * Form State Utility
+ *
+ * Handles form field registration and management within the widget context.
+ * This utility provides centralized logic for registering form fields and form widgets
+ * to their parent form context.
+ */
+/**
+ * Interface for widget properties related to form field registration
+ */
+
+/**
+ * Interface for the context structure where form fields are registered
+ */
+
+/**
+ * Checks if a widget is a form field (not a formWidget wrapper)
+ * @param widgetName - The name of the widget
+ * @returns true if the widget is NOT a formWidget wrapper
+ */
+var isFormField = function isFormField(widgetName) {
+  return !(widgetName !== null && widgetName !== void 0 && widgetName.includes("formWidget"));
+};
+
+/**
+ * Checks if a widget should be registered as a form field
+ * @param widget - The widget object to check
+ * @returns true if the widget should be registered as a form field
+ */
+var shouldRegisterFormField = exports.shouldRegisterFormField = function shouldRegisterFormField(widget) {
+  var isField = (0, _get["default"])(widget, "field", "false") === "true";
+  var hasFormName = Boolean(widget.formName);
+  var isNotFormWidget = isFormField(widget.name);
+  return isField && hasFormName && isNotFormWidget;
+};
+
+/**
+ * Registers a form field widget with its parent form in the context
+ * This creates references in both formfields and formWidgets collections
+ *
+ * @param widgetsContext - The Widgets context object where forms are stored
+ * @param widget - The widget/proxy to register
+ * @param widgetProps - The widget properties containing form metadata
+ */
+var registerFormField = exports.registerFormField = function registerFormField(widgetsContext, widget, widgetProps) {
+  var formName = widgetProps === null || widgetProps === void 0 ? void 0 : widgetProps.formName;
+  if (!formName || !shouldRegisterFormField(widgetProps)) {
+    return;
+  }
+  var formKey = widgetProps.formKey || widgetProps.fieldName;
+  var fieldName = widgetProps.fieldName;
+  if (!formKey || !fieldName) {
+    return;
+  }
+
+  // Ensure the form structure exists in the context
+  if (!widgetsContext[formName]) {
+    return;
+  }
+  widgetsContext[formName].formfields = widgetsContext[formName].formfields || {};
+  widgetsContext[formName].formWidgets = widgetsContext[formName].formWidgets || {};
+
+  // Register the field using the formKey (primary key)
+  widgetsContext[formName].formfields[formKey] = widget;
+
+  // Register using fieldName for direct access
+  widgetsContext[formName].formWidgets[fieldName] = widget;
+
+  // Register formWidget variants (for form field wrapper components)
+  widgetsContext[formName].formfields["".concat(fieldName, "_formWidget")] = widget;
+  widgetsContext[formName].formWidgets["".concat(fieldName, "_formWidget")] = widget;
+};
+
+/**
+ * Ensures the form structure exists in the widgets context and registers a form field
+ * with safe object spreading to merge properties
+ *
+ * @param widgetsContext - The Widgets context object where forms are stored
+ * @param fieldProps - The field properties to register
+ */
+var registerFormFieldSafe = exports.registerFormFieldSafe = function registerFormFieldSafe(widgetsContext, fieldProps) {
+  var _widgetsContext$formN, _widgetsContext$formN2, _widgetsContext$formN3, _widgetsContext$formN4, _widgetsContext$formN5;
+  var formName = fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.formName;
+  if (!formName || !shouldRegisterFormField(fieldProps)) {
+    return;
+  }
+  var formKey = fieldProps.formKey || fieldProps.fieldName;
+  var fieldName = fieldProps.fieldName;
+  if (!formKey || !fieldName) {
+    return;
+  }
+
+  // ✅ Ensure all nested structures exist using nullish coalescing
+  (_widgetsContext$formN = widgetsContext[formName]) !== null && _widgetsContext$formN !== void 0 ? _widgetsContext$formN : widgetsContext[formName] = {};
+  (_widgetsContext$formN3 = (_widgetsContext$formN2 = widgetsContext[formName]).formfields) !== null && _widgetsContext$formN3 !== void 0 ? _widgetsContext$formN3 : _widgetsContext$formN2.formfields = {};
+  (_widgetsContext$formN5 = (_widgetsContext$formN4 = widgetsContext[formName]).formWidgets) !== null && _widgetsContext$formN5 !== void 0 ? _widgetsContext$formN5 : _widgetsContext$formN4.formWidgets = {};
+
+  // ✅ Only add if not already present
+  widgetsContext[formName].formfields[formKey] = _objectSpread({}, fieldProps);
+  widgetsContext[formName].formWidgets[fieldName] = _objectSpread({}, fieldProps);
+  widgetsContext[formName].formfields["".concat(fieldName, "_formWidget")] = _objectSpread({}, fieldProps);
+  widgetsContext[formName].formWidgets["".concat(fieldName, "_formWidget")] = _objectSpread({}, fieldProps);
+};
+
+/**
+ * Unregisters a form field from its parent form
+ *
+ * @param widgetsContext - The Widgets context object where forms are stored
+ * @param formName - The name of the parent form
+ * @param fieldName - The name of the field to unregister
+ * @param formKey - Optional form key (defaults to fieldName if not provided)
+ */
+var unregisterFormField = exports.unregisterFormField = function unregisterFormField(widgetsContext, formName, fieldName, formKey) {
+  if (!widgetsContext[formName]) {
+    return;
+  }
+  var keyToRemove = formKey || fieldName;
+
+  // Remove from formfields
+  if (widgetsContext[formName].formfields) {
+    delete widgetsContext[formName].formfields[keyToRemove];
+    delete widgetsContext[formName].formfields["".concat(fieldName, "_formWidget")];
+  }
+
+  // Remove from formWidgets
+  if (widgetsContext[formName].formWidgets) {
+    delete widgetsContext[formName].formWidgets[fieldName];
+    delete widgetsContext[formName].formWidgets["".concat(fieldName, "_formWidget")];
+  }
+};