@stokr/components-library 3.0.16 → 3.0.17

package/dist/context/Checkbox/CheckboxContext.js

@@ -0,0 +1,151 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useState, useCallback, useMemo, useContext } from "react";
+import fetchDataPublic from "../../api/fetchDataPublic.js";
+import fetchData from "../../api/fetchData.js";
+const CheckboxContext = createContext();
+const CheckboxProvider = ({ children }) => {
+  const [checkboxes, setCheckboxes] = useState({});
+  const [loadingStates, setLoadingStates] = useState({});
+  const [errorStates, setErrorStates] = useState({});
+  const fetchCheckboxes = useCallback(
+    async (key, options = {}) => {
+      const { group, labels } = options;
+      if (loadingStates[key] || checkboxes[key] !== void 0 || errorStates[key]) {
+        return;
+      }
+      setLoadingStates((prev) => ({ ...prev, [key]: true }));
+      setErrorStates((prev) => {
+        const newState = { ...prev };
+        delete newState[key];
+        return newState;
+      });
+      try {
+        let response;
+        if (group) {
+          response = await fetchDataPublic("compliance/get-checkbox-group", {
+            group
+          });
+        } else if (labels) {
+          response = await fetchDataPublic("compliance/get-checkboxes", {
+            labels
+          });
+        } else {
+          throw new Error("Must provide either group or labels");
+        }
+        setCheckboxes((prev) => ({ ...prev, [key]: response }));
+      } catch (error) {
+        console.error(`Failed to fetch checkboxes for key: ${key}`, error);
+        setErrorStates((prev) => ({ ...prev, [key]: error }));
+        setCheckboxes((prev) => ({ ...prev, [key]: null }));
+      } finally {
+        setLoadingStates((prev) => ({ ...prev, [key]: false }));
+      }
+    },
+    [checkboxes, loadingStates, errorStates]
+  );
+  const getCheckboxes = useCallback(
+    (key, options = {}) => {
+      if (checkboxes[key] === void 0 && !loadingStates[key] && !errorStates[key]) {
+        fetchCheckboxes(key, options);
+      }
+      return {
+        checkboxes: checkboxes[key] || null,
+        isLoading: loadingStates[key] || false,
+        error: errorStates[key] || null,
+        refetch: () => {
+          setErrorStates((prev) => {
+            const newState = { ...prev };
+            delete newState[key];
+            return newState;
+          });
+          setCheckboxes((prev) => {
+            const newState = { ...prev };
+            delete newState[key];
+            return newState;
+          });
+          fetchCheckboxes(key, options);
+        }
+      };
+    },
+    [checkboxes, loadingStates, errorStates, fetchCheckboxes]
+  );
+  const checkCheckbox = useCallback(async (checkboxId, data = {}) => {
+    const { userId, investmentId = "", privateInvestorId = "" } = data;
+    if (!userId) {
+      throw new Error("userId is required to check checkbox");
+    }
+    if (!checkboxId) {
+      throw new Error("checkboxId is required");
+    }
+    try {
+      const response = await fetchData("compliance/check-checkbox", {
+        userId,
+        checkboxId,
+        investmentId,
+        privateInvestorId
+      });
+      return response;
+    } catch (error) {
+      console.error(`Failed to check checkbox: ${checkboxId}`, error);
+      throw error;
+    }
+  }, []);
+  const clearCheckboxes = useCallback((key) => {
+    if (key) {
+      setCheckboxes((prev) => {
+        const newState = { ...prev };
+        delete newState[key];
+        return newState;
+      });
+      setLoadingStates((prev) => {
+        const newState = { ...prev };
+        delete newState[key];
+        return newState;
+      });
+      setErrorStates((prev) => {
+        const newState = { ...prev };
+        delete newState[key];
+        return newState;
+      });
+    } else {
+      setCheckboxes({});
+      setLoadingStates({});
+      setErrorStates({});
+    }
+  }, []);
+  const value = useMemo(
+    () => ({
+      getCheckboxes,
+      checkCheckbox,
+      clearCheckboxes
+    }),
+    [getCheckboxes, checkCheckbox, clearCheckboxes]
+  );
+  return /* @__PURE__ */ jsx(CheckboxContext.Provider, { value, children });
+};
+const useCheckboxes = (key, options = {}) => {
+  const context = useContext(CheckboxContext);
+  if (!context) {
+    throw new Error("useCheckboxes must be used within CheckboxProvider");
+  }
+  if (!key) {
+    throw new Error("useCheckboxes requires a key parameter");
+  }
+  return context.getCheckboxes(key, options);
+};
+const useCheckboxActions = () => {
+  const context = useContext(CheckboxContext);
+  if (!context) {
+    throw new Error("useCheckboxActions must be used within CheckboxProvider");
+  }
+  return {
+    checkCheckbox: context.checkCheckbox,
+    clearCheckboxes: context.clearCheckboxes
+  };
+};
+export {
+  CheckboxContext,
+  CheckboxProvider,
+  useCheckboxActions,
+  useCheckboxes
+};

