grpc-libp2p-client 0.0.37 → 0.0.39

package/dist/index.cjs.js

@@ -357,7 +357,7 @@ class HPACK {
     }
     // Huffman编码实现  
     huffmanEncode(bytes) {
-        let result = [];
+        const result = [];
         let current = 0;
         let bits = 0;
         for (let i = 0; i < bytes.length; i++) {
@@ -450,7 +450,7 @@ class HPACK {
             try {
                 result = this.decode(bytes);
             }
-            catch (e) {
+            catch {
                 result = '';
             }
         }
@@ -458,7 +458,7 @@ class HPACK {
             try {
                 result = new TextDecoder().decode(bytes);
             }
-            catch (e) {
+            catch {
                 result = '';
             }
         }
@@ -504,7 +504,8 @@ class FrameEncoder {
     // 编码SETTINGS帧  
     static encodeSettingsFrame(frame) {
         // 计算payload总长度：每个设置项占6字节  
-        const payloadLength = frame.payload.length * 6;
+        const settingsPayload = frame.payload;
+        const payloadLength = settingsPayload.length * 6;
         // 分配缓冲区：9字节头部 + payload长度  
         const buffer = new Uint8Array(9 + payloadLength);
         // 编码帧头部（前9个字节）  
@@ -515,7 +516,7 @@ class FrameEncoder {
             streamId: frame.streamId
         });
         // 编码payload  
-        _encodeSettingsPayload(buffer, frame.payload);
+        _encodeSettingsPayload(buffer, settingsPayload);
         return buffer;
     }
     // 编码SETTINGS ACK帧  
@@ -585,11 +586,11 @@ const defaultSettings = {
     [SETTINGS_PARAMETERS.MAX_FRAME_SIZE]: 16 << 10, // 16k
     [SETTINGS_PARAMETERS.MAX_HEADER_LIST_SIZE]: 8192
 };
-const HTTP2_PREFACE = 'PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n';
+const HTTP2_PREFACE$1 = 'PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n';
 class Http2Frame {
     // 创建并编码PREFACE帧
     static createPreface() {
-        return new TextEncoder().encode(HTTP2_PREFACE);
+        return new TextEncoder().encode(HTTP2_PREFACE$1);
     }
     static createPongFrame(payload) {
         return Http2Frame.createFrame(0x6, 0x1, 0, payload);
@@ -806,6 +807,7 @@ function _createPayload(settings) {
     return payload;
 }
 
+const HTTP2_PREFACE = new TextEncoder().encode("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n");
 class HTTP2Parser {
     constructor(writer, options) {
         this.buffer = new Uint8Array(0);
@@ -853,44 +855,49 @@ class HTTP2Parser {
     // 处理单个数据块
     _processChunk(chunk) {
         // chunk 是 Uint8ArrayList 或 Uint8Array
-        const newData = chunk.subarray ? chunk.subarray() : new Uint8Array(chunk);
-        // 累积数据到buffer
+        const newData = 'subarray' in chunk && typeof chunk.subarray === 'function'
+            ? chunk.subarray()
+            : chunk;
+        // 原作者之前的 O(N) 内存拷贝优化被保留，去掉了存在 onEnd 竞态的 setTimeout
         const newBuffer = new Uint8Array(this.buffer.length + newData.length);
         newBuffer.set(this.buffer);
         newBuffer.set(newData, this.buffer.length);
         this.buffer = newBuffer;
         // 持续处理所有完整的帧
-        while (this.buffer.length >= 9) {
+        let readOffset = 0;
+        while (this.buffer.length - readOffset >= 9) {
             // 判断是否有HTTP/2前导
-            if (this.buffer.length >= 24 && this.isHttp2Preface(this.buffer)) {
-                this.buffer = this.buffer.slice(24);
+            if (this.buffer.length - readOffset >= 24 && this.isHttp2Preface(this.buffer.subarray(readOffset))) {
+                readOffset += 24;
                 // 发送SETTINGS帧
                 const settingFrame = Http2Frame.createSettingsFrame();
                 this.writer.write(settingFrame);
-                break;
+                continue;
             }
-            const frameHeader = this._parseFrameHeader(this.buffer);
+            const frameHeader = this._parseFrameHeader(this.buffer.subarray(readOffset));
             const totalFrameLength = 9 + frameHeader.length;
             // 检查是否有完整的帧
-            if (this.buffer.length < totalFrameLength) {
+            if (this.buffer.length - readOffset < totalFrameLength) {
                 break;
             }
             // 获取完整帧数据
-            const frameData = this.buffer.slice(0, totalFrameLength);
+            const frameData = this.buffer.subarray(readOffset, readOffset + totalFrameLength);
             // 处理不同类型的帧
             this._handleFrame(frameHeader, frameData).catch((err) => {
                 console.error("Error handling frame:", err);
             });
-            // 移除已处理的帧
-            this.buffer = this.buffer.slice(totalFrameLength);
+            // 移动偏移量
+            readOffset += totalFrameLength;
+        }
+        if (readOffset > 0) {
+            this.buffer = this.buffer.slice(readOffset);
         }
     }
     isHttp2Preface(buffer) {
-        const PREFACE = new TextEncoder().encode("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n");
-        if (buffer.length < PREFACE.length)
+        if (buffer.length < HTTP2_PREFACE.length)
             return false;
-        for (let i = 0; i < PREFACE.length; i++) {
-            if (buffer[i] !== PREFACE[i])
+        for (let i = 0; i < HTTP2_PREFACE.length; i++) {
+            if (buffer[i] !== HTTP2_PREFACE[i])
                 return false;
         }
         return true;
@@ -1077,7 +1084,9 @@ class HTTP2Parser {
                     waiters.forEach(fn => { try {
                         fn();
                     }
-                    catch { } });
+                    catch (e) {
+                        console.debug('waiter error', e);
+                    } });
                 }
                 break;
             case FRAME_TYPES.DATA:
@@ -1126,7 +1135,7 @@ class HTTP2Parser {
                 break;
             case FRAME_TYPES.WINDOW_UPDATE:
                 // 处理窗口更新帧
-                this.handleWindowUpdateFrame(frameHeader, frameData, frameHeader.streamId);
+                this.handleWindowUpdateFrame(frameHeader, frameData);
                 // 更新发送窗口（对端接收窗口）
                 try {
                     const inc = this.parseWindowUpdateFrame(frameData, frameHeader).windowSizeIncrement;
@@ -1141,9 +1150,11 @@ class HTTP2Parser {
                     waiters.forEach(fn => { try {
                         fn();
                     }
-                    catch { } });
+                    catch (e) {
+                        console.debug('waiter error', e);
+                    } });
                 }
-                catch (e) { }
+                catch { /* ignore WINDOW_UPDATE parse errors */ }
                 break;
             case FRAME_TYPES.PING:
                 // 处理PING帧
@@ -1165,7 +1176,7 @@ class HTTP2Parser {
                         info = {};
                     }
                 }
-                catch { }
+                catch { /* ignore GOAWAY parse errors */ }
                 try {
                     this.onGoaway?.(info ?? {});
                 }
@@ -1298,7 +1309,7 @@ class HTTP2Parser {
         };
     }
     // 处理 WINDOW_UPDATE 帧
-    handleWindowUpdateFrame(frameHeader, payload, streamId) {
+    handleWindowUpdateFrame(frameHeader, payload) {
         try {
             const windowUpdate = this.parseWindowUpdateFrame(payload, frameHeader);
             this.connectionWindowSize += windowUpdate.windowSizeIncrement;
@@ -1439,8 +1450,8 @@ class StreamWriter {
             }
             catch (err) {
                 // Gracefully handle stream closing errors - 不要传递到 handleError
-                const errMsg = err.message?.toLowerCase() || '';
-                if (err.name === 'StreamStateError' ||
+                const errMsg = (err instanceof Error ? err.message : '').toLowerCase();
+                if ((err instanceof Error && err.name === 'StreamStateError') ||
                     errMsg.includes('closing') ||
                     errMsg.includes('closed') ||
                     errMsg.includes('write to a stream that is closed')) {
@@ -1452,6 +1463,7 @@ class StreamWriter {
         }
     }
     createTransform() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
         return async function* (source) {
             for await (const chunk of source) {
@@ -1461,7 +1473,7 @@ class StreamWriter {
                 // 因此这里统计的 bytesDrained 更接近实际被 sink 消费的字节数
                 try {
                     // 在下游消费后再扣减待消费队列，避免误判“next 没取”
-                    if (self.p?._queueSize != null) {
+                    if (self.p._queueSize != null) {
                         self.p._queueSize = Math.max(0, self.p._queueSize - chunk.byteLength);
                     }
                     self.bytesDrained += chunk.byteLength;
@@ -1481,10 +1493,11 @@ class StreamWriter {
         };
     }
     // 简单的卡顿看门狗：当队列长期高位且 bytesDrained 无进展时发出 stalled 事件
+    // 使用递归 setTimeout 而非 setInterval，避免标签页后台恢复时回调堆积导致 Violation
     startWatchdog(intervalMs = 500, stallMs = 1500) {
         if (this.watchdogTimer)
             return;
-        this.watchdogTimer = setInterval(() => {
+        const tick = () => {
             if (this.abortController.signal.aborted)
                 return;
             const baseThreshold = this.options.bufferSize * 0.7;
@@ -1495,7 +1508,13 @@ class StreamWriter {
                     if (!this.stallStartAt)
                         this.stallStartAt = now;
                     if (now - this.stallStartAt >= stallMs) {
-                        this.dispatchEvent(new CustomEvent('stalled', { detail: { queueSize: q, drained: this.bytesDrained, sinceMs: now - this.stallStartAt } }));
+                        // 异步触发事件，让当前 tick 立即返回，避免同步事件处理器阻塞主线程
+                        const detail = { queueSize: q, drained: this.bytesDrained, sinceMs: now - this.stallStartAt };
+                        setTimeout(() => {
+                            if (!this.abortController.signal.aborted) {
+                                this.dispatchEvent(new CustomEvent('stalled', { detail }));
+                            }
+                        }, 0);
                         // 避免持续触发，推进起点
                         this.stallStartAt = now;
                     }
@@ -1510,7 +1529,10 @@ class StreamWriter {
                 // 队列回落，重置
                 this.stallStartAt = 0;
             }
-        }, intervalMs);
+            // 本次 tick 完成后再安排下一次，不会因主线程繁忙而堆积
+            this.watchdogTimer = setTimeout(tick, intervalMs);
+        };
+        this.watchdogTimer = setTimeout(tick, intervalMs);
     }
     async write(data) {
         // 静默处理 aborted 状态，避免在正常的流关闭场景下抛出错误
@@ -1542,6 +1564,8 @@ class StreamWriter {
             return data.arrayBuffer();
         if (typeof data === 'string')
             return new TextEncoder().encode(data).buffer;
+        if (data instanceof Uint8Array)
+            return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
         return data;
     }
     async writeChunks(buffer) {
@@ -1684,7 +1708,7 @@ class StreamWriter {
             }
             catch (err) {
                 // 忽略关闭已关闭流的错误
-                const errMsg = err.message?.toLowerCase() || '';
+                const errMsg = (err instanceof Error ? err.message : '').toLowerCase();
                 if (!errMsg.includes('closed') && !errMsg.includes('closing')) {
                     this.log?.trace?.('Stream close error:', err);
                 }
@@ -1702,7 +1726,8 @@ class StreamWriter {
             // 先检查流状态，避免在已关闭的流上调用 abort
             if (this.stream && typeof this.stream.abort === 'function') {
                 // 检查流的状态，避免操作已关闭的流
-                const streamState = this.stream.status || this.stream.state;
+                const streamState = this.stream.status ||
+                    this.stream.state;
                 if (streamState !== 'closed' && streamState !== 'closing') {
                     this.stream.abort(new Error(reason));
                 }
@@ -1711,7 +1736,7 @@ class StreamWriter {
         catch (err) {
             // Stream may already be closed, ignore all stream-related errors
             // 完全忽略流操作错误，避免在错误处理中再次抛出错误
-            const errMsg = err.message?.toLowerCase() || '';
+            const errMsg = (err instanceof Error ? err.message : '').toLowerCase();
             if (!errMsg.includes('closed') && !errMsg.includes('closing') && !errMsg.includes('write')) {
                 this.log?.trace?.('Stream abort error:', err);
             }
@@ -1733,17 +1758,17 @@ class StreamWriter {
         }
         // 立即拒绝所有待处理的写入任务，避免它们继续执行
         const pendingTasks = this.writeQueue.splice(0);
-        pendingTasks.forEach(task => {
+        pendingTasks.forEach(() => {
             // 这些任务的 Promise 会在执行时因为检查到 aborted 而被拒绝
         });
         try {
             this.p.end();
         }
-        catch (err) {
+        catch {
             // Ignore errors when ending pushable
         }
         if (this.watchdogTimer) {
-            clearInterval(this.watchdogTimer);
+            clearTimeout(this.watchdogTimer);
             this.watchdogTimer = undefined;
         }
     }
@@ -1879,6 +1904,7 @@ class Libp2pGrpcClient {
         }
         await new Promise((resolve, reject) => {
             let settled = false;
+            // eslint-disable-next-line prefer-const
             let timeoutId;
             const cleanup = () => {
                 const idx = state.waiters.indexOf(waiter);
@@ -1961,7 +1987,7 @@ class Libp2pGrpcClient {
             if (pooled) {
                 const conn = pooled.connection;
                 if (conn) {
-                    const status = conn?.stat?.status?.toLowerCase?.();
+                    const status = conn.status;
                     if (!status || status === "open") {
                         return conn;
                     }
@@ -1988,17 +2014,9 @@ class Libp2pGrpcClient {
                         }
                     };
                     try {
-                        const anyConn = conn;
-                        if (typeof anyConn.addEventListener === "function") {
-                            anyConn.addEventListener("close", removeFromPool, {
-                                once: true,
-                            });
-                        }
-                        else if (typeof anyConn.once === "function") {
-                            anyConn.once("close", removeFromPool);
-                        }
+                        conn.addEventListener("close", removeFromPool, { once: true });
                     }
-                    catch { }
+                    catch { /* ignore event listener registration errors */ }
                 }
             }
             return conn;
@@ -2068,14 +2086,14 @@ class Libp2pGrpcClient {
             });
             try {
                 writer.addEventListener("backpressure", (e) => {
-                    const d = e?.detail || {};
+                    const d = e.detail || {};
                     console.warn(`[unary stream ${streamId}] backpressure current=${d.currentSize} avg=${d.averageSize} threshold=${d.threshold}`);
                 });
-                writer.addEventListener("drain", (e) => {
-                    const d = e?.detail || {};
+                writer.addEventListener("drain", () => {
+                    // drain event - no action needed
                 });
                 writer.addEventListener("stalled", (e) => {
-                    const d = e?.detail || {};
+                    const d = e.detail || {};
                     console.warn(`[unary stream ${streamId}] stalled queue=${d.queueSize} drained=${d.drained} since=${d.sinceMs}ms — sending PING`);
                     try {
                         const payload = new Uint8Array(8);
@@ -2083,10 +2101,10 @@ class Libp2pGrpcClient {
                         const ping = Http2Frame.createFrame(0x6, 0x0, 0, payload);
                         writer.write(ping);
                     }
-                    catch { }
+                    catch { /* ignore ping write errors */ }
                 });
             }
-            catch { }
+            catch { /* ignore addEventListener errors */ }
             const parser = new HTTP2Parser(writer);
             parser.onGoaway = (info) => {
                 console.warn("[unaryCall] GOAWAY received from server", info);
@@ -2097,7 +2115,7 @@ class Libp2pGrpcClient {
                 exitFlag = true;
                 errMsg = `GOAWAY received: code=${info.errorCode}`;
                 try {
-                    connection?.close?.();
+                    connection?.close();
                 }
                 catch (err) {
                     console.warn("Error closing connection after GOAWAY:", err);
@@ -2122,7 +2140,6 @@ class Libp2pGrpcClient {
                     if (payload.length < 5) {
                         return;
                     }
-                    const compressionFlag = payload[0]; // 压缩标志
                     const lengthBytes = payload.slice(1, 5); // 消息长度的4字节
                     responseDataExpectedLength = new DataView(lengthBytes.buffer, lengthBytes.byteOffset).getUint32(0, false); // big-endian
                     if (responseDataExpectedLength < 0) {
@@ -2199,7 +2216,7 @@ class Libp2pGrpcClient {
                 const ackSettingFrame = Http2Frame.createSettingsAckFrame();
                 writer.write(ackSettingFrame);
             };
-            parser.onHeaders = (headers, header) => {
+            parser.onHeaders = (headers) => {
                 const plainHeaders = hpack.decodeHeaderFields(headers);
                 if (plainHeaders.get("grpc-status") === "0") {
                     // 成功状态
@@ -2224,21 +2241,12 @@ class Libp2pGrpcClient {
             const settingFrme = Http2Frame.createSettingsFrame();
             await writer.write(settingFrme);
             // 等待对端 SETTINGS 或 ACK，择一即可，避免偶发握手竞态
-            {
-                let progressed = false;
-                await Promise.race([
-                    (async () => {
-                        await parser.waitForPeerSettings(1000);
-                        progressed = true;
-                    })(),
-                    (async () => {
-                        await parser.waitForSettingsAck();
-                        progressed = true;
-                    })(),
-                    new Promise((res) => setTimeout(res, 300)),
-                ]);
-                // 即使未等到，也继续；多数实现会随后发送
-            }
+            await Promise.race([
+                parser.waitForPeerSettings(1000),
+                parser.waitForSettingsAck(),
+                new Promise((res) => setTimeout(res, 300)),
+            ]);
+            // 即使未等到，也继续；多数实现会随后发送
             // 创建头部帧
             const headerFrame = Http2Frame.createHeadersFrame(streamId, method, true, this.token);
             await writer.write(headerFrame);
@@ -2266,9 +2274,9 @@ class Libp2pGrpcClient {
                 checkResponse();
             });
             try {
-                await writer.flush?.(timeout);
+                await writer.flush(timeout);
             }
-            catch { }
+            catch { /* ignore flush errors */ }
             await writer.end();
         }
         catch (err) {
@@ -2368,7 +2376,7 @@ class Libp2pGrpcClient {
                 if (options?.freshConnection) {
                     try {
                         this.connectionPool.delete(this.peerAddr.toString());
-                        await this.node?.hangUp?.(this.peerAddr);
+                        await this.node.hangUp(this.peerAddr);
                         console.warn("[Call] hangUp existing connection before dialing due to freshConnection=true");
                     }
                     catch (err) {
@@ -2401,14 +2409,14 @@ class Libp2pGrpcClient {
                 });
                 try {
                     writer.addEventListener("backpressure", (e) => {
-                        const d = e?.detail || {};
+                        const d = e.detail || {};
                         console.warn(`[stream ${streamId}] backpressure current=${d.currentSize} avg=${d.averageSize} threshold=${d.threshold}`);
                     });
-                    writer.addEventListener("drain", (e) => {
-                        const d = e?.detail || {};
+                    writer.addEventListener("drain", () => {
+                        // drain event - no action needed
                     });
                     writer.addEventListener("stalled", (e) => {
-                        const d = e?.detail || {};
+                        const d = e.detail || {};
                         console.warn(`[stream ${streamId}] stalled queue=${d.queueSize} drained=${d.drained} since=${d.sinceMs}ms — sending PING`);
                         try {
                             const payload = new Uint8Array(8);
@@ -2416,10 +2424,10 @@ class Libp2pGrpcClient {
                             const ping = Http2Frame.createFrame(0x6, 0x0, 0, payload);
                             writer.write(ping);
                         }
-                        catch { /* empty */ }
+                        catch { /* ignore ping write errors */ }
                     });
                 }
-                catch { /* empty */ }
+                catch { /* ignore addEventListener errors */ }
                 const parser = new HTTP2Parser(writer, {
                     compatibilityMode: !useFlowControl,
                 });
@@ -2436,7 +2444,7 @@ class Libp2pGrpcClient {
                     }
                     internalController.abort();
                     try {
-                        connection?.close?.();
+                        connection?.close();
                     }
                     catch (err) {
                         console.warn("Error closing connection after GOAWAY:", err);
@@ -2471,7 +2479,7 @@ class Libp2pGrpcClient {
                     }
                 };
                 // 在各个回调中检查是否已中止
-                parser.onData = async (payload, frameHeader) => {
+                parser.onData = async (payload) => {
                     // 检查是否已中止
                     if (internalController.signal.aborted) {
                         return;
@@ -2491,7 +2499,6 @@ class Libp2pGrpcClient {
                             // 如果还没有读取消息长度，且缓冲区有足够数据
                             if (expectedMessageLength === -1 && messageBuffer.length >= 5) {
                                 // 读取 gRPC 消息头：1字节压缩标志 + 4字节长度
-                                const compressionFlag = messageBuffer[0];
                                 const lengthBytes = messageBuffer.slice(1, 5);
                                 expectedMessageLength = new DataView(lengthBytes.buffer, lengthBytes.byteOffset).getUint32(0, false); // big-endian
                             }
@@ -2528,7 +2535,7 @@ class Libp2pGrpcClient {
                     const ackSettingFrame = Http2Frame.createSettingsAckFrame();
                     writer.write(ackSettingFrame);
                 };
-                parser.onHeaders = (headers, header) => {
+                parser.onHeaders = (headers) => {
                     // 检查是否已中止
                     if (internalController.signal.aborted)
                         return;
@@ -2574,16 +2581,9 @@ class Libp2pGrpcClient {
                 }
                 // 等待对端 SETTINGS 或 ACK，择一即可，避免偶发握手竞态
                 {
-                    let progressed = false;
                     await Promise.race([
-                        (async () => {
-                            await parser.waitForPeerSettings(1000);
-                            progressed = true;
-                        })(),
-                        (async () => {
-                            await parser.waitForSettingsAck();
-                            progressed = true;
-                        })(),
+                        parser.waitForPeerSettings(1000),
+                        parser.waitForSettingsAck(),
                         new Promise((res) => setTimeout(res, 300)),
                     ]);
                     // 即使未等到，也继续；多数实现会随后发送
@@ -2620,7 +2620,6 @@ class Libp2pGrpcClient {
                     }
                     // 动态批量处理逻辑 - 在处理过程中动态补充新数据
                     const batchSize = options?.batchSize || 10;
-                    const maxBatchWaitMs = options?.maxBatchWaitMs || 50;
                     // 动态批处理器
                     const processingQueue = [];
                     let isProcessing = false;
@@ -2751,9 +2750,9 @@ class Libp2pGrpcClient {
                     await writeFrame(finalFrame);
                     // 在结束前尽量冲刷内部队列，避免服务器看到部分数据 + context canceled
                     try {
-                        await writer.flush?.(timeout);
+                        await writer.flush(timeout);
                     }
-                    catch { }
+                    catch { /* ignore flush errors */ }
                     await writer.end();
                 }
                 // 检查是否已中止
@@ -2800,15 +2799,16 @@ class Libp2pGrpcClient {
                 if (options?.freshConnection) {
                     try {
                         // 通过 libp2p 连接管理器关闭到该 peer 的连接
-                        const conns = this.node?.getConnections?.(this.peerAddr) || [];
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const conns = this.node.getConnections?.(this.peerAddr) || [];
                         for (const c of conns) {
                             try {
                                 await c.close?.();
                             }
-                            catch { }
+                            catch { /* ignore close errors */ }
                         }
                     }
-                    catch { }
+                    catch { /* ignore connection cleanup errors */ }
                 }
                 if (streamSlotAcquired && state) {
                     state.activeStreams = Math.max(0, state.activeStreams - 1);