@jolibox/implement 1.2.7 → 1.2.9-beta.9

package/src/common/rewards/registers/utils/subscription/sub-handler.ts

@@ -7,18 +7,28 @@ import { RewardsCommandType } from '@jolibox/types';
 import { createShowSubscriptionModal } from './commands/use-subscription';
 import { registerUseSubscriptionCommand } from './commands';
 import { context } from '@/common/context';
+import { checkIfSupportSubscription } from '../common';
+import { refreshBalanceCache } from '../coins/jolicoin/cached-fetch-balance';
+import { refreshGemBalanceCache } from '../coins/joligem/cached-fetch-gem-balance';
 
 export const createCommonSubscriptionHandler = (
   type: 'SUBSCRIPTION',
   httpClient: IHttpClient,
   {
-    handlers: { handleSubSuccess, handleSubFailed, unlockOptionsHandler, showSubscriptionModal }
+    handlers: {
+      handleSubSuccess,
+      handleSubFailed,
+      unlockOptionsHandler,
+      showSubscriptionModal,
+      hasSubscription
+    }
   }: {
     handlers: {
       handleSubSuccess?: () => void;
       handleSubFailed?: (params: IAdBreakParams) => void;
       unlockOptionsHandler: EventPromiseHandler<IUnlockOptionsEvent, typeof UnlockOptionsEventName>;
       showSubscriptionModal: ReturnType<typeof createShowSubscriptionModal>;
+      hasSubscription?: () => boolean;
     };
   }
 ) => {
@@ -31,6 +41,12 @@ export const createCommonSubscriptionHandler = (
 
   return async (params: IAdBreakParams) => {
     try {
+      const unlockOptions = await unlockOptionsHandler.getData();
+      const supportSubscription = checkIfSupportSubscription(unlockOptions, hasSubscription);
+      if (!supportSubscription) {
+        // pass to next handler
+        return false;
+      }
       let result = true;
       for (const command of commands) {
         const commandResult = await rewardsCommands.executeCommand(command as RewardsCommandType);
@@ -40,12 +56,11 @@ export const createCommonSubscriptionHandler = (
         }
       }
 
-      if (!result) {
-        handleSubFailed?.(params);
-        return false;
-      }
+      // refresh balance and gem balance cache.in case of user login, the balance and gem balance is not updated.
+      refreshBalanceCache(httpClient);
+      refreshGemBalanceCache(httpClient);
 
-      console.log('-----unlockWithSubscription result-----');
+      console.log('-----unlockWithSubscription result-----', result);
       if (result) {
         try {
           params.adBreakDone?.({
@@ -82,7 +97,8 @@ export const createCommonSubscriptionHandler = (
       handleSubFailed?.(params);
       return false;
     } finally {
-      unlockOptionsHandler.clearCache();
+      // do not clear cache for unlockoptions
+      // unlockOptionsHandler.clearCache();
     }
   };
 };

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

@@ -84,6 +84,10 @@ export interface IUseModalFrequencyConfig {
       dailyMaxPopUps?: number;
       minInterval?: number;
     };
+    joinMember: {
+      dailyMaxPopUps?: number;
+      minInterval?: number;
+    };
   };
   loginGuide: {
     show: boolean;
@@ -146,6 +150,10 @@ export const DefaltJoliCoinUseAndCharge = {
   useJolicoin: {
     dailyMaxPopUps: 2,
     minInterval: 8 * 60 * 60 * 1000
+  },
+  joinMember: {
+    dailyMaxPopUps: 2,
+    minInterval: 8 * 60 * 60 * 1000
   }
 };
 

package/src/common/rewards/type.ts

@@ -8,7 +8,7 @@ export interface IGem {
   enableAutoDeduct: boolean;
 }
 
-export type IUnlockOptionType = 'JOLI_COIN' | 'ADS' | 'JOLI_GEM';
+export type IUnlockOptionType = 'JOLI_COIN' | 'ADS' | 'JOLI_GEM' | 'SUBSCRIPTION';
 
 interface IJoliCoinChoice {
   joliCoinQuantity: number;

package/src/common/utils/index.ts

@@ -78,7 +78,7 @@ const ON_JOLIBOX_JOLI_COIN_USE_RESULT = 'ON_JOLIBOX_JOLI_COIN_USE_RESULT';
 const ON_JOLIBOX_JOLI_UNLOGIN_MODAL_RESULT_EVENT = 'ON_JOLIBOX_JOLI_UNLOGIN_MODAL_RESULT_EVENT';
 
 // subscription
-const ON_GET_USER_SUB_STATUS = 'ON_GET_USER_SUB_STATUS';
+const ON_GET_USER_SUB_STATUS = 'ON_JOLIBOX_GET_USER_SUB_STATUS';
 const ON_JOLIBOX_SUB_RESULT_EVENT = 'ON_JOLIBOX_SUB_RESULT_EVENT';
 
 interface ReceivedJoliboxCustomEvent {

package/src/h5/api/ads.ts

@@ -150,21 +150,24 @@ rewardsHelper.registerRewardHandler('ADS', createAdsRewardHandler(adsHandler.get
 rewardsHelper.registerRewardHandler(
   'JOLI_COIN',
   createJolicoinRewardHandler(httpClient, {
-    onUnlockSuccess: handleUnlockSuccess.bind(this)
+    onUnlockSuccess: handleUnlockSuccess.bind(this),
+    hasSubscription: () => true
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
 rewardsHelper.registerRewardHandler(
   'JOLI_COIN_ONLY',
   createJolicoinOnlyRewardHandler(httpClient, {
-    onUnlockSuccess: handleUnlockSuccess.bind(this)
+    onUnlockSuccess: handleUnlockSuccess.bind(this),
+    hasSubscription: () => true
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
 rewardsHelper.registerRewardHandler(
   'SUBSCRIPTION',
   createSubscriptionRewardHandler(httpClient, {
-    onSubSuccess: handleUnlockWithSubscriptionSuccess.bind(this)
+    onSubSuccess: handleUnlockWithSubscriptionSuccess.bind(this),
+    hasSubscription: () => true
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 

package/src/h5/bootstrap/auth/__tests__/auth.test.ts

@@ -49,7 +49,7 @@ describe('getUserSubStatus', () => {
   it('should resolve with correct value when event is received', async () => {
     let eventHandler: ((data: EventData) => void) | null = null;
     mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
-      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+      if (eventName === 'ON_JOLIBOX_GET_USER_SUB_STATUS') {
         eventHandler = handler;
       }
       return jest.fn();
@@ -79,7 +79,7 @@ describe('getUserSubStatus', () => {
   it('should resolve with false when isSubUser is false', async () => {
     let eventHandler: ((data: EventData) => void) | null = null;
     mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
-      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+      if (eventName === 'ON_JOLIBOX_GET_USER_SUB_STATUS') {
         eventHandler = handler;
       }
       return jest.fn();
@@ -102,6 +102,8 @@ describe('getUserSubStatus', () => {
   });
 
   it('should reject on timeout', async () => {
+    jest.useFakeTimers();
+
     mockOnCustomEvent.mockImplementation(() => jest.fn());
     mockUuidv4.mockReturnValue('timeout-test-id');
 
@@ -111,12 +113,14 @@ describe('getUserSubStatus', () => {
     jest.advanceTimersByTime(3000);
 
     await expect(promise).rejects.toThrow('Timeout waiting for user sub status response');
+
+    jest.useRealTimers();
   });
 
   it('should initialize event listener only once', async () => {
     let eventHandler: ((data: EventData) => void) | null = null;
     mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
-      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+      if (eventName === 'ON_JOLIBOX_GET_USER_SUB_STATUS') {
         eventHandler = handler;
       }
       return jest.fn();
@@ -133,7 +137,7 @@ describe('getUserSubStatus', () => {
 
     // Should only initialize listener once
     expect(mockOnCustomEvent).toHaveBeenCalledTimes(1);
-    expect(mockOnCustomEvent).toHaveBeenCalledWith('ON_GET_USER_SUB_STATUS', expect.any(Function));
+    expect(mockOnCustomEvent).toHaveBeenCalledWith('ON_JOLIBOX_GET_USER_SUB_STATUS', expect.any(Function));
 
     // Should send notification for both calls
     expect(mockNotifyCustomEvent).toHaveBeenCalledTimes(2);
@@ -152,7 +156,7 @@ describe('getUserSubStatus', () => {
   it('should ignore responses with different sequenceId', async () => {
     let eventHandler: ((data: EventData) => void) | null = null;
     mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
-      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+      if (eventName === 'ON_JOLIBOX_GET_USER_SUB_STATUS') {
         eventHandler = handler;
       }
       return jest.fn();
@@ -201,7 +205,7 @@ describe('getUserSubStatus', () => {
   it('should handle multiple concurrent requests with different sequenceIds', async () => {
     let eventHandler: ((data: EventData) => void) | null = null;
     mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
-      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+      if (eventName === 'ON_JOLIBOX_GET_USER_SUB_STATUS') {
         eventHandler = handler;
       }
       return jest.fn();
@@ -248,7 +252,7 @@ describe('getUserSubStatus', () => {
   it('should clean up timeout when response is received', async () => {
     let eventHandler: ((data: EventData) => void) | null = null;
     mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
-      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+      if (eventName === 'ON_JOLIBOX_GET_USER_SUB_STATUS') {
         eventHandler = handler;
       }
       return jest.fn();
@@ -278,9 +282,11 @@ describe('getUserSubStatus', () => {
   });
 
   it('should not resolve after timeout even if response comes later', async () => {
+    jest.useFakeTimers();
+
     let eventHandler: ((data: EventData) => void) | null = null;
     mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
-      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+      if (eventName === 'ON_JOLIBOX_GET_USER_SUB_STATUS') {
         eventHandler = handler;
       }
       return jest.fn();
@@ -303,6 +309,6 @@ describe('getUserSubStatus', () => {
       });
     }
 
-    // Promise should already be rejected, no additional effects
+    jest.useRealTimers();
   });
 });

package/src/h5/bootstrap/auth/sub.ts

@@ -14,7 +14,7 @@ let isListenerInitialized = false;
 const initializeEventListener = () => {
   if (isListenerInitialized) return;
 
-  onCustomEvent('ON_GET_USER_SUB_STATUS', (data) => {
+  onCustomEvent('ON_JOLIBOX_GET_USER_SUB_STATUS', (data) => {
     const pendingRequest = pendingRequests.get(data.sequenceId);
     if (pendingRequest) {
       clearTimeout(pendingRequest.timeoutId);

package/src/native/api/ads.ts

@@ -1,5 +1,5 @@
 import { createCommands } from '@jolibox/common';
-import { createSyncAPI, registerCanIUse } from './base';
+import { canIUseNative, createSyncAPI, registerCanIUse } from './base';
 import { createToast } from '@jolibox/ui';
 import '../rewards';
 
@@ -27,7 +27,8 @@ import {
   createGemRewardHandler,
   createGemOnlyRewardHandler,
   warmupGemBalanceCache,
-  warmupBalanceCache
+  warmupBalanceCache,
+  createSubscriptionRewardHandler
 } from '@/common/rewards';
 import { adEventEmitter } from '@/common/ads';
 import { warmupRewardCache } from '@/common/rewards/fetch-reward';
@@ -107,7 +108,8 @@ rewardsHelper.registerRewardHandler(
     },
     onUnlockFailed: () => {
       console.log('onUnlockFailed');
-    }
+    },
+    hasSubscription: () => canIUseNative('invokeSubscriptionPanelSync')
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
@@ -123,7 +125,8 @@ rewardsHelper.registerRewardHandler(
     },
     onUnlockFailed: () => {
       console.log('onUnlockFailed');
-    }
+    },
+    hasSubscription: () => canIUseNative('invokeSubscriptionPanelSync')
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
@@ -136,7 +139,8 @@ rewardsHelper.registerRewardHandler(
       track('gem_unlock_success', {
         quantity: params.quantity
       });
-    }
+    },
+    hasSubscription: () => canIUseNative('invokeSubscriptionPanelSync')
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
@@ -149,7 +153,20 @@ rewardsHelper.registerRewardHandler(
         quantity: params.quantity,
         isOnly: true
       });
-    }
+    },
+    hasSubscription: () => canIUseNative('invokeSubscriptionPanelSync')
+  }) as unknown as (params?: unknown) => Promise<boolean>
+);
+
+const handleUnlockWithSubscriptionSuccess = () => {
+  track('subscription_unlock_success', {});
+};
+
+rewardsHelper.registerRewardHandler(
+  'SUBSCRIPTION',
+  createSubscriptionRewardHandler(httpClient, {
+    onSubSuccess: handleUnlockWithSubscriptionSuccess.bind(this),
+    hasSubscription: () => canIUseNative('invokeSubscriptionPanelSync')
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
@@ -217,8 +234,28 @@ const adConfig = createSyncAPI('adConfig', {
 });
 
 let rewardLocked = false;
+
+const wrapAdBreadDoneViewed = (params: IAdBreakParams) => {
+  params.adBreakDone?.({
+    breakType: params.type,
+    breakName: 'name' in params ? params.name ?? '' : '',
+    breakFormat: params.type === 'reward' ? 'reward' : 'interstitial',
+    breakStatus: 'viewed'
+  });
+  if ('adViewed' in params) {
+    params.adViewed?.();
+  }
+};
+
 const adBreak = createSyncAPI('adBreak', {
   implement: (params: IAdBreakParams) => {
+    // check is sub user
+    const isSubUser = context.hostUserInfo?.isSubUser;
+    if (isSubUser) {
+      wrapAdBreadDoneViewed(params);
+      return;
+    }
+
     if (params.type === 'reward') {
       if (rewardLocked) {
         return;

package/src/native/api/call-host-method.ts

@@ -1,65 +1,10 @@
-import { createAPI, registerCanIUse, t } from './base';
+import { canIUseNative, createAPI, registerCanIUse, t } from './base';
 import { invokeNative } from '@jolibox/native-bridge';
-import { hostEmitter, UserCustomError } from '@jolibox/common';
+import { UserCustomError } from '@jolibox/common';
 import { createCommands } from '@jolibox/common';
 import { context } from '@/common/context';
 
 const commands = createCommands();
-let supportedMethods: string[] = [];
-let isInitialized = false;
-
-const formatSupportedMethods = (
-  methods: (
-    | string
-    | {
-        method: string;
-        platforms?: string[];
-        nativeVersionCode?: number;
-      }
-  )[]
-) => {
-  const platform = context.platform;
-  const nativeVersionCode = context.sdkInfo.nativeSDKVersionCode ?? 0;
-  return methods.reduce((acc, method) => {
-    if (typeof method === 'string') {
-      acc.push(method);
-    } else {
-      const { method: platformMethod, platforms, nativeVersionCode: methodNativeVersionCode } = method;
-      let canUse = true;
-      if (platforms && !platforms.includes(platform)) {
-        canUse = false;
-      }
-      if (methodNativeVersionCode && methodNativeVersionCode > nativeVersionCode) {
-        canUse = false;
-      }
-      if (canUse) {
-        acc.push(platformMethod);
-      }
-    }
-    return acc;
-  }, [] as string[]);
-};
-
-hostEmitter.on('onGlobalConfigChanged', (params) => {
-  supportedMethods = formatSupportedMethods(params.globalConfig?.supportedHostMethods ?? []);
-  isInitialized = true;
-});
-
-const getSupportedMethods = (): Promise<string[]> => {
-  return new Promise((resolve) => {
-    if (isInitialized) {
-      resolve(supportedMethods);
-    } else {
-      const handler = (params: any) => {
-        supportedMethods = formatSupportedMethods(params.globalConfig.supportedHostMethods ?? []);
-        isInitialized = true;
-        hostEmitter.off('onGlobalConfigChanged', handler);
-        resolve(supportedMethods);
-      };
-      hostEmitter.on('onGlobalConfigChanged', handler);
-    }
-  });
-};
 
 const callHostMethodAsync = createAPI('callHostMethod', {
   paramsSchema: t.tuple(
@@ -69,10 +14,10 @@ const callHostMethodAsync = createAPI('callHostMethod', {
     })
   ),
   implement: async ({ method, params }) => {
-    const supportedMethods = await getSupportedMethods();
-    if (!supportedMethods.includes(method)) {
+    if (!canIUseNative(method)) {
       throw new UserCustomError('Method not supported', 10001);
     }
+
     const { errNo, errMsg, data } = await invokeNative('callHostMethodAsync', {
       method,
       params: {
@@ -106,8 +51,7 @@ const userTrackAsync = createAPI('userTrackAsync', {
     })
   ),
   implement: async ({ event, eventType, params }) => {
-    const supportedMethods = await getSupportedMethods();
-    if (!supportedMethods.includes('userTrackAsync')) {
+    if (!canIUseNative('userTrackAsync')) {
       throw new UserCustomError('Method not supported', 10001);
     }
     const { errNo, errMsg } = await invokeNative('trackAsync', {

package/src/native/api/login.ts

@@ -19,19 +19,27 @@ registerCanIUse('login', {
 registerCanIUse('checkSession', {
   version: '1.0.0',
   success: {
-    errMsg: '1.0.0'
+    errMsg: '1.0.0',
+    isLogin: '1.0.0',
+    isSubUser: '1.2.9'
   }
 });
 
 const loginDeferredMap = new Map<
   string,
-  Deferred<{ isLogin: boolean; token?: string; isFirstLogin?: boolean; extra?: LoginExtra }>
+  Deferred<{
+    isLogin: boolean;
+    token?: string;
+    isFirstLogin?: boolean;
+    extra?: LoginExtra;
+    appAccountToken?: string;
+  }>
 >();
 
-onNative('onLoginStateChange', ({ isLogin, token, uuid, isFirstLogin, extra }) => {
+onNative('onLoginStateChange', ({ isLogin, token, uuid, isFirstLogin, extra, appAccountToken }) => {
   const deferred = loginDeferredMap.get(uuid);
   if (deferred) {
-    deferred.resolve({ isLogin, token, isFirstLogin, extra });
+    deferred.resolve({ isLogin, token, isFirstLogin, extra, appAccountToken });
     loginDeferredMap.delete(uuid);
   }
 });
@@ -81,12 +89,16 @@ export const loginImplement = async (
     isLogin: boolean;
     token?: string;
     isFirstLogin?: boolean;
+    appAccountToken?: string;
     extra?: LoginExtra;
   }>();
   loginDeferredMap.set(loginUUID, deferred);
   const loginRes = await deferred.promise;
-  context.onEnvConfigChanged({ hostUserInfo: loginRes });
-  const { extra, ...rest } = loginRes;
+  // update sub user status
+  const env = invokeNative('envSync');
+  const isSubUser = env?.data?.hostUserInfo?.isSubUser;
+  context.onEnvConfigChanged({ hostUserInfo: { ...loginRes, isSubUser } });
+  const { extra, appAccountToken, ...rest } = loginRes;
   hostEmitter.emit('onLoginComplete', rest);
   return needExtra ? loginRes : rest;
 };
@@ -110,8 +122,11 @@ const checkSession = createAPI('checkSession', {
     const {
       data: { isLogin }
     } = await applyNative('checkLoginAsync');
+
+    const isSubUser = context.hostUserInfo?.isSubUser;
     return {
-      isLogin
+      isLogin,
+      isSubUser
     };
   }
 });

package/src/native/api/payment.ts

@@ -3,6 +3,8 @@ import { createAPI, registerCanIUse, t } from './base';
 import { createJoliGemPaymentService } from '../payment/payment-service';
 import { createAPIError } from '@/common/report/errors';
 import { IPaymentChoice } from '@jolibox/ui/dist/bridge/coin';
+import { ISubscriptionTierData } from '@jolibox/types';
+import { subscriptionService } from '@/native/subscription';
 
 const commands = createCommands();
 const paymentService = createJoliGemPaymentService();
@@ -13,10 +15,10 @@ const purchaseGem = createAPI('purchaseGem', {
       productId: t.string()
     })
   ),
-  implement: async (params: { productId: string }): Promise<{ totalAmount: string }> => {
+  implement: async (params: { productId: string }): Promise<{ totalAmount?: string }> => {
     const result = await paymentService.purchase(params.productId);
 
-    if (result.code !== 'SUCCESS' || !result.data?.totalAmount) {
+    if (result.code !== 'SUCCESS') {
       throw createAPIError({
         code: -1,
         msg: '[JoliboxSDK]: purchase gem failed: ' + result.message
@@ -24,7 +26,7 @@ const purchaseGem = createAPI('purchaseGem', {
     }
 
     return {
-      totalAmount: result.data?.totalAmount
+      totalAmount: result.data?.totalAmount ?? ''
     };
   }
 });
@@ -44,9 +46,69 @@ const getGemProducts = createAPI('getGemProducts', {
   }
 });
 
+const getSubscriptionPlans = createAPI('getSubscriptionPlans', {
+  paramsSchema: t.tuple(),
+  implement: async (): Promise<{ plans: ISubscriptionTierData[] } | undefined> => {
+    const subPlans = await subscriptionService.getSubInfo();
+
+    console.log('[PaymentAPI] getSubscriptionPlans result', subPlans);
+    if (!subPlans) {
+      throw createAPIError({
+        code: -1,
+        msg: '[JoliboxSDK]: get subscription plans failed'
+      });
+    }
+    return {
+      plans: subPlans
+    };
+  }
+});
+
+const flushSubInfoCache = createAPI('flushSubInfoCache', {
+  paramsSchema: t.tuple(),
+  implement: async (): Promise<void> => {
+    await subscriptionService.updateAllNativePriceCache();
+  }
+});
+
+const subscribe = createAPI('subscribe', {
+  paramsSchema: t.tuple(
+    t.object({
+      productId: t.string()
+    })
+  ),
+  implement: async (params: {
+    productId: string;
+  }): Promise<{
+    subPlanId: string;
+    errMsg: string;
+    result: 'SUCCESS' | 'FAILED' | 'FAILURE_SUBSCRIPTED';
+  }> => {
+    const tier = await subscriptionService.getTierByProductId(params.productId);
+    if (!tier) {
+      throw createAPIError({
+        code: -1,
+        msg: '[JoliboxSDK]: product not found'
+      });
+    }
+    const { basePlanId, appStoreProductId, nativeProductId } = tier;
+    const result = await subscriptionService.subscribe({ basePlanId, nativeProductId, appStoreProductId });
+    return {
+      result: result.result,
+      subPlanId: result.subPlanId,
+      errMsg: result.message ?? ''
+    };
+  }
+});
+
 commands.registerCommand('PaymentSDK.purchaseGem', purchaseGem);
 commands.registerCommand('PaymentSDK.getGemProducts', getGemProducts);
 
+commands.registerCommand('PaymentSDK.getSubscriptionPlans', getSubscriptionPlans);
+commands.registerCommand('PaymentSDK.subscribe', subscribe);
+
+commands.registerCommand('PaymentSDK.flushSubInfoCache', flushSubInfoCache);
+
 registerCanIUse('payment.purchaseGem', {
   version: '1.2.3'
 });
@@ -54,3 +116,16 @@ registerCanIUse('payment.purchaseGem', {
 registerCanIUse('payment.getGemProducts', {
   version: '1.2.3'
 });
+
+// for test, correct version is 1.3.0
+registerCanIUse('payment.getSubscriptionPlans', {
+  version: '1.2.5'
+});
+
+registerCanIUse('payment.subscribe', {
+  version: '1.2.5'
+});
+
+registerCanIUse('payment.flushSubInfoCache', {
+  version: '1.2.5'
+});

package/src/native/payment/__tests__/payment-service-simple.test.ts

@@ -9,13 +9,26 @@ import {
 // Mock dependencies
 jest.mock('@jolibox/native-bridge', () => ({
   applyNative: jest.fn(),
-  onNative: jest.fn()
+  onNative: jest.fn(),
+  invokeNative: jest.fn()
 }));
 
 jest.mock('@/native/network', () => ({
   innerFetch: jest.fn()
 }));
 
+jest.mock('@/native/api/storage', () => ({
+  setGlobalStorage: jest.fn().mockResolvedValue({
+    code: 'SUCCESS',
+    message: 'success'
+  }),
+  getGlobalStorage: jest.fn().mockResolvedValue({
+    code: 'SUCCESS',
+    message: 'success',
+    data: null
+  })
+}));
+
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { applyNative } = require('@jolibox/native-bridge');