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

package/core/app.service.d.ts

@@ -0,0 +1,19 @@
+export declare function loadWmProperties(baseUrl: string): Promise<any>;
+export declare function getDefaultProperties(): {
+    defaultLanguage: string;
+    defaultTimezone: string;
+};
+/**
+ * Gets the page which needs to be redirected to on successful login
+ * @param config,
+ * @param page, page name for redirection
+ * @returns {any|string}
+ */
+export declare const getCurrentRouteQueryParam: (paramName: string) => string | null;
+export declare const getRedirectPage: (config: any, page?: string) => string;
+export declare const handle401: (page?: string, options?: {
+    queryParams?: Record<string, string>;
+}) => Promise<void>;
+export declare const closeLoginDialog: () => void;
+export declare const getQueryString: (queryObject: Record<string, string | number | boolean>) => string;
+export declare const setupAxiosInterceptors: () => void;

package/core/app.service.js

@@ -0,0 +1,366 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCurrentRouteQueryParam = exports.closeLoginDialog = void 0;
+exports.getDefaultProperties = getDefaultProperties;
+exports.handle401 = exports.getRedirectPage = exports.getQueryString = void 0;
+exports.loadWmProperties = loadWmProperties;
+exports.setupAxiosInterceptors = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _navigationMiddleware = require("@wavemaker-ai/react-runtime/store/middleware/navigationMiddleware");
+var _store = require("@wavemaker-ai/react-runtime/store");
+var _axios = _interopRequireDefault(require("axios"));
+var _authSlice = require("@wavemaker-ai/react-runtime/store/slices/authSlice");
+var _get = _interopRequireDefault(require("lodash-es/get"));
+var _isEmpty = _interopRequireDefault(require("lodash-es/isEmpty"));
+var _appstore = _interopRequireDefault(require("./appstore"));
+var _constants = require("@wavemaker-ai/react-runtime/core/constants");
+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; }
+function loadWmProperties(_x) {
+  return _loadWmProperties.apply(this, arguments);
+}
+function _loadWmProperties() {
+  _loadWmProperties = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(baseUrl) {
+    var response, text, jsonData;
+    return _regenerator["default"].wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _context4.prev = 0;
+          _context4.next = 3;
+          return _axios["default"].get("".concat(baseUrl !== null && baseUrl !== void 0 ? baseUrl : "", "/services/application/wmProperties.js"));
+        case 3:
+          response = _context4.sent;
+          text = response.data;
+          jsonData = text.substring(text.indexOf("{"), text.length - 1);
+          return _context4.abrupt("return", JSON.parse(jsonData));
+        case 9:
+          _context4.prev = 9;
+          _context4.t0 = _context4["catch"](0);
+          console.error("Failed to load WM properties:", _context4.t0);
+          return _context4.abrupt("return", getDefaultProperties());
+        case 13:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[0, 9]]);
+  }));
+  return _loadWmProperties.apply(this, arguments);
+}
+function getDefaultProperties() {
+  return {
+    defaultLanguage: "en",
+    defaultTimezone: "UTC"
+  };
+}
+var LOGIN_METHOD = {
+  DIALOG: "DIALOG",
+  PAGE: "PAGE",
+  SSO: "SSO"
+};
+var createQueryString = function createQueryString(params) {
+  if (!params) return "";
+  var searchParams = new URLSearchParams();
+  Object.entries(params).filter(function (_ref) {
+    var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+      _ = _ref2[0],
+      value = _ref2[1];
+    return value !== undefined;
+  }).forEach(function (_ref3) {
+    var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
+      key = _ref4[0],
+      value = _ref4[1];
+    searchParams.set(key, value);
+  });
+  return searchParams.toString();
+};
+var mergeQueryParams = function mergeQueryParams() {
+  var baseParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var additionalParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return _objectSpread(_objectSpread({}, baseParams), additionalParams);
+};
+
+/**
+ * Gets the page which needs to be redirected to on successful login
+ * @param config,
+ * @param page, page name for redirection
+ * @returns {any|string}
+ */
+
+var getCurrentRouteQueryParam = exports.getCurrentRouteQueryParam = function getCurrentRouteQueryParam(paramName) {
+  if (typeof window === "undefined") return null; // Ensure this runs only in the browser
+
+  var searchParams = new URLSearchParams(window.location.search);
+  return searchParams.get(paramName);
+};
+var getRedirectPage = exports.getRedirectPage = function getRedirectPage(config, page) {
+  var state = _store.store.getState();
+  var info = state.info;
+  var homePage = info.appConfig.appProperties.homePage,
+    loginPage = (0, _get["default"])(config, "loginConfig.pageName");
+  var prevRedirectPage,
+    redirectPage = page;
+
+  // If user is already on Home page or Login page, they should not be redirected to that page, hence return undefined
+  if (redirectPage === homePage || redirectPage === loginPage) {
+    var _getCurrentRouteQuery;
+    /*
+     * Find previous redirect page from URL, if exists, user should redirect to that page.
+     * USE CASE:
+     *  - User is on http://localhost:8080/app/Login?redirectTo=page
+     *  - A variable call fails resulting in 401
+     *  - In this case, redirectTo page should be 'page' and not undefined
+     */
+    prevRedirectPage = (_getCurrentRouteQuery = getCurrentRouteQueryParam("redirectTo")) !== null && _getCurrentRouteQuery !== void 0 ? _getCurrentRouteQuery : undefined;
+    redirectPage = !(0, _isEmpty["default"])(prevRedirectPage) ? prevRedirectPage : undefined;
+  }
+  return redirectPage;
+};
+var handle401 = exports.handle401 = /*#__PURE__*/function () {
+  var _ref5 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(page, options) {
+    var state, securityConfig, router, loginConfig, userInfo, loginMethod, basePath, getCurrentPageName, sessionTimeoutConfig, sessionTimeoutMethod, sessionTimeoutQueryParams, sessionTimeoutLoginPage, queryString, loginPath, loginPageName, _loginPath, loginQueryParams, _queryString, isOnLoginPage;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          state = _store.store.getState();
+          securityConfig = state.auth.securityConfig;
+          if (securityConfig) {
+            _context.next = 4;
+            break;
+          }
+          return _context.abrupt("return");
+        case 4:
+          if (securityConfig !== null && securityConfig !== void 0 && securityConfig.securityEnabled) {
+            _context.next = 6;
+            break;
+          }
+          return _context.abrupt("return");
+        case 6:
+          router = (0, _navigationMiddleware.getRouterInstance)();
+          if (router) {
+            _context.next = 10;
+            break;
+          }
+          console.error("Router is not defined");
+          return _context.abrupt("return");
+        case 10:
+          loginConfig = securityConfig.loginConfig || {};
+          userInfo = securityConfig.userInfo;
+          loginMethod = ((loginConfig === null || loginConfig === void 0 ? void 0 : loginConfig.type) || LOGIN_METHOD.PAGE).toUpperCase();
+          basePath = (0, _constants.getActiveRoutingBasePath)();
+          getCurrentPageName = function getCurrentPageName() {
+            return window.location.pathname.split("/").filter(Boolean).pop() || "";
+          };
+          if (!(userInfo !== null && userInfo !== void 0 && userInfo.userName)) {
+            _context.next = 33;
+            break;
+          }
+          sessionTimeoutConfig = loginConfig.sessionTimeout || {
+            type: LOGIN_METHOD.DIALOG
+          };
+          sessionTimeoutMethod = (sessionTimeoutConfig.type || LOGIN_METHOD.DIALOG).toUpperCase();
+          _context.t0 = sessionTimeoutMethod;
+          _context.next = _context.t0 === LOGIN_METHOD.DIALOG ? 21 : _context.t0 === LOGIN_METHOD.PAGE ? 23 : _context.t0 === LOGIN_METHOD.SSO ? 28 : 31;
+          break;
+        case 21:
+          showLoginDialog();
+          return _context.abrupt("break", 31);
+        case 23:
+          page = page || getCurrentPageName();
+          sessionTimeoutQueryParams = mergeQueryParams({
+            redirectTo: page
+          }, options === null || options === void 0 ? void 0 : options.queryParams);
+          sessionTimeoutLoginPage = sessionTimeoutConfig.pageName || "Login";
+          if (page !== sessionTimeoutLoginPage) {
+            queryString = createQueryString(sessionTimeoutQueryParams);
+            loginPath = "/".concat(basePath, "/").concat(sessionTimeoutLoginPage);
+            router.push("".concat(loginPath).concat(queryString ? "?".concat(queryString) : ""));
+          }
+          return _context.abrupt("break", 31);
+        case 28:
+          _context.next = 30;
+          return handleSSOLogin(loginConfig, options);
+        case 30:
+          return _context.abrupt("break", 31);
+        case 31:
+          _context.next = 49;
+          break;
+        case 33:
+          _context.t1 = loginMethod;
+          _context.next = _context.t1 === LOGIN_METHOD.DIALOG ? 36 : _context.t1 === LOGIN_METHOD.PAGE ? 38 : _context.t1 === LOGIN_METHOD.SSO ? 46 : 49;
+          break;
+        case 36:
+          showLoginDialog(true);
+          return _context.abrupt("break", 49);
+        case 38:
+          page = page || getRedirectPage(securityConfig, page) || getCurrentPageName();
+          loginPageName = loginConfig.pageName || "Login";
+          _loginPath = "/".concat(basePath, "/").concat(loginPageName);
+          loginQueryParams = mergeQueryParams({
+            redirectTo: page
+          }, options === null || options === void 0 ? void 0 : options.queryParams);
+          _queryString = createQueryString(loginQueryParams);
+          isOnLoginPage = window.location.pathname.endsWith(loginPageName);
+          if (!isOnLoginPage && page) {
+            router.push("".concat(_loginPath).concat(_queryString ? "?".concat(_queryString) : ""));
+          }
+          return _context.abrupt("break", 49);
+        case 46:
+          _context.next = 48;
+          return handleSSOLogin(loginConfig, options);
+        case 48:
+          return _context.abrupt("break", 49);
+        case 49:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function handle401(_x2, _x3) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+
+// Placeholder methods - implement based on your app's specific requirements
+var showLoginDialog = function showLoginDialog() {
+  var noRedirect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  var DialogService = _appstore["default"].getDependency("DialogService");
+  DialogService.open("CommonLoginDialog");
+};
+var closeLoginDialog = exports.closeLoginDialog = function closeLoginDialog() {
+  var DialogService = _appstore["default"].getDependency("DialogService");
+  DialogService.close("CommonLoginDialog");
+};
+var getRedirectedRouteQueryParams = function getRedirectedRouteQueryParams() {
+  if (typeof window === "undefined") {
+    return {}; // Prevents errors during SSR
+  }
+  var params = new URLSearchParams(window.location.search);
+  var queryParams = {};
+  params.forEach(function (value, key) {
+    queryParams[key] = value;
+  });
+  return queryParams;
+};
+
+// accepts query object like {a:1, b:2} and returns a=1&b=2 string
+var getQueryString = exports.getQueryString = function getQueryString(queryObject) {
+  return Object.entries(queryObject).map(function (_ref6) {
+    var _ref7 = (0, _slicedToArray2["default"])(_ref6, 2),
+      key = _ref7[0],
+      value = _ref7[1];
+    return "".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(value));
+  }).join("&");
+};
+var handleSSOLogin = /*#__PURE__*/function () {
+  var _ref8 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(config, options) {
+    var state, info, baseUrl, SSO_URL, PREVIEW_WINDOW_NAME, page, queryParams, ssoUrl;
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          state = _store.store.getState();
+          info = state.info;
+          baseUrl = info.appConfig.url || "";
+          SSO_URL = baseUrl + "/services/security/ssologin", PREVIEW_WINDOW_NAME = "WM_PREVIEW_WINDOW";
+          page = getRedirectPage(config);
+          page = page ? "?redirectPage=" + encodeURIComponent(page) : "";
+          /*
+           * For preview, getRedirectedRouteQueryParams() gets the queryparams form the activated route
+           * For deployed app, canactivate guard resolved to false and gets the queryparams from the canactivate gurard(no active route component)
+           */
+          queryParams = options && options.queryParams || getRedirectedRouteQueryParams();
+          queryParams = getQueryString(queryParams);
+          queryParams = queryParams ? "?" + queryParams : "";
+          // showing a redirecting message
+          // appending redirect to page and page params
+          // const ssoUrl = getDeployedURL() + SSO_URL + page + queryParams; Not sure where should get getDeployedURL(), so removed for now, but this is required in actual implementation
+          ssoUrl = SSO_URL + page + queryParams;
+          /*
+           * remove iFrame when redirected to IdP login page.
+           * this is being done as IDPs do not allow to get themselves loaded into iFrames.
+           * remove-toolbar has been assigned with a window name WM_PREVIEW_WINDOW, check if the iframe is our toolbar related and
+           * safely change the location of the parent toolbar with current url.
+           */
+          if (window.self !== window.top) {
+            try {
+              if (window.parent && window.location.origin === window.parent.origin) {
+                if (window.parent.name === PREVIEW_WINDOW_NAME) {
+                  window.parent.location.href = window.self.location.href;
+                  window.parent.name = "";
+                }
+              } else {
+                window.location.href = ssoUrl;
+              }
+            } catch (error) {
+              window.location.href = ssoUrl;
+            }
+          } else {
+            window.location.href = ssoUrl;
+          }
+        case 11:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function handleSSOLogin(_x4, _x5) {
+    return _ref8.apply(this, arguments);
+  };
+}();
+var setupAxiosInterceptors = exports.setupAxiosInterceptors = function setupAxiosInterceptors() {
+  _axios["default"].defaults.withCredentials = true;
+  _axios["default"].interceptors.request.use(/*#__PURE__*/function () {
+    var _ref9 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(config) {
+      var _state$info, _config$url;
+      var state, token, baseUrl;
+      return _regenerator["default"].wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            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) || ""; // Remove manual Cookie header setting as it's restricted by browsers
+            // and withCredentials already handles cookie transmission
+            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 _context3.abrupt("return", config);
+          case 5:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+    return function (_x6) {
+      return _ref9.apply(this, arguments);
+    };
+  }(), function (error) {
+    // Handle request config errors
+    return Promise.reject(error);
+  });
+  _axios["default"].interceptors.response.use(function (response) {
+    return response;
+  }, function (error) {
+    if (error.response) {
+      var _error$response$confi, _error$response$confi2;
+      var state = _store.store.getState();
+      var info = state.info;
+
+      // Check for 401 Unauthorized
+      if (error.response.status === 401 && (_error$response$confi = error.response.config.url) !== null && _error$response$confi !== void 0 && _error$response$confi.startsWith(info.appConfig.url) && !((_error$response$confi2 = error.response.config.url) !== null && _error$response$confi2 !== void 0 && _error$response$confi2.includes("/services/"))) {
+        handle401();
+      }
+    } else if (error.request) {
+      console.error("No response received:", error.request);
+    } else {
+      console.error("Error setting up request:", error.message);
+    }
+    // Always return a rejected promise to allow further error handling
+    return Promise.reject(error);
+  });
+};

package/core/appVariablesStore.d.ts

@@ -0,0 +1,5 @@
+export declare const getAppVariablesInstance: (pageProxy: any, getAppVariables: Function) => {
+    Variables: Record<string, any>;
+    Actions: Record<string, any>;
+};
+export declare const resetAppVariables: () => void;

package/core/appVariablesStore.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resetAppVariables = exports.getAppVariablesInstance = void 0;
+var appVariablesInstance;
+var isInitialized = false;
+var getAppVariablesInstance = exports.getAppVariablesInstance = function getAppVariablesInstance(pageProxy, getAppVariables) {
+  if (!isInitialized) {
+    appVariablesInstance = getAppVariables(pageProxy);
+    isInitialized = true;
+    console.log("App variables initialized once");
+  }
+  return appVariablesInstance;
+};
+var resetAppVariables = exports.resetAppVariables = function resetAppVariables() {
+  appVariablesInstance = {
+    Variables: {},
+    Actions: {}
+  };
+  isInitialized = false;
+};

package/core/appstore.d.ts

@@ -0,0 +1,35 @@
+interface I18nService {
+    selectedLocale?: string;
+    getSelectedLocale: () => string;
+    isRTLLocale: (newLocale?: string) => any;
+    setRTL: (locale?: string) => any;
+}
+interface DialogServiceInterface {
+    registerDialog: (name: string, dialogInstance: any) => void;
+    unregisterDialog: (name: string) => void;
+    open: (dialogName: string) => void;
+    close: (dialogName: string) => void;
+    getDialog: (dialogName: string) => any;
+    getAllDialogs: () => Record<string, any>;
+    isDialogOpen: (dialogName: string) => boolean;
+}
+declare const appstore: {
+    set: <T>(t: string, o: T) => void;
+    get: <T>(t: string) => T;
+    remove: <T>(t: string) => T;
+    getDependency: (t: string) => any;
+    getApp: () => {
+        [k: string]: any;
+    };
+    I18nService: {
+        set: (o: I18nService) => void;
+        get: () => I18nService;
+        remove: () => I18nService;
+    };
+    DialogService: {
+        set: (o: DialogServiceInterface) => void;
+        get: () => DialogServiceInterface;
+        remove: () => DialogServiceInterface;
+    };
+};
+export default appstore;

package/core/appstore.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _util = require("./util");
+var map = new Map();
+var _get = function get(t) {
+  return map.get(t);
+};
+var _set = function set(t, o) {
+  map.set(t, o);
+};
+var _remove = function remove(t) {
+  var v = map.get(t);
+  v && map["delete"](t);
+  return v;
+};
+var getDependency = function getDependency(t) {
+  var v = map.get(t);
+  if (v) {
+    return v;
+  }
+  return null;
+};
+var getApp = function getApp() {
+  var entries = Object.fromEntries(map.entries());
+  return entries;
+};
+var getInstance = function getInstance(key) {
+  return {
+    set: function set(o) {
+      return _set(key, o);
+    },
+    get: function get() {
+      return _get(key);
+    },
+    remove: function remove() {
+      return _remove(key);
+    }
+  };
+};
+var appstore = {
+  set: _set,
+  get: _get,
+  remove: _remove,
+  getDependency: getDependency,
+  getApp: getApp,
+  I18nService: getInstance("I18nService"),
+  DialogService: getInstance("DialogService")
+};
+
+// Initialize I18nService with default implementation if not already set
+if (!appstore.I18nService.get()) {
+  appstore.I18nService.set({
+    selectedLocale: "en",
+    getSelectedLocale: function getSelectedLocale() {
+      try {
+        var sessionLocale = (0, _util.getSessionLocaleSafe)();
+        if (sessionLocale) {
+          return sessionLocale;
+        }
+      } catch (_unused) {
+        // sessionStorage unavailable (e.g. Safari private mode) or store not ready
+      }
+      return this.selectedLocale || "en";
+    },
+    isRTLLocale: function isRTLLocale(newLocale) {
+      var _appstore$I18nService;
+      // Default RTL implementation - can be overridden
+      var rtlLocales = ["ar", "he", "fa", "ur"];
+      var locale = newLocale || ((_appstore$I18nService = appstore.I18nService.get()) === null || _appstore$I18nService === void 0 ? void 0 : _appstore$I18nService.getSelectedLocale()) || "en";
+      return rtlLocales.some(function (rtl) {
+        return locale.startsWith(rtl);
+      });
+    },
+    setRTL: function setRTL(locale) {
+      // Default setRTL implementation - can be overridden
+      if (typeof document !== "undefined") {
+        var _appstore$I18nService2;
+        var isRTL = (_appstore$I18nService2 = appstore.I18nService.get()) === null || _appstore$I18nService2 === void 0 ? void 0 : _appstore$I18nService2.isRTLLocale(locale);
+        document.body.style.direction = isRTL ? "rtl" : "ltr";
+      }
+    }
+  });
+}
+var _default = exports["default"] = appstore;

package/core/constants/currency-constant.d.ts

@@ -0,0 +1,11 @@
+export interface Currency {
+    symbol: string;
+    name: string;
+    symbol_native: string;
+    decimal_digits: number;
+    rounding: number;
+    code: string;
+    name_plural: string;
+}
+export declare const CURRENCY_INFO: Record<string, Currency>;
+export default CURRENCY_INFO;