@jolibox/implement 1.1.4-beta.10

package/dist/native/js-bridge/invoke.d.ts

@@ -0,0 +1,21 @@
+import { InvokeHandler, On } from './types';
+interface Invokes {
+    /** 暴露给宿主, 触发调用的方法 */
+    invokeHandler: InvokeHandler;
+    /** 基础库内部, 调用宿主的方法, 返回 native 返回对象 */
+    invokeNative: (method: string, args?: Record<string, unknown>, webviewId?: number) => any;
+    /** 基础库内部, 调用宿主的方法, 会根据 errMsg throwError */
+    applyNative: (method: string, args?: Record<string, unknown>, webviewId?: number) => any;
+}
+export declare function createInvoke(jsCore: jsb.JSCore, onNative: On): Invokes;
+export declare function ifThrowError(method: string, res: {
+    errMsg?: string;
+    errNo?: number;
+    errorType?: string;
+    errorCode?: number;
+}): {} | undefined;
+export declare class ApplyNativeError extends Error {
+    readonly errNo?: number | undefined;
+    constructor(message: string, errNo?: number | undefined);
+}
+export {};

package/dist/native/js-bridge/js-bridge.d.ts

@@ -0,0 +1,6 @@
+import { JSBridge } from './types';
+/**
+ * build js-bridge
+ * @param jsCore jsCore function inject by native
+ */
+export declare function createBridge(jsCore: jsb.JSCore): JSBridge;

package/dist/native/js-bridge/report.d.ts

@@ -0,0 +1,63 @@
+import { On } from './types';
+type MetricReporter = (points: unknown) => unknown;
+interface MetricCache {
+    [props: string]: MetricCache | (number | string)[];
+}
+interface PVMetricCache {
+    [props: string]: PVMetricCache | number;
+}
+type MetricCacheType = MetricCache | PVMetricCache;
+type MetricType = 'pv' | 'default';
+type Prettier<T> = T extends Record<string, unknown> ? {
+    [K in keyof T]: T[K];
+} : T;
+type MetricPoint<Tag extends string, Name extends string> = Prettier<{
+    [k in Tag]: string;
+} & {
+    [K in Name]: number | string;
+}>;
+interface PVPoint {
+    [props: string]: string | JSON;
+}
+interface MetricConfig<Tag extends string, Name extends string, Type extends string> {
+    reporter: MetricReporter;
+    interval?: number;
+    eventName: string;
+    tagNameOrder: Tag[];
+    metricName: Name;
+    type?: Type;
+}
+export declare class MetricsMonitor<Tag extends string, Name extends string, Type extends string> {
+    reporter: MetricReporter;
+    interval: number;
+    lastReportTime: number;
+    cache: MetricCacheType;
+    eventName: string;
+    tagNameOrder: Tag[];
+    metricName: Name;
+    type: MetricType;
+    constructor(config: MetricConfig<Tag, Name, Type>);
+    report(point: Type extends 'pv' ? PVPoint : MetricPoint<Tag, Name>): void;
+    flush(): void;
+    private tryReport;
+    private addPoint;
+    private addPVPoint;
+    private processPoints;
+    private clearPoints;
+}
+interface InvokeMetrics {
+    errMsg: string;
+    errNo?: number;
+    __timing?: {
+        receiveJSInvoke: number;
+        invokeCallback: number;
+    };
+    method: string;
+    startTime: number;
+    args?: Record<string, unknown>;
+    isForeground: string;
+    [prop: string]: unknown;
+}
+export type reportInvokeFn = (invokeMetrics: InvokeMetrics) => void;
+export declare function createReportInvokeMetrics(jsCore: jsb.JSCore, onNative: On): reportInvokeFn;
+export {};

package/dist/native/js-bridge/subscribe.d.ts

@@ -0,0 +1,8 @@
+import { Off, On } from './types';
+import { AnyFunction } from '@jolibox/types';
+export interface Subscribes {
+    onNative: On;
+    offNative: Off;
+    subscribeHandler: AnyFunction;
+}
+export declare function createSubscribe(jsCore: jsb.JSCore): Subscribes;

