@d-zero/puppeteer-scroll 4.0.2 → 4.0.3

package/dist/scroll-all-over.js

@@ -9,6 +9,49 @@ import { resolveValue } from './resolve-value.js';
  * enough to confirm that scrolling is genuinely blocked.
  */
 const MAX_STUCK_ITERATIONS = 3;
+/**
+ * Max attempts for each `page.evaluate` call when it fails with a transient
+ * frame error (Chrome may briefly swap or re-attach the main frame during a
+ * long scroll, even when the target site is not doing anything observable).
+ * Three attempts with a 200 ms gap absorbs the typical re-attach window
+ * without masking a genuinely broken page.
+ */
+const MAX_EVALUATE_RETRIES = 3;
+const DETACHED_RETRY_DELAY_MS = 200;
+/**
+ * Transient errors that occur when `page.evaluate` lands inside Puppeteer's
+ * own frame-swap or session-teardown window. Retrying after a short delay
+ * usually succeeds because the new execution context is then in place.
+ * @param error - Error caught from `page.evaluate`.
+ * @returns `true` when the error is a known transient frame/session error.
+ */
+function isTransientFrameError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return /Attempted to use detached Frame|Session closed|Execution context was destroyed/i.test(error.message);
+}
+/**
+ * Retries `evaluator` (typically a `page.evaluate` call) when it fails with
+ * a transient frame error. Non-transient errors are re-thrown immediately.
+ * @template T - Evaluator return type.
+ * @param evaluator - Thunk that performs a single `page.evaluate` call.
+ * @returns Whatever `evaluator` returns on success.
+ */
+async function evaluateWithFrameRetry(evaluator) {
+    let lastError;
+    for (let attempt = 0; attempt < MAX_EVALUATE_RETRIES; attempt++) {
+        try {
+            return await evaluator();
+        }
+        catch (error) {
+            lastError = error;
+            if (!isTransientFrameError(error))
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, DETACHED_RETRY_DELAY_MS));
+        }
+    }
+    throw lastError;
+}
 /**
  * Default interval range (ms) used when `options.interval` is omitted.
  * Randomized to mimic human-like reading pauses while staying close to the
@@ -43,14 +86,14 @@ export async function scrollAllOver(page, options) {
     const interval = options?.interval ?? DEFAULT_INTERVAL;
     const distance = options?.distance;
     let currentScrollY = 0;
-    let scrollHeight = await page.evaluate(() => document.body.scrollHeight);
+    let scrollHeight = await evaluateWithFrameRetry(() => page.evaluate(() => document.body.scrollHeight));
     let prevScrollY = -1;
     let stuckCount = 0;
     while (Math.ceil(currentScrollY) < Math.ceil(scrollHeight)) {
         // Force a minimum of 1 px so a user-supplied 0/negative distance
         // cannot stall the loop into the stuck-detection bail out.
         const stepDistance = distance === undefined ? null : Math.max(1, resolveValue(distance));
-        [currentScrollY, scrollHeight] = await page.evaluate((step, ratioMin, ratioMax) => {
+        [currentScrollY, scrollHeight] = await evaluateWithFrameRetry(() => page.evaluate((step, ratioMin, ratioMax) => {
             // When step is null, sample a random fraction of the viewport
             // height so each scroll feels less mechanical.
             const actualStep = step ??
@@ -61,7 +104,7 @@ export async function scrollAllOver(page, options) {
                 Math.ceil(globalThis.scrollY + globalThis.innerHeight),
                 Math.ceil(document.body.scrollHeight),
             ];
-        }, stepDistance, DEFAULT_DISTANCE_RATIO_MIN, DEFAULT_DISTANCE_RATIO_MAX);
+        }, stepDistance, DEFAULT_DISTANCE_RATIO_MIN, DEFAULT_DISTANCE_RATIO_MAX));
         options?.logger?.(currentScrollY, scrollHeight, 'Scrolling');
         if (currentScrollY === prevScrollY) {
             stuckCount++;
@@ -77,10 +120,10 @@ export async function scrollAllOver(page, options) {
         await delay(interval);
     }
     options?.logger?.(currentScrollY, scrollHeight, 'End of page');
-    await page.evaluate(() => {
+    await evaluateWithFrameRetry(() => page.evaluate(() => {
         // Move the scroll position to the top of the page.
         globalThis.scrollTo(0, 0);
-    });
+    }));
     await delay(400);
     options?.logger?.(currentScrollY, scrollHeight, 'End of page');
     await delay(400);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@d-zero/puppeteer-scroll",
-	"version": "4.0.2",
+	"version": "4.0.3",
 	"description": "Scroll function for puppeteer",
 	"author": "D-ZERO",
 	"license": "MIT",
@@ -36,5 +36,5 @@
 		"url": "https://github.com/d-zero-dev/tools.git",
 		"directory": "packages/@d-zero/puppeteer-scroll"
 	},
-	"gitHead": "16c831105a12bb635d49130e7f5add25b6643c40"
+	"gitHead": "d876ace142711051c337f7922931776526047cb0"
 }