@phygitallabs/tapquest-core 2.4.0 → 2.8.0

package/dist/index.js

@@ -0,0 +1,1558 @@
+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 });
+};
+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 __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, {
+  AchievementRuleActionType: () => AchievementRuleActionType,
+  AchievementServiceProvider: () => AchievementServiceProvider,
+  AchievementType: () => AchievementType,
+  AuthProvider: () => AuthProvider,
+  CampaignState: () => CampaignState,
+  CmentityRewardType: () => CmentityRewardType,
+  NotificationProvider: () => NotificationProvider,
+  RewardClaimStatus: () => RewardClaimStatus,
+  TapquestCoreProvider: () => TapquestCoreProvider,
+  TaskType: () => TaskType,
+  UserSourceType: () => UserSourceType,
+  accessTokenKey: () => accessTokenKey,
+  checkDeviceUid: () => checkDeviceUid,
+  chipAuthTokenKey: () => chipAuthTokenKey,
+  cn: () => cn,
+  convertSnakeToCamel: () => convertSnakeToCamel,
+  createRefreshTokenFunction: () => createRefreshTokenFunction,
+  deviceUIDKey: () => deviceUIDKey,
+  fileToBase64: () => 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: () => locationQueryKeys,
+  memoriesKey: () => memoriesKey,
+  parse: () => parse,
+  refreshTokenKey: () => refreshTokenKey,
+  removeAccessToken: () => removeAccessToken,
+  removeChipAuthToken: () => removeChipAuthToken,
+  removeDeviceUid: () => removeDeviceUid,
+  removeRefreshToken: () => removeRefreshToken,
+  removeUserInfo: () => removeUserInfo,
+  resetMemoriesQuery: () => resetMemoriesQuery,
+  retryAttemptsRefreshToken: () => retryAttemptsRefreshToken,
+  setAccessToken: () => setAccessToken,
+  setChipAuthToken: () => setChipAuthToken,
+  setDeviceUid: () => setDeviceUid,
+  setRefreshToken: () => setRefreshToken,
+  setRetryAttemptsRefreshToken: () => setRetryAttemptsRefreshToken,
+  setUserInfo: () => setUserInfo,
+  sortLocationsByIndex: () => sortLocationsByIndex,
+  useAchievementProgress: () => useAchievementProgress,
+  useAchivementPlusRewardModel: () => achivementPlusRewardModel_default,
+  useAuth: () => useAuth,
+  useCampaignDetail: () => useOneCampaign,
+  useCancelUserRewardsRequest: () => useCancelUserRewardsRequest,
+  useChipScanStory: () => useChipScanStory,
+  useClaimUserReward: () => useClaimUserReward,
+  useClearUserRewardCache: () => useClearUserRewardCache,
+  useCreateMemory: () => useCreateMemory,
+  useCreateModelGroupReward: () => useCreateModelGroupReward,
+  useCreateRewardModel: () => useApiCreateRewardModel,
+  useDataTracking: () => useDataTracking,
+  useDeleteRewardModel: () => useApiDeleteRewardModel,
+  useGenerateFansipanCertificate: () => useGenerateFansipanCertificate,
+  useGenerateTemplateCertificate: () => useGenerateTemplateCertificate,
+  useGenerateThaocamvienCertificate: () => useGenerateThaocamvienCertificate,
+  useGetRewardModel: () => useApiGetRewardModel,
+  useGetUserRewards: () => useGetUserRewards,
+  useInfiniteMemories: () => useInfiniteMemories,
+  useListRewardModels: () => useApiListRewardModels,
+  useLocationDetail: () => useOneLocation,
+  useLocationProgress: () => useUserCampaignsCompletedLocation,
+  useLocationsList: () => useManyLocations,
+  useManyAchievementProgress: () => useManyAchievementProgress,
+  useManyAchievements: () => useManyAchievements,
+  useManyAchievementsRewardModels: () => useManyAchievementsRewardModels,
+  useManyChildrenAchievements: () => useManyChildrenAchievements,
+  useManyMemory: () => useManyMemory,
+  useManyUserActionLocations: () => useManyUserActionLocations,
+  useManyUserRewards: () => useManyUserRewards,
+  useMyProfile: () => useMyProfile,
+  useOneAchievement: () => useOneAchievement,
+  useOneMemory: () => useOneMemory,
+  useOneUserCampaign: () => useOneUserCampaign,
+  usePGLCoreService: () => usePGLCoreService,
+  useScanChip: () => useScanChip,
+  useSendEmail: () => useSendEmail,
+  useSyncCheckin: () => useSyncCheckin,
+  useUpdateMyProfile: () => useUpdateMyProfile,
+  useUpdateRewardModel: () => useApiUpdateRewardModel,
+  useUploadMedia: () => useUploadMedia,
+  useUserAchievementAction: () => useUserAchievementAction,
+  useUserCampaignAction: () => useUserCampaignAction,
+  useV1ListRewards: () => useV1ListRewards,
+  userInfoKey: () => userInfoKey
+});
+
+// src/modules/achievement/hooks/index.ts
+import { useManyAchievementProgress as useManyAchievementProgressCore } from "@phygitallabs/achievement";
+import { useManyAchievementProgressByDevice as useManyAchievementProgressByDeviceCore } from "@phygitallabs/api-core";
+import {
+  useAchievementProgress,
+  useManyAchievements,
+  useUserAchievementAction,
+  useManyChildrenAchievements,
+  useOneAchievement,
+  useManyAchievementsRewardModels
+} from "@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 useManyAchievementProgressCore(
+      queryParams,
+      {
+        ...options,
+        select: (data) => data.map((item) => ({
+          ...item,
+          isCompleted: isAchievementCompleted(item)
+        }))
+      }
+    );
+  }
+  return useManyAchievementProgressByDeviceCore(
+    queryParams,
+    {
+      ...options,
+      select: (data) => {
+        const camelCaseData = convertSnakeToCamel(data);
+        return camelCaseData.map((item) => ({
+          ...item,
+          isCompleted: isAchievementCompleted(item)
+        }));
+      }
+    }
+  );
+};
+
+// src/modules/achievement/types/index.ts
+import {
+  AchievementRuleActionType,
+  AchievementServiceProvider
+} from "@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
+import {
+  useManyUserRewards,
+  useGetUserRewards,
+  useClaimUserReward,
+  useApiListRewardModels,
+  useApiGetRewardModel,
+  useApiCreateRewardModel,
+  useApiUpdateRewardModel,
+  useApiDeleteRewardModel,
+  useCreateModelGroupReward,
+  useClearUserRewardCache,
+  useV1ListRewards
+} from "@phygitallabs/reward/src/hooks";
+
+// src/modules/reward/types/enums.ts
+import {
+  CmentityRewardType
+} from "@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, notification_api_star);
+import * as notification_api_star from "@phygitallabs/notification-api";
+
+// src/modules/notification/providers/index.tsx
+import { NotificationProvider as NotificationProviderApi } from "@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
+import { jsx } from "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__ */ jsx(
+    NotificationProviderApi,
+    {
+      userUid: user.id,
+      accessToken: user.accessToken,
+      webSocketUrl,
+      autoConnect,
+      onWebSocketOpen,
+      onWebSocketClose,
+      onWebSocketMessage,
+      children
+    }
+  );
+};
+
+// src/index.ts
+__reExport(index_exports, notification_exports);
+
+// src/modules/memory/hooks/index.ts
+import { useOneMemory, useManyMemory, useInfiniteMemories, useCreateMemory, useUploadMedia, resetMemoriesQuery, memoriesKey } from "@phygitallabs/api-core";
+
+// src/modules/auth/providers/AuthProvider.tsx
+import { createContext, useEffect, useContext } from "react";
+
+// src/store/hooks.ts
+import { useDispatch, useSelector } from "react-redux";
+var useAppDispatch = () => useDispatch();
+var useAppSelector = useSelector;
+
+// src/modules/auth/store/authSlice.ts
+import { createSlice } from "@reduxjs/toolkit";
+
+// src/modules/auth/helpers/index.ts
+init_constants();
+import { v4 as uuidv4 } from "uuid";
+
+// src/modules/auth/helpers/refreshToken.ts
+import mem from "mem";
+var REFRESH_TOKEN_CONFIG = {
+  maxAge: 1e4
+  // 10 seconds cache
+};
+var createRefreshTokenFunction = (config) => {
+  const refreshTokenFn = async () => {
+    try {
+      const session = getUserInfo();
+      const refreshToken = getRefreshToken();
+      if (!refreshToken) {
+        removeUserInfo();
+        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 data = await response.json();
+      if (data.error) {
+        removeUserInfo();
+        return;
+      }
+      const newSession = {
+        ...session,
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token
+      };
+      setUserInfo(newSession);
+      return newSession;
+    } catch {
+      removeUserInfo();
+    }
+  };
+  return mem(refreshTokenFn, { maxAge: REFRESH_TOKEN_CONFIG.maxAge });
+};
+
+// src/modules/auth/helpers/index.ts
+var generateDeviceId = async () => {
+  try {
+    const deviceFingerprint = await generateDeviceFingerprint();
+    return deviceFingerprint;
+  } catch (error) {
+    console.error("Error generating device fingerprint:", error);
+    return uuidv4();
+  }
+};
+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/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";
+
+// src/modules/user-profile/types/index.ts
+import { UserSourceType } from "@phygitallabs/api-core";
+
+// src/modules/scan-chip/hooks/index.tsx
+import { useEffect as useEffect2 } from "react";
+import { useChipScanStory } from "@phygitallabs/api-core";
+import { usePGLCoreService } from "@phygitallabs/api-core";
+function useScanChip({ token, id, onScanChipError }) {
+  const { updateHeaders } = usePGLCoreService();
+  useEffect2(() => {
+    if (!!token) {
+      const header = {
+        "Chip-Authorization": token
+      };
+      setChipAuthToken(token);
+      updateHeaders(header);
+    }
+  }, [token, updateHeaders]);
+  const { data, isLoading, isError, isSuccess } = useChipScanStory({
+    token,
+    id
+  });
+  useEffect2(() => {
+    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
+import {
+  useOneCampaign,
+  useUserCampaignAction,
+  useOneUserCampaign
+} from "@phygitallabs/api-core";
+
+// src/modules/campaign/types/enums.ts
+import {
+  CampaignState
+} from "@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
+import {
+  useManyLocations,
+  useOneLocation,
+  useUserCampaignsCompletedLocation,
+  useManyUserActionLocations,
+  locationQueryKeys
+} from "@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
+import {
+  useGenerateThaocamvienCertificate,
+  useGenerateTemplateCertificate,
+  useGenerateFansipanCertificate
+} from "@phygitallabs/generate-certificate";
+
+// src/modules/data-tracking/hooks/index.ts
+import posthog from "posthog-js";
+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) => {
+  posthog.capture(eventName, eventData);
+};
+function useDataTracking() {
+  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 posthog == "function") {
+      pushEventToPosthog(eventName, eventData);
+    }
+  };
+  return {
+    trackEvent
+  };
+}
+
+// src/providers/TapquestCoreProvider.tsx
+import { useState as useState2, useEffect as useEffect4 } from "react";
+import { Provider } from "react-redux";
+import { PersistGate } from "redux-persist/integration/react";
+
+// src/providers/ServicesProvider.tsx
+import { useEffect as useEffect3, useState, useMemo } 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";
+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(() => {
+    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);
+          }
+        };
+        const requestInterceptors = {
+          onFulfilled: (config2) => {
+            const currentToken = getAccessToken();
+            if (currentToken && !config2.headers.Authorization) {
+              config2.headers.Authorization = `Bearer ${currentToken}`;
+            }
+            return 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__ */ jsx3(Fragment, {});
+  }
+  return /* @__PURE__ */ jsx3(
+    PGLCoreServiceProvider,
+    {
+      ...commonServiceConfig,
+      baseURL: `${service_default[environment].API_BASE_URL}/${version}`,
+      baseCoreURL: `${service_default[environment].API_BASE_CORE_URL}/${version}`,
+      children: /* @__PURE__ */ jsx3(
+        RewardServiceProvider,
+        {
+          ...commonServiceConfig,
+          baseURL: `${service_default[environment].API_REWARD_URL}/v1`,
+          children: /* @__PURE__ */ jsx3(
+            AchievementServiceProvider2,
+            {
+              ...commonServiceConfig,
+              baseURL: `${service_default[environment].API_ACHIEVEMENT_URL}/${version}`,
+              children: /* @__PURE__ */ jsx3(
+                GenerateCertificateServiceProvider,
+                {
+                  ...commonServiceConfig,
+                  baseURL: `${service_default[environment].API_GENERATE_CERTIFICATE_URL}/v1`,
+                  children
+                }
+              )
+            }
+          )
+        }
+      )
+    }
+  );
+};
+
+// 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";
+var TapquestCoreProvider = ({
+  children,
+  queryClient,
+  apiConfig,
+  firebaseConfig,
+  authCallbacks
+}) => {
+  const [internalAuthService, setInternalAuthService] = useState2(null);
+  useEffect4(() => {
+    if (firebaseConfig && typeof window !== "undefined") {
+      Promise.resolve().then(() => (init_services(), services_exports)).then(({ createAuthService: createAuthService2 }) => {
+        try {
+          const authService = createAuthService2({ firebaseConfig });
+          setInternalAuthService(authService);
+        } catch (error) {
+          console.warn("Failed to create auth service from firebase config:", error);
+          setInternalAuthService(null);
+        }
+      }).catch((error) => {
+        console.warn("Failed to dynamically import auth services:", error);
+        setInternalAuthService(null);
+      });
+    } else {
+      setInternalAuthService(null);
+    }
+  }, [firebaseConfig]);
+  return /* @__PURE__ */ jsx4(Provider, { store, children: /* @__PURE__ */ jsx4(PersistGate, { loading: null, persistor, children: /* @__PURE__ */ jsx4(
+    AuthProvider,
+    {
+      authService: internalAuthService,
+      authCallbacks,
+      children: /* @__PURE__ */ jsx4(
+        ServicesProvider,
+        {
+          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 useEffect5, useMemo as useMemo2 } from "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 } = useManyAchievements2(
+    {
+      "filter.labels": { campaign_id: campaignId },
+      "filter.type": "group_mission",
+      "pagination.limit": 200
+    },
+    { enabled: !!campaignId }
+  );
+  const groupRewardIds = useMemo2(() => {
+    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
+  } = useCreateModelGroupReward2();
+  useEffect5(() => {
+    if (groupRewardIds.length > 0) {
+      fetchGroupRewardModels({ group_reward_ids: groupRewardIds });
+    }
+  }, [groupRewardIds, fetchGroupRewardModels]);
+  const mappedAchievements = useMemo2(() => {
+    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
+import { useSendEmail } from "@phygitallabs/api-core";
+
+// src/helper/helpers.ts
+import { cn, parse, fileToBase64 } from "@phygitallabs/helpers";
+export {
+  AchievementRuleActionType,
+  AchievementServiceProvider,
+  AchievementType,
+  AuthProvider,
+  CampaignState,
+  CmentityRewardType,
+  NotificationProvider,
+  RewardClaimStatus,
+  TapquestCoreProvider,
+  TaskType,
+  UserSourceType,
+  accessTokenKey,
+  checkDeviceUid,
+  chipAuthTokenKey,
+  cn,
+  convertSnakeToCamel,
+  createRefreshTokenFunction,
+  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,
+  achivementPlusRewardModel_default as useAchivementPlusRewardModel,
+  useAuth,
+  useOneCampaign as useCampaignDetail,
+  useCancelUserRewardsRequest,
+  useChipScanStory,
+  useClaimUserReward,
+  useClearUserRewardCache,
+  useCreateMemory,
+  useCreateModelGroupReward,
+  useApiCreateRewardModel as useCreateRewardModel,
+  useDataTracking,
+  useApiDeleteRewardModel as useDeleteRewardModel,
+  useGenerateFansipanCertificate,
+  useGenerateTemplateCertificate,
+  useGenerateThaocamvienCertificate,
+  useApiGetRewardModel as useGetRewardModel,
+  useGetUserRewards,
+  useInfiniteMemories,
+  useApiListRewardModels as useListRewardModels,
+  useOneLocation as useLocationDetail,
+  useUserCampaignsCompletedLocation as useLocationProgress,
+  useManyLocations as useLocationsList,
+  useManyAchievementProgress,
+  useManyAchievements,
+  useManyAchievementsRewardModels,
+  useManyChildrenAchievements,
+  useManyMemory,
+  useManyUserActionLocations,
+  useManyUserRewards,
+  useMyProfile,
+  useOneAchievement,
+  useOneMemory,
+  useOneUserCampaign,
+  usePGLCoreService,
+  useScanChip,
+  useSendEmail,
+  useSyncCheckin,
+  useUpdateMyProfile,
+  useApiUpdateRewardModel as useUpdateRewardModel,
+  useUploadMedia,
+  useUserAchievementAction,
+  useUserCampaignAction,
+  useV1ListRewards,
+  userInfoKey
+};
+//# sourceMappingURL=index.js.map