@yuhere/js-jsonrpc2 2.1.11 → 2.1.13

package/dist/stream/stringify-stream.js

@@ -6,7 +6,9 @@ const MAX_GAP_LENGTH = 10;
 const DEFAULT_BUFFER_SIZE = 16 * 1024;
 export async function* stringifyStream(input, options = {}) {
     const { bufferSize: rawBufferSize = DEFAULT_BUFFER_SIZE, space, replacer, } = options;
-    const bufferSize = Math.max(1, rawBufferSize | 0);
+    const bufferSize = Number.isFinite(rawBufferSize)
+        ? Math.max(1, Math.floor(rawBufferSize))
+        : DEFAULT_BUFFER_SIZE;
     const seen = new WeakSet();
     let gap = '';
     if (typeof space === 'number') {
@@ -31,8 +33,19 @@ export async function* stringifyStream(input, options = {}) {
     let buffer = '';
     function* flush(force = false) {
         while (buffer.length >= bufferSize || (force && buffer.length > 0)) {
-            const chunk = buffer.slice(0, bufferSize);
-            buffer = buffer.slice(bufferSize);
+            let end = Math.min(bufferSize, buffer.length);
+            // 不要在 UTF-16 surrogate pair 中间切分
+            if (end < buffer.length) {
+                const prev = buffer.charCodeAt(end - 1);
+                const next = buffer.charCodeAt(end);
+                const isHighSurrogate = prev >= 0xD800 && prev <= 0xDBFF;
+                const isLowSurrogate = next >= 0xDC00 && next <= 0xDFFF;
+                if (isHighSurrogate && isLowSurrogate) {
+                    end++;
+                }
+            }
+            const chunk = buffer.slice(0, end);
+            buffer = buffer.slice(end);
             yield chunk;
         }
     }
@@ -69,7 +82,7 @@ export async function* stringifyStream(input, options = {}) {
     function isTypedArray(value) {
         return ArrayBuffer.isView(value) && !(value instanceof DataView);
     }
-    function prepareValue(value, key) {
+    function prepareValue(value, key, holder) {
         // 1. toJSON（跳过 Buffer）
         if (value !== null &&
             typeof value === 'object' &&
@@ -79,37 +92,30 @@ export async function* stringifyStream(input, options = {}) {
         }
         // 2. replacer
         if (replacerFn) {
-            value = replacerFn.call(key === '' ? undefined : null, key, value);
+            value = replacerFn.call(holder, key, value);
         }
         return value;
     }
-    async function* serialize(value, key, depth) {
-        // ========== 只在这里做一次 prepare ==========
-        value = prepareValue(value, key);
-        // undefined / function / symbol → 由调用方决定（对象省略，数组写 null）
-        if (value === undefined ||
-            typeof value === 'function' ||
-            typeof value === 'symbol') {
-            return;
-        }
+    async function* serialize(value, key, depth, holder) {
+        // 只在这里做一次 prepare
+        value = prepareValue(value, key, holder);
         assertNoBigInt(value);
-        // Promise（replacer 或 toJSON 返回的 Promise 在这里统一处理）
         if (value instanceof Promise) {
             value = await Promise.resolve(value);
-            // 注意：await 之后要重新走完整流程（包括可能的再次 toJSON/replacer？）
-            // 为了与「只 prepare 一次」一致，这里选择不再 prepare，直接递归时跳过 prepare
-            // 最简单且安全的做法：再调一次 serialize（此时 value 已是 resolved 后的值）
-            // 但为了避免对 resolved 后的 number 再次触发 replacer，我们改成内部递归时传一个 flag
             yield* serializePrepared(value, key, depth);
             return;
         }
         yield* serializePrepared(value, key, depth);
     }
-    /** 已经完成 prepare 的值，直接序列化（不再调用 toJSON/replacer） */
+    /**
+     * 已经完成 prepare 的值，直接序列化
+     * 不再调用 toJSON / replacer。
+     */
     async function* serializePrepared(value, key, depth) {
         if (value === undefined ||
             typeof value === 'function' ||
             typeof value === 'symbol') {
+            write('null');
             return;
         }
         assertNoBigInt(value);
@@ -152,9 +158,16 @@ export async function* stringifyStream(input, options = {}) {
                 if (!first)
                     write(',');
                 first = false;
-                if (gap)
+                if (gap) {
                     write('\n' + gap.repeat(depth + 1));
-                let elem = prepareValue(value[i], String(i));
+                }
+                let rawValue = value[i];
+                // 1. 先等待原始值
+                if (rawValue instanceof Promise) {
+                    rawValue = await Promise.resolve(rawValue);
+                }
+                // 2. 执行 toJSON 和 replacer
+                let elem = prepareValue(rawValue, String(i), value);
                 if (elem instanceof Promise) {
                     elem = await Promise.resolve(elem);
                 }
@@ -185,8 +198,9 @@ export async function* stringifyStream(input, options = {}) {
                 if (!first)
                     write(',');
                 first = false;
-                if (gap)
+                if (gap) {
                     write('\n' + gap.repeat(depth + 1));
+                }
                 writeJSONString(String(i));
                 write(gap ? ': ' : ':');
                 write(JSON.stringify(arr[i]));
@@ -199,7 +213,7 @@ export async function* stringifyStream(input, options = {}) {
             uncheckCycle(value);
             return;
         }
-        // 可迭代
+        // 可迭代对象
         const hasAsyncIterator = value != null &&
             typeof value[Symbol.asyncIterator] === 'function';
         const hasIterator = value != null &&
@@ -212,10 +226,9 @@ export async function* stringifyStream(input, options = {}) {
             !(value instanceof WeakMap) &&
             !(value instanceof WeakSet);
         if (shouldTreatAsIterable) {
-            write('[');
-            let first = true;
-            let idx = 0;
+            checkCycle(value);
             let iterator;
+            let completed = false;
             if (hasAsyncIterator) {
                 iterator = value[Symbol.asyncIterator]();
             }
@@ -225,40 +238,52 @@ export async function* stringifyStream(input, options = {}) {
             else {
                 iterator = value;
             }
-            while (true) {
-                const step = await Promise.resolve(iterator.next());
-                if (step.done)
-                    break;
-                if (!first)
-                    write(',');
-                first = false;
-                if (gap)
-                    write('\n' + gap.repeat(depth + 1));
-                // const before = buffer.length;
-                // yield* serialize(step.value, String(idx), depth + 1);
-                // if (buffer.length === before) {
-                //     write('null');
-                // }
-                // prepare + await 后再决定写 null 还是序列化（与对象路径一致）
-                let elem = prepareValue(step.value, String(idx));
-                if (elem instanceof Promise) {
-                    elem = await Promise.resolve(elem);
+            try {
+                write('[');
+                let first = true;
+                let idx = 0;
+                while (true) {
+                    const step = await Promise.resolve(iterator.next());
+                    if (step.done) {
+                        completed = true;
+                        break;
+                    }
+                    if (!first)
+                        write(',');
+                    first = false;
+                    if (gap) {
+                        write('\n' + gap.repeat(depth + 1));
+                    }
+                    let elem = prepareValue(step.value, String(idx), value);
+                    if (elem instanceof Promise) {
+                        elem = await Promise.resolve(elem);
+                    }
+                    if (elem === undefined ||
+                        typeof elem === 'function' ||
+                        typeof elem === 'symbol') {
+                        write('null');
+                    }
+                    else {
+                        yield* serializePrepared(elem, String(idx), depth + 1);
+                    }
+                    idx++;
+                    yield* flush();
                 }
-                if (elem === undefined ||
-                    typeof elem === 'function' ||
-                    typeof elem === 'symbol') {
-                    write('null');
+                if (gap && !first) {
+                    write('\n' + gap.repeat(depth));
                 }
-                else {
-                    yield* serializePrepared(elem, String(idx), depth + 1);
-                }
-                idx++;
-                yield* flush();
+                write(']');
             }
-            if (gap && !first) {
-                write('\n' + gap.repeat(depth));
+            finally {
+                if (!completed && typeof iterator.return === 'function') {
+                    try {
+                        await iterator.return();
+                    }
+                    catch {
+                    }
+                }
+                uncheckCycle(value);
             }
-            write(']');
             return;
         }
         // 普通对象
@@ -277,19 +302,17 @@ export async function* stringifyStream(input, options = {}) {
             ? [...propertyList].filter((k) => Object.prototype.hasOwnProperty.call(value, k))
             : Object.keys(value);
         for (const k of keys) {
-            // 1. 先 prepare
-            let propValue = prepareValue(value[k], k);
-            // 2. 如果是 Promise，先 await（关键！）
+            let rawValue = value[k];
+            // 1. 先等待原始值（如果它是 Promise）
+            if (rawValue instanceof Promise) {
+                rawValue = await Promise.resolve(rawValue);
+            }
+            // 2. 再执行 toJSON 和 replacer
+            let propValue = prepareValue(rawValue, k, value);
+            // 3. 如果 replacer 自身返回了 Promise，再等待它
             if (propValue instanceof Promise) {
                 propValue = await Promise.resolve(propValue);
             }
-            // 3. 现在再判断是否应该省略
-            if (propValue === undefined ||
-                typeof propValue === 'function' ||
-                typeof propValue === 'symbol') {
-                continue;
-            }
-            // 4. 可以安全地写 key 了
             if (!first)
                 write(',');
             first = false;
@@ -298,7 +321,7 @@ export async function* stringifyStream(input, options = {}) {
             }
             writeJSONString(k);
             write(gap ? ': ' : ':');
-            // 5. 直接序列化已经 prepare + await 过的值
+            // 4. 直接序列化已经 prepare + await 过的值
             yield* serializePrepared(propValue, k, depth + 1);
             yield* flush();
         }
@@ -308,7 +331,9 @@ export async function* stringifyStream(input, options = {}) {
         write('}');
         uncheckCycle(value);
     }
-    yield* serialize(input, '', 0);
+    // 根值包装：与 JSON.stringify 的根对象处理方式一致
+    const root = { '': input };
+    yield* serialize(root[''], '', 0, root);
     yield* flush(true);
 }
 export async function stringify(input, options = {}) {
@@ -319,4 +344,3 @@ export async function stringify(input, options = {}) {
     }
     return chunks.join('');
 }
-//# sourceMappingURL=stringify-stream.js.map

package/dist/transport/express/body.d.ts

@@ -6,4 +6,3 @@ export interface ReadJsonOptions {
 export declare function createJsonParser(options?: ReadJsonOptions): RequestHandler;
 export declare function readJson(req: Request, res: Response, parser: RequestHandler): Promise<unknown>;
 export type { NextFunction };
-//# sourceMappingURL=body.d.ts.map

package/dist/transport/express/body.js

@@ -25,4 +25,3 @@ export function readJson(req, res, parser) {
         }
     });
 }
-//# sourceMappingURL=body.js.map

package/dist/transport/express/index.d.ts

@@ -1,3 +1,2 @@
 export { createExpressRouter } from './middleware.js';
 export type { ExpressOptions } from './middleware.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/express/index.js

@@ -1,2 +1 @@
 export { createExpressRouter } from './middleware.js';
-//# sourceMappingURL=index.js.map

package/dist/transport/express/middleware.d.ts

@@ -9,4 +9,3 @@ export interface ExpressOptions {
 }
 export declare function createExpressRouter(repository: Repository, { mkInjectable, errorTransform, bodyLimit, useHtdoc, }?: ExpressOptions): Router;
 export type { RPCResponse };
-//# sourceMappingURL=middleware.d.ts.map

package/dist/transport/express/middleware.js

@@ -38,11 +38,14 @@ export function createExpressRouter(repository, { mkInjectable = undefined, erro
 }
 function buildInjectables(factory, req, res, repository) {
     const injections = typeof factory === 'function'
-        ? factory({
-            request: req,
-            session: req.session,
-            response: res
-        }, repository)
+        ? {
+            ...factory({
+                request: req,
+                session: req.session,
+                response: res
+            }, repository),
+            repository
+        }
         : {
             request: req,
             session: req.session,
@@ -74,4 +77,3 @@ async function handleError(res, error) {
         },
     });
 }
-//# sourceMappingURL=middleware.js.map

package/dist/transport/express/respond.d.ts

@@ -1,4 +1,3 @@
 import type { Response } from 'express';
 import type { RPCResponse } from '../../types.js';
 export declare function respond(res: Response, payload: RPCResponse | undefined): Promise<void>;
-//# sourceMappingURL=respond.d.ts.map

package/dist/transport/express/respond.js

@@ -122,4 +122,3 @@ async function respondNonStream(rpcRes, res) {
     if (!res.writableEnded && !res.destroyed)
         res.end();
 }
-//# sourceMappingURL=respond.js.map

package/dist/transport/stdio/index.d.ts

@@ -1,2 +1 @@
 export { serveStdio, type StdioOptions } from './middleware.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/stdio/index.js

@@ -1,2 +1 @@
 export { serveStdio } from './middleware.js';
-//# sourceMappingURL=index.js.map

package/dist/transport/stdio/middleware.d.ts

@@ -31,4 +31,3 @@ export interface StdioOptions {
  * Resolves when the input stream ends.
  */
 export declare function serveStdio(options?: StdioOptions): Promise<void>;
-//# sourceMappingURL=middleware.d.ts.map

package/dist/transport/stdio/middleware.js

@@ -192,10 +192,13 @@ async function enqueueWrite(ctx, payload) {
 }
 function buildInjectables(factory, repository) {
     const injections = typeof factory === 'function'
-        ? factory({
-            input: process.stdin,
-            output: process.stdout
-        }, repository)
+        ? {
+            ...factory({
+                input: process.stdin,
+                output: process.stdout
+            }, repository),
+            repository
+        }
         : {
             repository,
             input: process.stdin,
@@ -273,4 +276,3 @@ function isWs(code) {
     // space, \t, \n, \r
     return code === 0x20 || code === 0x09 || code === 0x0a || code === 0x0d;
 }
-//# sourceMappingURL=middleware.js.map

package/dist/transport/ws/index.d.ts

@@ -1,3 +1,2 @@
 export { attachWebSocket, type WSOptions } from './middleware.js';
 export { createWebSocketServer, type StandaloneWsOptions, type StandaloneWsHandle, } from './standalone.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/ws/index.js

@@ -1,3 +1,2 @@
 export { attachWebSocket } from './middleware.js';
 export { createWebSocketServer, } from './standalone.js';
-//# sourceMappingURL=index.js.map

package/dist/transport/ws/middleware.d.ts

@@ -22,4 +22,3 @@ export interface WSOptions {
  * Returns the underlying `WebSocketServer` so the caller can close it.
  */
 export declare function attachWebSocket(server: Server, repository: Repository, options: WSOptions): WebSocketServer;
-//# sourceMappingURL=middleware.d.ts.map

package/dist/transport/ws/middleware.js

@@ -198,10 +198,13 @@ function fallbackFailure(error) {
 }
 function buildInjectables(factory, ws, req, repository) {
     const injections = typeof factory === 'function'
-        ? factory({
-            socket: ws,
-            request: req,
-        }, repository)
+        ? {
+            ...factory({
+                socket: ws,
+                request: req,
+            }, repository),
+            repository
+        }
         : {
             socket: ws,
             request: req,
@@ -209,4 +212,3 @@ function buildInjectables(factory, ws, req, repository) {
         };
     return { ...injections, injections: injections };
 }
-//# sourceMappingURL=middleware.js.map

package/dist/transport/ws/standalone.d.ts

@@ -19,4 +19,3 @@ export interface StandaloneWsHandle {
  * JSON-RPC WebSocket endpoint. Returns a handle for clean shutdown.
  */
 export declare function createWebSocketServer(options?: StandaloneWsOptions): Promise<StandaloneWsHandle>;
-//# sourceMappingURL=standalone.d.ts.map

package/dist/transport/ws/standalone.js

@@ -36,4 +36,3 @@ export async function createWebSocketServer(options = {}) {
         },
     };
 }
-//# sourceMappingURL=standalone.js.map

package/dist/types.d.ts

@@ -110,4 +110,3 @@ export interface RPCMetrics {
         timeToFirstChunkSeconds?: number;
     }): void;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/webclient/webui/src/client/httpTransport.d.ts

@@ -0,0 +1,8 @@
+import { type RPCClient } from './rpc.js';
+export interface HttpRPCOptions {
+    endpoint?: string;
+    headers?: Record<string, string>;
+    fetchImpl?: typeof fetch;
+}
+export declare function createHttpRPC(options?: HttpRPCOptions): RPCClient;
+export declare function absoluteEndpoint(endpoint?: string): string;

package/dist/webclient/webui/src/client/httpTransport.js

@@ -0,0 +1,114 @@
+import { RPCError, } from './rpc.js';
+let idCounter = 0;
+async function readLine(reader, decoder, state) {
+    while (true) {
+        const nl = state.buf.indexOf('\n');
+        if (nl >= 0) {
+            const line = state.buf.slice(0, nl).trim();
+            state.buf = state.buf.slice(nl + 1);
+            if (line)
+                return line;
+            continue;
+        }
+        const { done, value } = await reader.read();
+        if (done) {
+            const trailing = state.buf.trim();
+            state.buf = '';
+            return trailing.length > 0 ? trailing : undefined;
+        }
+        state.buf += decoder.decode(value, { stream: true });
+    }
+}
+function isStreamFrame(v) {
+    return !!v && typeof v === 'object' && typeof v.done === 'boolean';
+}
+export function createHttpRPC(options = {}) {
+    const { endpoint = '', headers = {}, fetchImpl = fetch, } = options;
+    function call(method, ...params) {
+        const id = ++idCounter;
+        const body = { jsonrpc: '2.0', method, params, id };
+        return (async () => {
+            const res = await fetchImpl(endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json, application/x-ndjson',
+                    ...headers,
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            }
+            if (!res.body) {
+                const payload = (await res.json());
+                if (payload.error)
+                    throw new RPCError(payload.error);
+                return payload.result;
+            }
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            const state = { buf: '' };
+            const firstLine = await readLine(reader, decoder, state);
+            if (firstLine === undefined) {
+                await reader.cancel().catch(() => { });
+                throw new Error(`Empty response for ${method}`);
+            }
+            let first;
+            try {
+                first = JSON.parse(firstLine);
+            }
+            catch (e) {
+                await reader.cancel().catch(() => { });
+                throw new Error(`Invalid JSON response for ${method}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            if (!isStreamFrame(first)) {
+                const payload = first;
+                await reader.cancel().catch(() => { });
+                if (payload.error)
+                    throw new RPCError(payload.error);
+                return payload.result;
+            }
+            return (async function* () {
+                let drained = false;
+                try {
+                    let chunk = first;
+                    while (true) {
+                        if (chunk.error)
+                            throw new RPCError(chunk.error);
+                        if (chunk.done) {
+                            drained = true;
+                            return;
+                        }
+                        if (chunk.value !== undefined)
+                            yield chunk.value;
+                        const line = await readLine(reader, decoder, state);
+                        if (line === undefined) {
+                            throw new Error('Stream ended without terminal frame');
+                        }
+                        chunk = JSON.parse(line);
+                    }
+                }
+                finally {
+                    if (!drained) {
+                        await reader.cancel().catch(() => { });
+                    }
+                }
+            })();
+        })();
+    }
+    return {
+        call,
+        close() {
+        },
+    };
+}
+export function absoluteEndpoint(endpoint) {
+    const raw = endpoint && endpoint.trim().length > 0 ? endpoint : '/';
+    try {
+        return new URL(raw, window.location.href).toString();
+    }
+    catch {
+        return raw;
+    }
+}

package/dist/webclient/webui/src/client/index.d.ts

@@ -0,0 +1,4 @@
+export { createRPC, RPCError, isStreamResult, type RPCClient, type RPCOptions, type TransportKind, type CallResult, } from './rpc.js';
+export type { RPCErrorPayload, RPCResponse } from './types.js';
+export { type HttpRPCOptions, absoluteEndpoint } from './httpTransport.js';
+export type { WsRPCOptions } from './wsTransport.js';

package/dist/webclient/webui/src/client/index.js

@@ -0,0 +1,2 @@
+export { createRPC, RPCError, isStreamResult, } from './rpc.js';
+export { absoluteEndpoint } from './httpTransport.js';

package/dist/webclient/webui/src/client/rpc.d.ts

@@ -0,0 +1,24 @@
+import type { RPCErrorPayload } from './types.js';
+export type TransportKind = 'http' | 'ws';
+/** 普通调用返回 Promise<T>；流式调用返回 AsyncGenerator<T>。 */
+export type CallResult<T> = Promise<T> | AsyncGenerator<T, void, unknown>;
+export interface RPCClient {
+    call<T = unknown>(method: string, ...params: unknown[]): Promise<CallResult<T>>;
+    close(): void;
+}
+export interface RPCOptions {
+    transport: TransportKind;
+    endpoint?: string;
+    headers?: Record<string, string>;
+    fetchImpl?: typeof fetch;
+    connectTimeoutMs?: number;
+    callTimeoutMs?: number;
+}
+export declare class RPCError extends Error {
+    payload: RPCErrorPayload;
+    constructor(payload: RPCErrorPayload);
+    get code(): number;
+    get data(): unknown;
+}
+export declare function isStreamResult<T>(v: unknown): v is AsyncGenerator<T, void, unknown>;
+export declare function createRPC(options: RPCOptions): RPCClient;

package/dist/webclient/webui/src/client/rpc.js

@@ -0,0 +1,32 @@
+import { createHttpRPC } from './httpTransport.js';
+import { createWsRPC } from './wsTransport.js';
+export class RPCError extends Error {
+    constructor(payload) {
+        super(payload.message);
+        this.payload = payload;
+        this.name = 'RPCError';
+    }
+    get code() { return this.payload.code; }
+    get data() { return this.payload.data; }
+}
+export function isStreamResult(v) {
+    return (!!v &&
+        typeof v === 'object' &&
+        typeof v[Symbol.asyncIterator] === 'function');
+}
+export function createRPC(options) {
+    if (options.transport === 'ws') {
+        const wsOpts = {
+            endpoint: options.endpoint,
+            connectTimeoutMs: options.connectTimeoutMs,
+            callTimeoutMs: options.callTimeoutMs,
+        };
+        return createWsRPC(wsOpts);
+    }
+    const httpOpts = {
+        endpoint: options.endpoint,
+        headers: options.headers,
+        fetchImpl: options.fetchImpl,
+    };
+    return createHttpRPC(httpOpts);
+}

package/dist/webclient/webui/src/client/types.d.ts

@@ -0,0 +1,14 @@
+export interface RPCErrorPayload {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface RPCResponse<T = unknown> {
+    jsonrpc: '2.0';
+    id: number | string | null;
+    result?: T;
+    error?: RPCErrorPayload;
+}
+export interface Signature {
+    [index: number]: string | string[];
+}

package/dist/webclient/webui/src/client/types.js

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