@jolibox/implement 1.2.5 → 1.2.6

package/dist/native/payment/payment-service.d.ts

@@ -1,6 +1,6 @@
 import { IPaymentChoice } from '@/common/rewards/reward-emitter';
 import type { PaymentResult } from './payment-helper';
-import { RequestCacheService } from '@/common/cache/request-cache-service';
+import { RequestCacheService } from '@jolibox/common';
 type PaymentPurchaseType = 'JOLI_COIN' | 'JOLI_GEM';
 type PaymentRequest = Record<string, never>;
 interface PaymentResponse {

package/implement.build.log

@@ -1,9 +1,9 @@
 Invoking: npm run clean && npm run build:esm && tsc 
 
-> @jolibox/implement@1.2.5 clean
+> @jolibox/implement@1.2.6 clean
 > rimraf ./dist
 
 
-> @jolibox/implement@1.2.5 build:esm
+> @jolibox/implement@1.2.6 build:esm
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=esm
 

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@jolibox/implement",
   "description": "This project is Jolibox JS-SDk implement for Native && H5",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.2.5",
-    "@jolibox/types": "1.2.5",
-    "@jolibox/native-bridge": "1.2.5",
-    "@jolibox/ads": "1.2.5",
+    "@jolibox/common": "1.2.6",
+    "@jolibox/types": "1.2.6",
+    "@jolibox/native-bridge": "1.2.6",
+    "@jolibox/ads": "1.2.6",
     "localforage": "1.10.0",
     "@jolibox/ui": "1.0.0",
     "web-vitals": "4.2.4"

package/src/common/rewards/cached-fetch-reward.ts

@@ -16,6 +16,7 @@ const priority = () => {
   return (a: RewardType, b: RewardType) => {
     // Priority order: GEM > JOLI_COIN > ADS
     const priorityMap: Record<RewardType, number> = {
+      SUBSCRIPTION: 4,
       JOLI_GEM: 3,
       JOLI_GEM_ONLY: 3,
       JOLI_COIN: 2,
@@ -29,8 +30,24 @@ const priority = () => {
 
 const sortRewards = (rewardsTypes: RewardType[]): RewardType[] => {
   if (!rewardsTypes.length) return ['ADS'];
-  if (rewardsTypes.includes('JOLI_GEM') && rewardsTypes.length <= 1) return ['JOLI_GEM_ONLY'];
-  if (rewardsTypes.includes('JOLI_COIN') && rewardsTypes.length <= 1) return ['JOLI_COIN_ONLY'];
+
+  // Handle JOLI_GEM cases
+  if (rewardsTypes.includes('JOLI_GEM')) {
+    if (rewardsTypes.length === 1) {
+      return ['JOLI_GEM_ONLY'];
+    } else if (rewardsTypes.includes('SUBSCRIPTION') && rewardsTypes.length === 2) {
+      return ['SUBSCRIPTION', 'JOLI_GEM_ONLY'];
+    }
+  }
+
+  // Handle JOLI_COIN cases
+  if (rewardsTypes.includes('JOLI_COIN')) {
+    if (rewardsTypes.length === 1) {
+      return ['JOLI_COIN_ONLY'];
+    } else if (rewardsTypes.includes('SUBSCRIPTION') && rewardsTypes.length === 2) {
+      return ['SUBSCRIPTION', 'JOLI_COIN_ONLY'];
+    }
+  }
 
   return rewardsTypes.sort(priority());
 };

package/src/common/rewards/cached-reward-service.ts

@@ -1,4 +1,4 @@
-import { RequestCacheService, RequestAdapter } from '../cache/request-cache-service';
+import { RequestCacheService, RequestAdapter } from '@jolibox/common';
 import { IHttpClient } from '../http';
 import { StandardResponse, GlobalConfig } from '@jolibox/types';
 import { IJolicoinRewardOption, IUnlockOption, IJoliCoin, IGem } from './type';
@@ -50,8 +50,8 @@ class RewardRequestAdapter
   extractCacheableData(response: IJolicoinRewardOption): UnlockOptionsCacheData {
     return {
       unlockOptions: response.data?.unlockOptions || [],
-      joliCoin: response.extra.joliCoin,
-      joliGem: response.extra.joliGem || { balance: 0, enableAutoDeduct: false }
+      joliCoin: response.extra?.joliCoin,
+      joliGem: response.extra?.joliGem || { balance: 0, enableAutoDeduct: false }
     };
   }
 

package/src/common/rewards/index.ts

@@ -10,6 +10,7 @@ export * from './registers/use-jolicoin';
 export * from './registers/use-jolicoin-only';
 export * from './registers/use-gem';
 export * from './registers/use-gem-only';
+export * from './registers/use-subscription';
 
 export { warmupBalanceCache } from './registers/utils/coins/jolicoin/cached-fetch-balance';
 export { warmupGemBalanceCache } from './registers/utils/coins/joligem/cached-fetch-gem-balance';

package/src/common/rewards/registers/use-subscription.ts

@@ -0,0 +1,34 @@
+import { IHttpClient } from '@/common/http';
+import { IAdBreakParams } from '@/common/ads';
+import { unlockOptionsHandler } from './utils/common';
+import { createCommonSubscriptionHandler } from './utils/subscription/sub-handler';
+import { createShowSubscriptionModal } from './utils/subscription/commands/use-subscription';
+
+export type SubscriptionRewardsHandler = (params: IAdBreakParams) => Promise<boolean>;
+export const createSubscriptionRewardHandler = (
+  httpClient: IHttpClient,
+  {
+    onSubSuccess,
+    onSubFailed
+  }: {
+    onSubSuccess?: () => void;
+    onSubFailed?: () => void;
+  }
+): SubscriptionRewardsHandler => {
+  const handleUnlockFailed = () => {
+    onSubFailed?.();
+  };
+
+  const showSubscriptionModal = createShowSubscriptionModal('SUBSCRIPTION');
+
+  const subscriptionRewardHandler = createCommonSubscriptionHandler('SUBSCRIPTION', httpClient, {
+    handlers: {
+      handleSubSuccess: onSubSuccess,
+      handleSubFailed: handleUnlockFailed,
+      unlockOptionsHandler,
+      showSubscriptionModal
+    }
+  });
+
+  return subscriptionRewardHandler;
+};

package/src/common/rewards/registers/utils/coins/jolicoin/cached-fetch-balance.ts

@@ -1,4 +1,4 @@
-import { RequestCacheService, RequestAdapter } from '@/common/cache/request-cache-service';
+import { RequestCacheService, RequestAdapter } from '@jolibox/common';
 import { IHttpClient } from '@/common/http';
 import { StandardResponse } from '@jolibox/types';
 

package/src/common/rewards/registers/utils/coins/joligem/cached-fetch-gem-balance.ts

@@ -1,4 +1,4 @@
-import { RequestCacheService, RequestAdapter } from '@/common/cache/request-cache-service';
+import { RequestCacheService, RequestAdapter } from '@jolibox/common';
 import { IHttpClient } from '@/common/http';
 import { StandardResponse } from '@jolibox/types';
 

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

@@ -0,0 +1 @@
+export * from './use-subscription';

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

@@ -0,0 +1,29 @@
+import { rewardsCommands } from '../../coins/rewards-command';
+import { createEventPromiseHandler } from '../../event-listener';
+import { IUseSubscriptionResultEvent, UseSubscriptionResultEventName } from '@/common/rewards/reward-emitter';
+import { rewardsEmitter, InvokeSubscriptionEventName } from '@/common/rewards/reward-emitter';
+
+export const registerUseSubscriptionCommand = (params: {
+  showSubscriptionModal: () => Promise<'SUCCESS' | 'CANCEL' | 'FAILED'>;
+}) => {
+  const { showSubscriptionModal } = params;
+  rewardsCommands.registerCommand(`Rewards.subscription`, async () => {
+    const subscriptionResult = await showSubscriptionModal();
+    return {
+      result: subscriptionResult === 'SUCCESS' ? 'SUCCESS' : 'FAILED'
+    };
+  });
+};
+
+// EVENTS
+export const createShowSubscriptionModal = (type: 'SUBSCRIPTION') => {
+  return async () => {
+    const modalHandler = createEventPromiseHandler<
+      IUseSubscriptionResultEvent,
+      typeof UseSubscriptionResultEventName
+    >(rewardsEmitter, UseSubscriptionResultEventName);
+    rewardsEmitter.emit(InvokeSubscriptionEventName, type);
+    const modalResult = await modalHandler.getFreshData();
+    return modalResult.result;
+  };
+};

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,
@@ -24,7 +25,7 @@ import GamedistributionAdsHandler from './platformAdsHandle/GamedistributionAdsH
 import FunmaxAdsHandler from './platformAdsHandle/FunmaxAdsHandler';
 import JoliboxAdsHandler from './platformAdsHandle/JoliboxAdsHandler';
 import { warmupRewardCache } from '@/common/rewards/fetch-reward';
-import { warmupBalanceCache, warmupGemBalanceCache } from '@/common/rewards';
+import { warmupBalanceCache } from '@/common/rewards';
 
 declare global {
   interface Window {
@@ -138,6 +139,10 @@ const handleUnlockSuccess = (params: { quantity: number; balance: number }) => {
   });
 };
 
+const handleUnlockWithSubscriptionSuccess = () => {
+  track('subscription_unlock_success', {});
+};
+
 const adsManager = new H5AdsManager(adsContext);
 const adsHandler = adsManager.getAdsHandler(context.sdkEnvironment);
 
@@ -156,6 +161,13 @@ rewardsHelper.registerRewardHandler(
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
+rewardsHelper.registerRewardHandler(
+  'SUBSCRIPTION',
+  createSubscriptionRewardHandler(httpClient, {
+    onSubSuccess: handleUnlockWithSubscriptionSuccess.bind(this)
+  }) as unknown as (params?: unknown) => Promise<boolean>
+);
+
 warmupRewardCache(httpClient);
 warmupBalanceCache(httpClient);
 

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?.();
+    }
+  }
 }