@yuhere/js-jsonrpc2 2.1.12 → 2.1.14

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

@@ -212,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 {};

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

@@ -0,0 +1,8 @@
+import { type RPCClient } from './rpc.js';
+export interface WsRPCOptions {
+    /** 默认：根据当前页面 URL 推导（http->ws / https->wss，同路径） */
+    endpoint?: string;
+    connectTimeoutMs?: number;
+    callTimeoutMs?: number;
+}
+export declare function createWsRPC(options?: WsRPCOptions): RPCClient;