@jolibox/implement 1.1.13-beta.7 → 1.1.13-beta.9

package/implement.build.log

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

package/package.json

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

package/src/common/ads/anti-cheating.ts

@@ -1,5 +1,7 @@
 import type { IHttpClient } from '../http';
 import type { Track } from '../report';
+import { getOriginalLocalStorage } from '@jolibox/common';
+getOriginalLocalStorage();
 
 export type AdsDisplayPermission =
   | 'BLOCK_INITIAL'

package/src/common/rewards/__tests__/can-use-jolicoin.test.ts

@@ -0,0 +1,94 @@
+import { IUnlockOptionType } from '../type';
+import { canUseJolicoin } from '../registers/utils';
+
+describe('canUseJolicoin', () => {
+  it('should return true when joliCoin balance is sufficient and autoDeduct is enabled', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 100 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(true);
+  });
+
+  it('should return true when joliCoin balance is more than required', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(true);
+  });
+
+  it('should return false when joliCoin balance is insufficient', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 150 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false when autoDeduct is disabled', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: false };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false when there is no JOLI_COIN option', () => {
+    const unlockOptions = [
+      {
+        type: 'ADS' as IUnlockOptionType,
+        joliCoinChoices: []
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false with empty unlockOptions', () => {
+    const unlockOptions: any[] = [];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false when joliCoin is undefined', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+      }
+    ];
+
+    expect(canUseJolicoin(unlockOptions, undefined)).toBe(false);
+  });
+
+  it('should return true when at least one choice is valid', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 200 }, { joliCoinQuantity: 50 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(true);
+  });
+});

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

@@ -0,0 +1,33 @@
+import { UnlockOptionsEventName, unlockOptionsEmitter } from '.';
+import { IHttpClient } from '../http';
+import { RewardsHelper, RewardType } from './reward-helper';
+import { IJolicoinRewardOption } from './type';
+
+const priority = () => {
+  return (a: RewardType, b: RewardType) => {
+    if (a === 'JOLI_COIN' && b === 'ADS') return -1;
+    if (a === 'ADS' && b === 'JOLI_COIN') return 1;
+    return 0;
+  };
+};
+
+export const createRewardFetcher = (rewardsHelper: RewardsHelper) => {
+  rewardsHelper.registerRewardsFetcher(async (httpClient: IHttpClient) => {
+    const defaultRewards: RewardType[] = [];
+    const res = await httpClient.post<IJolicoinRewardOption>('/api/games/unlock-options', {});
+    if (res.code !== 'SUCCESS') {
+      return defaultRewards;
+    }
+    unlockOptionsEmitter.emit(UnlockOptionsEventName, {
+      options: res.data?.unlockOptions || [],
+      userJoliCoin: res.extra?.joliCoin || {
+        balance: 0,
+        enableAutoDeduct: false
+      }
+    });
+
+    const rewardsTypes = res.data?.unlockOptions?.map((option) => option.type) || Array.from(defaultRewards);
+    // Sort reward types with JOLI_COIN having higher priority than ADS
+    return rewardsTypes.sort(priority());
+  });
+};

package/src/common/rewards/index.ts

@@ -0,0 +1,20 @@
+import { createRewardsHelper } from './reward-helper';
+import { createRewardFetcher } from './fetch-reward';
+import { EventEmitter } from '@jolibox/common';
+import { IUnlockOption, IJoliCoin } from './type';
+
+export const rewardsHelper = createRewardsHelper();
+createRewardFetcher(rewardsHelper);
+
+export * from './registers/use-ads';
+export * from './registers/use-jolicoin';
+
+export interface IUnlockOptionsEvent {
+  options: IUnlockOption[];
+  userJoliCoin: IJoliCoin;
+}
+
+export const UnlockOptionsEventName = 'UNLOCK_OPTIONS_CHANGED' as const;
+export const unlockOptionsEmitter = new EventEmitter<{
+  [UnlockOptionsEventName]: [IUnlockOptionsEvent];
+}>();

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

@@ -0,0 +1,9 @@
+import { JoliboxAdsImpl, IRewardParams } from '../../ads';
+
+export type AdsRewardsHandler = (params: IRewardParams) => Promise<boolean>;
+export const createAdsRewardHandler = (ads: JoliboxAdsImpl): AdsRewardsHandler => {
+  return async (params: IRewardParams) => {
+    ads.adBreak(params);
+    return true;
+  };
+};

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

