@wavemaker/react-runtime 11.14.1-16.6404

package/utils/form-utils.js

@@ -0,0 +1,187 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loginErrorMessage = exports.invokeFormEvent = exports.getFormWidget = exports.getFormProps = exports.getFormData = 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"));
+/**
+ * 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
+  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 (serverError) {
+      var message = serverError.message,
+        _serverError$paramete = serverError.parameters,
+        parameters = _serverError$paramete === void 0 ? [] : _serverError$paramete;
+      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;
+        });
+      }
+
+      // 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";
+};
+
+/**
+ * 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)) {
+    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];
+};
+
+/**
+ * Get form data from form reference with fallback
+ */
+var getFormData = exports.getFormData = function 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);
+  };
+}();

package/utils/format-util.js

@@ -0,0 +1,260 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateNumericValue = exports.roundToStep = exports.parseNumber = exports.isPercentageValue = exports.handleValidatedValueUpdate = exports.handleStepValue = exports.handleNumericInputChange = exports.getValueInRange = exports.getDecimalCount = exports.formatOnBlur = exports.formatNumberWithCommas = exports.formatFinancialValue = exports.findValueOf = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+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; }
+var getDecimalCount = exports.getDecimalCount = function getDecimalCount(format, DECIMAL_COUNT_MAP) {
+  return DECIMAL_COUNT_MAP[format] || 0;
+};
+var isPercentageValue = exports.isPercentageValue = function isPercentageValue(value) {
+  return value.includes("%");
+};
+var findValueOf = exports.findValueOf = function findValueOf(datum, key) {
+  return datum[key] !== undefined ? datum[key] : datum;
+};
+var parseNumber = exports.parseNumber = function parseNumber(val) {
+  return Number.parseFloat(val) || NaN;
+};
+var formatFinancialValue = exports.formatFinancialValue = function formatFinancialValue(value, decimalplaces) {
+  var numericValue = value.replace(/[^\d]/g, "");
+  if (!numericValue) return "";
+  var num = Number.parseInt(numericValue, 10) / Math.pow(10, decimalplaces);
+  return new Intl.NumberFormat("en-US", {
+    minimumFractionDigits: decimalplaces,
+    maximumFractionDigits: decimalplaces
+  }).format(num);
+};
+var formatNumberWithCommas = exports.formatNumberWithCommas = function formatNumberWithCommas(value, trailingzero, decimalplaces) {
+  if (!value && value !== 0) return "";
+  if (trailingzero && typeof value === "string") {
+    // When trailingzero is true, preserve the original string format
+    var _num = Number(value.replace(/,/g, ""));
+    if (isNaN(_num)) return "";
+
+    // If the string has decimal places, preserve them with commas in integer part
+    if (value.includes(".")) {
+      var _value$split = value.split("."),
+        _value$split2 = (0, _slicedToArray2["default"])(_value$split, 2),
+        intPart = _value$split2[0],
+        decPart = _value$split2[1];
+      var intWithCommas = new Intl.NumberFormat("en-US").format(Number(intPart));
+      return "".concat(intWithCommas, ".").concat(decPart);
+    } else {
+      return new Intl.NumberFormat("en-US").format(_num);
+    }
+  }
+  var num = typeof value === "string" ? Number(value.toString().replace(/,/g, "")) : value;
+  if (isNaN(num)) return "";
+  if (trailingzero && decimalplaces !== undefined && decimalplaces > 0) {
+    // Show trailing zeros with specified decimal places
+    return new Intl.NumberFormat("en-US", {
+      minimumFractionDigits: decimalplaces,
+      maximumFractionDigits: decimalplaces
+    }).format(num);
+  } else {
+    return new Intl.NumberFormat("en-US").format(num);
+  }
+};
+var getValueInRange = exports.getValueInRange = function getValueInRange(value, minvalue, maxvalue) {
+  if (!isNaN(minvalue) && value < minvalue) {
+    return minvalue;
+  }
+  if (!isNaN(maxvalue) && value > maxvalue) {
+    return maxvalue;
+  }
+  return value;
+};
+
+// Helper function to round value based on step decimal places
+var roundToStep = exports.roundToStep = function roundToStep(value, step, decimalplaces) {
+  var _step$toString$split$;
+  if (step === 0) return value;
+  var stepDecimals = step.toString().includes(".") ? ((_step$toString$split$ = step.toString().split(".")[1]) === null || _step$toString$split$ === void 0 ? void 0 : _step$toString$split$.length) || 0 : 0;
+  var factor = Math.pow(10, Math.max(stepDecimals, decimalplaces));
+  return Math.round(value * factor) / factor;
+};
+
+// Handle step value calculation for increment/decrement operations
+var handleStepValue = exports.handleStepValue = function handleStepValue(currentValue, direction, step, decimalplaces, minvalue, maxvalue) {
+  if (step === 0) {
+    return currentValue || 0;
+  }
+
+  // Calculate new value based on step
+  var newValue;
+  if (currentValue === null || currentValue === undefined || isNaN(currentValue)) {
+    newValue = getValueInRange(minvalue || 0, minvalue || 0, maxvalue || 0);
+  } else {
+    var stepAmount = direction === "UP" ? step : -step;
+    newValue = getValueInRange(currentValue + stepAmount, minvalue || 0, maxvalue || 0);
+  }
+
+  // Round to appropriate decimal places
+  return roundToStep(newValue, step, decimalplaces);
+};
+
+// Common validation function for both currency and number widgets
+var validateNumericValue = exports.validateNumericValue = function validateNumericValue(value, required, minvalue, maxvalue, regexp) {
+  if (!value && required) {
+    return {
+      isValid: false,
+      message: "This field is required"
+    };
+  }
+  var numValue = typeof value === "string" ? parseNumber(value) : value;
+  if (!numValue && required) {
+    return {
+      isValid: false,
+      message: "This field is required"
+    };
+  }
+  if (!numValue) {
+    return {
+      isValid: !required,
+      message: required ? "This field is required" : ""
+    };
+  }
+
+  // Regex validation (mainly for number widget)
+  if (regexp && !RegExp(regexp).test(numValue.toString())) {
+    return {
+      isValid: false,
+      message: "Invalid number format"
+    };
+  }
+  if (minvalue !== undefined && numValue < minvalue) {
+    return {
+      isValid: false,
+      message: "Value must be at least ".concat(minvalue)
+    };
+  }
+  if (maxvalue !== undefined && numValue > maxvalue) {
+    return {
+      isValid: false,
+      message: "Value must not exceed ".concat(maxvalue)
+    };
+  }
+  return {
+    isValid: true,
+    message: ""
+  };
+};
+
+// Common input change handler for both widgets
+var handleNumericInputChange = exports.handleNumericInputChange = function handleNumericInputChange(inputValue, inputmode, decimalplaces, setRawInputValue) {
+  var processedInputValue = inputValue;
+  var newVal;
+  if (inputmode === "financial") {
+    var digitsOnly = inputValue.replace(/[^\d]/g, "");
+    if (digitsOnly === "") {
+      processedInputValue = "";
+      newVal = null;
+      setRawInputValue("");
+    } else {
+      var divisor = Math.pow(10, decimalplaces);
+      newVal = parseInt(digitsOnly) / divisor;
+      if (decimalplaces > 0) {
+        processedInputValue = newVal.toFixed(decimalplaces);
+      } else {
+        processedInputValue = newVal.toString();
+      }
+      setRawInputValue(processedInputValue);
+    }
+  } else {
+    // Basic validation for decimal input
+    if (decimalplaces > 0) {
+      // Allow digits, one dot, and basic decimal formatting
+      var _cleanValue = inputValue.replace(/[^\d.-]/g, "");
+      var dotCount = (_cleanValue.match(/\./g) || []).length;
+
+      // Prevent multiple dots
+      if (dotCount > 1) {
+        return {
+          inputValue: inputValue,
+          newVal: null
+        };
+      }
+
+      // Prevent decimal places beyond the limit
+      var _cleanValue$split = _cleanValue.split("."),
+        _cleanValue$split2 = (0, _slicedToArray2["default"])(_cleanValue$split, 2),
+        intPart = _cleanValue$split2[0],
+        _cleanValue$split2$ = _cleanValue$split2[1],
+        decPart = _cleanValue$split2$ === void 0 ? "" : _cleanValue$split2$;
+      if (decPart && decPart.length > decimalplaces) {
+        return {
+          inputValue: inputValue,
+          newVal: null
+        };
+      }
+      processedInputValue = _cleanValue;
+    }
+
+    // Remove commas for processing but keep original input for display
+    var cleanValue = processedInputValue.replace(/,/g, "");
+    if (cleanValue === "" || cleanValue === "-") {
+      newVal = null;
+      setRawInputValue(cleanValue);
+    } else {
+      // Convert to number for validation and calculations
+      newVal = Number(cleanValue);
+      if (isNaN(newVal)) {
+        return {
+          inputValue: inputValue,
+          newVal: null
+        };
+      }
+
+      // Store raw input value to preserve trailing zeros
+      setRawInputValue(cleanValue);
+    }
+
+    // Don't format during typing - keep original input
+    processedInputValue = inputValue;
+  }
+  return {
+    inputValue: processedInputValue,
+    newVal: newVal
+  };
+};
+
+// Common blur formatting function
+var formatOnBlur = exports.formatOnBlur = function formatOnBlur(datavalue, rawInputValue, trailingzero, decimalplaces) {
+  if (datavalue !== null) {
+    if (trailingzero) {
+      // Use the raw input value to preserve trailing zeros
+      return formatNumberWithCommas(rawInputValue, trailingzero, decimalplaces);
+    } else {
+      return formatNumberWithCommas(datavalue);
+    }
+  }
+  return "";
+};
+
+// Common validated value update function
+var handleValidatedValueUpdate = exports.handleValidatedValueUpdate = function handleValidatedValueUpdate(value, name, inputElCurrent, onChangeProp, listenerProp, prevDatavalueState, setPrevDatavalueState, widgetProps) {
+  var stringifiedValue = value === null ? "" : value.toString();
+  var widgetInfo = name && listenerProp !== null && listenerProp !== void 0 && listenerProp.Widgets ? listenerProp.Widgets[name] : undefined;
+  if (onChangeProp) {
+    var syntheticEvent = {
+      target: {
+        value: stringifiedValue,
+        name: name
+      },
+      currentTarget: inputElCurrent
+    };
+    onChangeProp(syntheticEvent, widgetInfo || widgetProps, value, prevDatavalueState);
+  }
+  if (listenerProp !== null && listenerProp !== void 0 && listenerProp.onChange) {
+    listenerProp.onChange(name, _objectSpread(_objectSpread({}, widgetInfo || {}), {}, {
+      datavalue: stringifiedValue
+    }));
+  }
+  setPrevDatavalueState(value);
+};

