@wavemaker/react-runtime 11.14.1-rc.236

package/hooks/useDebounce.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDebounceCallback = exports.debounce = void 0;
+var _react = require("react");
+/**
+ * A hook that returns a debounced version of the provided callback function.
+ * The callback will only be executed after the specified delay has passed since the last invocation.
+ *
+ * @param callback - The function to debounce
+ * @param delay - The delay in milliseconds
+ * @returns A debounced version of the callback function with a cancel method
+ */
+var useDebounceCallback = exports.useDebounceCallback = function useDebounceCallback(callback, delay) {
+  var timeoutRef = (0, _react.useRef)(null);
+  var debouncedCallback = (0, _react.useCallback)(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    // Clear the previous timeout if it exists
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+
+    // Set a new timeout
+    timeoutRef.current = setTimeout(function () {
+      callback.apply(void 0, args);
+      timeoutRef.current = null;
+    }, delay);
+  }, [callback, delay]);
+
+  // Add cancel method to the debounced function
+  var cancel = (0, _react.useCallback)(function () {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+
+  // Attach cancel method to the debounced function
+  debouncedCallback.cancel = cancel;
+  return debouncedCallback;
+};
+
+/**
+ * A simpler debounce utility function that can be used outside of React components
+ *
+ * @param func - The function to debounce
+ * @param delay - The delay in milliseconds
+ * @returns A debounced version of the function with a cancel method
+ */
+var debounce = exports.debounce = function debounce(func, delay) {
+  var timeoutId = null;
+  var debouncedFunction = function debouncedFunction() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(function () {
+      func.apply(void 0, args);
+      timeoutId = null;
+    }, delay);
+  };
+  var cancel = function cancel() {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  debouncedFunction.cancel = cancel;
+  return debouncedFunction;
+};

package/hooks/useDeviceVisibility.js

@@ -0,0 +1,49 @@
+"use strict";
+"use client";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDeviceVisibility = void 0;
+var _react = require("react");
+var useDeviceVisibility = exports.useDeviceVisibility = function useDeviceVisibility(devices) {
+  var _useState = (0, _react.useState)(typeof window !== "undefined" ? window.innerWidth : undefined),
+    windowSize = _useState[0],
+    setWindowSize = _useState[1];
+  var checkIsHidden = function checkIsHidden() {
+    if (!windowSize) return false;
+    if (!devices || devices.length === 0 || devices.includes("all")) {
+      return false;
+    }
+    if (windowSize <= 767) {
+      // Mobile
+      return !devices.includes("xs");
+    }
+    if (windowSize >= 768 && windowSize <= 991) {
+      // Tablet
+      return !devices.includes("sm");
+    }
+    if (windowSize >= 992 && windowSize <= 1199) {
+      // Small Desktop
+      return !devices.includes("md");
+    }
+    if (windowSize >= 1200) {
+      // Large Desktop
+      return !devices.includes("lg");
+    }
+    return false;
+  };
+  (0, _react.useEffect)(function () {
+    var handleResize = function handleResize() {
+      setWindowSize(window.innerWidth);
+    };
+    window.addEventListener("resize", handleResize);
+    return function () {
+      return window.removeEventListener("resize", handleResize);
+    };
+  }, []);
+  return {
+    isHidden: checkIsHidden(),
+    windowSize: windowSize
+  };
+};

package/hooks/useHttp.js

@@ -0,0 +1,338 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useHttp = exports.httpService = exports["default"] = exports.HttpProvider = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _axios = _interopRequireWildcard(require("axios"));
+var _constants = require("@wavemaker/react-runtime/variables/constants");
+var _store = require("../store");
+var _authSlice = require("../store/slices/authSlice");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+var __jsx = _react["default"].createElement;
+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; } // @ts-ignore
+// Types
+// Create the HTTP service class implementing HttpClientService
+var ModernHttpService = /*#__PURE__*/function () {
+  function ModernHttpService() {
+    var baseURL = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+    (0, _classCallCheck2["default"])(this, ModernHttpService);
+    (0, _defineProperty2["default"])(this, "axiosInstance", void 0);
+    this.axiosInstance = _axios["default"].create({
+      baseURL: baseURL
+    });
+    this.setupInterceptors();
+  }
+  (0, _createClass2["default"])(ModernHttpService, [{
+    key: "setupInterceptors",
+    value: function setupInterceptors() {
+      this.axiosInstance.interceptors.request.use(function (config) {
+        var _state$info, _config$withCredentia, _config$url;
+        // Create new headers instance
+        var state = _store.store.getState();
+        var token = state.auth.token;
+        var baseUrl = ((_state$info = state.info) === null || _state$info === void 0 || (_state$info = _state$info.appConfig) === null || _state$info === void 0 ? void 0 : _state$info.url) || "";
+        var headers = new _axios.AxiosHeaders(config.headers);
+        // Check if this is a file download operation
+        var wmVariable = config.__wmVariable;
+        var isFileDownload = (wmVariable === null || wmVariable === void 0 ? void 0 : wmVariable.operation) === "getDownloadFile";
+
+        // Only set Accept header for non-download operations
+        if (!isFileDownload) {
+          headers.set("Accept", "application/json");
+        }
+        config.headers = headers;
+        config.withCredentials = (_config$withCredentia = config.withCredentials) !== null && _config$withCredentia !== void 0 ? _config$withCredentia : true;
+        if ((_config$url = config.url) !== null && _config$url !== void 0 && _config$url.startsWith(baseUrl) && token) {
+          if (config.headers) config.headers[_authSlice.XSRF_HEADER_NAME] = token;
+        }
+        return config;
+      }, function (error) {
+        return Promise.reject(error);
+      });
+      this.axiosInstance.interceptors.response.use(function (response) {
+        return _objectSpread(_objectSpread({}, response), {}, {
+          body: response.data,
+          type: 4 // mimic Angular's HttpEventType.Response
+        });
+      }, /*#__PURE__*/function () {
+        var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(error) {
+          var _error$response;
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                if (((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) === 401) {}
+                throw error.response || error;
+              case 2:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee);
+        }));
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+    }
+  }, {
+    key: "send",
+    value: function () {
+      var _send = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(options, variable) {
+        var serviceInfo, headers, requestBody, url, _options$url$replace, methodType, isNonDataMethod, axiosConfig, response;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              serviceInfo = variable.serviceInfo;
+              headers = new _axios.AxiosHeaders(options.headers);
+              requestBody = options.data;
+              url = options.url;
+              variable.cancelTokenSource = _axios["default"].CancelToken.source();
+              if (variable.category === "wm.LiveVariable" && !(url.startsWith("http://") || url.startsWith("https://"))) {
+                url = variable.config.baseUrl + options.url.replace("./", "/");
+              } else if (options.isExtURL && options.url.startsWith("http")) {
+                url = options.url;
+              } else {
+                url = variable.config.baseUrl + ((_options$url$replace = options.url.replace("./services", "")) === null || _options$url$replace === void 0 ? void 0 : _options$url$replace.replace("./", "/"));
+              }
+
+              // Ensure all requests are marked as XMLHttpRequest if not a direct call
+              if (!options.isDirectCall) {
+                headers = headers.set("X-Requested-With", "XMLHttpRequest");
+              }
+              methodType = ((serviceInfo === null || serviceInfo === void 0 ? void 0 : serviceInfo.methodType) || options.method || "get").toLowerCase();
+              isNonDataMethod = _constants.WS_CONSTANTS.NON_DATA_AXIOS_METHODS.indexOf(methodType.toUpperCase()) > -1;
+              axiosConfig = _objectSpread(_objectSpread({
+                url: url.endsWith("/") ? url.slice(0, -1) : url,
+                method: methodType,
+                headers: headers,
+                cancelToken: variable.cancelTokenSource.token,
+                withCredentials: (options === null || options === void 0 ? void 0 : options.withCredentials) !== false
+              }, isNonDataMethod ? {} : {
+                data: requestBody || {}
+              }), {}, {
+                __wmVariable: {
+                  name: variable.name,
+                  owner: variable.config._context.name,
+                  operation: variable.operation // Add operation to the context
+                }
+              }); // Set responseType for file download operations to prevent XML parsing errors
+              if (variable.operation === "getDownloadFile" || (serviceInfo === null || serviceInfo === void 0 ? void 0 : serviceInfo.operationId) === "FileController_getDownloadFile") {
+                axiosConfig.responseType = "blob";
+              }
+
+              // Add progress tracking if provided
+              if (options !== null && options !== void 0 && options.onUploadProgress) {
+                axiosConfig.onUploadProgress = options.onUploadProgress;
+              }
+              _context2.prev = 12;
+              _context2.next = 15;
+              return this.axiosInstance.request(axiosConfig);
+            case 15:
+              response = _context2.sent;
+              if (!(variable.operation === "getDownloadFile" || (serviceInfo === null || serviceInfo === void 0 ? void 0 : serviceInfo.operationId) === "FileController_getDownloadFile")) {
+                _context2.next = 18;
+                break;
+              }
+              return _context2.abrupt("return", this.handleFileDownload(response, options, variable));
+            case 18:
+              return _context2.abrupt("return", response);
+            case 21:
+              _context2.prev = 21;
+              _context2.t0 = _context2["catch"](12);
+              throw _context2.t0.response || _context2.t0;
+            case 24:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[12, 21]]);
+      }));
+      function send(_x2, _x3) {
+        return _send.apply(this, arguments);
+      }
+      return send;
+    }()
+  }, {
+    key: "sendCall",
+    value: function () {
+      var _sendCall = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(requestParams, variable) {
+        var response;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return this.send(requestParams, variable);
+            case 3:
+              response = _context3.sent;
+              return _context3.abrupt("return", response);
+            case 7:
+              _context3.prev = 7;
+              _context3.t0 = _context3["catch"](0);
+              throw _context3.t0;
+            case 10:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[0, 7]]);
+      }));
+      function sendCall(_x4, _x5) {
+        return _sendCall.apply(this, arguments);
+      }
+      return sendCall;
+    }()
+  }, {
+    key: "getLocale",
+    value: function getLocale() {
+      return "appLocale";
+    }
+  }, {
+    key: "cancel",
+    value: function cancel(variable) {
+      if (variable.cancelTokenSource) {
+        variable.cancelTokenSource.cancel("Operation cancelled by user");
+      }
+    }
+
+    /**
+     * Handle file download operations with proper filename extraction and blob processing
+     * @param response - Axios response object
+     * @param options - Request options
+     * @param variable - Variable configuration
+     * @returns Modified response object with download success information
+     */
+  }, {
+    key: "handleFileDownload",
+    value: function handleFileDownload(response, options, variable) {
+      var filename = "download";
+      var contentDisposition = response.headers["content-disposition"];
+      if (contentDisposition) {
+        // Simple extraction: look for filename= followed by the value
+        var filenameMatch = contentDisposition.match(/filename[*]?=['"]?([^'";]+)/);
+        if (filenameMatch && filenameMatch[1]) {
+          filename = filenameMatch[1].trim();
+        }
+      }
+
+      // Fallback to URL parameter or variable name
+      if (!filename || filename === "download") {
+        if (options.url && options.url.includes("file=")) {
+          var urlParams = new URLSearchParams(options.url.split("?")[1]);
+          filename = urlParams.get("file") || variable.name || "download";
+        }
+      }
+
+      // Create blob URL and trigger download
+      var blob = response.data; // This should be a blob due to responseType: "blob"
+      var url = URL.createObjectURL(blob);
+      var downloadLink = document.createElement("a");
+      downloadLink.href = url;
+      downloadLink.download = filename;
+      downloadLink.click();
+
+      // Clean up the blob URL
+      URL.revokeObjectURL(url);
+
+      // Return success response for the variable
+      return _objectSpread(_objectSpread({}, response), {}, {
+        data: {
+          success: true,
+          filename: filename,
+          downloaded: true
+        }
+      });
+    }
+  }, {
+    key: "uploadFile",
+    value: function () {
+      var _uploadFile = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(url, data, variable, options) {
+        var _this = this;
+        var requestParams;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.prev = 0;
+              requestParams = {
+                url: url,
+                data: data,
+                // Send individual file
+                method: "POST",
+                headers: new _axios.AxiosHeaders({
+                  "Content-Type": "multipart/form-data"
+                }),
+                onUploadProgress: function onUploadProgress(progressEvent) {
+                  if (progressEvent.total) {
+                    var progress = Math.round(progressEvent.loaded * 100 / progressEvent.total);
+                    options.notify(progress);
+                  }
+                }
+              };
+              return _context4.abrupt("return", new Promise(function (resolve, reject) {
+                variable.request = _this.send(requestParams, variable).then(function (event) {
+                  resolve(event.data);
+                })["catch"](function (error) {
+                  reject(error);
+                });
+              }));
+            case 5:
+              _context4.prev = 5;
+              _context4.t0 = _context4["catch"](0);
+              console.error("Unexpected error in uploadFile:", _context4.t0);
+              throw _context4.t0;
+            case 9:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, null, [[0, 5]]);
+      }));
+      function uploadFile(_x6, _x7, _x8, _x9) {
+        return _uploadFile.apply(this, arguments);
+      }
+      return uploadFile;
+    }()
+  }]);
+  return ModernHttpService;
+}(); // Create Context
+var HttpContext = /*#__PURE__*/(0, _react.createContext)(null);
+
+// Provider Component
+var HttpProvider = exports.HttpProvider = function HttpProvider(_ref2) {
+  var children = _ref2.children,
+    _ref2$baseURL = _ref2.baseURL,
+    baseURL = _ref2$baseURL === void 0 ? "" : _ref2$baseURL;
+  var httpService = (0, _react.useRef)(new ModernHttpService(baseURL));
+  var contextValue = (0, _react.useMemo)(function () {
+    return _objectSpread(_objectSpread({}, httpService.current), {}, {
+      axiosInstance: httpService.current["axiosInstance"],
+      send: httpService.current.send.bind(httpService.current),
+      sendCall: httpService.current.sendCall.bind(httpService.current),
+      cancel: httpService.current.cancel.bind(httpService.current),
+      uploadFile: httpService.current.uploadFile.bind(httpService.current),
+      getLocale: httpService.current.getLocale.bind(httpService.current)
+    });
+  }, []);
+  return __jsx(HttpContext.Provider, {
+    value: contextValue
+  }, children);
+};
+
+// Hook
+var useHttp = exports.useHttp = function useHttp() {
+  var context = (0, _react.useContext)(HttpContext);
+  if (!context) {
+    throw new Error("useHttp must be used within an HttpProvider");
+  }
+  return context;
+};
+
+// Export singleton instance for direct usage
+var httpService = exports.httpService = new ModernHttpService();
+var _default = exports["default"] = httpService;

package/libs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "QRCode", {
+  enumerable: true,
+  get: function get() {
+    return _qrcodejs["default"];
+  }
+});
+Object.defineProperty(exports, "Utils", {
+  enumerable: true,
+  get: function get() {
+    return _utils.Utils;
+  }
+});
+var _utils = require("@wavemaker/react-runtime/core/util/utils");
+var _qrcodejs = _interopRequireDefault(require("qrcodejs2"));

package/mui-config/theme-provider.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WmThemeProvider = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _material = require("@mui/material");
+var _theme = _interopRequireDefault(require("@wavemaker/react-runtime/mui-config/theme"));
+var __jsx = _react["default"].createElement;
+var WmThemeProvider = exports.WmThemeProvider = function WmThemeProvider(_ref) {
+  var children = _ref.children;
+  return __jsx(_material.ThemeProvider, {
+    theme: _theme["default"]
+  }, __jsx(_material.CssBaseline, null), " ", children);
+};