@jolibox/implement 1.1.24 → 1.1.26

package/dist/native/api/base.d.ts

@@ -1,6 +1,6 @@
 export declare const createAPI: <ParamsSchema extends import("@/common/api-factory/validator").Validator<unknown[]>, Inputs extends import("@/common/api-factory/validator").Type<ParamsSchema> & unknown[], Return>(method: string, config: {
     paramsSchema?: ParamsSchema;
-    implement: Inputs extends undefined ? () => Promise<Return | import("@jolibox/types").StandardResponse<Return>> : (...params: Inputs) => Promise<Return | import("@jolibox/types").StandardResponse<Return>>;
+    implement: Inputs extends undefined ? () => Promise<Return | import("@jolibox/types").StandardResponse<Return, unknown>> : (...params: Inputs) => Promise<Return | import("@jolibox/types").StandardResponse<Return, unknown>>;
 }) => (...inputs: unknown[]) => Promise<import("@jolibox/types").StandardResponse<Return>>, createSyncAPI: <ParamsSchema extends import("@/common/api-factory/validator").Validator<unknown[]>, Inputs extends import("@/common/api-factory/validator").Type<ParamsSchema> & unknown[], Return = void>(method: string, config: {
     paramsSchema?: ParamsSchema;
     implement: (...inputs: Inputs) => Return | {

package/dist/native/api/keyboard.d.ts

@@ -2,8 +2,8 @@ export declare const showKeyboard: (params: {
     defaultValue?: string | undefined;
     multiple?: boolean | undefined;
     maxLength?: unknown;
-}) => import("@jolibox/types").StandardResponse<void>;
+}) => import("@jolibox/types").StandardResponse<void, unknown>;
 export declare const updateKeyboard: (params: {
     value: string;
-}) => import("@jolibox/types").StandardResponse<void>;
-export declare const hideKeyboard: () => import("@jolibox/types").StandardResponse<void>;
+}) => import("@jolibox/types").StandardResponse<void, unknown>;
+export declare const hideKeyboard: () => import("@jolibox/types").StandardResponse<void, unknown>;

package/dist/native/api/login.d.ts

@@ -1,4 +1,4 @@
 export declare const login: (...inputs: unknown[]) => Promise<import("@jolibox/types").StandardResponse<{
     isLogin: boolean;
     token?: string;
-}>>;
+}, unknown>>;

package/dist/native/api/storage.d.ts

@@ -2,7 +2,7 @@ import { StandardResponse } from '@jolibox/types';
 /**
  * 移除指定key
  */
-export declare const removeStorage: (...inputs: unknown[]) => Promise<StandardResponse<void>>;
+export declare const removeStorage: (...inputs: unknown[]) => Promise<StandardResponse<void, unknown>>;
 /**
  * 异步获取当前storage的相关信息
  */
@@ -10,7 +10,7 @@ export declare const getStorageInfo: (...inputs: unknown[]) => Promise<StandardR
     currentSize: number;
     limitSize: number;
     keys: string[];
-}>>;
+}, unknown>>;
 /**
  * 同步获取当前storage的相关信息
  */
@@ -22,9 +22,9 @@ export declare const getStorageInfoSync: () => StandardResponse<{
         limitSize: number;
         keys: string[];
     };
-}>;
-export declare const getGlobalStorage: (...inputs: unknown[]) => Promise<StandardResponse<any>>;
+}, unknown>;
+export declare const getGlobalStorage: (...inputs: unknown[]) => Promise<StandardResponse<any, unknown>>;
 export declare const setGlobalStorage: (...inputs: unknown[]) => Promise<StandardResponse<{
     code: string;
     message: string;
-}>>;
+}, unknown>>;

package/dist/native/payment/index.d.ts

@@ -0,0 +1,4 @@
+export declare const paymentHelper: {
+    registerPaymentHandler<T extends import("./payment-helper").PaymentType>(type: T, handler: import("./payment-helper").PaymentHandler<T>): void;
+    invokePayment<T extends import("./payment-helper").PaymentType>(type: T, ...args: Parameters<import("./payment-helper").PaymentHandler<T>>): Promise<any>;
+};

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

@@ -0,0 +1,13 @@
+export type PaymentType = 'JOLI_COIN';
+import { StandardResponse } from '@jolibox/types';
+type PaymentResult = StandardResponse<void>;
+export interface PaymentHandlerMap {
+    JOLI_COIN: (productId: string) => Promise<PaymentResult>;
+}
+export type PaymentHandler<T extends PaymentType> = PaymentHandlerMap[T];
+export declare function createPaymentHelper(): {
+    registerPaymentHandler<T extends PaymentType>(type: T, handler: PaymentHandler<T>): void;
+    invokePayment<T extends PaymentType>(type: T, ...args: Parameters<PaymentHandler<T>>): Promise<any>;
+};
+export type PaymentHelper = ReturnType<typeof createPaymentHelper>;
+export {};

