@jolibox/implement 1.1.4-beta.4

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

@@ -0,0 +1,13 @@
+export declare const createAPI: <ParamsSchema extends import("@/common/api-factory/validator").Validator<unknown[]>, Inputs extends import("@/common/api-factory/validator").Type<ParamsSchema> & unknown[], Return>(method: string, config: {
+    paramsSchema?: ParamsSchema;
+    implement: Inputs extends undefined ? () => Promise<Return | import("@jolibox/types").StandardResponse<Return>> : (...params: Inputs) => Promise<Return | import("@jolibox/types").StandardResponse<Return>>;
+}) => (...inputs: unknown[]) => Promise<import("@jolibox/types").StandardResponse<Return>>, createSyncAPI: <ParamsSchema extends import("@/common/api-factory/validator").Validator<unknown[]>, Inputs extends import("@/common/api-factory/validator").Type<ParamsSchema> & unknown[], Return = void>(method: string, config: {
+    paramsSchema?: ParamsSchema;
+    implement: (...inputs: Inputs) => Return | {
+        code: import("@jolibox/types").ResponseType;
+        data: Return;
+    };
+}) => (...inputs: Inputs) => import("@jolibox/types").StandardResponse<Return>;
+export declare const registerCanIUse: (name: string, config: import("@jolibox/common").CanIUseInfo) => void;
+import { t } from '@/common/api-factory/validator';
+export { t };

package/dist/native/api/get-system-info.d.ts

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

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

@@ -0,0 +1,7 @@
+import './get-system-info';
+import './lifecycle';
+import './request';
+import './storage';
+import './keyboard';
+import './task';
+import './login';

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

@@ -0,0 +1,3 @@
+export declare const showKeyboard: (...inputs: unknown[]) => Promise<import("@jolibox/types").StandardResponse<void>>;
+export declare const updateKeyboard: (...inputs: unknown[]) => Promise<import("@jolibox/types").StandardResponse<void>>;
+export declare const hideKeyboard: (...inputs: unknown[]) => Promise<import("@jolibox/types").StandardResponse<void>>;

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

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

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

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

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

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

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

@@ -0,0 +1,25 @@
+import { StandardResponse } from '@jolibox/types';
+/**
+ * 移除指定key
+ */
+export declare const removeStorage: (...inputs: unknown[]) => Promise<StandardResponse<void>>;
+/**
+ * 异步获取当前storage的相关信息
+ */
+export declare const getStorageInfo: (...inputs: unknown[]) => Promise<StandardResponse<{
+    currentSize: number;
+    limitSize: number;
+    keys: string[];
+}>>;
+/**
+ * 同步获取当前storage的相关信息
+ */
+export declare const getStorageInfoSync: () => StandardResponse<{
+    errMsg: string;
+    errNo?: number;
+    data: {
+        currentSize: number;
+        limitSize: number;
+        keys: string[];
+    };
+}>;

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

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

package/dist/native/bootstrap/bridge.d.ts

@@ -0,0 +1,4 @@
+import { On } from '../js-bridge';
+export declare const applyNative: jsb.service.ApplyNative, invokeNative: jsb.service.InvokeNative, onNative: jsb.service.OnNative, offNative: jsb.service.OnNative, subscribeHandler: import("../js-bridge").SubscribeHandler;
+export declare const onNativeWithError: On;
+export { RuntimeLoader } from '../js-core';

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

@@ -0,0 +1 @@
+export declare function config(): void;

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

@@ -0,0 +1,5 @@
+export declare const CUSTOM_EVENT_PREFIX = "custom_event_";
+export declare const HOST_EVENT_PREFIX = "host_event_";
+export declare const BUFFER_METHODS: string[];
+export declare const BACKGROUND_FORBIDDEN_METHODS: string[];
+export declare const SYNC_METHODS: string[];

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

@@ -0,0 +1,2 @@
+export { createBridge } from './js-bridge';
+export * from './types';

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,20 @@
+/**
+ * 任务上报
+ */
+import { TaskTracker, TaskPoint } from '@/common/report/task-track';
+import { EventEmitter } from '@jolibox/common';
+type NativeTaskPointEvent = 'OPEN_GAME' | 'CLOSE_GAME' | 'LEVEL_FINISHED' | 'TASK_FINISHED' | 'LEVEL_UPGRADE' | 'HISTORY_USER_LEVEL' | 'HISTORY_USER_SCORE' | 'TASK_PAYMENT' | 'TASK_EVENT';
+export type NativeTaskPoint = {
+    event: NativeTaskPointEvent;
+    params: Record<string, unknown>;
+};
+export declare class NativeTaskTracker extends TaskTracker {
+    private gameId;
+    private sessionId;
+    constructor(eventEmitter: EventEmitter<{
+        visible: [boolean];
+    }>, interval?: number);
+    reporter(point: TaskPoint): Promise<void>;
+    reportToNative(point: NativeTaskPoint): Promise<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.4 clean
+> rimraf ./dist
+
+
+> @jolibox/implement@1.1.4-beta.4 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 implementation for Native && H5",
+  "version": "1.1.4-beta.4",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "license": "MIT",
+  "dependencies": {
+    "@jolibox/common": "1.1.4-beta.4",
+    "@jolibox/types": "1.1.4-beta.4",
+    "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"
+}