@wavemaker-ai/react-runtime 1.0.0-next.27766

package/context/PrefabContext.js

@@ -0,0 +1,144 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useEffect, useRef } from "react";
+import { isEqual } from "lodash";
+import { EVENTEMITTER_METHODS } from "../core/constants/events";
+const PrefabContext = createContext({
+  inbound: {},
+  outbound: {},
+  prefabName: "",
+  parentForm: void 0,
+  isParentList: false,
+  formArrayIndex: -1,
+  parentListName: void 0
+});
+const getChangedKeys = (prev, curr) => {
+  const changes = [];
+  const keys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(curr)]);
+  keys.forEach((key) => {
+    const ignoredKeys = ["name", "prefabname", "data-widget-id", "prefabName"];
+    if (ignoredKeys.includes(key)) {
+      return;
+    }
+    const prevValue = prev[key];
+    const currValue = curr[key];
+    if (typeof prevValue === "function" && typeof currValue === "function") {
+      if (prevValue.toString() !== currValue.toString() && prevValue === void 0 && currValue !== void 0) {
+        changes.push({
+          key,
+          oldValue: prevValue,
+          newValue: currValue
+        });
+      }
+      return;
+    }
+    if (!isEqual(prevValue, currValue) && currValue !== void 0 && currValue !== null) {
+      changes.push({
+        key,
+        oldValue: prevValue,
+        newValue: currValue
+      });
+    }
+  });
+  return changes;
+};
+const PrefabProvider = ({
+  value: Context,
+  children
+}) => {
+  const prevOutboundRef = useRef(Context.outbound);
+  const pendingChangesRef = useRef([]);
+  const retryCountRef = useRef(0);
+  const isInitialMountRef = useRef(true);
+  const maxRetries = 20;
+  const initialMountMaxRetries = 30;
+  const rafIdRef = useRef(null);
+  useEffect(() => {
+    const currInbound = Context.inbound;
+    if (isEqual(prevOutboundRef.current, currInbound)) {
+      return;
+    }
+    const inboundChanges = getChangedKeys(prevOutboundRef.current, currInbound);
+    prevOutboundRef.current = currInbound;
+    if (inboundChanges.length > 0) {
+      const changeMap = /* @__PURE__ */ new Map();
+      pendingChangesRef.current.forEach((change) => {
+        changeMap.set(change.key, change);
+      });
+      inboundChanges.forEach((change) => {
+        changeMap.set(change.key, change);
+      });
+      pendingChangesRef.current = Array.from(changeMap.values());
+      retryCountRef.current = 0;
+      if (rafIdRef.current !== null) {
+        cancelAnimationFrame(rafIdRef.current);
+      }
+      const tryEmit = () => {
+        const changesAsObject = {};
+        pendingChangesRef.current.forEach((change, index) => {
+          changesAsObject[index] = change;
+        });
+        const hasListeners = EVENTEMITTER_METHODS.PREFAB_STATE_SYNC_EMIT(
+          Context.prefabName,
+          changesAsObject
+        );
+        const currentMaxRetries = isInitialMountRef.current ? initialMountMaxRetries : maxRetries;
+        if (!hasListeners && retryCountRef.current < currentMaxRetries) {
+          retryCountRef.current += 1;
+          const rafCycles = isInitialMountRef.current ? 10 : 5;
+          let rafChain = tryEmit;
+          for (let i = 0; i < rafCycles; i++) {
+            const next = rafChain;
+            rafChain = () => {
+              rafIdRef.current = requestAnimationFrame(() => {
+                next();
+              });
+            };
+          }
+          rafChain();
+        } else {
+          if (hasListeners) {
+            isInitialMountRef.current = false;
+          } else {
+            isInitialMountRef.current = false;
+            console.warn(
+              "PrefabContext: Max retries reached without finding listeners. BasePage may not be ready yet. Future updates will use normal retry behavior."
+            );
+          }
+          pendingChangesRef.current = [];
+          retryCountRef.current = 0;
+          rafIdRef.current = null;
+        }
+      };
+      const initialRafCycles = isInitialMountRef.current ? 5 : 3;
+      queueMicrotask(() => {
+        let rafChain = tryEmit;
+        for (let i = 0; i < initialRafCycles; i++) {
+          const next = rafChain;
+          rafChain = () => {
+            rafIdRef.current = requestAnimationFrame(() => {
+              next();
+            });
+          };
+        }
+        rafChain();
+      });
+    }
+  }, [Context.inbound]);
+  useEffect(() => {
+    return () => {
+      if (rafIdRef.current !== null) {
+        cancelAnimationFrame(rafIdRef.current);
+        rafIdRef.current = null;
+      }
+      pendingChangesRef.current = [];
+      retryCountRef.current = 0;
+      isInitialMountRef.current = true;
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(PrefabContext.Provider, { value: Context, children });
+};
+var PrefabContext_default = PrefabProvider;
+export {
+  PrefabContext,
+  PrefabContext_default as default
+};

package/context/WidgetProvider.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+interface WidgetContextProps {
+    pageContext: any;
+    updateWidgetState: (widgetName: string, props: Record<string, any>) => void;
+    proxy: any;
+    destroy: (widgetName: string[]) => void;
+}
+export declare const WidgetProvider: ({ value: Context, children, }: {
+    value: {
+        value: any;
+        proxy: any;
+    };
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const usePageContext: (standalone?: boolean) => WidgetContextProps;
+export declare const useWidgetProxy: (name?: string, standalone?: boolean) => any;
+export declare const useProxy: (path?: string) => any;
+export declare const useAppState: () => any;
+export {};

package/context/WidgetProvider.js

@@ -0,0 +1,266 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { jsx } from "react/jsx-runtime";
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useState,
+  useMemo,
+  useRef,
+  useCallback
+} from "react";
+import get from "lodash-es/get";
+import debounce from "lodash-es/debounce";
+import { useDebounceCallback } from "../hooks/useDebounce";
+import { HttpProvider } from "../hooks/useHttp";
+import { removeWidgetsFromContext } from "../utils/widget-cleanup-util";
+import { EVENTEMITTER_METHODS } from "../core/constants/events";
+import { createWidgetProxy } from "../core/proxy-service";
+import { useLayout } from "./LayoutProvider";
+import isPlainObject from "lodash-es/isPlainObject";
+const WidgetContext = createContext(void 0);
+const proxyMap = /* @__PURE__ */ new WeakMap();
+const WidgetProvider = ({
+  value: Context,
+  children
+}) => {
+  var _a, _b;
+  const { value, proxy } = Context;
+  const pageContextRef = useRef(proxy);
+  const [pageContext, setPageContext] = useState(__spreadProps(__spreadValues({}, value), { isLayoutReady: false }));
+  const { layout, proxy: layoutProxy } = useLayout();
+  const pendingDestroysRef = useRef(/* @__PURE__ */ new Set());
+  const isPage = ((_a = pageContext == null ? void 0 : pageContext.componentType) == null ? void 0 : _a.toUpperCase()) === "PAGE";
+  const flushDestroys = useCallback(() => {
+    const names = Array.from(pendingDestroysRef.current);
+    pendingDestroysRef.current.clear();
+    if (names.length === 0) return;
+    setPageContext((prev) => {
+      const newContext = removeWidgetsFromContext(prev, proxy, names);
+      pageContextRef.current = newContext;
+      return newContext;
+    });
+  }, []);
+  const debouncedFlushDestroys = useDebounceCallback(flushDestroys, 100);
+  useEffect(() => () => debouncedFlushDestroys.cancel(), [debouncedFlushDestroys]);
+  const isAppWidgetRegisterNeeded = useMemo(() => {
+    var _a2;
+    return isPage || ((_a2 = pageContext == null ? void 0 : pageContext.componentName) == null ? void 0 : _a2.toUpperCase()) === "COMMON";
+  }, [isPage, pageContext == null ? void 0 : pageContext.componentName]);
+  const destroy = useCallback(
+    (widgetNames) => {
+      if (!(widgetNames == null ? void 0 : widgetNames.length)) return;
+      widgetNames.forEach((name) => name && pendingDestroysRef.current.add(name));
+      debouncedFlushDestroys();
+    },
+    [debouncedFlushDestroys]
+  );
+  useEffect(() => {
+    setPageContext((prevContext) => {
+      const newContext = __spreadValues({}, prevContext);
+      function registerMethod(context, newWidget, widgetName) {
+        if (isAppWidgetRegisterNeeded) {
+          pageContextRef.current.App.Widgets[widgetName] = newWidget;
+        }
+        context.Widgets[widgetName] = newWidget;
+      }
+      if ((value == null ? void 0 : value.Widgets) && (newContext == null ? void 0 : newContext.Widgets)) {
+        Object.keys(value.Widgets).forEach((widgetName) => {
+          var _a2;
+          const currentWidget = newContext.Widgets[widgetName];
+          const incomingWidget = proxy.Widgets[widgetName] || value.Widgets[widgetName];
+          if (currentWidget == null ? void 0 : currentWidget.App) {
+            registerMethod(newContext, (_a2 = pageContextRef.current) == null ? void 0 : _a2.Widgets[widgetName], widgetName);
+          } else {
+            if (incomingWidget.__isProxy) return;
+            if (!isPage && (incomingWidget == null ? void 0 : incomingWidget.isLayout)) return;
+            const registry = value == null ? void 0 : value.overriddenPropsRegistry;
+            const widgetProxy = createWidgetProxy(
+              incomingWidget,
+              widgetName,
+              setPageContext,
+              registry
+            );
+            registerMethod(newContext, widgetProxy, widgetName);
+          }
+        });
+      }
+      value && Object.keys(value).forEach((key) => {
+        if (key !== "Widgets") {
+          newContext[key] = value[key];
+        }
+      });
+      pageContextRef.current = newContext;
+      return newContext;
+    });
+  }, [value]);
+  useEffect(() => {
+    const layoutKeys = Object.keys(layout);
+    if (isPage && isPlainObject(layout) && layoutKeys.length > 0) {
+      setPageContext((prevContext) => {
+        const newContext = prevContext;
+        if (newContext == null ? void 0 : newContext.Widgets) {
+          layoutKeys.forEach((widgetName) => {
+            const currentWidget = newContext.Widgets[widgetName];
+            const incomingWidget = layout[widgetName];
+            if (!currentWidget || !proxyMap.has(currentWidget)) {
+              newContext.Widgets[widgetName] = layoutProxy[widgetName];
+              proxy.Widgets[widgetName] = layoutProxy[widgetName];
+            } else {
+              Object.entries(incomingWidget).forEach(([key, val]) => {
+                if (typeof key === "string" && !key.startsWith("_")) {
+                  currentWidget[key] = val;
+                  proxy.Widgets[widgetName][key] = val;
+                }
+              });
+            }
+          });
+        }
+        value && Object.keys(value).forEach((key) => {
+          if (key !== "Widgets") {
+            newContext[key] = value[key];
+          }
+        });
+        return newContext;
+      });
+      proxy.layoutReady && proxy.layoutReady();
+    }
+  }, [layout]);
+  const updateWidgetState = useMemo(() => {
+    return (widgetName, props) => {
+      if (!widgetName || !pageContext.Widgets) return;
+      const widget = pageContext.Widgets[widgetName];
+      if (!isPage && (widget == null ? void 0 : widget.isLayout)) return;
+      if (widget != props) {
+        pageContextRef.current.Widgets[widgetName] = props;
+        pageContext.Widgets[widgetName] = props;
+        if (isAppWidgetRegisterNeeded) {
+          pageContextRef.current.App.Widgets[widgetName] = props;
+          pageContext.App.Widgets[widgetName] = props;
+        }
+      }
+    };
+  }, [isAppWidgetRegisterNeeded]);
+  const debouncedEmitRef = useRef(
+    debounce((partialName2, context) => {
+      EVENTEMITTER_METHODS.PARTIAL_STATE_SYNC_EMIT({
+        partialName: partialName2,
+        pageContext: context,
+        proxy: pageContextRef.current
+      });
+    }, 100)
+  );
+  const partialName = (pageContext == null ? void 0 : pageContext.partialName) || ((_b = pageContext == null ? void 0 : pageContext.componentType) == null ? void 0 : _b.toLowerCase()) === "prefab" && (pageContext == null ? void 0 : pageContext.name);
+  useEffect(() => {
+    if (!isPage) return;
+    const handlePartialStateSync = (data) => {
+      var _a2;
+      if (!data.pageContext) return;
+      if ((_a2 = data.pageContext) == null ? void 0 : _a2.isLayout) return;
+      proxy.Widgets[data.partialName] = data.proxy;
+      if (isAppWidgetRegisterNeeded) proxy.App.Widgets[data.partialName] = data.proxy;
+    };
+    EVENTEMITTER_METHODS.PARTIAL_STATE_SYNC_ON(handlePartialStateSync);
+    return () => {
+      EVENTEMITTER_METHODS.PARTIAL_STATE_SYNC_OFF(handlePartialStateSync);
+      debouncedEmitRef.current.cancel();
+    };
+  }, []);
+  useEffect(() => {
+    if (isPage || !partialName) return;
+    debouncedEmitRef.current(partialName, proxy);
+    if (pageContext == null ? void 0 : pageContext.isLayout) {
+      EVENTEMITTER_METHODS.LAYOUT_STATE_REFRESH_EMIT({
+        layoutName: pageContext.partialName,
+        layout: pageContext,
+        proxy
+      });
+    }
+    return () => {
+      debouncedEmitRef.current.cancel();
+    };
+  }, [partialName, pageContext, isPage]);
+  const contextValue = useMemo(
+    () => ({
+      pageContext,
+      updateWidgetState,
+      proxy,
+      destroy
+    }),
+    [pageContext, updateWidgetState, proxy, destroy]
+  );
+  return /* @__PURE__ */ jsx(HttpProvider, { children: /* @__PURE__ */ jsx(WidgetContext.Provider, { value: contextValue, children }) });
+};
+const usePageContext = (standalone) => {
+  const context = useContext(WidgetContext);
+  if (standalone) {
+    return {
+      pageContext: {},
+      updateWidgetState: () => {
+      },
+      proxy: {},
+      destroy: () => {
+      }
+    };
+  }
+  if (!context) {
+    throw new Error("useWidgetContext must be used within a WidgetProvider");
+  }
+  return context;
+};
+const useWidgetProxy = (name, standalone) => {
+  const context = useContext(WidgetContext);
+  if (standalone) {
+    return {};
+  }
+  if (!context) {
+    throw new Error("useWidgetProxy must be used within a WidgetProvider");
+  }
+  if (!name) {
+    return context.proxy.Widgets;
+  }
+  return get(context.proxy, `Widgets.${name}`, {});
+};
+const useProxy = (path) => {
+  const context = useContext(WidgetContext);
+  if (!context) {
+    throw new Error("useProxy must be used within a WidgetProvider");
+  }
+  if (!path) {
+    return context.proxy;
+  }
+  return get(context.proxy, path, null);
+};
+const useAppState = () => {
+  const context = useContext(WidgetContext);
+  if (!context) {
+    throw new Error("useAppState must be used within a WidgetProvider");
+  }
+  return context.pageContext;
+};
+export {
+  WidgetProvider,
+  useAppState,
+  usePageContext,
+  useProxy,
+  useWidgetProxy
+};

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,239 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { getRouterInstance } from "../store/middleware/navigationMiddleware";
+import { store } from "../store";
+import axios from "axios";
+import { XSRF_HEADER_NAME } from "../store/slices/authSlice";
+import get from "lodash-es/get";
+import isEmpty from "lodash-es/isEmpty";
+import appstore from "./appstore";
+import { getActiveRoutingBasePath } from "./constants";
+import { resolveBasePath } from "../store/util/resolve-path";
+async function loadWmProperties(baseUrl) {
+  try {
+    const response = await axios.get(
+      `${resolveBasePath(baseUrl)}/services/application/wmProperties.js`
+    );
+    const text = response.data;
+    const jsonData = text.substring(text.indexOf("{"), text.length - 1);
+    return JSON.parse(jsonData);
+  } catch (error) {
+    console.error("Failed to load WM properties:", error);
+    return getDefaultProperties();
+  }
+}
+function getDefaultProperties() {
+  return {
+    defaultLanguage: "en",
+    defaultTimezone: "UTC"
+  };
+}
+const LOGIN_METHOD = {
+  DIALOG: "DIALOG",
+  PAGE: "PAGE",
+  SSO: "SSO"
+};
+const createQueryString = (params) => {
+  if (!params) return "";
+  const searchParams = new URLSearchParams();
+  Object.entries(params).filter(([_, value]) => value !== void 0).forEach(([key, value]) => {
+    searchParams.set(key, value);
+  });
+  return searchParams.toString();
+};
+const mergeQueryParams = (baseParams = {}, additionalParams = {}) => {
+  return __spreadValues(__spreadValues({}, baseParams), additionalParams);
+};
+const getCurrentRouteQueryParam = (paramName) => {
+  if (typeof window === "undefined") return null;
+  const searchParams = new URLSearchParams(window.location.search);
+  return searchParams.get(paramName);
+};
+const getRedirectPage = (config, page) => {
+  var _a;
+  const state = store.getState();
+  const { info } = state;
+  const homePage = info.appConfig.appProperties.homePage, loginPage = get(config, "loginConfig.pageName");
+  let prevRedirectPage, redirectPage = page;
+  if (redirectPage === homePage || redirectPage === loginPage) {
+    prevRedirectPage = (_a = getCurrentRouteQueryParam("redirectTo")) != null ? _a : void 0;
+    redirectPage = !isEmpty(prevRedirectPage) ? prevRedirectPage : void 0;
+  }
+  return redirectPage;
+};
+const handle401 = async (page, options) => {
+  const state = store.getState();
+  const { securityConfig } = state.auth;
+  if (!securityConfig) return;
+  if (!(securityConfig == null ? void 0 : securityConfig.securityEnabled)) return;
+  const router = getRouterInstance();
+  if (!router) {
+    console.error("Router is not defined");
+    return;
+  }
+  const loginConfig = securityConfig.loginConfig || {};
+  const userInfo = securityConfig.userInfo;
+  const loginMethod = ((loginConfig == null ? void 0 : loginConfig.type) || LOGIN_METHOD.PAGE).toUpperCase();
+  const basePath = getActiveRoutingBasePath();
+  const getCurrentPageName = () => {
+    return window.location.pathname.split("/").filter(Boolean).pop() || "";
+  };
+  if (userInfo == null ? void 0 : userInfo.userName) {
+    const sessionTimeoutConfig = loginConfig.sessionTimeout || { type: LOGIN_METHOD.DIALOG };
+    const sessionTimeoutMethod = (sessionTimeoutConfig.type || LOGIN_METHOD.DIALOG).toUpperCase();
+    switch (sessionTimeoutMethod) {
+      case LOGIN_METHOD.DIALOG:
+        showLoginDialog();
+        break;
+      case LOGIN_METHOD.PAGE:
+        page = page || getCurrentPageName();
+        const sessionTimeoutQueryParams = mergeQueryParams(
+          { redirectTo: page },
+          options == null ? void 0 : options.queryParams
+        );
+        const sessionTimeoutLoginPage = sessionTimeoutConfig.pageName || "Login";
+        if (page !== sessionTimeoutLoginPage) {
+          const queryString = createQueryString(sessionTimeoutQueryParams);
+          const loginPath = `/${basePath}/${sessionTimeoutLoginPage}`;
+          router.push(`${loginPath}${queryString ? `?${queryString}` : ""}`);
+        }
+        break;
+      case LOGIN_METHOD.SSO:
+        await handleSSOLogin(loginConfig, options);
+        break;
+    }
+  } else {
+    switch (loginMethod) {
+      case LOGIN_METHOD.DIALOG:
+        showLoginDialog(true);
+        break;
+      case LOGIN_METHOD.PAGE:
+        page = page || getRedirectPage(securityConfig, page) || getCurrentPageName();
+        const loginPageName = loginConfig.pageName || "Login";
+        const loginPath = `/${basePath}/${loginPageName}`;
+        const loginQueryParams = mergeQueryParams({ redirectTo: page }, options == null ? void 0 : options.queryParams);
+        const queryString = createQueryString(loginQueryParams);
+        const isOnLoginPage = window.location.pathname.endsWith(loginPageName);
+        if (!isOnLoginPage && page) {
+          router.push(`${loginPath}${queryString ? `?${queryString}` : ""}`);
+        }
+        break;
+      case LOGIN_METHOD.SSO:
+        await handleSSOLogin(loginConfig, options);
+        break;
+    }
+  }
+};
+const showLoginDialog = (noRedirect = false) => {
+  const DialogService = appstore.getDependency("DialogService");
+  DialogService.open("CommonLoginDialog");
+};
+const closeLoginDialog = () => {
+  const DialogService = appstore.getDependency("DialogService");
+  DialogService.close("CommonLoginDialog");
+};
+const getRedirectedRouteQueryParams = () => {
+  if (typeof window === "undefined") {
+    return {};
+  }
+  const params = new URLSearchParams(window.location.search);
+  let queryParams = {};
+  params.forEach((value, key) => {
+    queryParams[key] = value;
+  });
+  return queryParams;
+};
+const getQueryString = (queryObject) => {
+  return Object.entries(queryObject).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+};
+const handleSSOLogin = async (config, options) => {
+  const state = store.getState();
+  const { info } = state;
+  const baseUrl = info.appConfig.url || "";
+  const SSO_URL = baseUrl + "/services/security/ssologin", PREVIEW_WINDOW_NAME = "WM_PREVIEW_WINDOW";
+  let page, queryParams;
+  page = getRedirectPage(config);
+  page = page ? "?redirectPage=" + encodeURIComponent(page) : "";
+  queryParams = options && options.queryParams || getRedirectedRouteQueryParams();
+  queryParams = getQueryString(queryParams);
+  queryParams = queryParams ? "?" + queryParams : "";
+  const ssoUrl = SSO_URL + page + queryParams;
+  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;
+  }
+};
+const setupAxiosInterceptors = () => {
+  axios.defaults.withCredentials = true;
+  axios.interceptors.request.use(
+    async (config) => {
+      var _a, _b, _c;
+      const state = store.getState();
+      const token = state.auth.token;
+      const baseUrl = ((_b = (_a = state.info) == null ? void 0 : _a.appConfig) == null ? void 0 : _b.url) || "";
+      if (((_c = config.url) == null ? void 0 : _c.startsWith(baseUrl)) && token) {
+        if (config.headers) config.headers[XSRF_HEADER_NAME] = token;
+      }
+      return config;
+    },
+    (error) => {
+      return Promise.reject(error);
+    }
+  );
+  axios.interceptors.response.use(
+    (response) => {
+      return response;
+    },
+    (error) => {
+      var _a, _b;
+      if (error.response) {
+        const state = store.getState();
+        const { info } = state;
+        if (error.response.status === 401 && ((_a = error.response.config.url) == null ? void 0 : _a.startsWith(info.appConfig.url)) && !((_b = error.response.config.url) == null ? void 0 : _b.includes("/services/"))) {
+          handle401();
+        }
+      } else if (error.request) {
+        console.error("No response received:", error.request);
+      } else {
+        console.error("Error setting up request:", error.message);
+      }
+      return Promise.reject(error);
+    }
+  );
+};
+export {
+  closeLoginDialog,
+  getCurrentRouteQueryParam,
+  getDefaultProperties,
+  getQueryString,
+  getRedirectPage,
+  handle401,
+  loadWmProperties,
+  setupAxiosInterceptors
+};

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;