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

package/utils/dataset-util.js

@@ -0,0 +1,173 @@
+"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);
+  }
+  return (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;
+    }
+  }]);
+}();

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.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 FormFieldWidget {
+    name?: string;
+    formName?: string;
+    field?: string;
+    fieldName?: string;
+    formKey?: string;
+    parentForm?: string;
+    [key: string]: any;
+}
+/**
+ * Interface for the context structure where form fields are registered
+ */
+interface WidgetsContext {
+    [formName: string]: {
+        formfields: Record<string, any>;
+        formWidgets: Record<string, any>;
+        [key: string]: any;
+    };
+}
+/**
+ * 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
+ */
+export declare const shouldRegisterFormField: (widget: FormFieldWidget) => 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
+ */
+export declare const registerFormField: (widgetsContext: WidgetsContext, widget: any, widgetProps: FormFieldWidget, newContext: any) => void;
+/**
+ * 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
+ */
+export declare const registerFormFieldSafe: (widgetsContext: WidgetsContext, fieldProps: FormFieldWidget) => void;
+/**
+ * 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)
+ */
+export declare const unregisterFormField: (widgetsContext: WidgetsContext, formName: string, fieldName: string, formKey?: string) => void;
+export {};

package/utils/form-state.util.js

@@ -0,0 +1,167 @@
+"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;
+};
+var hasParentForm = function 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;
+  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;
+  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.
+  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;
+  }
+};
+
+/**
+ * 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;
+  if (!formName || !shouldRegisterFormField(fieldProps)) {
+    return;
+  }
+  var formKey = fieldProps.formKey || fieldProps.fieldName;
+  var 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] = {
+      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);
+  }
+  register(formName, formKey, fieldName, fieldProps);
+  var parentForm = (_widgetsContext$formN7 = widgetsContext[formName]) === null || _widgetsContext$formN7 === void 0 ? void 0 : _widgetsContext$formN7.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) {
+  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")];
+  }
+};

package/utils/form-utils.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Form utility functions for centralizing form operations across widgets
+ */
+export interface IFormData {
+    values: Record<string, any>;
+    isValid: boolean;
+}
+export interface FormRef {
+    getProps?: () => {
+        name: string;
+        onSubmit?: (event: Event, widget: any, formData: Record<string, any>) => void;
+        onBeforeSubmit?: (event: Event, widget: any, formData: Record<string, any>) => void;
+        [key: string]: any;
+    };
+    getFormData?: () => IFormData;
+    validateForm?: () => boolean | Promise<boolean>;
+    clearErrors?: () => void;
+}
+/**
+ * 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:
+ */
+export declare const loginErrorMessage: (error: any, appLocale?: Record<string, string>, errorMessage?: string) => string;
+/**
+ * Get form properties safely from a form reference
+ */
+export declare const getFormProps: (formRef: React.RefObject<FormRef | null>) => {
+    [key: string]: any;
+    name: string;
+    onSubmit?: (event: Event, widget: any, formData: Record<string, any>) => void;
+    onBeforeSubmit?: (event: Event, widget: any, formData: Record<string, any>) => void;
+};
+/**
+ * Get form widget from listener widgets collection
+ */
+export declare const getFormWidget: (formName: string, listener: any) => any;
+/**
+ * Get form data from form reference with fallback
+ */
+export declare const getFormData: (formRef: React.RefObject<FormRef | null>) => IFormData;
+export declare const formValidate: (formRef: React.RefObject<FormRef | null>) => Promise<boolean>;
+/**
+ * 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)
+ */
+export declare const invokeFormEvent: (formRef: React.RefObject<FormRef | null>, listener: any, eventName: string, event: Event, formData: IFormData) => Promise<any>;
+/**
+ * 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
+ */
+export declare const getErrorTypes: (fieldErrors: any) => string[];
+/**
+ * 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
+ */
+export declare const shouldSkipFieldKey: (fieldKey: string, allFieldKeys: string[]) => boolean;