@jolibox/implement 1.1.4-beta.10

package/src/common/context/index.ts

@@ -0,0 +1,85 @@
+import { mergeArray, mergeWith } from '@jolibox/common';
+import { DeviceInfo, HostInfo, HostUserInfo, SdkInfo } from './types';
+import { Env } from '@jolibox/types';
+import { parseUrlQuery } from './url-parse';
+import { getAppVersion, getDeviceId } from '../http/xua';
+
+declare const globalThis: {
+  joliboxJSCore?: {
+    env: () => Env | undefined;
+  };
+};
+
+const defaultEnv: Env = {
+  deviceInfo: {
+    brand: 'UnknownBrand',
+    model: 'UnknownModel',
+    did: getDeviceId(),
+    pixelRatio: window.devicePixelRatio || 1,
+    platform: 'h5',
+    system: 'UnknownSystemVersion',
+    lang: 'zh'
+  },
+  sdkInfo: {
+    nativeSDKVersion: '',
+    jssdkVersion: getAppVersion()
+  },
+  schema: '',
+  platform: 'h5'
+};
+
+const nativeEnv = globalThis.joliboxJSCore?.env;
+
+const env = Object.assign({}, nativeEnv?.() ?? defaultEnv);
+
+const wrapContext = () => {
+  const { payloadJson, headerJson } = parseUrlQuery(env.schema);
+  const defaultSessionId = `${env.deviceInfo.did}-${new Date().getTime()}`;
+  const urlParams = new URLSearchParams(env.schema.length ? env.schema : window.location.search);
+  const defaultGameID = urlParams.get('appId') ?? urlParams.get('gameId') ?? '';
+  const sessionId = payloadJson.sessionId ?? urlParams.get('sessionId') ?? defaultSessionId;
+  const testAdsMode = !!(payloadJson.testAdsMode ?? urlParams.get('testAdsMode') === 'true');
+  const joliboxEnv = payloadJson.joliboxEnv ?? urlParams.get('joliboxEnv') ?? 'production';
+  const testMode = joliboxEnv === 'staging';
+
+  return {
+    get testMode(): boolean {
+      return testMode; // TODO: true test mode
+    },
+    get testAdsMode(): boolean {
+      return testAdsMode;
+    },
+    get joliboxEnv() {
+      return joliboxEnv;
+    },
+    get mpId(): string {
+      return defaultGameID ?? payloadJson['id'];
+    },
+    get mpVersion(): string {
+      return headerJson.ver ?? getAppVersion();
+    },
+    get platform(): Env['platform'] {
+      return env.platform;
+    },
+    get deviceInfo(): DeviceInfo {
+      return env.deviceInfo;
+    },
+    get sdkInfo(): SdkInfo {
+      return env.sdkInfo;
+    },
+    get hostInfo(): HostInfo {
+      return env.hostInfo;
+    },
+    get hostUserInfo(): HostUserInfo {
+      return env.hostUserInfo;
+    },
+    get sessionId(): string {
+      return env.clientSessionId ?? sessionId ?? defaultSessionId;
+    },
+    onEnvConfigChanged: (newConfig: Partial<Env>) => {
+      mergeWith(env, newConfig, mergeArray);
+    }
+  };
+};
+
+export const context = wrapContext();

package/src/common/context/types.ts

@@ -0,0 +1,5 @@
+import { Env } from '@jolibox/types';
+export type DeviceInfo = Env['deviceInfo'];
+export type HostInfo = Env['hostInfo'];
+export type SdkInfo = Env['sdkInfo'];
+export type HostUserInfo = Env['hostUserInfo'];

package/src/common/context/url-parse.ts

