@stokr/components-library 3.0.16 → 3.0.17

package/dist/context/AuthContext.js

@@ -0,0 +1,781 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import PropTypes from "prop-types";
+import axiosInstance from "../model/axios.js";
+import React__default, { Component } from "react";
+import fetchData from "../api/fetchData.js";
+import { identify, reset } from "../analytics/index.js";
+import { withRouter } from "../utils/withRouter.js";
+import { configure, getConfig } from "../config.js";
+import { Text } from "../components/Text/Text.styles.js";
+import { getFirebaseAuth } from "../firebase-config.js";
+import { Auth } from "./Auth.js";
+import { DEFAULT_TOKEN_EXPIRY_MS } from "./Auth.js";
+import { ConfirmModal as ConfirmModalComponent } from "../components/ConfirmModal/ConfirmModal.js";
+import avatarPlaceholder from "../static/images/avatar-placeholder.png.js";
+import { signOut, getMultiFactorResolver, PhoneMultiFactorGenerator, TotpMultiFactorGenerator, multiFactor } from "firebase/auth";
+const AuthContext = React__default.createContext();
+const INACTIVITY_TIME_MS = 5 * 60 * 1e3;
+const INACTIVITY_EVENTS = ["mousemove", "keydown", "click", "scroll", "touchstart"];
+class AuthProviderClass extends Component {
+  userRef = React__default.createRef(null);
+  inactivityTimerRef = null;
+  cookieExpiryTimerRef = null;
+  // Timestamp of the last inactivity timer reset; used to throttle the reset
+  // to at most once per second so frequent DOM events (mousemove fires 30-60×/s)
+  // don't continuously create and destroy setTimeout objects.
+  _lastActivityAt = 0;
+  state = {
+    user: void 0,
+    firebaseUser: void 0,
+    // Start as `true` when a session cookie already exists so the app
+    // shows a loader immediately instead of flashing the login form
+    // for a frame before componentDidMount fires getUser().
+    // When there is no cookie the value stays `false` so the login
+    // page appears instantly without any loader.
+    isFetchingUser: !!Auth.getAccessToken(),
+    avatar: avatarPlaceholder,
+    userMfaEnrollment: null,
+    waitingFor2fa: false,
+    firebaseError: null,
+    verifyEmailError: null,
+    isVerifyingEmail: false,
+    loggedOutDueToInactivity: false,
+    loggedOutDueToCookieExpiry: false
+  };
+  componentDidMount() {
+    if (this.props.config) {
+      configure(this.props.config);
+      if (this.props.config.firebase == null && typeof console !== "undefined" && console.warn) {
+        console.warn(
+          "[@stokr/components-library] <AuthProvider> config has no `firebase` property. Auth (login, 2FA, session) may fail with auth/internal-error or auth/network-request-failed. Pass config.firebase with your Firebase project config (apiKey, authDomain, projectId, etc.)."
+        );
+      }
+    } else if (typeof console !== "undefined" && console.warn) {
+      console.warn(
+        "[@stokr/components-library] <AuthProvider> rendered without a `config` prop. API URLs, Firebase, and cookie domain will use values baked at library build time. Pass a config prop to use your app’s environment variables at runtime. See: https://github.com/stokr-io/components-library#runtime-config"
+      );
+    }
+    const isActivatingUser = window.location.href.includes("verifyEmail");
+    if (isActivatingUser) {
+      this.handleVerifyEmail();
+    } else if (getFirebaseAuth()) {
+      this.getUser().catch((err) => {
+        if (typeof console !== "undefined" && console.debug) {
+          console.debug("[AuthProvider] getUser() on mount failed:", err?.message || err);
+        }
+      });
+    } else if (typeof console !== "undefined" && console.debug) {
+      console.debug(
+        "[@stokr/components-library] getUser() not run on mount: Firebase not initialized. Pass config.firebase to AuthProvider."
+      );
+    }
+    INACTIVITY_EVENTS.forEach((event) => window.addEventListener(event, this.resetInactivityTimer));
+  }
+  componentDidUpdate(prevProps, prevState) {
+    const hadUser = prevState.user || prevState.firebaseUser;
+    const hasUser = this.state.user || this.state.firebaseUser;
+    if (!hadUser && hasUser) {
+      this.resetInactivityTimer();
+      this.scheduleCookieExpiryLogout();
+    } else if (hadUser && !hasUser) {
+      this.clearInactivityTimer();
+      this.clearCookieExpiryTimer();
+    }
+  }
+  componentWillUnmount() {
+    INACTIVITY_EVENTS.forEach((event) => window.removeEventListener(event, this.resetInactivityTimer));
+    this.clearInactivityTimer();
+    this.clearCookieExpiryTimer();
+  }
+  checkTokenIsValid = (redirect = false) => {
+    const accessToken = Auth.getAccessToken();
+    if (!accessToken) {
+      this.logoutUser(redirect, { dueToCookieExpiry: true });
+    }
+    return !!accessToken;
+  };
+  clearInactivityTimer = () => {
+    if (this.inactivityTimerRef) {
+      clearTimeout(this.inactivityTimerRef);
+      this.inactivityTimerRef = null;
+    }
+  };
+  clearCookieExpiryTimer = () => {
+    if (this.cookieExpiryTimerRef != null) {
+      clearTimeout(this.cookieExpiryTimerRef);
+      this.cookieExpiryTimerRef = null;
+    }
+  };
+  scheduleCookieExpiryLogout = () => {
+    if (this.cookieExpiryTimerRef != null) {
+      clearTimeout(this.cookieExpiryTimerRef);
+      this.cookieExpiryTimerRef = null;
+    }
+    const { user, firebaseUser } = this.state;
+    if (!user && !firebaseUser) return;
+    const expiresAt = Auth.getAccessTokenExpiresAt();
+    if (!expiresAt) return;
+    const delay = expiresAt - Date.now();
+    if (delay <= 0) {
+      this.logoutUser(false, { dueToCookieExpiry: true });
+      return;
+    }
+    this.cookieExpiryTimerRef = setTimeout(() => {
+      this.cookieExpiryTimerRef = null;
+      this.logoutUser(false, { dueToCookieExpiry: true });
+    }, delay);
+  };
+  getInactivityTimeMs = () => {
+    const { inactivityTimeMs } = this.props;
+    return typeof inactivityTimeMs === "number" && inactivityTimeMs > 0 ? inactivityTimeMs : INACTIVITY_TIME_MS;
+  };
+  resetInactivityTimer = () => {
+    const now = Date.now();
+    if (now - this._lastActivityAt < 1e3) return;
+    this._lastActivityAt = now;
+    this.clearInactivityTimer();
+    const { user, firebaseUser } = this.state;
+    if (user || firebaseUser) {
+      const delay = this.getInactivityTimeMs();
+      this.inactivityTimerRef = setTimeout(() => {
+        this.inactivityTimerRef = null;
+        this.logoutUser(false, { dueToInactivity: true });
+      }, delay);
+    }
+  };
+  loginUser = async (email, password, customToken) => {
+    try {
+      let user;
+      if (customToken) {
+        user = await Auth.signInWithToken(customToken);
+      } else {
+        user = await Auth.login(email, password);
+      }
+      const token = await user.getIdToken();
+      const expiryMs = Number(this.props.accessTokenExpiryMs);
+      Auth.setAccessToken(token, Number.isFinite(expiryMs) && expiryMs > 0 ? { expiresInMs: expiryMs } : void 0);
+      this.setState({
+        firebaseUser: user
+      });
+      await this.getUser(token, user);
+      return user;
+    } catch (error) {
+      console.log("🚀 ~ file: AuthContext.js:56 ~ error:", error);
+      const httpStatus = error?.response?.status;
+      if (httpStatus != null) {
+        const auth = getFirebaseAuth();
+        if (auth) signOut(auth).catch(() => {
+        });
+        Auth.logout();
+        this.setState({ firebaseUser: null });
+        if (httpStatus === 401 || httpStatus === 403) {
+          error.message = "Your account was authenticated but the server rejected the session. Please verify that the API and Firebase environments match, or contact support.";
+        }
+        throw error;
+      }
+      switch (error.code) {
+        case "auth/internal-error":
+          error.message = "Authentication service error. Ensure AuthProvider receives config.firebase and your domain is authorized in Firebase Console.";
+          throw error;
+        case "auth/multi-factor-auth-required":
+          this.setState({ waitingFor2fa: true, firebaseError: error });
+          throw error;
+        case "auth/requires-recent-login":
+          this.logoutUser();
+          break;
+        case "auth/invalid-login-credentials":
+        case "auth/invalid-credential":
+          error.message = "The credentials are not correct. Try again?";
+          throw error;
+        case "auth/invalid-custom-token":
+        case "auth/argument-error":
+          error.message = "This sign-in link is invalid, expired, or was already used. Please sign in again or request a new link.";
+          throw error;
+        case "auth/network-request-failed":
+          error.message = "Unable to reach the authentication server. Check your connection and try again.";
+          throw error;
+        default:
+          console.log({ error });
+          throw error;
+      }
+    }
+  };
+  createUser = async (email, password) => {
+    try {
+      await Auth.createUser(email, password);
+    } catch (error) {
+      console.log("🚀 ~ file: AuthContext.js:56 ~ error:", error);
+      throw error;
+    }
+  };
+  loginUserWithTotp = async (verificationCode, error) => {
+    const auth = getFirebaseAuth();
+    if (!auth) {
+      throw new Error("Firebase is not configured.");
+    }
+    const mfaResolver = getMultiFactorResolver(auth, error);
+    const selectedIndex = 0;
+    switch (mfaResolver.hints[selectedIndex].factorId) {
+      case TotpMultiFactorGenerator.FACTOR_ID: {
+        const otpFromAuthenticator = verificationCode;
+        const multiFactorAssertion = TotpMultiFactorGenerator.assertionForSignIn(
+          mfaResolver.hints[selectedIndex].uid,
+          otpFromAuthenticator
+        );
+        try {
+          const userCredential = await mfaResolver.resolveSignIn(multiFactorAssertion);
+          const user = userCredential.user;
+          const token = await user.getIdToken();
+          const expiryMs = Number(this.props.accessTokenExpiryMs);
+          Auth.setAccessToken(token, Number.isFinite(expiryMs) && expiryMs > 0 ? { expiresInMs: expiryMs } : void 0);
+          this.setState({ firebaseUser: user, waitingFor2fa: false });
+          await this.getUser(token, user);
+        } catch (_error) {
+          console.log({ _error });
+          throw _error;
+        }
+        break;
+      }
+      case PhoneMultiFactorGenerator.FACTOR_ID:
+        break;
+    }
+  };
+  generateTotpSecret = async (user = getFirebaseAuth()?.currentUser, appName = "STOKR") => {
+    try {
+      const multiFactorSession = await multiFactor(user).getSession();
+      const totpSecret = await TotpMultiFactorGenerator.generateSecret(multiFactorSession);
+      const totpUri = totpSecret.generateQrCodeUrl(user.email, appName);
+      return { totpUri, totpSecret };
+    } catch (error) {
+      console.log("🚀 ~ file: AuthContext.js:51 ~ error:", error);
+      throw error;
+    }
+  };
+  unenrollUser2FA = async () => {
+    const { userMfaEnrollment, user } = this.state;
+    if (userMfaEnrollment?.length === 0) {
+      console.log("User is not enrolled in 2FA");
+      return;
+    }
+    try {
+      for (let i = 0; i < userMfaEnrollment.length; i++) {
+        await multiFactor(user).unenroll(userMfaEnrollment[i].uid);
+      }
+    } catch (error) {
+      console.log({ error });
+      throw error;
+    }
+  };
+  checkMfaEnrollment = (user = getFirebaseAuth()?.currentUser) => {
+    const checkMfaEnrollment = multiFactor(user).enrolledFactors;
+    this.setState({
+      userMfaEnrollment: checkMfaEnrollment
+    });
+    return checkMfaEnrollment;
+  };
+  enrollUserToTotp = async (user, totpSecret, verificationCode, displayName) => {
+    const multiFactorAssertion = TotpMultiFactorGenerator.assertionForEnrollment(totpSecret, verificationCode);
+    await multiFactor(user).enroll(multiFactorAssertion, displayName);
+  };
+  logoutUser = async (redirect = false, options = {}) => {
+    console.log("🚀 ~ file: AuthContext.js:303 ~ logoutUser ~ redirect:", redirect);
+    this.clearCookieExpiryTimer();
+    try {
+      const auth = getFirebaseAuth();
+      if (auth) signOut(auth).then(() => {
+      });
+      Auth.logout();
+    } catch (_e) {
+    }
+    delete axiosInstance.defaults.headers.common.Authorization;
+    reset();
+    this.setUser(null);
+    this.setState({
+      firebaseUser: null,
+      firebaseError: null,
+      verifyEmailError: null,
+      userMfaEnrollment: null,
+      waitingFor2fa: false,
+      isVerifyingEmail: false,
+      avatar: avatarPlaceholder,
+      isFetchingUser: false,
+      loggedOutDueToInactivity: options.dueToInactivity === true,
+      loggedOutDueToCookieExpiry: options.dueToCookieExpiry === true
+    });
+    if (redirect) {
+      window.location.href = `https://${getConfig("websiteDomain")}`;
+    }
+  };
+  clearLoggedOutDueToInactivity = () => {
+    this.setState({ loggedOutDueToInactivity: false });
+  };
+  clearLoggedOutDueToCookieExpiry = () => {
+    this.setState({ loggedOutDueToCookieExpiry: false });
+  };
+  /** Call when user cancels the 2FA step (e.g. goes back to login to try another account). */
+  reset2faFlow = () => {
+    this.setState({ waitingFor2fa: false, firebaseError: null });
+  };
+  patchUserObject = (user, firebaseUser) => {
+    if (!user || !firebaseUser) return;
+    const merged = Object.assign(Object.create(Object.getPrototypeOf(firebaseUser)), firebaseUser, user);
+    merged.active = merged.emailVerified;
+    return merged;
+  };
+  checkUserPhoto = (avatar) => {
+    try {
+      const http = new XMLHttpRequest();
+      http.open("HEAD", avatar, true);
+      http.onload = () => {
+        if (http.status === 200) {
+          this.setState({ avatar });
+        }
+      };
+      http.send();
+    } catch (error) {
+      console.log("error: ", error);
+    }
+  };
+  getUser = async (accessToken = Auth.getAccessToken(), firebaseUserOverride) => {
+    if (!accessToken) {
+      this.setState({
+        isFetchingUser: false,
+        user: null,
+        firebaseUser: null
+      });
+      if (typeof console !== "undefined" && console.debug) {
+        console.debug(
+          "[@stokr/components-library] getUser() skipped: no access token. If you expected a session, ensure config.cookieDomain matches this origin (e.g. omit or use empty for localhost)."
+        );
+      }
+      return;
+    }
+    this.setState({
+      isFetchingUser: true
+    });
+    axiosInstance.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
+    const { customValidateGetUser } = this.props;
+    try {
+      const existingFirebaseUser = firebaseUserOverride || this.state.firebaseUser || getFirebaseAuth()?.currentUser;
+      const [result, tokenRes] = await Promise.all([
+        Auth.getUser(),
+        !existingFirebaseUser ? fetchData("auth/get-custom-token") : Promise.resolve(null)
+      ]);
+      let firebaseUser = existingFirebaseUser;
+      if (!firebaseUser) {
+        const customToken = tokenRes?.customToken ?? tokenRes?.custom_token ?? tokenRes?.token ?? tokenRes;
+        firebaseUser = await Auth.signInWithToken(customToken);
+      }
+      const user = this.patchUserObject(result.user, firebaseUser);
+      this.checkUserIsValid(user);
+      customValidateGetUser?.(user);
+      const userAvatar = `${getConfig("photoApiUrl")}/media/picture/view/${user._id}`;
+      this.checkUserPhoto(userAvatar);
+      this.setUser(user);
+      this.setState({
+        isFetchingUser: false
+      });
+      identify(user._id, {
+        role: user.user_type,
+        is_internal: user.email?.endsWith("@stokr.io") ?? false
+      });
+      this.replaceLocationPathName();
+      return user;
+    } catch (error) {
+      this.setState({
+        isFetchingUser: false
+      });
+      const code = error?.code;
+      if (code === "auth/internal-error" || code === "auth/network-request-failed") {
+        Auth.logout();
+        if (typeof console !== "undefined" && console.warn) {
+          console.warn(
+            "[@stokr/components-library] getUser() failed with",
+            code,
+            "— session cleared. Ensure AuthProvider receives config.firebase for this origin and that the domain is authorized in Firebase Console (Authentication → Settings → Authorized domains)."
+          );
+        }
+        return;
+      }
+      console.log(`Error in getUser: ${error}`);
+      throw error;
+    }
+  };
+  checkUserIsValid = (user) => {
+    if (!user) {
+      throw new Error("User is not defined");
+    } else if (!user?.emailVerified && !window.location.href.includes("signup.")) {
+      window.location.href = `https://signup.${getConfig("websiteDomain")}/resend-activation-email`;
+      return false;
+    } else if (!user?.country && user?.user_type === "investor" && !window.location.href.includes("signup.")) {
+      window.location.href = `https://signup.${getConfig("websiteDomain")}/welcome`;
+      return false;
+    }
+    return true;
+  };
+  uploadPhoto = async (file) => {
+    try {
+      const { user } = this.state;
+      if (!user || !file) {
+        return;
+      }
+      const formData = new FormData();
+      formData.append("userId", user._id);
+      formData.append("file", file);
+      const result = await Auth.uploadPhoto(formData);
+      this.setState({
+        avatar: `${getConfig("photoApiUrl")}/media/picture/view/${user._id}?ignore=${Date.now()}`
+      });
+      return result;
+    } catch (error) {
+      console.log(`Error: ${error}`);
+      throw error;
+    }
+  };
+  deletePhoto = async () => {
+    const { user } = this.state;
+    if (!user) {
+      return;
+    }
+    const formData = new FormData();
+    formData.append("userId", user._id);
+    await Auth.deletePhoto(formData);
+    this.setState({
+      avatar: void 0
+    });
+  };
+  replaceLocationPathName = () => {
+    const pathname = this.props.location?.pathname ?? "";
+    console.log("🚀 ~ file: AuthContext.js:511 ~ replaceLocationPathName ~ pathname:", pathname);
+    if (pathname === "/login" || pathname === "/signup") {
+      this.props.navigate("/");
+    }
+  };
+  updateUser = async (data) => {
+    try {
+      const existingFirebaseUser = this.state.firebaseUser;
+      const [{ user }, tokenRes] = await Promise.all([
+        Auth.updateUser(data),
+        !existingFirebaseUser ? fetchData("auth/get-custom-token") : Promise.resolve(null)
+      ]);
+      let firebaseUser = existingFirebaseUser;
+      if (!firebaseUser) {
+        const customToken = tokenRes?.customToken ?? tokenRes?.custom_token ?? tokenRes?.token ?? tokenRes;
+        firebaseUser = await Auth.signInWithToken(customToken);
+      }
+      const newUser = this.patchUserObject(user, firebaseUser);
+      this.setUser(newUser);
+      return user;
+    } catch (error) {
+      console.log(`Error updating the user: ${error}`);
+      throw error;
+    }
+  };
+  checkIfPrivateInvestor = async (project, user = this.state.user, returnData = false) => {
+    if (!user || !project) {
+      return;
+    }
+    try {
+      let dataToSend = {
+        userId: user._id,
+        projectId: project._id
+      };
+      const isPrivateInvestor = await Auth.checkPrivateInvestor(dataToSend);
+      const userCopy = { ...user };
+      userCopy.isPrivateInvestor = isPrivateInvestor.isAllowed;
+      userCopy.privateInvestorStatus = isPrivateInvestor.status;
+      if (returnData) {
+        return userCopy;
+      } else {
+        this.setState({ user: userCopy });
+      }
+    } catch (error) {
+      console.log("🚀 ~ error in checkPrivateInvestor", error);
+      throw error;
+    }
+  };
+  checkPrivateInvestorAll = async (user = this.state.user, returnData = false) => {
+    try {
+      const { list } = await Auth.checkPrivateInvestor();
+      if (list) {
+        const userCopy = { ...user };
+        userCopy.privateInvestorProjects = list;
+        if (returnData) {
+          return userCopy;
+        } else {
+          this.setState({ user: userCopy });
+        }
+      }
+    } catch (error) {
+      console.log("🚀 ~ error in checkPrivateInvestorAll", error);
+      throw error;
+    }
+  };
+  checkIfUserSubscribed = async (project, user = this.state.user, returnData = false) => {
+    if (!user || !project) {
+      return;
+    }
+    try {
+      let dataToSend = {
+        listName: project.name,
+        email: user.email
+      };
+      const isSubscribed = await Auth.checkIfUserSubscribed(dataToSend);
+      const userCopy = { ...user };
+      userCopy.isSubscribed = isSubscribed;
+      if (returnData) {
+        return userCopy;
+      } else {
+        this.setState({ user: userCopy });
+      }
+    } catch (error) {
+      console.log("🚀 ~ error in checkIfUserSubscribed", error);
+      throw error;
+    }
+  };
+  checkIfUserSubscribedAll = async (user = this.state.user, returnData = false) => {
+    if (!user) {
+      return;
+    }
+    try {
+      let dataToSend = {
+        email: user.email
+      };
+      const result = await Auth.checkIfUserSubscribed(dataToSend);
+      const userCopy = { ...user };
+      userCopy.subscribedProjects = result;
+      if (returnData) {
+        return userCopy;
+      } else {
+        this.setState({ user: userCopy });
+      }
+    } catch (error) {
+      console.log("🚀 ~ error in checkIfUserSubscribed", error);
+      throw error;
+    }
+  };
+  handleVerifyEmail = async () => {
+    this.setState({ isVerifyingEmail: true });
+    const { location } = this.props;
+    const query = new URLSearchParams(location.search);
+    try {
+      let oobCode = query.get("oobCode");
+      await Auth.handleVerifyEmail(oobCode);
+      this.setState({ isVerifyingEmail: false });
+      let customToken = query.get("customtoken");
+      if (customToken) {
+        await this.loginUser(null, null, customToken);
+      }
+    } catch (error) {
+      switch (error?.code) {
+        case "auth/expired-action-code": {
+          error.message = "The activation link has expired. We are sending you a new one right now.";
+          let email = query.get("email");
+          if (email) {
+            error.email = email;
+          }
+          break;
+        }
+        case "auth/invalid-action-code":
+          error.message = "This link is invalid. Please try verifying email again.";
+          break;
+        case "auth/user-disabled":
+          error.message = "Your account has been disabled. Please contact our support.";
+          break;
+      }
+      console.log("🚀 ~ file: AuthContext.js:446 ~ error:", error);
+      this.setState({
+        verifyEmailError: error,
+        isVerifyingEmail: false,
+        isFetchingUser: false
+      });
+    }
+  };
+  handleResetPassword = async (password) => {
+    const { location } = this.props;
+    try {
+      const query = new URLSearchParams(location.search);
+      let oobCode = query.get("oobCode");
+      await Auth.handleResetPassword(oobCode, password);
+    } catch (error) {
+      switch (error?.code) {
+        case "auth/expired-action-code":
+          error.message = "This link has expired. Please try reseting password again.";
+          break;
+        case "auth/invalid-action-code":
+          error.message = "This link is invalid. Please try reseting password again.";
+          break;
+        case "auth/user-disabled":
+          error.message = "Your account has been disabled. Please contact our support.";
+          break;
+      }
+      throw error;
+    }
+  };
+  sendWelcomeEmail = async () => {
+    try {
+      await Auth.sendWelcomeEmail();
+    } catch (error) {
+      console.log(`Error sending welcome email: ${error}`);
+    }
+  };
+  uploaProofOfAddress = async (data, ip) => {
+    try {
+      const user = await Auth.uploaProofOfAddress(data, ip);
+      this.setUser(user);
+    } catch (error) {
+      console.log(`Error uploading proof of address: ${error}`);
+      throw error;
+    }
+  };
+  validateGreenWalletId = async (id) => {
+    try {
+      return await Auth.validateGreenWalletId(id);
+    } catch (error) {
+      console.log(`Error validating Green Wallet ID: ${error}`);
+      throw error;
+    }
+  };
+  createWallet = async (data) => {
+    try {
+      const wallet = await Auth.createWallet(data);
+      return wallet;
+    } catch (error) {
+      console.log(`Error creating wallet: ${error}`);
+      throw error;
+    }
+  };
+  setUser = (user) => {
+    this.userRef.current = user;
+    this.setState({ user });
+  };
+  fetchLastTime = async (projectName, page, userId) => {
+    try {
+      let filterBody = {
+        projectName,
+        page
+      };
+      if (userId) {
+        filterBody.userId = userId;
+      }
+      let response = await Auth.fetchTrackingUserLastTime({
+        filter: filterBody
+      });
+      return response;
+    } catch (error) {
+      console.log(" error", error);
+    }
+  };
+  render() {
+    const { children } = this.props;
+    return /* @__PURE__ */ jsxs(
+      AuthContext.Provider,
+      {
+        value: {
+          ...this.state,
+          userRef: this.userRef,
+          checkUserIsValid: this.checkUserIsValid,
+          checkTokenIsValid: this.checkTokenIsValid,
+          checkUserPhoto: this.checkUserPhoto,
+          uploadPhoto: this.uploadPhoto,
+          deletePhoto: this.deletePhoto,
+          unenrollUser2FA: this.unenrollUser2FA,
+          loginUserWithTotp: this.loginUserWithTotp,
+          checkMfaEnrollment: this.checkMfaEnrollment,
+          generateTotpSecret: this.generateTotpSecret,
+          enrollUserToTotp: this.enrollUserToTotp,
+          loginUser: this.loginUser,
+          logoutUser: this.logoutUser,
+          getUser: this.getUser,
+          updateUser: this.updateUser,
+          checkIfPrivateInvestor: this.checkIfPrivateInvestor,
+          checkPrivateInvestorAll: this.checkPrivateInvestorAll,
+          checkIfUserSubscribed: this.checkIfUserSubscribed,
+          checkIfUserSubscribedAll: this.checkIfUserSubscribedAll,
+          sendWelcomeEmail: this.sendWelcomeEmail,
+          resendActivationEmail: Auth.resendActivationEmail,
+          uploaProofOfAddress: this.uploaProofOfAddress,
+          validateGreenWalletId: this.validateGreenWalletId,
+          fetchLastTime: this.fetchLastTime,
+          createWallet: this.createWallet,
+          requestUpdateEmail: Auth.requestUpdateEmail,
+          updatePassword: Auth.updateUserPassword,
+          createUser: this.createUser,
+          updateFirebaseUser: Auth.updateFirebaseUser,
+          handleResetPassword: this.handleResetPassword,
+          handleVerifyEmail: this.handleVerifyEmail,
+          setUser: this.setUser,
+          refreshIdToken: Auth.refreshIdToken,
+          clearLoggedOutDueToInactivity: this.clearLoggedOutDueToInactivity,
+          clearLoggedOutDueToCookieExpiry: this.clearLoggedOutDueToCookieExpiry,
+          reset2faFlow: this.reset2faFlow
+        },
+        children: [
+          children,
+          this.state.loggedOutDueToInactivity && !this.props.hideInactivityModal && /* @__PURE__ */ jsx(
+            ConfirmModalComponent,
+            {
+              isOpen: true,
+              maxWidth: "600px",
+              confirmText: "OK",
+              onCancel: this.clearLoggedOutDueToInactivity,
+              onConfirm: this.clearLoggedOutDueToInactivity,
+              showRedBar: true,
+              title: "Session expired",
+              content: /* @__PURE__ */ jsx(Text, { children: /* @__PURE__ */ jsx("p", { style: { fontSize: 16 }, children: "You have been logged out due to inactivity." }) })
+            }
+          ),
+          this.state.loggedOutDueToCookieExpiry && !this.props.hideInactivityModal && /* @__PURE__ */ jsx(
+            ConfirmModalComponent,
+            {
+              isOpen: true,
+              maxWidth: "600px",
+              confirmText: "OK",
+              onCancel: this.clearLoggedOutDueToCookieExpiry,
+              onConfirm: this.clearLoggedOutDueToCookieExpiry,
+              showRedBar: true,
+              title: "Session expired",
+              content: /* @__PURE__ */ jsx(Text, { children: /* @__PURE__ */ jsx("p", { style: { fontSize: 16 }, children: "Your session has expired. Please log in again." }) })
+            }
+          )
+        ]
+      }
+    );
+  }
+}
+AuthProviderClass.propTypes = {
+  children: PropTypes.node.isRequired,
+  /** Runtime config for the library. Sets API URLs, Firebase config, cookie domain, etc.
+   *  When omitted, the library falls back to import.meta.env.VITE_* (Storybook / dev).
+   *  When consumed as an npm package, pass this prop so values are available at runtime. */
+  config: PropTypes.shape({
+    apiUrl: PropTypes.string,
+    baseUrlPublic: PropTypes.string,
+    cookieDomain: PropTypes.string,
+    websiteDomain: PropTypes.string,
+    photoApiUrl: PropTypes.string,
+    firebase: PropTypes.shape({
+      apiKey: PropTypes.string,
+      authDomain: PropTypes.string,
+      projectId: PropTypes.string,
+      storageBucket: PropTypes.string,
+      messagingSenderId: PropTypes.string,
+      appId: PropTypes.string,
+      measurementId: PropTypes.string
+    })
+  }),
+  /** Override inactivity timeout in ms (e.g. for Storybook). Production uses 5 minutes. */
+  inactivityTimeMs: PropTypes.number,
+  /** When true, the inactivity modal is not shown after auto-logout. Default false. */
+  hideInactivityModal: PropTypes.bool,
+  /** Override access token cookie lifetime in ms (e.g. for Storybook). Production uses 1 hour. */
+  accessTokenExpiryMs: PropTypes.number
+};
+const AuthConsumer = AuthContext.Consumer;
+const AuthProvider = withRouter(AuthProviderClass);
+export {
+  AuthConsumer,
+  AuthContext,
+  AuthProvider,
+  DEFAULT_TOKEN_EXPIRY_MS
+};