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

package/store/slices/authSlice.js

@@ -0,0 +1,372 @@
+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 { createSlice, createAsyncThunk } from "@reduxjs/toolkit";
+import axios from "axios";
+import each from "lodash-es/each";
+import { getRouterInstance } from "../middleware/navigationMiddleware";
+import { getServiceDefinitions } from "./appConfigSlice";
+import { getCurrentRouteQueryParam, handle401 } from "../../core/app.service";
+import { checkPublicAccess, getValidJSON } from "../../core/util";
+import { clearAccessCache } from "../../hooks/useAccess";
+import { getActiveRoutingBasePath, PREVIEW_ROUTING_BASEPATH } from "../../core/constants";
+const XSRF_COOKIE_NAME = process.env.NEXT_PUBLIC_XSRF_COOKIE_NAME || "wm_xsrf_token";
+const XSRF_HEADER_NAME = process.env.NEXT_PUBLIC_XSRF_HEADER_NAME || "X-WM-XSRF-TOKEN";
+const SESSION = "SESSION";
+var USER_ROLE = /* @__PURE__ */ ((USER_ROLE2) => {
+  USER_ROLE2["EVERYONE"] = "Everyone";
+  USER_ROLE2["ANONYMOUS"] = "Anonymous";
+  USER_ROLE2["AUTHENTICATED"] = "Authenticated";
+  return USER_ROLE2;
+})(USER_ROLE || {});
+const defaultUserState = {
+  isAuthenticated: false,
+  isSecurityEnabled: false,
+  roles: [],
+  name: "",
+  id: "",
+  tenantId: "",
+  userAttributes: {},
+  landingPage: ""
+};
+const initialState = {
+  isLoggedIn: false,
+  isPageLoading: false,
+  loggedInUser: null,
+  securityConfig: null,
+  token: null,
+  landingPage: "",
+  error: null
+};
+const saveUserInfo = (details, dispatch) => {
+  var _a, _b, _c, _d, _e, _f;
+  const user = __spreadProps(__spreadValues({}, details.userInfo), {
+    isAuthenticated: Boolean(details.authenticated),
+    isSecurityEnabled: Boolean(details.authenticated),
+    roles: Array.isArray((_a = details.userInfo) == null ? void 0 : _a.userRoles) ? details.userInfo.userRoles : [],
+    name: ((_b = details.userInfo) == null ? void 0 : _b.userName) || "",
+    id: ((_c = details.userInfo) == null ? void 0 : _c.userId) || "",
+    tenantId: ((_d = details.userInfo) == null ? void 0 : _d.tenantId) || "",
+    userAttributes: typeof ((_e = details.userInfo) == null ? void 0 : _e.userAttributes) === "object" ? details.userInfo.userAttributes : {},
+    landingPage: ((_f = details.userInfo) == null ? void 0 : _f.landingPage) || ""
+  });
+  dispatch(setLoggedInUser(user));
+};
+const loadSecurityInfo = createAsyncThunk(
+  "auth/loadSecurityInfo",
+  async (baseURL, { dispatch, rejectWithValue }) => {
+    var _a, _b;
+    const pathname = window.location.pathname;
+    const cookieToken = (_a = document == null ? void 0 : document.cookie) == null ? void 0 : _a.split(";").filter((item) => item.includes("wm_xsrf_token"));
+    if (cookieToken && cookieToken.length > 0) {
+      const wmXsrfToken = cookieToken[0].split("=")[1];
+      if (wmXsrfToken) {
+        dispatch(setToken(wmXsrfToken));
+      }
+    }
+    try {
+      dispatch(setPageLoading(true));
+      const response = await axios.get(`${baseURL}/services/security/info`);
+      const details = response.data;
+      const secConfig = details || {};
+      secConfig.isSecurityEnabled = !!(details == null ? void 0 : details.securityEnabled);
+      if (typeof details !== "string" && (!(details == null ? void 0 : details.securityEnabled) || (details == null ? void 0 : details.authenticated))) {
+        if (details == null ? void 0 : details.authenticated) {
+          const router = getRouterInstance();
+          saveUserInfo(details, dispatch);
+          await dispatch(getServiceDefinitions(baseURL)).unwrap();
+          dispatch(setIsLoggedIn(true));
+          clearAccessCache();
+          const landingPage = details.userInfo.landingPage;
+          const loginPage = (_b = secConfig.loginConfig) == null ? void 0 : _b.pageName;
+          if (landingPage) {
+            dispatch(setLandingPage(`/${getActiveRoutingBasePath()}/${landingPage}`));
+          }
+          const currentPageName = pathname.split("/").filter(Boolean).pop();
+          const isOnLoginPage = currentPageName === loginPage;
+          if (router && landingPage && isOnLoginPage) {
+            router.push(`/${getActiveRoutingBasePath()}/${landingPage}`);
+          }
+        } else {
+          await dispatch(getServiceDefinitions(baseURL)).unwrap();
+        }
+        dispatch(setSecurityConfig(secConfig));
+        return Promise.resolve(details);
+      } else {
+        saveUserInfo(details, dispatch);
+        await dispatch(getServiceDefinitions(baseURL)).unwrap();
+        dispatch(setSecurityConfig(secConfig));
+        if (!secConfig.isSecurityEnabled) {
+          return Promise.resolve({});
+        }
+        return Promise.resolve({});
+      }
+    } catch (error) {
+      await dispatch(redirectToLogin({})).unwrap();
+      throw error;
+    } finally {
+      dispatch(setPageLoading(false));
+    }
+  }
+);
+const login = createAsyncThunk(
+  "auth/login",
+  async (options, { dispatch, getState, rejectWithValue }) => {
+    var _a, _b, _c, _d, _e;
+    let payload = "";
+    each(options.formData, (value, name) => {
+      payload += (payload ? "&" : "") + encodeURIComponent(name) + "=" + encodeURIComponent(value);
+    });
+    try {
+      axios.defaults.withCredentials = true;
+      const response = await axios.post(`${options.baseURL}/j_spring_security_check`, payload, {
+        withCredentials: true,
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "X-Requested-With": "XMLHttpRequest"
+        }
+      });
+      const xsrfCookieValue = response.data ? response.data[XSRF_COOKIE_NAME] : "";
+      dispatch(setToken(xsrfCookieValue));
+      dispatch(setIsLoggedIn(true));
+      await dispatch(loadSecurityInfo(options.baseURL)).unwrap();
+      clearAccessCache();
+      return getState().auth.loggedInUser;
+    } catch (error) {
+      console.error("Login error:", error);
+      const errorInfo = {
+        message: error.message,
+        status: (_a = error.response) == null ? void 0 : _a.status,
+        statusText: (_b = error.response) == null ? void 0 : _b.statusText,
+        data: (_c = error.response) == null ? void 0 : _c.data,
+        url: (_d = error.config) == null ? void 0 : _d.url,
+        method: (_e = error.config) == null ? void 0 : _e.method
+      };
+      return rejectWithValue(errorInfo);
+    }
+  }
+);
+const logout = createAsyncThunk(
+  "auth/logout",
+  async (options, { dispatch, getState }) => {
+    var _a, _b, _c;
+    let responseData = null;
+    try {
+      const response = await axios.post(`${options.baseURL}/j_spring_security_logout`, null, {
+        withCredentials: true,
+        headers: {
+          "X-Requested-With": "XMLHttpRequest"
+        }
+      });
+      responseData = response == null ? void 0 : response.data;
+      const redirectURI = getValidJSON(response == null ? void 0 : response.data);
+      console.debug("Logout response", responseData, redirectURI);
+      if (redirectURI && redirectURI.result) {
+        window.location.href = redirectURI.result;
+      }
+    } catch (error) {
+      console.error("Logout error:", error);
+    } finally {
+      await dispatch(loadSecurityInfo(options.baseURL)).unwrap();
+      dispatch(setIsLoggedIn(false));
+      dispatch(setLandingPage(""));
+      clearAccessCache();
+      const router = getRouterInstance();
+      const isPreview = getActiveRoutingBasePath() === PREVIEW_ROUTING_BASEPATH;
+      if (router && isPreview) {
+        const state = getState();
+        const loginPage = ((_c = (_b = (_a = state.auth) == null ? void 0 : _a.securityConfig) == null ? void 0 : _b.loginConfig) == null ? void 0 : _c.pageName) || "Login";
+        router.replace(`/${PREVIEW_ROUTING_BASEPATH}/${loginPage}`);
+      }
+    }
+    return Promise.resolve(responseData);
+  }
+);
+const canAccessPage = createAsyncThunk(
+  "auth/canAccessPage",
+  async ({ pageName }, { getState, dispatch }) => {
+    var _a, _b, _c, _d;
+    const state = getState();
+    const userRoles = ((_a = state.auth.loggedInUser) == null ? void 0 : _a.roles) || [];
+    const isSecurityEnabled = (_b = state.auth.securityConfig) == null ? void 0 : _b.isSecurityEnabled;
+    const pages = ((_c = state.info.appConfig) == null ? void 0 : _c.pages) || [];
+    const routeConfig = pages.find((route) => route.name === pageName);
+    if (!isSecurityEnabled || !routeConfig) {
+      return true;
+    } else if ((!routeConfig.allowedRoles || routeConfig.allowedRoles.length === 0) && checkPublicAccess(pageName)) {
+      return true;
+    }
+    const hasRequiredRole = (_d = routeConfig == null ? void 0 : routeConfig.allowedRoles) == null ? void 0 : _d.some(
+      (role) => userRoles.includes(role)
+    );
+    if (!hasRequiredRole) {
+      dispatch(redirectToLogin({ redirectTo: pageName })).unwrap();
+    }
+    return hasRequiredRole;
+  }
+);
+const checkAccess = createAsyncThunk(
+  "auth/checkAccess",
+  async ({ name, type }, { getState, dispatch }) => {
+    var _a, _b, _c, _d, _e, _f;
+    const state = getState();
+    const userRoles = ((_a = state.auth.loggedInUser) == null ? void 0 : _a.roles) || [];
+    const isAuthenticated = ((_b = state.auth.loggedInUser) == null ? void 0 : _b.isAuthenticated) || false;
+    const isSecurityEnabled = (_c = state.auth.securityConfig) == null ? void 0 : _c.isSecurityEnabled;
+    if (!isSecurityEnabled) {
+      return true;
+    }
+    const configs = type === "PAGE" ? ((_d = state.info.appConfig) == null ? void 0 : _d.pages) || [] : type === "PREFAB" ? ((_e = state.info.prefabs[name]) == null ? void 0 : _e.pages) || [] : ((_f = state.info.appConfig) == null ? void 0 : _f.partials) || [];
+    const config = type === "PREFAB" ? configs[0] : configs == null ? void 0 : configs.find((item) => item.name.toLowerCase() === name.toLowerCase());
+    if (!config) {
+      return false;
+    }
+    switch (config.permission) {
+      case "PermitAll":
+        return true;
+      case "Authenticated":
+        return isAuthenticated;
+      case "Role":
+        if (!isAuthenticated) {
+          return false;
+        }
+        const allowedRoles = config.allowedRoles || [];
+        if (allowedRoles.length === 0) {
+          return false;
+        }
+        const hasRole = allowedRoles.some((role) => userRoles.includes(role));
+        return hasRole;
+      default:
+        return false;
+    }
+  }
+);
+const navigateToLandingPage = createAsyncThunk(
+  "auth/navigate/landingpage",
+  async ({ baseUrl, pageName }, { getState, dispatch }) => {
+    var _a, _b, _c, _d;
+    const state = getState();
+    const { auth = {} } = state;
+    const redirectTo = getCurrentRouteQueryParam("redirectTo");
+    let landingPageToNavigate;
+    if (redirectTo) {
+      landingPageToNavigate = `/${getActiveRoutingBasePath()}/${redirectTo}`;
+    } else if (auth.landingPage) {
+      landingPageToNavigate = auth.landingPage;
+    } else {
+      const homePage = ((_c = (_b = (_a = state.info) == null ? void 0 : _a.appConfig) == null ? void 0 : _b.appProperties) == null ? void 0 : _c.homePage) || "Main";
+      const userLandingPage = (_d = auth.loggedInUser) == null ? void 0 : _d.landingPage;
+      landingPageToNavigate = userLandingPage ? `/${getActiveRoutingBasePath()}/${userLandingPage}` : `/${getActiveRoutingBasePath()}/${homePage}`;
+    }
+    const router = getRouterInstance();
+    if (router) {
+      router.push(landingPageToNavigate);
+    }
+    if (auth.landingPage) {
+      dispatch(setLandingPage(""));
+    }
+  }
+);
+const redirectToLogin = createAsyncThunk(
+  "auth/navigate/loginPage",
+  async ({ redirectTo, securityConfig }, { getState }) => {
+    var _a, _b, _c, _d, _e;
+    const state = getState();
+    const homePage = (_c = (_b = (_a = state.info) == null ? void 0 : _a.appConfig) == null ? void 0 : _b.appProperties) == null ? void 0 : _c.homePage;
+    const isPublicPage = checkPublicAccess();
+    if (((_d = securityConfig == null ? void 0 : securityConfig.loginConfig) == null ? void 0 : _d.type) === "SSO" && !isPublicPage) {
+      handle401();
+    } else {
+      const loginPage = ((_e = securityConfig == null ? void 0 : securityConfig.loginConfig) == null ? void 0 : _e.pageName) || "Login";
+      if (redirectTo && !redirectTo.startsWith("/" + loginPage)) {
+        setLandingPage(`/${getActiveRoutingBasePath()}/${redirectTo}`);
+      }
+      const router = getRouterInstance();
+      if (router && !isPublicPage) {
+        const loginPath = `/${getActiveRoutingBasePath()}/${loginPage}`;
+        const loginUrl = redirectTo && redirectTo.toLowerCase() !== homePage.toLowerCase() ? `${loginPath}?redirectTo=${redirectTo}` : loginPath;
+        router.push(loginUrl);
+      }
+    }
+  }
+);
+const authSlice = createSlice({
+  name: "auth",
+  initialState,
+  reducers: {
+    setIsLoggedIn: (state, action) => {
+      state.isLoggedIn = action.payload;
+    },
+    setLoggedInUser: (state, action) => {
+      state.loggedInUser = action.payload ? __spreadProps(__spreadValues(__spreadValues({}, defaultUserState), action.payload), {
+        roles: action.payload.roles || [],
+        userAttributes: action.payload.userAttributes || {},
+        isAuthenticated: Boolean(action.payload.isAuthenticated),
+        isSecurityEnabled: Boolean(action.payload.isSecurityEnabled)
+      }) : defaultUserState;
+    },
+    setSecurityConfig: (state, action) => {
+      state.securityConfig = action.payload;
+    },
+    setToken: (state, action) => {
+      state.token = action.payload;
+    },
+    setLandingPage: (state, action) => {
+      state.landingPage = action.payload;
+    },
+    setPageLoading: (state, action) => {
+      state.isPageLoading = action.payload;
+    },
+    clearError: (state) => {
+      state.error = null;
+    }
+  }
+});
+const {
+  setIsLoggedIn,
+  setLoggedInUser,
+  setSecurityConfig,
+  setToken,
+  setLandingPage,
+  setPageLoading,
+  clearError
+} = authSlice.actions;
+var authSlice_default = authSlice.reducer;
+export {
+  SESSION,
+  USER_ROLE,
+  XSRF_COOKIE_NAME,
+  XSRF_HEADER_NAME,
+  canAccessPage,
+  checkAccess,
+  clearError,
+  authSlice_default as default,
+  defaultUserState,
+  loadSecurityInfo,
+  login,
+  logout,
+  navigateToLandingPage,
+  redirectToLogin,
+  setIsLoggedIn,
+  setLandingPage,
+  setLoggedInUser,
+  setPageLoading,
+  setSecurityConfig,
+  setToken
+};