package/dist/native/js-bridge/types.d.ts

@@ -0,0 +1,14 @@
+export type Listener = (...args: any[]) => any;
+export type On = <T extends string>(event: T, handler: Listener) => void;
+export type Off = <T extends string>(event: T, handler: Listener) => void;
+export type InvokeHandler = (callbackId: string | number, data: string | Record<string, unknown>) => void;
+export type SubscribeHandler = (event: string, data: string | Record<string, unknown>, webviewId?: number) => void;
+export type AnyFunction = (...args: any[]) => any;
+export interface JSBridge {
+    invokeHandler: InvokeHandler;
+    subscribeHandler: SubscribeHandler;
+    invokeNative: jsb.service.InvokeNative;
+    applyNative: jsb.service.ApplyNative;
+    onNative: jsb.service.OnNative;
+    offNative: jsb.service.OffNative;
+}

package/dist/native/js-bridge/utils.d.ts

@@ -0,0 +1,17 @@
+export interface DataObj {
+    params?: Record<string, unknown>;
+    errorCode?: number;
+    __extra?: {
+        startTime: number;
+        type: string;
+    };
+    __nativeBuffers__?: NativeBufferElement[] | undefined;
+}
+interface NativeBufferElement {
+    key: string;
+    value?: ArrayBuffer;
+    base64?: string;
+}
+export declare function unpack(data: unknown): DataObj;
+export declare function pack(_data?: {}, useArrayBuffer?: boolean): Record<string, unknown>;
+export {};

package/dist/native/js-core/index.d.ts

@@ -0,0 +1,3 @@
+export { joliboxJSCore, RuntimeLoader } from './jolibox-js-core';
+export { messagePort, initMessagePort } from './message-port';
+export { normalizeParams } from './utils';

package/dist/native/js-core/jolibox-js-core.d.ts

@@ -0,0 +1,45 @@
+export declare let joliboxJSCore: jsb.JSCore | undefined;
+declare global {
+    interface Window {
+        JoliAndroidSDKBridge?: {
+            invoke: (invokeString: string) => void;
+            onDocumentReady: (paramsstr: string) => void;
+            doExit: (uuidString: string) => void;
+        };
+        webkit?: {
+            messageHandlers: {
+                invoke: {
+                    postMessage: (params: {
+                        event: string;
+                        callbackId: number;
+                        paramsString: string;
+                    }) => void;
+                };
+                publish: {
+                    postMessage: (params: {
+                        event: string;
+                        webviewIds: string;
+                        paramsString: string;
+                    }) => void;
+                };
+                onDocumentReady: {
+                    postMessage: (params: {
+                        path: string;
+                    }) => void;
+                };
+                doExit: {
+                    postMessage: (params: {
+                        uuid: string;
+                        shouldInterrupt: boolean;
+                    }) => void;
+                };
+            };
+        };
+    }
+}
+export declare const RuntimeLoader: {
+    trigger(): void;
+    exit(): boolean;
+    onReady(fn: () => void): void;
+    doExit(fn: () => boolean): void;
+};

package/dist/native/js-core/message-port.d.ts

@@ -0,0 +1,12 @@
+interface MessageEvent {
+    data: string;
+    ports: MessagePort[];
+}
+interface MessagePort {
+    onmessage: (msg: MessageEvent) => void;
+    postMessage: (msg: string) => void;
+    publish: (event: string, data: Record<string, unknown>) => void;
+}
+export declare let messagePort: MessagePort | undefined;
+export declare function initMessagePort(): void;
+export {};

package/dist/native/js-core/utils.d.ts

@@ -0,0 +1,7 @@
+export declare function normalizeParams(params: Record<string, unknown>, type: string): {
+    params: Record<string, unknown>;
+    __extra: {
+        startTime: number;
+        type: string;
+    };
+};

package/dist/native/network/create-fetch.d.ts

