@pagepocket/lib 0.4.1 → 0.5.0

package/README.md

@@ -1,8 +1,8 @@
 # @pagepocket/lib
 
-Library for rewriting captured HTML into an offline-ready snapshot. It downloads
-assets, rewrites HTML/CSS/JS references to local URLs, and injects replay/preload
-scripts.
+Core library for capturing a page via NetworkInterceptorAdapter events and
+producing a virtual snapshot (HTML/CSS/JS rewritten to absolute snapshot paths).
+No network fetch happens in the core library.
 
 ## Install
 
@@ -14,32 +14,81 @@ pnpm add @pagepocket/lib
 
 ```ts
 import { PagePocket } from "@pagepocket/lib";
+import { CdpAdapter } from "@pagepocket/cdp-adapter";
 
-const pagepocket = new PagePocket(htmlString, requestsJSON, {
-  assetsDirName: "example_files",
-  baseUrl: "https://example.com",
-  requestsPath: "example.requests.json"
+const interceptor = new CdpAdapter();
+const snapshot = await PagePocket.fromURL("https://example.com").capture({
+  interceptor
 });
 
-const html = await pagepocket.put();
+await snapshot.toDirectory("./out");
 ```
 
 ## API
 
 ```ts
-type PagePocketOptions = {
-  assetsDirName?: string;
-  baseUrl?: string;
-  requestsPath?: string;
-};
+class PagePocket {
+  static fromURL(url: string, options?: PagePocketOptions): PagePocket;
+  static fromTarget(target: InterceptTarget, options?: PagePocketOptions): PagePocket;
+  capture(options?: CaptureOptions): Promise<PageSnapshot>;
+}
 ```
 
-- `assetsDirName`: folder name for downloaded assets.
-- `baseUrl`: used to resolve relative URLs.
-- `requestsPath`: path to the `*.requests.json` file referenced by replay.
+### CaptureOptions (core)
 
-`put()` returns the rewritten HTML string.
+```ts
+interface CaptureOptions {
+  interceptor: NetworkInterceptorAdapter;
+  completion?: CompletionStrategy | CompletionStrategy[];
+  filter?: ResourceFilter;
+  pathResolver?: PathResolver;
+  contentStore?: ContentStore;
+  rewriteEntry?: boolean;
+  rewriteCSS?: boolean;
+  limits?: {
+    maxTotalBytes?: number;
+    maxSingleResourceBytes?: number;
+    maxResources?: number;
+  };
+}
+```
+
+### PageSnapshot output
+
+```ts
+interface PageSnapshot {
+  version: "1.0";
+  createdAt: number;
+  url: string;
+  entry: string;
+  files: SnapshotFile[];
+  toDirectory(outDir: string, options?: WriteFSOptions): Promise<WriteResult>;
+  toZip(options?: ZipOptions): Promise<Uint8Array | Blob>;
+}
+
+interface WriteFSOptions {
+  clearCache?: boolean;
+}
+
+interface ZipOptions {
+  asBlob?: boolean;
+  clearCache?: boolean;
+}
+```
+
+Snapshot layout:
+
+```
+/index.html
+/api.json
+/<same-origin paths>
+/external_resources/<cross-origin paths>
+```
+
+If multiple documents are captured, each document is written to its own output
+directory based on the document URL path (e.g. `foo/bar/index.html`).
 
 ## Notes
 
 - Uses `@pagepocket/uni-fs` for file IO so it works in Node and OPFS contexts.
+- Network data comes only from the interceptor events.

package/dist/completion.d.ts

@@ -0,0 +1,4 @@
+import type { CompletionStrategy } from "./types";
+export declare const timeout: (ms: number) => CompletionStrategy;
+export declare const networkIdle: (ms: number, checkInterval?: number) => CompletionStrategy;
+export declare const normalizeCompletion: (completion?: CompletionStrategy | CompletionStrategy[]) => CompletionStrategy[];

