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

package/hooks/useHttp.js

@@ -0,0 +1,531 @@
+"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.getHttpService = 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 axiosModule = _axios;
+var _constants = require("@wavemaker-ai/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; }
+var axios = axiosModule["default"] || axiosModule;
+
+// @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);
+    (0, _defineProperty2["default"])(this, "_context", null);
+    (0, _defineProperty2["default"])(this, "localeObject", _store.store.getState().i18n.appLocale);
+    this.axiosInstance = axios.create({
+      baseURL: baseURL
+    });
+    this.setupInterceptors();
+  }
+
+  /**
+   * Set the current context (page/component context)
+   * @param context - The context object to store
+   */
+  return (0, _createClass2["default"])(ModernHttpService, [{
+    key: "setContext",
+    value: function setContext(context) {
+      this._context = context;
+    }
+
+    /**
+     * Get the currently stored context
+     * @returns The stored context object
+     */
+  }, {
+    key: "getContext",
+    value: function getContext() {
+      return this._context;
+    }
+  }, {
+    key: "getAppManager",
+    value: function getAppManager() {
+      var _ref, _currentContext$App;
+      var currentContext = this.getContext();
+      return (_ref = (_currentContext$App = currentContext === null || currentContext === void 0 ? void 0 : currentContext.App) !== null && _currentContext$App !== void 0 ? _currentContext$App : currentContext) !== null && _ref !== void 0 ? _ref : {};
+    }
+  }, {
+    key: "setupInterceptors",
+    value: function setupInterceptors() {
+      var _this = this;
+      this.axiosInstance.interceptors.request.use(/*#__PURE__*/function () {
+        var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(config) {
+          var _state$info, _config$withCredentia, _config$url;
+          var appManager, state, token, baseUrl, headers, wmVariable, isFileDownload, modifiedReq;
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                appManager = _this.getAppManager(); // Create new headers instance
+                state = _store.store.getState();
+                token = state.auth.token;
+                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) || "";
+                headers = new _axios.AxiosHeaders(config.headers); // Check if this is a file download operation
+                wmVariable = config.__wmVariable;
+                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;
+                }
+
+                // Call onBeforeServiceCall if available - wait for promise to resolve
+                // This allows the app to modify the request config before it's sent
+                if (!(appManager && appManager.onBeforeServiceCall)) {
+                  _context.next = 22;
+                  break;
+                }
+                _context.prev = 12;
+                _context.next = 15;
+                return appManager.onBeforeServiceCall(config);
+              case 15:
+                modifiedReq = _context.sent;
+                if (modifiedReq) {
+                  config = modifiedReq;
+                }
+                _context.next = 22;
+                break;
+              case 19:
+                _context.prev = 19;
+                _context.t0 = _context["catch"](12);
+                console.error("Error in onBeforeServiceCall:", _context.t0);
+                // Continue with original config if the callback fails
+              case 22:
+                return _context.abrupt("return", config);
+              case 23:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee, null, [[12, 19]]);
+        }));
+        return function (_x) {
+          return _ref2.apply(this, arguments);
+        };
+      }(), function (error) {
+        return Promise.reject(error);
+      });
+      this.axiosInstance.interceptors.response.use(/*#__PURE__*/function () {
+        var _ref3 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(response) {
+          var appManager, modifiedResponse, modifiedResp;
+          return _regenerator["default"].wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                appManager = _this.getAppManager();
+                modifiedResponse = _objectSpread(_objectSpread({}, response), {}, {
+                  body: response.data,
+                  type: 4 // mimic Angular's HttpEventType.Response
+                }); // Call appOnServiceSuccess if available - similar to Angular's tap operator
+                if (!(appManager && appManager.onServiceSuccess)) {
+                  _context2.next = 13;
+                  break;
+                }
+                _context2.prev = 3;
+                _context2.next = 6;
+                return appManager.onServiceSuccess(modifiedResponse.body, modifiedResponse);
+              case 6:
+                modifiedResp = _context2.sent;
+                if (modifiedResp) {
+                  modifiedResponse = _objectSpread(_objectSpread({}, modifiedResponse), modifiedResp);
+                }
+                _context2.next = 13;
+                break;
+              case 10:
+                _context2.prev = 10;
+                _context2.t0 = _context2["catch"](3);
+                console.error("Error in onServiceSuccess:", _context2.t0);
+              case 13:
+                return _context2.abrupt("return", modifiedResponse);
+              case 14:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2, null, [[3, 10]]);
+        }));
+        return function (_x2) {
+          return _ref3.apply(this, arguments);
+        };
+      }(), /*#__PURE__*/function () {
+        var _ref4 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(error) {
+          var _error$response;
+          var appManager, errorResponse, _errorResponse, _errorResponse2, _errorResponse3, errorMessage, modifiedResp;
+          return _regenerator["default"].wrap(function _callee3$(_context3) {
+            while (1) switch (_context3.prev = _context3.next) {
+              case 0:
+                appManager = _this.getAppManager();
+                errorResponse = error.response || error; // Handle 401 session timeout if needed
+                if (((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) === 401) {
+                  // Session timeout handling can be added here
+                }
+
+                // Call appOnServiceError if available
+                if (!(appManager && appManager.onServiceError)) {
+                  _context3.next = 16;
+                  break;
+                }
+                _context3.prev = 4;
+                errorMessage = ((_errorResponse = errorResponse) === null || _errorResponse === void 0 || (_errorResponse = _errorResponse.data) === null || _errorResponse === void 0 ? void 0 : _errorResponse.message) || ((_errorResponse2 = errorResponse) === null || _errorResponse2 === void 0 ? void 0 : _errorResponse2.message) || "Unknown error";
+                errorResponse.error = ((_errorResponse3 = errorResponse) === null || _errorResponse3 === void 0 ? void 0 : _errorResponse3.data) || errorResponse;
+                _context3.next = 9;
+                return appManager.onServiceError(errorMessage, errorResponse);
+              case 9:
+                modifiedResp = _context3.sent;
+                if (modifiedResp) {
+                  errorResponse = _objectSpread(_objectSpread({}, errorResponse), modifiedResp);
+                }
+                _context3.next = 16;
+                break;
+              case 13:
+                _context3.prev = 13;
+                _context3.t0 = _context3["catch"](4);
+                console.error("Error in onServiceError:", _context3.t0);
+              case 16:
+                throw errorResponse;
+              case 17:
+              case "end":
+                return _context3.stop();
+            }
+          }, _callee3, null, [[4, 13]]);
+        }));
+        return function (_x3) {
+          return _ref4.apply(this, arguments);
+        };
+      }());
+    }
+  }, {
+    key: "send",
+    value: function () {
+      var _send = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(options, variable) {
+        var serviceInfo, headers, requestBody, url, _serviceInfo$proxySet, isProxyCall, _options$url$replace, methodType, isNonDataMethod, axiosConfig, response;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              serviceInfo = variable.serviceInfo;
+              headers = new _axios.AxiosHeaders(options.headers);
+              requestBody = options.data;
+              variable.cancelTokenSource = axios.CancelToken.source();
+              url = options.url;
+              if (serviceInfo) {
+                serviceInfo.proxySettings = (serviceInfo === null || serviceInfo === void 0 ? void 0 : serviceInfo.proxySettings) || {
+                  web: true
+                };
+                isProxyCall = serviceInfo === null || serviceInfo === void 0 || (_serviceInfo$proxySet = serviceInfo.proxySettings) === null || _serviceInfo$proxySet === void 0 ? void 0 : _serviceInfo$proxySet.web;
+                url = isProxyCall ? options.url : serviceInfo === null || serviceInfo === void 0 ? void 0 : serviceInfo.directPath;
+              }
+              if (variable.category === "wm.CrudVariable") {
+                if (url.startsWith("http://") || url.startsWith("https://")) {
+                  url = url;
+                } else {
+                  url = variable.config.baseUrl + options.url.replace(".//", "/").replace("./", "/");
+                }
+              } else if (variable.category === "wm.LiveVariable" && !(url.startsWith("http://") || url.startsWith("https://"))) {
+                url = variable.config.baseUrl + options.url.replace("./", "/");
+              } else if (url === (serviceInfo === null || serviceInfo === void 0 ? void 0 : serviceInfo.directPath) && 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;
+              }
+              _context4.prev = 13;
+              _context4.next = 16;
+              return this.axiosInstance.request(axiosConfig);
+            case 16:
+              response = _context4.sent;
+              if (!(variable.operation === "getDownloadFile" || (serviceInfo === null || serviceInfo === void 0 ? void 0 : serviceInfo.operationId) === "FileController_getDownloadFile")) {
+                _context4.next = 19;
+                break;
+              }
+              return _context4.abrupt("return", this.handleFileDownload(response, options, variable));
+            case 19:
+              return _context4.abrupt("return", response);
+            case 22:
+              _context4.prev = 22;
+              _context4.t0 = _context4["catch"](13);
+              throw _context4.t0.response || _context4.t0;
+            case 25:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this, [[13, 22]]);
+      }));
+      function send(_x4, _x5) {
+        return _send.apply(this, arguments);
+      }
+      return send;
+    }()
+  }, {
+    key: "sendCall",
+    value: function () {
+      var _sendCall = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5(requestParams, variable) {
+        var response;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.prev = 0;
+              _context5.next = 3;
+              return this.send(requestParams, variable);
+            case 3:
+              response = _context5.sent;
+              return _context5.abrupt("return", response);
+            case 7:
+              _context5.prev = 7;
+              _context5.t0 = _context5["catch"](0);
+              throw _context5.t0;
+            case 10:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this, [[0, 7]]);
+      }));
+      function sendCall(_x6, _x7) {
+        return _sendCall.apply(this, arguments);
+      }
+      return sendCall;
+    }()
+  }, {
+    key: "setLocale",
+    value: function setLocale(locale) {
+      this.localeObject = locale;
+    }
+  }, {
+    key: "getLocale",
+    value: function getLocale() {
+      return this.localeObject;
+    }
+  }, {
+    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 _callee6(url, data, variable, options) {
+        var _this2 = this;
+        var requestParams;
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.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 _context6.abrupt("return", new Promise(function (resolve, reject) {
+                variable.request = _this2.send(requestParams, variable).then(function (event) {
+                  resolve(event.data);
+                })["catch"](function (error) {
+                  reject(error);
+                });
+              }));
+            case 5:
+              _context6.prev = 5;
+              _context6.t0 = _context6["catch"](0);
+              console.error("Unexpected error in uploadFile:", _context6.t0);
+              throw _context6.t0;
+            case 9:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, null, [[0, 5]]);
+      }));
+      function uploadFile(_x8, _x9, _x0, _x1) {
+        return _uploadFile.apply(this, arguments);
+      }
+      return uploadFile;
+    }()
+  }]);
+}(); // Create Context
+var HttpContext = /*#__PURE__*/(0, _react.createContext)(null);
+
+// Provider Component
+var HttpProvider = exports.HttpProvider = function HttpProvider(_ref5) {
+  var children = _ref5.children,
+    _ref5$baseURL = _ref5.baseURL,
+    baseURL = _ref5$baseURL === void 0 ? "" : _ref5$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),
+      setContext: httpService.current.setContext.bind(httpService.current),
+      getContext: httpService.current.getContext.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;
+};
+
+// Lazy singleton - only created when first accessed
+var _httpService = null;
+var getHttpService = exports.getHttpService = function getHttpService() {
+  if (!_httpService) {
+    _httpService = new ModernHttpService();
+  }
+  return _httpService;
+};
+
+// For backward compatibility - use getter pattern
+var httpService = exports.httpService = {
+  get instance() {
+    return getHttpService();
+  },
+  send: function send() {
+    var _getHttpService;
+    return (_getHttpService = getHttpService()).send.apply(_getHttpService, arguments);
+  },
+  sendCall: function sendCall() {
+    var _getHttpService2;
+    return (_getHttpService2 = getHttpService()).sendCall.apply(_getHttpService2, arguments);
+  },
+  cancel: function cancel() {
+    var _getHttpService3;
+    return (_getHttpService3 = getHttpService()).cancel.apply(_getHttpService3, arguments);
+  },
+  uploadFile: function uploadFile() {
+    var _getHttpService4;
+    return (_getHttpService4 = getHttpService()).uploadFile.apply(_getHttpService4, arguments);
+  },
+  setLocale: function setLocale() {
+    var _getHttpService5;
+    return (_getHttpService5 = getHttpService()).setLocale.apply(_getHttpService5, arguments);
+  },
+  getLocale: function getLocale() {
+    return getHttpService().getLocale();
+  },
+  setContext: function setContext() {
+    var _getHttpService6;
+    return (_getHttpService6 = getHttpService()).setContext.apply(_getHttpService6, arguments);
+  },
+  getContext: function getContext() {
+    return getHttpService().getContext();
+  }
+};
+var _default = exports["default"] = httpService;

package/libs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "moment", {
+  enumerable: true,
+  get: function get() {
+    return _moment["default"];
+  }
+});
+var _moment = _interopRequireDefault(require("moment"));

package/libs/prefab/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-ai/react-runtime/core/util/utils");
+var _qrcodejs = _interopRequireDefault(require("qrcodejs2"));

package/mui-config/theme-provider.d.ts

@@ -0,0 +1,3 @@
+export declare const WmThemeProvider: React.FC<{
+    children: React.ReactNode;
+}>;

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-ai/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"]
+  }, children);
+};

package/mui-config/theme.d.ts

@@ -0,0 +1,2 @@
+declare const theme: import("@mui/material").Theme;
+export default theme;