package/dist/firebase-config.js

@@ -0,0 +1,73 @@
+import { getApps, getApp, initializeApp } from "firebase/app";
+import { initializeAuth, inMemoryPersistence, getAuth } from "firebase/auth";
+const __vite_import_meta_env__ = {};
+let app = null;
+let auth = null;
+function getEnvFirebaseConfig() {
+  try {
+    return {
+      apiKey: "AIzaSyBBp_3Romnfv--YpUuV0mJgDymvSp3oq0c",
+      authDomain: "stokr-development-env.firebaseapp.com",
+      projectId: "stokr-development-env",
+      storageBucket: "stokr-development-env.appspot.com",
+      messagingSenderId: "568229412804",
+      appId: "1:568229412804:web:2391857e3e2a0b02346e91",
+      measurementId: "G-CP53SZVSMN"
+    };
+  } catch {
+    return {};
+  }
+}
+function isValidConfig(config) {
+  return config?.apiKey != null && String(config.apiKey).trim() !== "";
+}
+function getFirebaseAuth() {
+  return auth;
+}
+function initFirebase(configOverride) {
+  const firebaseConfig = configOverride || getEnvFirebaseConfig();
+  if (!isValidConfig(firebaseConfig)) {
+    if (configOverride && typeof console !== "undefined" && console.warn) {
+      console.warn(
+        "[firebase-config] initFirebase() received a config with no valid apiKey. Ensure all VITE_FIREBASE_* variables are defined in your .env file and the dev server was restarted."
+      );
+    }
+    return;
+  }
+  try {
+    const existingApps = getApps();
+    if (existingApps.length > 0) {
+      app = getApp();
+    } else {
+      app = initializeApp(firebaseConfig);
+    }
+    try {
+      auth = initializeAuth(app, { persistence: inMemoryPersistence });
+    } catch (initErr) {
+      auth = getAuth(app);
+      if (typeof console !== "undefined" && console.warn) {
+        console.warn(
+          "[firebase-config] initializeAuth() failed (auth already initialized by another module). Falling back to getAuth() — if sign-in hangs for 30s, ensure this module loads BEFORE @stokr/components-library. Error:",
+          initErr?.message || initErr
+        );
+      }
+    }
+  } catch (err) {
+    app = null;
+    auth = null;
+    if (typeof console !== "undefined" && console.warn) {
+      console.warn(
+        "[firebase-config] Firebase init failed (e.g. invalid API key or duplicate app):",
+        err?.code || err?.message || err
+      );
+    }
+  }
+}
+if (typeof __vite_import_meta_env__ !== "undefined" && isValidConfig(getEnvFirebaseConfig())) {
+  initFirebase();
+}
+export {
+  auth,
+  getFirebaseAuth,
+  initFirebase
+};

package/dist/hooks/useNewVentureForm.js