package/dist/completion.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCompletion = exports.networkIdle = exports.timeout = void 0;
+const utils_1 = require("./utils");
+const timeout = (ms) => ({
+    async wait() {
+        await (0, utils_1.sleep)(ms);
+    }
+});
+exports.timeout = timeout;
+const networkIdle = (ms, checkInterval = 100) => ({
+    async wait(ctx) {
+        while (true) {
+            const stats = ctx.getStats();
+            const idleFor = ctx.now() - stats.lastNetworkTs;
+            if (stats.inflightRequests === 0 && idleFor >= ms) {
+                return;
+            }
+            await (0, utils_1.sleep)(Math.min(checkInterval, ms));
+        }
+    }
+});
+exports.networkIdle = networkIdle;
+const normalizeCompletion = (completion) => {
+    if (!completion)
+        return [];
+    return Array.isArray(completion) ? completion : [completion];
+};
+exports.normalizeCompletion = normalizeCompletion;

package/dist/content-store.d.ts

@@ -0,0 +1,21 @@
+import type { BodySource, ContentRef, ContentStore } from "./types";
+type HybridContentStoreOptions = {
+    thresholdBytes?: number;
+    baseDir?: string;
+};
+export declare class HybridContentStore implements ContentStore {
+    name: string;
+    private thresholdBytes;
+    private baseDir;
+    private storedIds;
+    constructor(options?: HybridContentStoreOptions);
+    put(body: BodySource, meta: {
+        url: string;
+        mimeType?: string;
+        sizeHint?: number;
+    }): Promise<ContentRef>;
+    open(ref: ContentRef): Promise<ReadableStream<Uint8Array>>;
+    dispose(): Promise<void>;
+    private removeBaseDir;
+}
+export {};

package/dist/content-store.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridContentStore = void 0;
+const uni_fs_1 = require("@pagepocket/uni-fs");
+const utils_1 = require("./utils");
+const DEFAULT_THRESHOLD = 256 * 1024;
+const DEFAULT_BASE_DIR = ".pagepocket_store";
+const nowId = () => `${Date.now()}_${Math.random().toString(16).slice(2)}`;
+const streamFromBytes = (data) => new ReadableStream({
+    start(controller) {
+        controller.enqueue(data);
+        controller.close();
+    }
+});
+const isNodeEnvironment = () => {
+    const globalProcess = globalThis.process;
+    return typeof globalProcess?.versions?.node === "string";
+};
+class HybridContentStore {
+    constructor(options) {
+        this.name = "hybrid";
+        this.storedIds = new Set();
+        this.thresholdBytes = options?.thresholdBytes ?? DEFAULT_THRESHOLD;
+        this.baseDir = options?.baseDir ?? DEFAULT_BASE_DIR;
+    }
+    async put(body, meta) {
+        const data = await (0, utils_1.toUint8Array)(body);
+        const size = data.byteLength;
+        if (size <= this.thresholdBytes) {
+            return { kind: "memory", data };
+        }
+        const id = `${(0, utils_1.hashString)(meta.url)}_${nowId()}`;
+        await (0, uni_fs_1.write)(`${this.baseDir}/${id}`, "bin", data);
+        this.storedIds.add(id);
+        return { kind: "store-ref", id };
+    }
+    async open(ref) {
+        if (ref.kind === "memory") {
+            return streamFromBytes(ref.data);
+        }
+        const data = await (0, uni_fs_1.readBinary)(`${this.baseDir}/${ref.id}`, "bin");
+        return streamFromBytes(data);
+    }
+    async dispose() {
+        const entries = Array.from(this.storedIds);
+        this.storedIds.clear();
+        await Promise.all(entries.map((id) => (0, uni_fs_1.remove)(`${this.baseDir}/${id}`, "bin").catch(() => { })));
+        await this.removeBaseDir().catch(() => { });
+    }
+    async removeBaseDir() {
+        if (!isNodeEnvironment()) {
+            return;
+        }
+        if (!this.baseDir || this.baseDir === "/" || this.baseDir === ".") {
+            return;
+        }
+        const { resolve, isAbsolute } = await Promise.resolve().then(() => __importStar(require("node:path")));
+        const { rm } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+        const target = isAbsolute(this.baseDir) ? this.baseDir : resolve(this.baseDir);
+        await rm(target, { recursive: true, force: true });
+    }
+}
+exports.HybridContentStore = HybridContentStore;

package/dist/css-rewrite.d.ts