package/dist/native/payment/registers/base.d.ts

@@ -0,0 +1,21 @@
+import { StandardResponse } from '@jolibox/types';
+import type { IPlaceOrderJoliCoinParamas, IJoliCoinProductInfo, IJolicoinPaymentContext } from './joli-coin';
+import type { IPlaceOrderResponse } from './type';
+type PaymentStatus = 'INIT' | 'PENDING' | 'SUCCESS' | 'FAILED';
+import { UserPaymentError, InternalPaymentError } from '@jolibox/common';
+type IPlaceOrderParams = IPlaceOrderJoliCoinParamas;
+type IOrderProductInfo = IJoliCoinProductInfo;
+type IOrderPaymentContext = IJolicoinPaymentContext;
+declare const createPaymentError: (errMsg: string, errNo: number, extra?: Record<string, unknown>) => UserPaymentError | InternalPaymentError, createPaymentInternalError: (errMsg: string, errNo: number, extra?: Record<string, unknown>) => UserPaymentError | InternalPaymentError;
+export { createPaymentError, createPaymentInternalError };
+export declare abstract class BasePaymentRegister<T extends IPlaceOrderParams, E extends IOrderProductInfo> {
+    private _orderId;
+    private _orderStatus;
+    startPayment: (params: T) => Promise<void>;
+    cancelOrder: (orderId: string) => Promise<void>;
+    private generateCallbackUrl;
+    abstract placeOrder(params: T): Promise<StandardResponse<IPlaceOrderResponse<E>>>;
+    abstract generatePaymentContext(): IOrderPaymentContext;
+    get orderId(): string | null;
+    get status(): PaymentStatus;
+}

package/dist/native/payment/registers/joli-coin.d.ts

@@ -0,0 +1,17 @@
+import { ResponseType } from '@jolibox/types';
+export interface IPlaceOrderJoliCoinParamas {
+    productId: string;
+}
+export interface IJoliCoinProductInfo {
+    quantity: number;
+}
+export interface IJolicoinPaymentContext {
+    type: 'JOLI_COIN_ORDER_CONTEXT';
+    state: 'TO_CHECKOUT' | 'TO_VALIDATE';
+    productId: string;
+    orderId: string;
+}
+export declare const createJolicoinPaymentHandler: () => (productId: string) => Promise<{
+    code: ResponseType;
+    message: string;
+}>;

package/dist/native/payment/registers/type.d.ts

@@ -0,0 +1,14 @@
+type OrderStatus = 'PENDING' | 'PAYING' | 'PAYMENT_FAILED' | 'PAYMENT_SUCCESS' | 'PAYMENT_CLOSED';
+export interface IPlaceOrderResponse<T> {
+    orderId: string;
+    status: OrderStatus;
+    totalAmountStr: string;
+    joliBizType: 'DRAMA' | 'JOLI_COIN';
+    productInfo: T;
+}
+export declare enum PaymentErrorCodeMap {
+    PlaceOrderFailed = 1001,
+    JolicoinPlaceOrderRequestFailed = 1002,
+    CancelOrderFailed = 1003
+}
+export {};

package/dist/native/report/task-tracker.d.ts

@@ -5,7 +5,7 @@ import { TaskTracker, TaskPoint } from '@/common/report/task-track';
 import { EventEmitter } from '@jolibox/common';
 import type { Track } from '.';
 import type { TrackEvent } from '@jolibox/types';