@@ -0,0 +1,27 @@
+import { FetchResponse, FetchOptions } from './types';
+type Fetch = <T>(url: string, innerOptions?: FetchOptions & {
+    baseUrl?: string;
+}) => Promise<{
+    url: string;
+    timeout?: number;
+    method: string;
+    response: FetchResponse<T>;
+}>;
+type PublicFetch = <T>(url: string, options?: FetchOptions) => Promise<{
+    url: string;
+    timeout?: number;
+    method: string;
+    response: FetchResponse<T>;
+}>;
+export declare function createFetch(createMethod: 'createRequestTaskSync', operateMethod: 'operateRequestTaskSync', options?: {
+    baseUrl?: string;
+    type: 'public';
+}): PublicFetch;
+export declare function createFetch(createMethod: 'createRequestTaskSync', operateMethod: 'operateRequestTaskSync', options?: {
+    baseUrl?: string;
+    type: 'inner';
+    defaultHeaders?: Record<string, string>;
+}): Fetch;
+export declare function parseJSON(data: string): any;
+export declare function normalizeData(data: unknown, contentType?: string): string | ArrayBuffer;
+export {};

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

@@ -0,0 +1,11 @@
+/**
+ * inner fetch
+ */
+export declare const innerFetch: <T>(url: string, innerOptions?: import("./types").FetchOptions & {
+    baseUrl?: string;
+}) => Promise<{
+    url: string;
+    timeout?: number;
+    method: string;
+    response: import("./types").FetchResponse<T>;
+}>;

package/dist/native/network/report.d.ts

@@ -0,0 +1,15 @@
+import { FetchResponse, DownLoadResponse, UpLoadResponse, RequestFrom } from './types';
+type NetworkResponse = FetchResponse | DownLoadResponse | UpLoadResponse;
+interface ReportNetworkOptions {
+    state: 'success' | 'fail';
+    params: Record<string, unknown>;
+    response: NetworkResponse;
+    startTime: number;
+    endTime: number;
+    callbackStartTime?: number;
+    callbackEndTime?: number;
+    requestId?: string;
+    requestFrom?: RequestFrom;
+}
+export declare function reportNetworkAPI(method: string, url: string, options: ReportNetworkOptions): void;
+export {};

package/dist/native/network/types.d.ts

@@ -0,0 +1,61 @@
+interface Profile {
+    socketReused?: boolean;
+}
+export interface DownLoadOptions {
+    url: string;
+    header: Record<string, unknown>;
+    filePath?: string;
+    appendHostCookie?: boolean;
+    timeout?: number;
+}
+export interface DownLoadResponse {
+    statusCode?: number;
+    tempFilePath?: string;
+    errMsg?: string;
+    profile?: Profile;
+    filePath?: string;
+    header?: Record<string, string>;
+}
+export type HTTPMethod = 'GET' | 'OPTIONS' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'TRACE' | 'CONNECT' | 'PATCH';
+export interface FetchOptions {
+    method?: HTTPMethod;
+    data?: Record<string, unknown> | string | ArrayBuffer;
+    query?: Record<string, string>;
+    header?: Record<string, string>;
+    dataType?: string;
+    timeout?: number;
+    enableCache?: boolean;
+    responseType?: string;
+    appendHostCookie?: boolean;
+}
+export interface FetchResponse<T = string | JSON | ArrayBuffer | undefined> {
+    header?: Record<string, string>;
+    code?: string;
+    message?: string;
+    data: T;
+    errMsg?: string;
+    prefetchDetail?: number;
+    size?: number;
+    profile?: Profile;
+}
+export interface UpLoadOptions {
+    url: string;
+    filePath: string;
+    name: string;
+    header: Record<string, unknown>;
+    formData: Record<string, unknown>;
+    appendHostCookie?: boolean;
+    timeout?: number;
+}
+export interface UpLoadResponse<T = string | Record<string, unknown> | ArrayBuffer | undefined> {
+    statusCode?: number;
+    data: T;
+    errMsg?: string;
+    progress?: number;
+    profile?: Profile;
+}
+export declare enum RequestFrom {
+    PUBLIC = "public",
+    INNER = "inner"
+}
+export {};

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

