@jolibox/implement 1.2.4 → 1.2.5-beta.3

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

@@ -0,0 +1,88 @@
+import { IHttpClient } from '@/common/http';
+import { IAdBreakParams } from '@/common/ads';
+import { EventPromiseHandler } from '../event-listener';
+import { UnlockOptionsEventName, IUnlockOptionsEvent } from '@/common/rewards/reward-emitter';
+import { rewardsCommands } from '../coins/rewards-command';
+import { RewardsCommandType } from '@jolibox/types';
+import { createShowSubscriptionModal } from './commands/use-subscription';
+import { registerUseSubscriptionCommand } from './commands';
+import { context } from '@/common/context';
+
+export const createCommonSubscriptionHandler = (
+  type: 'SUBSCRIPTION',
+  httpClient: IHttpClient,
+  {
+    handlers: { handleSubSuccess, handleSubFailed, unlockOptionsHandler, showSubscriptionModal }
+  }: {
+    handlers: {
+      handleSubSuccess?: () => void;
+      handleSubFailed?: (params: IAdBreakParams) => void;
+      unlockOptionsHandler: EventPromiseHandler<IUnlockOptionsEvent, typeof UnlockOptionsEventName>;
+      showSubscriptionModal: ReturnType<typeof createShowSubscriptionModal>;
+    };
+  }
+) => {
+  // register commands
+  registerUseSubscriptionCommand({
+    showSubscriptionModal: showSubscriptionModal
+  });
+
+  const commands = [`Rewards.subscription`];
+
+  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) {
+        handleSubFailed?.(params);
+        return false;
+      }
+
+      console.log('-----unlockWithSubscription result-----');
+      if (result) {
+        try {
+          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?.();
+          }
+
+          context.onEnvConfigChanged?.({
+            hostUserInfo: {
+              ...(context.hostUserInfo ?? { isLogin: false }),
+              isSubUser: true
+            }
+          });
+        } catch (e) {
+          console.error('-----unlockWithSubscription adBreakDone error-----', e);
+        }
+
+        handleSubSuccess?.();
+        return true;
+      }
+      handleSubFailed?.(params);
+      return false;
+    } catch (e) {
+      console.info(`SubscriptionRewardHandler error:`, e);
+      if (e instanceof Error && e.message == 'CANCEL') {
+        // Cancel should terminate the reward handler, invoke unlock failed
+        throw e;
+      }
+      handleSubFailed?.(params);
+      return false;
+    } finally {
+      unlockOptionsHandler.clearCache();
+    }
+  };
+};

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

@@ -17,6 +17,8 @@ export const UseModalResultEventName = 'ON_USE_MODAL_RESULT' as const;
 export const UseModalFrequencyEventName = 'ON_USE_MODAL_FREQUENCY' as const;
 export const UseUnloginModalResultEventName = 'ON_USE_UNLOGIN_MODAL_EVENT' as const;
 export const InvokeUnloginModalEventName = 'INVOKE_UNLOGIN_MODAL_EVENT' as const;
+export const InvokeSubscriptionEventName = 'INVOKE_SUBSCRIPTION_EVENT' as const;
+export const UseSubscriptionResultEventName = 'ON_USE_SUBSCRIPTION_RESULT' as const;
 
 type IPaymentResult = 'SUCCESS' | 'FAILED' | 'CANCEL';
 export interface IPaymentEvent {
@@ -90,6 +92,10 @@ export interface IUseModalFrequencyConfig {
   };
 }
 
