@jolibox/implement 1.1.20 → 1.1.21

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

@@ -23,3 +23,8 @@ export declare const getStorageInfoSync: () => StandardResponse<{
         keys: string[];
     };
 }>;
+export declare const getGlobalStorage: (...inputs: unknown[]) => Promise<StandardResponse<any>>;
+export declare const setGlobalStorage: (...inputs: unknown[]) => Promise<StandardResponse<{
+    code: string;
+    message: string;
+}>>;

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

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

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

@@ -0,0 +1 @@
+export declare const filterTodayTimestamps: (timestamps: number[]) => number[];

package/implement.build.log

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

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

@@ -1,7 +1,14 @@
 import { IHttpClient } from '../http';
 import { RewardsHelper, RewardType } from './reward-helper';
 import { IJolicoinRewardOption } from './type';
-import { UnlockOptionsEventName, rewardsEmitter } from './reward-emitter';
+import {
+  IUseModalFrequencyConfig,
+  UnlockOptionsEventName,
+  UseModalFrequencyEventName,
+  rewardsEmitter,
+  DefaltJoliCoinUseAndCharge
+} from './reward-emitter';
+import { StandardResponse } from '@jolibox/types';
 
 const priority = () => {
   return (a: RewardType, b: RewardType) => {
@@ -43,3 +50,22 @@ export const createRewardFetcher = (rewardsHelper: RewardsHelper) => {
     }
   });
 };
+
+export const createRewardFrequencyConfigFetcher = (rewardsHelper: RewardsHelper) => {
+  rewardsHelper.registerRewardFrequencyConfigFetcher(async (httpClient: IHttpClient) => {
+    const res = await httpClient.get<StandardResponse<IUseModalFrequencyConfig>>(
+      '/api/fe-configs/web-common/global-config',
+      {}
+    );
+    if (res.code !== 'SUCCESS') {
+      return { joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge };
+    }
+    rewardsEmitter.emit(UseModalFrequencyEventName, {
+      joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge
+    });
+
+    return {
+      joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge
+    };
+  });
+};

package/src/common/rewards/index.ts

@@ -1,8 +1,9 @@
 import { createRewardsHelper } from './reward-helper';
-import { createRewardFetcher } from './fetch-reward';
+import { createRewardFetcher, createRewardFrequencyConfigFetcher } from './fetch-reward';
 
 export const rewardsHelper = createRewardsHelper();
 createRewardFetcher(rewardsHelper);
+createRewardFrequencyConfigFetcher(rewardsHelper);
 
 export * from './registers/use-ads';
 export * from './registers/use-jolicoin';

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

@@ -14,6 +14,7 @@ export const InvokePaymentEventName = 'INVOKE_PAYMENT' as const;
 export const PaymentResultEventName = 'ON_PAYMENT_RESULT' as const;
 export const UseModalEventName = 'ON_USE_MODAL_EVENT' as const;
 export const UseModalResultEventName = 'ON_USE_MODAL_RESULT' as const;
