@jolibox/implement 1.1.38 → 1.1.40

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

@@ -1,4 +1,24 @@
+type LoginExtra = {
+    firstLogin?: {
+        reward: {
+            rewardType: 'JOLI_COIN';
+            rewardValue: number;
+        };
+    };
+};
+export declare const loginImplement: (params: {
+    skipLogin?: boolean;
+    triggerFrom?: string;
+}, needExtra?: boolean) => Promise<{
+    isLogin: boolean;
+    token?: string;
+    isFirstLogin?: boolean;
+    extra?: LoginExtra;
+}>;
 export declare const login: (...inputs: unknown[]) => Promise<import("@jolibox/types").StandardResponse<{
     isLogin: boolean;
     token?: string;
+    isFirstLogin?: boolean;
+    extra?: LoginExtra;
 }, unknown>>;
+export {};

package/dist/native/rewards/check-frequency.d.ts

@@ -1,27 +1,24 @@
-/**
- * check can show useModal
- * @param config
- * @returns
- */
 export declare const checkUseModalFrequency: (config: {
-    dailyMaxPopUps: number;
-    minInterval: number;
+    dailyMaxPopUps?: number;
+    minInterval?: number;
 }) => Promise<{
     canShow: boolean;
     isFirst: boolean;
 }>;
-export declare const updateUseModalFrequency: () => Promise<void>;
-/**
- * check can show paymentModal
- */
 export declare const checkPaymentFrequency: (config: {
-    dailyMaxPopUps: number;
-    minInterval: number;
+    dailyMaxPopUps?: number;
+    minInterval?: number;
+}) => Promise<{
+    canShow: boolean;
+    isFirst: boolean;
+}>;
+export declare const checkUnloginModalFrequency: (config: {
+    dailyMaxPopUps?: number;
+    minInterval?: number;
 }) => Promise<{
     canShow: boolean;
     isFirst: boolean;
 }>;
-/**
- * update paymentFrequency
- */
+export declare const updateUseModalFrequency: () => Promise<void>;
 export declare const updatePaymentFrequency: () => Promise<void>;
+export declare const updateUnloginModalFrequency: () => Promise<void>;

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

@@ -1,4 +1,6 @@
 /**
  * rewards event handlers
  */
-export {};
+import './ui/use-modal';
+import './ui/payment-modal';
+import './ui/unlogin-modal';

package/dist/native/rewards/ui/payment-modal.d.ts

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

package/dist/native/rewards/ui/unlogin-modal.d.ts

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

package/dist/native/rewards/ui/use-modal.d.ts

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

package/dist/native/rewards/ui/utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 更新自动扣费配置的函数
+ * @param enabled 是否启用自动扣费
+ * @returns Promise 更新操作的Promise
+ */
+export declare const updateAutoDeductConfig: (enabled: boolean) => Promise<void>;

package/implement.build.log

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

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

@@ -6,7 +6,8 @@ import {
   UnlockOptionsEventName,
   UseModalFrequencyEventName,
   rewardsEmitter,
-  DefaltJoliCoinUseAndCharge
+  DefaltJoliCoinUseAndCharge,
+  DefaltLoginGuide
 } from './reward-emitter';
 import { StandardResponse } from '@jolibox/types';
 
@@ -59,11 +60,13 @@ export const createRewardFrequencyConfigFetcher = (rewardsHelper: RewardsHelper)
     );
 
     rewardsEmitter.emit(UseModalFrequencyEventName, {
-      joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge
+      joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge,
+      loginGuide: res.data?.loginGuide || DefaltLoginGuide
     });
 
     return {
-      joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge
+      joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge,
+      loginGuide: res.data?.loginGuide || DefaltLoginGuide
     };
   });
 };

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

@@ -1,13 +1,12 @@
 import { IHttpClient } from '@/common/http';
-import { rewardsEmitter, UnlockOptionsEventName, IUnlockOptionsEvent } from '../reward-emitter';
 import { IAdBreakParams } from '@/common/ads';
