@phygitallabs/tapquest-core 2.8.0 → 2.9.1

package/dist/index.cjs

@@ -1,1531 +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 __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 __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);
-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: () => import_achievement3.AchievementRuleActionType,
-  AchievementServiceProvider: () => import_achievement3.AchievementServiceProvider,
-  AchievementType: () => AchievementType,
-  AuthProvider: () => AuthProvider,
-  CampaignState: () => import_api_core8.CampaignState,
-  CmentityRewardType: () => import_reward.CmentityRewardType,
-  NotificationProvider: () => NotificationProvider,
-  RewardClaimStatus: () => RewardClaimStatus,
-  TapquestCoreProvider: () => TapquestCoreProvider,
-  TaskType: () => TaskType,
-  UserSourceType: () => import_api_core4.UserSourceType,
-  accessTokenKey: () => accessTokenKey,
-  checkDeviceUid: () => checkDeviceUid,
-  chipAuthTokenKey: () => chipAuthTokenKey,
-  cn: () => import_helpers5.cn,
-  convertSnakeToCamel: () => convertSnakeToCamel,
-  createRefreshTokenFunction: () => createRefreshTokenFunction,
-  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_core9.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_core7.useOneCampaign,
-  useCancelUserRewardsRequest: () => import_api_core3.useCancelUserRewardsRequest,
-  useChipScanStory: () => import_api_core5.useChipScanStory,
-  useClaimUserReward: () => import_hooks.useClaimUserReward,
-  useClearUserRewardCache: () => import_hooks.useClearUserRewardCache,
-  useCreateMemory: () => import_api_core2.useCreateMemory,
-  useCreateModelGroupReward: () => import_hooks.useCreateModelGroupReward,
-  useCreateRewardModel: () => import_hooks.useApiCreateRewardModel,
-  useDataTracking: () => useDataTracking,
-  useDeleteRewardModel: () => import_hooks.useApiDeleteRewardModel,
-  useGenerateFansipanCertificate: () => import_generate_certificate.useGenerateFansipanCertificate,
-  useGenerateTemplateCertificate: () => import_generate_certificate.useGenerateTemplateCertificate,
-  useGenerateThaocamvienCertificate: () => import_generate_certificate.useGenerateThaocamvienCertificate,
-  useGetRewardModel: () => import_hooks.useApiGetRewardModel,
-  useGetUserRewards: () => import_hooks.useGetUserRewards,
-  useInfiniteMemories: () => import_api_core2.useInfiniteMemories,
-  useListRewardModels: () => import_hooks.useApiListRewardModels,
-  useLocationDetail: () => import_api_core9.useOneLocation,
-  useLocationProgress: () => import_api_core9.useUserCampaignsCompletedLocation,
-  useLocationsList: () => import_api_core9.useManyLocations,
-  useManyAchievementProgress: () => useManyAchievementProgress,
-  useManyAchievements: () => import_achievement2.useManyAchievements,
-  useManyAchievementsRewardModels: () => import_achievement2.useManyAchievementsRewardModels,
-  useManyChildrenAchievements: () => import_achievement2.useManyChildrenAchievements,
-  useManyMemory: () => import_api_core2.useManyMemory,
-  useManyUserActionLocations: () => import_api_core9.useManyUserActionLocations,
-  useManyUserRewards: () => import_hooks.useManyUserRewards,
-  useMyProfile: () => import_api_core3.useMyProfile,
-  useOneAchievement: () => import_achievement2.useOneAchievement,
-  useOneMemory: () => import_api_core2.useOneMemory,
-  useOneUserCampaign: () => import_api_core7.useOneUserCampaign,
-  usePGLCoreService: () => import_api_core6.usePGLCoreService,
-  useScanChip: () => useScanChip,
-  useSendEmail: () => import_api_core11.useSendEmail,
-  useSyncCheckin: () => import_api_core3.useSyncCheckin,
-  useUpdateMyProfile: () => import_api_core3.useUpdateMyProfile,
-  useUpdateRewardModel: () => import_hooks.useApiUpdateRewardModel,
-  useUploadMedia: () => import_api_core2.useUploadMedia,
-  useUserAchievementAction: () => import_achievement2.useUserAchievementAction,
-  useUserCampaignAction: () => import_api_core7.useUserCampaignAction,
-  useV1ListRewards: () => import_hooks.useV1ListRewards,
-  userInfoKey: () => userInfoKey
-});
-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_hooks = require("@phygitallabs/reward/src/hooks");
-
-// src/modules/reward/types/enums.ts
-var import_reward = 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,
-      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_react = require("react");
-
-// src/store/hooks.ts
-var import_react_redux = require("react-redux");
-var useAppDispatch = () => (0, import_react_redux.useDispatch)();
-var useAppSelector = import_react_redux.useSelector;
-
-// src/modules/auth/store/authSlice.ts
-var import_toolkit = require("@reduxjs/toolkit");
-
-// src/modules/auth/helpers/index.ts
-init_constants();
-var import_uuid = require("uuid");
-
-// src/modules/auth/helpers/refreshToken.ts
-var import_mem = __toESM(require("mem"), 1);
-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 (0, import_mem.default)(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 (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/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 = (0, import_toolkit.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
-var import_jsx_runtime2 = require("react/jsx-runtime");
-var AuthContext = (0, import_react.createContext)(null);
-function AuthProvider({ children, authService, authCallbacks }) {
-  const dispatch = useAppDispatch();
-  (0, import_react.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__ */ (0, import_jsx_runtime2.jsx)(AuthContext.Provider, { value: contextValue, children });
-}
-var useAuth = () => {
-  const authContext = (0, import_react.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
-var import_api_core3 = require("@phygitallabs/api-core");
-
-// src/modules/user-profile/types/index.ts
-var import_api_core4 = require("@phygitallabs/api-core");
-
-// src/modules/scan-chip/hooks/index.tsx
-var import_react2 = require("react");
-var import_api_core5 = require("@phygitallabs/api-core");
-var import_api_core6 = require("@phygitallabs/api-core");
-function useScanChip({ token, id, onScanChipError }) {
-  const { updateHeaders } = (0, import_api_core6.usePGLCoreService)();
-  (0, import_react2.useEffect)(() => {
-    if (!!token) {
-      const header = {
-        "Chip-Authorization": token
-      };
-      setChipAuthToken(token);
-      updateHeaders(header);
-    }
-  }, [token, updateHeaders]);
-  const { data, isLoading, isError, isSuccess } = (0, import_api_core5.useChipScanStory)({
-    token,
-    id
-  });
-  (0, import_react2.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_core7 = require("@phygitallabs/api-core");
-
-// src/modules/campaign/types/enums.ts
-var import_api_core8 = 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_core9 = 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_certificate = require("@phygitallabs/generate-certificate");
-
-// src/modules/data-tracking/hooks/index.ts
-var import_posthog_js = __toESM(require("posthog-js"), 1);
-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 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);
-    }
-  };
-  return {
-    trackEvent
-  };
-}
-
-// src/providers/TapquestCoreProvider.tsx
-var import_react4 = require("react");
-var import_react_redux2 = require("react-redux");
-var import_react5 = require("redux-persist/integration/react");
-
-// src/providers/ServicesProvider.tsx
-var import_react3 = require("react");
-var import_api_core10 = require("@phygitallabs/api-core");
-var import_reward2 = require("@phygitallabs/reward");
-var import_achievement4 = require("@phygitallabs/achievement");
-var import_generate_certificate2 = require("@phygitallabs/generate-certificate");
-var import_axios = __toESM(require("axios"), 1);
-var import_jsx_runtime3 = require("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] = (0, import_react3.useState)(null);
-  const memoizedRefreshToken = (0, import_react3.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]);
-  (0, import_react3.useEffect)(() => {
-    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 (0, import_axios.default)(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__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, {});
-  }
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
-    import_api_core10.PGLCoreServiceProvider,
-    {
-      ...commonServiceConfig,
-      baseURL: `${service_default[environment].API_BASE_URL}/${version}`,
-      baseCoreURL: `${service_default[environment].API_BASE_CORE_URL}/${version}`,
-      children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
-        import_reward2.RewardServiceProvider,
-        {
-          ...commonServiceConfig,
-          baseURL: `${service_default[environment].API_REWARD_URL}/v1`,
-          children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
-            import_achievement4.AchievementServiceProvider,
-            {
-              ...commonServiceConfig,
-              baseURL: `${service_default[environment].API_ACHIEVEMENT_URL}/${version}`,
-              children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
-                import_generate_certificate2.GenerateCertificateServiceProvider,
-                {
-                  ...commonServiceConfig,
-                  baseURL: `${service_default[environment].API_GENERATE_CERTIFICATE_URL}/v1`,
-                  children
-                }
-              )
-            }
-          )
-        }
-      )
-    }
-  );
-};
-
-// src/store/index.ts
-var import_toolkit2 = require("@reduxjs/toolkit");
-var import_storage = __toESM(require("redux-persist/lib/storage"), 1);
-var import_redux_persist = require("redux-persist");
-var authPersistConfig = {
-  key: "tapquest-auth",
-  storage: import_storage.default,
-  whitelist: ["user", "isSignedIn"]
-  // Only persist user and sign-in status
-};
-var persistedAuthReducer = (0, import_redux_persist.persistReducer)(authPersistConfig, authSlice.reducer);
-var store = (0, import_toolkit2.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 = (0, import_redux_persist.persistStore)(store);
-
-// src/providers/TapquestCoreProvider.tsx
-var import_jsx_runtime4 = require("react/jsx-runtime");
-var TapquestCoreProvider = ({
-  children,
-  queryClient,
-  apiConfig,
-  firebaseConfig,
-  authCallbacks
-}) => {
-  const [internalAuthService, setInternalAuthService] = (0, import_react4.useState)(null);
-  (0, import_react4.useEffect)(() => {
-    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__ */ (0, import_jsx_runtime4.jsx)(import_react_redux2.Provider, { store, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react5.PersistGate, { loading: null, persistor, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-    AuthProvider,
-    {
-      authService: internalAuthService,
-      authCallbacks,
-      children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-        ServicesProvider,
-        {
-          queryClient,
-          apiConfig,
-          firebaseConfig,
-          children
-        }
-      )
-    }
-  ) }) });
-};
-
-// src/modules/achivementWithReward/hooks/achivementPlusRewardModel.ts
-var import_achievement5 = require("@phygitallabs/achievement");
-var import_useGroupReward = require("@phygitallabs/reward/src/hooks/useGroupReward");
-var import_react6 = 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_achievement5.useManyAchievements)(
-    {
-      "filter.labels": { campaign_id: campaignId },
-      "filter.type": "group_mission",
-      "pagination.limit": 200
-    },
-    { enabled: !!campaignId }
-  );
-  const groupRewardIds = (0, import_react6.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_react6.useEffect)(() => {
-    if (groupRewardIds.length > 0) {
-      fetchGroupRewardModels({ group_reward_ids: groupRewardIds });
-    }
-  }, [groupRewardIds, fetchGroupRewardModels]);
-  const mappedAchievements = (0, import_react6.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_core11 = 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 = {
-  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,
-  useAchivementPlusRewardModel,
-  useAuth,
-  useCampaignDetail,
-  useCancelUserRewardsRequest,
-  useChipScanStory,
-  useClaimUserReward,
-  useClearUserRewardCache,
-  useCreateMemory,
-  useCreateModelGroupReward,
-  useCreateRewardModel,
-  useDataTracking,
-  useDeleteRewardModel,
-  useGenerateFansipanCertificate,
-  useGenerateTemplateCertificate,
-  useGenerateThaocamvienCertificate,
-  useGetRewardModel,
-  useGetUserRewards,
-  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
-});
-//# sourceMappingURL=index.cjs.map