package/store/slices/i18nSlice.d.ts

@@ -0,0 +1,27 @@
+export interface I18nState {
+    selectedLocale: string;
+    /** Bumped on each bundle load so React trees can re-bind locale labels globally. */
+    localeRevision: number;
+    defaultSupportedLocale: string;
+    appLocale: any;
+    dateFormat: string;
+    timeFormat: string;
+    dateTimeFormat: string;
+    currencyCode: string;
+    timezone: string;
+    isLoading: boolean;
+    error: string | null;
+    prefabMessages: Record<string, string>;
+}
+export declare const loadLocaleBundle: import("@reduxjs/toolkit").AsyncThunk<{
+    data: any;
+    locale: any;
+}, void, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const setSelectedLocaleAndLoadBundle: import("@reduxjs/toolkit").AsyncThunk<string, {
+    locale: string | {
+        datavalue: string;
+    };
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const setTimezone: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "i18n/setTimezone">, setAppLocale: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "i18n/setAppLocale">, setDateFormat: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "i18n/setDateFormat">, setTimeFormat: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "i18n/setTimeFormat">, setCurrencyCode: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "i18n/setCurrencyCode">;
+declare const _default: import("redux").Reducer<import("immer").WritableDraft<I18nState>>;
+export default _default;

package/store/slices/i18nSlice.js

@@ -0,0 +1,209 @@
+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 { createSlice, createAsyncThunk } from "@reduxjs/toolkit";
+import axios from "axios";
+import toLower from "lodash-es/toLower";
+import map from "lodash-es/map";
+import { includes, intersection, isObject } from "lodash-es";
+import {
+  getSessionStorageItem,
+  setSessionStorageItem
+} from "../../core/util";
+import { setCSS } from "../../core/util/dom";
+import { store } from "..";
+import appstore from "../../core/appstore";
+import { resolveBasePath } from "../util/resolve-path";
+const APP_LOCALE_ROOT_PATH = "/resources/i18n";
+const RTL_LANGUAGE_CODES = [
+  "ar",
+  "ar-001",
+  "ar-ae",
+  "ar-bh",
+  "ar-dz",
+  "ar-eg",
+  "ar-iq",
+  "ar-jo",
+  "ar-kw",
+  "ar-lb",
+  "ar-ly",
+  "ar-ma",
+  "ar-om",
+  "ar-qa",
+  "ar-sa",
+  "ar-sd",
+  "ar-sy",
+  "ar-tn",
+  "ar-ye",
+  "arc",
+  "bcc",
+  "bqi",
+  "ckb",
+  "dv",
+  "fa",
+  "glk",
+  "he",
+  "ku",
+  "mzn",
+  "pnb",
+  "ps",
+  "sd",
+  "ug",
+  "ur",
+  "yi"
+];
+const initialState = {
+  selectedLocale: "",
+  localeRevision: 0,
+  defaultSupportedLocale: "en",
+  appLocale: {},
+  dateFormat: "MMM d, y",
+  timeFormat: "h:mm:ss a",
+  dateTimeFormat: "MMM d, y h:mm:ss a",
+  currencyCode: "USD",
+  timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+  isLoading: false,
+  error: null,
+  prefabMessages: {}
+};
+function updateLocaleDirection(locale) {
+  let direction = "ltr";
+  if (RTL_LANGUAGE_CODES.includes(locale)) {
+    direction = "rtl";
+  }
+  setCSS(document.body, "direction", direction);
+}
+const loadLocaleBundle = createAsyncThunk(
+  "i18n/loadLocaleBundle",
+  async (_, { rejectWithValue }) => {
+    const appProperties = store.getState().info.appConfig.appProperties;
+    function getAcceptedLanguages() {
+      var _a;
+      let languages = decodeURIComponent(appProperties.preferredLanguage || "");
+      languages = (_a = languages == null ? void 0 : languages.split(",")) == null ? void 0 : _a.map(function(locale2) {
+        return locale2 == null ? void 0 : locale2.split(";")[0];
+      });
+      return map(languages, toLower);
+    }
+    const _acceptLang = getAcceptedLanguages();
+    const _defaultLanguage = appProperties.defaultLanguage;
+    _acceptLang.push(_defaultLanguage);
+    let preferBrowserLang = appProperties.preferBrowserLang;
+    if (!preferBrowserLang) {
+      preferBrowserLang = true;
+    } else {
+      preferBrowserLang = preferBrowserLang === "true" || preferBrowserLang === true ? true : false;
+    }
+    let _supportedLang = (Object == null ? void 0 : Object.keys(appProperties.supportedLanguages)) || [
+      initialState.defaultSupportedLocale
+    ];
+    let _selectedDefaultLang = preferBrowserLang ? void 0 : _defaultLanguage;
+    const sessionLanguage = getSessionStorageItem("selectedLocale");
+    let localLanguage = includes(_supportedLang, sessionLanguage) && sessionLanguage;
+    let locale = localLanguage || _selectedDefaultLang || intersection(_acceptLang, _supportedLang)[0] || initialState.defaultSupportedLocale;
+    try {
+      const url = store.getState().info.appConfig.url;
+      const path = `${resolveBasePath(url) + APP_LOCALE_ROOT_PATH}/${locale}.json`;
+      const response = await axios.get(path);
+      setSessionStorageItem("selectedLocale", locale);
+      const i18nService = appstore.I18nService.get();
+      if (i18nService) {
+        i18nService.selectedLocale = locale;
+      }
+      updateLocaleDirection(locale);
+      appstore.set("i18nService", __spreadProps(__spreadValues(__spreadValues({}, i18nService), response.data), { selectedLocale: locale }));
+      return { data: response.data, locale };
+    } catch (error) {
+      console.warn(`Error loading locale resource: ${error}`);
+      return rejectWithValue("Failed to load locale bundle");
+    }
+  }
+);
+const setSelectedLocaleAndLoadBundle = createAsyncThunk(
+  "i18n/setSelectedLocaleAndLoadBundle",
+  async ({ locale }, { dispatch, getState }) => {
+    let localeValue = isObject(locale) ? locale.datavalue : locale;
+    const appProperties = store.getState().info.appConfig.appProperties;
+    const supportedLocales = Object.keys(appProperties.supportedLanguages);
+    if (!includes(supportedLocales, localeValue)) {
+      return null;
+    }
+    if (!localeValue || localeValue === getState().i18n.selectedLocale) {
+      return null;
+    }
+    const currentLocale = getSessionStorageItem("selectedLocale");
+    if (currentLocale === localeValue) {
+      return null;
+    }
+    setSessionStorageItem("selectedLocale", localeValue);
+    updateLocaleDirection(localeValue);
+    await dispatch(loadLocaleBundle());
+    return localeValue;
+  }
+);
+const i18nSlice = createSlice({
+  name: "i18n",
+  initialState,
+  reducers: {
+    setTimezone: (state, action) => {
+      state.timezone = action.payload;
+    },
+    setAppLocale: (state, action) => {
+      state.appLocale = action.payload;
+    },
+    setDateFormat: (state, action) => {
+      state.dateFormat = action.payload;
+      state.dateTimeFormat = `${action.payload} ${state.timeFormat}`;
+    },
+    setTimeFormat: (state, action) => {
+      state.timeFormat = action.payload;
+      state.dateTimeFormat = `${state.dateFormat} ${action.payload}`;
+    },
+    setCurrencyCode: (state, action) => {
+      state.currencyCode = action.payload;
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addCase(loadLocaleBundle.fulfilled, (state, action) => {
+      var _a, _b, _c;
+      state.appLocale = action.payload.data.messages || {};
+      state.dateFormat = ((_a = action.payload.data.formats) == null ? void 0 : _a.date) || state.dateFormat;
+      state.timeFormat = ((_b = action.payload.data.formats) == null ? void 0 : _b.time) || state.timeFormat;
+      state.currencyCode = ((_c = action.payload.data.formats) == null ? void 0 : _c.currency) || state.currencyCode;
+      state.dateTimeFormat = `${state.dateFormat} ${state.timeFormat}`;
+      state.prefabMessages = action.payload.data.prefabMessages || {};
+      state.selectedLocale = action.payload.locale || state.selectedLocale;
+      state.localeRevision += 1;
+    }).addCase(loadLocaleBundle.rejected, (state, action) => {
+      state.error = action.payload;
+    });
+  }
+});
+const { setTimezone, setAppLocale, setDateFormat, setTimeFormat, setCurrencyCode } = i18nSlice.actions;
+var i18nSlice_default = i18nSlice.reducer;
+export {
+  i18nSlice_default as default,
+  loadLocaleBundle,
+  setAppLocale,
+  setCurrencyCode,
+  setDateFormat,
+  setSelectedLocaleAndLoadBundle,
+  setTimeFormat,
+  setTimezone
+};

package/store/slices/navigationSlice.d.ts

@@ -0,0 +1,7 @@
+export interface NavigationState {
+    pendingAccordionExpansion: string | null;
+    pendingTabSelection: string | null;
+}
+export declare const setPendingAccordionExpansion: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<string, "navigation/setPendingAccordionExpansion">, clearPendingAccordionExpansion: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"navigation/clearPendingAccordionExpansion">, setPendingTabSelection: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<string, "navigation/setPendingTabSelection">, clearPendingTabSelection: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"navigation/clearPendingTabSelection">;
+declare const _default: import("redux").Reducer<NavigationState>;
+export default _default;

package/store/slices/navigationSlice.js

@@ -0,0 +1,37 @@
+import { createSlice } from "@reduxjs/toolkit";
+const initialState = {
+  pendingAccordionExpansion: null,
+  pendingTabSelection: null
+};
+const navigationSlice = createSlice({
+  name: "navigation",
+  initialState,
+  reducers: {
+    setPendingAccordionExpansion: (state, action) => {
+      state.pendingAccordionExpansion = action.payload;
+    },
+    clearPendingAccordionExpansion: (state) => {
+      state.pendingAccordionExpansion = null;
+    },
+    setPendingTabSelection: (state, action) => {
+      state.pendingTabSelection = action.payload;
+    },
+    clearPendingTabSelection: (state) => {
+      state.pendingTabSelection = null;
+    }
+  }
+});
+const {
+  setPendingAccordionExpansion,
+  clearPendingAccordionExpansion,
+  setPendingTabSelection,
+  clearPendingTabSelection
+} = navigationSlice.actions;
+var navigationSlice_default = navigationSlice.reducer;
+export {
+  clearPendingAccordionExpansion,
+  clearPendingTabSelection,
+  navigationSlice_default as default,
+  setPendingAccordionExpansion,
+  setPendingTabSelection
+};

package/store/util/resolve-path.d.ts

@@ -0,0 +1 @@
+export declare const resolveBasePath: (baseUrl: string) => string;

package/store/util/resolve-path.js

@@ -0,0 +1,7 @@
+const BASE_PATH = typeof process !== "undefined" ? process.env.NEXT_PUBLIC_BASE_PATH || "" : "";
+const resolveBasePath = (baseUrl) => {
+  return `${baseUrl || BASE_PATH || ""}`;
+};
+export {
+  resolveBasePath
+};