@@ -0,0 +1,9 @@
+export type HTTPMethod = 'GET' | 'OPTIONS' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'TRACE' | 'CONNECT' | 'PATCH';
+export declare function normalizeHeader(header: unknown): Record<string, string>;
+export declare function normalizeFormData(formData: unknown): Record<string, string>;
+export declare function normalizeMethod(method?: string): HTTPMethod;
+export declare function normalizeTimeout(time: number | undefined, unlimited?: boolean): number | undefined;
+/**
+ * modify url
+ */
+export declare function dirtyURL(url: string, method: HTTPMethod, data?: unknown): string;

package/dist/native/report/errors/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 端侧上报的实现逻辑
+ */
+import '@/common/report/errors/report/listeners';

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

@@ -0,0 +1,10 @@
+import './errors';
+import { EventEmitter } from '@jolibox/common';
+export * from '../../common/report/types';
+import { NativeTaskTracker } from './task-tracker';
+declare const track: import("@/common/report").Track, trackPerformance: import("@/common/report").TrackPerformance;
+export { track, trackPerformance };
+export declare const nativeTaskEmitter: EventEmitter<{
+    visible: [boolean];
+}, "visible">;
+export declare const taskTracker: NativeTaskTracker;

package/dist/native/report/task-tracker.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 任务上报
+ */
+import { TaskTracker, TaskPoint } from '@/common/report/task-track';
+import { EventEmitter } from '@jolibox/common';
+import type { Track } from '.';
+import type { TrackEvent } from '@jolibox/types';
+type NativeTaskPointEvent = 'OpenGame' | 'CloseGame' | 'LevelFinished' | 'TaskFinished' | 'LevelUpgrade' | 'HistoryUserLevel' | 'HistoryUserScore' | 'UseGameItem' | 'TaskEvent';
+export type NativeTaskPoint = {
+    event: NativeTaskPointEvent;
+    params: Record<string, unknown>;
+};
+export declare class NativeTaskTracker extends TaskTracker {
+    private gameId;
+    private sessionId;
+    private track;
+    constructor(track: Track, eventEmitter: EventEmitter<{
+        visible: [boolean];
+    }>, interval?: number);
+    reporter(point: TaskPoint): Promise<void>;
+    reportToNative(point: NativeTaskPoint): Promise<void>;
+    tracker(event: TrackEvent, info?: Record<string, unknown> | null): void;
+}
+export {};

package/esbuild.config.js

@@ -0,0 +1,66 @@
+const esbuild = require('esbuild');
+const fs = require('fs');
+
+function versionPlugin(version) {
+  return {
+    name: 'version',
+    setup(build) {
+      build.onLoad({ filter: /\.[jt]sx?$/ }, async (args) => {
+        const contents = await fs.promises.readFile(args.path, 'utf8');
+        return {
+          contents: contents.replace(/__JOLIBOX_LOCAL_SDK_VERSION__/g, version),
+          loader: args.path.endsWith('tsx') ? 'tsx' : 'ts'
+        };
+      });
+    }
+  };
+}
+
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {
+      format: 'esm',  // 默认值
+    };
+  
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      
+      if (arg === '--format' || arg === '-f') {
+        const format = args[i + 1];
+        if (['esm', 'cjs', 'iife'].includes(format)) {
+          options.format = format;
+        }
+        i++;
+      }
+    }
+  
+    return options;
+  }
+  
+const options = parseArgs();
+
+function build(format) {
+    return esbuild.build({
+        entryPoints: ['src/index.native.ts', 'src/index.ts'],
+        bundle: true,
+        outdir: 'dist',
+        format: format,
+        minify: true,
+        loader: { 
+          '.ts': 'ts',
+          '.tsx': 'tsx',
+          '.js': 'jsx'
+        },
+        plugins: [versionPlugin(process.env.BUILD_VERSION || '1.0.0')],
+      }); 
+}
+
+(async ()=>{
+    try{
+        await build(options.format);
+    }catch(e) {
+        console.error(e);
+        process.exit(1);
+    }
+})()
+

