@wavemaker/react-runtime 11.14.1-rc.241 → 11.14.2-1.6423

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wavemaker/react-runtime",
-  "version": "11.14.1-rc.241",
+  "version": "11.14.2-1.6423",
   "description": "React runtime package for Wavemaker",
   "license": "MIT",
   "repository": {
@@ -45,7 +45,7 @@
     "@mui/icons-material": "6.3.1",
     "@mui/material": "6.3.1",
     "@mui/x-date-pickers": "^8.5.3",
-    "@reduxjs/toolkit": "^2.6.1",
+    "@reduxjs/toolkit": "2.9.1",
     "@tanstack/react-table": "^8.21.3",
     "axios": "^1.7.9",
     "dompurify": "^3.2.3",
@@ -78,7 +78,7 @@
     "@types/react": "^19",
     "@types/react-color": "^3.0.13",
     "@types/react-dom": "^19",
-    "@wavemaker/variables": "11.14.1-rc.241",
+    "@wavemaker/variables": "11.14.2-1.6423",
     "babel-plugin-module-resolver": "^5.0.2",
     "eslint": "^9",
     "eslint-config-next": "15.1.4",

package/store/index.js

@@ -28,6 +28,10 @@ var store = exports.store = (0, _toolkit.configureStore)({
     });
   }
 });
-(0, _query.setupListeners)(store.dispatch);
+
+// Only setup listeners on the client side (not during SSR)
+if (typeof window !== "undefined") {
+  (0, _query.setupListeners)(store.dispatch);
+}
 var useAppDispatch = exports.useAppDispatch = _reactRedux.useDispatch;
 var useAppSelector = exports.useAppSelector = _reactRedux.useSelector;

package/utils/lib-error-skipper.js