@@ -0,0 +1,63 @@
+import { InternalSchemaParseError } from '@jolibox/common';
+import { reportError } from '../report/errors/report';
+
+interface HeaderJson {
+  ver?: string;
+  channel?: string;
+  subChannel?: string;
+}
+
+interface PayloadJson {
+  id?: string;
+  testAdsMode?: boolean;
+  joliboxEnv?: 'staging' | 'production';
+  sessionId?: string;
+}
+
+interface Signature {
+  headerSig?: string;
+  payloadSig?: string;
+}
+
+interface QueryParams {
+  headerJson: HeaderJson;
+  payloadJson: PayloadJson;
+  signature: Signature;
+}
+
+const base64UrlDecode = <T>(input: string): T => {
+  const base64 = input.replace(/-/g, '+').replace(/_/g, '/');
+  const padding = base64.length % 4 === 0 ? '' : '='.repeat(4 - (base64.length % 4));
+  const jsonStr = atob(base64 + padding);
+  try {
+    return JSON.parse(jsonStr) as T;
+  } catch (e) {
+    return {} as T;
+  }
+};
+
+export const parseUrlQuery = (url: string): QueryParams => {
+  try {
+    const urlObj = new URL(url);
+    const params = urlObj.searchParams;
+
+    const joli_source = params.get('joliSource')?.split('.');
+    if (joli_source?.length) {
+      const [headerJsonStr, payloadJsonStr, signatureJsonStr] = joli_source;
+      return {
+        headerJson: base64UrlDecode<HeaderJson>(headerJsonStr),
+        payloadJson: base64UrlDecode<PayloadJson>(payloadJsonStr),
+        signature: base64UrlDecode<Signature>(signatureJsonStr)
+      };
+    } else {
+      throw `joli_source is missing`;
+    }
+  } catch (e) {
+    reportError(new InternalSchemaParseError(`${url} not a valid schema: ${e}`));
+    return {
+      headerJson: {},
+      payloadJson: {},
+      signature: {}
+    };
+  }
+};

package/src/common/http/index.ts

@@ -0,0 +1,29 @@
+export interface IHttpClient {
+  get<T>(
+    path: string,
+    {
+      query,
+      headers,
+      timeout
+    }: {
+      query?: Record<string, string>;
+      headers?: Record<string, string>;
+      timeout?: number;
+    }
+  ): Promise<T>;
+
+  post<T = any>(
+    path: string,
+    {
+      data,
+      query,
+      headers,
+      timeout
+    }: {
+      data?: any;
+      query?: Record<string, string>;
+      headers?: Record<string, string>;
+      timeout?: number;
+    }
+  ): Promise<T>;
+}

package/src/common/http/uuid.ts