@@ -0,0 +1,262 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { useState, useContext, useEffect, useCallback } from "react";
+import { AuthContext } from "../context/AuthContext.js";
+import fetchDataPublic from "../api/fetchDataPublic.js";
+import parse from "html-react-parser";
+import { useCheckboxes } from "../context/Checkbox/CheckboxContext.js";
+const initialState = {
+  email: "",
+  name: "",
+  mailingList: false,
+  privateInvestorList: false,
+  mailingListText: /* @__PURE__ */ jsx(Fragment, { children: "You just want to be updated on the project. Subscribe here for further information going forward." }),
+  privateInvestorListText: /* @__PURE__ */ jsxs(Fragment, { children: [
+    "You are a professional investor or an investor willing to invest in private offerings. Subscribe here to be contacted by a dedicated team to help you confirm your eligibility for this investment.",
+    /* @__PURE__ */ jsx("br", {}),
+    " ",
+    /* @__PURE__ */ jsx("br", {}),
+    "You are seeking to invest on your own initiative and any potential investments arose as a result of your direct inquiry and outreach."
+  ] }),
+  mailingListDisabled: false,
+  privateInvestorListDisabled: false,
+  optionalCheckBox: false,
+  optionalCheckBoxText: "",
+  optionalCheckBoxChecked: false,
+  checkedCheckboxes: [],
+  isSubmitting: false,
+  successMessage: null,
+  errorMessage: null
+};
+const getProjectSubscription = (user, project) => {
+  if (!user || !project?._id) {
+    return {
+      isPrivateInvestor: false,
+      isSubscribed: false,
+      privateInvestorStatus: null
+    };
+  }
+  if (user.privateInvestorProjects && user.subscribedProjects) {
+    const privateInvestorProject = user.privateInvestorProjects.find((p) => p.projectId === project._id);
+    const subscribedProject = user.subscribedProjects[project.name];
+    return {
+      isPrivateInvestor: !!privateInvestorProject?.isAllowed,
+      isSubscribed: !!subscribedProject,
+      privateInvestorStatus: privateInvestorProject?.status
+    };
+  }
+  return {
+    isPrivateInvestor: user.isPrivateInvestor,
+    isSubscribed: user.isSubscribed,
+    privateInvestorStatus: user.privateInvestorStatus
+  };
+};
+const updateUserSubscription = (user, project, updates) => {
+  if (!user) return user;
+  if (user.privateInvestorProjects && user.subscribedProjects) {
+    const updatedUser = { ...user };
+    if (updates.isPrivateInvestor !== void 0) {
+      const existingIndex = updatedUser.privateInvestorProjects.findIndex((p) => p.projectId === project._id);
+      if (existingIndex >= 0) {
+        updatedUser.privateInvestorProjects[existingIndex] = {
+          ...updatedUser.privateInvestorProjects[existingIndex],
+          ...updates
+        };
+      } else {
+        updatedUser.privateInvestorProjects = [
+          ...updatedUser.privateInvestorProjects,
+          { projectId: project._id, status: "New", ...updates }
+        ];
+      }
+    }
+    if (updates.isSubscribed !== void 0) {
+      updatedUser.subscribedProjects[project.name] = updates.isSubscribed;
+    }
+    return updatedUser;
+  }
+  return { ...user, ...updates };
+};
+const useNewVentureForm = ({ project, user, salesChannel, customSuccessMessage }) => {
+  const [formValues, setFormValues] = useState(initialState);
+  const { setUser, checkPrivateInvestorAll, checkIfUserSubscribedAll } = useContext(AuthContext);
+  const { checkboxes, isLoading: isLoadingCheckboxes } = useCheckboxes("newVentureModal", {
+    group: "newVentureModal"
+  });
+  useEffect(() => {
+    let formValuesCopy = { ...formValues };
+    if (checkboxes) {
+      Object.values(checkboxes).forEach((checkbox) => {
+        if (checkbox.label === "createPrivateInvestor" && !formValuesCopy.privateInvestorListDisabled) {
+          formValuesCopy.privateInvestorListText = parse(checkbox.agreementText);
+        } else if (checkbox.label === "subscribeToProject" && !formValuesCopy.mailingListDisabled) {
+          formValuesCopy.mailingListText = parse(checkbox.agreementText);
+        }
+      });
+    }
+    if (user?._id) {
+      formValuesCopy.email = user.email;
+      formValuesCopy.name = user.username;
+      const projectSubscription = getProjectSubscription(user, project);
+      if (projectSubscription.isPrivateInvestor) {
+        formValuesCopy.privateInvestorListText = "You are already registered on the whitelist.";
+        formValuesCopy.privateInvestorList = true;
+        formValuesCopy.privateInvestorListDisabled = true;
+      } else if (projectSubscription.privateInvestorStatus && projectSubscription.privateInvestorStatus !== "Admitted") {
+        formValuesCopy.privateInvestorListText = "Your profile is under review. An account manager will reach out to you to confirm your eligibility.";
+        formValuesCopy.privateInvestorList = true;
+        formValuesCopy.privateInvestorListDisabled = true;
+      }
+      if (projectSubscription.isSubscribed) {
+        formValuesCopy.mailingList = true;
+        formValuesCopy.mailingListText = "You already subscribed to the email notification list.";
+        formValuesCopy.mailingListDisabled = true;
+      }
+    }
+    setFormValues(formValuesCopy);
+  }, [user, checkboxes, project, formValues]);
+  const handleSubmit = useCallback(
+    async (values) => {
+      setFormValues((prev) => ({ ...prev, isSubmitting: true }));
+      try {
+        const dataToSend = {
+          email: values.email,
+          projectId: project._id,
+          name: values.name,
+          checkedCheckboxes: formValues.checkedCheckboxes,
+          salesChannel: salesChannel ? salesChannel : window.location.pathname.includes("featured-assets") ? "featuredAssets" : "investor"
+        };
+        if (values.privateInvestorList && !formValues.privateInvestorListDisabled) {
+          dataToSend.createPrivateInvestor = true;
+        }
+        if (values.mailingList && !formValues.mailingListDisabled) {
+          dataToSend.subscribeToProject = true;
+        }
+        const response = await fetchDataPublic("private-investor/public/create", dataToSend);
+        let updates = {};
+        if (response?.privateInvestor) {
+          updates.privateInvestorStatus = response.privateInvestor.status;
+          updates.isPrivateInvestor = response.privateInvestor.isAllowed || false;
+        }
+        if (response?.subscribedToProject) {
+          updates.isSubscribed = true;
+        }
+        const updatedUser = updateUserSubscription(user, project, updates);
+        setUser(updatedUser);
+        setFormValues((prev) => ({
+          ...prev,
+          successMessage: customSuccessMessage ? customSuccessMessage : /* @__PURE__ */ jsxs(Fragment, { children: [
+            "Please continue onboarding, an account manager will reach out to you.",
+            /* @__PURE__ */ jsx("br", {}),
+            "If you are an existing account holder, kindly log in and make sure your account is fully verified."
+          ] }),
+          errorMessage: null,
+          isSubmitting: false
+        }));
+        return response;
+      } catch (error) {
+        let errorMessage;
+        if (error?.response?.status === 406) {
+          errorMessage = error.response.data?.substring(7) || "You are already added to this project.";
+        } else {
+          errorMessage = /* @__PURE__ */ jsxs(Fragment, { children: [
+            "Something went wrong. Please try again a bit later or contact us at",
+            " ",
+            /* @__PURE__ */ jsx("a", { href: "mailto:support@stokr.io", style: { color: "inherit" }, children: "support@stokr.io" }),
+            " "
+          ] });
+        }
+        setFormValues((prev) => ({
+          ...prev,
+          errorMessage,
+          successMessage: null,
+          isSubmitting: false
+        }));
+        throw error;
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      project,
+      formValues.checkedCheckboxes,
+      formValues.privateInvestorListDisabled,
+      formValues.mailingListDisabled,
+      user,
+      setUser
+    ]
+  );
+  const checkUserProjectStatus = async () => {
+    const promises = [];
+    const projectSubscription = getProjectSubscription(user, project);
+    const needsPrivateInvestorData = projectSubscription.isPrivateInvestor === void 0;
+    const needsSubscriptionData = projectSubscription.isSubscribed === void 0;
+    if (needsPrivateInvestorData) {
+      promises.push(checkPrivateInvestorAll(user, true));
+    }
+    if (needsSubscriptionData) {
+      promises.push(checkIfUserSubscribedAll(user, true));
+    }
+    if (promises.length === 0) return;
+    try {
+      const results = await Promise.all(promises);
+      const updatedUser = { ...user };
+      results.forEach((result) => {
+        if (result) {
+          Object.assign(updatedUser, result);
+        }
+      });
+      setUser(updatedUser);
+    } catch (error) {
+      console.error("Failed to check user status for project:", error);
+    }
+  };
+  useEffect(() => {
+    if (!user || !user._id || !(project && project._id)) return;
+    checkUserProjectStatus();
+  }, [user, project]);
+  useEffect(() => {
+    let formValuesCopy = { ...formValues };
+    if (checkboxes) {
+      Object.values(checkboxes).forEach((checkbox) => {
+        if (checkbox.label === "createPrivateInvestor" && !formValuesCopy.privateInvestorListDisabled) {
+          formValuesCopy.privateInvestorListText = parse(checkbox.agreementText);
+        } else if (checkbox.label === "subscribeToProject" && !formValuesCopy.mailingListDisabled) {
+          formValuesCopy.mailingListText = parse(checkbox.agreementText);
+        }
+      });
+    }
+    if (user?._id) {
+      formValuesCopy.email = user.email;
+      formValuesCopy.name = user.username;
+      const projectSubscription = getProjectSubscription(user, project);
+      if (projectSubscription.isPrivateInvestor) {
+        formValuesCopy.privateInvestorListText = "You are already registered on the whitelist.";
+        formValuesCopy.privateInvestorList = true;
+        formValuesCopy.privateInvestorListDisabled = true;
+      } else if (projectSubscription.privateInvestorStatus && projectSubscription.privateInvestorStatus !== "Admitted") {
+        formValuesCopy.privateInvestorListText = "Your profile is under review. An account manager will reach out to you to confirm your eligibility.";
+        formValuesCopy.privateInvestorList = true;
+        formValuesCopy.privateInvestorListDisabled = true;
+      }
+      if (projectSubscription.isSubscribed) {
+        formValuesCopy.mailingList = true;
+        formValuesCopy.mailingListText = "You already subscribed to the email notification list.";
+        formValuesCopy.mailingListDisabled = true;
+      }
+    }
+    setFormValues(formValuesCopy);
+  }, [user, checkboxes, project]);
+  const updateCheckedCheckboxes = useCallback((_checkboxes) => {
+    setFormValues((prev) => ({ ...prev, checkedCheckboxes: _checkboxes }));
+  }, []);
+  return {
+    // Form state
+    ...formValues,
+    // Loading state
+    isLoading: isLoadingCheckboxes,
+    // Actions
+    handleSubmit,
+    updateCheckedCheckboxes
+  };
+};
+export {
+  useNewVentureForm
+};

package/dist/hooks/useTimer.js

@@ -0,0 +1,89 @@
+import { useState, useRef, useCallback, useEffect } from "react";
+import stdin_default from "../services/TimerService.js";
+const useTimer = (timerId, initialDuration = 0) => {
+  const [secondsRemaining, setSecondsRemaining] = useState(initialDuration);
+  const [hasTimerFinished, setHasTimerFinished] = useState(false);
+  const [isTimerActive, setIsTimerActive] = useState(false);
+  const [wasTimerStarted, setWasTimerStarted] = useState(false);
+  const timerIdRef = useRef(timerId);
+  const startTimer = useCallback((duration) => {
+    setIsTimerActive(true);
+    setHasTimerFinished(false);
+    setSecondsRemaining(duration);
+    setWasTimerStarted(true);
+    stdin_default.startTimer(
+      timerIdRef.current,
+      duration,
+      (remaining, isExpired) => {
+        setSecondsRemaining(remaining);
+        if (isExpired) {
+          setHasTimerFinished(true);
+          setIsTimerActive(false);
+        }
+      },
+      () => {
+        setHasTimerFinished(true);
+        setIsTimerActive(false);
+      }
+    );
+  }, []);
+  const stopTimer = useCallback(() => {
+    stdin_default.stopTimer(timerIdRef.current);
+    setIsTimerActive(false);
+    setSecondsRemaining(0);
+    setHasTimerFinished(true);
+  }, []);
+  const pauseTimer = useCallback(() => {
+    stdin_default.stopTimer(timerIdRef.current);
+    setIsTimerActive(false);
+  }, []);
+  const resumeTimer = useCallback(() => {
+    if (!isTimerActive && secondsRemaining > 0 && !hasTimerFinished) {
+      startTimer(secondsRemaining);
+    }
+  }, [isTimerActive, secondsRemaining, hasTimerFinished, startTimer]);
+  useEffect(() => {
+    let initialId;
+    const existingTimer = stdin_default.getTimerInfo(timerIdRef.current);
+    if (existingTimer) {
+      initialId = setTimeout(() => {
+        setSecondsRemaining(existingTimer.remaining);
+        setHasTimerFinished(existingTimer.isExpired);
+        setIsTimerActive(existingTimer.isActive);
+        setWasTimerStarted(true);
+      }, 0);
+    }
+    const syncInterval = setInterval(() => {
+      const timerInfo = stdin_default.getTimerInfo(timerIdRef.current);
+      if (timerInfo) {
+        setSecondsRemaining(timerInfo.remaining);
+        setHasTimerFinished(timerInfo.isExpired);
+        setIsTimerActive(timerInfo.isActive);
+      } else if (wasTimerStarted) {
+        setHasTimerFinished(true);
+        setIsTimerActive(false);
+        setSecondsRemaining(0);
+      }
+    }, 1e3);
+    return () => {
+      clearTimeout(initialId);
+      clearInterval(syncInterval);
+    };
+  }, [wasTimerStarted]);
+  useEffect(() => {
+    return () => {
+    };
+  }, []);
+  return {
+    secondsRemaining,
+    hasTimerFinished,
+    isTimerActive,
+    startTimer,
+    stopTimer,
+    pauseTimer,
+    resumeTimer
+  };
+};
+export {
+  useTimer
+};