@jolibox/implement 1.2.3 → 1.2.4

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

@@ -10,3 +10,4 @@ import './navigate';
 import './runtime';
 import './is-native-support';
 import './call-host-method';
+import './payment';

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

@@ -0,0 +1 @@
+export {};

package/dist/native/payment/__tests__/payment-service-simple.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,16 +1,20 @@
 export type PaymentType = 'JOLI_COIN' | 'JOLI_COIN_IAP' | 'JOLI_GEM_IAP';
 import { StandardResponse } from '@jolibox/types';
-type PaymentResult = StandardResponse<void>;
+export type PaymentResult<T> = StandardResponse<T>;
 export interface PaymentHandlerMap {
-    JOLI_COIN: (productId: string) => Promise<PaymentResult>;
+    JOLI_COIN: (productId: string) => Promise<PaymentResult<void>>;
     JOLI_COIN_IAP: (params: {
         productId: string;
         appStoreProductId: string;
-    }) => Promise<PaymentResult>;
+    }) => Promise<PaymentResult<{
+        totalAmount: string;
+    }>>;
     JOLI_GEM_IAP: (params: {
         productId: string;
         appStoreProductId: string;
-    }) => Promise<PaymentResult>;
+    }) => Promise<PaymentResult<{
+        totalAmount: string;
+    }>>;
 }
 export type PaymentHandler<T extends PaymentType> = PaymentHandlerMap[T];
 export declare function createPaymentHelper(): {
@@ -18,4 +22,3 @@ export declare function createPaymentHelper(): {
     invokePayment<T extends PaymentType>(type: T, ...args: Parameters<PaymentHandler<T>>): Promise<any>;
 };
 export type PaymentHelper = ReturnType<typeof createPaymentHelper>;
-export {};

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

@@ -0,0 +1,38 @@
+import { IPaymentChoice } from '@/common/rewards/reward-emitter';
+import type { PaymentResult } from './payment-helper';
+type PaymentPurchaseType = 'JOLI_COIN' | 'JOLI_GEM';
+export interface CachedPaymentChoices {
+    choices: IPaymentChoice[];
+    timestamp: number;
+    expiresAt: number;
+    productIds: string[];
+}
+export declare class PaymentService {
+    private productInfoCache;
+    private static paymentChoicesCache;
+    private static readonly PAYMENT_CHOICES_CACHE_DURATION;
+    getJolicoinProductsInfo(type: PaymentPurchaseType): Promise<IPaymentChoice[]>;
+    purchase(type: PaymentPurchaseType, productId: string): Promise<PaymentResult<{
+        totalAmount: string;
+    }>>;
+    private static mergeResponseData;
+    static getProductsInfo(apiEndpoint: string): Promise<{
+        balance: number;
+        enableAutoDeduct: boolean;
+        paymentChoices: IPaymentChoice[];
+    } | undefined>;
+    private static getProductsInfoInternal;
+    private static getPaymentChoicesFromCache;
+    private static cachePaymentChoices;
+    private static extractProductIds;
+    private static arraysEqual;
+    private static updateChoicesWithServerData;
+    static clearPaymentChoicesCache(apiEndpoint?: string): void;
+    static getPaymentChoicesCacheStats(): {
+        cacheCount: number;
+        validCount: number;
+        expiredCount: number;
+    };
+    static clearExpiredPaymentChoicesCache(): void;
+}
+export {};

package/implement.build.log

@@ -1,9 +1,9 @@
 Invoking: npm run clean && npm run build:esm && tsc 
 
-> @jolibox/implement@1.2.3 clean
+> @jolibox/implement@1.2.4 clean
 > rimraf ./dist
 
 
-> @jolibox/implement@1.2.3 build:esm
+> @jolibox/implement@1.2.4 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.3",
+  "version": "1.2.4",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.2.3",
-    "@jolibox/types": "1.2.3",
-    "@jolibox/native-bridge": "1.2.3",
-    "@jolibox/ads": "1.2.3",
+    "@jolibox/common": "1.2.4",
+    "@jolibox/types": "1.2.4",
+    "@jolibox/native-bridge": "1.2.4",
+    "@jolibox/ads": "1.2.4",
     "localforage": "1.10.0",
     "@jolibox/ui": "1.0.0",
     "web-vitals": "4.2.4"
@@ -17,6 +17,7 @@
   "devDependencies": {
     "typescript": "5.7.3",
     "@types/jest": "28.1.1",
+    "@types/node": "18.0.0",
     "rimraf": "6.0.1",
     "esbuild": "0.24.2",
     "@jolibox/eslint-config": "1.0.0"

package/src/common/context/index.ts

@@ -49,6 +49,11 @@ type Viewport = {
   navigationBarHeight: number;
 };
 
+type MPInfo = {
+  mpName: string;
+  mpVersion?: string;
+};
+
 function hasMetaTag(name: string, content: string): boolean {
   return document?.head.querySelector(`meta[name="${name}"][content="${content}"]`) !== null;
 }
@@ -165,6 +170,13 @@ const wrapContext = () => {
     get abTests(): string[] {
       return env.abValues?.split(',') ?? [];
     },
+    get mpInfo(): MPInfo {
+      return (
+        env.mpInfo ?? {
+          mpName: 'unknown'
+        }
+      );
+    },
     onEnvConfigChanged: (newConfig: Partial<Env>) => {
       mergeWith(env, newConfig, mergeArray);
     },

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

@@ -1,4 +1,4 @@
-import { canIUseNative, createAPI, registerCanIUse, t, createSyncAPI } from './base';
+import { createAPI, registerCanIUse, t } from './base';
 import { invokeNative } from '@jolibox/native-bridge';
 import { hostEmitter, UserCustomError } from '@jolibox/common';
 import { createCommands } from '@jolibox/common';

package/src/native/api/index.ts

@@ -10,3 +10,4 @@ import './navigate';
 import './runtime';
 import './is-native-support';
 import './call-host-method';
+import './payment';

package/src/native/api/navigate.ts

@@ -56,7 +56,16 @@ const interceptSystemExitSync = createSyncAPI('interceptSystemExitSync', {
 
 const navigateToNativePage = createSyncAPI('navigateToNativePage', {
   paramsSchema: t.tuple(
-    t.enum('openHistory', 'openDiscover', 'openDiscover', 'openGame', 'openDrama', 'openTopup', 'openFeed'),
+    t.enum(
+      'openHistory',
+      'openDiscover',
+      'openDiscover',
+      'openGame',
+      'openDrama',
+      'openTopup',
+      'openFeed',
+      'openRewards'
+    ),
     t.object()
   ),
   implement: (path, params) => {

package/src/native/api/payment.ts

@@ -0,0 +1,56 @@
+import { createCommands } from '@jolibox/common';
+import { createAPI, registerCanIUse, t } from './base';
+import { PaymentService } from '../payment/payment-service';
+import { createAPIError } from '@/common/report/errors';
+import { IPaymentChoice } from '@jolibox/ui/dist/bridge/coin';
+
+const commands = createCommands();
+const paymentService = new PaymentService();
+
+const purchaseGem = createAPI('purchaseGem', {
+  paramsSchema: t.tuple(
+    t.object({
+      productId: t.string()
+    })
+  ),
+  implement: async (params: { productId: string }): Promise<{ totalAmount: string }> => {
+    const result = await paymentService.purchase('JOLI_GEM', params.productId);
+
+    if (result.code !== 'SUCCESS' || !result.data?.totalAmount) {
+      throw createAPIError({
+        code: -1,
+        msg: '[JoliboxSDK]: purchase gem failed: ' + result.message
+      });
+    }
+
+    return {
+      totalAmount: result.data?.totalAmount
+    };
+  }
+});
+
+const getGemProducts = createAPI('getGemProducts', {
+  paramsSchema: t.tuple(),
+  implement: async (): Promise<{ products: IPaymentChoice[] }> => {
+    const choices = await paymentService.getJolicoinProductsInfo('JOLI_GEM');
+    console.info('choices', choices);
+    return {
+      products: choices.map((choice) => ({
+        productId: choice.productId,
+        totalAmountStr: choice.totalAmountStr ?? '',
+        quantity: choice.quantity
+      }))
+    };
+  }
+});
+
+commands.registerCommand('PaymentSDK.purchaseGem', purchaseGem);
+commands.registerCommand('PaymentSDK.getGemProducts', getGemProducts);
+
+registerCanIUse('payment.purchaseGem', {
+  version: '1.2.3'
+});
+
+registerCanIUse('payment.getGemProducts', {
+  version: '1.2.3'
+});

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

@@ -0,0 +1,208 @@
+import { PaymentService } from '../payment-service';
+
+// Mock dependencies
+jest.mock('@jolibox/native-bridge', () => ({
+  applyNative: jest.fn(),
+  onNative: jest.fn()
+}));
+
+jest.mock('@/native/network', () => ({
+  innerFetch: jest.fn()
+}));
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { applyNative } = require('@jolibox/native-bridge');
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { innerFetch: fetch } = require('@/native/network');
+
+const mockApplyNative = applyNative;
+const mockFetch = fetch;
+
+describe('PaymentService - Basic Tests', () => {
+  const mockApiEndpoint = '/api/joli-coin/balance-detail';
+
+  const mockServerData = {
+    balance: 100,
+    enableAutoDeduct: true,
+    paymentChoices: [
+      {
+        productId: 'coin_100',
+        quantity: 100,
+        appStoreProductId: 'com.joli.coin.100'
+      }
+    ]
+  };
+
+  const mockNativeData = {
+    'com.joli.coin.100': { price: '$0.99' }
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.clearAllTimers();
+    jest.useFakeTimers();
+    PaymentService.clearPaymentChoicesCache();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  it('should fetch and cache payment choices on first call', async () => {
+    mockFetch.mockResolvedValue({
+      response: {
+        data: {
+          data: mockServerData
+        }
+      }
+    });
+
+    mockApplyNative.mockResolvedValue({
+      data: mockNativeData
+    });
+
+    const result = await PaymentService.getProductsInfo(mockApiEndpoint);
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockApplyNative).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({
+      balance: 100,
+      enableAutoDeduct: true,
+      paymentChoices: [
+        {
+          productId: 'coin_100',
+          quantity: 100,
+          appStoreProductId: 'com.joli.coin.100',
+          totalAmountStr: '$0.99'
+        }
+      ]
+    });
+
+    const stats = PaymentService.getPaymentChoicesCacheStats();
+    expect(stats.cacheCount).toBe(1);
+    expect(stats.validCount).toBe(1);
+  });
+
+  it('should use cache on second call', async () => {
+    mockFetch.mockResolvedValue({
+      response: {
+        data: {
+          data: mockServerData
+        }
+      }
+    });
+
+    mockApplyNative.mockResolvedValue({
+      data: mockNativeData
+    });
+
+    // First call
+    await PaymentService.getProductsInfo(mockApiEndpoint);
+
+    // Second call - should use cache
+    const result = await PaymentService.getProductsInfo(mockApiEndpoint);
+
+    expect(mockFetch).toHaveBeenCalledTimes(2); // Still fetch for real-time data
+    expect(mockApplyNative).toHaveBeenCalledTimes(1); // Only called once
+
+    expect(result).toEqual({
+      balance: 100,
+      enableAutoDeduct: true,
+      paymentChoices: [
+        {
+          productId: 'coin_100',
+          quantity: 100,
+          appStoreProductId: 'com.joli.coin.100',
+          totalAmountStr: '$0.99'
+        }
+      ]
+    });
+  });
+
+  it('should timeout after 3 seconds', async () => {
+    // Mock a slow server response
+    mockFetch.mockImplementation(() => new Promise((resolve) => setTimeout(resolve, 5000)));
+
+    const promise = PaymentService.getProductsInfo(mockApiEndpoint);
+
+    // Fast forward past timeout
+    jest.advanceTimersByTime(3000);
+
+    await expect(promise).rejects.toThrow('[PaymentService] Request timeout after 3 seconds');
+  });
+
+  it('should handle cache expiration', async () => {
+    mockFetch.mockResolvedValue({
+      response: {
+        data: {
+          data: mockServerData
+        }
+      }
+    });
+
+    mockApplyNative.mockResolvedValue({
+      data: mockNativeData
+    });
+
+    // First call
+    await PaymentService.getProductsInfo(mockApiEndpoint);
+
+    // Fast forward time beyond cache duration (10 minutes)
+    jest.advanceTimersByTime(11 * 60 * 1000);
+
+    // Second call - cache should be expired
+    await PaymentService.getProductsInfo(mockApiEndpoint);
+
+    expect(mockApplyNative).toHaveBeenCalledTimes(2); // Called again due to expiration
+  });
+
+  it('should throw error when mockApplyNative fails', async () => {
+    mockFetch.mockResolvedValue({
+      response: {
+        data: {
+          data: mockServerData
+        }
+      }
+    });
+
+    // Mock applyNative to reject
+    mockApplyNative.mockRejectedValue(new Error('Native call failed'));
+
+    await expect(PaymentService.getProductsInfo(mockApiEndpoint)).rejects.toThrow('Native call failed');
+  });
+
+  it('should throw error when mockFetch fails', async () => {
+    // Mock fetch to reject
+    mockFetch.mockRejectedValue(new Error('Network error'));
+
+    await expect(PaymentService.getProductsInfo(mockApiEndpoint)).rejects.toThrow('Network error');
+  });
+
+  it('should throw error when request exceeds 3 seconds timeout', async () => {
+    // Mock a very slow fetch request that never resolves within 3 seconds
+    mockFetch.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          // This will resolve after 5 seconds, but timeout should trigger at 3 seconds
+          setTimeout(() => {
+            resolve({
+              response: {
+                data: {
+                  data: mockServerData
+                }
+              }
+            });
+          }, 5000);
+        })
+    );
+
+    const promise = PaymentService.getProductsInfo(mockApiEndpoint);
+
+    // Advance timers to 3 seconds to trigger timeout
+    jest.advanceTimersByTime(3000);
+
+    await expect(promise).rejects.toThrow('[PaymentService] Request timeout after 3 seconds');
+  });
+});

package/src/native/payment/payment-helper.ts

@@ -4,12 +4,18 @@ import { StandardResponse } from '@jolibox/types';
 import { reportError } from '@/common/report/errors/report';
 import { BaseError } from '@jolibox/common';
 
-type PaymentResult = StandardResponse<void>;
+export type PaymentResult<T> = StandardResponse<T>;
 
 export interface PaymentHandlerMap {
-  JOLI_COIN: (productId: string) => Promise<PaymentResult>; // jolicoin
-  JOLI_COIN_IAP: (params: { productId: string; appStoreProductId: string }) => Promise<PaymentResult>; // jolicoin iap
-  JOLI_GEM_IAP: (params: { productId: string; appStoreProductId: string }) => Promise<PaymentResult>; // gem iap
+  JOLI_COIN: (productId: string) => Promise<PaymentResult<void>>; // jolicoin
+  JOLI_COIN_IAP: (params: {
+    productId: string;
+    appStoreProductId: string;
+  }) => Promise<PaymentResult<{ totalAmount: string }>>; // jolicoin iap
+  JOLI_GEM_IAP: (params: {
+    productId: string;
+    appStoreProductId: string;
+  }) => Promise<PaymentResult<{ totalAmount: string }>>; // gem iap
 }
 
 export type PaymentHandler<T extends PaymentType> = PaymentHandlerMap[T];