@@ -0,0 +1,11 @@
+export const uuidv4 = () => {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+
+export const isValidUUIDV4 = (uuid: string) => {
+  return /^[\da-f]{8}-[\da-f]{4}-4[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/i.test(uuid);
+};

package/src/common/http/xua.ts

@@ -0,0 +1,79 @@
+import { uuidv4 } from './uuid';
+
+export const platform = {
+  isiOS:
+    navigator.userAgent.includes('iPhone') ||
+    navigator.userAgent.includes('iPod') ||
+    navigator.userAgent.includes('iPad') ||
+    navigator.userAgent.includes('iPhone OS'),
+  iosVersion: () => {
+    const v = navigator.appVersion.match(/OS (\d+)_(\d+)_?(\d+)?/) as string[];
+    return [parseInt(v[1], 10), parseInt(v[2], 10), parseInt(v[3] || '0', 10)];
+  },
+  isAndroid: navigator.userAgent.includes('Android'),
+  isMac: navigator.userAgent.includes('Mac'),
+  isFacebook: navigator.userAgent.includes('FB_IAB'),
+  isPC: !navigator.userAgent.includes('iPhone') && !navigator.userAgent.includes('Android')
+};
+
+export const getPlatform = () => {
+  if (platform.isiOS) {
+    return 'iOS';
+  } else if (platform.isAndroid) {
+    return 'Android';
+  } else if (platform.isMac) {
+    return 'Mac';
+  } else if (platform.isFacebook) {
+    return 'Facebook';
+  } else {
+    return 'PC';
+  }
+};
+
+const jssdkVersion = '__JOLIBOX_LOCAL_SDK_VERSION__';
+
+export const getAppVersion = () => {
+  return jssdkVersion;
+};
+
+export const DEVICE_ID = 'device_id';
+export const ADVERTISING_ID = 'advertising_id';
+
+export const getStorage = (cookieKey: string) => {
+  if (!localStorage.getItem(cookieKey)) {
+    localStorage.setItem(cookieKey, uuidv4());
+  }
+  return localStorage.getItem(cookieKey)!;
+};
+
+export const getDeviceId = () => {
+  return getStorage(DEVICE_ID);
+};
+
+export const getAdvertisingId = () => {
+  return getStorage(ADVERTISING_ID);
+};
+
+const firstCharUpperCase = (chars: string) => chars.charAt(0).toUpperCase() + chars.slice(1);
+
+export const getUtmSource = () => {
+  const urlParams = new URLSearchParams(window.location.search);
+  return firstCharUpperCase(urlParams.get('utm_source') ?? '') || 'JoliboxSDK';
+};
+
+export const xUserAgent = () => {
+  const applicationName = 'JoliboxWebSDK';
+  const thePlatform = getPlatform();
+  const locale = navigator.language;
+  const deviceId = getDeviceId();
+  const adid = getAdvertisingId();
+  const appVersion = getAppVersion();
+  //   const parserResult = getUAParser();
+  //   const deviceModel = parserResult.device.model;
+  const deviceModel = 'UnknownModel';
+  //   const systemVersion = parserResult.os.version;
+  const systemVersion = 'UnknownSystemVersion';
+  return `${applicationName} (${getUtmSource()}${thePlatform}; ${deviceModel}; ${systemVersion}; ${locale}) uuid/${deviceId} adid/${adid} version/${
+    appVersion || ''
+  }`;
+};

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

@@ -0,0 +1,134 @@
+import { context } from '@/common/context';
+import { logger } from '@jolibox/common';
+import { IDevice, IPage, IEventPackage, IEvent, EProject } from '@/common/report/types';
+
+const keysOfPage: (keyof IPage)[] = ['name', 'params'];
+const keysOfEvent: (keyof IEvent)[] = ['name', 'type', 'location', 'target', 'extra', 'timestamp', 'userId'];
+const keysOfDevice: (keyof IDevice)[] = [
+  'platform',
+  'os',
+  'appVersion',
+  'appId',
+  'model',
+  'brand',
+  'uuid',
+  'jsSdkVersion',
+  'extra'
+];
+function serializeObject<T>(obj: T, order: (keyof T)[]): any[] {
+  return order.map((key) => {
+    if (key === 'params' && obj[key]) {
+      const params = obj[key] as Record<string, any>;
+      return Object.keys(params).reduce((acc, k) => {
+        acc[k] = String(params[k]);
+        return acc;
+      }, {} as Record<string, any>);
+    }
+    return obj[key];
+  });
+}
+
+function serializeEvent(event: IEvent): any[] {
+  const location = event.location ? serializeObject(event.location, keysOfPage) : null;
+  const target = event.target ? serializeObject(event.target, keysOfPage) : null;
+
+  // 定义IEvent的序列化顺序
+  return serializeObject({ ...event, location, target }, keysOfEvent);
+}
+
+function serializeEventPackage(eventPackage: IEventPackage): any[] {
+  // 序列化事件数组
+  const events = eventPackage.events.map((event) => serializeEvent(event));
+
+  // 定义IDevice的序列化顺序
+  const device = serializeObject(eventPackage.device, keysOfDevice);
+
+  return [eventPackage.protocolVersion, events, device, eventPackage.project];
+}
+
+export abstract class EventTracker {
+  deviceInfo: IDevice | null = null;
+
+  abstract doReport(event: unknown[]): void;
+  abstract doReport<T extends Record<string, unknown>>(event: unknown[], extra: T): void;
+  abstract doReport<T extends Record<string, unknown>>(event: unknown[], extra?: T): void;
+
+  private pastTrackings: boolean[] = [];
+
+  private pushPastTracking = (tracking: boolean) => {
+    this.pastTrackings.push(tracking);
+    if (this.pastTrackings.length > 10) {
+      this.pastTrackings.slice(-10);
+    }
+  };
+
+  public get networkIsOk() {
+    // in the past 10 trackings, at least 60% of them are successful
+    return (
+      this.pastTrackings.length <= 4 ||
+      this.pastTrackings.filter(Boolean).length / this.pastTrackings.length >= 0.6
+    );
+  }
+
+  getDevice(): IDevice {
+    const { nativeSDKVersion, jssdkVersion } = context.sdkInfo;
+    return {
+      platform: 1000,
+      os: context.deviceInfo.platform,
+      appVersion: nativeSDKVersion ?? jssdkVersion ?? '1.0.0', // mock
+      appId: context.hostInfo?.aid ?? '1',
+      model: context.deviceInfo.model ?? 'UnknownModel',
+      brand: context.deviceInfo.brand ?? 'UnknownBrand',
+      uuid: context.deviceInfo.did,
+      jsSdkVersion: jssdkVersion, // mock
+      extra: {}
+    };
+  }
+
+  getLocation(): IPage {
+    const urlParams = new URLSearchParams(window.location.search);
+    const params: Record<string, any> = {};
+    urlParams.forEach((value, key) => {
+      params[key] = value;
+    });
+    return {
+      name: 'GamePage',
+      params
+    };
+  }
+
+  async trackEvent(event: IEvent, project: EProject, extraInfo?: Record<string, unknown>) {
+    const location = event.location ? event.location : await this.getLocation();
+    const target = event.target || null;
+    const extra = event.extra || null;
+    if (!this.deviceInfo) {
+      this.deviceInfo = await this.getDevice();
+    }
+    const device = this.deviceInfo;
+    const events: IEvent[] = [
+      {
+        ...event,
+        location,
+        target,
+        extra,
+        timestamp: Date.now(),
+        userId: null
+      }
+    ];
+    const eventPackage: IEventPackage = {
+      protocolVersion: '1.0.0',
+      events,
+      device,
+      project
+    };
+    try {
+      extraInfo
+        ? this.doReport(serializeEventPackage(eventPackage), extraInfo)
+        : this.doReport(serializeEventPackage(eventPackage));
+      this.pushPastTracking(true);
+    } catch (e) {
+      this.pushPastTracking(false);
+      logger.log('[Jolibox SDK] report API error', e);
+    }
+  }
+}

package/src/common/report/create-trace.ts

@@ -0,0 +1,17 @@
+import { createTrack, createTrackPerformance } from './track';
+import { Track, TrackPerformance, ReportHandler, CommonReportConfig } from './types';
+
+interface Tracks {
+  track: Track;
+  trackPerformance: TrackPerformance;
+}
+
+export function createTracks(reportHandler: ReportHandler, common: CommonReportConfig): Tracks {
+  const track = createTrack(reportHandler, common);
+  const trackPerformance = createTrackPerformance(track);
+
+  return {
+    track,
+    trackPerformance
+  };
+}

package/src/common/report/errors/error-types.ts

@@ -0,0 +1,206 @@
+type InternalLifeCycleErrorName = 'INTERNAL_GAME_LAUNCH_ERROR';
+
+// API
+type InternalAPIErrorName = 'INTERNAL_API_ERROR';
+
+// 前端埋点
+type InternalMetricErrorName = 'INTERNAL_METRIC_REPORT_ERROR';
+
+// reporter
+type InternalReporterErrorName = 'INTERNAL_REPORTER_ERROR';
+
+// 内部错误
+type InternalUtilErrorName = 'INTERNAL_BUFFER_ERROR' | 'INTERNAL_SCHEMA_PARSE_ERROR';
+
+// Native Inject Error
+type InternalInjectErrorName = 'INTERNAL_CONTEXT_ERROR' | 'INTERNAL_JSCORE_ERROR';
+
+type InternalBridgeErrorName =
+  | 'INTERNAL_INVOKE_NATIVE_ERROR'
+  | 'INTERNAL_APPLY_NATIVE_ERROR'
+  | 'INTERNAL_INVOKE_METHOD_ERROR';
+
+// User
+type UserErrorName =
+  | 'USER_VALIDATE_ERROR'
+  | 'USER_GLOBAL_ERROR'
+  | 'USER_FETCH_ERROR'
+  | 'API_ERROR'
+  | 'USER_CUSTOM_ERROR';
+
+export type ErrorName =
+  | InternalLifeCycleErrorName
+  | InternalInjectErrorName
+  | InternalAPIErrorName
+  | InternalBridgeErrorName
+  | InternalUtilErrorName
+  | InternalReporterErrorName
+  | UserErrorName
+  | InternalMetricErrorName;
+
+export type ErrorKind = 'INTERNAL_ERROR' | 'USER_ERROR' | 'API_ERROR';
+export type ErrorEnv = 'native' | 'h5';
+export type LoadScriptError = BaseError & { code?: number };
+export enum LoadScriptCode {
+  DEVELOPER_FILE_NOT_FOUND = 0,
+  INTERNAL_IOS_CAN_NOT_FOUND_PKG = 1,
+  USER_IOS_LOAD_TIMEOUT = 2,
+  INTERNAL_IOS_PKG_LOAD_ERROR = 3,
+  INTERNAL_IOS_PKG_PARSE_FAIL = 4,
+  USER_IOS_GET_EMPTY_DATA = 5,
+  USER_ANDROID_GET_PKG_FAIL = 6,
+  DEVELOPER_ANDROID_PACKAGE_FILE_UNEXPECTED_REQUIRE = 7
+}
+
+export abstract class BaseError extends Error {
+  abstract kind: ErrorKind;
+  abstract name: ErrorName;
+  priority: 'P0' | 'P1';
+  env?: ErrorEnv;
+  raw?: Error;
+  component?: string;
+  constructor(error: string | Error) {
+    if (typeof error === 'string') {
+      super(error);
+      this.priority = 'P1';
+      return;
+    }
+    super(error.message);
+    this.priority = 'P1';
+    this.stack = error.stack;
+    this.raw = error;
+  }
+}
+
+export abstract class InternalError extends BaseError {
+  readonly kind = 'INTERNAL_ERROR';
+}
+export abstract class UserError extends BaseError {
+  readonly kind = 'USER_ERROR';
+}
+
+export class UserValidateError extends UserError {
+  readonly name = 'USER_VALIDATE_ERROR';
+}
+
+export class UserGlobalError extends UserError {
+  readonly name = 'USER_GLOBAL_ERROR';
+  readonly priority = 'P0';
+}
+
+export class UserCustomError extends UserError {
+  readonly name = 'USER_CUSTOM_ERROR';
+  errMsg: string;
+  extra?: { [key: string]: unknown };
+
+  constructor(readonly message: string, readonly errNo?: number, extra?: { [key: string]: unknown }) {
+    super(message);
+    this.errMsg = message;
+
+    if (extra) {
+      this.extra = Object.assign({}, this.extra, extra);
+    }
+  }
+}
+
+export class UserFetchError extends UserError {
+  readonly name = 'USER_FETCH_ERROR';
+  errMsg: string;
+  extra?: { [key: string]: unknown };
+
+  constructor(readonly message: string, readonly errNo?: number, extra?: { [key: string]: unknown }) {
+    super(message);
+    this.errMsg = message;
+
+    if (extra) {
+      this.extra = Object.assign({}, this.extra, extra);
+    }
+  }
+}
+
+export class InternalSchemaParseError extends InternalError {
+  readonly name = 'INTERNAL_SCHEMA_PARSE_ERROR';
+  readonly priority = 'P0';
+}
+
+export class InternalInvokeNativeError extends InternalError {
+  readonly name = 'INTERNAL_INVOKE_NATIVE_ERROR';
+}
+
+export class InternalApplyNativeError extends InternalError {
+  readonly name = 'INTERNAL_APPLY_NATIVE_ERROR';
+  errorType?: string;
+  errorCode?: number;
+  constructor(message: string, readonly errNo?: number, errorType?: string, errorCode?: number) {
+    super(message);
+    this.errorType = errorType;
+    this.errorCode = errorCode;
+  }
+}
+
+export class InternalInvokeMethodError extends InternalError {
+  readonly name = 'INTERNAL_INVOKE_METHOD_ERROR';
+}
+
+export class InternalJSCoreNotFoundError extends InternalError {
+  readonly name = 'INTERNAL_JSCORE_ERROR';
+}
+
+export class InternalBufferError extends InternalError {
+  readonly name = 'INTERNAL_BUFFER_ERROR';
+}
+
+export class InternalContextError extends InternalError {
+  readonly name = 'INTERNAL_CONTEXT_ERROR';
+  readonly property: string;
+  constructor(readonly message: string, property: string) {
+    super(message);
+    this.property = property;
+  }
+}
+
+export class APIError extends BaseError {
+  readonly kind = 'API_ERROR';
+  readonly name = 'API_ERROR';
+  extra?: Record<string, unknown>;
+  errorType?: string;
+
+  constructor(
+    readonly message: string,
+    readonly code: number,
+    errorType?: string,
+    stack?: string,
+    priority?: 'P0' | 'P1'
+  ) {
+    super(message);
+
+    if (errorType) {
+      this.errorType = errorType;
+    }
+
+    if (stack !== undefined) {
+      this.stack = stack;
+    }
+    if (priority) {
+      this.priority = priority;
+    }
+  }
+
+  toJSON() {
+    return {
+      message: this.message,
+      stack: this.stack,
+      name: this.name,
+      code: this.code,
+      errorType: this.errorType
+    };
+  }
+}
+
+export class InternalMetricReportError extends InternalError {
+  readonly name = 'INTERNAL_METRIC_REPORT_ERROR';
+}
+
+export class InternalReporterError extends InternalError {
+  readonly name = 'INTERNAL_REPORTER_ERROR';
+}

package/src/common/report/errors/index.ts

@@ -0,0 +1,20 @@
+import './report';
+import { APIError, UserCustomError } from '@jolibox/common';
+
+export function formatErrorCode(method: string, code?: number) {
+  return `[${method}]:${code}`;
+}
+
+// 创建APIError异常对象
+export const createAPIError = (
+  error: { code: number; msg: string; type?: string },
+  params?: { errNo?: number; errMsg?: string }
+) => {
+  return new APIError(params?.errMsg ?? error.msg ?? '', error.code, error.type);
+};
+
+export const createUserAPIError = (msg: string) => {
+  return new UserCustomError(msg);
+};
+
+export { errorReportEmitter, ErrorData } from './report';