@jolibox/implement 1.2.4 → 1.2.5-beta.3

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

@@ -1,38 +1,44 @@
 import { IPaymentChoice } from '@/common/rewards/reward-emitter';
 import type { PaymentResult } from './payment-helper';
+import { RequestCacheService } from '@jolibox/common';
 type PaymentPurchaseType = 'JOLI_COIN' | 'JOLI_GEM';
-export interface CachedPaymentChoices {
-    choices: IPaymentChoice[];
-    timestamp: number;
-    expiresAt: number;
-    productIds: string[];
+type PaymentRequest = Record<string, never>;
+interface PaymentResponse {
+    balance: number;
+    enableAutoDeduct: boolean;
+    paymentChoices: IPaymentChoice[];
 }
-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<{
+interface PaymentCacheData {
+    paymentChoices: IPaymentChoice[];
+}
+interface PaymentRealTimeData {
+    balance: number;
+    enableAutoDeduct: boolean;
+}
+declare class BasePaymentService extends RequestCacheService<PaymentRequest, PaymentResponse, PaymentCacheData, PaymentRealTimeData> {
+    private apiEndpoint;
+    private paymentType;
+    private static failureCounters;
+    private static readonly MAX_FAILURE_COUNT;
+    constructor(apiEndpoint: string, paymentType: PaymentPurchaseType);
+    getProductsInfo(): Promise<PaymentResponse | undefined>;
+    purchase(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;
+    getProductsInfoWithBalance(): Promise<PaymentResponse | undefined>;
+    refreshProductsInfo(): Promise<PaymentResponse | undefined>;
+    static resetFailureCounters(): void;
+    static getFailureCount(endpoint: string): number;
+}
+export declare class JoliCoinPaymentService extends BasePaymentService {
+    constructor();
+}
+export declare class JoliGemPaymentService extends BasePaymentService {
+    constructor();
 }
+export declare const createJoliCoinPaymentService: () => JoliCoinPaymentService;
+export declare const createJoliGemPaymentService: () => JoliGemPaymentService;
+export declare const clearNativePriceCache: () => void;
+export declare const resetFailureCounters: () => void;
+export declare const getFailureCount: (endpoint: string) => number;
 export {};

package/implement.build.log

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

package/src/common/report/base-tracker.ts

@@ -22,12 +22,12 @@ export abstract class EventTracker {
 
   private samplesConfig: ISamplesConfig | null = null;
 
-  constructor() {
+  constructor(readonly apiHost: string) {
     this.fetchSamplesConfig();
   }
 
   private async fetchSamplesConfig() {
-    const host = getApiHost(context.testMode);
+    const host = this.apiHost;
     const path = `${host}/api/fe-configs/js-sdk/samples-config`;
     const samplesConfig = (await (await fetch(path)).json()) as ISamplesConfig;
     this.samplesConfig = samplesConfig;

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

@@ -0,0 +1,258 @@
+import { IHttpClient } from '../http';
+import { RewardsHelper, RewardType } from './reward-helper';
+import { CachedRewardService } from './cached-reward-service';
+import { IUnlockOption } from './type';
+import {
+  UnlockOptionsEventName,
+  UseModalFrequencyEventName,
+  rewardsEmitter,
+  DefaltJoliCoinUseAndCharge,
+  DefaltLoginGuide
+} from './reward-emitter';
+import { hostEmitter } from '@jolibox/common';
+import { StandardResponse, GlobalConfig } from '@jolibox/types';
+
+const priority = () => {
+  return (a: RewardType, b: RewardType) => {
+    // Priority order: GEM > JOLI_COIN > ADS
+    const priorityMap: Record<RewardType, number> = {
+      SUBSCRIPTION: 4,
+      JOLI_GEM: 3,
+      JOLI_GEM_ONLY: 3,
+      JOLI_COIN: 2,
+      JOLI_COIN_ONLY: 2,
+      ADS: 1
+    };
+
+    return priorityMap[b] - priorityMap[a];
+  };
+};
+
+const sortRewards = (rewardsTypes: RewardType[]): RewardType[] => {
+  if (!rewardsTypes.length) return ['ADS'];
+
+  // Handle JOLI_GEM cases
+  if (rewardsTypes.includes('JOLI_GEM')) {
+    if (rewardsTypes.length === 1) {
+      return ['JOLI_GEM_ONLY'];
+    } else if (rewardsTypes.includes('SUBSCRIPTION') && rewardsTypes.length === 2) {
+      return ['SUBSCRIPTION', 'JOLI_GEM_ONLY'];
+    }
+  }
+
+  // Handle JOLI_COIN cases
+  if (rewardsTypes.includes('JOLI_COIN')) {
+    if (rewardsTypes.length === 1) {
+      return ['JOLI_COIN_ONLY'];
+    } else if (rewardsTypes.includes('SUBSCRIPTION') && rewardsTypes.length === 2) {
+      return ['SUBSCRIPTION', 'JOLI_COIN_ONLY'];
+    }
+  }
+
+  return rewardsTypes.sort(priority());
+};
+
+// 创建缓存奖励服务的单例
+let cachedRewardServiceInstance: CachedRewardService | null = null;
+
+function getCachedRewardService(httpClient: IHttpClient): CachedRewardService {
+  if (!cachedRewardServiceInstance) {
+    cachedRewardServiceInstance = new CachedRewardService(httpClient);
+  }
+  return cachedRewardServiceInstance;
+}
+
+/**
+ * 使用缓存的奖励获取器
+ * 优化版本：unlockOptions 使用缓存，余额信息实时获取
+ */
+export const createCachedRewardFetcher = (rewardsHelper: RewardsHelper) => {
+  rewardsHelper.registerRewardsFetcher(async (httpClient: IHttpClient) => {
+    const defaultRewards: RewardType[] = ['ADS'];
+    const cachedRewardService = getCachedRewardService(httpClient);
+
+    try {
+      const res = await cachedRewardService.getUnlockOptions({});
+
+      if (res.code !== 'SUCCESS') {
+        return defaultRewards;
+      }
+      // 发送事件通知
+      rewardsEmitter.emit(UnlockOptionsEventName, {
+        options: res.data?.unlockOptions || [],
+        userJoliCoin: res.extra?.joliCoin || {
+          balance: 0,
+          enableAutoDeduct: false
+        },
+        userGem: res.extra?.joliGem || {
+          balance: 0,
+          enableAutoDeduct: false
+        }
+      });
+
+      const rewardsTypes =
+        res.data?.unlockOptions?.map((option: IUnlockOption) => option.type) || Array.from(defaultRewards);
+
+      return sortRewards(rewardsTypes);
+    } catch (e) {
+      console.error('getRewardOptions error (cached):', e);
+      return defaultRewards;
+    }
+  });
+};
+
+/**
+ * 使用缓存的频率配置获取器
+ * 优化版本：全局配置使用纯缓存
+ */
+export const createCachedRewardFrequencyConfigFetcher = (rewardsHelper: RewardsHelper) => {
+  rewardsHelper.registerRewardFrequencyConfigFetcher(async (httpClient: IHttpClient) => {
+    const cachedRewardService = getCachedRewardService(httpClient);
+
+    try {
+      const res = await cachedRewardService.getGlobalConfig();
+
+      // 发送事件通知
+      rewardsEmitter.emit(UseModalFrequencyEventName, {
+        joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge,
+        loginGuide: res.data?.loginGuide || DefaltLoginGuide
+      });
+
+      res.data &&
+        hostEmitter.emit('onGlobalConfigChanged', {
+          globalConfig: res.data
+        });
+
+      return {
+        joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge,
+        loginGuide: res.data?.loginGuide || DefaltLoginGuide
+      };
+    } catch (e) {
+      console.error('getGlobalConfig error (cached):', e);
+      // 发送兜底事件通知
+      rewardsEmitter.emit(UseModalFrequencyEventName, {
+        joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge,
+        loginGuide: DefaltLoginGuide
+      });
+
+      hostEmitter.emit('onGlobalConfigChanged', {
+        globalConfig: {
+          joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge,
+          loginGuide: DefaltLoginGuide
+        }
+      });
+      return {
+        joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge,
+        loginGuide: DefaltLoginGuide
+      };
+    }
+  });
+};
+
+/**
+ * 获取缓存服务实例（用于手动管理缓存）
+ */
+export const getRewardCacheService = (httpClient: IHttpClient): CachedRewardService => {
+  return getCachedRewardService(httpClient);
+};
+
+/**
+ * 强制刷新奖励数据缓存
+ */
+export const refreshRewardCache = async (httpClient: IHttpClient) => {
+  const cachedRewardService = getCachedRewardService(httpClient);
+  await cachedRewardService.refreshUnlockOptions({});
+  console.log('Reward cache refreshed');
+};
+
+/**
+ * 强制刷新全局配置缓存
+ */
+export const refreshGlobalConfigCache = async (httpClient: IHttpClient) => {
+  const cachedRewardService = getCachedRewardService(httpClient);
+  await cachedRewardService.refreshGlobalConfig();
+  console.log('Global config cache refreshed');
+};
+
+/**
+ * 预热所有缓存
+ */
+export const warmupRewardCache = async (httpClient: IHttpClient) => {
+  const cachedRewardService = getCachedRewardService(httpClient);
+  await cachedRewardService.warmupCache();
+  console.log('Reward cache warmed up');
+};
+
+/**
+ * 清除所有奖励相关缓存
+ */
+export const clearRewardCache = (httpClient: IHttpClient) => {
+  const cachedRewardService = getCachedRewardService(httpClient);
+  cachedRewardService.clearAllCache();
+  console.log('All reward cache cleared');
+};
+
+/**
+ * 获取缓存统计信息
+ */
+export const getRewardCacheStats = (httpClient: IHttpClient) => {
+  const cachedRewardService = getCachedRewardService(httpClient);
+  return cachedRewardService.getCacheStats();
+};
+
+// 保持原有的创建器以便向后兼容
+export const createRewardFetcher = (rewardsHelper: RewardsHelper) => {
+  rewardsHelper.registerRewardsFetcher(async (httpClient: IHttpClient) => {
+    const defaultRewards: RewardType[] = ['ADS'];
+    try {
+      const res = await httpClient.post('/api/games/unlock-options', {});
+      if (res.code !== 'SUCCESS') {
+        return defaultRewards;
+      }
+
+      console.log('-----res fetch reward-----', res);
+      rewardsEmitter.emit(UnlockOptionsEventName, {
+        options: res.data?.unlockOptions || [],
+        userJoliCoin: res.extra?.joliCoin || {
+          balance: 0,
+          enableAutoDeduct: false
+        },
+        userGem: res.extra?.joliGem || {
+          balance: 0,
+          enableAutoDeduct: false
+        }
+      });
+
+      const rewardsTypes =
+        res.data?.unlockOptions?.map((option: IUnlockOption) => option.type) || Array.from(defaultRewards);
+      return sortRewards(rewardsTypes);
+    } catch (e) {
+      console.error('getRewardOptions error:', e);
+      return defaultRewards;
+    }
+  });
+};
+
+export const createRewardFrequencyConfigFetcher = (rewardsHelper: RewardsHelper) => {
+  rewardsHelper.registerRewardFrequencyConfigFetcher(async (httpClient: IHttpClient) => {
+    const res: StandardResponse<GlobalConfig> = await httpClient.get(
+      '/api/fe-configs/web-common/global-config',
+      {}
+    );
+
+    rewardsEmitter.emit(UseModalFrequencyEventName, {
+      joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge,
+      loginGuide: res.data?.loginGuide || DefaltLoginGuide
+    });
+
+    res.data &&
+      hostEmitter.emit('onGlobalConfigChanged', {
+        globalConfig: res.data
+      });
+
+    return {
+      joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge,
+      loginGuide: res.data?.loginGuide || DefaltLoginGuide
+    };
+  });
+};

package/src/common/rewards/cached-reward-service.ts

@@ -0,0 +1,255 @@
+import { RequestCacheService, RequestAdapter } from '@jolibox/common';
+import { IHttpClient } from '../http';
+import { StandardResponse, GlobalConfig } from '@jolibox/types';
+import { IJolicoinRewardOption, IUnlockOption, IJoliCoin, IGem } from './type';
+import { IUseModalFrequencyConfig } from './reward-emitter';
+
+// 定义请求参数类型
+interface RewardRequest {
+  endpoint: string;
+  body?: Record<string, unknown>;
+  method?: 'GET' | 'POST';
+}
+
+interface UnlockOptionsCacheData {
+  unlockOptions: IUnlockOption[];
+  joliCoin: IJoliCoin;
+  joliGem: IGem;
+}
+
+interface UnlockOptionsRealTimeData {
+  timestamp?: number;
+}
+
+// 定义全局配置的缓存数据
+interface GlobalConfigCacheData {
+  joliCoinUseAndCharge: IUseModalFrequencyConfig['joliCoinUseAndCharge'];
+  loginGuide: IUseModalFrequencyConfig['loginGuide'];
+  // 其他全局配置字段
+  [key: string]: unknown;
+}
+
+// 奖励接口适配器
+class RewardRequestAdapter
+  implements
+    RequestAdapter<RewardRequest, IJolicoinRewardOption, UnlockOptionsCacheData, UnlockOptionsRealTimeData>
+{
+  constructor(private httpClient: IHttpClient) {}
+
+  async execute(endpoint: string, options?: RewardRequest): Promise<IJolicoinRewardOption> {
+    const method = options?.method || 'POST';
+    const body = options?.body || {};
+
+    if (method === 'GET') {
+      return await this.httpClient.get<IJolicoinRewardOption>(endpoint, body);
+    } else {
+      return await this.httpClient.post<IJolicoinRewardOption>(endpoint, body);
+    }
+  }
+
+  extractCacheableData(response: IJolicoinRewardOption): UnlockOptionsCacheData {
+    return {
+      unlockOptions: response.data?.unlockOptions || [],
+      joliCoin: response.extra?.joliCoin,
+      joliGem: response.extra?.joliGem || { balance: 0, enableAutoDeduct: false }
+    };
+  }
+
+  extractRealTimeData?: undefined;
+
+  mergeData(cached: UnlockOptionsCacheData, realTime: UnlockOptionsRealTimeData): IJolicoinRewardOption {
+    return {
+      code: 'SUCCESS',
+      message: 'success',
+      data: {
+        unlockOptions: cached.unlockOptions
+      },
+      extra: {
+        joliCoin: cached.joliCoin,
+        joliGem: cached.joliGem
+      }
+    };
+  }
+
+  processCachedData(cached: UnlockOptionsCacheData): IJolicoinRewardOption {
+    return {
+      code: 'SUCCESS',
+      message: 'success from cache',
+      data: {
+        unlockOptions: cached.unlockOptions
+      },
+      extra: {
+        joliCoin: cached.joliCoin,
+        joliGem: cached.joliGem
+      }
+    };
+  }
+}
+
+class GlobalConfigRequestAdapter
+  implements
+    RequestAdapter<
+      RewardRequest,
+      StandardResponse<GlobalConfig & IUseModalFrequencyConfig>,
+      GlobalConfigCacheData,
+      undefined
+    >
+{
+  constructor(private httpClient: IHttpClient) {}
+
+  async execute(
+    endpoint: string,
+    options?: RewardRequest
+  ): Promise<StandardResponse<GlobalConfig & IUseModalFrequencyConfig>> {
+    const method = options?.method || 'GET';
+    const body = options?.body || {};
+
+    if (method === 'GET') {
+      return await this.httpClient.get<StandardResponse<GlobalConfig & IUseModalFrequencyConfig>>(
+        endpoint,
+        body
+      );
+    } else {
+      return await this.httpClient.post<StandardResponse<GlobalConfig & IUseModalFrequencyConfig>>(
+        endpoint,
+        body
+      );
+    }
+  }
+
+  extractCacheableData(
+    response: StandardResponse<GlobalConfig & IUseModalFrequencyConfig>
+  ): GlobalConfigCacheData {
+    const data = response.data;
+    return {
+      joliCoinUseAndCharge: data?.joliCoinUseAndCharge,
+      loginGuide: data?.loginGuide,
+      ...data // 包含其他所有配置字段
+    } as GlobalConfigCacheData;
+  }
+
+  extractRealTimeData?: undefined;
+  mergeData?: undefined;
+
+  processCachedData(
+    cached: GlobalConfigCacheData
+  ): StandardResponse<GlobalConfig & IUseModalFrequencyConfig> {
+    return {
+      code: 'SUCCESS',
+      message: 'success from cache',
+      data: cached as GlobalConfig & IUseModalFrequencyConfig
+    };
+  }
+}
+
+export class CachedRewardService {
+  private unlockOptionsService: RequestCacheService<
+    RewardRequest,
+    IJolicoinRewardOption,
+    UnlockOptionsCacheData,
+    UnlockOptionsRealTimeData
+  >;
+  private globalConfigService: RequestCacheService<
+    RewardRequest,
+    StandardResponse<GlobalConfig & IUseModalFrequencyConfig>,
+    GlobalConfigCacheData,
+    undefined
+  >;
+
+  constructor(httpClient: IHttpClient) {
+    // 创建 unlock-options 服务，缓存 unlockOptions，实时获取余额
+    this.unlockOptionsService = new (RequestCacheService as new (...args: unknown[]) => RequestCacheService<
+      RewardRequest,
+      IJolicoinRewardOption,
+      UnlockOptionsCacheData,
+      UnlockOptionsRealTimeData
+    >)(new RewardRequestAdapter(httpClient), {
+      duration: 30 * 60 * 1000, // 30分钟缓存
+      timeout: 1000, // 1s timeout for request
+      keyGenerator: (endpoint: string) => endpoint,
+      // unlockOptions 结构一致性检查
+      consistencyChecker: (cached: UnlockOptionsCacheData, serverData: UnlockOptionsCacheData) => {
+        if (cached.unlockOptions.length !== serverData.unlockOptions.length) {
+          return false;
+        }
+        return cached.unlockOptions.every((cachedOption: IUnlockOption, index: number) => {
+          const serverOption = serverData.unlockOptions[index];
+          return (
+            cachedOption.type === serverOption.type &&
+            cachedOption.joliGemChoice?.joliGemQuantity === serverOption.joliGemChoice?.joliGemQuantity
+          );
+        });
+      }
+    });
+
+    this.globalConfigService = new (RequestCacheService as new (...args: unknown[]) => RequestCacheService<
+      RewardRequest,
+      StandardResponse<GlobalConfig & IUseModalFrequencyConfig>,
+      GlobalConfigCacheData,
+      undefined
+    >)(new GlobalConfigRequestAdapter(httpClient), {
+      duration: 60 * 60 * 1000, // 60分钟缓存
+      timeout: 1000, // 1s timeout for request
+      keyGenerator: (endpoint: string) => endpoint
+    });
+  }
+
+  async getUnlockOptions(body: Record<string, unknown> = {}): Promise<IJolicoinRewardOption> {
+    return await this.unlockOptionsService.request('/api/games/unlock-options', {
+      endpoint: '/api/games/unlock-options',
+      body,
+      method: 'POST'
+    });
+  }
+
+  async getGlobalConfig(): Promise<StandardResponse<GlobalConfig & IUseModalFrequencyConfig>> {
+    return await this.globalConfigService.request('/api/fe-configs/web-common/global-config', {
+      endpoint: '/api/fe-configs/web-common/global-config',
+      method: 'GET'
+    });
+  }
+  async refreshUnlockOptions(body: Record<string, unknown> = {}): Promise<IJolicoinRewardOption> {
+    return await this.unlockOptionsService.forceRequest('/api/games/unlock-options', {
+      endpoint: '/api/games/unlock-options',
+      body,
+      method: 'POST'
+    });
+  }
+
+  async refreshGlobalConfig(): Promise<StandardResponse<GlobalConfig & IUseModalFrequencyConfig>> {
+    return await this.globalConfigService.forceRequest('/api/fe-configs/web-common/global-config', {
+      endpoint: '/api/fe-configs/web-common/global-config',
+      method: 'GET'
+    });
+  }
+
+  async warmupCache(): Promise<void> {
+    await Promise.all([
+      this.unlockOptionsService.warmupCache('/api/games/unlock-options', {
+        endpoint: '/api/games/unlock-options',
+        method: 'POST'
+      }),
+      this.globalConfigService.warmupCache('/api/fe-configs/web-common/global-config', {
+        endpoint: '/api/fe-configs/web-common/global-config',
+        method: 'GET'
+      })
+    ]);
+  }
+
+  clearAllCache(): void {
+    this.unlockOptionsService.clearCache();
+    this.globalConfigService.clearCache();
+  }
+
+  getCacheStats() {
+    return {
+      unlockOptions: this.unlockOptionsService.getCacheStats(),
+      globalConfig: this.globalConfigService.getCacheStats()
+    };
+  }
+
+  clearExpiredCache(): void {
+    this.unlockOptionsService.clearExpiredCache();
+    this.globalConfigService.clearExpiredCache();
+  }
+}