+export const UseModalFrequencyEventName = 'ON_USE_MODAL_FREQUENCY' as const;
 
 type IPaymentResult = 'SUCCESS' | 'FAILED' | 'CANCEL';
 export interface IPaymentEvent {
@@ -49,12 +50,26 @@ export interface IUseModalResultEvent {
   useModalResult: 'CONFIRM' | 'CANCEL' | 'FAILED';
 }
 
+export interface IUseModalFrequencyConfig {
+  joliCoinUseAndCharge: {
+    useJolicoin: {
+      dailyMaxPopUps: number;
+      minInterval: number;
+    };
+    charge: {
+      dailyMaxPopUps: number;
+      minInterval: number;
+    };
+  };
+}
+
 export interface RewardsEventMap extends Record<string, unknown[]> {
   [UnlockOptionsEventName]: [IUnlockOptionsEvent];
   [InvokePaymentEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN', IInvokePaymentEvent];
   [PaymentResultEventName]: [IPaymentEvent];
   [UseModalResultEventName]: [IUseModalResultEvent];
   [UseModalEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN', IUseModalEvent];
+  [UseModalFrequencyEventName]: [IUseModalFrequencyConfig];
 }
 
 export const originalRewardsEmitter = new EventEmitter<RewardsEventMap>();
@@ -77,3 +92,16 @@ export const createRewardsEmitterWrapper = (): RewardsEmitter => {
 };
 
 export const rewardsEmitter = createRewardsEmitterWrapper();
+
+export const DefaltJoliCoinUseAndCharge = {
+  // 充值弹窗：
+  charge: {
+    dailyMaxPopUps: 2, // 一天内最多2次弹窗
+    minInterval: 8 * 60 * 60 * 1000 // 同一用户若在8小时内刚点过弹窗，则不再弹出
+  },
+  // 使用弹窗：
+  useJolicoin: {
+    dailyMaxPopUps: 2,
+    minInterval: 8 * 60 * 60 * 1000
+  }
+};

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

@@ -2,6 +2,7 @@ export type RewardType = 'ADS' | 'JOLI_COIN' | 'JOLI_COIN_ONLY';
 
 import { context } from '../context';
 import type { AdsRewardsHandler } from './registers/use-ads';
+import { IUseModalFrequencyConfig, DefaltJoliCoinUseAndCharge } from './reward-emitter';
 
 export interface RewardHandlerMap {
   ADS: AdsRewardsHandler;
@@ -14,7 +15,9 @@ export type RewardHandler<T extends RewardType> = RewardHandlerMap[T];
 const isTestMode = context.testMode;
 export function createRewardsHelper() {
   const rewardsHandlers = new Map<RewardType, RewardHandler<any>>();
+
   let rewardFetcher: ((...args: any[]) => Promise<RewardType[]>) | undefined;
+  let rewardFrequencyConfigFetcher: ((...args: any[]) => Promise<IUseModalFrequencyConfig>) | undefined;
 
   return {
     registerRewardHandler<T extends RewardType>(type: T, handler: RewardHandler<T>) {
@@ -45,11 +48,31 @@ export function createRewardsHelper() {
         }
       };
     },
+    async registerRewardFrequencyConfigFetcher(
+      fetcher: (...args: any[]) => Promise<IUseModalFrequencyConfig>
+    ) {
+      rewardFrequencyConfigFetcher = async (...args: unknown[]) => {
+        try {
+          const config = await fetcher(...args);
+          return config;
+        } catch (e) {
+          console.error(`getRewardOptions error:`, e);
+          return { joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge };
+        }
+      };
+    },
+
     async getRewardsTypes(...args: unknown[]): Promise<RewardType[]> {
       if (!rewardFetcher) {
         return ['ADS'];
       }
       return await rewardFetcher(...args);
+    },
+    async getRewardFrequencyConfig(...args: unknown[]): Promise<IUseModalFrequencyConfig> {
+      if (!rewardFrequencyConfigFetcher) {
+        return { joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge };
+      }
+      return await rewardFrequencyConfigFetcher(...args);
     }
   };
 }

package/src/native/api/ads.ts

@@ -76,6 +76,10 @@ const adsContext: IAdsContext<'GAME'> = {
 
 const ads = new JoliboxAdsForGame(adsContext);
 
+rewardsHelper.getRewardFrequencyConfig(httpClient).then((config) => {
+  console.log('getRewardFrequencyConfig', config);
+});
+
 rewardsHelper.registerRewardHandler('ADS', createAdsRewardHandler(ads));
 rewardsHelper.registerRewardHandler(
   'JOLI_COIN',

package/src/native/api/navigate.ts

@@ -2,6 +2,7 @@ import { createCommands, hostEmitter, UserCustomError } from '@jolibox/common';
 import { invokeNative } from '@jolibox/native-bridge';
 import { createSyncAPI, t, registerCanIUse } from './base';
 import { context } from '@/common/context';
+import { reportError } from '@/common/report/errors/report';
 
 const commands = createCommands();
 
@@ -53,10 +54,26 @@ const interceptSystemExitSync = createSyncAPI('interceptSystemExitSync', {
   }
 });
 
+const navigateToNativePage = createSyncAPI('navigateToNativePage', {
+  paramsSchema: t.tuple(t.enum('openHistory'), t.object()),
+  implement: (path, params) => {
+    const { errNo, errMsg } = invokeNative('callHostMethodAsync', {
+      method: path,
+      params: {
+        ...params
+      }
+    });
+    if (errNo !== 0) {
+      throw new UserCustomError(errMsg, errNo);
+    }
+  }
+});
+
 commands.registerCommand('RouterSDK.openSchema', openSchemaSync);
 commands.registerCommand('RouterSDK.openPage', openPageSync);
 commands.registerCommand('RouterSDK.closePage', closePageSync);
 commands.registerCommand('RouterSDK.interceptSystemExit', interceptSystemExitSync);
+commands.registerCommand('RouterSDK.navigateToNativePage', navigateToNativePage);
 
 registerCanIUse('router.openSchema', {
   version: '1.1.10'
@@ -73,3 +90,7 @@ registerCanIUse('router.closePage', {
 registerCanIUse('router.interceptSystemExit', {
   version: '1.1.18'
 });
+
+registerCanIUse('router.navigateToNativePage', {
+  version: '1.1.19'
+});

package/src/native/api/storage.ts

@@ -285,3 +285,48 @@ function stringify(data: unknown, type: DataType) {
     return '';
   }
 }
+
+export const getGlobalStorage = createAPI('getGlobalStorage', {
+  paramsSchema: t.tuple(t.string()),
+  async implement(key) {
+    try {
+      const { data, dataType } = await applyNative('getGlobalStorageAsync', { key });
+      const parsedData = parse(data, dataType);
+      return {
+        code: 'SUCCESS',
+        message: 'success',
+        data: parsedData
+      };
+    } catch (error) {
+      return {
+        code: 'INTERNAL_ERROR',
+        message: '[Jolibox SDK] get global storage failed',
+        data: null
+      };
+    }
+  }
+});
+
+export const setGlobalStorage = createAPI('setGlobalStorage', {
+  paramsSchema: t.tuple(t.string(), t.or(t.string(), t.boolean(), t.number())),
+  async implement(key, value) {
+    try {
+      const dataType = getType(value);
+      const data = stringify(value, dataType);
+      await applyNative('setGlobalStorageAsync', {
+        key,
+        data,
+        dataType
+      });
+      return {
+        code: 'SUCCESS',
+        message: 'success'
+      };
+    } catch (error) {
+      return {
+        code: 'INTERNAL_ERROR',
+        message: '[Jolibox SDK] set global storage failed'
+      };
+    }
+  }
+});

package/src/native/bootstrap/init-env.ts

@@ -1,7 +1,17 @@
 export function initializeNativeEnv() {
   let styleElement: HTMLStyleElement | null = null;
+  let viewportMeta: HTMLMetaElement | null = null;
   const originalFetch = window.fetch;
   const createStyles = () => {
+    // 创建并插入viewport meta标签
+    viewportMeta = document.createElement('meta');
+    viewportMeta.setAttribute('name', 'viewport');
+    viewportMeta.setAttribute(
+      'content',
+      'viewport-fit=cover, width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no'
+    );
+    viewportMeta.setAttribute('data-jolibox-sdk', 'viewport-meta');
+
     styleElement = document.createElement('style');
     styleElement.setAttribute('data-jolibox-sdk', 'default-styles');
 
@@ -28,6 +38,8 @@ export function initializeNativeEnv() {
     styleElement.textContent = styles;
 
     const head = document.head || document.getElementsByTagName('head')[0];
+    // 插入viewport meta标签
+    head.insertBefore(viewportMeta, head.firstChild);
     head.insertBefore(styleElement, head.firstChild);
     document.documentElement.setAttribute('data-jolibox-root', '');
   };
@@ -72,6 +84,11 @@ export function initializeNativeEnv() {
       styleElement.parentNode.removeChild(styleElement);
       styleElement = null;
     }
+    // 清理viewport meta标签
+    if (viewportMeta?.parentNode) {
+      viewportMeta.parentNode.removeChild(viewportMeta);
+      viewportMeta = null;
+    }
     document.documentElement.removeAttribute('data-jolibox-root');
 
     window.fetch = originalFetch;

package/src/native/rewards/check-frequency.ts

@@ -0,0 +1,70 @@
+import { StandardResponse } from '@jolibox/types';
+import { getGlobalStorage, setGlobalStorage } from '../api/storage';
+import { filterTodayTimestamps } from './utils';
+
+/**
+ * check can show useModal
+ * @param config
+ * @returns
+ */
+export const checkUseModalFrequency = async (config: { dailyMaxPopUps: number; minInterval: number }) => {
+  const { dailyMaxPopUps, minInterval } = config;
+  const res = (await getGlobalStorage('joli_coin_use_modal_frequency')) as StandardResponse<number[]>;
+  if (!res.data) {
+    return true;
+  }
+  const fequeycies = res.data;
+  const todayFequencies = filterTodayTimestamps(fequeycies);
+  if (todayFequencies.length >= dailyMaxPopUps) {
+    return false;
+  }
+  const now = Date.now();
+  if (now - todayFequencies[todayFequencies.length - 1] < minInterval) {
+    return false;
+  }
+  return true;
+};
+
+export const updateUseModalFrequency = async () => {
+  const now = Date.now();
+  const res = (await getGlobalStorage('joli_coin_use_modal_frequency')) as StandardResponse<number[]>;
+
+  const fequeycies = res.data ?? [];
+  fequeycies.push(now);
+  fequeycies.sort((a, b) => b - a).splice(8);
+  await setGlobalStorage('joli_coin_use_modal_frequency', fequeycies);
+};
+
+/**
+ * check can show paymentModal
+ */
+export const checkPaymentFrequency = async (config: { dailyMaxPopUps: number; minInterval: number }) => {
+  const { dailyMaxPopUps, minInterval } = config;
+  const res = (await getGlobalStorage('joli_coin_payment_frequency')) as StandardResponse<number[]>;
+
+  if (!res.data) {
+    return true;
+  }
+  const fequeycies = res.data;
+  const todayFequencies = filterTodayTimestamps(fequeycies);
+  if (todayFequencies.length >= dailyMaxPopUps) {
+    return false;
+  }
+  const now = Date.now();
+  if (now - todayFequencies[todayFequencies.length - 1] < minInterval) {
+    return false;
+  }
+  return true;
+};
+
+/**
+ * update paymentFrequency
+ */
+export const updatePaymentFrequency = async () => {
+  const now = Date.now();
+  const res = (await getGlobalStorage('joli_coin_payment_frequency')) as StandardResponse<number[]>;
+  const frequencies = res.data ?? [];
+  frequencies.push(now);
+  frequencies.sort((a, b) => b - a).splice(8);
+  await setGlobalStorage('joli_coin_payment_frequency', frequencies);
+};

package/src/native/rewards/index.ts

@@ -10,7 +10,9 @@ import {
   UseModalResultEventName,
   InvokePaymentEventName,
   IInvokePaymentEvent,
-  IPaymentChoice
+  IPaymentChoice,
+  UseModalFrequencyEventName,
+  IUseModalFrequencyConfig
 } from '@/common/rewards/reward-emitter';
 import { createConfirmJolicoinModal, createPaymentJolicoinModal } from '@jolibox/ui';
 import { innerFetch as fetch } from '../network';
@@ -18,13 +20,34 @@ import { StandardResponse } from '@jolibox/types';
 import { context } from '@/common/context';
 import { login } from '../api/login';
 
+import { createEventPromiseHandler } from '@/common/rewards/registers/utils/event-listener';
+import {
+  checkUseModalFrequency,
+  updateUseModalFrequency,
+  checkPaymentFrequency,
+  updatePaymentFrequency
+} from './check-frequency';
+const modalUseFrequencyConfig = createEventPromiseHandler<
+  IUseModalFrequencyConfig,
+  typeof UseModalFrequencyEventName
+>(rewardsEmitter, UseModalFrequencyEventName);
+
+modalUseFrequencyConfig.getData();
+
 /**
  * confirm jolicoin modal
  */
-rewardsEmitter.on(UseModalEventName, (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', params: IUseModalEvent) => {
+rewardsEmitter.on(UseModalEventName, async (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', params: IUseModalEvent) => {
   if (type === 'ADS-JOLI_COIN') {
     //TODO
     console.log('use modal show by frequency');
+    const config = await modalUseFrequencyConfig.getData();
+    const canShowUseModal = await checkUseModalFrequency(config.joliCoinUseAndCharge.useJolicoin);
+    if (!canShowUseModal) {
+      // return by frequency control
+      rewardsEmitter.emit(UseModalResultEventName, { useModalResult: 'CONFIRM' });
+      return;
+    }
   }
   const modal = createConfirmJolicoinModal({
     data: {
@@ -51,6 +74,8 @@ rewardsEmitter.on(UseModalEventName, (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', param
       }
     }
   });
+
+  await updateUseModalFrequency();
 });
 
 /**
@@ -63,6 +88,13 @@ rewardsEmitter.on(
       // handle showup frequecy
       if (type === 'ADS-JOLI_COIN') {
         //
+        const config = await modalUseFrequencyConfig.getData();
+        const canShowPaymentModal = await checkPaymentFrequency(config.joliCoinUseAndCharge.charge);
+        if (!canShowPaymentModal) {
+          // return by frequency control
+          rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'SUCCESS' });
+          return;
+        }
         console.log('show by frequency');
       }
 
@@ -107,6 +139,8 @@ rewardsEmitter.on(
           }
         }
       });
+
+      await updatePaymentFrequency();
     } catch (error) {
       console.info('payment failed', error);
       rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });

package/src/native/rewards/utils.ts

@@ -0,0 +1,7 @@
+export const filterTodayTimestamps = (timestamps: number[]): number[] => {
+  const now = new Date();
+  const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+  const todayEnd = todayStart + 24 * 60 * 60 * 1000;
+
+  return timestamps.filter((timestamp) => timestamp >= todayStart && timestamp < todayEnd);
+};