package/utils/page-params-util.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeMergedPageParams = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+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; }
+var computeMergedPageParams = exports.computeMergedPageParams = function computeMergedPageParams(urlParams, options) {
+  var _ref = options || {},
+    componentType = _ref.componentType,
+    props = _ref.props;
+  if (componentType === "PARTIAL") {
+    var partialParams = {};
+    Object.keys(props || {}).forEach(function (k) {
+      // Including all incoming props as partial params
+      partialParams[k] = props[k];
+    });
+    return _objectSpread(_objectSpread({}, urlParams), partialParams);
+  }
+  return urlParams;
+};

package/utils/resource-url.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prefixPrefabResourceUrl = prefixPrefabResourceUrl;
+function prefixPrefabResourceUrl(source, prefabName) {
+  if (!source) return source;
+  var trimmed = source.trim();
+
+  // Skip if absolute http(s) URL or starts with data: or blob:
+  var lower = trimmed.toLowerCase();
+  if (lower.startsWith("http://") || lower.startsWith("https://") || lower.startsWith("data:") || lower.startsWith("blob:")) {
+    return source;
+  }
+
+  // Only process if starts with resources/ and prefabName exists
+  if (!prefabName) return source;
+  if (!trimmed.startsWith("resources/")) return source;
+
+  // If already prefixed with prefabName/, avoid double prefixing
+  var prefabPrefix = "".concat(prefabName, "/");
+  if (trimmed.startsWith(prefabPrefix)) return source;
+
+  // concadinating the prefabName with scr path like  Port_In_PreCheck + /resources/images/imagelists/bring_your_phone.png
+  return "".concat(prefabName, "/").concat(trimmed);
+}