@skrillex1224/playwright-toolkit 2.0.72 → 2.0.74

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,124 +1096,129 @@ var Sse = {
       onData,
       onEnd,
       onTimeout,
-      firstDataTimeout = 9e4,
+      initialTimeout = 9e4,
       timeout = 18e4
     } = options;
-    let firstDataTimer = null;
+    let initialTimer = null;
     let overallTimer = null;
-    let hasReceivedFirstData = false;
+    let hasReceivedInitialData = false;
     const clearAllTimers = () => {
-      if (firstDataTimer) clearTimeout(firstDataTimer);
+      if (initialTimer) clearTimeout(initialTimer);
       if (overallTimer) clearTimeout(overallTimer);
-      firstDataTimer = null;
+      initialTimer = null;
       overallTimer = null;
     };
     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 (!hasReceivedFirstData) {
-                hasReceivedFirstData = true;
-                if (firstDataTimer) {
-                  clearTimeout(firstDataTimer);
-                  firstDataTimer = null;
+      try {
+        await page.route(urlPattern, async (route) => {
+          const request = route.request();
+          logger8.info(`[MITM] \u5DF2\u62E6\u622A\u8BF7\u6C42: ${request.url()}`);
+          try {
+            const headers = await request.allHeaders();
+            const postData = request.postData();
+            const urlObj = new import_url.URL(request.url());
+            delete headers["accept-encoding"];
+            delete headers["content-length"];
+            const req = import_https.default.request({
+              hostname: urlObj.hostname,
+              port: 443,
+              path: urlObj.pathname + urlObj.search,
+              method: request.method(),
+              headers,
+              timeout
+            }, (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;
+                if (onData) {
+                  try {
+                    onData(textChunk, resolve, accumulatedText);
+                  } catch (e) {
+                    logger8.fail(`onData \u9519\u8BEF`, e);
+                  }
                 }
-                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, resolve, accumulatedText);
-                } catch (e) {
-                  logger8.fail(`onData callback error: ${e.message}`, e);
+              });
+              res.on("end", () => {
+                logger8.info("[MITM] \u4E0A\u6E38\u54CD\u5E94\u7ED3\u675F");
+                clearAllTimers();
+                if (onEnd) {
+                  try {
+                    onEnd(accumulatedText, resolve);
+                  } catch (e) {
+                    logger8.fail(`onEnd \u9519\u8BEF`, e);
+                  }
+                } else if (!onData) {
+                  resolve(accumulatedText);
                 }
-              }
+                route.fulfill({
+                  status: res.statusCode,
+                  headers: res.headers,
+                  body: Buffer.concat(chunks)
+                }).catch(() => {
+                });
+              });
             });
-            res.on("end", () => {
-              logger8.info("[MITM] \u4E0A\u6E38\u54CD\u5E94\u7ED3\u675F (Stream End)");
+            req.on("error", (e) => {
               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}`));
+              route.abort().catch(() => {
+              });
+              reject(e);
             });
-          });
-          req.on("error", (e) => {
-            logger8.fail(`[MITM] Upstream request error: ${e.message}`, e);
+            if (postData) req.write(postData);
+            req.end();
+          } catch (e) {
             clearAllTimers();
-            route.abort();
+            route.continue().catch(() => {
+            });
             reject(e);
-          });
-          if (postData) req.write(postData);
-          req.end();
-        } catch (e) {
-          logger8.fail(`[MITM] Setup error: ${e.message}`, e);
-          clearAllTimers();
-          route.continue();
-        }
-      });
+          }
+        });
+      } catch (e) {
+        reject(e);
+      }
     });
     const timeoutPromise = new Promise((_, reject) => {
-      firstDataTimer = setTimeout(() => {
-        if (!hasReceivedFirstData) {
-          const error = new FirstDataTimeoutError(firstDataTimeout);
+      initialTimer = setTimeout(() => {
+        if (!hasReceivedInitialData) {
+          const error = new InitialTimeoutError(initialTimeout);
           clearAllTimers();
           if (onTimeout) {
-            onTimeout(error, reject);
+            try {
+              onTimeout(error, reject);
+            } catch (e) {
+              reject(e);
+            }
           } else {
-            logger8.fail(`[Intercept] \u9996\u6B21\u6570\u636E\u63A5\u6536\u8D85\u65F6`, error);
             reject(error);
           }
         }
-      }, firstDataTimeout);
+      }, initialTimeout);
       overallTimer = setTimeout(() => {
         const error = new OverallTimeoutError(timeout);
         clearAllTimers();
         if (onTimeout) {
-          onTimeout(error, reject);
+          try {
+            onTimeout(error, reject);
+          } catch (e) {
+            reject(e);
+          }
         } else {
-          logger8.fail(`[Intercept] \u6574\u4F53\u8BF7\u6C42\u8D85\u65F6`, error);
           reject(error);
         }
       }, timeout);
     });
-    const racePromise = Promise.race([workPromise, timeoutPromise]);
-    racePromise.catch(() => {
-    });
-    return racePromise;
+    return Promise.race([workPromise, timeoutPromise]);
   }
 };