@jolibox/implement 1.4.2 → 1.4.6

package/dist/native/api/__tests__/getSpinSubscriptionPrice.test.d.ts

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

package/implement.build.log

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

package/package.json

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

package/src/native/api/__tests__/getSpinSubscriptionPrice.test.ts

@@ -0,0 +1,155 @@
+import { applyNative } from '@jolibox/native-bridge';
+import { ISubscriptionPlanData } from '@/native/subscription/type';
+
+jest.mock('@jolibox/native-bridge', () => ({
+  applyNative: jest.fn(),
+  onNative: jest.fn(),
+  invokeNative: jest.fn()
+}));
+
+const mockApplyNative = applyNative as jest.Mock;
+
+/**
+ * Replicate the core logic of getSpinSubscriptionPrice from payment.ts
+ * to test it in isolation without triggering the full module import chain.
+ */
+async function getSpinSubscriptionPriceImpl(params: { appStoreProductId: string }) {
+  const { data } = await applyNative('requestSubscriptionPlansAsync', {
+    appStoreProductIds: [params.appStoreProductId],
+    type: 'SPIN'
+  });
+
+  if (!data) {
+    throw new Error('[JoliboxSDK]: get spin subscription price failed');
+  }
+
+  const plans = Object.values(data as Record<string, ISubscriptionPlanData>).map((plan) => ({
+    basePlanId: plan.basePlanId,
+    productId: plan.productId,
+    formattedPrice: plan.pricing.formattedPrice,
+    originalPrice: plan.pricing.originalPrice,
+    trialDay: plan.trial?.duration ?? 0
+  }));
+
+  return { plans };
+}
+
+describe('getSpinSubscriptionPrice', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call applyNative with type SPIN and return formatted plans', async () => {
+    mockApplyNative.mockResolvedValue({
+      data: {
+        'spin-weekly': {
+          basePlanId: 'spin-weekly',
+          productId: 'jolibox_app_spin_sub',
+          pricing: {
+            formattedPrice: '$1.99',
+            originalPrice: '$1.99',
+            discountPercentage: null
+          },
+          trial: {
+            duration: 3,
+            description: ''
+          }
+        }
+      }
+    });
+
+    const result = await getSpinSubscriptionPriceImpl({
+      appStoreProductId: 'jolibox_app_spin_sub'
+    });
+
+    expect(mockApplyNative).toHaveBeenCalledWith('requestSubscriptionPlansAsync', {
+      appStoreProductIds: ['jolibox_app_spin_sub'],
+      type: 'SPIN'
+    });
+
+    expect(result).toEqual({
+      plans: [
+        {
+          basePlanId: 'spin-weekly',
+          productId: 'jolibox_app_spin_sub',
+          formattedPrice: '$1.99',
+          originalPrice: '$1.99',
+          trialDay: 3
+        }
+      ]
+    });
+  });
+
+  it('should handle multiple plans', async () => {
+    mockApplyNative.mockResolvedValue({
+      data: {
+        'spin-weekly': {
+          basePlanId: 'spin-weekly',
+          productId: 'jolibox_app_spin_sub',
+          pricing: { formattedPrice: '$1.99', originalPrice: '$1.99' },
+          trial: { duration: 3 }
+        },
+        'spin-monthly': {
+          basePlanId: 'spin-monthly',
+          productId: 'jolibox_app_spin_sub',
+          pricing: { formattedPrice: '$4.99', originalPrice: '$4.99' },
+          trial: { duration: 7 }
+        }
+      }
+    });
+
+    const result = await getSpinSubscriptionPriceImpl({
+      appStoreProductId: 'jolibox_app_spin_sub'
+    });
+
+    expect(result.plans).toHaveLength(2);
+    expect(result.plans).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ basePlanId: 'spin-weekly', formattedPrice: '$1.99' }),
+        expect.objectContaining({ basePlanId: 'spin-monthly', formattedPrice: '$4.99' })
+      ])
+    );
+  });
+
+  it('should default trialDay to 0 when trial is undefined', async () => {
+    mockApplyNative.mockResolvedValue({
+      data: {
+        'spin-weekly': {
+          basePlanId: 'spin-weekly',
+          productId: 'jolibox_app_spin_sub',
+          pricing: { formattedPrice: '$1.99', originalPrice: '$1.99' }
+        }
+      }
+    });
+
+    const result = await getSpinSubscriptionPriceImpl({
+      appStoreProductId: 'jolibox_app_spin_sub'
+    });
+
+    expect(result.plans[0].trialDay).toBe(0);
+  });
+
+  it('should throw error when native returns no data', async () => {
+    mockApplyNative.mockResolvedValue({ data: null });
+
+    await expect(getSpinSubscriptionPriceImpl({ appStoreProductId: 'jolibox_app_spin_sub' })).rejects.toThrow(
+      'get spin subscription price failed'
+    );
+  });
+
+  it('should throw error when native returns undefined data', async () => {
+    mockApplyNative.mockResolvedValue({});
+
+    await expect(getSpinSubscriptionPriceImpl({ appStoreProductId: 'jolibox_app_spin_sub' })).rejects.toThrow(
+      'get spin subscription price failed'
+    );
+  });
+
+  it('should throw error when native call rejects', async () => {
+    mockApplyNative.mockRejectedValue(new Error('Native bridge unavailable'));
+
+    await expect(getSpinSubscriptionPriceImpl({ appStoreProductId: 'jolibox_app_spin_sub' })).rejects.toThrow(
+      'Native bridge unavailable'
+    );
+  });
+});

package/src/native/api/payment.ts

