@phygitallabs/tapquest-core 2.7.0 → 2.9.0

package/dist/index.js

@@ -2,10 +2,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -19,325 +15,16 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/modules/auth/constants/index.ts
-var userInfoKey, accessTokenKey, refreshTokenKey, httpMaxRetries, retryAttemptsRefreshToken, deviceUIDKey, chipAuthTokenKey;
-var init_constants = __esm({
-  "src/modules/auth/constants/index.ts"() {
-    "use strict";
-    userInfoKey = "phygital-user-info";
-    accessTokenKey = "accessToken";
-    refreshTokenKey = "refreshToken";
-    httpMaxRetries = 3;
-    retryAttemptsRefreshToken = "retryAttemptsRefreshToken";
-    deviceUIDKey = "Device-UID";
-    chipAuthTokenKey = "chip-auth-token";
-  }
-});
-
-// src/modules/auth/services/FirebaseAuthService.ts
-var firebaseApp, firebaseAuth, getFirebaseModules, FirebaseAuthService;
-var init_FirebaseAuthService = __esm({
-  "src/modules/auth/services/FirebaseAuthService.ts"() {
-    "use strict";
-    init_constants();
-    getFirebaseModules = async () => {
-      if (typeof window === "undefined") {
-        throw new Error("Firebase can only be used in client environment");
-      }
-      if (!firebaseApp || !firebaseAuth) {
-        const [
-          { initializeApp, getApps },
-          {
-            getAuth,
-            signInWithEmailAndPassword,
-            createUserWithEmailAndPassword,
-            signInWithPopup,
-            GoogleAuthProvider,
-            signOut: signOut2,
-            sendPasswordResetEmail,
-            sendEmailVerification,
-            updatePassword,
-            onAuthStateChanged
-          }
-        ] = await Promise.all([
-          import("firebase/app"),
-          import("firebase/auth")
-        ]);
-        firebaseApp = { initializeApp, getApps };
-        firebaseAuth = {
-          getAuth,
-          signInWithEmailAndPassword,
-          createUserWithEmailAndPassword,
-          signInWithPopup,
-          GoogleAuthProvider,
-          signOut: signOut2,
-          sendPasswordResetEmail,
-          sendEmailVerification,
-          updatePassword,
-          onAuthStateChanged
-        };
-      }
-      return { firebaseApp, firebaseAuth };
-    };
-    FirebaseAuthService = class {
-      constructor(config) {
-        __publicField(this, "app");
-        __publicField(this, "auth");
-        __publicField(this, "googleProvider");
-        __publicField(this, "config");
-        __publicField(this, "initialized", false);
-        this.config = config;
-      }
-      async ensureInitialized() {
-        if (this.initialized) return;
-        const { firebaseApp: firebaseApp2, firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-        if (!firebaseApp2.getApps().length) {
-          this.app = firebaseApp2.initializeApp(this.config);
-        } else {
-          this.app = firebaseApp2.getApps()[0];
-        }
-        this.auth = firebaseAuth2.getAuth(this.app);
-        this.googleProvider = new firebaseAuth2.GoogleAuthProvider();
-        this.initialized = true;
-      }
-      transformUserData(user) {
-        return {
-          id: user.uid,
-          uid: user.uid,
-          userName: user.displayName || "",
-          displayName: user.displayName || "",
-          email: user.email || "",
-          refreshToken: user.refreshToken,
-          accessToken: user.accessToken || "",
-          exp: user.stsTokenManager?.expirationTime || 0,
-          emailVerified: user.emailVerified,
-          avatar: user.photoURL || "/images/default-avatar.jpg",
-          signInProvider: this.getSignInProvider(user),
-          role: void 0,
-          scanStatus: false
-        };
-      }
-      getSignInProvider(user) {
-        const providers = user.providerData.map((p) => p.providerId);
-        if (providers.includes("google.com")) return "google.com";
-        return "password";
-      }
-      translateErrorCode(errorCode) {
-        switch (errorCode) {
-          case "auth/invalid-email":
-            return "Email kh\xF4ng h\u1EE3p l\u1EC7";
-          case "auth/user-disabled":
-            return "T\xE0i kho\u1EA3n \u0111\xE3 b\u1ECB kh\xF3a";
-          case "auth/wrong-password":
-            return "T\xE0i kho\u1EA3n/m\u1EADt kh\u1EA9u kh\xF4ng \u0111\xFAng";
-          case "auth/user-not-found":
-            return "T\xE0i kho\u1EA3n/m\u1EADt kh\u1EA9u kh\xF4ng \u0111\xFAng";
-          case "auth/weak-password":
-            return "Weak password! Please use stronger password.";
-          case "auth/email-already-in-use":
-            return "Email \u0111\xE3 \u0111\u01B0\u1EE3c s\u1EED d\u1EE5ng";
-          case "auth/account-exists-with-different-credential":
-            return "T\xE0i kho\u1EA3n email \u0111\xE3 \u0111\u01B0\u1EE3c s\u1EED d\u1EE5ng b\u1EDFi m\u1ED9t ph\u01B0\u01A1ng th\u1EE9c \u0111\u0103ng nh\u1EADp kh\xE1c";
-          case "auth/email-not-verified":
-            return "Email ch\u01B0a \u0111\u01B0\u1EE3c x\xE1c th\u1EF1c";
-          default:
-            return "\u0110\xE3 c\xF3 l\u1ED7i x\u1EA3y ra";
-        }
-      }
-      async signInWithEmailAndPassword(email, password) {
-        try {
-          await this.ensureInitialized();
-          const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-          const signInResponse = await firebaseAuth2.signInWithEmailAndPassword(this.auth, email, password);
-          const { user } = signInResponse;
-          const data = this.transformUserData(user);
-          const { emailVerified } = data;
-          if (!emailVerified) {
-            await this.signOut();
-            localStorage.removeItem("phygital-user-info");
-            localStorage.removeItem(accessTokenKey);
-            localStorage.removeItem(refreshTokenKey);
-            throw new Error("Email is not verified");
-          }
-          return {
-            errorCode: "",
-            data
-          };
-        } catch (err) {
-          const errorCode = this.translateErrorCode(err.code);
-          return {
-            errorCode,
-            data: null
-          };
-        }
-      }
-      async signInWithGoogle() {
-        try {
-          await this.ensureInitialized();
-          const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-          const signInResponse = await firebaseAuth2.signInWithPopup(this.auth, this.googleProvider);
-          const { user } = signInResponse;
-          const data = this.transformUserData(user);
-          const { emailVerified } = data;
-          if (!emailVerified) {
-            await this.signOut();
-            throw new Error("Email is not verified");
-          }
-          return {
-            errorCode: "",
-            data
-          };
-        } catch (err) {
-          const errorCode = this.translateErrorCode(err.code);
-          return {
-            errorCode,
-            data: null
-          };
-        }
-      }
-      async signUp(email, password) {
-        try {
-          await this.ensureInitialized();
-          const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-          const signUpResponse = await firebaseAuth2.createUserWithEmailAndPassword(this.auth, email, password);
-          const { user } = signUpResponse;
-          const data = this.transformUserData(user);
-          return {
-            errorCode: "",
-            data
-          };
-        } catch (err) {
-          const errorCode = this.translateErrorCode(err.code);
-          return {
-            errorCode,
-            data: null
-          };
-        }
-      }
-      async signOut() {
-        try {
-          await this.ensureInitialized();
-          const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-          await firebaseAuth2.signOut(this.auth);
-        } catch (err) {
-          console.log("Firebase signOut error:", err);
-        }
-      }
-      async sendPasswordResetEmail(email) {
-        await this.ensureInitialized();
-        const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-        const actionCodeSettings = {
-          url: window.location.origin,
-          handleCodeInApp: true
-        };
-        await firebaseAuth2.sendPasswordResetEmail(this.auth, email, actionCodeSettings);
-      }
-      async sendEmailVerification() {
-        await this.ensureInitialized();
-        const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-        if (!this.auth.currentUser) {
-          throw new Error("No current user");
-        }
-        const actionCodeSettings = {
-          url: window.location.origin,
-          handleCodeInApp: true
-        };
-        await firebaseAuth2.sendEmailVerification(this.auth.currentUser, actionCodeSettings);
-      }
-      async changePassword(newPassword) {
-        await this.ensureInitialized();
-        const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-        const user = this.auth.currentUser;
-        if (!user) {
-          throw new Error("No current user");
-        }
-        return firebaseAuth2.updatePassword(user, newPassword);
-      }
-      onAuthStateChanged(callback) {
-        if (typeof window === "undefined") {
-          return () => {
-          };
-        }
-        let unsubscriber = null;
-        this.ensureInitialized().then(async () => {
-          const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-          unsubscriber = firebaseAuth2.onAuthStateChanged(this.auth, (user) => {
-            if (user && user.emailVerified) {
-              const userData = this.transformUserData(user);
-              callback(userData);
-            } else {
-              callback(null);
-            }
-          });
-        });
-        return () => {
-          if (unsubscriber) {
-            unsubscriber();
-          }
-        };
-      }
-      getCurrentUser() {
-        if (typeof window === "undefined" || !this.initialized) {
-          return null;
-        }
-        const user = this.auth.currentUser;
-        if (user && user.emailVerified) {
-          return this.transformUserData(user);
-        }
-        return null;
-      }
-    };
-  }
-});
-
-// src/modules/auth/services/authServiceFactory.ts
-var authServiceInstance, createAuthService, getAuthService, resetAuthService;
-var init_authServiceFactory = __esm({
-  "src/modules/auth/services/authServiceFactory.ts"() {
-    "use strict";
-    init_FirebaseAuthService();
-    authServiceInstance = null;
-    createAuthService = (config) => {
-      if (!authServiceInstance) {
-        authServiceInstance = new FirebaseAuthService(config.firebaseConfig);
-      }
-      return authServiceInstance;
-    };
-    getAuthService = () => {
-      return authServiceInstance;
-    };
-    resetAuthService = () => {
-      authServiceInstance = null;
-    };
-  }
-});
-
-// src/modules/auth/services/index.ts
-var services_exports = {};
-__export(services_exports, {
-  FirebaseAuthService: () => FirebaseAuthService,
-  createAuthService: () => createAuthService,
-  getAuthService: () => getAuthService,
-  resetAuthService: () => resetAuthService
-});
-var init_services = __esm({
-  "src/modules/auth/services/index.ts"() {
-    "use strict";
-    init_FirebaseAuthService();
-    init_authServiceFactory();
-  }
-});
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ALLOWED_ORIGINS: () => ALLOWED_ORIGINS,
   AchievementRuleActionType: () => AchievementRuleActionType,
   AchievementServiceProvider: () => AchievementServiceProvider,
   AchievementType: () => AchievementType,
   AuthProvider: () => AuthProvider,
+  CALLBACK_URL: () => CALLBACK_URL,
   CampaignState: () => CampaignState,
   CmentityRewardType: () => CmentityRewardType,
   NotificationProvider: () => NotificationProvider,
@@ -350,7 +37,6 @@ __export(index_exports, {
   chipAuthTokenKey: () => chipAuthTokenKey,
   cn: () => cn,
   convertSnakeToCamel: () => convertSnakeToCamel,
-  createRefreshTokenFunction: () => createRefreshTokenFunction,
   deviceUIDKey: () => deviceUIDKey,
   fileToBase64: () => fileToBase64,
   filterLocationsByProperty: () => filterLocationsByProperty,
@@ -391,18 +77,22 @@ __export(index_exports, {
   useChipScanStory: () => useChipScanStory,
   useClaimUserReward: () => useClaimUserReward,
   useClearUserRewardCache: () => useClearUserRewardCache,
+  useCreateCertificate: () => useCreateCertificate,
+  useCreateCertificateAnonymous: () => useCreateCertificateAnonymous,
+  useCreateCertificateWithMask: () => useCreateCertificateWithMask,
   useCreateMemory: () => useCreateMemory,
   useCreateModelGroupReward: () => useCreateModelGroupReward,
-  useCreateRewardModel: () => useApiCreateRewardModel,
+  useCreateRewardModel: () => useCreateRewardModel,
   useDataTracking: () => useDataTracking,
-  useDeleteRewardModel: () => useApiDeleteRewardModel,
+  useDeleteRewardModel: () => useDeleteRewardModel,
   useGenerateFansipanCertificate: () => useGenerateFansipanCertificate,
   useGenerateTemplateCertificate: () => useGenerateTemplateCertificate,
   useGenerateThaocamvienCertificate: () => useGenerateThaocamvienCertificate,
-  useGetRewardModel: () => useApiGetRewardModel,
+  useGetRewardModel: () => useGetRewardModel,
   useGetUserRewards: () => useGetUserRewards,
+  useGoogleLogin: () => useGoogleLogin,
   useInfiniteMemories: () => useInfiniteMemories,
-  useListRewardModels: () => useApiListRewardModels,
+  useListRewardModels: () => useListRewardModels,
   useLocationDetail: () => useOneLocation,
   useLocationProgress: () => useUserCampaignsCompletedLocation,
   useLocationsList: () => useManyLocations,
@@ -417,17 +107,18 @@ __export(index_exports, {
   useOneAchievement: () => useOneAchievement,
   useOneMemory: () => useOneMemory,
   useOneUserCampaign: () => useOneUserCampaign,
-  usePGLCoreService: () => usePGLCoreService,
+  usePGLCoreService: () => usePGLCoreService2,
   useScanChip: () => useScanChip,
   useSendEmail: () => useSendEmail,
   useSyncCheckin: () => useSyncCheckin,
   useUpdateMyProfile: () => useUpdateMyProfile,
-  useUpdateRewardModel: () => useApiUpdateRewardModel,
+  useUpdateRewardModel: () => useUpdateRewardModel,
   useUploadMedia: () => useUploadMedia,
   useUserAchievementAction: () => useUserAchievementAction,
   useUserCampaignAction: () => useUserCampaignAction,
   useV1ListRewards: () => useV1ListRewards,
-  userInfoKey: () => userInfoKey
+  userInfoKey: () => userInfoKey,
+  wrapTextWithFont: () => wrapTextWithFont
 });
 
 // src/modules/achievement/hooks/index.ts
@@ -566,15 +257,15 @@ import {
   useManyUserRewards,
   useGetUserRewards,
   useClaimUserReward,
-  useApiListRewardModels,
-  useApiGetRewardModel,
-  useApiCreateRewardModel,
-  useApiUpdateRewardModel,
-  useApiDeleteRewardModel,
+  useListRewardModels,
+  useGetRewardModel,
+  useCreateRewardModel,
+  useUpdateRewardModel,
+  useDeleteRewardModel,
   useCreateModelGroupReward,
   useClearUserRewardCache,
   useV1ListRewards
-} from "@phygitallabs/reward/src/hooks";
+} from "@phygitallabs/reward";
 
 // src/modules/reward/types/enums.ts
 import {
@@ -643,8 +334,8 @@ var NotificationProvider = ({
   return /* @__PURE__ */ jsx(
     NotificationProviderApi,
     {
-      userUid: user.id,
-      accessToken: user.accessToken,
+      userUid: user?.id,
+      accessToken: user?.accessToken ?? null,
       webSocketUrl,
       autoConnect,
       onWebSocketOpen,
@@ -662,69 +353,774 @@ __reExport(index_exports, notification_exports);
 import { useOneMemory, useManyMemory, useInfiniteMemories, useCreateMemory, useUploadMedia, resetMemoriesQuery, memoriesKey } from "@phygitallabs/api-core";
 
 // src/modules/auth/providers/AuthProvider.tsx
-import { createContext, useEffect, useContext } from "react";
+import {
+  AuthenticationProvider,
+  useAuthenticationHeaders,
+  tokenStorage as tokenStorage3
+} from "@phygitallabs/authentication";
+import { useEffect } from "react";
 
-// src/store/hooks.ts
-import { useDispatch, useSelector } from "react-redux";
-var useAppDispatch = () => useDispatch();
-var useAppSelector = useSelector;
+// src/modules/auth/store/authStore.ts
+import { create } from "zustand";
+import { immer } from "zustand/middleware/immer";
+import {
+  createJSONStorage,
+  devtools,
+  persist,
+  subscribeWithSelector
+} from "zustand/middleware";
+import {
+  authService,
+  verifyCodeService,
+  tokenStorage
+} from "@phygitallabs/authentication";
 
-// src/modules/auth/store/authSlice.ts
-import { createSlice } from "@reduxjs/toolkit";
+// src/modules/auth/constants/index.ts
+var userInfoKey = "phygital-user-info";
+var accessTokenKey = "accessToken";
+var refreshTokenKey = "refreshToken";
+var httpMaxRetries = 3;
+var retryAttemptsRefreshToken = "retryAttemptsRefreshToken";
+var deviceUIDKey = "Device-UID";
+var chipAuthTokenKey = "chip-auth-token";
+var CALLBACK_URL = "https://s3-sgn10.fptcloud.com/nomion-assets/platform/callback.html";
+var ALLOWED_ORIGINS = [
+  "https://s3-sgn10.fptcloud.com",
+  "https://accounts.google.com/"
+];
 
-// src/modules/auth/helpers/index.ts
-init_constants();
-import { v4 as uuidv4 } from "uuid";
+// src/modules/auth/store/authStore.ts
+var initialState = {
+  user: null,
+  isSignedIn: false,
+  isInitialized: false,
+  isLoading: false,
+  error: null,
+  cleanupFunctions: {},
+  eventCallbacks: {}
+};
+var useAuthStore = create()(
+  devtools(
+    persist(
+      subscribeWithSelector(
+        immer((set, get) => ({
+          ...initialState,
+          actions: {
+            setIsLoading: (isLoading) => set((state) => {
+              state.isLoading = isLoading;
+            }),
+            setCleanupFunctions: (newCleanupFunctions) => set((state) => {
+              state.cleanupFunctions = {
+                ...state.cleanupFunctions,
+                ...newCleanupFunctions
+              };
+            }),
+            // Event management
+            addEventCallbacks: (callbacks) => {
+              set((state) => {
+                state.eventCallbacks = {
+                  ...state.eventCallbacks,
+                  ...callbacks
+                };
+              });
+              return () => {
+                set((state) => {
+                  state.eventCallbacks = {
+                    ...state.eventCallbacks,
+                    ...callbacks
+                  };
+                });
+              };
+            },
+            // Sign in with email and password
+            signInWithEmail: async (email, password) => {
+              const { eventCallbacks } = get();
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const response = await authService.signIn({
+                  email,
+                  password
+                });
+                if (response?.data?.idToken && response?.data?.refreshToken) {
+                  tokenStorage.setTokens({
+                    idToken: response.data.idToken,
+                    refreshToken: response.data.refreshToken
+                  });
+                  set((state) => {
+                    state.isSignedIn = true;
+                  });
+                  eventCallbacks.onLoginSuccess?.(response.data.idToken);
+                }
+                return response;
+              } catch (error) {
+                if (error?.response?.data?.code === 7) {
+                  return {
+                    data: void 0,
+                    message: "Email verification required",
+                    code: 7
+                  };
+                }
+                const errorMessage = error instanceof Error ? error.message : "Login failed";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                eventCallbacks.onLoginError?.(new Error(errorMessage));
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            // Sign in with Google
+            signInWithGoogle: async () => {
+              const { eventCallbacks } = get();
+              try {
+                const currentDomain = CALLBACK_URL;
+                const userData = await authService.getOAuthSignInUrl(currentDomain);
+                return userData;
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Google sign in failed";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                eventCallbacks.onLoginError?.(new Error(errorMessage));
+                throw error;
+              }
+            },
+            // Sign up with email and password
+            signUpWithEmail: async (email, password) => {
+              const { eventCallbacks } = get();
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const response = await authService.signUp({
+                  email,
+                  password
+                });
+                if (response.data) {
+                  eventCallbacks.onSignupSuccess?.();
+                }
+                return response;
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Signup failed";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                eventCallbacks.onSignupError?.(new Error(errorMessage));
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                  state.user = null;
+                  state.isSignedIn = false;
+                });
+              }
+            },
+            // Sign out
+            signOut: async () => {
+              const { eventCallbacks, cleanupFunctions } = get();
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                set((state) => {
+                  state.user = null;
+                  state.isSignedIn = false;
+                  state.error = null;
+                });
+                const isTokenExpired = tokenStorage.isTokenExpired();
+                if (isTokenExpired) {
+                  tokenStorage.clearTokens();
+                  localStorage.clear();
+                  return;
+                }
+                await authService.logout();
+                localStorage.clear();
+                tokenStorage.clearTokens();
+                try {
+                  cleanupFunctions.clearQueryCache?.();
+                  cleanupFunctions.clearOrganization?.();
+                  cleanupFunctions.clearCustomData?.();
+                  cleanupFunctions.clearHeaders?.();
+                } catch (cleanupError) {
+                  console.warn("Error during logout cleanup:", cleanupError);
+                }
+                eventCallbacks.onLogoutSuccess?.();
+              } catch (error) {
+                console.log(error);
+                const errorMessage = error instanceof Error ? error.message : "Logout failed";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                eventCallbacks.onLogoutError?.(new Error(errorMessage));
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            // Send password reset email
+            sendPasswordResetEmail: async (email) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                await verifyCodeService.forgotPassword({
+                  email
+                });
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Failed to send reset email";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            resetPassword: async (data) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const resetPasswordResponse = await verifyCodeService.resetPassword(data);
+                return resetPasswordResponse;
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Failed to reset password";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            changePassword: async (data) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const changePasswordResponse = await verifyCodeService.changePassword(data);
+                return changePasswordResponse;
+              } catch (error) {
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            verifyEmailCode: async (data) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const verifyEmailResponse = await verifyCodeService.verifyEmail(data);
+                return verifyEmailResponse;
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Failed to send reset email";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            sendVerifyCode: async (data) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const sendVerifyCodeResponse = await verifyCodeService.sendVerifyCode(data);
+                return sendVerifyCodeResponse;
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Failed to send verify code";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            refreshToken: async (refreshToken) => {
+              const refreshTokenResponse = await authService.refreshToken({
+                refreshToken: refreshToken ?? tokenStorage.getRefreshToken() ?? ""
+              });
+              return refreshTokenResponse;
+            },
+            // Clear error
+            clearError: () => set((state) => {
+              state.error = null;
+            }),
+            setUser: (user) => set((state) => {
+              state.user = user;
+            }),
+            setIsSignedIn: (isSignedIn) => set((state) => {
+              state.isSignedIn = isSignedIn;
+            }),
+            setIsInitialized: (isInitialized) => set((state) => {
+              state.isInitialized = isInitialized;
+            }),
+            patchUser: (user) => set((state) => {
+              if (state.user) {
+                state.user = { ...state.user, ...user };
+              } else {
+                state.user = user;
+              }
+            }),
+            // Initialize the store - check if user is already authenticated from tokenStorage
+            initialize: () => {
+              set((state) => {
+                const token = tokenStorage.getAuthToken();
+                state.isSignedIn = !!token;
+                state.isInitialized = true;
+              });
+            },
+            // Sync auth state from tokenStorage (called when axios interceptor updates tokens)
+            syncAuthState: () => {
+              set((state) => {
+                const token = tokenStorage.getAuthToken();
+                const wasSignedIn = state.isSignedIn;
+                state.isSignedIn = !!token;
+                if (wasSignedIn !== state.isSignedIn) {
+                  if (state.isSignedIn) {
+                    state.eventCallbacks?.onAuthStateChange?.(state.user, true);
+                  } else {
+                    state.eventCallbacks?.onAuthStateChange?.(null, false);
+                  }
+                }
+              });
+            }
+          }
+        }))
+      ),
+      {
+        version: 1,
+        name: "auth-store",
+        storage: createJSONStorage(() => localStorage),
+        partialize: (state) => ({
+          isSignedIn: state.isSignedIn,
+          user: state.user
+        })
+      }
+    )
+  )
+);
+var useAuth = () => {
+  const user = useAuthStore((state) => state.user);
+  const isSignedIn = useAuthStore((state) => state.isSignedIn);
+  const isInitialized = useAuthStore((state) => state.isInitialized);
+  const isLoading = useAuthStore((state) => state.isLoading);
+  const error = useAuthStore((state) => state.error);
+  const actions = useAuthStore((state) => state.actions);
+  return {
+    user,
+    isSignedIn,
+    isInitialized,
+    isLoading,
+    error,
+    ...actions
+  };
+};
 
-// src/modules/auth/helpers/refreshToken.ts
-import mem from "mem";
-var REFRESH_TOKEN_CONFIG = {
-  maxAge: 1e4
-  // 10 seconds cache
+// src/modules/auth/utils/user.ts
+import jwtDecode from "jwt-decode";
+var transformProtoUserData = (user, accessToken) => {
+  const userData = { ...user };
+  let tokenDecoded = {};
+  try {
+    tokenDecoded = jwtDecode(accessToken);
+  } catch (error) {
+    console.warn("Failed to decode token in transformUserData:", error);
+  }
+  userData.exp = tokenDecoded.exp || 0;
+  userData.accessToken = accessToken || "";
+  userData.roles = tokenDecoded?.roles || ["USER" /* USER */];
+  userData.account_type = tokenDecoded?.account_type || 0 /* C */;
+  userData.picture = user.picture || "";
+  return userData;
 };
-var createRefreshTokenFunction = (config) => {
-  const refreshTokenFn = async () => {
+
+// src/modules/auth/providers/AuthProvider.tsx
+import { userService } from "@phygitallabs/api-core";
+import { usePGLCoreService } from "@phygitallabs/api-core";
+import { useAchievementService } from "@phygitallabs/achievement";
+import { useRewardService } from "@phygitallabs/reward";
+import { useGenerateCertificateService } from "@phygitallabs/generate-certificate";
+
+// src/modules/auth/hooks/useTokenRefresher.ts
+import { useQuery } from "@tanstack/react-query";
+import { tokenStorage as tokenStorage2 } from "@phygitallabs/authentication";
+function useTokenRefresher() {
+  const { refreshToken, signOut } = useAuth();
+  const handleRefreshToken = async () => {
     try {
-      const session = getUserInfo();
-      const refreshToken = getRefreshToken();
-      if (!refreshToken) {
-        removeUserInfo();
+      const isTokenExpired = tokenStorage2.isTokenExpired();
+      if (!isTokenExpired) {
         return;
       }
-      const params = new URLSearchParams();
-      params.append("grant_type", "refresh_token");
-      params.append("refresh_token", refreshToken);
-      const fetchData = {
-        method: "POST",
-        headers: new Headers({
-          "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"
-        }),
-        body: params
-      };
-      const response = await fetch(
-        `https://securetoken.googleapis.com/v1/token?key=${config.firebaseApiKey}`,
-        fetchData
+      const newToken = await refreshToken();
+      if (newToken.data?.idToken && newToken.data?.refreshToken) {
+        tokenStorage2.setTokens({
+          idToken: newToken.data?.idToken,
+          refreshToken: newToken.data?.refreshToken
+        });
+      }
+    } catch (error) {
+      console.error("Failed to refresh token:", error);
+      signOut();
+    }
+  };
+  useQuery({
+    queryKey: ["refresh-token"],
+    queryFn: () => handleRefreshToken(),
+    refetchInterval: 30 * 60 * 1e3,
+    // every 30 minutes
+    refetchIntervalInBackground: false,
+    // even when tab is hidden
+    refetchOnWindowFocus: true,
+    // also refresh when user returns to tab
+    retry: false,
+    // don't retry repeatedly if refresh fails
+    enabled: !!tokenStorage2.getAuthToken()
+    // only run if logged in
+  });
+}
+
+// src/modules/auth/providers/AuthProvider.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var AuthStateManager = () => {
+  const { updateHeaders } = useAuthenticationHeaders();
+  const { updateHeaders: updateHeadersPGL, coreApi } = usePGLCoreService();
+  const { updateHeaders: updateHeadersAchievement } = useAchievementService();
+  const { updateHeaders: updateHeadersReward } = useRewardService();
+  const { updateHeaders: updateHeadersGenerateCertificate } = useGenerateCertificateService();
+  useEffect(() => {
+    useAuthStore.getState().actions.initialize();
+    const token = tokenStorage3.getAuthToken();
+    if (token) {
+      updateHeaders({
+        Authorization: `Bearer ${token}`
+      });
+      updateHeadersPGL({
+        Authorization: `Bearer ${token}`
+      });
+      updateHeadersAchievement({
+        Authorization: `Bearer ${token}`
+      });
+      updateHeadersReward({
+        Authorization: `Bearer ${token}`
+      });
+      updateHeadersGenerateCertificate({
+        Authorization: `Bearer ${token}`
+      });
+      const { user } = useAuthStore.getState();
+      if (user && user.accessToken !== token) {
+        useAuthStore.getState().actions.setUser({
+          ...user,
+          accessToken: token
+        });
+      }
+    }
+    let previousIsSignedIn = useAuthStore.getState().isSignedIn;
+    const unsub = useAuthStore.subscribe(
+      (state) => [state.isSignedIn, state.user],
+      async ([isSignedIn]) => {
+        if (isSignedIn === previousIsSignedIn) {
+          return;
+        }
+        previousIsSignedIn = isSignedIn;
+        if (isSignedIn) {
+          const token2 = tokenStorage3.getAuthToken();
+          if (token2) {
+            updateHeaders({
+              Authorization: `Bearer ${token2}`
+            });
+            updateHeadersPGL({
+              Authorization: `Bearer ${token2}`
+            });
+            updateHeadersAchievement({
+              Authorization: `Bearer ${token2}`
+            });
+            updateHeadersReward({
+              Authorization: `Bearer ${token2}`
+            });
+            updateHeadersGenerateCertificate({
+              Authorization: `Bearer ${token2}`
+            });
+            try {
+              const userApi = userService(coreApi);
+              const userProfile = await userApi.getMyProfile();
+              const transformedUserData = transformProtoUserData(
+                userProfile,
+                token2
+              );
+              useAuthStore.getState().actions.setUser(transformedUserData);
+            } catch (error) {
+              useAuthStore.getState().actions.signOut();
+            }
+          }
+          const { eventCallbacks, user } = useAuthStore.getState();
+          eventCallbacks?.onAuthStateChange?.(user, true);
+        } else {
+          updateHeaders({});
+          updateHeadersPGL({});
+          updateHeadersAchievement({
+            Authorization: ``
+          });
+          updateHeadersReward({
+            Authorization: ``
+          });
+          updateHeadersGenerateCertificate({
+            Authorization: ``
+          });
+          const { eventCallbacks } = useAuthStore.getState();
+          eventCallbacks?.onAuthStateChange?.(null, false);
+        }
+      }
+    );
+    const unsubTokenChange = tokenStorage3.addTokenChangeListener(async () => {
+      const { isSignedIn, user } = useAuthStore.getState();
+      if (isSignedIn) {
+        const token2 = tokenStorage3.getAuthToken();
+        if (token2) {
+          updateHeaders({
+            Authorization: `Bearer ${token2}`
+          });
+          updateHeadersPGL({
+            Authorization: `Bearer ${token2}`
+          });
+          updateHeadersAchievement({
+            Authorization: `Bearer ${token2}`
+          });
+          updateHeadersReward({
+            Authorization: `Bearer ${token2}`
+          });
+          updateHeadersGenerateCertificate({
+            Authorization: `Bearer ${token2}`
+          });
+          if (user && user.accessToken !== token2) {
+            useAuthStore.getState().actions.setUser({
+              ...user,
+              accessToken: token2
+            });
+          }
+        } else {
+          useAuthStore.getState().actions.signOut();
+          updateHeaders({});
+          updateHeadersPGL({});
+          updateHeadersAchievement({
+            Authorization: ``
+          });
+          updateHeadersReward({
+            Authorization: ``
+          });
+          updateHeadersGenerateCertificate({
+            Authorization: ``
+          });
+        }
+      }
+    });
+    return () => {
+      unsub();
+      unsubTokenChange();
+    };
+  }, [
+    updateHeaders,
+    updateHeadersPGL,
+    updateHeadersAchievement,
+    updateHeadersReward,
+    updateHeadersGenerateCertificate,
+    coreApi
+  ]);
+  return null;
+};
+var TokenRefresher = () => {
+  useTokenRefresher();
+  return null;
+};
+var AuthProvider = ({
+  children,
+  baseURL,
+  queryClient
+}) => {
+  const axiosConfig = {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    AuthenticationProvider,
+    {
+      axiosConfig,
+      baseURL,
+      queryClient,
+      children: [
+        /* @__PURE__ */ jsx2(AuthStateManager, {}),
+        /* @__PURE__ */ jsx2(TokenRefresher, {}),
+        children
+      ]
+    }
+  );
+};
+
+// src/modules/auth/hooks/useGoogleLogin.ts
+import { useRef, useCallback, useEffect as useEffect2 } from "react";
+import { tokenStorage as tokenStorage4 } from "@phygitallabs/authentication";
+function useGoogleLogin(options = {}) {
+  const { onSuccess, onError, onPopupBlocked, onPopupClosed } = options;
+  const { signInWithGoogle, refreshToken, setIsSignedIn, setIsLoading, isLoading } = useAuth();
+  const popupRef = useRef(null);
+  const gotDataRef = useRef(false);
+  const timerRef = useRef(null);
+  const errorRef = useRef(null);
+  const handleTokenRefresh = useCallback(
+    async (refresh) => {
+      if (refresh) {
+        try {
+          const newToken = await refreshToken(refresh);
+          if (newToken.data?.idToken && newToken.data?.refreshToken) {
+            tokenStorage4.setTokens({
+              idToken: newToken.data.idToken,
+              refreshToken: newToken.data.refreshToken
+            });
+            setIsSignedIn(true);
+            setIsLoading(false);
+            onSuccess?.();
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Token refresh failed";
+          errorRef.current = errorMessage;
+          onError?.(errorMessage);
+          setIsLoading(false);
+        }
+      }
+    },
+    [refreshToken, setIsSignedIn, setIsLoading, onSuccess, onError]
+  );
+  const cleanup = useCallback(() => {
+    if (timerRef.current) {
+      clearInterval(timerRef.current);
+      timerRef.current = null;
+    }
+    gotDataRef.current = false;
+  }, []);
+  const handleMessage = useCallback(
+    (event) => {
+      const allowedOrigins = ALLOWED_ORIGINS.concat(window?.location?.origin);
+      if (event.origin !== "*" && !allowedOrigins.includes(event.origin)) {
+        console.warn("Rejected message from untrusted origin:", event.origin);
+        return;
+      }
+      if (!event.data || typeof event.data !== "object") {
+        console.warn("Invalid message data received");
+        return;
+      }
+      if (event.data.type === "LOGIN_SUCCESS") {
+        const { refreshToken: refresh } = event.data;
+        if (refresh) {
+          handleTokenRefresh(refresh);
+        }
+        gotDataRef.current = true;
+        cleanup();
+      } else if (event.data.type === "LOGIN_ERROR") {
+        const errorMessage = event.data.error || "Login failed";
+        errorRef.current = errorMessage;
+        onError?.(errorMessage);
+        setIsLoading(false);
+        gotDataRef.current = true;
+        cleanup();
+      }
+    },
+    [handleTokenRefresh, setIsLoading, cleanup, onError]
+  );
+  const signIn = useCallback(async () => {
+    const width = 500;
+    const height = 600;
+    const left = window.screenX + (window.outerWidth - width) / 2;
+    const top = window.screenY + (window.outerHeight - height) / 2;
+    try {
+      errorRef.current = null;
+      setIsLoading(true);
+      const response = await signInWithGoogle();
+      popupRef.current = window.open(
+        `${response.statusMessage}`,
+        "oauthPopup",
+        `width=${width},height=${height},left=${left},top=${top},resizable,scrollbars`
       );
-      const data = await response.json();
-      if (data.error) {
-        removeUserInfo();
+      if (!popupRef.current) {
+        setIsLoading(false);
+        const error = "Popup blocked. Please allow popups for this site.";
+        errorRef.current = error;
+        onPopupBlocked?.();
+        onError?.(error);
         return;
       }
-      const newSession = {
-        ...session,
-        accessToken: data.access_token,
-        refreshToken: data.refresh_token
-      };
-      setUserInfo(newSession);
-      return newSession;
-    } catch {
-      removeUserInfo();
+      timerRef.current = setInterval(() => {
+        if (popupRef.current && popupRef.current.closed) {
+          if (timerRef.current) {
+            clearInterval(timerRef.current);
+            timerRef.current = null;
+          }
+          if (!gotDataRef.current) {
+            const error = "Authentication popup was closed";
+            errorRef.current = error;
+            onPopupClosed?.();
+            onError?.(error);
+            setIsLoading(false);
+          }
+        }
+      }, 500);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Google sign in failed";
+      errorRef.current = errorMessage;
+      onError?.(errorMessage);
+      setIsLoading(false);
     }
+  }, [signInWithGoogle, setIsLoading, handleMessage, onError, onPopupBlocked, onPopupClosed]);
+  useEffect2(() => {
+    window.addEventListener("message", handleMessage);
+    return () => {
+      window.removeEventListener("message", handleMessage);
+    };
+  }, [handleMessage]);
+  useEffect2(() => {
+    return () => {
+      cleanup();
+    };
+  }, [cleanup, handleMessage]);
+  return {
+    signIn,
+    isLoading,
+    error: errorRef.current
   };
-  return mem(refreshTokenFn, { maxAge: REFRESH_TOKEN_CONFIG.maxAge });
-};
+}
 
 // src/modules/auth/helpers/index.ts
+import { v4 as uuidv4 } from "uuid";
 var generateDeviceId = async () => {
   try {
     const deviceFingerprint = await generateDeviceFingerprint();
@@ -839,208 +1235,6 @@ var removeUserInfo = () => {
   localStorage.removeItem(userInfoKey);
 };
 
-// src/modules/auth/store/authSlice.ts
-var defaultUser = {
-  uid: "",
-  id: "",
-  userName: "",
-  displayName: "",
-  avatar: "/images/default-avatar.jpg",
-  email: "",
-  exp: 0,
-  emailVerified: false,
-  refreshToken: "",
-  accessToken: "",
-  role: "NULL" /* NULL */,
-  scanStatus: false
-};
-var initialState = {
-  user: defaultUser,
-  isSignedIn: false,
-  pending: true
-};
-var authSlice = createSlice({
-  name: "auth",
-  initialState,
-  reducers: {
-    signIn: (state, action) => {
-      const userData = action.payload;
-      state.user = userData;
-      state.isSignedIn = true;
-      state.pending = false;
-      setUserInfo(userData);
-      setAccessToken(userData.accessToken);
-      setRefreshToken(userData.refreshToken);
-    },
-    signOut: (state) => {
-      state.user = defaultUser;
-      state.isSignedIn = false;
-      state.pending = false;
-      removeUserInfo();
-      removeAccessToken();
-      removeRefreshToken();
-    },
-    updateScanStatus: (state, action) => {
-      state.user.scanStatus = action.payload;
-      setUserInfo(state.user);
-    },
-    refreshUser: (state, action) => {
-      const userData = action.payload;
-      if (userData) {
-        state.user = userData;
-        state.isSignedIn = true;
-        state.pending = false;
-        setUserInfo(userData);
-        setAccessToken(userData.accessToken);
-        setRefreshToken(userData.refreshToken);
-      }
-    },
-    setPending: (state, action) => {
-      state.pending = action.payload;
-    },
-    initializeFromStorage: (state) => {
-      const storedUser = getUserInfo();
-      const accessToken = getAccessToken();
-      if (storedUser && accessToken) {
-        state.user = storedUser;
-        state.isSignedIn = true;
-      }
-      state.pending = false;
-    }
-  }
-});
-var {
-  signIn,
-  signOut,
-  updateScanStatus,
-  refreshUser,
-  setPending,
-  initializeFromStorage
-} = authSlice.actions;
-var selectUser = (state) => state.auth.user;
-var selectIsSignedIn = (state) => state.auth.isSignedIn;
-var selectIsLoading = (state) => state.auth.pending;
-var authSlice_default = authSlice.reducer;
-
-// src/modules/auth/providers/AuthProvider.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
-var AuthContext = createContext(null);
-function AuthProvider({ children, authService, authCallbacks }) {
-  const dispatch = useAppDispatch();
-  useEffect(() => {
-    dispatch(initializeFromStorage());
-    const unsubscribe = authService.onAuthStateChanged((user2) => {
-      if (user2) {
-        dispatch(signIn(user2));
-        if (authCallbacks?.onUserIdentify && user2.email) {
-          authCallbacks.onUserIdentify({
-            email: user2.email,
-            name: user2.displayName,
-            avatar: user2.avatar,
-            uid: user2.uid
-          });
-        }
-        if (authCallbacks?.onSignInSuccess) {
-          authCallbacks.onSignInSuccess(user2);
-        }
-      } else {
-        dispatch(signOut());
-        if (authCallbacks?.onTrackingReset) {
-          authCallbacks.onTrackingReset();
-        }
-      }
-      dispatch(setPending(false));
-    });
-    return () => {
-      unsubscribe();
-    };
-  }, [authService, dispatch, authCallbacks]);
-  const user = useAppSelector(selectUser);
-  const isSignedIn = useAppSelector(selectIsSignedIn);
-  const isLoading = useAppSelector(selectIsLoading);
-  const signInWithCredential = async (email, password) => {
-    const result = await authService.signInWithEmailAndPassword(email, password);
-    if (result.data && authCallbacks?.onSignInSuccess) {
-      authCallbacks.onSignInSuccess(result.data);
-    } else if (result.errorCode && authCallbacks?.onSignInError) {
-      authCallbacks.onSignInError(result.errorCode);
-    }
-    return result;
-  };
-  const signInWithGoogle = async () => {
-    const result = await authService.signInWithGoogle();
-    if (result.data && authCallbacks?.onSignInSuccess) {
-      authCallbacks.onSignInSuccess(result.data);
-      return result;
-    } else if (result.errorCode && authCallbacks?.onSignInError) {
-      authCallbacks.onSignInError(result.errorCode);
-    }
-    return null;
-  };
-  const signUp = async (email, password) => {
-    const result = await authService.signUp(email, password);
-    if (result.data && authCallbacks?.onSignUpSuccess) {
-      authCallbacks.onSignUpSuccess(result.data);
-    } else if (result.errorCode && authCallbacks?.onSignUpError) {
-      authCallbacks.onSignUpError(result.errorCode);
-    }
-    return result;
-  };
-  const signOut2 = async () => {
-    await authService.signOut();
-    dispatch(signOut());
-    if (authCallbacks?.onSignOutSuccess) {
-      authCallbacks.onSignOutSuccess();
-    }
-  };
-  const forgotPassword = async (email) => {
-    return await authService.sendPasswordResetEmail(email);
-  };
-  const sendEmailVerification = async () => {
-    return await authService.sendEmailVerification();
-  };
-  const changePassword = async (newPassword) => {
-    return await authService.changePassword(newPassword);
-  };
-  const updateScanStatus2 = (status) => {
-    dispatch(updateScanStatus(status));
-  };
-  const refreshUser2 = (userData) => {
-    dispatch(refreshUser(userData));
-  };
-  const contextValue = {
-    authService,
-    authCallbacks,
-    // User state
-    user,
-    isSignedIn,
-    isLoading,
-    // Auth actions
-    signInWithCredential,
-    signInWithGoogle,
-    signUp,
-    signOut: signOut2,
-    // Password actions
-    forgotPassword,
-    sendEmailVerification,
-    changePassword,
-    // User management
-    updateScanStatus: updateScanStatus2,
-    refreshUser: refreshUser2
-  };
-  return /* @__PURE__ */ jsx2(AuthContext.Provider, { value: contextValue, children });
-}
-var useAuth = () => {
-  const authContext = useContext(AuthContext);
-  if (!authContext) {
-    throw new Error("useAuth must be used within an AuthProvider");
-  }
-  return authContext;
-};
-
-// src/modules/auth/index.ts
-init_constants();
-
 // src/modules/user-profile/hooks/index.ts
 import { useMyProfile, useUpdateMyProfile, useSyncCheckin, useCancelUserRewardsRequest } from "@phygitallabs/api-core";
 
@@ -1048,12 +1242,12 @@ import { useMyProfile, useUpdateMyProfile, useSyncCheckin, useCancelUserRewardsR
 import { UserSourceType } from "@phygitallabs/api-core";
 
 // src/modules/scan-chip/hooks/index.tsx
-import { useEffect as useEffect2 } from "react";
+import { useEffect as useEffect3 } from "react";
 import { useChipScanStory } from "@phygitallabs/api-core";
-import { usePGLCoreService } from "@phygitallabs/api-core";
+import { usePGLCoreService as usePGLCoreService2 } from "@phygitallabs/api-core";
 function useScanChip({ token, id, onScanChipError }) {
-  const { updateHeaders } = usePGLCoreService();
-  useEffect2(() => {
+  const { updateHeaders } = usePGLCoreService2();
+  useEffect3(() => {
     if (!!token) {
       const header = {
         "Chip-Authorization": token
@@ -1066,7 +1260,7 @@ function useScanChip({ token, id, onScanChipError }) {
     token,
     id
   });
-  useEffect2(() => {
+  useEffect3(() => {
     if (isError) {
       onScanChipError?.();
     }
@@ -1139,11 +1333,172 @@ var filterLocationsByProperty = (locations, propertyName, value) => {
 import {
   useGenerateThaocamvienCertificate,
   useGenerateTemplateCertificate,
-  useGenerateFansipanCertificate
+  useGenerateFansipanCertificate,
+  useCreateCertificate,
+  useCreateCertificateAnonymous,
+  useCreateCertificateWithMask
 } from "@phygitallabs/generate-certificate";
 
+// src/modules/generate-certificate/helpers/index.ts
+import { wrapTextWithFont } from "@phygitallabs/generate-certificate";
+
 // src/modules/data-tracking/hooks/index.ts
 import posthog from "posthog-js";
+
+// src/modules/session-replay/providers/SessionReplayProvider.tsx
+import { createContext, useEffect as useEffect4, useReducer } from "react";
+import { v4 as uuidV4 } from "uuid";
+
+// src/modules/session-replay/utils/index.ts
+var isBrowser = () => {
+  return typeof window !== "undefined";
+};
+
+// src/modules/session-replay/providers/SessionReplayProvider.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var TrackerContext = createContext(null);
+function defaultGetUserId() {
+  return uuidV4();
+}
+async function newTracker(config) {
+  try {
+    const OpenReplay = (await import("@openreplay/tracker")).default;
+    const getUserId = config?.userIdEnabled && config?.getUserId ? config.getUserId : defaultGetUserId;
+    const trackerConfig = {
+      projectKey: config?.projectKey || process.env.NEXT_PUBLIC_OPENREPLAY_PROJECT_KEY,
+      ingestPoint: config?.ingestPoint,
+      // Capture options
+      captureExceptions: config.captureExceptions ?? true,
+      capturePerformance: config.capturePerformance ?? true,
+      // Network tracking
+      network: config.network || {
+        capturePayload: true,
+        sanitizer: (data) => data
+      },
+      // Console tracking
+      console: config.console || {
+        levels: ["error", "warn", "log"]
+      },
+      // Privacy settings
+      obscureTextEmails: config.obscureTextEmails ?? true,
+      obscureTextNumbers: config.obscureTextNumbers ?? false,
+      obscureInputEmails: config.obscureInputEmails ?? true,
+      // Development mode
+      __DISABLE_SECURE_MODE: config.__DISABLE_SECURE_MODE ?? (typeof process !== "undefined" && process.env?.NODE_ENV === "development")
+    };
+    const tracker = new OpenReplay(trackerConfig);
+    if (config?.userIdEnabled) {
+      const userId = getUserId();
+      tracker.setUserID(userId);
+      console.log("User ID set:", userId);
+    }
+    console.log("OpenReplay tracker initialized");
+    console.log("Project Key:", trackerConfig.projectKey);
+    console.log("Ingest Point:", trackerConfig.ingestPoint);
+    return tracker;
+  } catch (error) {
+    console.error("Failed to create tracker:", error);
+    throw error;
+  }
+}
+function reducer(state, action) {
+  const { debug = false } = state.config;
+  switch (action.type) {
+    case "init":
+      if (!state.tracker && isBrowser()) {
+        if (!state.config.projectKey && !process.env.NEXT_PUBLIC_OPENREPLAY_PROJECT_KEY) {
+          console.warn(
+            debug,
+            "Project key not found. Skipping session replay initialization."
+          );
+          return state;
+        }
+        return {
+          ...state,
+          tracker: newTracker(state.config)
+        };
+      }
+      return state;
+    case "start":
+      if (state.tracker) {
+        Promise.resolve(state.tracker).then((tracker) => {
+          tracker.start();
+          console.log(debug, "Session replay tracker started");
+        }).catch((error) => {
+          console.error("Failed to start tracker:", error);
+        });
+      } else {
+        console.warn(debug, "Tracker not initialized. Call initTracker() first.");
+      }
+      return state;
+    case "setUserId":
+      if (state.tracker) {
+        Promise.resolve(state.tracker).then((tracker) => {
+          tracker.setUserID(action.payload);
+          console.log(debug, "User ID updated:", action.payload);
+        }).catch((error) => {
+          console.error("Failed to set user ID:", error);
+        });
+      } else {
+        console.warn(debug, "Tracker not initialized. Call initTracker() first.");
+      }
+      return state;
+    // Set metadata
+    case "setMetadata":
+      if (state.tracker) {
+        Promise.resolve(state.tracker).then((tracker) => {
+          Object.entries(action.payload || {})?.forEach(([key, value]) => {
+            tracker.setMetadata(key, value);
+          });
+          console.log(debug, "Metadata updated:", action.payload.metadata);
+        }).catch((error) => {
+          console.error("Failed to set metadata:", error);
+        });
+      } else {
+        console.warn(debug, "Tracker not initialized. Call initTracker() first.");
+      }
+      return state;
+    default:
+      return state;
+  }
+}
+var SessionReplayProvider = ({
+  children,
+  config = {}
+}) => {
+  const [, dispatch] = useReducer(reducer, {
+    tracker: null,
+    config
+  });
+  const initTracker = () => dispatch({ type: "init" });
+  const startTracking = () => dispatch({ type: "start" });
+  const setUserId = (userId) => dispatch({ type: "setUserId", payload: userId });
+  const setMetadata = (metadata) => dispatch({ type: "setMetadata", payload: metadata });
+  useEffect4(() => {
+    initTracker();
+    startTracking();
+  }, []);
+  return /* @__PURE__ */ jsx3(TrackerContext.Provider, { value: {
+    initTracker,
+    startTracking,
+    setUserId,
+    setMetadata
+  }, children });
+};
+
+// src/modules/session-replay/hooks/useSessionReplay.ts
+import { useContext } from "react";
+function useSessionReplay() {
+  const context = useContext(TrackerContext);
+  if (!context) {
+    throw new Error(
+      "useSessionReplay must be used within a SessionReplayProvider. Make sure your component is wrapped with <SessionReplayProvider>."
+    );
+  }
+  return context;
+}
+
+// src/modules/data-tracking/hooks/index.ts
 var pushEventToDataLayer = (event, data) => {
   try {
     window.dataLayer = window.dataLayer || [];
@@ -1166,6 +1521,7 @@ var pushEventToPosthog = (eventName, eventData) => {
   posthog.capture(eventName, eventData);
 };
 function useDataTracking() {
+  const { setUserId, setMetadata } = useSessionReplay();
   const trackEvent = (eventName, eventData, useTools) => {
     useTools = useTools || ["gtm"];
     if (useTools.includes("gtm") && typeof window !== "undefined") {
@@ -1178,91 +1534,58 @@ function useDataTracking() {
       pushEventToPosthog(eventName, eventData);
     }
   };
+  const trackUserIdentify = (userInfo) => {
+    posthog.identify(userInfo.email, {
+      email: userInfo.email,
+      name: userInfo.name,
+      avatar: userInfo.avatar,
+      uid: userInfo.uid
+    });
+    setUserId(userInfo.id);
+    setMetadata({
+      user_email: userInfo.email
+    });
+  };
+  const trackLogoutEvent = () => {
+    posthog.capture("user_signed_out");
+  };
   return {
-    trackEvent
+    trackEvent,
+    trackUserIdentify,
+    trackLogoutEvent
   };
 }
 
 // src/providers/TapquestCoreProvider.tsx
-import { useMemo as useMemo2 } from "react";
-import { Provider } from "react-redux";
-import { PersistGate } from "redux-persist/integration/react";
+import { useMemo } from "react";
 
 // src/providers/ServicesProvider.tsx
-import { useEffect as useEffect3, useState, useMemo } from "react";
+import { useEffect as useEffect5, useState } from "react";
 import { PGLCoreServiceProvider } from "@phygitallabs/api-core";
 import { RewardServiceProvider } from "@phygitallabs/reward";
 import { AchievementServiceProvider as AchievementServiceProvider2 } from "@phygitallabs/achievement";
 import { GenerateCertificateServiceProvider } from "@phygitallabs/generate-certificate";
-import axios from "axios";
-import { Fragment, jsx as jsx3 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx4 } from "react/jsx-runtime";
 var ServicesProvider = ({
   children,
   queryClient,
   apiConfig = {
     environment: "dev",
     version: "v1"
-  },
-  firebaseConfig
+  }
 }) => {
-  const { refreshUser: refreshUser2, signOut: signOut2 } = useAuth();
   const { environment, version } = apiConfig;
   const [commonServiceConfig, setCommonServiceConfig] = useState(null);
-  const memoizedRefreshToken = useMemo(() => {
-    if (!firebaseConfig?.apiKey) {
-      console.warn("Firebase API key not provided, refresh token functionality will not work");
-      return null;
-    }
-    return createRefreshTokenFunction({
-      firebaseApiKey: firebaseConfig.apiKey
-    });
-  }, [firebaseConfig?.apiKey]);
-  useEffect3(() => {
+  useEffect5(() => {
     const initClient = async () => {
       try {
         const deviceUid = await checkDeviceUid();
         const responseInterceptors = {
           onFulfilled: (response) => response,
-          onRejected: async (error) => {
-            const originalRequest = error.config;
-            if (error.response?.status === 401 && !originalRequest._retry) {
-              const retryAttempts = parseInt(
-                getRetryAttemptsRefreshToken() || "0",
-                10
-              );
-              if (retryAttempts >= httpMaxRetries) {
-                await signOut2();
-                return Promise.reject(error);
-              }
-              setRetryAttemptsRefreshToken(`${retryAttempts + 1}`);
-              originalRequest._retry = true;
-              try {
-                if (!memoizedRefreshToken) {
-                  await signOut2();
-                  return Promise.reject(error);
-                }
-                const result = await memoizedRefreshToken();
-                if (result?.accessToken) {
-                  originalRequest.headers["Authorization"] = `Bearer ${result.accessToken}`;
-                  setRetryAttemptsRefreshToken("0");
-                  refreshUser2(result);
-                  return axios(originalRequest);
-                }
-              } catch (refreshError) {
-                console.log("Failed to refresh token:", refreshError);
-              }
-            }
-            return Promise.reject(error);
-          }
+          onRejected: async (error) => Promise.reject(error)
         };
         const requestInterceptors = {
-          onFulfilled: (config2) => {
-            const currentToken = getAccessToken();
-            if (currentToken && !config2.headers.Authorization) {
-              config2.headers.Authorization = `Bearer ${currentToken}`;
-            }
-            return config2;
-          },
+          onFulfilled: (config2) => config2,
           onRejected: (error) => Promise.reject(error)
         };
         const axiosConfig = {
@@ -1286,25 +1609,25 @@ var ServicesProvider = ({
     initClient();
   }, [queryClient]);
   if (!commonServiceConfig) {
-    return /* @__PURE__ */ jsx3(Fragment, {});
+    return /* @__PURE__ */ jsx4(Fragment, {});
   }
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx4(
     PGLCoreServiceProvider,
     {
       ...commonServiceConfig,
       baseURL: `${service_default[environment].API_BASE_URL}/${version}`,
       baseCoreURL: `${service_default[environment].API_BASE_CORE_URL}/${version}`,
-      children: /* @__PURE__ */ jsx3(
+      children: /* @__PURE__ */ jsx4(
         RewardServiceProvider,
         {
           ...commonServiceConfig,
           baseURL: `${service_default[environment].API_REWARD_URL}/v1`,
-          children: /* @__PURE__ */ jsx3(
+          children: /* @__PURE__ */ jsx4(
             AchievementServiceProvider2,
             {
               ...commonServiceConfig,
               baseURL: `${service_default[environment].API_ACHIEVEMENT_URL}/${version}`,
-              children: /* @__PURE__ */ jsx3(
+              children: /* @__PURE__ */ jsx4(
                 GenerateCertificateServiceProvider,
                 {
                   ...commonServiceConfig,
@@ -1320,80 +1643,51 @@ var ServicesProvider = ({
   );
 };
 
-// src/store/index.ts
-import { configureStore } from "@reduxjs/toolkit";
-import storage from "redux-persist/lib/storage";
-import { persistReducer, persistStore } from "redux-persist";
-var authPersistConfig = {
-  key: "tapquest-auth",
-  storage,
-  whitelist: ["user", "isSignedIn"]
-  // Only persist user and sign-in status
-};
-var persistedAuthReducer = persistReducer(authPersistConfig, authSlice.reducer);
-var store = configureStore({
-  reducer: {
-    auth: persistedAuthReducer
-  },
-  middleware: (getDefaultMiddleware) => getDefaultMiddleware({
-    serializableCheck: {
-      // Ignore redux-persist actions
-      ignoredActions: [
-        "persist/FLUSH",
-        "persist/REHYDRATE",
-        "persist/PAUSE",
-        "persist/PERSIST",
-        "persist/PURGE",
-        "persist/REGISTER"
-      ]
-    }
-  })
-});
-var persistor = persistStore(store);
-
 // src/providers/TapquestCoreProvider.tsx
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { jsx as jsx5 } from "react/jsx-runtime";
 var TapquestCoreProvider = ({
   children,
   queryClient,
-  apiConfig,
-  firebaseConfig,
-  authCallbacks
+  apiConfig
+  // authCallbacks
 }) => {
-  const internalAuthService = useMemo2(() => {
-    if (firebaseConfig && typeof window !== "undefined") {
-      try {
-        const { createAuthService: createAuthService2 } = (init_services(), __toCommonJS(services_exports));
-        return createAuthService2({ firebaseConfig });
-      } catch (error) {
-        console.warn("Failed to create auth service from firebase config:", error);
-        return null;
-      }
+  const { environment } = apiConfig;
+  const sessionReplayConfig = useMemo(() => {
+    const projectKey = process.env.NEXT_PUBLIC_OPENREPLAY_PROJECT_KEY;
+    if (!projectKey) {
+      return void 0;
     }
-    return null;
-  }, [firebaseConfig]);
-  return /* @__PURE__ */ jsx4(Provider, { store, children: /* @__PURE__ */ jsx4(PersistGate, { loading: null, persistor, children: /* @__PURE__ */ jsx4(
-    AuthProvider,
+    return {
+      projectKey,
+      ingestPoint: process.env.NEXT_PUBLIC_OPENREPLAY_INGEST_POINT,
+      debug: process.env.NODE_ENV === "development",
+      captureExceptions: true,
+      capturePerformance: true,
+      obscureTextEmails: true,
+      obscureInputEmails: true
+    };
+  }, []);
+  return /* @__PURE__ */ jsx5(SessionReplayProvider, { config: sessionReplayConfig, children: /* @__PURE__ */ jsx5(
+    ServicesProvider,
     {
-      authService: internalAuthService,
-      authCallbacks,
-      children: /* @__PURE__ */ jsx4(
-        ServicesProvider,
+      queryClient,
+      apiConfig,
+      children: /* @__PURE__ */ jsx5(
+        AuthProvider,
         {
+          baseURL: `${service_default[environment].API_BASE_URL}`,
           queryClient,
-          apiConfig,
-          firebaseConfig,
           children
         }
       )
     }
-  ) }) });
+  ) });
 };
 
 // src/modules/achivementWithReward/hooks/achivementPlusRewardModel.ts
 import { useManyAchievements as useManyAchievements2 } from "@phygitallabs/achievement";
 import { useCreateModelGroupReward as useCreateModelGroupReward2 } from "@phygitallabs/reward/src/hooks/useGroupReward";
-import { useEffect as useEffect4, useMemo as useMemo3 } from "react";
+import { useEffect as useEffect6, useMemo as useMemo2 } from "react";
 function buildMappedAchievements(achievements, groupRewardData) {
   if (!groupRewardData?.reward_models) return [];
   const rewardModels = groupRewardData.reward_models;
@@ -1423,7 +1717,7 @@ var useAchivementPlusRewardModel = ({ campaignId }) => {
     },
     { enabled: !!campaignId }
   );
-  const groupRewardIds = useMemo3(() => {
+  const groupRewardIds = useMemo2(() => {
     if (!achievements?.data) return [];
     return achievements.data.map((achievement) => achievement.groupRewardId).filter((id) => id !== void 0);
   }, [achievements?.data]);
@@ -1432,12 +1726,12 @@ var useAchivementPlusRewardModel = ({ campaignId }) => {
     data: groupRewardModelsData,
     isPending: isPendingGroupRewardModels
   } = useCreateModelGroupReward2();
-  useEffect4(() => {
+  useEffect6(() => {
     if (groupRewardIds.length > 0) {
       fetchGroupRewardModels({ group_reward_ids: groupRewardIds });
     }
   }, [groupRewardIds, fetchGroupRewardModels]);
-  const mappedAchievements = useMemo3(() => {
+  const mappedAchievements = useMemo2(() => {
     if (!groupRewardModelsData?.data || !achievements?.data) return [];
     return buildMappedAchievements(achievements.data, groupRewardModelsData.data);
   }, [groupRewardModelsData, achievements?.data]);
@@ -1454,10 +1748,12 @@ import { useSendEmail } from "@phygitallabs/api-core";
 // src/helper/helpers.ts
 import { cn, parse, fileToBase64 } from "@phygitallabs/helpers";
 export {
+  ALLOWED_ORIGINS,
   AchievementRuleActionType,
   AchievementServiceProvider,
   AchievementType,
   AuthProvider,
+  CALLBACK_URL,
   CampaignState,
   CmentityRewardType,
   NotificationProvider,
@@ -1470,7 +1766,6 @@ export {
   chipAuthTokenKey,
   cn,
   convertSnakeToCamel,
-  createRefreshTokenFunction,
   deviceUIDKey,
   fileToBase64,
   filterLocationsByProperty,
@@ -1511,18 +1806,22 @@ export {
   useChipScanStory,
   useClaimUserReward,
   useClearUserRewardCache,
+  useCreateCertificate,
+  useCreateCertificateAnonymous,
+  useCreateCertificateWithMask,
   useCreateMemory,
   useCreateModelGroupReward,
-  useApiCreateRewardModel as useCreateRewardModel,
+  useCreateRewardModel,
   useDataTracking,
-  useApiDeleteRewardModel as useDeleteRewardModel,
+  useDeleteRewardModel,
   useGenerateFansipanCertificate,
   useGenerateTemplateCertificate,
   useGenerateThaocamvienCertificate,
-  useApiGetRewardModel as useGetRewardModel,
+  useGetRewardModel,
   useGetUserRewards,
+  useGoogleLogin,
   useInfiniteMemories,
-  useApiListRewardModels as useListRewardModels,
+  useListRewardModels,
   useOneLocation as useLocationDetail,
   useUserCampaignsCompletedLocation as useLocationProgress,
   useManyLocations as useLocationsList,
@@ -1537,16 +1836,17 @@ export {
   useOneAchievement,
   useOneMemory,
   useOneUserCampaign,
-  usePGLCoreService,
+  usePGLCoreService2 as usePGLCoreService,
   useScanChip,
   useSendEmail,
   useSyncCheckin,
   useUpdateMyProfile,
-  useApiUpdateRewardModel as useUpdateRewardModel,
+  useUpdateRewardModel,
   useUploadMedia,
   useUserAchievementAction,
   useUserCampaignAction,
   useV1ListRewards,
-  userInfoKey
+  userInfoKey,
+  wrapTextWithFont
 };
 //# sourceMappingURL=index.js.map