@skrillex1224/playwright-toolkit 2.0.71 → 2.0.73

package/dist/index.cjs

@@ -115,7 +115,7 @@ function createLogger(moduleName) {
 var errors_exports = {};
 __export(errors_exports, {
   CrawlerError: () => CrawlerError,
-  FirstDataTimeoutError: () => FirstDataTimeoutError,
+  InitialTimeoutError: () => InitialTimeoutError,
   OverallTimeoutError: () => OverallTimeoutError,
   TimeoutError: () => TimeoutError
 });
@@ -189,16 +189,16 @@ var TimeoutError = class _TimeoutError extends CrawlerError {
     }
   }
 };
-var FirstDataTimeoutError = class _FirstDataTimeoutError extends TimeoutError {
+var InitialTimeoutError = class _InitialTimeoutError extends TimeoutError {
   /**
    * @param {number} timeout - 超时时间（毫秒）
    * @param {Object} [context={}] - 上下文信息
    */
   constructor(timeout, context = {}) {
-    super(`\u9996\u6B21\u6570\u636E\u63A5\u6536\u8D85\u65F6 (${timeout}ms)`, timeout, context);
-    this.name = "FirstDataTimeoutError";
+    super(`\u521D\u59CB\u6570\u636E\u63A5\u6536\u8D85\u65F6 (${timeout}ms)`, timeout, context);
+    this.name = "InitialTimeoutError";
     if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _FirstDataTimeoutError);
+      Error.captureStackTrace(this, _InitialTimeoutError);
     }
   }
 };