@@ -0,0 +1,89 @@
+import { IHttpClient } from '@/common/http';
+import { context } from '@/common/context';
+import { uuidv4 } from '@jolibox/common';
+import { canUseJolicoin } from './utils';
+import { unlockOptionsEmitter, UnlockOptionsEventName, IUnlockOptionsEvent } from '..';
+
+interface IJolicoinUnlockRes {
+  code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
+  message: string;
+  data: {
+    transactionId: string;
+    quantity: number;
+    balance: number;
+  };
+}
+
+export type JolicoinRewardsHandler = () => Promise<boolean>;
+export const createJolicoinRewardHandler = (
+  httpClient: IHttpClient,
+  {
+    onUnlockSuccess,
+    onUnlockFailed
+  }: {
+    onUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
+    onUnlockFailed?: () => void;
+  }
+): JolicoinRewardsHandler => {
+  let unlockOptionsPromise: Promise<IUnlockOptionsEvent> | null = null;
+  let resolveUnlockOptions: ((value: IUnlockOptionsEvent) => void) | null = null;
+  let cachedUnlockOptions: IUnlockOptionsEvent | null = null;
+
+  const createUnlockOptionsPromise = () => {
+    if (cachedUnlockOptions) {
+      unlockOptionsPromise = Promise.resolve(cachedUnlockOptions);
+      return;
+    }
+
+    unlockOptionsPromise = new Promise<IUnlockOptionsEvent>((resolve) => {
+      resolveUnlockOptions = resolve;
+    });
+  };
+
+  createUnlockOptionsPromise();
+
+  unlockOptionsEmitter.on(UnlockOptionsEventName, (options) => {
+    cachedUnlockOptions = options;
+    if (resolveUnlockOptions) {
+      resolveUnlockOptions(options);
+      resolveUnlockOptions = null;
+    }
+  });
+
+  return async () => {
+    try {
+      if (!unlockOptionsPromise) {
+        createUnlockOptionsPromise();
+      }
+      const unlockOptions = await unlockOptionsPromise!;
+      if (!canUseJolicoin(unlockOptions?.options || [], unlockOptions?.userJoliCoin)) {
+        onUnlockFailed?.();
+        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
+          }
+        }
+      });
+      if (unlockWithJolicoin.code == 'SUCCESS') {
+        onUnlockSuccess?.({
+          quantity: unlockWithJolicoin.data.quantity,
+          balance: unlockWithJolicoin.data.balance
+        });
+        return true;
+      }
+      onUnlockFailed?.();
+      return false;
+    } catch (e) {
+      console.error(`JolicoinRewardHandler error:`, e);
+      onUnlockFailed?.();
+      return false;
+    }
+  };
+};

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

@@ -0,0 +1,11 @@
+import { IJoliCoin, IUnlockOption } from '@/common/rewards/type';
+
+export const canUseJolicoin = (unlockOptions: IUnlockOption[], joliCoin?: IJoliCoin) => {
+  return unlockOptions.some(
+    (option) =>
+      option.type === 'JOLI_COIN' &&
+      option.joliCoinChoices.some(
+        (choice) => choice.joliCoinQuantity <= (joliCoin?.balance ?? 0) && !!joliCoin?.enableAutoDeduct
+      )
+  );
+};

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

@@ -0,0 +1,56 @@
+export type RewardType = 'ADS' | 'JOLI_COIN';
+
+import { context } from '../context';
+import type { AdsRewardsHandler } from './registers/use-ads';
+
+export interface RewardHandlerMap {
+  ADS: AdsRewardsHandler;
+  JOLI_COIN: (params?: unknown) => Promise<boolean>;
+}
+
+export type RewardHandler<T extends RewardType> = RewardHandlerMap[T];
+
+const isTestMode = context.testMode;
+export function createRewardsHelper() {
+  const rewardsHandlers = new Map<RewardType, RewardHandler<any>>();
+  let rewardFetcher: ((...args: any[]) => Promise<RewardType[]>) | undefined;
+
+  return {
+    registerRewardHandler<T extends RewardType>(type: T, handler: RewardHandler<T>) {
+      rewardsHandlers.set(type, handler);
+    },
+    async handleReward<T extends RewardType>(rewardsTypes: T[], ...args: Parameters<RewardHandler<T>>) {
+      const result = await rewardsTypes.reduce(async (prevPromise, type) => {
+        const prevResult = await prevPromise;
+        if (prevResult === true) return true;
+
+        isTestMode && console.log(`handleReward ${type}`);
+        const handler = rewardsHandlers.get(type);
+        const nextResult = handler ? await handler(...args) : prevResult;
+        isTestMode && console.log(`handleReward ${type} ${nextResult}`);
+        return nextResult;
+      }, Promise.resolve(false));
+
+      return result;
+    },
+    async registerRewardsFetcher<T extends RewardType>(fetcher: (...args: any[]) => Promise<T[]>) {
+      rewardFetcher = async (...args: unknown[]) => {
+        try {
+          const rewardsTypes = await fetcher(...args);
+          return rewardsTypes;
+        } catch (e) {
+          console.error(`getRewardOptions error:`, e);
+          return ['ADS'];
+        }
+      };
+    },
+    async getRewardsTypes(...args: unknown[]): Promise<RewardType[]> {
+      if (!rewardFetcher) {
+        return ['ADS'];
+      }
+      return await rewardFetcher(...args);
+    }
+  };
+}
+
+export type RewardsHelper = ReturnType<typeof createRewardsHelper>;