@@ -3,8 +3,10 @@ import { createAPI, registerCanIUse, t } from './base';
 import { createJoliGemPaymentService } from '../payment/payment-service';
 import { createAPIError } from '@/common/report/errors';
 import { IPaymentChoice } from '@jolibox/ui/dist/bridge/coin';
-import { ISubscriptionTierData } from '@jolibox/types';
+import { ISpinSubscriptionPriceData, ISubscriptionTierData } from '@jolibox/types';
 import { subscriptionService } from '@/native/subscription';
+import { applyNative } from '@jolibox/native-bridge';
+import { ISubscriptionPlanData } from '@/native/subscription/type';
 
 const commands = createCommands();
 const paymentService = createJoliGemPaymentService();
@@ -143,7 +145,43 @@ commands.registerCommand('PaymentSDK.getSubscriptionPlans', getSubscriptionPlans
 commands.registerCommand('PaymentSDK.subscribe', subscribe);
 commands.registerCommand('PaymentSDK.subscribeSpin', subscribeSpin);
 
+const getSpinSubscriptionPrice = createAPI('getSpinSubscriptionPrice', {
+  paramsSchema: t.tuple(
+    t.object({
+      appStoreProductId: t.string()
+    })
+  ),
+  implement: async (params: {
+    appStoreProductId: string;
+  }): Promise<{ plans: ISpinSubscriptionPriceData[] }> => {
+    const { data } = await applyNative('requestSubscriptionPlansAsync', {
+      appStoreProductIds: [params.appStoreProductId],
+      type: 'SPIN'
+    });
+
+    if (!data) {
+      throw createAPIError({
+        code: -1,
+        msg: '[JoliboxSDK]: get spin subscription price failed'
+      });
+    }
+
+    const plans: ISpinSubscriptionPriceData[] = Object.values(
+      data as Record<string, ISubscriptionPlanData>
+    ).map((plan) => ({
+      basePlanId: plan.basePlanId,
+      productId: plan.productId,
+      formattedPrice: plan.pricing.formattedPrice,
+      originalPrice: plan.pricing.originalPrice,
+      trialDay: plan.trial?.duration ?? 0
+    }));
+
+    return { plans };
+  }
+});
+
 commands.registerCommand('PaymentSDK.flushSubInfoCache', flushSubInfoCache);
+commands.registerCommand('PaymentSDK.getSpinSubscriptionPrice', getSpinSubscriptionPrice);
 
 registerCanIUse('payment.purchaseGem', {
   version: '1.2.9'
@@ -168,3 +206,7 @@ registerCanIUse('payment.flushSubInfoCache', {
 registerCanIUse('payment.subscribeSpin', {
   version: '1.3.7'
 });
+
+registerCanIUse('payment.getSpinSubscriptionPrice', {
+  version: '1.4.3'
+});

package/src/native/api/task.ts

@@ -1,7 +1,7 @@
 import { createCommands } from '@jolibox/common';
-import { createAPI, registerCanIUse, t } from './base';
+import { createAPI, registerCanIUse, t, canIUseNative } from './base';
 import { taskTracker } from '../report';
-import { emitNative } from '@jolibox/native-bridge';
+import { emitNative, invokeNative } from '@jolibox/native-bridge';
 import { context } from '@/common/context';
 
 const commands = createCommands();
@@ -35,6 +35,15 @@ function throttledEmitScore(data: any) {
   }
 }
 
+function reportTaskGameInfo(
+  event: 'COMPLETE_GAME_LEVEL' | 'GAME_ENDED' | 'GAME_LEVEL_UP',
+  inGameInfo: Record<string, any>
+) {
+  return canIUseNative('notifyTaskGameInfoAsync')
+    ? invokeNative('notifyTaskGameInfoAsync', { event, inGameInfo })
+    : taskTracker.reporter({ event, extraParams: { inGameInfo } });
+}
+
 const onLevelFinished = createAPI('levelFinished', {
   paramsSchema: t.tuple(
     t.object({
@@ -59,16 +68,11 @@ const onLevelFinished = createAPI('levelFinished', {
     );
 
     tasks.push(
-      taskTracker.reporter({
-        event: 'COMPLETE_GAME_LEVEL',
-        extraParams: {
-          inGameInfo: {
-            levelId,
-            duration,
-            rating,
-            score
-          }
-        }
+      reportTaskGameInfo('COMPLETE_GAME_LEVEL', {
+        levelId,
+        duration,
+        rating,
+        score
       })
     );
     throttledEmitScore({ levelId, duration, rating, score });
@@ -98,15 +102,10 @@ const onGamePlayEnded = createAPI('gamePlayEnded', {
     );
 
     tasks.push(
-      taskTracker.reporter({
-        event: 'GAME_ENDED',
-        extraParams: {
-          inGameInfo: {
-            duration,
-            rating,
-            score
-          }
-        }
+      reportTaskGameInfo('GAME_ENDED', {
+        duration,
+        rating,
+        score
       })
     );
     throttledEmitScore({ duration, rating, score });
@@ -130,14 +129,9 @@ const onLevelUpgrade = createAPI('levelUpgrade', {
       })
     );
     tasks.push(
-      taskTracker.reporter({
-        event: 'GAME_LEVEL_UP',
-        extraParams: {
-          inGameInfo: {
-            levelId,
-            levelName: name
-          }
-        }
+      reportTaskGameInfo('GAME_LEVEL_UP', {
+        levelId,
+        levelName: name
       })
     );
     emitNative('cpUpdateScoreEvent', { levelId }, context.webviewId);