@d-zero/puppeteer-page-scan 4.5.2 → 4.6.1

package/dist/before-page-scan.d.ts

@@ -10,12 +10,30 @@ type Options = {
     openDisclosures?: boolean;
     scrollInterval?: number | DelayOptions;
     scrollDistance?: number | DelayOptions;
+    /**
+     * Maximum `document.body.scrollHeight` (px) tolerated before `scrollAllOver`
+     * is skipped. Pages whose post-load scrollHeight exceeds this threshold
+     * return `{ scrolled: false, scrollHeight }` without scrolling, so callers
+     * can decide to abandon the device preset rather than letting the scroll
+     * run unbounded. Omit to disable the check (legacy behavior).
+     */
+    maxScrollHeight?: number;
 } & Size;
+export type BeforePageScanResult = {
+    /**
+     * `true` when `scrollAllOver` ran to completion (or to a stuck bail-out).
+     * `false` when the scroll was skipped because `scrollHeight` exceeded
+     * `maxScrollHeight`.
+     */
+    scrolled: boolean;
+    /** `document.body.scrollHeight` measured immediately before scroll. */
+    scrollHeight: number;
+};
 /**
  *
  * @param page
  * @param url
  * @param options
  */
-export declare function beforePageScan(page: Page, url: string, options?: Options): Promise<void>;
+export declare function beforePageScan(page: Page, url: string, options?: Options): Promise<BeforePageScanResult>;
 export {};

package/dist/before-page-scan.js

@@ -1,4 +1,4 @@
-import { scrollAllOver } from '@d-zero/puppeteer-scroll';
+import { evaluateWithFrameRetry, scrollAllOver } from '@d-zero/puppeteer-scroll';
 /**
  * Open all disclosure elements on the page
  * This function loops until all disclosure elements are expanded,
@@ -61,6 +61,7 @@ export async function beforePageScan(page, url, options) {
     const width = options?.width ?? 1400;
     const resolution = options?.resolution;
     const timeout = options?.timeout || 5000;
+    const maxScrollHeight = options?.maxScrollHeight;
     const countDownId = `${name}${url}_timeout`;
     listener?.('setViewport', { name, width, resolution });
     await page.setViewport({
@@ -94,6 +95,29 @@ export async function beforePageScan(page, url, options) {
             message: `Opened ${result.details} <details> elements and clicked ${result.buttons} [aria-expanded="false"] buttons`,
         });
     }
+    // WHY measure before scrollAllOver: pathological pages can have a
+    // post-load scrollHeight of millions of pixels (e.g. responsive data
+    // tables that expand to ~321k px at 320px viewport, and worse cases exist).
+    // `scrollAllOver` has no upper bound, so without this guard it can run
+    // for tens of minutes — long enough to exceed any reasonable retry
+    // timeout, leaving the scroll's page.evaluate calls executing in the
+    // background while the next retry attempts to use the same page.
+    //
+    // WHY retry on detached-Frame: this evaluation runs immediately after
+    // `page.reload()` resolves, which is exactly when Chrome may still be
+    // finishing an internal main-frame swap. A single read landing in that
+    // window throws even though the page itself is doing nothing observable,
+    // and the throw escapes `beforePageScan` before `scrollAllOver`'s own
+    // retry layer can absorb anything. Reuse the same retry helper as
+    // `scrollAllOver` to keep the swap-window absorption consistent.
+    const scrollHeight = await evaluateWithFrameRetry(() => page.evaluate(() => document.body.scrollHeight));
+    if (maxScrollHeight !== undefined && scrollHeight > maxScrollHeight) {
+        listener?.('hook', {
+            name,
+            message: `Skipped scroll: scrollHeight ${scrollHeight} exceeds limit ${maxScrollHeight}`,
+        });
+        return { scrolled: false, scrollHeight };
+    }
     listener?.('scroll', {
         name,
         scrollY: 0,
@@ -103,8 +127,9 @@ export async function beforePageScan(page, url, options) {
     await scrollAllOver(page, {
         interval: options?.scrollInterval,
         distance: options?.scrollDistance,
-        logger: (scrollY, scrollHeight, message) => listener?.('scroll', { name, scrollY, scrollHeight, message }),
+        logger: (scrollY, scrollHeightCurrent, message) => listener?.('scroll', { name, scrollY, scrollHeight: scrollHeightCurrent, message }),
     });
+    return { scrolled: true, scrollHeight };
 }
 /**
  * Navigate with fallback from networkidle0 to networkidle2 on timeout

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { beforePageScan } from './before-page-scan.js';
+export type { BeforePageScanResult } from './before-page-scan.js';
 export { defaultSizes, devicePresets, createSizesFromDevices, parseDevicesOption, } from './default-sizes.js';
 export { readPageHooks } from './read-page-hooks.js';
 export { pageScanListener, pageScanLoggers } from './page-scan-listener.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@d-zero/puppeteer-page-scan",
-	"version": "4.5.2",
+	"version": "4.6.1",
 	"description": "Scanning page function for puppeteer",
 	"author": "D-ZERO",
 	"license": "MIT",
@@ -24,7 +24,7 @@
 	},
 	"dependencies": {
 		"@d-zero/puppeteer-general-actions": "1.2.5",
-		"@d-zero/puppeteer-scroll": "4.0.2",
+		"@d-zero/puppeteer-scroll": "4.0.4",
 		"@d-zero/shared": "0.22.0"
 	},
 	"devDependencies": {
@@ -38,5 +38,5 @@
 		"url": "https://github.com/d-zero-dev/tools.git",
 		"directory": "packages/@d-zero/puppeteer-page-scan"
 	},
-	"gitHead": "16c831105a12bb635d49130e7f5add25b6643c40"
+	"gitHead": "9a26e6d8c1e996684691055ffc070547344b21e9"
 }