@@ -0,0 +1,196 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapWithThirdPartyErrorGuard = exports.isJQueryError = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Utility to wrap all methods in a script object with jQuery error handling
+ * This prevents jQuery usage from breaking the React application
+ */
+
+/**
+ * Configuration for unsupported libraries
+ */
+
+var UNSUPPORTED_LIBRARIES = {
+  jquery: {
+    identifiers: ["jQuery", "$"],
+    errorMessage: "jQuery is not supported in React App",
+    notificationMessage: "jQuery functionality is not supported. Check console for details."
+  }
+  // Add more libraries here in future
+};
+
+/**
+ * Result of unsupported library detection
+ */
+
+/**
+ * Detects if an error is related to any unsupported library
+ * @param error - The error object to check
+ * @returns Object with isUnsupported flag and library info
+ */
+function detectUnsupportedLibrary(error) {
+  if (!error || !error.stack) {
+    return {
+      isUnsupported: false,
+      library: null
+    };
+  }
+  var errorMessage = error.message || "";
+  var stackTrace = String(error.stack);
+
+  // Check each configured library
+  for (var _i = 0, _Object$entries = Object.entries(UNSUPPORTED_LIBRARIES); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = (0, _slicedToArray2["default"])(_Object$entries[_i], 2),
+      libraryName = _Object$entries$_i[0],
+      config = _Object$entries$_i[1];
+    var identifiers = config.identifiers;
+
+    // Check if error message contains library identifiers
+    if (identifiers.some(function (identifier) {
+      return errorMessage.includes(identifier);
+    })) {
+      return {
+        isUnsupported: true,
+        library: libraryName,
+        config: config
+      };
+    }
+
+    // Check if stack trace contains library identifiers
+    var stackLines = stackTrace.split("\n");
+    var _iterator = _createForOfIteratorHelper(stackLines),
+      _step;
+    try {
+      var _loop = function _loop() {
+          var line = _step.value;
+          if (identifiers.some(function (identifier) {
+            return line.includes(identifier);
+          })) {
+            return {
+              v: {
+                isUnsupported: true,
+                library: libraryName,
+                config: config
+              }
+            };
+          }
+        },
+        _ret;
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        _ret = _loop();
+        if (_ret) return _ret.v;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return {
+    isUnsupported: false,
+    library: null
+  };
+}
+
+/**
+ * Checks if an error is related to jQuery usage
+ * @param error - The error object to check
+ * @returns true if the error is jQuery-related
+ */
+var isJQueryError = exports.isJQueryError = function isJQueryError(error) {
+  if (!(error !== null && error !== void 0 && error.stack)) return false;
+  var UnSupportedFunctionality = ["jQuery", "$"];
+
+  // Check if error message contains jQuery references
+  if (error.message && UnSupportedFunctionality.some(function (func) {
+    return error.message.includes(func);
+  })) {
+    return true;
+  }
+
+  // Check stack trace for jQuery references
+  var stackLines = error.stack.split("\n");
+  var _iterator2 = _createForOfIteratorHelper(stackLines),
+    _step2;
+  try {
+    var _loop2 = function _loop2() {
+        var line = _step2.value;
+        if (UnSupportedFunctionality.some(function (func) {
+          return line.includes(func);
+        })) {
+          return {
+            v: true
+          };
+        }
+      },
+      _ret2;
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      _ret2 = _loop2();
+      if (_ret2) return _ret2.v;
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return false;
+};
+/**
+ * Wraps all methods with unsupported library error handling
+ * @param pageProxy - The page/prefab proxy object
+ * @param appContext - App context for notifications
+ * @param componentName - Name of component for logging
+ * @param libraryConfig - Optional: specific libraries to check (default: all)
+ */
+var wrapWithThirdPartyErrorGuard = exports.wrapWithThirdPartyErrorGuard = function wrapWithThirdPartyErrorGuard(pageProxy, appContext, componentName) {
+  var libraryConfig = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : UNSUPPORTED_LIBRARIES;
+  var skipProperties = ["Variables", "Actions", "Widgets", "App", "pageParams", "serviceDefinitions", "baseUrl", "appConfig", "notification", "toaster", "onContentReady", "onChange", "cleanup", "eval", "appLocale", "executeStartup", "formatters", "type", "componentName", "componentType", "prefabname", "onPropertyChange"];
+  Object.keys(pageProxy).forEach(function (methodName) {
+    if (typeof pageProxy[methodName] === "function" && !skipProperties.includes(methodName)) {
+      var originalMethod = pageProxy[methodName];
+      pageProxy[methodName] = function () {
+        try {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          return originalMethod.apply(this, args);
+        } catch (error) {
+          // Detect which unsupported library caused the error
+          var detection = detectUnsupportedLibrary(error);
+          if (detection.isUnsupported && detection.library && detection.config) {
+            var library = detection.library;
+            var config = detection.config;
+
+            // Log detailed error
+            console.error("[".concat(library.toUpperCase(), " ERROR] in ").concat(componentName, ".").concat(methodName, "()"), "\n".concat(config.errorMessage), "\nError:", error);
+
+            // Show user notification
+            if (appContext !== null && appContext !== void 0 && appContext.notifyApp) {
+              appContext.notifyApp(config.notificationMessage, "Error");
+            }
+
+            // Return undefined to prevent further errors
+            return undefined;
+          } else {
+            // Not an unsupported library error - log normally
+            console.log("Error in ".concat(componentName, ".").concat(methodName, "():"));
+          }
+        }
+      };
+
+      // Preserve function name for debugging
+      Object.defineProperty(pageProxy[methodName], "name", {
+        value: "wrapped_".concat(methodName),
+        writable: false
+      });
+    }
+  });
+};

package/variables/service-variable.js

@@ -89,6 +89,7 @@ var ServiceVariable = exports.ServiceVariable = /*#__PURE__*/function (_ServiceV
     (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "cancelTokenSource", void 0);
     (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "initialized", false);
     (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "params", undefined);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "lastInvokedParams", undefined);
     _this.setupEventHandlers(config);
     return _this;
   }
@@ -164,18 +165,20 @@ var ServiceVariable = exports.ServiceVariable = /*#__PURE__*/function (_ServiceV
     value: function () {
       var _invokeOnParamChange = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
         var _this2 = this;
-        var last, latest;
+        var latest, last;
         return _regenerator["default"].wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
-              last = this.params;
-              latest = (0, _lodashEs.merge)({}, this.config.paramProvider(), this.dataBinding);
+              latest = (0, _lodashEs.merge)({}, this.config.paramProvider(), this.params || {}, this.dataBinding);
+              last = this.lastInvokedParams || {};
               if (!(!(0, _lodashEs.isEqual)(last, latest) && latest !== undefined && !(0, _lodashEs.isEmpty)(latest))) {
-                _context3.next = 11;
+                _context3.next = 12;
                 break;
               }
-              _context3.prev = 3;
-              _context3.next = 6;
+              // Update lastInvokedParams to reflect the merged values
+              this.lastInvokedParams = (0, _common.deepCopy)({}, latest);
+              _context3.prev = 4;
+              _context3.next = 7;
               return new Promise(function (resolve, reject) {
                 _this2.invoke(latest, function (data) {
                   return resolve(data);
@@ -183,20 +186,20 @@ var ServiceVariable = exports.ServiceVariable = /*#__PURE__*/function (_ServiceV
                   return reject(error);
                 });
               });
-            case 6:
-              _context3.next = 11;
+            case 7:
+              _context3.next = 12;
               break;
-            case 8:
-              _context3.prev = 8;
-              _context3.t0 = _context3["catch"](3);
+            case 9:
+              _context3.prev = 9;
+              _context3.t0 = _context3["catch"](4);
               console.error("Error in invokeOnParamChange:", _context3.t0);
-            case 11:
-              return _context3.abrupt("return", this);
             case 12:
+              return _context3.abrupt("return", this);
+            case 13:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this, [[3, 8]]);
+        }, _callee3, this, [[4, 9]]);
       }));
       function invokeOnParamChange() {
         return _invokeOnParamChange.apply(this, arguments);