package/implement.build.log

@@ -0,0 +1,9 @@
+Invoking: npm run clean && npm run build:esm && tsc 
+
+> @jolibox/implement@1.1.4-beta.10 clean
+> rimraf ./dist
+
+
+> @jolibox/implement@1.1.4-beta.10 build:esm
+> BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=esm
+

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@jolibox/implement",
+  "description": "This project is Jolibox JS-SDk implement for Native && H5",
+  "version": "1.1.4-beta.10",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "license": "MIT",
+  "dependencies": {
+    "@jolibox/common": "1.1.4-beta.10",
+    "@jolibox/types": "1.1.4-beta.10",
+    "localforage": "1.10.0"
+  },
+  "devDependencies": {
+    "typescript": "5.7.3",
+    "@types/jest": "28.1.1",
+    "rimraf": "6.0.1",
+    "esbuild": "0.24.2",
+    "@jolibox/eslint-config": "1.0.0"
+  },
+  "scripts": {
+    "clean": "rimraf ./dist",
+    "build": "npm run clean && npm run build:esm && tsc",
+    "build:esm": "BUILD_VERSION=$(node -p \"require('./package.json').version\")  node esbuild.config.js --format=esm",
+    "build:iife": "BUILD_VERSION=$(node -p \"require('./package.json').version\")  node esbuild.config.js --format=iife",
+    "build:cjs": "BUILD_VERSION=$(node -p \"require('./package.json').version\")  node esbuild.config.js --format=cjs",
+    "dev": "tsc --watch",
+    "test": "jest"
+  },
+  "readme": "# Jolibox JSSDK Interface\n"
+}

package/src/common/api-factory/index.ts