+export interface IUseSubscriptionResultEvent {
+  result: 'SUCCESS' | 'CANCEL' | 'FAILED';
+}
+
 export interface RewardsEventMap extends Record<string, unknown[]> {
   [UnlockOptionsEventName]: [IUnlockOptionsEvent];
   [InvokePaymentEventName]: [
@@ -105,6 +111,8 @@ export interface RewardsEventMap extends Record<string, unknown[]> {
     IUseUnloginModalEvent
   ];
   [UseUnloginModalResultEventName]: [IUseUnloginModalResultEvent];
+  [InvokeSubscriptionEventName]: ['SUBSCRIPTION'];
+  [UseSubscriptionResultEventName]: [IUseSubscriptionResultEvent];
 }
 
 export const originalRewardsEmitter = new EventEmitter<RewardsEventMap>();

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

@@ -1,4 +1,10 @@
-export type RewardType = 'ADS' | 'JOLI_COIN' | 'JOLI_COIN_ONLY' | 'JOLI_GEM' | 'JOLI_GEM_ONLY';
+export type RewardType =
+  | 'ADS'
+  | 'JOLI_COIN'
+  | 'JOLI_COIN_ONLY'
+  | 'JOLI_GEM'
+  | 'JOLI_GEM_ONLY'
+  | 'SUBSCRIPTION';
 
 import { context } from '../context';
 import type { AdsRewardsHandler } from './registers/use-ads';
@@ -10,6 +16,7 @@ export interface RewardHandlerMap {
   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
+  SUBSCRIPTION: (params?: unknown) => Promise<boolean>; // subscription
 }
 
 export type RewardHandler<T extends RewardType> = RewardHandlerMap[T];

package/src/common/utils/index.ts

@@ -8,6 +8,11 @@ const JOLIBOX_JOLI_COIN_USE_EVENT = 'JOLIBOX_JOLI_COIN_USE_EVENT';
 const JOLIBOX_JOLI_UNLOGIN_MODAL_EVENT = 'JOLIBOX_JOLI_UNLOGIN_MODAL_EVENT'; // unlogin modal event, triggered when unlogin
 // unlogin modal result event success.
 
+// subscrition
+
+const JOLIBOX_GET_USER_SUB_STATUS = 'JOLIBOX_GET_USER_SUB_STATUS';
+const JOLIBOX_SUB_EVENT = 'JOLIBOX_SUB_EVENT';
+
 interface JoliboxCustomEvent {
   [JOLIBOX_CUSTOM_ADS_EVENT_TYPE]: {
     isAdShowing: boolean;
@@ -41,6 +46,12 @@ interface JoliboxCustomEvent {
     sequenceId: string;
     type: 'ADS-JOLI_COIN' | 'JOLI_COIN';
   };
+  [JOLIBOX_GET_USER_SUB_STATUS]: {
+    sequenceId: string;
+  };
+  [JOLIBOX_SUB_EVENT]: {
+    sequenceId: string;
+  };
 }
 
 const notifyCustomEvent = <T extends keyof JoliboxCustomEvent>(eventName: T, data: JoliboxCustomEvent[T]) => {
@@ -66,6 +77,10 @@ const ON_JOLIBOX_TOPUP_JOLI_COIN_RESULT = 'ON_JOLIBOX_TOPUP_JOLI_COIN_RESULT';
 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_JOLIBOX_SUB_RESULT_EVENT = 'ON_JOLIBOX_SUB_RESULT_EVENT';
+
 interface ReceivedJoliboxCustomEvent {
   [ON_JOLIBOX_TOPUP_JOLI_COIN_RESULT]: {
     sequenceId: string;
@@ -93,6 +108,14 @@ interface ReceivedJoliboxCustomEvent {
     };
     isFirstLogin?: boolean;
   };
+  [ON_GET_USER_SUB_STATUS]: {
+    sequenceId: string;
+    isSubUser: boolean;
+  };
+  [ON_JOLIBOX_SUB_RESULT_EVENT]: {
+    sequenceId: string;
+    result: 'SUCCESS' | 'CANCEL' | 'FAILED';
+  };
 }
 
 type ReceivedJoliboxCustomEventResult = keyof ReceivedJoliboxCustomEvent;

package/src/h5/api/ads.ts

@@ -6,7 +6,8 @@ import {
   createAdsRewardHandler,
   rewardsHelper,
   createJolicoinRewardHandler,
-  createJolicoinOnlyRewardHandler
+  createJolicoinOnlyRewardHandler,
+  createSubscriptionRewardHandler
 } from '@/common/rewards';
 import {
   JoliboxAdsForGame,
@@ -23,6 +24,8 @@ import HuaweiQuickAdsHandler from './platformAdsHandle/HuaweiQuickAdsHandler';
 import GamedistributionAdsHandler from './platformAdsHandle/GamedistributionAdsHandler';
 import FunmaxAdsHandler from './platformAdsHandle/FunmaxAdsHandler';
 import JoliboxAdsHandler from './platformAdsHandle/JoliboxAdsHandler';
+import { warmupRewardCache } from '@/common/rewards/fetch-reward';
+import { warmupBalanceCache } from '@/common/rewards';
 
 declare global {
   interface Window {
@@ -127,13 +130,9 @@ const adsContext: IAdsContext<'GAME'> = {
   }
 };
 
-const handleUnlockSuccess = (params: { quantity: number; balance: number }) => {
-  notifyCustomEvent('JOLIBOX_CUSTOM_REWARDS_EVENT', {
-    JOLI_COIN: params
-  });
-  track('jolicoin_unlock_success', {
-    quantity: params.quantity
-  });
+
+const handleUnlockWithSubscriptionSuccess = () => {
+  track('subscription_unlock_success', {});
 };
 
 const adsManager = new H5AdsManager(adsContext);
@@ -143,17 +142,24 @@ rewardsHelper.registerRewardHandler('ADS', createAdsRewardHandler(adsHandler.get
 rewardsHelper.registerRewardHandler(
   'JOLI_COIN',
   createJolicoinRewardHandler(httpClient, {
-    onUnlockSuccess: handleUnlockSuccess.bind(this)
+    onUnlockSuccess: (params: { quantity: number; balance: number }) => {
+      notifyCustomEvent('JOLIBOX_CUSTOM_REWARDS_EVENT', {
+        JOLI_COIN: params
+      });
+    }
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
 rewardsHelper.registerRewardHandler(
-  'JOLI_COIN_ONLY',
-  createJolicoinOnlyRewardHandler(httpClient, {
-    onUnlockSuccess: handleUnlockSuccess.bind(this)
+  'SUBSCRIPTION',
+  createSubscriptionRewardHandler(httpClient, {
+    onSubSuccess: handleUnlockWithSubscriptionSuccess.bind(this)
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
+warmupRewardCache(httpClient);
+warmupBalanceCache(httpClient);
+
 adEventEmitter.on('isAdShowing', (isAdShowing) => {
   notifyCustomEvent('JOLIBOX_ADS_EVENT', { isAdShowing });
 });

package/src/h5/api/platformAdsHandle/JoliboxAdsHandler.ts

@@ -8,6 +8,7 @@ import {
 } from '@jolibox/ads';
 import { IAdsHandler } from '../ads';
 import { JoliboxHttpClient } from '@/h5/http';
+import { context } from '@/common/context';
 
 export default class JoliboxAdsHandler implements IAdsHandler {
   constructor(private ads: JoliboxAdsForGame, private httpClient: JoliboxHttpClient) {}
@@ -25,10 +26,21 @@ export default class JoliboxAdsHandler implements IAdsHandler {
   }
 
   async adBreak(params: IAdBreakParams): Promise<void> {
+    const isSubUser = context.hostUserInfo?.isSubUser;
+
+    // if is sub user, just call adBreakDone with viewed status
+    if (isSubUser) {
+      this.wrapAdBreadDoneViewed(params);
+      return;
+    }
+
     if (params.type === 'reward') {
       try {
         const rewardsTypes = await rewardsHelper.getRewardsTypes(this.httpClient);
-        await rewardsHelper.handleReward(rewardsTypes, params);
+        const rewardResult = await rewardsHelper.handleReward(rewardsTypes, params);
+        if (!rewardResult) {
+          throw new Error('handleReward failed: fallback to unlock failed');
+        }
       } catch (e) {
         console.info('handleReward failed', e);
         params.adBreakDone?.({
@@ -45,4 +57,16 @@ export default class JoliboxAdsHandler implements IAdsHandler {
   adUnit(params: IAdUnitParams): void {
     this.ads.adUnit(params);
   }
+
+  private 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?.();
+    }
+  }
 }

package/src/h5/api/storage.ts

@@ -1,5 +1,5 @@
 import { createAPI, t, registerCanIUse } from './base';
-import { createCommands, getApiHost } from '@jolibox/common';
+import { createCommands, getH5ApiHost } 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: getApiHost(context.testMode)
+    baseUrl: getH5ApiHost(context.testMode)
   });
   private gameStore: LocalForage;
   constructor() {

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

@@ -0,0 +1,308 @@
+// Mock dependencies first
+const mockOnCustomEvent = jest.fn();
+const mockNotifyCustomEvent = jest.fn();
+const mockUuidv4 = jest.fn();
+
+jest.mock('@jolibox/common', () => ({
+  uuidv4: mockUuidv4,
+  EventEmitter: jest.fn().mockImplementation(() => ({
+    emit: jest.fn(),
+    on: jest.fn(),
+    off: jest.fn(),
+    once: jest.fn(),
+    removeAllListeners: jest.fn()
+  })),
+  InternalGlobalJSError: jest.fn().mockImplementation((error) => error)
+}));
+
+jest.mock('@/common/utils', () => ({
+  onCustomEvent: mockOnCustomEvent,
+  notifyCustomEvent: mockNotifyCustomEvent
+}));
+
+jest.mock('@/common/report/errors/report', () => ({
+  reportError: jest.fn()
+}));
+
+import { getUserSubStatus, resetSubState } from '../sub';
+
+// Define event data interface
+interface EventData {
+  sequenceId: string;
+  isSubUser: boolean;
+}
+
+describe('getUserSubStatus', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.clearAllTimers();
+    jest.useRealTimers(); // Use real timers to avoid timing issues
+
+    // Reset module state between tests
+    resetSubState();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  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') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    mockUuidv4.mockReturnValue('test-sequence-id');
+
+    const promise = getUserSubStatus();
+
+    // Verify notification was sent
+    expect(mockNotifyCustomEvent).toHaveBeenCalledWith('JOLIBOX_GET_USER_SUB_STATUS', {
+      sequenceId: 'test-sequence-id'
+    });
+
+    // Simulate response immediately
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'test-sequence-id',
+        isSubUser: true
+      });
+    }
+
+    const result = await promise;
+    expect(result).toBe(true);
+  });
+
+  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') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    mockUuidv4.mockReturnValue('test-sequence-id');
+
+    const promise = getUserSubStatus();
+
+    // Simulate response with false
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'test-sequence-id',
+        isSubUser: false
+      });
+    }
+
+    const result = await promise;
+    expect(result).toBe(false);
+  });
+
+  it('should reject on timeout', async () => {
+    mockOnCustomEvent.mockImplementation(() => jest.fn());
+    mockUuidv4.mockReturnValue('timeout-test-id');
+
+    const promise = getUserSubStatus();
+
+    // Fast forward time to trigger timeout
+    jest.advanceTimersByTime(3000);
+
+    await expect(promise).rejects.toThrow('Timeout waiting for user sub status response');
+  });
+
+  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') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    // Mock different UUIDs for different calls
+    mockUuidv4.mockReturnValueOnce('uuid-1').mockReturnValueOnce('uuid-2');
+
+    // First call
+    const promise1 = getUserSubStatus();
+
+    // Second call
+    const promise2 = getUserSubStatus();
+
+    // Should only initialize listener once
+    expect(mockOnCustomEvent).toHaveBeenCalledTimes(1);
+    expect(mockOnCustomEvent).toHaveBeenCalledWith('ON_GET_USER_SUB_STATUS', expect.any(Function));
+
+    // Should send notification for both calls
+    expect(mockNotifyCustomEvent).toHaveBeenCalledTimes(2);
+
+    // Simulate responses with different sequence IDs
+    if (eventHandler) {
+      (eventHandler as any)({ sequenceId: 'uuid-1', isSubUser: true });
+      (eventHandler as any)({ sequenceId: 'uuid-2', isSubUser: false });
+    }
+
+    const [result1, result2] = await Promise.all([promise1, promise2]);
+    expect(result1).toBe(true);
+    expect(result2).toBe(false);
+  });
+
+  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') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    mockUuidv4.mockReturnValue('correct-sequence-id');
+
+    const promise = getUserSubStatus();
+
+    // Simulate response with wrong sequenceId first
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'wrong-sequence-id',
+        isSubUser: true
+      });
+    }
+
+    // Promise should still be pending after wrong sequenceId
+    let isResolved = false;
+    let promiseResult: any;
+    promise
+      .then((result) => {
+        isResolved = true;
+        promiseResult = result;
+      })
+      .catch(() => {
+        isResolved = true;
+      });
+
+    // Flush microtasks
+    await Promise.resolve();
+    expect(isResolved).toBe(false);
+
+    // Now send correct response
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'correct-sequence-id',
+        isSubUser: true
+      });
+    }
+
+    await promise;
+    expect(promiseResult).toBe(true);
+  });
+
+  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') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    // Mock different UUIDs for different calls
+    mockUuidv4
+      .mockReturnValueOnce('request-1')
+      .mockReturnValueOnce('request-2')
+      .mockReturnValueOnce('request-3');
+
+    const promise1 = getUserSubStatus();
+    const promise2 = getUserSubStatus();
+    const promise3 = getUserSubStatus();
+
+    // Should initialize listener only once
+    expect(mockOnCustomEvent).toHaveBeenCalledTimes(1);
+
+    // Should send three notifications
+    expect(mockNotifyCustomEvent).toHaveBeenCalledTimes(3);
+    expect(mockNotifyCustomEvent).toHaveBeenNthCalledWith(1, 'JOLIBOX_GET_USER_SUB_STATUS', {
+      sequenceId: 'request-1'
+    });
+    expect(mockNotifyCustomEvent).toHaveBeenNthCalledWith(2, 'JOLIBOX_GET_USER_SUB_STATUS', {
+      sequenceId: 'request-2'
+    });
+    expect(mockNotifyCustomEvent).toHaveBeenNthCalledWith(3, 'JOLIBOX_GET_USER_SUB_STATUS', {
+      sequenceId: 'request-3'
+    });
+
+    // Simulate responses in reverse order
+    if (eventHandler) {
+      (eventHandler as any)({ sequenceId: 'request-3', isSubUser: false });
+      (eventHandler as any)({ sequenceId: 'request-1', isSubUser: true });
+      (eventHandler as any)({ sequenceId: 'request-2', isSubUser: true });
+    }
+
+    const [result1, result2, result3] = await Promise.all([promise1, promise2, promise3]);
+    expect(result1).toBe(true);
+    expect(result2).toBe(true);
+    expect(result3).toBe(false);
+  });
+
+  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') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    mockUuidv4.mockReturnValue('cleanup-test-id');
+
+    // Spy on clearTimeout
+    const clearTimeoutSpy = jest.spyOn(global, 'clearTimeout');
+
+    const promise = getUserSubStatus();
+
+    // Simulate response before timeout
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'cleanup-test-id',
+        isSubUser: true
+      });
+    }
+
+    await promise;
+
+    // Verify timeout was cleared
+    expect(clearTimeoutSpy).toHaveBeenCalled();
+
+    clearTimeoutSpy.mockRestore();
+  });
+
+  it('should not resolve after timeout even if response comes later', async () => {
+    let eventHandler: ((data: EventData) => void) | null = null;
+    mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
+      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    mockUuidv4.mockReturnValue('late-response-id');
+
+    const promise = getUserSubStatus();
+
+    // Trigger timeout first
+    jest.advanceTimersByTime(3000);
+
+    await expect(promise).rejects.toThrow('Timeout waiting for user sub status response');
+
+    // Try to send response after timeout
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'late-response-id',
+        isSubUser: true
+      });
+    }
+
+    // Promise should already be rejected, no additional effects
+  });
+});

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

@@ -0,0 +1,20 @@
+import { httpClientManager } from '@/h5/http';
+import { StandardResponse } from '@jolibox/types';
+import { reportError } from '@/common/report/errors/report';
+import { InternalGlobalJSError } from '@jolibox/common';
+
+export async function checkSession(): Promise<boolean> {
+  const httpClient = httpClientManager.create();
+  try {
+    const response = await httpClient.get<StandardResponse<void>>('/api/users/info');
+    if (response.code !== 'SUCCESS' || !response.data) {
+      return false;
+    }
+    return true;
+  } catch (error) {
+    reportError(new InternalGlobalJSError(error as Error));
+    return false;
+  }
+}
+
+export { getUserSubStatus } from './sub';