-type NativeTaskPointEvent = 'OpenGame' | 'CloseGame' | 'LevelFinished' | 'TaskFinished' | 'LevelUpgrade' | 'HistoryUserLevel' | 'HistoryUserScore' | 'UseGameItem' | 'TaskEvent';
+type NativeTaskPointEvent = 'OpenGame' | 'CloseGame' | 'LevelFinished' | 'TaskFinished' | 'LevelUpgrade' | 'HistoryUserLevel' | 'HistoryUserScore' | 'UseGameItem' | 'GameTaskEvent';
 export type NativeTaskPoint = {
     event: NativeTaskPointEvent;
     params: Record<string, unknown>;

package/implement.build.log

@@ -1,9 +1,9 @@
 Invoking: npm run clean && npm run build:esm && tsc 
 
-> @jolibox/implement@1.1.24 clean
+> @jolibox/implement@1.1.26 clean
 > rimraf ./dist
 
 
-> @jolibox/implement@1.1.24 build:esm
+> @jolibox/implement@1.1.26 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.1.24",
+  "version": "1.1.26",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.1.24",
-    "@jolibox/types": "1.1.24",
-    "@jolibox/native-bridge": "1.1.24",
-    "@jolibox/ads": "1.1.24",
+    "@jolibox/common": "1.1.26",
+    "@jolibox/types": "1.1.26",
+    "@jolibox/native-bridge": "1.1.26",
+    "@jolibox/ads": "1.1.26",
     "localforage": "1.10.0",
     "@jolibox/ui": "1.0.0",
     "web-vitals": "4.2.4"

package/src/common/context/index.ts

@@ -112,6 +112,9 @@ const wrapContext = () => {
     get adId(): string {
       return env.deviceInfo.adId ?? env.deviceInfo.did;
     },
+    get language(): string {
+      return env.deviceInfo.lang;
+    },
     onEnvConfigChanged: (newConfig: Partial<Env>) => {
       mergeWith(env, newConfig, mergeArray);
     },

package/src/common/context/url-parse.ts

@@ -22,6 +22,7 @@ interface PayloadJson {
   __from?: number; // 从哪个小程序打开的
   __testAdsMode?: boolean;
   __joliboxEnv?: 'staging' | 'production';
+  [property: string]: any;
 }
 
 interface Signature {

package/src/common/report/task-track/index.ts

@@ -6,9 +6,10 @@ type TaskEvent =
   | 'PLAY_GAME'
   | 'CLOSE_GAME'
   | 'COMPLETE_GAME_LEVEL'
-  | 'USE_GAME_ITEM' // 使用道具
+  | 'USE_GAME_ITEM' // TODO: deprecate
   | 'IN_GAME_PURCHASES' // 游戏内购
-  | 'ADS_UNLOCK_GAME'; // 广告解锁
+  | 'ADS_UNLOCK_GAME' // 广告解锁
+  | 'GAME_TASK_EVENT'; // 关卡行为
 export type TaskPoint = {
   event: TaskEvent;
   params?: Record<string, unknown>;
@@ -76,7 +77,8 @@ export abstract class TaskTracker {
       const deltaTime = currentTime - lastTime;
       if (deltaTime >= this.interval) {
         if (this.visible) {
-          totalTime += deltaTime;
+          // Flutter WebView affects the execution of setInterval timing tasks. Here we do a simple handling. Each totalTime can accumulate at most this.interval + 1s
+          totalTime += Math.min(deltaTime, this.interval + 1000);
           callback(totalTime);
         }
         lastTime = currentTime;

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

@@ -34,13 +34,13 @@ export const createJolicoinOnlyRewardHandler = (
   })();
 
   const showUnlockWithJolicoinModal = createShowUnlockWithJolicoinModal('JOLI_COIN', {
-    confirmButtonText: 'Use Jolicoin',
-    cancelButtonText: 'No thanks'
+    confirmButtonText: 'jolicoin.useJolicoin',
+    cancelButtonText: 'jolicoin.noThanks'
   });
 
   const initiateAndAwaitPayment = createInitiateAndAwaitPayment('JOLI_COIN', {
-    confirmButtonText: 'Pay and unlock',
-    cancelButtonText: 'No thanks'
+    confirmButtonText: 'jolicoin.payAndUnlock',
+    cancelButtonText: 'jolicoin.noThanks'
   });
 
   const jolicoinOnlyRewardHandler = createCommonJolicoinRewardHandler(httpClient, {

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

@@ -26,13 +26,13 @@ export const createJolicoinRewardHandler = (
   };
 
   const showUnlockWithJolicoinModal = createShowUnlockWithJolicoinModal('ADS-JOLI_COIN', {
-    confirmButtonText: 'Use Jolicoin',
-    cancelButtonText: 'No watch ads'
+    confirmButtonText: 'jolicoin.useJolicoin',
+    cancelButtonText: 'jolicoin.noWatchAds'
   });
 
   const initiateAndAwaitPayment = createInitiateAndAwaitPayment('ADS-JOLI_COIN', {
-    confirmButtonText: 'Pay and unlock',
-    cancelButtonText: 'No watch ads'
+    confirmButtonText: 'jolicoin.payAndUnlock',
+    cancelButtonText: 'jolicoin.noWatchAds'
   });
 
   const jolicoinOnlyRewardHandler = createCommonJolicoinRewardHandler(httpClient, {

package/src/h5/api/task.ts

@@ -1,5 +1,4 @@
 import { createCommands, logger } from '@jolibox/common';
-
 import { createAPI, registerCanIUse, t } from './base';
 import { taskTracker } from '../report';
 
@@ -7,184 +6,97 @@ const commands = createCommands();
 
 const onLevelFinished = createAPI('levelFinished', {
   paramsSchema: t.tuple(
-    t.string(),
     t.object({
-      result: t.boolean(),
-      duration: t.number()
+      levelId: t.or(t.string(), t.number()),
+      duration: t.number().optional(),
+      rating: t.number().optional(),
+      score: t.number().optional()
     })
   ),
-  implement: async (levelId, parmas) => {
-    const { result, duration } = parmas;
-    logger.info(`onLevelFinished`, result, duration);
+  implement: async (parmas) => {
+    const { levelId, duration, rating, score } = parmas;
+    logger.info(`onLevelFinished`, duration, rating, score);
     await Promise.all([
       taskTracker.reporter({
         event: 'COMPLETE_GAME_LEVEL'
       }),
       taskTracker.tracker('LevelFinished', {
         levelId,
-        result,
-        duration
+        duration,
+        rating,
+        score
       })
     ]);
   }
 });
 
-const onTaskFinished = createAPI('taskFinished', {
+const onGamePlayEnded = createAPI('gamePlayEnded', {
   paramsSchema: t.tuple(
-    t.string(),
     t.object({
-      duration: t.number()
+      duration: t.number().optional(),
+      rating: t.number().optional(),
+      score: t.number()
     })
   ),
-  implement: async (taskId, params) => {
-    const { duration } = params;
-    await taskTracker.tracker('TaskFinished', {
+  implement: async (params) => {
+    const { duration, rating, score } = params;
+    logger.info(`onGamePlayEnded`, duration, rating, score);
+    return taskTracker.tracker('GamePlayEnded', {
       duration,
-      taskId
-    });
-  }
-});
-
-const onLevelUpgrade = createAPI('levelUpgrade', {
-  paramsSchema: t.tuple(t.string(), t.string()),
-  implement: async (levelId, name) => {
-    return await taskTracker.tracker('LevelUpgrade', {
-      name,
-      levelId
-    });
-  }
-});
-
-const onHistoryUserLevel = createAPI('onHistoryUserLevel', {
-  paramsSchema: t.tuple(t.number()),
-  implement: async (level) => {
-    return await taskTracker.tracker('HistoryUserLevel', {
-      level
-    });
-  }
-});
-
-const onHistoryUserScore = createAPI('onHistoryUserScore', {
-  paramsSchema: t.tuple(t.number()),
-  implement: async (score) => {
-    return await taskTracker.tracker('HistoryUserScore', {
+      rating,
       score
     });
   }
 });
 
-const onTaskEvent = createAPI('taskEvent', {
+const onLevelUpgrade = createAPI('levelUpgrade', {
   paramsSchema: t.tuple(
-    t.string(),
     t.object({
-      tools: t
-        .array(
-          t.object({
-            id: t.string(),
-            name: t.string(),
-            count: t.number(),
-            description: t.string().optional(),
-            price: t
-              .object({
-                amount: t.number(),
-                unit: t.string()
-              })
-              .optional()
-          })
-        )
-        .optional(),
-      awards: t
-        .array(
-          t.object({
-            id: t.string(),
-            name: t.string()
-          })
-        )
-        .optional()
+      levelId: t.or(t.string(), t.number()),
+      name: t.string().optional()
     })
   ),
-  implement: async (taskId, params) => {
-    if (params.tools?.length) {
-      await Promise.all([
-        taskTracker.reporter({
-          event: 'USE_GAME_ITEM'
-        }),
-        taskTracker.tracker('UseGameItem', {
-          taskId,
-          ...params
-        })
-      ]);
-    }
+  implement: async ({ levelId, name }) => {
+    return taskTracker.tracker('LevelUpgrade', {
+      name,
+      levelId
+    });
   }
 });
 
 commands.registerCommand('TaskTrackerSDK.levelFinished', onLevelFinished);
-commands.registerCommand('TaskTrackerSDK.taskFinished', onTaskFinished);
+commands.registerCommand('TaskTrackerSDK.gamePlayEnded', onGamePlayEnded);
 commands.registerCommand('TaskTrackerSDK.levelUpgrade', onLevelUpgrade);
-commands.registerCommand('TaskTrackerSDK.historyUserLevel', onHistoryUserLevel);
-commands.registerCommand('TaskTrackerSDK.historyUserScore', onHistoryUserScore);
-commands.registerCommand('TaskTrackerSDK.taskEvent', onTaskEvent);
 
 registerCanIUse('TaskTrackerSDK.onLevelFinished', {
-  version: '1.0.0',
+  version: '1.1.25',
   properties: {
-    levelId: '1.0.0',
     params: {
-      result: '1.0.0',
-      duration: '1.0.0'
+      levelId: '1.1.25',
+      duration: '1.1.25',
+      rating: '1.1.25',
+      score: '1.1.25'
     }
   }
 });
 
-registerCanIUse('TaskTrackerSDK.onTaskFinished', {
-  version: '1.0.0',
+registerCanIUse('TaskTrackerSDK.onGamePlayEnded', {
+  version: '1.1.25',
   properties: {
-    taskId: '1.0.0',
-    duration: '1.0.0'
+    params: {
+      duration: '1.1.25',
+      rating: '1.1.25',
+      score: '1.1.25'
+    }
   }
 });
 
 registerCanIUse('TaskTrackerSDK.onLevelUpgrade', {
-  version: '1.0.0',
-  properties: {
-    levelId: '1.0.0',
-    name: '1.0.0'
-  }
-});
-
-registerCanIUse('TaskTrackerSDK.onHistoryUserLevel', {
-  version: '1.0.0',
-  properties: {
-    level: '1.0.0'
-  }
-});
-
-registerCanIUse('TaskTrackerSDK.onHistoryUserScore', {
-  version: '1.0.0',
-  properties: {
-    score: '1.0.0'
-  }
-});
-
-registerCanIUse('TaskTrackerSDK.onTaskEvent', {
-  version: '1.0.0',
+  version: '1.1.25',
   properties: {
-    taskId: '1.0.0',
     params: {
-      tools: {
-        id: '1.0.0',
-        name: '1.0.0',
-        count: '1.0.0',
-        description: '1.0.0',
-        price: {
-          amount: '1.0.0',
-          unit: '1.0.0'
-        }
-      },
-      awards: {
-        id: '1.0.0',
-        name: '1.0.0'
-      }
+      levelId: '1.1.25',
+      name: '1.1.25'
     }
   }
 });

package/src/native/api/ads.ts

@@ -107,12 +107,15 @@ rewardsHelper.registerRewardHandler(
 
 const showUnlockSuccessToast = (params: { quantity: number; balance: number }) => {
   const { quantity } = params;
-  const toastTemplate = `{slot-coin} ${quantity} JoliCoins used`;
+  const toastTemplate = `{slot-coin} ${quantity} {slot-i18n-jolicoin.coinUsed}`;
   createToast(toastTemplate, {
     customStyle: {
       mark: {
         marginRight: '8px'
       }
+    },
+    i18nParams: {
+      text: 'Jolicoin Used'
     }
   });
 };

package/src/native/api/storage.ts

@@ -232,11 +232,11 @@ const DATA_TYPE = [
 type DataType = typeof DATA_TYPE[number];
 
 function getType(data: unknown): DataType {
-  const type = Object.prototype.toString
-    .call(data)
-    .split(' ')[1]
-    .split(']')[0]
-    .toLocaleLowerCase() as DataType;
+  let type = Object.prototype.toString.call(data).split(' ')[1].split(']')[0].toLocaleLowerCase() as DataType;
+
+  if ((type as string) === 'array') {
+    type = 'object' as DataType;
+  }
 
   if (DATA_TYPE.includes(type)) {
     return type;
@@ -290,7 +290,9 @@ export const getGlobalStorage = createAPI('getGlobalStorage', {
   paramsSchema: t.tuple(t.string()),
   async implement(key) {
     try {
-      const { data, dataType } = await applyNative('getGlobalStorageAsync', { key });
+      const {
+        data: { data, dataType }
+      } = await applyNative('getGlobalStorageAsync', { key });
       const parsedData = parse(data, dataType);
       return {
         code: 'SUCCESS',
@@ -308,7 +310,7 @@ export const getGlobalStorage = createAPI('getGlobalStorage', {
 });
 
 export const setGlobalStorage = createAPI('setGlobalStorage', {
-  paramsSchema: t.tuple(t.string(), t.or(t.string(), t.boolean(), t.number())),
+  paramsSchema: t.tuple(t.string(), t.or(t.string(), t.boolean(), t.number(), t.array())),
   async implement(key, value) {
     try {
       const dataType = getType(value);