@@ -0,0 +1,188 @@
+import { APIError, isArray } from '@jolibox/common';
+
+import { ResponseType, StandardResponse } from '@jolibox/types';
+import { Track } from '../report';
+import { reportError } from '../report/errors/report';
+import { Type, typeAsserts, Validator } from './validator';
+import { createAPIError, createUserAPIError } from '../report/errors';
+
+let traceId = 1;
+
+/**
+ * TODO: 埋点逻辑
+ */
+type Response<T> = T | StandardResponse<T>;
+type SyncFunction<Params extends unknown[], Return> = (
+  ...inputs: Params
+) => Return | { code: ResponseType; data: Return };
+type AsyncFunction<Params extends unknown[], Return> = (
+  ...inputs: Params
+) => Promise<Response<Return> | Return>;
+interface APIFactory {
+  createSyncAPI<Params extends unknown[], Return = void>(
+    method: string,
+    config: {
+      implement: SyncFunction<Params, Return>;
+    }
+  ): (...inputs: Params) => StandardResponse<Return>;
+
+  createAPI<Params extends unknown[], Return = void>(
+    method: string,
+    config: {
+      implement: Params extends undefined ? () => Promise<Return> : AsyncFunction<Params, Return>;
+    }
+  ): (...inputs: unknown[]) => Promise<StandardResponse<Return>>;
+}
+
+export const createAPIFactory = (track: Track) => {
+  /**
+   * create Sync API
+   */
+  function createSyncAPI<
+    ParamsSchema extends Validator<unknown[]>,
+    Inputs extends Type<ParamsSchema> & unknown[],
+    Return = void
+  >(
+    method: string,
+    config: {
+      paramsSchema?: ParamsSchema;
+      implement: (...inputs: Inputs) => Return | { code: ResponseType; data: Return };
+    }
+  ): (...inputs: Inputs) => StandardResponse<Return> {
+    return (...inputs) => {
+      const startTime = Date.now();
+      const reportExtra = { method, trace_id: traceId };
+      traceId += 1;
+
+      let status: ResponseType = 'SUCCESS';
+      let errMsg = `${method}:ok`;
+      let errNo = 0;
+
+      try {
+        // 类型校验
+        if (config.paramsSchema) {
+          try {
+            typeAsserts(config.paramsSchema, inputs, 'params');
+          } catch (err: unknown) {
+            const error = err as { message: string };
+            throw createUserAPIError(`${method}:fail ${error.message}`);
+          }
+        }
+        const res = config.implement(...inputs);
+        let data = res as Return;
+        let message = `${method}:ok`;
+        if (res && 'code' in (res as { code: ResponseType; data: Return })) {
+          const {
+            code,
+            data: originData,
+            message: originMessage
+          } = res as { code: ResponseType; data: Return; message: string };
+          status = code;
+          data = originData;
+          message = originMessage;
+        }
+
+        return {
+          code: status,
+          message,
+          data
+        };
+      } catch (error) {
+        const _error = error as { code?: number; message?: string; errNo?: number; errMsg?: string };
+        errNo = _error.code ?? _error.errNo ?? 2000;
+        status = 'FAILURE';
+        const msg = _error.message ?? _error.errMsg ?? `${error}`;
+        errMsg = `${method}:${status} ${msg.replace(/^\S+:(fail|cancel)\s?/, '')}`;
+        reportError(new APIError(errMsg, errNo));
+        return {
+          code: status,
+          message: errMsg
+        };
+      } finally {
+        const duration = Date.now() - startTime;
+        track('apiInvoked', { ...reportExtra, duration, status });
+      }
+    };
+  }
+
+  /**
+   * Async API
+   */
+
+  function createAPI<
+    ParamsSchema extends Validator<unknown[]>,
+    Inputs extends Type<ParamsSchema> & unknown[],
+    Return
+  >(
+    method: string,
+    config: {
+      paramsSchema?: ParamsSchema;
+      implement: Inputs extends undefined
+        ? () => Promise<Response<Return>>
+        : (...params: Inputs) => Promise<Response<Return>>;
+    }
+  ): (...inputs: unknown[]) => Promise<StandardResponse<Return>> {
+    // 异步 API
+    return async (..._inputs) => {
+      const inputs = isArray(_inputs) ? _inputs : [_inputs];
+
+      const startTime = Date.now();
+      const reportExtra = { method, trace_id: traceId };
+      traceId += 1;
+
+      let message = `${method}:ok`;
+      let status: ResponseType = 'SUCCESS';
+      const res: StandardResponse<Return> = {
+        code: status,
+        message
+      };
+
+      try {
+        if (config.paramsSchema) {
+          try {
+            typeAsserts(config.paramsSchema, inputs, 'params');
+          } catch (error) {
+            throw createUserAPIError((error as Error).message);
+          }
+        }
+
+        const data = await config.implement(...inputs);
+
+        let ret = data as Return;
+        if (ret && 'code' in (ret as unknown as { code: ResponseType; data: Return })) {
+          const {
+            code,
+            data: originData,
+            message: originMessage
+          } = ret as unknown as { code: ResponseType; data: Return; message: string };
+          status = code;
+          message = originMessage;
+          ret = originData;
+        }
+        Object.assign(res, {
+          code: status,
+          message,
+          data: ret
+        });
+        return res;
+      } catch (error: any) {
+        const _error = error as { code?: number; message?: string; errNo?: number; errMsg?: string };
+        const errNo = _error.code ?? _error.errNo ?? 2000;
+        status = 'FAILURE';
+        const msg = _error.message ?? _error.errMsg ?? `${error}`;
+        const errMsg = `${method}:${status} ${msg.replace(/^\S+:(fail|cancel)\s?/, '')}`;
+        Object.assign(res, {
+          code: status,
+          message: errMsg
+        });
+        reportError(new APIError(errMsg, errNo));
+        return res;
+      } finally {
+        const duration = Date.now() - startTime;
+        track('apiInvoked', { ...reportExtra, duration, status });
+      }
+    };
+  }
+
+  return { createAPI, createSyncAPI };
+};