@@ -1086,8 +1086,8 @@ var Sse = {
    * @param {object} options
    * @param {function(string, function, string): void} [options.onData] - (textChunk, resolve, accumulatedText) => void
    * @param {function(string, function): void} [options.onEnd] - (fullText, resolve) => void
-   * @param {function(Error, function): void} [options.onTimeout] - (error, reject) => void，error 为 FirstDataTimeoutError 或 OverallTimeoutError
-   * @param {number} [options.firstDataTimeout=90000] - 首次数据接收超时 (ms)，默认 90s
+   * @param {function(Error, function): void} [options.onTimeout] - (error, reject) => void，error 为 InitialTimeoutError 或 OverallTimeoutError
+   * @param {number} [options.initialTimeout=90000] - 初始数据接收超时 (ms)，默认 90s
    * @param {number} [options.timeout=180000] - 整体请求超时时间 (ms)，默认 180s
    * @returns {Promise<any>} - 返回 Promise，当流满足条件时 resolve
    */
@@ -1096,140 +1096,124 @@ var Sse = {
       onData,
       onEnd,
       onTimeout,
-      firstDataTimeout = 9e4,
+      initialTimeout = 9e4,
       timeout = 18e4
     } = options;
-    let streamResolve, streamReject;
-    const capturePromise = new Promise((resolve, reject) => {
-      streamResolve = resolve;
-      streamReject = reject;
-    });
-    capturePromise.catch(() => {
-    });
-    let firstDataTimer = null;
-    overallTimer = null;
-    let hasReceivedFirstData = false;
+    let initialTimer = null;
+    let overallTimer = null;
+    let hasReceivedInitialData = false;
     const clearAllTimers = () => {
-      if (firstDataTimer) {
-        clearTimeout(firstDataTimer);
-        firstDataTimer = null;
-      }
-      if (overallTimer) {
-        clearTimeout(overallTimer);
-        overallTimer = null;
-      }
+      if (initialTimer) clearTimeout(initialTimer);
+      if (overallTimer) clearTimeout(overallTimer);
+      initialTimer = null;
+      overallTimer = null;
     };
-    firstDataTimer = setTimeout(() => {
-      try {
-        if (!hasReceivedFirstData) {
-          const error = new FirstDataTimeoutError(firstDataTimeout);
+    const workPromise = new Promise(async (resolve, reject) => {
+      await page.route(urlPattern, async (route) => {
+        const request = route.request();
+        const requestUrl = request.url();
+        logger8.info(`[MITM] \u5DF2\u62E6\u622A\u8BF7\u6C42: ${requestUrl}`);
+        try {
+          const headers = await request.allHeaders();
+          const postData = request.postData();
+          const urlObj = new import_url.URL(requestUrl);
+          delete headers["accept-encoding"];
+          delete headers["content-length"];
+          const reqOptions = {
+            hostname: urlObj.hostname,
+            port: 443,
+            path: urlObj.pathname + urlObj.search,
+            method: request.method(),
+            headers,
+            timeout
+          };
+          const req = import_https.default.request(reqOptions, (res) => {
+            const chunks = [];
+            let accumulatedText = "";
+            res.on("data", (chunk) => {
+              if (!hasReceivedInitialData) {
+                hasReceivedInitialData = true;
+                if (initialTimer) {
+                  clearTimeout(initialTimer);
+                  initialTimer = null;
+                }
+                logger8.debug("[Intercept] \u5DF2\u63A5\u6536\u521D\u59CB\u6570\u636E");
+              }
+              chunks.push(chunk);
+              const textChunk = chunk.toString("utf-8");
+              accumulatedText += textChunk;
+              logger8.debug(`[CHUNK] ${textChunk.length} bytes`);
+              if (onData) {
+                try {
+                  onData(textChunk, resolve, accumulatedText);
+                } catch (e) {
+                  logger8.fail(`onData callback error: ${e.message}`, e);
+                }
+              }
+            });
+            res.on("end", () => {
+              logger8.info("[MITM] \u4E0A\u6E38\u54CD\u5E94\u7ED3\u675F (Stream End)");
+              clearAllTimers();
+              const fullBody = Buffer.concat(chunks);
+              if (onEnd) {
+                try {
+                  onEnd(accumulatedText, resolve);
+                } catch (e) {
+                  logger8.fail(`onEnd callback error: ${e.message}`, e);
+                }
+              } else if (!onData) {
+                resolve(accumulatedText);
+              }
+              route.fulfill({
+                status: res.statusCode,
+                headers: res.headers,
+                body: fullBody
+              }).catch((e) => logger8.warn(`Route fulfill failed: ${e.message}`));
+            });
+          });
+          req.on("error", (e) => {
+            logger8.fail(`[MITM] Upstream request error: ${e.message}`, e);
+            clearAllTimers();
+            route.abort();
+            reject(e);
+          });
+          if (postData) req.write(postData);
+          req.end();
+        } catch (e) {
+          logger8.fail(`[MITM] Setup error: ${e.message}`, e);
+          clearAllTimers();
+          route.continue();
+        }
+      });
+    });
+    const timeoutPromise = new Promise((_, reject) => {
+      initialTimer = setTimeout(() => {
+        if (!hasReceivedInitialData) {
+          const error = new InitialTimeoutError(initialTimeout);
           clearAllTimers();
           if (onTimeout) {
-            onTimeout(error, streamReject);
+            onTimeout(error, reject);
           } else {
-            logger8.fail(`[Intercept] \u9996\u6B21\u6570\u636E\u63A5\u6536\u8D85\u65F6`, error);
-            streamReject(error);
+            logger8.fail(`[Intercept] \u521D\u59CB\u6570\u636E\u63A5\u6536\u8D85\u65F6`, error);
+            reject(error);
           }
         }
-      } catch (e) {
-        logger8.fail(`[Intercept] \u9996\u6B21\u6570\u636E\u8D85\u65F6\u5904\u7406\u5F02\u5E38`, e);
-        streamReject(e);
-      }
-    }, firstDataTimeout);
-    overallTimer = setTimeout(() => {
-      try {
+      }, initialTimeout);
+      overallTimer = setTimeout(() => {
         const error = new OverallTimeoutError(timeout);
         clearAllTimers();
         if (onTimeout) {
-          onTimeout(error, streamReject);
+          onTimeout(error, reject);
         } else {
           logger8.fail(`[Intercept] \u6574\u4F53\u8BF7\u6C42\u8D85\u65F6`, error);
-          streamReject(error);
-        }
-      } catch (e) {
-        logger8.fail(`[Intercept] \u6574\u4F53\u8D85\u65F6\u5904\u7406\u5F02\u5E38`, e);
-        streamReject(e);
-      }
-    }, timeout);
-    await page.route(urlPattern, async (route) => {
-      const request = route.request();
-      const requestUrl = request.url();
-      logger8.info(`[MITM] \u5DF2\u62E6\u622A\u8BF7\u6C42: ${requestUrl}`);
-      try {
-        const headers = await request.allHeaders();
-        const postData = request.postData();
-        const urlObj = new import_url.URL(requestUrl);
-        delete headers["accept-encoding"];
-        delete headers["content-length"];
-        const reqOptions = {
-          hostname: urlObj.hostname,
-          port: 443,
-          path: urlObj.pathname + urlObj.search,
-          method: request.method(),
-          headers,
-          timeout
-        };
-        const req = import_https.default.request(reqOptions, (res) => {
-          const chunks = [];
-          let accumulatedText = "";
-          res.on("data", (chunk) => {
-            if (!hasReceivedFirstData) {
-              hasReceivedFirstData = true;
-              if (firstDataTimer) {
-                clearTimeout(firstDataTimer);
-                firstDataTimer = null;
-              }
-              logger8.debug("[Intercept] \u5DF2\u63A5\u6536\u9996\u6B21\u6570\u636E");
-            }
-            chunks.push(chunk);
-            const textChunk = chunk.toString("utf-8");
-            accumulatedText += textChunk;
-            logger8.debug(`[CHUNK] ${textChunk.length} bytes`);
-            if (onData) {
-              try {
-                onData(textChunk, streamResolve, accumulatedText);
-              } catch (e) {
-                logger8.fail(`onData callback error: ${e.message}`, e);
-              }
-            }
-          });
-          res.on("end", () => {
-            logger8.info("[MITM] \u4E0A\u6E38\u54CD\u5E94\u7ED3\u675F (Stream End)");
-            clearAllTimers();
-            const fullBody = Buffer.concat(chunks);
-            if (onEnd) {
-              try {
-                onEnd(accumulatedText, streamResolve);
-              } catch (e) {
-                logger8.fail(`onEnd callback error: ${e.message}`, e);
-              }
-            } else if (!onData) {
-              streamResolve(accumulatedText);
-            }
-            route.fulfill({
-              status: res.statusCode,
-              headers: res.headers,
-              body: fullBody
-            }).catch((e) => logger8.warn(`Route fulfill failed: ${e.message}`));
-          });
-        });
-        req.on("error", (e) => {
-          logger8.fail(`[MITM] Upstream request error: ${e.message}`, e);
-          clearAllTimers();
-          route.abort();
-          streamReject(e);
-        });
-        if (postData) {
-          req.write(postData);
+          reject(error);
         }
-        req.end();
-      } catch (e) {
-        logger8.fail(`[MITM] Setup error: ${e.message}`, e);
-        clearAllTimers();
-        route.continue();
-      }
+      }, timeout);
+    });
+    const racePromise = Promise.race([workPromise, timeoutPromise]);
+    racePromise.catch(() => {
     });
-    return capturePromise;
+    return racePromise;
   }
 };