@jolibox/implement 1.1.53-beta.0 → 1.1.54

package/src/common/rewards/registers/utils/coins/commands/use-payment.ts

@@ -1,7 +1,9 @@
-import { IJoliCoin, IGem } from '@/common/rewards/type';
+import { IJoliCoin } from '@/common/rewards/type';
+import { fetchBalance } from '../fetch-balance';
 import { rewardsCommands } from '../rewards-command';
 import { IHttpClient } from '@/common/http';
 import { unlockOptionsHandler } from '../../common';
+import { joliCoinIsEnough } from '../../index';
 import { rewardsEmitter } from '@/common/rewards/reward-emitter';
 import { createEventPromiseHandler } from '../../event-listener';
 import {
@@ -9,43 +11,39 @@ import {
   PaymentResultEventName,
   InvokePaymentEventName
 } from '@/common/rewards/reward-emitter';
-import { CURRENCY_HANDLERS, CurrencyType } from './currency-handlers';
 
-export const registerUsePaymentCommand = <T extends IJoliCoin | IGem>(
-  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
-  currency: 'JOLI_COIN' | 'JOLI_GEM',
+export const registerUsePaymentCommand = (
+  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN',
   params: {
     httpClient: IHttpClient;
     initiateAndAwaitPayment: (params: {
-      userCurrency: T;
-      currencyQuantity: number;
-      currency: T extends IJoliCoin ? 'JOLI_COIN' : 'JOLI_GEM';
+      userJoliCoin: IJoliCoin;
+      joliCoinQuantity: number;
     }) => Promise<'SUCCESS' | 'FAILED' | 'CANCEL'>;
   }
 ) => {
   const { httpClient, initiateAndAwaitPayment } = params;
   rewardsCommands.registerCommand(`Rewards.${prefix}.usePayment`, async () => {
     const unlockOptions = await unlockOptionsHandler.getData();
+    const newBalance = await fetchBalance(httpClient);
+    const joliCoinQuantity =
+      unlockOptions?.options?.find((option) => option.type === 'JOLI_COIN')?.joliCoinChoices[0]
+        .joliCoinQuantity ?? 0;
 
-    // Use currency handler for balance and quantity calculation
-    const handler = CURRENCY_HANDLERS[currency as CurrencyType];
-    const newBalance = await handler.fetchBalance(httpClient);
-    const currencyQuantity = handler.getQuantity(unlockOptions);
-    const currentUser = handler.getCurrentUser(unlockOptions);
-
-    const newUser = handler.createUpdatedUser(newBalance?.balance ?? 0, currentUser.enableAutoDeduct);
+    const newJoliCoin = {
+      balance: newBalance?.balance ?? 0,
+      enableAutoDeduct: unlockOptions?.userJoliCoin?.enableAutoDeduct ?? false
+    };
 
-    const updateKey = handler.getUpdateKey();
     unlockOptionsHandler.updateData({
-      [updateKey]: newUser
+      userJoliCoin: newJoliCoin
     });
 
-    console.log('-----unlockOptions payment-----', unlockOptions, newUser, currencyQuantity);
-    if (!handler.isEnough(unlockOptions, newUser)) {
+    console.log('-----unlockOptions payment-----', unlockOptions, newJoliCoin, joliCoinQuantity);
+    if (!joliCoinIsEnough(unlockOptions?.options || [], newJoliCoin)) {
       const paymentResult = await initiateAndAwaitPayment({
-        userCurrency: newUser as T,
-        currencyQuantity,
-        currency: currency as T extends IJoliCoin ? 'JOLI_COIN' : 'JOLI_GEM'
+        userJoliCoin: newJoliCoin,
+        joliCoinQuantity
       });
 
       return {
@@ -60,27 +58,22 @@ export const registerUsePaymentCommand = <T extends IJoliCoin | IGem>(
 
 // events
 export const createInitiateAndAwaitPayment = (
-  type: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
   buttons: {
     confirmButtonText: string;
     cancelButtonText: string;
   }
 ) => {
-  return async <T extends IJoliCoin | IGem>(params: {
-    userCurrency: T;
-    currencyQuantity: number;
-    currency: T extends IJoliCoin ? 'JOLI_COIN' : 'JOLI_GEM';
-  }) => {
+  return async (params: { userJoliCoin: IJoliCoin; joliCoinQuantity: number }) => {
     const paymentHandler = createEventPromiseHandler<IPaymentEvent, typeof PaymentResultEventName>(
       rewardsEmitter,
       PaymentResultEventName
     );
 
     rewardsEmitter.emit(InvokePaymentEventName, type, {
-      userCurrency: params.userCurrency as T,
-      quantity: params.currencyQuantity,
-      currency: params.currency,
-      enableAutoDeduct: params.userCurrency.enableAutoDeduct,
+      userJoliCoin: params.userJoliCoin,
+      joliCoinQuantity: params.joliCoinQuantity,
+      enableAutoDeduct: params.userJoliCoin.enableAutoDeduct,
       confirmButtonText: buttons.confirmButtonText,
       cancelButtonText: buttons.cancelButtonText
     });

package/src/common/rewards/registers/utils/coins/commands/use-unlogin.ts

@@ -3,21 +3,23 @@ import { rewardsCommands } from '../rewards-command';
 import { createEventPromiseHandler } from '../../event-listener';
 import { IUseUnloginModalResultEvent, UseUnloginModalResultEventName } from '@/common/rewards/reward-emitter';
 import { rewardsEmitter, InvokeUnloginModalEventName } from '@/common/rewards/reward-emitter';
+import { createToast } from '@jolibox/ui';
 import { sleep } from '@jolibox/common';
+import { fetchBalance } from '../fetch-balance';
 import { IHttpClient } from '@/common/http';
 import { unlockOptionsHandler } from '../../common';
-import { CURRENCY_HANDLERS, CurrencyType } from './currency-handlers';
 
 export const registerUseUnloginCommand = (
-  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
-  currency: 'JOLI_COIN' | 'JOLI_GEM',
+  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN',
   params: {
     httpClient: IHttpClient;
-    showUnloginModal: (currency: 'JOLI_COIN' | 'JOLI_GEM') => Promise<{
+    showUnloginModal: () => Promise<{
       result: 'CANCEL' | 'FAILED' | 'SUCCESS' | 'ADS' | 'NOT_SUPPORT';
       rewards?: {
-        isFirstLogin: boolean;
-        claimedRewardValue: number;
+        jolicoin?: {
+          isFirstLogin: boolean;
+          claimedRewardValue: number;
+        };
       };
     }>;
   }
@@ -28,7 +30,7 @@ export const registerUseUnloginCommand = (
     const unlockOptions = await unlockOptionsHandler.getData();
     console.log('-----isLogin-----', !!isLogin);
     if (!isLogin) {
-      const unloginModalResult = await showUnloginModal(currency);
+      const unloginModalResult = await showUnloginModal();
 
       console.log('-----unloginModalResult-----', unloginModalResult);
       if (unloginModalResult.result == 'FAILED' || unloginModalResult.result == 'CANCEL') {
@@ -37,26 +39,27 @@ export const registerUseUnloginCommand = (
         };
       }
 
-      const { isFirstLogin, claimedRewardValue } = unloginModalResult.rewards ?? {};
+      const { isFirstLogin, claimedRewardValue } = unloginModalResult.rewards?.jolicoin ?? {};
       if (unloginModalResult.result == 'SUCCESS') {
         if (isFirstLogin && claimedRewardValue) {
           await sleep(3000); // wait for center toast to show
         }
 
-        //check balance using currency handler
-        const handler = CURRENCY_HANDLERS[currency as CurrencyType];
-        const newBalance = await handler.fetchBalance(httpClient);
-        const currencyQuantity = handler.getQuantity(unlockOptions);
-        const currentUser = handler.getCurrentUser(unlockOptions);
+        //check balance
+        const newBalance = await fetchBalance(httpClient);
+        const joliCoinQuantity =
+          unlockOptions?.options?.find((option) => option.type === 'JOLI_COIN')?.joliCoinChoices[0]
+            .joliCoinQuantity ?? 0;
 
-        const newUser = handler.createUpdatedUser(newBalance?.balance ?? 0, currentUser.enableAutoDeduct);
+        const newJoliCoin = {
+          balance: newBalance?.balance ?? 0,
+          enableAutoDeduct: unlockOptions?.userJoliCoin?.enableAutoDeduct ?? false
+        };
 
-        const updateKey = handler.getUpdateKey();
         unlockOptionsHandler.updateData({
-          [updateKey]: newUser
+          userJoliCoin: newJoliCoin
         });
-
-        if (newUser.balance >= currencyQuantity) {
+        if (newJoliCoin.balance >= joliCoinQuantity) {
           return {
             result: 'SUCCESS'
           };
@@ -72,21 +75,20 @@ export const registerUseUnloginCommand = (
 //EVENTS
 
 export const createShowUnloginModal = (
-  type: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
   buttons: {
     confirmButtonText: string;
     cancelButtonText: string;
   }
 ) => {
-  return async (currency: 'JOLI_COIN' | 'JOLI_GEM') => {
+  return async () => {
     const modalHandler = createEventPromiseHandler<
       IUseUnloginModalResultEvent,
       typeof UseUnloginModalResultEventName
     >(rewardsEmitter, UseUnloginModalResultEventName);
     rewardsEmitter.emit(InvokeUnloginModalEventName, type, {
       confirmButtonText: buttons.confirmButtonText,
-      cancelButtonText: buttons.cancelButtonText,
-      currency
+      cancelButtonText: buttons.cancelButtonText
     });
     const modalResult = await modalHandler.getFreshData();
     return modalResult;

package/src/common/rewards/registers/utils/coins/index.ts

@@ -1,2 +1,139 @@
-export { createCommonJolicoinRewardHandler } from './jolicoin/jolicoin-handler';
-export { createCommonGemRewardHandler } from './joligem/gem-handler';
+import { IHttpClient } from '@/common/http';
+import { context } from '@/common/context';
+import { uuidv4 } from '@jolibox/common';
+import { UnlockOptionsEventName, IUnlockOptionsEvent } from '@/common/rewards/reward-emitter';
+import { IAdBreakParams } from '@/common/ads';
+import { EventPromiseHandler } from '../event-listener';
+
+import {
+  createInitiateAndAwaitPayment,
+  registerUseJolicoinCommand,
+  registerUsePaymentCommand,
+  registerUseUnloginCommand,
+  createShowUnlockWithJolicoinModal,
+  createShowUnloginModal
+} from './commands';
+import { rewardsCommands } from './rewards-command';
+import { RewardsCommandType } from '@jolibox/types';
+
+interface IJolicoinUnlockRes {
+  code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
+  message: string;
+  data: {
+    transactionId: string;
+    quantity: number;
+    balance: number;
+  };
+}
+
+export const createCommonJolicoinRewardHandler = (
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  httpClient: IHttpClient,
+  {
+    handlers: {
+      handleUnlockSuccess,
+      handleUnlockFailed,
+      unlockOptionsHandler,
+      initiateAndAwaitPayment,
+      showUnlockWithJolicoinModal,
+      showUnloginModal
+    }
+  }: {
+    handlers: {
+      handleUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
+      handleUnlockFailed?: (params: IAdBreakParams) => void;
+      unlockOptionsHandler: EventPromiseHandler<IUnlockOptionsEvent, typeof UnlockOptionsEventName>;
+      initiateAndAwaitPayment: ReturnType<typeof createInitiateAndAwaitPayment>;
+      showUnlockWithJolicoinModal: ReturnType<typeof createShowUnlockWithJolicoinModal>;
+      showUnloginModal: ReturnType<typeof createShowUnloginModal>;
+    };
+  }
+) => {
+  // register commands
+  registerUseUnloginCommand(type, {
+    httpClient: httpClient,
+    showUnloginModal: showUnloginModal
+  });
+  registerUsePaymentCommand(type, {
+    httpClient: httpClient,
+    initiateAndAwaitPayment: initiateAndAwaitPayment
+  });
+  registerUseJolicoinCommand(type, {
+    showUnlockWithJolicoinModal: showUnlockWithJolicoinModal
+  });
+
+  const targetABTest = context.abTests.find((abTest) => abTest.startsWith('coinOpt_v1'));
+  let commands = [];
+  if (targetABTest) {
+    commands = [`Rewards.${type}.usePayment`, `Rewards.${type}.useJolicoin`];
+  } else {
+    commands = [
+      `Rewards.${type}.useUnloginModal`,
+      `Rewards.${type}.usePayment`,
+      `Rewards.${type}.useJolicoin`
+    ];
+  }
+  return async (params: IAdBreakParams) => {
+    try {
+      let result = true;
+      for (const command of commands) {
+        const commandResult = await rewardsCommands.executeCommand(command as RewardsCommandType);
+        result = result && commandResult.result !== 'FAILED';
+        if (commandResult.result !== 'CONTINUE') {
+          break;
+        }
+      }
+
+      if (!result) {
+        handleUnlockFailed?.(params);
+        return false;
+      }
+
+      const unlockWithJolicoin = await httpClient.post<IJolicoinUnlockRes>('/api/joli-coin/unlock', {
+        data: {
+          // TODO: support drama
+          type: 'GAME_REWARD',
+          reqId: `${uuidv4()}-${context.mpType}-${Date.now()}`,
+          gameInfo: {
+            gameId: context.mpId
+          }
+        }
+      });
+
+      console.log('-----unlockWithJolicoin request result-----', unlockWithJolicoin);
+      if (unlockWithJolicoin.code == 'SUCCESS') {
+        try {
+          params.adBreakDone?.({
+            breakType: params.type,
+            breakName: 'name' in params ? params.name ?? '' : '',
+            breakFormat: 'reward',
+            breakStatus: 'viewed'
+          });
+          if ('adViewed' in params) {
+            params.adViewed?.();
+          }
+        } catch (e) {
+          console.error('-----unlockWithJolicoin adBreakDone error-----', e);
+        }
+
+        handleUnlockSuccess?.({
+          quantity: unlockWithJolicoin.data.quantity,
+          balance: unlockWithJolicoin.data.balance
+        });
+        return true;
+      }
+      handleUnlockFailed?.(params);
+      return false;
+    } catch (e) {
+      console.info(`JolicoinRewardHandler error:`, e);
+      if (e instanceof Error && e.message == 'CANCEL') {
+        // Cancel should terminate the reward handler, invoke unlock failed
+        throw e;
+      }
+      handleUnlockFailed?.(params);
+      return false;
+    } finally {
+      unlockOptionsHandler.clearCache();
+    }
+  };
+};

package/src/common/rewards/registers/utils/index.ts

@@ -1,5 +1,4 @@
-import { IJoliCoin, IGem, IUnlockOption } from '@/common/rewards/type';
-import { isNumber } from '@jolibox/common';
+import { IJoliCoin, IUnlockOption } from '@/common/rewards/type';
 
 export const canUseJolicoin = (unlockOptions: IUnlockOption[], joliCoin?: IJoliCoin) => {
   return unlockOptions.some(
@@ -18,21 +17,3 @@ export const joliCoinIsEnough = (unlockOptions: IUnlockOption[], joliCoin?: IJol
       option.joliCoinChoices.some((choice) => choice.joliCoinQuantity <= (joliCoin?.balance ?? 0))
   );
 };
-
-// Gem utility functions
-export const canUseGem = (unlockOptions: IUnlockOption[], gem?: IGem) => {
-  return unlockOptions.some((option) => {
-    if (option.type === 'JOLI_GEM' && isNumber(option.joliGemChoices?.joliGemQuantity)) {
-      return option.joliGemChoices.joliGemQuantity <= (gem?.balance ?? 0) && !!gem?.enableAutoDeduct;
-    }
-    return false;
-  });
-};
-
-export const gemIsEnough = (unlockOptions: IUnlockOption[], gem?: IGem) => {
-  const gemOptions = unlockOptions.find((option) => option.type === 'JOLI_GEM');
-  if (gemOptions) {
-    return (gemOptions.joliGemChoices?.joliGemQuantity ?? 0) <= (gem?.balance ?? 0);
-  }
-  return false;
-};

package/src/common/rewards/reward-emitter.ts

@@ -1,12 +1,12 @@
 // rewards-emitter-wrapper.ts
 
 import { EventEmitter } from '@jolibox/common';
-import { IUnlockOption, IJoliCoin, IGem } from './type';
+import { IUnlockOption } from './type';
+import { IJoliCoin } from './type';
 
 export interface IUnlockOptionsEvent {
   options: IUnlockOption[];
   userJoliCoin: IJoliCoin;
-  userGem?: IGem;
 }
 
 export const UnlockOptionsEventName = 'UNLOCK_OPTIONS_CHANGED' as const;
@@ -21,8 +21,6 @@ export const InvokeUnloginModalEventName = 'INVOKE_UNLOGIN_MODAL_EVENT' as const
 type IPaymentResult = 'SUCCESS' | 'FAILED' | 'CANCEL';
 export interface IPaymentEvent {
   userJoliCoin?: IJoliCoin;
-  userGem?: IGem;
-  currency: 'JOLI_COIN' | 'JOLI_GEM';
   paymentResult: IPaymentResult;
 }
 
@@ -34,9 +32,8 @@ export interface IPaymentChoice {
 }
 
 export interface IInvokePaymentEvent {
-  userCurrency: IJoliCoin | IGem;
-  quantity: number;
-  currency: 'JOLI_COIN' | 'JOLI_GEM';
+  userJoliCoin: IJoliCoin;
+  joliCoinQuantity: number;
   enableAutoDeduct: boolean;
   confirmButtonText: string;
   cancelButtonText: string;
@@ -45,9 +42,8 @@ export interface IInvokePaymentEvent {
 
 export interface IUseModalEvent {
   enableAutoDeduct: boolean;
-  userCurrency: IJoliCoin | IGem;
-  quantity: number;
-  currency: 'JOLI_COIN' | 'JOLI_GEM';
+  userJoliCoin: IJoliCoin;
+  joliCoinQuantity: number;
   confirmButtonText: string;
   cancelButtonText: string;
   sequenceId?: string;
@@ -56,7 +52,6 @@ export interface IUseModalEvent {
 export interface IUseUnloginModalEvent {
   confirmButtonText: string;
   cancelButtonText: string;
-  currency: 'JOLI_COIN' | 'JOLI_GEM';
 }
 
 export interface IUseModalResultEvent {
@@ -66,9 +61,10 @@ export interface IUseModalResultEvent {
 export interface IUseUnloginModalResultEvent {
   result: 'SUCCESS' | 'CANCEL' | 'ADS' | 'FAILED' | 'NOT_SUPPORT';
   rewards?: {
-    claimedRewardValue: number;
-    isFirstLogin: boolean;
-    currency?: 'JOLI_COIN' | 'JOLI_GEM';
+    jolicoin?: {
+      claimedRewardValue: number;
+      isFirstLogin: boolean;
+    };
   };
 }
 
@@ -92,18 +88,12 @@ export interface IUseModalFrequencyConfig {
 
 export interface RewardsEventMap extends Record<string, unknown[]> {
   [UnlockOptionsEventName]: [IUnlockOptionsEvent];
-  [InvokePaymentEventName]: [
-    'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
-    IInvokePaymentEvent
-  ];
+  [InvokePaymentEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN', IInvokePaymentEvent];
   [PaymentResultEventName]: [IPaymentEvent];
   [UseModalResultEventName]: [IUseModalResultEvent];
-  [UseModalEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM', IUseModalEvent];
+  [UseModalEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN', IUseModalEvent];
   [UseModalFrequencyEventName]: [IUseModalFrequencyConfig];
-  [InvokeUnloginModalEventName]: [
-    'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
-    IUseUnloginModalEvent
-  ];
+  [InvokeUnloginModalEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN', IUseUnloginModalEvent];
   [UseUnloginModalResultEventName]: [IUseUnloginModalResultEvent];
 }
 

package/src/common/rewards/reward-helper.ts

@@ -1,4 +1,4 @@
-export type RewardType = 'ADS' | 'JOLI_COIN' | 'JOLI_COIN_ONLY' | 'JOLI_GEM' | 'JOLI_GEM_ONLY';
+export type RewardType = 'ADS' | 'JOLI_COIN' | 'JOLI_COIN_ONLY';
 
 import { context } from '../context';
 import type { AdsRewardsHandler } from './registers/use-ads';
@@ -8,8 +8,6 @@ export interface RewardHandlerMap {
   ADS: AdsRewardsHandler;
   JOLI_COIN: (params?: unknown) => Promise<boolean>; // coins + ads
   JOLI_COIN_ONLY: (params?: unknown) => Promise<boolean>; // coins only
-  JOLI_GEM: (params?: unknown) => Promise<boolean>; // gem + ads
-  JOLI_GEM_ONLY: (params?: unknown) => Promise<boolean>; // gem only
 }
 
 export type RewardHandler<T extends RewardType> = RewardHandlerMap[T];

package/src/common/rewards/type.ts

@@ -3,25 +3,14 @@ export interface IJoliCoin {
   enableAutoDeduct: boolean;
 }
 
-export interface IGem {
-  balance: number;
-  enableAutoDeduct: boolean;
-}
-
-export type IUnlockOptionType = 'JOLI_COIN' | 'ADS' | 'JOLI_GEM';
+export type IUnlockOptionType = 'JOLI_COIN' | 'ADS';
 
 interface IJoliCoinChoice {
   joliCoinQuantity: number;
 }
-
-interface IGemChoice {
-  joliGemQuantity: number;
-}
-
 export interface IUnlockOption {
   type: IUnlockOptionType;
   joliCoinChoices: IJoliCoinChoice[];
-  joliGemChoices: IGemChoice | null;
 }
 
 export interface IJolicoinRewardOption {
@@ -32,6 +21,5 @@ export interface IJolicoinRewardOption {
   };
   extra: {
     joliCoin: IJoliCoin;
-    joliGem?: IGem;
   };
 }

package/src/h5/api/ads.ts

@@ -127,6 +127,11 @@ const adsContext: IAdsContext<'GAME'> = {
   }
 };
 
+const handleUnlockSuccess = (params: { quantity: number; balance: number }) => {
+  notifyCustomEvent('JOLIBOX_CUSTOM_REWARDS_EVENT', {
+    JOLI_COIN: params
+  });
+};
 
 const adsManager = new H5AdsManager(adsContext);
 const adsHandler = adsManager.getAdsHandler(context.sdkEnvironment);
@@ -135,11 +140,14 @@ rewardsHelper.registerRewardHandler('ADS', createAdsRewardHandler(adsHandler.get
 rewardsHelper.registerRewardHandler(
   'JOLI_COIN',
   createJolicoinRewardHandler(httpClient, {
-    onUnlockSuccess: (params: { quantity: number; balance: number }) => {
-      notifyCustomEvent('JOLIBOX_CUSTOM_REWARDS_EVENT', {
-        JOLI_COIN: params
-      });
-    }
+    onUnlockSuccess: handleUnlockSuccess.bind(this)
+  }) as unknown as (params?: unknown) => Promise<boolean>
+);
+
+rewardsHelper.registerRewardHandler(
+  'JOLI_COIN_ONLY',
+  createJolicoinOnlyRewardHandler(httpClient, {
+    onUnlockSuccess: handleUnlockSuccess.bind(this)
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 

package/src/h5/api/storage.ts

@@ -1,5 +1,5 @@
 import { createAPI, t, registerCanIUse } from './base';
-import { createCommands } from '@jolibox/common';
+import { createCommands, getApiHost } from '@jolibox/common';
 import { httpClientManager } from '@/h5/http';
 import { context } from '@/common/context';
 import { StorageResponse } from '@jolibox/types';
@@ -10,7 +10,7 @@ const commands = createCommands();
 export class JoliboxCloudStorage {
   private gameId: string;
   private httpClient = httpClientManager.create({
-    baseUrl: context.testMode ? 'https://stg-api.jolibox.com' : 'https://api.jolibox.com'
+    baseUrl: getApiHost(context.testMode)
   });
   private gameStore: LocalForage;
   constructor() {

package/src/h5/http/index.ts

@@ -1,7 +1,7 @@
 import { IHttpClient } from '@/common/http';
 import { xUserAgent } from '../../common/http/xua';
 import { context } from '@/common/context';
-import { platform } from '@jolibox/common';
+import { getApiHost, platform } from '@jolibox/common';
 
 declare global {
   interface Window {
@@ -68,7 +68,7 @@ export class JoliboxHttpClient implements IHttpClient {
   };
 
   constructor(config?: IHttpClientInitParams) {
-    const defaultUrl = context.testMode ? 'https://stg-api.jolibox.com' : 'https://api.jolibox.com';
+    const defaultUrl = getApiHost(context.testMode);
     this.baseUrl = config?.baseUrl ?? defaultUrl;
   }
 

package/src/h5/report/event-tracker.ts

@@ -1,26 +1,11 @@
 import { context } from '@/common/context';
 import { EventTracker } from '@/common/report';
 import { httpClientManager } from '@/h5/http';
+import { getCollectHost } from '@jolibox/common';
 
 export class H5EventTracker extends EventTracker {
-  private hostToApiMap: Record<string | 'default', { test: string; prod: string }> = {
-    default: {
-      test: 'https://stg-collect.jolibox.com',
-      prod: 'https://collect.jolibox.com'
-    },
-    'oss.jolibox.com': {
-      test: 'https://stg-collect.jolibox.com',
-      prod: 'https://collect.jolibox.com'
-    },
-    'oss.pico-game.com': {
-      test: 'https://stg-collect.pico-game.com',
-      prod: 'https://collect.pico-game.com'
-    }
-  };
-
   private get apiBaseURL() {
-    const api = this.hostToApiMap[window.location.host] ?? this.hostToApiMap.default;
-    return context.testMode ?? false ? api.test : api.prod;
+    return getCollectHost(context.testMode ?? false);
   }
 
   private httpClient = httpClientManager.create({