@phygitallabs/tapquest-core 2.9.0 → 2.13.0

package/dist/index.cjs

@@ -1,1809 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ALLOWED_ORIGINS: () => ALLOWED_ORIGINS,
-  AchievementRuleActionType: () => import_achievement3.AchievementRuleActionType,
-  AchievementServiceProvider: () => import_achievement3.AchievementServiceProvider,
-  AchievementType: () => AchievementType,
-  AuthProvider: () => AuthProvider,
-  CALLBACK_URL: () => CALLBACK_URL,
-  CampaignState: () => import_api_core10.CampaignState,
-  CmentityRewardType: () => import_reward2.CmentityRewardType,
-  NotificationProvider: () => NotificationProvider,
-  RewardClaimStatus: () => RewardClaimStatus,
-  TapquestCoreProvider: () => TapquestCoreProvider,
-  TaskType: () => TaskType,
-  UserSourceType: () => import_api_core6.UserSourceType,
-  accessTokenKey: () => accessTokenKey,
-  checkDeviceUid: () => checkDeviceUid,
-  chipAuthTokenKey: () => chipAuthTokenKey,
-  cn: () => import_helpers5.cn,
-  convertSnakeToCamel: () => convertSnakeToCamel,
-  deviceUIDKey: () => deviceUIDKey,
-  fileToBase64: () => import_helpers5.fileToBase64,
-  filterLocationsByProperty: () => filterLocationsByProperty,
-  generateDeviceId: () => generateDeviceId,
-  getAccessToken: () => getAccessToken,
-  getActionsFromAchievementRule: () => getActionsFromAchievementRule,
-  getChipAuthToken: () => getChipAuthToken,
-  getDeviceUid: () => getDeviceUid,
-  getLocationIdsFromAchievementRule: () => getLocationIdsFromAchievementRule,
-  getRefreshToken: () => getRefreshToken,
-  getRetryAttemptsRefreshToken: () => getRetryAttemptsRefreshToken,
-  getUserInfo: () => getUserInfo,
-  httpMaxRetries: () => httpMaxRetries,
-  isAchievementCompleted: () => isAchievementCompleted,
-  locationQueryKeys: () => import_api_core11.locationQueryKeys,
-  memoriesKey: () => import_api_core2.memoriesKey,
-  parse: () => import_helpers5.parse,
-  refreshTokenKey: () => refreshTokenKey,
-  removeAccessToken: () => removeAccessToken,
-  removeChipAuthToken: () => removeChipAuthToken,
-  removeDeviceUid: () => removeDeviceUid,
-  removeRefreshToken: () => removeRefreshToken,
-  removeUserInfo: () => removeUserInfo,
-  resetMemoriesQuery: () => import_api_core2.resetMemoriesQuery,
-  retryAttemptsRefreshToken: () => retryAttemptsRefreshToken,
-  setAccessToken: () => setAccessToken,
-  setChipAuthToken: () => setChipAuthToken,
-  setDeviceUid: () => setDeviceUid,
-  setRefreshToken: () => setRefreshToken,
-  setRetryAttemptsRefreshToken: () => setRetryAttemptsRefreshToken,
-  setUserInfo: () => setUserInfo,
-  sortLocationsByIndex: () => sortLocationsByIndex,
-  useAchievementProgress: () => import_achievement2.useAchievementProgress,
-  useAchivementPlusRewardModel: () => achivementPlusRewardModel_default,
-  useAuth: () => useAuth,
-  useCampaignDetail: () => import_api_core9.useOneCampaign,
-  useCancelUserRewardsRequest: () => import_api_core5.useCancelUserRewardsRequest,
-  useChipScanStory: () => import_api_core7.useChipScanStory,
-  useClaimUserReward: () => import_reward.useClaimUserReward,
-  useClearUserRewardCache: () => import_reward.useClearUserRewardCache,
-  useCreateCertificate: () => import_generate_certificate2.useCreateCertificate,
-  useCreateCertificateAnonymous: () => import_generate_certificate2.useCreateCertificateAnonymous,
-  useCreateCertificateWithMask: () => import_generate_certificate2.useCreateCertificateWithMask,
-  useCreateMemory: () => import_api_core2.useCreateMemory,
-  useCreateModelGroupReward: () => import_reward.useCreateModelGroupReward,
-  useCreateRewardModel: () => import_reward.useCreateRewardModel,
-  useDataTracking: () => useDataTracking,
-  useDeleteRewardModel: () => import_reward.useDeleteRewardModel,
-  useGenerateFansipanCertificate: () => import_generate_certificate2.useGenerateFansipanCertificate,
-  useGenerateTemplateCertificate: () => import_generate_certificate2.useGenerateTemplateCertificate,
-  useGenerateThaocamvienCertificate: () => import_generate_certificate2.useGenerateThaocamvienCertificate,
-  useGetRewardModel: () => import_reward.useGetRewardModel,
-  useGetUserRewards: () => import_reward.useGetUserRewards,
-  useGoogleLogin: () => useGoogleLogin,
-  useInfiniteMemories: () => import_api_core2.useInfiniteMemories,
-  useListRewardModels: () => import_reward.useListRewardModels,
-  useLocationDetail: () => import_api_core11.useOneLocation,
-  useLocationProgress: () => import_api_core11.useUserCampaignsCompletedLocation,
-  useLocationsList: () => import_api_core11.useManyLocations,
-  useManyAchievementProgress: () => useManyAchievementProgress,
-  useManyAchievements: () => import_achievement2.useManyAchievements,
-  useManyAchievementsRewardModels: () => import_achievement2.useManyAchievementsRewardModels,
-  useManyChildrenAchievements: () => import_achievement2.useManyChildrenAchievements,
-  useManyMemory: () => import_api_core2.useManyMemory,
-  useManyUserActionLocations: () => import_api_core11.useManyUserActionLocations,
-  useManyUserRewards: () => import_reward.useManyUserRewards,
-  useMyProfile: () => import_api_core5.useMyProfile,
-  useOneAchievement: () => import_achievement2.useOneAchievement,
-  useOneMemory: () => import_api_core2.useOneMemory,
-  useOneUserCampaign: () => import_api_core9.useOneUserCampaign,
-  usePGLCoreService: () => import_api_core8.usePGLCoreService,
-  useScanChip: () => useScanChip,
-  useSendEmail: () => import_api_core13.useSendEmail,
-  useSyncCheckin: () => import_api_core5.useSyncCheckin,
-  useUpdateMyProfile: () => import_api_core5.useUpdateMyProfile,
-  useUpdateRewardModel: () => import_reward.useUpdateRewardModel,
-  useUploadMedia: () => import_api_core2.useUploadMedia,
-  useUserAchievementAction: () => import_achievement2.useUserAchievementAction,
-  useUserCampaignAction: () => import_api_core9.useUserCampaignAction,
-  useV1ListRewards: () => import_reward.useV1ListRewards,
-  userInfoKey: () => userInfoKey,
-  wrapTextWithFont: () => import_generate_certificate3.wrapTextWithFont
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/modules/achievement/hooks/index.ts
-var import_achievement = require("@phygitallabs/achievement");
-var import_api_core = require("@phygitallabs/api-core");
-var import_achievement2 = require("@phygitallabs/achievement");
-
-// src/modules/achievement/helpers/index.ts
-var getLocationIdsFromAchievementRule = (achievement) => {
-  if (!achievement.rule) return [];
-  const locationIds = [];
-  Object.values(achievement.rule).forEach((ruleList) => {
-    if (!ruleList.rules) return;
-    ruleList.rules.forEach((rule) => {
-      if (!rule.filter) return;
-      Object.values(rule.filter).forEach((filterList) => {
-        if (!filterList.filters) return;
-        filterList.filters.forEach((filter) => {
-          if (filter.label === "location_id" && filter.value) {
-            if (Array.isArray(filter.value)) {
-              locationIds.push(...filter.value);
-            } else {
-              locationIds.push(filter.value);
-            }
-          }
-        });
-      });
-    });
-  });
-  return Array.from(new Set(locationIds));
-};
-var getActionsFromAchievementRule = (achievement) => {
-  if (!achievement.rule) return [];
-  const actions = [];
-  Object.values(achievement.rule).forEach((ruleList) => {
-    if (!ruleList.rules) return;
-    ruleList.rules.forEach((rule) => {
-      if (rule.action) {
-        actions.push(rule.action);
-      }
-    });
-  });
-  return Array.from(new Set(actions));
-};
-var isAchievementCompleted = (achievement) => {
-  return achievement.isCompleted || achievement.overallPercentage === 100;
-};
-function convertSnakeToCamel(obj) {
-  if (obj === null || obj === void 0) {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(
-      (item) => convertSnakeToCamel(item)
-    );
-  }
-  if (typeof obj === "object" && obj.constructor === Object) {
-    const converted = {};
-    for (const key in obj) {
-      if (obj.hasOwnProperty(key)) {
-        const camelKey = key.replace(
-          /_([a-z])/g,
-          (_, letter) => letter.toUpperCase()
-        );
-        converted[camelKey] = convertSnakeToCamel(
-          obj[key]
-        );
-      }
-    }
-    return converted;
-  }
-  return obj;
-}
-
-// src/modules/achievement/hooks/index.ts
-var useManyAchievementProgress = (params, options) => {
-  const isLoggedIn = !!params.userId;
-  const queryParams = isLoggedIn ? {
-    achievementIds: params.achievementIds,
-    userId: params.userId,
-    applicationId: params.applicationId
-  } : {
-    achievement_ids: params.achievementIds,
-    device_uid: params.deviceUid,
-    applicationId: params.applicationId
-  };
-  if (isLoggedIn) {
-    return (0, import_achievement.useManyAchievementProgress)(
-      queryParams,
-      {
-        ...options,
-        select: (data) => data.map((item) => ({
-          ...item,
-          isCompleted: isAchievementCompleted(item)
-        }))
-      }
-    );
-  }
-  return (0, import_api_core.useManyAchievementProgressByDevice)(
-    queryParams,
-    {
-      ...options,
-      select: (data) => {
-        const camelCaseData = convertSnakeToCamel(data);
-        return camelCaseData.map((item) => ({
-          ...item,
-          isCompleted: isAchievementCompleted(item)
-        }));
-      }
-    }
-  );
-};
-
-// src/modules/achievement/types/index.ts
-var import_achievement3 = require("@phygitallabs/achievement");
-var AchievementType = /* @__PURE__ */ ((AchievementType2) => {
-  AchievementType2["DEFAULT"] = "default";
-  AchievementType2["MULTIPLE_CHECK_INS"] = "multiple_check_ins";
-  AchievementType2["RANDOM_CHECK_INS"] = "random_check_ins";
-  AchievementType2["GROUP_MISSION"] = "group_mission";
-  return AchievementType2;
-})(AchievementType || {});
-
-// src/modules/reward/hooks/useRewardService.ts
-var import_reward = require("@phygitallabs/reward");
-
-// src/modules/reward/types/enums.ts
-var import_reward2 = require("@phygitallabs/reward");
-var RewardClaimStatus = /* @__PURE__ */ ((RewardClaimStatus2) => {
-  RewardClaimStatus2["NOT_CLAIMED"] = "not_claimed";
-  RewardClaimStatus2["CLAIMED"] = "claimed";
-  RewardClaimStatus2["IN_PROGRESS"] = "in_progress";
-  RewardClaimStatus2["FAILED"] = "failed";
-  return RewardClaimStatus2;
-})(RewardClaimStatus || {});
-
-// src/modules/notification/index.ts
-var notification_exports = {};
-__export(notification_exports, {
-  NotificationProvider: () => NotificationProvider
-});
-__reExport(notification_exports, require("@phygitallabs/notification-api"));
-
-// src/modules/notification/providers/index.tsx
-var import_notification_api = require("@phygitallabs/notification-api");
-
-// src/constants/service.ts
-var serviceApiUrl = {
-  dev: {
-    API_BASE_URL: "https://backend-dev.nomion.io",
-    API_BASE_CORE_URL: "https://backend-dev.nomion.io/core",
-    API_ACHIEVEMENT_URL: "https://backend-dev.nomion.io/achievement",
-    API_REWARD_URL: "https://backend-dev.nomion.io/reward",
-    API_GENERATE_CERTIFICATE_URL: "https://media-prc-dev.nomion.io/api",
-    API_NOTIFICATION_SOCKET_URL: "https://backend-dev.nomion.io/notification-ws/ws"
-  },
-  staging: {
-    API_BASE_URL: "https://backend-staging.nomion.io",
-    API_BASE_CORE_URL: "https://backend-staging.nomion.io/core",
-    API_ACHIEVEMENT_URL: "https://backend-staging.nomion.io/achievement",
-    API_REWARD_URL: "https://backend-staging.nomion.io/reward",
-    API_GENERATE_CERTIFICATE_URL: "https://media-prc-staging.nomion.io/api",
-    API_NOTIFICATION_SOCKET_URL: "https://backend-staging.nomion.io/notification-ws/ws"
-  },
-  production: {
-    API_BASE_URL: "https://backend.nomion.io",
-    API_BASE_CORE_URL: "https://backend.nomion.io/core",
-    API_ACHIEVEMENT_URL: "https://backend.nomion.io/achievement",
-    API_REWARD_URL: "https://backend.nomion.io/reward",
-    API_GENERATE_CERTIFICATE_URL: "https://media-prc.nomion.io/api",
-    API_NOTIFICATION_SOCKET_URL: "https://backend.nomion.io/notification-ws/ws"
-  }
-};
-var service_default = serviceApiUrl;
-
-// src/modules/notification/providers/index.tsx
-var import_jsx_runtime = require("react/jsx-runtime");
-var NotificationProvider = ({
-  children,
-  autoConnect = true,
-  environment = "dev",
-  user,
-  onWebSocketOpen,
-  onWebSocketClose,
-  onWebSocketMessage
-}) => {
-  const webSocketUrl = service_default[environment]?.API_NOTIFICATION_SOCKET_URL;
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-    import_notification_api.NotificationProvider,
-    {
-      userUid: user?.id,
-      accessToken: user?.accessToken ?? null,
-      webSocketUrl,
-      autoConnect,
-      onWebSocketOpen,
-      onWebSocketClose,
-      onWebSocketMessage,
-      children
-    }
-  );
-};
-
-// src/index.ts
-__reExport(index_exports, notification_exports, module.exports);
-
-// src/modules/memory/hooks/index.ts
-var import_api_core2 = require("@phygitallabs/api-core");
-
-// src/modules/auth/providers/AuthProvider.tsx
-var import_authentication3 = require("@phygitallabs/authentication");
-var import_react = require("react");
-
-// src/modules/auth/store/authStore.ts
-var import_zustand = require("zustand");
-var import_immer = require("zustand/middleware/immer");
-var import_middleware = require("zustand/middleware");
-var import_authentication = require("@phygitallabs/authentication");
-
-// 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/store/authStore.ts
-var initialState = {
-  user: null,
-  isSignedIn: false,
-  isInitialized: false,
-  isLoading: false,
-  error: null,
-  cleanupFunctions: {},
-  eventCallbacks: {}
-};
-var useAuthStore = (0, import_zustand.create)()(
-  (0, import_middleware.devtools)(
-    (0, import_middleware.persist)(
-      (0, import_middleware.subscribeWithSelector)(
-        (0, import_immer.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 import_authentication.authService.signIn({
-                  email,
-                  password
-                });
-                if (response?.data?.idToken && response?.data?.refreshToken) {
-                  import_authentication.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 import_authentication.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 import_authentication.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 = import_authentication.tokenStorage.isTokenExpired();
-                if (isTokenExpired) {
-                  import_authentication.tokenStorage.clearTokens();
-                  localStorage.clear();
-                  return;
-                }
-                await import_authentication.authService.logout();
-                localStorage.clear();
-                import_authentication.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 import_authentication.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 import_authentication.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 import_authentication.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 import_authentication.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 import_authentication.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 import_authentication.authService.refreshToken({
-                refreshToken: refreshToken ?? import_authentication.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 = import_authentication.tokenStorage.getAuthToken();
-                state.isSignedIn = !!token;
-                state.isInitialized = true;
-              });
-            },
-            // Sync auth state from tokenStorage (called when axios interceptor updates tokens)
-            syncAuthState: () => {
-              set((state) => {
-                const token = import_authentication.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: (0, import_middleware.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/utils/user.ts
-var import_jwt_decode = __toESM(require("jwt-decode"), 1);
-var transformProtoUserData = (user, accessToken) => {
-  const userData = { ...user };
-  let tokenDecoded = {};
-  try {
-    tokenDecoded = (0, import_jwt_decode.default)(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;
-};
-
-// src/modules/auth/providers/AuthProvider.tsx
-var import_api_core3 = require("@phygitallabs/api-core");
-var import_api_core4 = require("@phygitallabs/api-core");
-var import_achievement4 = require("@phygitallabs/achievement");
-var import_reward3 = require("@phygitallabs/reward");
-var import_generate_certificate = require("@phygitallabs/generate-certificate");
-
-// src/modules/auth/hooks/useTokenRefresher.ts
-var import_react_query = require("@tanstack/react-query");
-var import_authentication2 = require("@phygitallabs/authentication");
-function useTokenRefresher() {
-  const { refreshToken, signOut } = useAuth();
-  const handleRefreshToken = async () => {
-    try {
-      const isTokenExpired = import_authentication2.tokenStorage.isTokenExpired();
-      if (!isTokenExpired) {
-        return;
-      }
-      const newToken = await refreshToken();
-      if (newToken.data?.idToken && newToken.data?.refreshToken) {
-        import_authentication2.tokenStorage.setTokens({
-          idToken: newToken.data?.idToken,
-          refreshToken: newToken.data?.refreshToken
-        });
-      }
-    } catch (error) {
-      console.error("Failed to refresh token:", error);
-      signOut();
-    }
-  };
-  (0, import_react_query.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: !!import_authentication2.tokenStorage.getAuthToken()
-    // only run if logged in
-  });
-}
-
-// src/modules/auth/providers/AuthProvider.tsx
-var import_jsx_runtime2 = require("react/jsx-runtime");
-var AuthStateManager = () => {
-  const { updateHeaders } = (0, import_authentication3.useAuthenticationHeaders)();
-  const { updateHeaders: updateHeadersPGL, coreApi } = (0, import_api_core4.usePGLCoreService)();
-  const { updateHeaders: updateHeadersAchievement } = (0, import_achievement4.useAchievementService)();
-  const { updateHeaders: updateHeadersReward } = (0, import_reward3.useRewardService)();
-  const { updateHeaders: updateHeadersGenerateCertificate } = (0, import_generate_certificate.useGenerateCertificateService)();
-  (0, import_react.useEffect)(() => {
-    useAuthStore.getState().actions.initialize();
-    const token = import_authentication3.tokenStorage.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 = import_authentication3.tokenStorage.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 = (0, import_api_core3.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 = import_authentication3.tokenStorage.addTokenChangeListener(async () => {
-      const { isSignedIn, user } = useAuthStore.getState();
-      if (isSignedIn) {
-        const token2 = import_authentication3.tokenStorage.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__ */ (0, import_jsx_runtime2.jsxs)(
-    import_authentication3.AuthenticationProvider,
-    {
-      axiosConfig,
-      baseURL,
-      queryClient,
-      children: [
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AuthStateManager, {}),
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(TokenRefresher, {}),
-        children
-      ]
-    }
-  );
-};
-
-// src/modules/auth/hooks/useGoogleLogin.ts
-var import_react2 = require("react");
-var import_authentication4 = require("@phygitallabs/authentication");
-function useGoogleLogin(options = {}) {
-  const { onSuccess, onError, onPopupBlocked, onPopupClosed } = options;
-  const { signInWithGoogle, refreshToken, setIsSignedIn, setIsLoading, isLoading } = useAuth();
-  const popupRef = (0, import_react2.useRef)(null);
-  const gotDataRef = (0, import_react2.useRef)(false);
-  const timerRef = (0, import_react2.useRef)(null);
-  const errorRef = (0, import_react2.useRef)(null);
-  const handleTokenRefresh = (0, import_react2.useCallback)(
-    async (refresh) => {
-      if (refresh) {
-        try {
-          const newToken = await refreshToken(refresh);
-          if (newToken.data?.idToken && newToken.data?.refreshToken) {
-            import_authentication4.tokenStorage.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 = (0, import_react2.useCallback)(() => {
-    if (timerRef.current) {
-      clearInterval(timerRef.current);
-      timerRef.current = null;
-    }
-    gotDataRef.current = false;
-  }, []);
-  const handleMessage = (0, import_react2.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 = (0, import_react2.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`
-      );
-      if (!popupRef.current) {
-        setIsLoading(false);
-        const error = "Popup blocked. Please allow popups for this site.";
-        errorRef.current = error;
-        onPopupBlocked?.();
-        onError?.(error);
-        return;
-      }
-      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]);
-  (0, import_react2.useEffect)(() => {
-    window.addEventListener("message", handleMessage);
-    return () => {
-      window.removeEventListener("message", handleMessage);
-    };
-  }, [handleMessage]);
-  (0, import_react2.useEffect)(() => {
-    return () => {
-      cleanup();
-    };
-  }, [cleanup, handleMessage]);
-  return {
-    signIn,
-    isLoading,
-    error: errorRef.current
-  };
-}
-
-// src/modules/auth/helpers/index.ts
-var import_uuid = require("uuid");
-var generateDeviceId = async () => {
-  try {
-    const deviceFingerprint = await generateDeviceFingerprint();
-    return deviceFingerprint;
-  } catch (error) {
-    console.error("Error generating device fingerprint:", error);
-    return (0, import_uuid.v4)();
-  }
-};
-var generateDeviceFingerprint = async () => {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const fingerprintRaw = [
-    navigator.userAgent,
-    navigator.language,
-    screen.width,
-    screen.height,
-    screen.colorDepth,
-    Intl.DateTimeFormat().resolvedOptions().timeZone,
-    navigator.platform,
-    navigator.hardwareConcurrency,
-    timestamp
-    // Include timestamp
-  ].join("::");
-  const encoder = new TextEncoder();
-  const data = encoder.encode(fingerprintRaw);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const fingerprint = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  return fingerprint;
-};
-var getDeviceUid = () => {
-  if (typeof window === "undefined") return null;
-  return localStorage.getItem(deviceUIDKey);
-};
-var setDeviceUid = (deviceId) => {
-  if (typeof window === "undefined") return;
-  localStorage.setItem(deviceUIDKey, deviceId);
-};
-var removeDeviceUid = () => {
-  if (typeof window === "undefined") return;
-  localStorage.removeItem(deviceUIDKey);
-};
-var checkDeviceUid = async () => {
-  let deviceUID = getDeviceUid();
-  if (!deviceUID) {
-    deviceUID = await generateDeviceId();
-    setDeviceUid(deviceUID);
-  }
-  return deviceUID;
-};
-var getChipAuthToken = () => {
-  if (typeof window === "undefined") return null;
-  return localStorage.getItem(chipAuthTokenKey);
-};
-var setChipAuthToken = (value) => {
-  if (typeof window === "undefined") return;
-  localStorage.setItem(chipAuthTokenKey, value);
-};
-var removeChipAuthToken = () => {
-  if (typeof window === "undefined") return;
-  localStorage.removeItem(chipAuthTokenKey);
-};
-var getRetryAttemptsRefreshToken = () => {
-  if (typeof window === "undefined") return null;
-  return localStorage.getItem(retryAttemptsRefreshToken);
-};
-var setRetryAttemptsRefreshToken = (value) => {
-  if (typeof window === "undefined") return;
-  localStorage.setItem(retryAttemptsRefreshToken, value);
-};
-var getAccessToken = () => {
-  if (typeof window === "undefined") return null;
-  return localStorage.getItem(accessTokenKey);
-};
-var setAccessToken = (value) => {
-  if (typeof window === "undefined") return;
-  localStorage.setItem(accessTokenKey, value);
-};
-var removeAccessToken = () => {
-  if (typeof window === "undefined") return;
-  localStorage.removeItem(accessTokenKey);
-};
-var getRefreshToken = () => {
-  if (typeof window === "undefined") return null;
-  return localStorage.getItem(refreshTokenKey);
-};
-var setRefreshToken = (value) => {
-  if (typeof window === "undefined") return;
-  localStorage.setItem(refreshTokenKey, value);
-};
-var removeRefreshToken = () => {
-  if (typeof window === "undefined") return;
-  localStorage.removeItem(refreshTokenKey);
-};
-var getUserInfo = () => {
-  if (typeof window === "undefined") return null;
-  const userInfo = localStorage.getItem(userInfoKey);
-  if (!userInfo) return null;
-  try {
-    return JSON.parse(userInfo);
-  } catch (error) {
-    console.error("Failed to parse stored user data:", error);
-    return null;
-  }
-};
-var setUserInfo = (userData) => {
-  if (typeof window === "undefined") return;
-  localStorage.setItem(userInfoKey, JSON.stringify(userData));
-};
-var removeUserInfo = () => {
-  if (typeof window === "undefined") return;
-  localStorage.removeItem(userInfoKey);
-};
-
-// src/modules/user-profile/hooks/index.ts
-var import_api_core5 = require("@phygitallabs/api-core");
-
-// src/modules/user-profile/types/index.ts
-var import_api_core6 = require("@phygitallabs/api-core");
-
-// src/modules/scan-chip/hooks/index.tsx
-var import_react3 = require("react");
-var import_api_core7 = require("@phygitallabs/api-core");
-var import_api_core8 = require("@phygitallabs/api-core");
-function useScanChip({ token, id, onScanChipError }) {
-  const { updateHeaders } = (0, import_api_core8.usePGLCoreService)();
-  (0, import_react3.useEffect)(() => {
-    if (!!token) {
-      const header = {
-        "Chip-Authorization": token
-      };
-      setChipAuthToken(token);
-      updateHeaders(header);
-    }
-  }, [token, updateHeaders]);
-  const { data, isLoading, isError, isSuccess } = (0, import_api_core7.useChipScanStory)({
-    token,
-    id
-  });
-  (0, import_react3.useEffect)(() => {
-    if (isError) {
-      onScanChipError?.();
-    }
-  }, [isError, onScanChipError]);
-  if (!data)
-    return {
-      data: null,
-      isLoading,
-      isError,
-      isSuccess
-    };
-  return {
-    data: {
-      externalUrl: data?.external_url,
-      campaignDetail: data?.project,
-      locationDetail: data?.location,
-      scanCounter: data?.scan_counter,
-      campaignId: data?.campaign_id,
-      chipModelId: data?.chip_model_id,
-      organizationId: data?.organization_id,
-      projectId: data?.project_id,
-      locationId: data?.location_id,
-      chipUid: data?.uid
-    },
-    isLoading,
-    isError,
-    isSuccess
-  };
-}
-
-// src/modules/campaign/hooks/useCampaignService.ts
-var import_api_core9 = require("@phygitallabs/api-core");
-
-// src/modules/campaign/types/enums.ts
-var import_api_core10 = require("@phygitallabs/api-core");
-
-// src/modules/campaign/types/campaign.ts
-var TaskType = /* @__PURE__ */ ((TaskType2) => {
-  TaskType2["CHECK_IN"] = "check_in";
-  TaskType2["CREATE_MEMORY"] = "create_memory";
-  TaskType2["FILL_FORM"] = "fill_form";
-  TaskType2["SHARE"] = "share";
-  return TaskType2;
-})(TaskType || {});
-
-// src/modules/location/hooks/useLocationService.ts
-var import_api_core11 = require("@phygitallabs/api-core");
-
-// src/modules/location/utils/locationHelpers.ts
-var sortLocationsByIndex = (locations) => {
-  return [...locations].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
-};
-var filterLocationsByProperty = (locations, propertyName, value) => {
-  return locations.filter((location) => location[propertyName] === value);
-};
-
-// src/modules/generate-certificate/hooks/index.ts
-var import_generate_certificate2 = require("@phygitallabs/generate-certificate");
-
-// src/modules/generate-certificate/helpers/index.ts
-var import_generate_certificate3 = require("@phygitallabs/generate-certificate");
-
-// src/modules/data-tracking/hooks/index.ts
-var import_posthog_js = __toESM(require("posthog-js"), 1);
-
-// src/modules/session-replay/providers/SessionReplayProvider.tsx
-var import_react4 = require("react");
-var import_uuid2 = require("uuid");
-
-// src/modules/session-replay/utils/index.ts
-var isBrowser = () => {
-  return typeof window !== "undefined";
-};
-
-// src/modules/session-replay/providers/SessionReplayProvider.tsx
-var import_jsx_runtime3 = require("react/jsx-runtime");
-var TrackerContext = (0, import_react4.createContext)(null);
-function defaultGetUserId() {
-  return (0, import_uuid2.v4)();
-}
-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] = (0, import_react4.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 });
-  (0, import_react4.useEffect)(() => {
-    initTracker();
-    startTracking();
-  }, []);
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(TrackerContext.Provider, { value: {
-    initTracker,
-    startTracking,
-    setUserId,
-    setMetadata
-  }, children });
-};
-
-// src/modules/session-replay/hooks/useSessionReplay.ts
-var import_react5 = require("react");
-function useSessionReplay() {
-  const context = (0, import_react5.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 || [];
-    window.dataLayer.push({
-      event,
-      ...data
-    });
-  } catch (error) {
-    console.error(error);
-  }
-};
-var pushEventToGA = (eventName, eventData) => {
-  if (typeof gtag != "function") {
-    console.error("gtag is not a function");
-    return;
-  }
-  gtag("event", eventName, eventData);
-};
-var pushEventToPosthog = (eventName, eventData) => {
-  import_posthog_js.default.capture(eventName, eventData);
-};
-function useDataTracking() {
-  const { setUserId, setMetadata } = useSessionReplay();
-  const trackEvent = (eventName, eventData, useTools) => {
-    useTools = useTools || ["gtm"];
-    if (useTools.includes("gtm") && typeof window !== "undefined") {
-      pushEventToDataLayer(eventName, eventData);
-    }
-    if (useTools.includes("ga") && typeof gtag == "function") {
-      pushEventToGA(eventName, eventData);
-    }
-    if (useTools.includes("posthog") && typeof import_posthog_js.default == "function") {
-      pushEventToPosthog(eventName, eventData);
-    }
-  };
-  const trackUserIdentify = (userInfo) => {
-    import_posthog_js.default.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 = () => {
-    import_posthog_js.default.capture("user_signed_out");
-  };
-  return {
-    trackEvent,
-    trackUserIdentify,
-    trackLogoutEvent
-  };
-}
-
-// src/providers/TapquestCoreProvider.tsx
-var import_react7 = require("react");
-
-// src/providers/ServicesProvider.tsx
-var import_react6 = require("react");
-var import_api_core12 = require("@phygitallabs/api-core");
-var import_reward4 = require("@phygitallabs/reward");
-var import_achievement5 = require("@phygitallabs/achievement");
-var import_generate_certificate4 = require("@phygitallabs/generate-certificate");
-var import_jsx_runtime4 = require("react/jsx-runtime");
-var ServicesProvider = ({
-  children,
-  queryClient,
-  apiConfig = {
-    environment: "dev",
-    version: "v1"
-  }
-}) => {
-  const { environment, version } = apiConfig;
-  const [commonServiceConfig, setCommonServiceConfig] = (0, import_react6.useState)(null);
-  (0, import_react6.useEffect)(() => {
-    const initClient = async () => {
-      try {
-        const deviceUid = await checkDeviceUid();
-        const responseInterceptors = {
-          onFulfilled: (response) => response,
-          onRejected: async (error) => Promise.reject(error)
-        };
-        const requestInterceptors = {
-          onFulfilled: (config2) => config2,
-          onRejected: (error) => Promise.reject(error)
-        };
-        const axiosConfig = {
-          headers: {
-            "Content-Type": "application/json",
-            "Device-UID": deviceUid
-          }
-        };
-        const config = {
-          queryClient,
-          axiosConfig,
-          responseInterceptors,
-          requestInterceptors,
-          useDevTool: true
-        };
-        setCommonServiceConfig(config);
-      } catch (error) {
-        console.error(error);
-      }
-    };
-    initClient();
-  }, [queryClient]);
-  if (!commonServiceConfig) {
-    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, {});
-  }
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-    import_api_core12.PGLCoreServiceProvider,
-    {
-      ...commonServiceConfig,
-      baseURL: `${service_default[environment].API_BASE_URL}/${version}`,
-      baseCoreURL: `${service_default[environment].API_BASE_CORE_URL}/${version}`,
-      children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-        import_reward4.RewardServiceProvider,
-        {
-          ...commonServiceConfig,
-          baseURL: `${service_default[environment].API_REWARD_URL}/v1`,
-          children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-            import_achievement5.AchievementServiceProvider,
-            {
-              ...commonServiceConfig,
-              baseURL: `${service_default[environment].API_ACHIEVEMENT_URL}/${version}`,
-              children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-                import_generate_certificate4.GenerateCertificateServiceProvider,
-                {
-                  ...commonServiceConfig,
-                  baseURL: `${service_default[environment].API_GENERATE_CERTIFICATE_URL}/v1`,
-                  children
-                }
-              )
-            }
-          )
-        }
-      )
-    }
-  );
-};
-
-// src/providers/TapquestCoreProvider.tsx
-var import_jsx_runtime5 = require("react/jsx-runtime");
-var TapquestCoreProvider = ({
-  children,
-  queryClient,
-  apiConfig
-  // authCallbacks
-}) => {
-  const { environment } = apiConfig;
-  const sessionReplayConfig = (0, import_react7.useMemo)(() => {
-    const projectKey = process.env.NEXT_PUBLIC_OPENREPLAY_PROJECT_KEY;
-    if (!projectKey) {
-      return void 0;
-    }
-    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__ */ (0, import_jsx_runtime5.jsx)(SessionReplayProvider, { config: sessionReplayConfig, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-    ServicesProvider,
-    {
-      queryClient,
-      apiConfig,
-      children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-        AuthProvider,
-        {
-          baseURL: `${service_default[environment].API_BASE_URL}`,
-          queryClient,
-          children
-        }
-      )
-    }
-  ) });
-};
-
-// src/modules/achivementWithReward/hooks/achivementPlusRewardModel.ts
-var import_achievement6 = require("@phygitallabs/achievement");
-var import_useGroupReward = require("@phygitallabs/reward/src/hooks/useGroupReward");
-var import_react8 = require("react");
-function buildMappedAchievements(achievements, groupRewardData) {
-  if (!groupRewardData?.reward_models) return [];
-  const rewardModels = groupRewardData.reward_models;
-  return achievements.map((achievement, achievementIndex) => {
-    const parentReward = rewardModels[achievementIndex]?.[0] || null;
-    const subAchievements = achievement.subAchievementIds?.map((subId, subIndex) => {
-      const reward = rewardModels[achievementIndex * (achievement.subAchievementIds?.length || 0) + subIndex + 1]?.[0] || null;
-      return {
-        id: subId,
-        reward_model: reward
-      };
-    }) || [];
-    return {
-      id: achievement.id,
-      name: achievement.name,
-      reward_model: parentReward,
-      subAchievements
-    };
-  });
-}
-var useAchivementPlusRewardModel = ({ campaignId }) => {
-  const { data: achievements, isLoading: isLoadingAchievements } = (0, import_achievement6.useManyAchievements)(
-    {
-      "filter.labels": { campaign_id: campaignId },
-      "filter.type": "group_mission",
-      "pagination.limit": 200
-    },
-    { enabled: !!campaignId }
-  );
-  const groupRewardIds = (0, import_react8.useMemo)(() => {
-    if (!achievements?.data) return [];
-    return achievements.data.map((achievement) => achievement.groupRewardId).filter((id) => id !== void 0);
-  }, [achievements?.data]);
-  const {
-    mutate: fetchGroupRewardModels,
-    data: groupRewardModelsData,
-    isPending: isPendingGroupRewardModels
-  } = (0, import_useGroupReward.useCreateModelGroupReward)();
-  (0, import_react8.useEffect)(() => {
-    if (groupRewardIds.length > 0) {
-      fetchGroupRewardModels({ group_reward_ids: groupRewardIds });
-    }
-  }, [groupRewardIds, fetchGroupRewardModels]);
-  const mappedAchievements = (0, import_react8.useMemo)(() => {
-    if (!groupRewardModelsData?.data || !achievements?.data) return [];
-    return buildMappedAchievements(achievements.data, groupRewardModelsData.data);
-  }, [groupRewardModelsData, achievements?.data]);
-  return {
-    mappedAchievements,
-    isLoading: isLoadingAchievements || isPendingGroupRewardModels
-  };
-};
-var achivementPlusRewardModel_default = useAchivementPlusRewardModel;
-
-// src/modules/send-email/hooks/index.ts
-var import_api_core13 = require("@phygitallabs/api-core");
-
-// src/helper/helpers.ts
-var import_helpers5 = require("@phygitallabs/helpers");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ALLOWED_ORIGINS,
-  AchievementRuleActionType,
-  AchievementServiceProvider,
-  AchievementType,
-  AuthProvider,
-  CALLBACK_URL,
-  CampaignState,
-  CmentityRewardType,
-  NotificationProvider,
-  RewardClaimStatus,
-  TapquestCoreProvider,
-  TaskType,
-  UserSourceType,
-  accessTokenKey,
-  checkDeviceUid,
-  chipAuthTokenKey,
-  cn,
-  convertSnakeToCamel,
-  deviceUIDKey,
-  fileToBase64,
-  filterLocationsByProperty,
-  generateDeviceId,
-  getAccessToken,
-  getActionsFromAchievementRule,
-  getChipAuthToken,
-  getDeviceUid,
-  getLocationIdsFromAchievementRule,
-  getRefreshToken,
-  getRetryAttemptsRefreshToken,
-  getUserInfo,
-  httpMaxRetries,
-  isAchievementCompleted,
-  locationQueryKeys,
-  memoriesKey,
-  parse,
-  refreshTokenKey,
-  removeAccessToken,
-  removeChipAuthToken,
-  removeDeviceUid,
-  removeRefreshToken,
-  removeUserInfo,
-  resetMemoriesQuery,
-  retryAttemptsRefreshToken,
-  setAccessToken,
-  setChipAuthToken,
-  setDeviceUid,
-  setRefreshToken,
-  setRetryAttemptsRefreshToken,
-  setUserInfo,
-  sortLocationsByIndex,
-  useAchievementProgress,
-  useAchivementPlusRewardModel,
-  useAuth,
-  useCampaignDetail,
-  useCancelUserRewardsRequest,
-  useChipScanStory,
-  useClaimUserReward,
-  useClearUserRewardCache,
-  useCreateCertificate,
-  useCreateCertificateAnonymous,
-  useCreateCertificateWithMask,
-  useCreateMemory,
-  useCreateModelGroupReward,
-  useCreateRewardModel,
-  useDataTracking,
-  useDeleteRewardModel,
-  useGenerateFansipanCertificate,
-  useGenerateTemplateCertificate,
-  useGenerateThaocamvienCertificate,
-  useGetRewardModel,
-  useGetUserRewards,
-  useGoogleLogin,
-  useInfiniteMemories,
-  useListRewardModels,
-  useLocationDetail,
-  useLocationProgress,
-  useLocationsList,
-  useManyAchievementProgress,
-  useManyAchievements,
-  useManyAchievementsRewardModels,
-  useManyChildrenAchievements,
-  useManyMemory,
-  useManyUserActionLocations,
-  useManyUserRewards,
-  useMyProfile,
-  useOneAchievement,
-  useOneMemory,
-  useOneUserCampaign,
-  usePGLCoreService,
-  useScanChip,
-  useSendEmail,
-  useSyncCheckin,
-  useUpdateMyProfile,
-  useUpdateRewardModel,
-  useUploadMedia,
-  useUserAchievementAction,
-  useUserCampaignAction,
-  useV1ListRewards,
-  userInfoKey,
-  wrapTextWithFont
-});
-//# sourceMappingURL=index.cjs.map