+import { createCommonJolicoinRewardHandler } from './utils/coins';
+import { unlockOptionsHandler } from './utils/common';
 import {
-  createCommonJolicoinRewardHandler,
   createShowUnlockWithJolicoinModal,
-  createInitiateAndAwaitPayment
-} from './utils/coins';
-import { createEventPromiseHandler } from './utils/event-listener';
-import { IRewardParams } from '@jolibox/types';
+  createInitiateAndAwaitPayment,
+  createShowUnloginModal
+} from './utils/coins/commands';
 
 export type JolicoinOnlyRewardsHandler = (params: IAdBreakParams) => Promise<boolean>;
 export const createJolicoinOnlyRewardHandler = (
@@ -20,11 +19,6 @@ export const createJolicoinOnlyRewardHandler = (
     onUnlockFailed?: () => void;
   }
 ): JolicoinOnlyRewardsHandler => {
-  const unlockOptionsHandler = createEventPromiseHandler<IUnlockOptionsEvent, typeof UnlockOptionsEventName>(
-    rewardsEmitter,
-    UnlockOptionsEventName
-  );
-
   const handleUnlockFailed = (() => (params: IAdBreakParams) => {
     onUnlockFailed?.();
     params.adBreakDone?.({
@@ -44,13 +38,19 @@ export const createJolicoinOnlyRewardHandler = (
     cancelButtonText: 'jolicoin.noThanks'
   });
 
-  const jolicoinOnlyRewardHandler = createCommonJolicoinRewardHandler(httpClient, {
+  const showUnloginModal = createShowUnloginModal('JOLI_COIN', {
+    confirmButtonText: 'loginGuide.login',
+    cancelButtonText: 'loginGuide.noThanks'
+  });
+
+  const jolicoinOnlyRewardHandler = createCommonJolicoinRewardHandler('JOLI_COIN', httpClient, {
     handlers: {
       handleUnlockSuccess: onUnlockSuccess,
       handleUnlockFailed,
       unlockOptionsHandler,
       initiateAndAwaitPayment,
-      showUnlockWithJolicoinModal
+      showUnlockWithJolicoinModal,
+      showUnloginModal
     }
   });
 

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

@@ -1,9 +1,12 @@
 import { IHttpClient } from '@/common/http';
-import { rewardsEmitter, UnlockOptionsEventName, IUnlockOptionsEvent } from '../reward-emitter';
 import { IAdBreakParams } from '@/common/ads';
-import { createEventPromiseHandler } from './utils/event-listener';
+import { unlockOptionsHandler } from './utils/common';
 import { createCommonJolicoinRewardHandler } from './utils/coins';
-import { createInitiateAndAwaitPayment, createShowUnlockWithJolicoinModal } from './utils/coins';
+import {
+  createShowUnlockWithJolicoinModal,
+  createInitiateAndAwaitPayment,
+  createShowUnloginModal
+} from './utils/coins/commands';
 
 export type JolicoinRewardsHandler = (params: IAdBreakParams) => Promise<boolean>;
 export const createJolicoinRewardHandler = (
@@ -16,11 +19,6 @@ export const createJolicoinRewardHandler = (
     onUnlockFailed?: () => void;
   }
 ): JolicoinRewardsHandler => {
-  const unlockOptionsHandler = createEventPromiseHandler<IUnlockOptionsEvent, typeof UnlockOptionsEventName>(
-    rewardsEmitter,
-    UnlockOptionsEventName
-  );
-
   const handleUnlockFailed = () => {
     onUnlockFailed?.();
   };
@@ -35,15 +33,21 @@ export const createJolicoinRewardHandler = (
     cancelButtonText: 'jolicoin.noWatchAds'
   });
 
-  const jolicoinOnlyRewardHandler = createCommonJolicoinRewardHandler(httpClient, {
+  const showUnloginModal = createShowUnloginModal('ADS-JOLI_COIN', {
+    confirmButtonText: 'loginGuide.login',
+    cancelButtonText: 'loginGuide.noWatchAds'
+  });
+
+  const jolicoinRewardHandler = createCommonJolicoinRewardHandler('ADS-JOLI_COIN', httpClient, {
     handlers: {
       handleUnlockSuccess: onUnlockSuccess,
       handleUnlockFailed,
       unlockOptionsHandler,
       initiateAndAwaitPayment,
-      showUnlockWithJolicoinModal
+      showUnlockWithJolicoinModal,
+      showUnloginModal
     }
   });
 
-  return jolicoinOnlyRewardHandler;
+  return jolicoinRewardHandler;
 };

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

@@ -0,0 +1,3 @@
+export { registerUseJolicoinCommand, createShowUnlockWithJolicoinModal } from './use-jolicoin';
+export { registerUsePaymentCommand, createInitiateAndAwaitPayment } from './use-payment';
+export { registerUseUnloginCommand, createShowUnloginModal } from './use-unlogin';

package/src/common/rewards/registers/utils/coins/commands/use-jolicoin.ts

@@ -0,0 +1,67 @@
+import { IJoliCoin } from '@/common/rewards/type';
+import { rewardsCommands } from '../rewards-command';
+import { unlockOptionsHandler } from '@/common/rewards/registers/utils/common';
+import { createEventPromiseHandler } from '../../event-listener';
+import { IUseModalResultEvent, UseModalResultEventName } from '@/common/rewards/reward-emitter';
+import { rewardsEmitter, UseModalEventName } from '@/common/rewards/reward-emitter';
+
+export const registerUseJolicoinCommand = (
+  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  params: {
+    showUnlockWithJolicoinModal: (params: {
+      enableAutoDeduct: boolean;
+      userJoliCoin: IJoliCoin;
+      joliCoinQuantity: number;
+    }) => Promise<'CONFIRM' | 'CANCEL' | 'FAILED'>;
+  }
+) => {
+  const { showUnlockWithJolicoinModal } = params;
+  rewardsCommands.registerCommand(`Rewards.${prefix}.useJolicoin`, async () => {
+    const unlockOptions = await unlockOptionsHandler.getData();
+    const enableAutoDeduct = !!unlockOptions?.userJoliCoin?.enableAutoDeduct;
+    const joliCoinQuantity =
+      unlockOptions?.options?.find((option) => option.type === 'JOLI_COIN')?.joliCoinChoices[0]
+        .joliCoinQuantity ?? 0;
+
+    console.log('-----unlockOptions usemodal-----', unlockOptions, enableAutoDeduct, joliCoinQuantity);
+    const shouldUnlock = await showUnlockWithJolicoinModal({
+      enableAutoDeduct,
+      userJoliCoin: unlockOptions?.userJoliCoin,
+      joliCoinQuantity
+    });
+
+    if (shouldUnlock !== 'CONFIRM') {
+      return {
+        result: 'FAILED'
+      };
+    }
+    return {
+      result: 'SUCCESS'
+    };
+  });
+};
+
+// EVENTS
+export const createShowUnlockWithJolicoinModal = (
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  buttons: {
+    confirmButtonText: string;
+    cancelButtonText: string;
+  }
+) => {
+  return async (params: { enableAutoDeduct: boolean; userJoliCoin: IJoliCoin; joliCoinQuantity: number }) => {
+    const modalHandler = createEventPromiseHandler<IUseModalResultEvent, typeof UseModalResultEventName>(
+      rewardsEmitter,
+      UseModalResultEventName
+    );
+    rewardsEmitter.emit(UseModalEventName, type, {
+      enableAutoDeduct: params.enableAutoDeduct,
+      userJoliCoin: params.userJoliCoin,
+      joliCoinQuantity: params.joliCoinQuantity,
+      confirmButtonText: buttons.confirmButtonText,
+      cancelButtonText: buttons.cancelButtonText
+    });
+    const modalResult = await modalHandler.getFreshData();
+    return modalResult.useModalResult;
+  };
+};

package/src/common/rewards/registers/utils/coins/commands/use-payment.ts

@@ -0,0 +1,85 @@
+import { IJoliCoin } from '@/common/rewards/type';
+import { fetchBalance } from '../fetch-balance';
+import { rewardsCommands } from '../rewards-command';
+import { IHttpClient } from '@/common/http';
+import { unlockOptionsHandler } from '../../common';
+import { joliCoinIsEnough } from '../../index';
+import { rewardsEmitter } from '@/common/rewards/reward-emitter';
+import { createEventPromiseHandler } from '../../event-listener';
+import {
+  IPaymentEvent,
+  PaymentResultEventName,
+  InvokePaymentEventName
+} from '@/common/rewards/reward-emitter';
+
+export const registerUsePaymentCommand = (
+  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  params: {
+    httpClient: IHttpClient;
+    initiateAndAwaitPayment: (params: {
+      userJoliCoin: IJoliCoin;
+      joliCoinQuantity: number;
+    }) => Promise<'SUCCESS' | 'FAILED' | 'CANCEL'>;
+  }
+) => {
+  const { httpClient, initiateAndAwaitPayment } = params;
+  rewardsCommands.registerCommand(`Rewards.${prefix}.usePayment`, async () => {
+    const unlockOptions = await unlockOptionsHandler.getData();
+    const newBalance = await fetchBalance(httpClient);
+    const joliCoinQuantity =
+      unlockOptions?.options?.find((option) => option.type === 'JOLI_COIN')?.joliCoinChoices[0]
+        .joliCoinQuantity ?? 0;
+
+    const newJoliCoin = {
+      balance: newBalance?.balance ?? 0,
+      enableAutoDeduct: unlockOptions?.userJoliCoin?.enableAutoDeduct ?? false
+    };
+
+    unlockOptionsHandler.updateData({
+      userJoliCoin: newJoliCoin
+    });
+
+    console.log('-----unlockOptions payment-----', unlockOptions, newJoliCoin, joliCoinQuantity);
+    if (!joliCoinIsEnough(unlockOptions?.options || [], newJoliCoin)) {
+      const paymentResult = await initiateAndAwaitPayment({
+        userJoliCoin: newJoliCoin,
+        joliCoinQuantity
+      });
+
+      return {
+        result: paymentResult === 'SUCCESS' ? 'SUCCESS' : 'FAILED'
+      };
+    }
+    return {
+      result: 'CONTINUE'
+    };
+  });
+};
+
+// events
+export const createInitiateAndAwaitPayment = (
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  buttons: {
+    confirmButtonText: string;
+    cancelButtonText: string;
+  }
+) => {
+  return async (params: { userJoliCoin: IJoliCoin; joliCoinQuantity: number }) => {
+    const paymentHandler = createEventPromiseHandler<IPaymentEvent, typeof PaymentResultEventName>(
+      rewardsEmitter,
+      PaymentResultEventName
+    );
+
+    rewardsEmitter.emit(InvokePaymentEventName, type, {
+      userJoliCoin: params.userJoliCoin,
+      joliCoinQuantity: params.joliCoinQuantity,
+      enableAutoDeduct: params.userJoliCoin.enableAutoDeduct,
+      confirmButtonText: buttons.confirmButtonText,
+      cancelButtonText: buttons.cancelButtonText
+    });
+
+    // Wait for payment result
+    const paymentResult = await paymentHandler.getFreshData();
+    return paymentResult.paymentResult;
+  };
+};

package/src/common/rewards/registers/utils/coins/commands/use-unlogin.ts

@@ -0,0 +1,96 @@
+import { context } from '@/common/context';
+import { rewardsCommands } from '../rewards-command';
+import { createEventPromiseHandler } from '../../event-listener';
+import { IUseUnloginModalResultEvent, UseUnloginModalResultEventName } from '@/common/rewards/reward-emitter';
+import { rewardsEmitter, InvokeUnloginModalEventName } from '@/common/rewards/reward-emitter';
+import { createToast } from '@jolibox/ui';
+import { sleep } from '@jolibox/common';
+import { fetchBalance } from '../fetch-balance';
+import { IHttpClient } from '@/common/http';
+import { unlockOptionsHandler } from '../../common';
+
+export const registerUseUnloginCommand = (
+  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  params: {
+    httpClient: IHttpClient;
+    showUnloginModal: () => Promise<{
+      result: 'CANCEL' | 'FAILED' | 'SUCCESS' | 'ADS' | 'NOT_SUPPORT';
+      rewards?: {
+        jolicoin?: {
+          isFirstLogin: boolean;
+          claimedRewardValue: number;
+        };
+      };
+    }>;
+  }
+) => {
+  const { showUnloginModal, httpClient } = params;
+  rewardsCommands.registerCommand(`Rewards.${prefix}.useUnloginModal`, async () => {
+    const isLogin = context.hostUserInfo?.isLogin;
+    const unlockOptions = await unlockOptionsHandler.getData();
+    console.log('-----isLogin-----', !!isLogin);
+    if (!isLogin) {
+      const unloginModalResult = await showUnloginModal();
+
+      console.log('-----unloginModalResult-----', unloginModalResult);
+      if (unloginModalResult.result == 'FAILED' || unloginModalResult.result == 'CANCEL') {
+        return {
+          result: 'FAILED'
+        };
+      }
+
+      const { isFirstLogin, claimedRewardValue } = unloginModalResult.rewards?.jolicoin ?? {};
+      if (unloginModalResult.result == 'SUCCESS') {
+        if (isFirstLogin && claimedRewardValue) {
+          await sleep(3000); // wait for center toast to show
+        }
+
+        //check balance
+        const newBalance = await fetchBalance(httpClient);
+        const joliCoinQuantity =
+          unlockOptions?.options?.find((option) => option.type === 'JOLI_COIN')?.joliCoinChoices[0]
+            .joliCoinQuantity ?? 0;
+
+        const newJoliCoin = {
+          balance: newBalance?.balance ?? 0,
+          enableAutoDeduct: unlockOptions?.userJoliCoin?.enableAutoDeduct ?? false
+        };
+
+        unlockOptionsHandler.updateData({
+          userJoliCoin: newJoliCoin
+        });
+        if (newJoliCoin.balance >= joliCoinQuantity) {
+          return {
+            result: 'SUCCESS'
+          };
+        }
+      }
+    }
+    return {
+      result: 'CONTINUE'
+    };
+  });
+};
+
+//EVENTS
+
+export const createShowUnloginModal = (
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  buttons: {
+    confirmButtonText: string;
+    cancelButtonText: string;
+  }
+) => {
+  return async () => {
+    const modalHandler = createEventPromiseHandler<
+      IUseUnloginModalResultEvent,
+      typeof UseUnloginModalResultEventName
+    >(rewardsEmitter, UseUnloginModalResultEventName);
+    rewardsEmitter.emit(InvokeUnloginModalEventName, type, {
+      confirmButtonText: buttons.confirmButtonText,
+      cancelButtonText: buttons.cancelButtonText
+    });
+    const modalResult = await modalHandler.getFreshData();
+    return modalResult;
+  };
+};

package/src/common/rewards/registers/utils/coins/fetch-balance.ts

@@ -0,0 +1,15 @@
+import { IHttpClient } from '@/common/http';
+import { StandardResponse } from '@jolibox/types';
+
+export const fetchBalance = async (httpClient: IHttpClient) => {
+  const res = await httpClient.get<
+    StandardResponse<{
+      balance: number;
+    }>
+  >('/api/joli-coin/balance', {
+    query: {
+      type: 'JOLI_COIN'
+    }
+  });
+  return res.data;
+};