@jolibox/implement 1.4.3 → 1.4.7

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.3 clean
+> @jolibox/implement@1.4.7 clean
 > rimraf ./dist
 
 
-> @jolibox/implement@1.4.3 build:esm
+> @jolibox/implement@1.4.7 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.3",
+  "version": "1.4.7",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.4.3",
-    "@jolibox/types": "1.4.3",
-    "@jolibox/native-bridge": "1.4.3",
-    "@jolibox/ads": "1.4.3",
+    "@jolibox/common": "1.4.7",
+    "@jolibox/types": "1.4.7",
+    "@jolibox/native-bridge": "1.4.7",
+    "@jolibox/ads": "1.4.7",
     "localforage": "1.10.0",
-    "@jolibox/ui": "1.4.3",
+    "@jolibox/ui": "1.4.7",
     "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/rewards.ts

@@ -175,12 +175,15 @@ const createRewardsAdsManager = createAPI('createRewardsAdsManager', {
               }
             });
           },
-          showAd: async (callbacks: {
-            onAdLoaded?: () => void;
-            onAdError?: (error: Error) => void;
-            onAdRewarded?: () => void;
-            onAdDismissed?: () => void;
-          }) => {
+          showAd: async (
+            callbacks: {
+              onAdLoaded?: () => void;
+              onAdError?: (error: Error) => void;
+              onAdRewarded?: () => void;
+              onAdDismissed?: () => void;
+            },
+            isSpinWheel = false
+          ) => {
             ads.adBreak({
               type: 'reward',
               beforeReward: (showAdFn) => {
@@ -204,9 +207,10 @@ const createRewardsAdsManager = createAPI('createRewardsAdsManager', {
                 if (breakStatus === 'viewed') {
                   // reward should be given to user
                   console.log('-----> complete watch ads');
-                  taskTracker.reporter({
-                    event: 'COMPLETE_WATCH_ADS'
-                  });
+                  !isSpinWheel &&
+                    taskTracker.reporter({
+                      event: 'COMPLETE_WATCH_ADS'
+                    });
                   callbacks.onAdRewarded?.();
                 }