@@ -1,9 +1,8 @@
-export type CssUrlResolver = (absoluteUrl: string) => Promise<string | null>;
+export type CssUrlResolver = (absoluteUrl: string) => Promise<string | null> | string | null;
 type RewriteCssInput = {
-    filename: string;
-    extension: string;
+    cssText: string;
     cssUrl: string;
     resolveUrl: CssUrlResolver;
 };
-export declare const rewriteCssUrls: (input: RewriteCssInput) => Promise<boolean>;
+export declare const rewriteCssText: (input: RewriteCssInput) => Promise<string>;
 export {};

package/dist/css-rewrite.js

@@ -1,76 +1,75 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rewriteCssUrls = void 0;
+exports.rewriteCssText = void 0;
 const URL_PATTERN = /url\(\s*(['"]?)([^'")]+)\1\s*\)/g;
-const rewriteCssUrls = async (input) => {
-    const { readText, write } = await Promise.resolve().then(() => __importStar(require("uni-fs")));
-    const original = await readText(input.filename, input.extension);
+const IMPORT_PATTERN = /@import\s+(?:url\()?['"]?([^'")]+)['"]?\)?/g;
+const shouldSkipValue = (value) => {
+    const trimmed = value.trim();
+    return (!trimmed ||
+        trimmed.startsWith("data:") ||
+        trimmed.startsWith("blob:") ||
+        trimmed.startsWith("mailto:") ||
+        trimmed.startsWith("tel:") ||
+        trimmed.startsWith("javascript:") ||
+        trimmed.startsWith("#"));
+};
+const rewriteCssText = async (input) => {
+    const { cssText, cssUrl, resolveUrl } = input;
     let updated = "";
     let lastIndex = 0;
-    let changed = false;
-    for (const match of original.matchAll(URL_PATTERN)) {
+    for (const match of cssText.matchAll(URL_PATTERN)) {
         const index = match.index ?? 0;
-        updated += original.slice(lastIndex, index);
+        updated += cssText.slice(lastIndex, index);
         const quote = match[1] || "";
         const rawUrl = String(match[2] || "").trim();
         let replacement = match[0];
-        if (rawUrl && !rawUrl.startsWith("data:") && !rawUrl.startsWith("blob:")) {
+        if (!shouldSkipValue(rawUrl)) {
             const absolute = (() => {
                 try {
-                    return new URL(rawUrl, input.cssUrl).toString();
+                    return new URL(rawUrl, cssUrl).toString();
                 }
                 catch {
                     return null;
                 }
             })();
             if (absolute) {
-                const resolved = await input.resolveUrl(absolute);
+                const resolved = await resolveUrl(absolute);
                 if (resolved) {
                     replacement = `url(${quote}${resolved}${quote})`;
-                    changed = true;
                 }
             }
         }
         updated += replacement;
         lastIndex = index + match[0].length;
     }
-    updated += original.slice(lastIndex);
-    if (changed) {
-        await write(input.filename, input.extension, updated);
+    updated += cssText.slice(lastIndex);
+    let final = "";
+    lastIndex = 0;
+    for (const match of updated.matchAll(IMPORT_PATTERN)) {
+        const index = match.index ?? 0;
+        final += updated.slice(lastIndex, index);
+        const rawUrl = String(match[1] || "").trim();
+        let replacement = match[0];
+        if (!shouldSkipValue(rawUrl)) {
+            const absolute = (() => {
+                try {
+                    return new URL(rawUrl, cssUrl).toString();
+                }
+                catch {
+                    return null;
+                }
+            })();
+            if (absolute) {
+                const resolved = await resolveUrl(absolute);
+                if (resolved) {
+                    replacement = match[0].replace(rawUrl, resolved);
+                }
+            }
+        }
+        final += replacement;
+        lastIndex = index + match[0].length;
     }
-    return changed;
+    final += updated.slice(lastIndex);
+    return final;
 };
-exports.rewriteCssUrls = rewriteCssUrls;
+exports.rewriteCssText = rewriteCssText;

package/dist/download-resources.js

@@ -98,16 +98,13 @@ const collectSrcsetUrls = (items, baseUrl) => {
     return urls;
 };
 const downloadResources = async (input) => {
-    const { write, exists } = await Promise.resolve().then(() => __importStar(require("uni-fs")));
+    const { write, exists } = await Promise.resolve().then(() => __importStar(require("@pagepocket/uni-fs")));
     const resourceMap = new Map();
     const resourceMeta = [];
     let downloadedCount = 0;
     let failedCount = 0;
     const srcsetUrls = collectSrcsetUrls(input.srcsetItems, input.baseUrl);
-    const candidateUrls = [
-        ...input.resourceUrls.map((resource) => resource.url),
-        ...srcsetUrls
-    ];
+    const candidateUrls = [...input.resourceUrls.map((resource) => resource.url), ...srcsetUrls];
     for (const candidate of candidateUrls) {
         if (shouldSkipUrl(candidate)) {
             continue;

package/dist/hack-html.d.ts

@@ -2,7 +2,7 @@ import type { CheerioAPI } from "cheerio";
 type HackHtmlInput = {
     $: CheerioAPI;
     baseUrl: string;
-    requestsPath: string;
+    apiPath: string;
     faviconDataUrl?: string | null;
 };
 export declare const hackHtml: (input: HackHtmlInput) => void;

package/dist/hack-html.js

@@ -4,7 +4,7 @@ exports.hackHtml = void 0;
 const preload_1 = require("./preload");
 const replay_script_1 = require("./replay-script");
 const hackHtml = (input) => {
-    const replayScript = (0, replay_script_1.buildReplayScript)(input.requestsPath, input.baseUrl);
+    const replayScript = (0, replay_script_1.buildReplayScript)(input.apiPath, input.baseUrl);
     const preloadScript = `<script>${(0, preload_1.buildPreloadScript)()}</script>`;
     const head = input.$("head");
     const root = input.$.root();

package/dist/hackers/replay-xhr.js

@@ -51,13 +51,21 @@ exports.replayXhrResponder = {
             defineProp(xhr, "response", responseText);
             defineProp(xhr, "responseText", responseText);
           }
+          const makeEvent = (type) => {
+            const event = new Event(type);
+            try {
+              defineProp(event, "target", xhr);
+              defineProp(event, "currentTarget", xhr);
+            } catch {}
+            return event;
+          };
           if (typeof xhr.onreadystatechange === "function") xhr.onreadystatechange();
-          if (typeof xhr.onload === "function") xhr.onload(new Event("load"));
-          if (typeof xhr.onloadend === "function") xhr.onloadend(new Event("loadend"));
+          if (typeof xhr.onload === "function") xhr.onload(makeEvent("load"));
+          if (typeof xhr.onloadend === "function") xhr.onloadend(makeEvent("loadend"));
           if (xhr.dispatchEvent) {
-            xhr.dispatchEvent(new Event("readystatechange"));
-            xhr.dispatchEvent(new Event("load"));
-            xhr.dispatchEvent(new Event("loadend"));
+            xhr.dispatchEvent(makeEvent("readystatechange"));
+            xhr.dispatchEvent(makeEvent("load"));
+            xhr.dispatchEvent(makeEvent("loadend"));
           }
         }, 0);
         return;
@@ -72,13 +80,21 @@ exports.replayXhrResponder = {
         defineProp(xhr, "statusText", statusText);
         defineProp(xhr, "response", "");
         defineProp(xhr, "responseText", "");
+        const makeEvent = (type) => {
+          const event = new Event(type);
+          try {
+            defineProp(event, "target", xhr);
+            defineProp(event, "currentTarget", xhr);
+          } catch {}
+          return event;
+        };
         if (typeof xhr.onreadystatechange === "function") xhr.onreadystatechange();
-        if (typeof xhr.onload === "function") xhr.onload(new Event("load"));
-        if (typeof xhr.onloadend === "function") xhr.onloadend(new Event("loadend"));
+        if (typeof xhr.onload === "function") xhr.onload(makeEvent("load"));
+        if (typeof xhr.onloadend === "function") xhr.onloadend(makeEvent("loadend"));
         if (xhr.dispatchEvent) {
-          xhr.dispatchEvent(new Event("readystatechange"));
-          xhr.dispatchEvent(new Event("load"));
-          xhr.dispatchEvent(new Event("loadend"));
+          xhr.dispatchEvent(makeEvent("readystatechange"));
+          xhr.dispatchEvent(makeEvent("load"));
+          xhr.dispatchEvent(makeEvent("loadend"));
         }
       }, 0);
     });

package/dist/index.d.ts

@@ -1,6 +1,11 @@
 export { PagePocket } from "./pagepocket";
-export type { PagePocketOptions } from "./pagepocket";
-export type { FetchRecord, NetworkRecord, LighterceptorNetworkRecord, SnapshotData } from "./types";
+export type { ApiRecord, ApiSnapshot, CaptureOptions, CompletionContext, CompletionStrategy, ContentRef, ContentStore, ContentStoreHandle, InterceptOptions, InterceptSession, InterceptTarget, NetworkEvent, NetworkEventHandlers, NetworkInterceptorAdapter, NetworkRequestEvent, NetworkRequestFailedEvent, NetworkResponseEvent, PagePocketOptions, PageSnapshot, PathResolver, ResourceFilter, ResourceType, SnapshotFile, WriteFSOptions, WriteResult, ZipOptions } from "./types";
+export { HybridContentStore } from "./content-store";
+export { createDefaultPathResolver, withPrefixPathResolver } from "./path-resolver";
+export { createDefaultResourceFilter } from "./resource-filter";
+export { networkIdle, timeout } from "./completion";
 export { buildReplayScript } from "./replay-script";
 export { buildPreloadScript } from "./preload";
-export { findFaviconDataUrl, mapLighterceptorRecords, toDataUrlFromRecord } from "./network-records";
+export { rewriteEntryHtml, rewriteJsText } from "./rewrite-links";
+export { rewriteCssText } from "./css-rewrite";
+export { writeToFS, toZip } from "./writers";

package/dist/index.js

@@ -1,13 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toDataUrlFromRecord = exports.mapLighterceptorRecords = exports.findFaviconDataUrl = exports.buildPreloadScript = exports.buildReplayScript = exports.PagePocket = void 0;
+exports.toZip = exports.writeToFS = exports.rewriteCssText = exports.rewriteJsText = exports.rewriteEntryHtml = exports.buildPreloadScript = exports.buildReplayScript = exports.timeout = exports.networkIdle = exports.createDefaultResourceFilter = exports.withPrefixPathResolver = exports.createDefaultPathResolver = exports.HybridContentStore = exports.PagePocket = void 0;
 var pagepocket_1 = require("./pagepocket");
 Object.defineProperty(exports, "PagePocket", { enumerable: true, get: function () { return pagepocket_1.PagePocket; } });
+var content_store_1 = require("./content-store");
+Object.defineProperty(exports, "HybridContentStore", { enumerable: true, get: function () { return content_store_1.HybridContentStore; } });
+var path_resolver_1 = require("./path-resolver");
+Object.defineProperty(exports, "createDefaultPathResolver", { enumerable: true, get: function () { return path_resolver_1.createDefaultPathResolver; } });
+Object.defineProperty(exports, "withPrefixPathResolver", { enumerable: true, get: function () { return path_resolver_1.withPrefixPathResolver; } });
+var resource_filter_1 = require("./resource-filter");
+Object.defineProperty(exports, "createDefaultResourceFilter", { enumerable: true, get: function () { return resource_filter_1.createDefaultResourceFilter; } });
+var completion_1 = require("./completion");
+Object.defineProperty(exports, "networkIdle", { enumerable: true, get: function () { return completion_1.networkIdle; } });
+Object.defineProperty(exports, "timeout", { enumerable: true, get: function () { return completion_1.timeout; } });
 var replay_script_1 = require("./replay-script");
 Object.defineProperty(exports, "buildReplayScript", { enumerable: true, get: function () { return replay_script_1.buildReplayScript; } });
 var preload_1 = require("./preload");
 Object.defineProperty(exports, "buildPreloadScript", { enumerable: true, get: function () { return preload_1.buildPreloadScript; } });
-var network_records_1 = require("./network-records");
-Object.defineProperty(exports, "findFaviconDataUrl", { enumerable: true, get: function () { return network_records_1.findFaviconDataUrl; } });
-Object.defineProperty(exports, "mapLighterceptorRecords", { enumerable: true, get: function () { return network_records_1.mapLighterceptorRecords; } });
-Object.defineProperty(exports, "toDataUrlFromRecord", { enumerable: true, get: function () { return network_records_1.toDataUrlFromRecord; } });
+var rewrite_links_1 = require("./rewrite-links");
+Object.defineProperty(exports, "rewriteEntryHtml", { enumerable: true, get: function () { return rewrite_links_1.rewriteEntryHtml; } });
+Object.defineProperty(exports, "rewriteJsText", { enumerable: true, get: function () { return rewrite_links_1.rewriteJsText; } });
+var css_rewrite_1 = require("./css-rewrite");
+Object.defineProperty(exports, "rewriteCssText", { enumerable: true, get: function () { return css_rewrite_1.rewriteCssText; } });
+var writers_1 = require("./writers");
+Object.defineProperty(exports, "writeToFS", { enumerable: true, get: function () { return writers_1.writeToFS; } });
+Object.defineProperty(exports, "toZip", { enumerable: true, get: function () { return writers_1.toZip; } });

package/dist/network-records.d.ts

@@ -1,4 +1,4 @@
-import type { LighterceptorNetworkRecord, NetworkRecord } from "./types";
+import type { CapturedNetworkRecord, NetworkRecord } from "./types";
 export declare const toDataUrlFromRecord: (record: NetworkRecord) => string | null;
 export declare const findFaviconDataUrl: (records: NetworkRecord[]) => string | null;
-export declare const mapLighterceptorRecords: (records: LighterceptorNetworkRecord[] | undefined) => NetworkRecord[];
+export declare const mapCapturedNetworkRecords: (records: CapturedNetworkRecord[] | undefined) => NetworkRecord[];

package/dist/network-records.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapLighterceptorRecords = exports.findFaviconDataUrl = exports.toDataUrlFromRecord = void 0;
+exports.mapCapturedNetworkRecords = exports.findFaviconDataUrl = exports.toDataUrlFromRecord = void 0;
 const getHeaderValue = (headers, name) => {
     for (const key in headers) {
         if (key.toLowerCase() === name.toLowerCase()) {
@@ -61,7 +61,7 @@ const findFaviconDataUrl = (records) => {
     return null;
 };
 exports.findFaviconDataUrl = findFaviconDataUrl;
-const mapLighterceptorRecords = (records) => {
+const mapCapturedNetworkRecords = (records) => {
     if (!records)
         return [];
     return records.map((record) => {
@@ -80,4 +80,4 @@ const mapLighterceptorRecords = (records) => {
         };
     });
 };
-exports.mapLighterceptorRecords = mapLighterceptorRecords;
+exports.mapCapturedNetworkRecords = mapCapturedNetworkRecords;

package/dist/network-store.d.ts

@@ -0,0 +1,51 @@
+import type { ApiRecord, ContentRef, ContentStore, NetworkEvent, NetworkRequestEvent, NetworkRequestFailedEvent, NetworkResponseEvent, ResourceFilter } from "./types";
+type Limits = {
+    maxTotalBytes?: number;
+    maxSingleResourceBytes?: number;
+    maxResources?: number;
+};
+export type StoredResource = {
+    request: NetworkRequestEvent;
+    response: NetworkResponseEvent;
+    contentRef: ContentRef;
+    size: number;
+    mimeType?: string;
+};
+type RequestRecord = {
+    request: NetworkRequestEvent;
+    response?: NetworkResponseEvent;
+    failed?: NetworkRequestFailedEvent;
+};
+export type ApiEntry = {
+    record: ApiRecord;
+    request: NetworkRequestEvent;
+};
+export declare class NetworkStore {
+    private contentStore;
+    private filter;
+    private limits;
+    private requests;
+    private storedResources;
+    private apiEntries;
+    private apiRecordIds;
+    private warnings;
+    private totalBytes;
+    constructor(options: {
+        contentStore: ContentStore;
+        filter: ResourceFilter;
+        limits?: Limits;
+    });
+    getWarnings(): string[];
+    getTotals(): {
+        totalBytes: number;
+        totalFiles: number;
+    };
+    getResources(): StoredResource[];
+    getApiRecords(): ApiRecord[];
+    getApiEntries(): ApiEntry[];
+    getRequestRecords(): Map<string, RequestRecord>;
+    handleEvent(event: NetworkEvent): Promise<void>;
+    private recordApiFailure;
+    private recordApiResponse;
+}
+export {};