@wavemaker-ai/react-runtime 1.0.0-rc.312 → 1.0.0-rc.317

package/utils/form-state.util.js

@@ -1,167 +1,109 @@
-"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"));
+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;
 };
-
-/**
- * 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);
+import get from "lodash-es/get";
+const isFormField = (widgetName) => {
+  return !(widgetName == null ? void 0 : widgetName.includes("formWidget"));
+};
+const shouldRegisterFormField = (widget) => {
+  const isField = get(widget, "field", "false") === "true";
+  const hasFormName = Boolean(widget.formName);
+  const isNotFormWidget = isFormField(widget.name);
   return isField && hasFormName && isNotFormWidget;
 };
-var hasParentForm = function hasParentForm(formName) {
+const hasParentForm = (formName) => {
   return Boolean();
 };
-
-/**
- * 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, newContext) {
-  var _widgetsContext$formN;
-  var formName = widgetProps === null || widgetProps === void 0 ? void 0 : widgetProps.formName;
+const registerFormField = (widgetsContext, widget, widgetProps, newContext) => {
+  var _a;
+  const formName = widgetProps == null ? void 0 : widgetProps.formName;
   if (!formName || !shouldRegisterFormField(widgetProps)) {
     return;
   }
-  var formKey = widgetProps.formKey || widgetProps.fieldName;
-  var fieldName = widgetProps.fieldName;
+  const formKey = widgetProps.formKey || widgetProps.fieldName;
+  const 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;
-  var parentFormName = (_widgetsContext$formN = widgetsContext[formName]) === null || _widgetsContext$formN === void 0 ? void 0 : _widgetsContext$formN.parentForm;
-  // NOTE: Prefab form field registration via CHILD_FORM_FIELD_REGISTER_EMIT has been removed.
-  // Prefab forms now use ParentFormDataContext.registerChildField callback instead,
-  // which is called by the form component when it registers fields in its context.
-  // For non-prefab parent forms, direct registration below still works.
+  widgetsContext[formName].formfields[`${fieldName}_formWidget`] = widget;
+  widgetsContext[formName].formWidgets[`${fieldName}_formWidget`] = widget;
+  const parentFormName = (_a = widgetsContext[formName]) == null ? void 0 : _a.parentForm;
   if (parentFormName && widgetsContext[parentFormName]) {
     widgetsContext[parentFormName].formfields = widgetsContext[parentFormName].formfields || {};
     widgetsContext[parentFormName].formWidgets = widgetsContext[parentFormName].formWidgets || {};
     widgetsContext[parentFormName].formfields[formKey] = widget;
     widgetsContext[parentFormName].formWidgets[fieldName] = widget;
-    widgetsContext[parentFormName].formfields["".concat(formKey, "_formWidget")] = widget;
-    widgetsContext[parentFormName].formWidgets["".concat(fieldName, "_formWidget")] = widget;
+    widgetsContext[parentFormName].formfields[`${formKey}_formWidget`] = widget;
+    widgetsContext[parentFormName].formWidgets[`${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$formN7;
-  var formName = fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.formName;
+const registerFormFieldSafe = (widgetsContext, fieldProps) => {
+  var _a;
+  const formName = fieldProps == null ? void 0 : fieldProps.formName;
   if (!formName || !shouldRegisterFormField(fieldProps)) {
     return;
   }
-  var formKey = fieldProps.formKey || fieldProps.fieldName;
-  var fieldName = fieldProps.fieldName;
+  const formKey = fieldProps.formKey || fieldProps.fieldName;
+  const fieldName = fieldProps.fieldName;
   if (!formKey || !fieldName) {
     return;
   }
-  function register(formName, formKey, fieldName, fieldProps) {
-    var _widgetsContext$formN2, _widgetsContext$formN3, _widgetsContext$formN4, _widgetsContext$formN5, _widgetsContext$formN6;
-    // ✅ Ensure all nested structures exist using nullish coalescing
-    (_widgetsContext$formN2 = widgetsContext[formName]) !== null && _widgetsContext$formN2 !== void 0 ? _widgetsContext$formN2 : widgetsContext[formName] = {
+  function register(formName2, formKey2, fieldName2, fieldProps2) {
+    var _a2, _b, _c, _d, _e;
+    (_a2 = widgetsContext[formName2]) != null ? _a2 : widgetsContext[formName2] = {
       formfields: {},
       formWidgets: {}
     };
-    (_widgetsContext$formN4 = (_widgetsContext$formN3 = widgetsContext[formName]).formfields) !== null && _widgetsContext$formN4 !== void 0 ? _widgetsContext$formN4 : _widgetsContext$formN3.formfields = {};
-    (_widgetsContext$formN6 = (_widgetsContext$formN5 = widgetsContext[formName]).formWidgets) !== null && _widgetsContext$formN6 !== void 0 ? _widgetsContext$formN6 : _widgetsContext$formN5.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);
+    (_c = (_b = widgetsContext[formName2]).formfields) != null ? _c : _b.formfields = {};
+    (_e = (_d = widgetsContext[formName2]).formWidgets) != null ? _e : _d.formWidgets = {};
+    widgetsContext[formName2].formfields[formKey2] = __spreadValues({}, fieldProps2);
+    widgetsContext[formName2].formWidgets[fieldName2] = __spreadValues({}, fieldProps2);
+    widgetsContext[formName2].formfields[`${fieldName2}_formWidget`] = __spreadValues({}, fieldProps2);
+    widgetsContext[formName2].formWidgets[`${fieldName2}_formWidget`] = __spreadValues({}, fieldProps2);
   }
   register(formName, formKey, fieldName, fieldProps);
-  var parentForm = (_widgetsContext$formN7 = widgetsContext[formName]) === null || _widgetsContext$formN7 === void 0 ? void 0 : _widgetsContext$formN7.parentForm;
+  const parentForm = (_a = widgetsContext[formName]) == null ? void 0 : _a.parentForm;
   if (parentForm) {
     register(parentForm, formKey, fieldName, 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) {
+const unregisterFormField = (widgetsContext, formName, fieldName, formKey) => {
   if (!widgetsContext[formName]) {
     return;
   }
-  var keyToRemove = formKey || fieldName;
-
-  // Remove from formfields
+  const keyToRemove = formKey || fieldName;
   if (widgetsContext[formName].formfields) {
     delete widgetsContext[formName].formfields[keyToRemove];
-    delete widgetsContext[formName].formfields["".concat(fieldName, "_formWidget")];
+    delete widgetsContext[formName].formfields[`${fieldName}_formWidget`];
   }
-
-  // Remove from formWidgets
   if (widgetsContext[formName].formWidgets) {
     delete widgetsContext[formName].formWidgets[fieldName];
-    delete widgetsContext[formName].formWidgets["".concat(fieldName, "_formWidget")];
+    delete widgetsContext[formName].formWidgets[`${fieldName}_formWidget`];
   }
-};
+};
+export {
+  registerFormField,
+  registerFormFieldSafe,
+  shouldRegisterFormField,
+  unregisterFormField
+};

package/utils/form-utils.js

@@ -1,232 +1,91 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.shouldSkipFieldKey = exports.loginErrorMessage = exports.invokeFormEvent = exports.getFormWidget = exports.getFormProps = exports.getFormData = exports.getErrorTypes = exports.formValidate = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-var _keys = _interopRequireDefault(require("lodash-es/keys"));
-/**
- * Form utility functions for centralizing form operations across widgets
- */
-
-/**
- * The `loginErrorMessage` function handles various scenarios to generate an appropriate error message
- * for login failures, including extracting from standard error response structures and providing
- * fallback options.
- * @param {any} error - The `error` parameter in the `loginErrorMessage` function is used to handle
- * different types of errors that may occur during the login process. It can be of any type, such as a
- * string, object, or other data types, and the function provides different logic to extract and handle
- * error messages based
- * @param [appLocale] - The `appLocale` parameter is an optional object that contains localized strings
- * for different languages or regions. It is used to provide localized error messages based on the
- * user's preferred language or region. If a specific error message is not provided, the function will
- * fallback to a default error message stored in the `
- * @param {string} [errorMessage] - The `errorMessage` parameter in the `loginErrorMessage` function is
- * a string that can be passed directly to override any other error message handling logic in the
- * function. If a value is provided for `errorMessage`, it will be returned immediately without going
- * through the other error handling steps in the function.
- * @returns The function `loginErrorMessage` returns a string message based on the provided error
- * object, appLocale object, and optional errorMessage string. The function follows these steps to
- * determine the message to return:
- */
-var loginErrorMessage = exports.loginErrorMessage = function loginErrorMessage(error, appLocale, errorMessage) {
-  // 1. If a direct error message is passed, use it
+import keys from "lodash-es/keys";
+const loginErrorMessage = (error, appLocale, errorMessage) => {
+  var _a, _b, _c;
   if (errorMessage) return errorMessage;
-
-  // 2. If it's a plain string error
   if (typeof error === "string") {
     return error;
   }
-
-  // 3. Try extracting from standard error response structure
-  if (error && (0, _typeof2["default"])(error) === "object") {
-    var _error$data;
-    var serverError = error === null || error === void 0 || (_error$data = error.data) === null || _error$data === void 0 || (_error$data = _error$data.errors) === null || _error$data === void 0 || (_error$data = _error$data.error) === null || _error$data === void 0 ? void 0 : _error$data[0];
+  if (error && typeof error === "object") {
+    const serverError = (_c = (_b = (_a = error == null ? void 0 : error.data) == null ? void 0 : _a.errors) == null ? void 0 : _b.error) == null ? void 0 : _c[0];
     if (serverError) {
-      var message = serverError.message,
-        _serverError$paramete = serverError.parameters,
-        parameters = _serverError$paramete === void 0 ? [] : _serverError$paramete;
+      const { message, parameters = [] } = serverError;
       if (typeof message === "string") {
-        // Replace {0}, {1}, {2}, ... with corresponding parameters dynamically
-        return message.replace(/{(\d+)}/g, function (match, index) {
-          var param = parameters[+index];
-          return param !== undefined ? param : match;
+        return message.replace(/{(\d+)}/g, (match, index) => {
+          const param = parameters[+index];
+          return param !== void 0 ? param : match;
         });
       }
-
-      // If no message, but parameters exist, just join them
       if (parameters.length) {
         return parameters.join(", ");
       }
     }
-
-    // Fallback to error.message or .toString()
     return error.message || error.toString();
   }
-
-  // 4. Fallback to localized or default error message
-  return (appLocale === null || appLocale === void 0 ? void 0 : appLocale.LABEL_INVALID_USERNAME_OR_PASSWORD) || "Invalid username or password";
+  return (appLocale == null ? void 0 : appLocale.LABEL_INVALID_USERNAME_OR_PASSWORD) || "Invalid username or password";
 };
-
-/**
- * Get form properties safely from a form reference
- */
-var getFormProps = exports.getFormProps = function getFormProps(formRef) {
-  var _formRef$current;
-  if (!((_formRef$current = formRef.current) !== null && _formRef$current !== void 0 && _formRef$current.getProps)) {
+const getFormProps = (formRef) => {
+  var _a;
+  if (!((_a = formRef.current) == null ? void 0 : _a.getProps)) {
     return null;
   }
   return formRef.current.getProps();
 };
-
-/**
- * Get form widget from listener widgets collection
- */
-var getFormWidget = exports.getFormWidget = function getFormWidget(formName, listener) {
-  var _listener$Widgets;
-  return listener === null || listener === void 0 || (_listener$Widgets = listener.Widgets) === null || _listener$Widgets === void 0 ? void 0 : _listener$Widgets[formName];
+const getFormWidget = (formName, listener) => {
+  var _a;
+  return (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[formName];
 };
-
-/**
- * Get form data from form reference with fallback
- */
-var getFormData = exports.getFormData = function getFormData(formRef) {
-  if (!formRef.current) return {
-    values: {},
-    isValid: false
-  };
+const getFormData = (formRef) => {
+  if (!formRef.current) return { values: {}, isValid: false };
   if (formRef.current.getFormData) {
     return formRef.current.getFormData();
   }
-
-  // Fallback for legacy forms
   return {
     values: {},
     isValid: true
   };
 };
-var formValidate = exports.formValidate = /*#__PURE__*/function () {
-  var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(formRef) {
-    var _formRef$current$vali, _formRef$current2;
-    return _regenerator["default"].wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          if (formRef.current) {
-            _context.next = 2;
-            break;
-          }
-          return _context.abrupt("return", false);
-        case 2:
-          _context.next = 4;
-          return (_formRef$current$vali = (_formRef$current2 = formRef.current).validateForm) === null || _formRef$current$vali === void 0 ? void 0 : _formRef$current$vali.call(_formRef$current2);
-        case 4:
-          _context.t0 = _context.sent;
-          if (_context.t0) {
-            _context.next = 7;
-            break;
-          }
-          _context.t0 = false;
-        case 7:
-          return _context.abrupt("return", _context.t0);
-        case 8:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return function formValidate(_x) {
-    return _ref.apply(this, arguments);
-  };
-}();
-
-/**
- * Invoke form events in a centralized way
- * @param formRef - Reference to the form element
- * @param listener - Widget listener containing form widgets
- * @param eventName - Name of the event to invoke ('onSubmit', 'onBeforeSubmit', etc.)
- * @param event - The event object
- * @param formData - Optional form data to pass to the event handler
- * @returns The result from the event handler (boolean, string, object, or undefined)
- */
-var invokeFormEvent = exports.invokeFormEvent = /*#__PURE__*/function () {
-  var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(formRef, listener, eventName, event, formData) {
-    var formProps, formName, eventHandler, formWidget, result;
-    return _regenerator["default"].wrap(function _callee2$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
-        case 0:
-          formProps = getFormProps(formRef);
-          if (formProps) {
-            _context2.next = 3;
-            break;
-          }
-          return _context2.abrupt("return");
-        case 3:
-          formName = formProps.name, eventHandler = formProps[eventName];
-          if (!(eventHandler && formName)) {
-            _context2.next = 10;
-            break;
-          }
-          formWidget = getFormWidget(formName, listener);
-          _context2.next = 8;
-          return eventHandler(event, formWidget, formData.values || {});
-        case 8:
-          result = _context2.sent;
-          return _context2.abrupt("return", result);
-        case 10:
-        case "end":
-          return _context2.stop();
-      }
-    }, _callee2);
-  }));
-  return function invokeFormEvent(_x2, _x3, _x4, _x5, _x6) {
-    return _ref2.apply(this, arguments);
-  };
-}();
-
-/**
- * Extracts error types from react-hook-form error object.
- * react-hook-form error structure: { type: 'required', message: '...' }
- * or { types: { required: '...', minLength: '...' } }
- * @param fieldErrors - The error object from react-hook-form
- * @returns Array of error type strings
- */
-var getErrorTypes = exports.getErrorTypes = function getErrorTypes(fieldErrors) {
+const formValidate = async (formRef) => {
+  var _a, _b;
+  if (!formRef.current) return false;
+  return await ((_b = (_a = formRef.current).validateForm) == null ? void 0 : _b.call(_a)) || false;
+};
+const invokeFormEvent = async (formRef, listener, eventName, event, formData) => {
+  const formProps = getFormProps(formRef);
+  if (!formProps) return;
+  const { name: formName, [eventName]: eventHandler } = formProps;
+  if (eventHandler && formName) {
+    const formWidget = getFormWidget(formName, listener);
+    const result = await eventHandler(event, formWidget, formData.values || {});
+    return result;
+  }
+};
+const getErrorTypes = (fieldErrors) => {
   if (!fieldErrors) return [];
-
-  // Handle multiple errors (when using criteriaMode: 'all')
   if (fieldErrors.types) {
-    return (0, _keys["default"])(fieldErrors.types);
+    return keys(fieldErrors.types);
   }
-
-  // Handle single error
   if (fieldErrors.type) {
     return [fieldErrors.type];
   }
-  return (0, _keys["default"])(fieldErrors);
+  return keys(fieldErrors);
 };
-
-/**
- * Checks if a field key should be skipped during validation messages iteration.
- * - Skips formWidget entries (duplicates)
- * - Skips underscore variants if dot notation exists (e.g., Department_deptCode when Department.deptCode exists)
- * @param fieldKey - The field key to check
- * @param allFieldKeys - All field keys in the form
- * @returns true if the field should be skipped
- */
-var shouldSkipFieldKey = exports.shouldSkipFieldKey = function shouldSkipFieldKey(fieldKey, allFieldKeys) {
-  // Skip formWidget entries (they are duplicates)
+const shouldSkipFieldKey = (fieldKey, allFieldKeys) => {
   if (fieldKey.includes("formWidget")) return true;
-
-  // Skip underscore variants if dot notation exists (avoid duplicates)
   if (fieldKey.includes("_")) {
-    var dotNotationKey = fieldKey.replace(/_/g, ".");
+    const dotNotationKey = fieldKey.replace(/_/g, ".");
     if (allFieldKeys.includes(dotNotationKey)) {
       return true;
     }
   }
   return false;
-};
+};
+export {
+  formValidate,
+  getErrorTypes,
+  getFormData,
+  getFormProps,
+  getFormWidget,
+  invokeFormEvent,
+  loginErrorMessage,
+  shouldSkipFieldKey
+};