@pagepocket/capture-http-puppeteer-unit 0.8.5 → 0.9.0

package/dist/capture-http-puppeteer-unit.js

@@ -2,8 +2,9 @@ import { NETWORK } from "@pagepocket/contracts";
 import { Unit, createMemoryContentStore, InflightTracker, mapKind, networkIdle, normalizeCompletion, throwUnsupportedEntryKind, timeout } from "@pagepocket/lib";
 import { PuppeteerAdapter } from "./internal/puppeteer-adapter.js";
 const headersRecordToList = (headers) => {
-    if (!headers)
+    if (!headers) {
         return [];
+    }
     return Object.keys(headers).map((name) => ({ name, value: headers[name] }));
 };
 const targetBuilders = {

package/dist/internal/puppeteer-adapter/events.d.ts

@@ -0,0 +1,24 @@
+import type { NetworkEventHandlers } from "@pagepocket/lib";
+import type { HTTPRequest, HTTPResponse } from "puppeteer";
+export declare const createRequestIdStore: () => {
+    getRequestId: (request: HTTPRequest) => string;
+    has: (request: HTTPRequest) => boolean;
+};
+export declare const createEmitRequest: (handlers: NetworkEventHandlers, getRequestId: (r: HTTPRequest) => string) => (request: HTTPRequest, timestamp: number) => void;
+export declare const isExpectedMissingBody: (input: {
+    request: HTTPRequest;
+    response: HTTPResponse;
+    headers: Record<string, string>;
+}) => boolean;
+export declare const createOnResponse: (input: {
+    handlers: NetworkEventHandlers;
+    getRequestId: (r: HTTPRequest) => string;
+    hasRequestId: (r: HTTPRequest) => boolean;
+    emitRequest: (r: HTTPRequest, ts: number) => void;
+}) => (response: HTTPResponse) => void;
+export declare const createOnRequestFailed: (input: {
+    handlers: NetworkEventHandlers;
+    getRequestId: (r: HTTPRequest) => string;
+    hasRequestId: (r: HTTPRequest) => boolean;
+    emitRequest: (r: HTTPRequest, ts: number) => void;
+}) => (request: HTTPRequest) => void;

package/dist/internal/puppeteer-adapter/events.js

@@ -0,0 +1,130 @@
+import { isResponseBodyUnavailableError } from "../utils/errors.js";
+import { getHeaderValue, normalizeHeaders } from "../utils/headers.js";
+import { getFrameId, getInitiator } from "../utils/puppeteer-internals.js";
+const toResourceType = (request) => {
+    const type = request.resourceType?.();
+    return type ? type : undefined;
+};
+export const createRequestIdStore = () => {
+    const requestIds = new WeakMap();
+    let requestSequence = 0;
+    const getRequestId = (request) => {
+        const existing = requestIds.get(request);
+        if (existing) {
+            return existing;
+        }
+        const requestId = `pptr-${Date.now()}-${requestSequence++}`;
+        requestIds.set(request, requestId);
+        return requestId;
+    };
+    const has = (request) => requestIds.has(request);
+    return { getRequestId, has };
+};
+export const createEmitRequest = (handlers, getRequestId) => {
+    return (request, timestamp) => {
+        const requestEvent = {
+            type: "request",
+            requestId: getRequestId(request),
+            url: request.url(),
+            method: request.method(),
+            headers: normalizeHeaders(request.headers()),
+            frameId: getFrameId(request),
+            resourceType: toResourceType(request),
+            initiator: getInitiator(request),
+            timestamp
+        };
+        handlers.onEvent(requestEvent);
+    };
+};
+export const isExpectedMissingBody = (input) => {
+    const { request, response, headers } = input;
+    const method = request.method().toUpperCase();
+    if (method === "OPTIONS" || method === "HEAD") {
+        return true;
+    }
+    const status = response.status();
+    if (status >= 100 && status < 200) {
+        return true;
+    }
+    if (status >= 300 && status < 400) {
+        return true;
+    }
+    if (status === 206) {
+        const contentRange = getHeaderValue(headers, "content-range");
+        const contentType = getHeaderValue(headers, "content-type") ?? "";
+        if (contentRange) {
+            return true;
+        }
+        if (/^video\//i.test(contentType) || /^audio\//i.test(contentType)) {
+            return true;
+        }
+    }
+    return status === 204 || status === 205 || status === 304;
+};
+export const createOnResponse = (input) => {
+    const { handlers, getRequestId, hasRequestId, emitRequest } = input;
+    return (response) => {
+        const timestamp = Date.now();
+        const request = response.request();
+        if (!hasRequestId(request)) {
+            emitRequest(request, timestamp);
+        }
+        const headers = normalizeHeaders(response.headers());
+        const expectedMissingBody = () => isExpectedMissingBody({ request, response, headers });
+        const responseEvent = {
+            type: "response",
+            requestId: getRequestId(request),
+            url: response.url(),
+            status: response.status(),
+            statusText: response.statusText(),
+            headers,
+            mimeType: getHeaderValue(headers, "content-type"),
+            fromDiskCache: response.fromCache(),
+            fromServiceWorker: response.fromServiceWorker(),
+            timestamp,
+            body: {
+                kind: "late",
+                read: async () => {
+                    try {
+                        const buffer = await response.buffer();
+                        return new Uint8Array(buffer);
+                    }
+                    catch (error) {
+                        if (isResponseBodyUnavailableError(error)) {
+                            if (!expectedMissingBody()) {
+                                const method = request.method();
+                                const status = response.status();
+                                const url = response.url();
+                                handlers.onError?.(new Error(`Unexpected missing response body (method=${method} status=${status}) for ${url}`));
+                            }
+                            return new Uint8Array();
+                        }
+                        handlers.onError?.(error);
+                        return new Uint8Array();
+                    }
+                }
+            }
+        };
+        handlers.onEvent(responseEvent);
+    };
+};
+export const createOnRequestFailed = (input) => {
+    const { handlers, getRequestId, hasRequestId, emitRequest } = input;
+    return (request) => {
+        const timestamp = Date.now();
+        const failure = request.failure?.();
+        const hadRequest = hasRequestId(request);
+        const requestId = getRequestId(request);
+        if (!hadRequest) {
+            emitRequest(request, timestamp);
+        }
+        const failedEvent = {
+            type: "failed",
+            requestId,
+            url: request.url(),
+            errorText: failure?.errorText ?? "Request failed",
+            timestamp
+        };
+        handlers.onEvent(failedEvent);
+    };
+};

package/dist/internal/puppeteer-adapter/targets.d.ts

@@ -0,0 +1,7 @@
+import type { InterceptTarget } from "@pagepocket/lib";
+import type { GoToOptions, Page } from "puppeteer";
+export declare const buildNavigate: (page: Page, gotoOptions?: GoToOptions) => {
+    navigate: (url: string, options?: GoToOptions) => Promise<void>;
+    awaitLastNavigation: (fallbackUrl: string) => Promise<void>;
+};
+export declare const ensureHtmlTargetLoaded: (page: Page, target: InterceptTarget) => Promise<void>;

package/dist/internal/puppeteer-adapter/targets.js

@@ -0,0 +1,25 @@
+export const buildNavigate = (page, gotoOptions) => {
+    let navigationPromise;
+    const navigate = async (url, options) => {
+        navigationPromise = page.goto(url, {
+            ...gotoOptions,
+            ...options
+        });
+        await navigationPromise;
+    };
+    const awaitLastNavigation = async (fallbackUrl) => {
+        await (navigationPromise ?? navigate(fallbackUrl));
+    };
+    return { navigate, awaitLastNavigation };
+};
+export const ensureHtmlTargetLoaded = async (page, target) => {
+    if (target.kind !== "html") {
+        return;
+    }
+    const baseTag = `<base href="${target.baseUrl}">`;
+    const alreadyHasBase = /<base\s+/i.test(target.htmlString);
+    const htmlWithBase = alreadyHasBase
+        ? target.htmlString
+        : target.htmlString.replace(/<head(\s[^>]*)?>/i, (match) => `${match}${baseTag}`);
+    await page.setContent(htmlWithBase, { waitUntil: "domcontentloaded" });
+};

package/dist/internal/puppeteer-adapter.js

@@ -1,14 +1,10 @@
 import puppeteer from "puppeteer";
+import { createEmitRequest, createOnRequestFailed, createOnResponse, createRequestIdStore } from "./puppeteer-adapter/events.js";
+import { buildNavigate, ensureHtmlTargetLoaded } from "./puppeteer-adapter/targets.js";
 import { readDomHtml } from "./utils/dom-html.js";
 import { getEnvString } from "./utils/env.js";
-import { buildMissingChromeHelp, isMissingChromeError, isResponseBodyUnavailableError } from "./utils/errors.js";
-import { getHeaderValue, normalizeHeaders } from "./utils/headers.js";
-import { getFrameId, getInitiator } from "./utils/puppeteer-internals.js";
+import { buildMissingChromeHelp, getErrorMessage, isMissingChromeError } from "./utils/errors.js";
 import { runTriggerActions } from "./utils/trigger-actions.js";
-const toResourceType = (request) => {
-    const type = request.resourceType?.();
-    return type ? type : undefined;
-};
 /**
  * Internal adapter for the capture plugin.
  *
@@ -52,10 +48,7 @@ export class PuppeteerAdapter {
                         if (!isMissingChromeError(error)) {
                             throw error;
                         }
-                        const message = error && typeof error.message === "string"
-                            ? error.message
-                            : String(error);
-                        throw new Error(`${message}\n\n${buildMissingChromeHelp()}`);
+                        throw new Error(`${getErrorMessage(error)}\n\n${buildMissingChromeHelp()}`);
                     }
                     ownsBrowser = true;
                 }
@@ -69,153 +62,35 @@ export class PuppeteerAdapter {
         if (!page || typeof page.on !== "function") {
             throw new Error("PuppeteerAdapter requires a Puppeteer Page instance.");
         }
-        const requestIds = new WeakMap();
-        let requestSequence = 0;
-        const getRequestId = (request) => {
-            const existing = requestIds.get(request);
-            if (existing) {
-                return existing;
-            }
-            const requestId = `pptr-${Date.now()}-${requestSequence++}`;
-            requestIds.set(request, requestId);
-            return requestId;
-        };
-        const emitRequest = (request, timestamp) => {
-            const requestEvent = {
-                type: "request",
-                requestId: getRequestId(request),
-                url: request.url(),
-                method: request.method(),
-                headers: normalizeHeaders(request.headers()),
-                frameId: getFrameId(request),
-                resourceType: toResourceType(request),
-                initiator: getInitiator(request),
-                timestamp
-            };
-            handlers.onEvent(requestEvent);
-        };
-        const onRequest = (request) => {
-            const timestamp = Date.now();
-            emitRequest(request, timestamp);
-        };
-        const onResponse = (response) => {
-            const timestamp = Date.now();
-            const request = response.request();
-            if (!requestIds.has(request)) {
-                emitRequest(request, timestamp);
-            }
-            const headers = normalizeHeaders(response.headers());
-            const isExpectedMissingBody = () => {
-                const method = request.method().toUpperCase();
-                if (method === "OPTIONS" || method === "HEAD") {
-                    return true;
-                }
-                const status = response.status();
-                if (status >= 100 && status < 200) {
-                    return true;
-                }
-                if (status >= 300 && status < 400) {
-                    return true;
-                }
-                if (status === 206) {
-                    // Range / streaming responses are frequently not retrievable via CDP.
-                    // Treat missing bodies as expected to avoid noisy adapter errors.
-                    const contentRange = getHeaderValue(headers, "content-range");
-                    const contentType = getHeaderValue(headers, "content-type") ?? "";
-                    if (contentRange) {
-                        return true;
-                    }
-                    if (/^video\//i.test(contentType) || /^audio\//i.test(contentType)) {
-                        return true;
-                    }
-                }
-                return status === 204 || status === 205 || status === 304;
-            };
-            const responseEvent = {
-                type: "response",
-                requestId: getRequestId(request),
-                url: response.url(),
-                status: response.status(),
-                statusText: response.statusText(),
-                headers,
-                mimeType: getHeaderValue(headers, "content-type"),
-                fromDiskCache: response.fromCache(),
-                fromServiceWorker: response.fromServiceWorker(),
-                timestamp,
-                body: {
-                    kind: "late",
-                    read: async () => {
-                        try {
-                            const buffer = await response.buffer();
-                            return new Uint8Array(buffer);
-                        }
-                        catch (error) {
-                            if (isResponseBodyUnavailableError(error)) {
-                                if (!isExpectedMissingBody()) {
-                                    const method = request.method();
-                                    const status = response.status();
-                                    const url = response.url();
-                                    handlers.onError?.(new Error(`Unexpected missing response body (method=${method} status=${status}) for ${url}`));
-                                }
-                                return new Uint8Array();
-                            }
-                            handlers.onError?.(error);
-                            return new Uint8Array();
-                        }
-                    }
-                }
-            };
-            handlers.onEvent(responseEvent);
-        };
-        const onRequestFailed = (request) => {
-            const timestamp = Date.now();
-            const failure = request.failure?.();
-            const hadRequest = requestIds.has(request);
-            const requestId = getRequestId(request);
-            if (!hadRequest) {
-                emitRequest(request, timestamp);
-            }
-            const failedEvent = {
-                type: "failed",
-                requestId,
-                url: request.url(),
-                errorText: failure?.errorText ?? "Request failed",
-                timestamp
-            };
-            handlers.onEvent(failedEvent);
-        };
+        const { getRequestId, has } = createRequestIdStore();
+        const emitRequest = createEmitRequest(handlers, getRequestId);
+        const onRequest = (request) => emitRequest(request, Date.now());
+        const onResponse = createOnResponse({
+            handlers,
+            getRequestId,
+            hasRequestId: has,
+            emitRequest
+        });
+        const onRequestFailed = createOnRequestFailed({
+            handlers,
+            getRequestId,
+            hasRequestId: has,
+            emitRequest
+        });
         page.on("request", onRequest);
         page.on("response", onResponse);
         page.on("requestfailed", onRequestFailed);
-        let navigationPromise = null;
-        const navigate = async (url, options) => {
-            navigationPromise = page.goto(url, {
-                ...this.options.gotoOptions,
-                ...options
-            });
-            await navigationPromise;
-        };
-        const ensureHtmlTargetLoaded = async () => {
-            if (target.kind !== "html") {
-                return;
-            }
-            const baseTag = `<base href="${target.baseUrl}">`;
-            const alreadyHasBase = /<base\s+/i.test(target.htmlString);
-            const htmlWithBase = alreadyHasBase
-                ? target.htmlString
-                : target.htmlString.replace(/<head(\s[^>]*)?>/i, (match) => `${match}${baseTag}`);
-            await page.setContent(htmlWithBase, { waitUntil: "domcontentloaded" });
-        };
+        const { navigate, awaitLastNavigation } = buildNavigate(page, this.options.gotoOptions);
         let htmlLoaded = false;
         const whenHtmlLoaded = async () => {
             if (htmlLoaded) {
                 return;
             }
             if (target.kind === "url") {
-                await (navigationPromise ?? navigate(target.url));
+                await awaitLastNavigation(target.url);
             }
             else if (target.kind === "html") {
-                await ensureHtmlTargetLoaded();
+                await ensureHtmlTargetLoaded(page, target);
             }
             htmlLoaded = true;
         };

package/dist/internal/utils/errors.d.ts

@@ -1,4 +1,5 @@
 export declare const isMissingChromeError: (error: unknown) => boolean;
+export declare const getErrorMessage: (error: unknown) => string;
 export declare const buildMissingChromeHelp: () => string;
 export declare const isNoDataForResourceError: (error: unknown) => boolean;
 /**

package/dist/internal/utils/errors.js

@@ -4,6 +4,18 @@ export const isMissingChromeError = (error) => {
         : "";
     return message.includes("Could not find Chrome") || message.includes("Could not find Chromium");
 };
+export const getErrorMessage = (error) => {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (error && typeof error === "object" && "message" in error) {
+        const msg = error.message;
+        if (typeof msg === "string") {
+            return msg;
+        }
+    }
+    return String(error);
+};
 export const buildMissingChromeHelp = () => {
     return `Puppeteer could not find a compatible Chrome installation.
 

package/dist/internal/utils/puppeteer-internals.js

@@ -1,21 +1,26 @@
 export const getFrameId = (request) => {
     const frame = request.frame();
-    if (!frame)
+    if (!frame) {
         return undefined;
+    }
     const frameRef = frame;
-    if (frameRef._id)
+    if (frameRef._id) {
         return frameRef._id;
-    if (frameRef._frameId)
+    }
+    if (frameRef._frameId) {
         return frameRef._frameId;
-    if (typeof frameRef.id === "function")
+    }
+    if (typeof frameRef.id === "function") {
         return frameRef.id();
+    }
     return undefined;
 };
 export const getInitiator = (request) => {
     const requestRef = request;
     const initiator = requestRef.initiator?.();
-    if (!initiator)
+    if (!initiator) {
         return undefined;
+    }
     return {
         type: initiator.type,
         url: initiator.url

package/dist/internal/utils/trigger-actions.js

@@ -1,6 +1,7 @@
 export const runTriggerActions = async (page, actions = []) => {
-    if (actions.length === 0)
+    if (actions.length === 0) {
         return;
+    }
     await page.evaluate((actionsArg) => {
         const hoverAll = () => {
             const elements = Array.from(document.querySelectorAll("*"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagepocket/capture-http-puppeteer-unit",
-  "version": "0.8.5",
+  "version": "0.9.0",
   "description": "PagePocket plugin: capture HTTP events (puppeteer adapter)",
   "type": "module",
   "main": "dist/index.js",
@@ -11,8 +11,8 @@
   "license": "ISC",
   "dependencies": {
     "puppeteer": "^22.12.1",
-    "@pagepocket/lib": "0.8.5",
-    "@pagepocket/contracts": "0.8.5"
+    "@pagepocket/lib": "0.9.0",
+    "@pagepocket/contracts": "0.9.0"
   },
   "devDependencies": {
     "typescript": "^5.4.5"