package/src/common/rewards/type.ts

@@ -0,0 +1,25 @@
+export interface IJoliCoin {
+  balance: number;
+  enableAutoDeduct: boolean;
+}
+
+export type IUnlockOptionType = 'JOLI_COIN' | 'ADS';
+
+interface IJoliCoinChoice {
+  joliCoinQuantity: number;
+}
+export interface IUnlockOption {
+  type: IUnlockOptionType;
+  joliCoinChoices: IJoliCoinChoice[];
+}
+
+export interface IJolicoinRewardOption {
+  code: 'SUCCESS' | 'ERROR' | 'PARAMETER_ERROR' | 'EPISODE_LOCK_JUMP';
+  message: string;
+  data: {
+    unlockOptions?: IUnlockOption[];
+  };
+  extra: {
+    joliCoin: IJoliCoin;
+  };
+}

package/src/common/utils/index.ts

@@ -1,9 +1,16 @@
 const JOLIBOX_CUSTOM_ADS_EVENT_TYPE = 'JOLIBOX_ADS_EVENT';
+const JOLIBOX_CUSTOM_REWARDS_EVENT_TYPE = 'JOLIBOX_CUSTOM_REWARDS_EVENT';
 
 interface JoliboxCustomEvent {
   [JOLIBOX_CUSTOM_ADS_EVENT_TYPE]: {
     isAdShowing: boolean;
   };
+  [JOLIBOX_CUSTOM_REWARDS_EVENT_TYPE]: {
+    ['JOLI_COIN']?: {
+      quantity: number;
+      balance: number;
+    };
+  };
 }
 
 export const notifyCustomEvent = <T extends keyof JoliboxCustomEvent>(

package/src/h5/api/ads.ts

@@ -3,10 +3,23 @@ import { track } from '../report';
 import { createCommands } from '@jolibox/common';
 import { httpClientManager } from '../http';
 import { notifyCustomEvent } from '@/common/utils';
+import { createAdsRewardHandler, rewardsHelper, createJolicoinRewardHandler } from '@/common/rewards';
+
 const commands = createCommands();
 
 const httpClient = httpClientManager.create();
 const ads = new JoliboxAdsImpl(track, httpClient, () => httpClientManager.getNetworkStatus());
+rewardsHelper.registerRewardHandler('ADS', createAdsRewardHandler(ads));
+rewardsHelper.registerRewardHandler(
+  'JOLI_COIN',
+  createJolicoinRewardHandler(ads.httpClient, {
+    onUnlockSuccess: (params: { quantity: number; balance: number }) => {
+      notifyCustomEvent('JOLIBOX_CUSTOM_REWARDS_EVENT', {
+        JOLI_COIN: params
+      });
+    }
+  })
+);
 
 adEventEmitter.on('isAdShowing', (isAdShowing) => {
   notifyCustomEvent('JOLIBOX_ADS_EVENT', { isAdShowing });
@@ -21,7 +34,13 @@ commands.registerCommand('AdsSDK.adConfig', (params) => {
 });
 
 commands.registerCommand('AdsSDK.adBreak', (params) => {
-  ads.adBreak(params);
+  if (params.type === 'reward') {
+    rewardsHelper.getRewardsTypes(ads.httpClient).then((rewardsTypes) => {
+      rewardsHelper.handleReward(rewardsTypes, params);
+    });
+  } else {
+    ads.adBreak(params);
+  }
 });
 
 commands.registerCommand('AdsSDK.adUnit', (params) => {

package/src/h5/api/get-system-info.ts

@@ -11,7 +11,7 @@ const API_GET_SYSTEM_SYNC = 'getSystemInfoSync';
 const getSystemInfo = () => {
   let config = {
     system: context.deviceInfo.system,
-    platform: context.deviceInfo.platform,
+    platform: context.deviceInfo.platform.toLowerCase(),
     brand: context.deviceInfo.brand,
     pixelRatio: context.deviceInfo.pixelRatio,
     language: context.deviceInfo.lang,

package/src/native/api/ads.ts

@@ -1,5 +1,6 @@
 import { createCommands } from '@jolibox/common';
 import { createSyncAPI, registerCanIUse } from './base';
+import { createToast } from '@jolibox/ui';
 
 const commands = createCommands();
 
@@ -8,6 +9,7 @@ import { track } from '../report';
 
 import { innerFetch as fetch } from '../network';
 import { invokeNative } from '@jolibox/native-bridge';
+import { rewardsHelper, createAdsRewardHandler, createJolicoinRewardHandler } from '@/common/rewards';
 
 const checkNetworkStatus = () => {
   const { data } = invokeNative('getNetworkStatusSync');
@@ -34,6 +36,26 @@ const ads = new JoliboxAdsImpl(
   checkNetworkStatus
 );
 
+rewardsHelper.registerRewardHandler('ADS', createAdsRewardHandler(ads));
+rewardsHelper.registerRewardHandler(
+  'JOLI_COIN',
+  createJolicoinRewardHandler(ads.httpClient, {
+    onUnlockSuccess: (params) => {
+      const { quantity, balance } = params;
+      const balanceStr = balance >= 1000 ? '999+' : balance;
+      createToast(`{slot-checkmark}  −${quantity} {slot-coin} | Balance: ${balanceStr} {slot-coin}`, {
+        customStyle: {
+          mark: {
+            marginRight: '8px'
+          }
+        }
+      });
+    },
+    onUnlockFailed: () => {
+      console.log('onUnlockFailed');
+    }
+  })
+);
 const adInit = createSyncAPI('adInit', {
   implement: (config?: IAdsInitParams) => {
     ads.init(config);
@@ -48,7 +70,13 @@ const adConfig = createSyncAPI('adConfig', {
 
 const adBreak = createSyncAPI('adBreak', {
   implement: (params: IAdBreakParams) => {
-    ads.adBreak(params);
+    if (params.type === 'reward') {
+      rewardsHelper.getRewardsTypes(ads.httpClient).then((rewardsTypes) => {
+        rewardsHelper.handleReward(rewardsTypes, params);
+      });
+    } else {
+      ads.adBreak(params);
+    }
   }
 });
 

package/src/native/api/get-system-info.ts

@@ -13,7 +13,7 @@ const getSystemInfoSync = createSyncAPI(API_GET_SYSTEM_SYNC, {
     const { data } = res;
     return {
       system: data.deviceInfo.system,
-      platform: data.deviceInfo.platform,
+      platform: data.deviceInfo.platform.toLowerCase() as 'h5' | 'android' | 'ios',
       version: data.sdkInfo.jssdkVersion,
       pixelRatio: data.deviceInfo.pixelRatio,
       language: data.deviceInfo.lang,

package/src/native/network/create-fetch.ts

@@ -82,7 +82,11 @@ export function createFetch(
 
     if (res.state === 'success') {
       const { requestTaskId, state, ...rest } = res;
-      task.resolve(rest);
+      if (res.statusCode === 200) {
+        task.resolve(rest);
+      } else {
+        task.reject(rest);
+      }
       promiseMap.delete(requestTaskId);
     } else if (res.state === 'fail') {
       const { requestTaskId, state, ...rest } = res;

package/src/native/ui/retention.ts

@@ -50,10 +50,11 @@ const openGameSchema = (game: IGame) => {
   // Parse the original URL to preserve its structure
 
   const url = new URL(data.schema);
+  const originalPath = url.pathname;
   const originalSearch = new URLSearchParams(url.search);
 
   // Set or replace gameId and joliSource parameters
-  originalSearch.set('gameId', game.gameId);
+  originalSearch.set('gameId', context.mpId);
   originalSearch.set(
     'joliSource',
     context.encodeJoliSourceQuery({
@@ -64,7 +65,7 @@ const openGameSchema = (game: IGame) => {
 
   const host = `https://${game.gameId}.content.jolibox.com/`;
   // Construct the final schema URL
-  const schema = `${host}index.html?${originalSearch.toString()}`;
+  const schema = `${host}${originalPath}?${originalSearch.toString()}`;
 
   invokeNative('openSchemaSync', {
     schema