@skrillex1224/playwright-toolkit 2.0.71 → 2.0.72

package/dist/index.cjs

@@ -1099,137 +1099,121 @@ var Sse = {
       firstDataTimeout = 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 overallTimer = null;
     let hasReceivedFirstData = false;
     const clearAllTimers = () => {
-      if (firstDataTimer) {
-        clearTimeout(firstDataTimer);
-        firstDataTimer = null;
-      }
-      if (overallTimer) {
-        clearTimeout(overallTimer);
-        overallTimer = null;
-      }
+      if (firstDataTimer) clearTimeout(firstDataTimer);
+      if (overallTimer) clearTimeout(overallTimer);
+      firstDataTimer = null;
+      overallTimer = null;
     };
-    firstDataTimer = setTimeout(() => {
-      try {
+    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;
+                }
+                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 (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) => {
+      firstDataTimer = setTimeout(() => {
         if (!hasReceivedFirstData) {
           const error = new FirstDataTimeoutError(firstDataTimeout);
           clearAllTimers();
           if (onTimeout) {
-            onTimeout(error, streamReject);
+            onTimeout(error, reject);
           } else {
             logger8.fail(`[Intercept] \u9996\u6B21\u6570\u636E\u63A5\u6536\u8D85\u65F6`, error);
-            streamReject(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 {
+      }, firstDataTimeout);
+      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;
   }
 };