@pagepocket/lib 0.4.2 → 0.5.0

package/dist/replay-script.js

@@ -1,10 +1,148 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildReplayScript = void 0;
+exports.matchAPI = matchAPI;
 const hackers_1 = require("./hackers");
-const buildReplayScript = (requestsPath, baseUrl) => {
+function matchAPI(options) {
+    const { records, byKey, baseUrl, method, url, body } = options;
+    const normalizeBody = (value) => {
+        if (value === undefined || value === null)
+            return "";
+        if (typeof value === "string")
+            return value;
+        try {
+            return String(value);
+        }
+        catch {
+            return "";
+        }
+    };
+    const normalizeUrl = (input) => {
+        try {
+            return new URL(input, baseUrl).toString();
+        }
+        catch {
+            return input;
+        }
+    };
+    const stripHash = (value) => {
+        const index = value.indexOf("#");
+        return index === -1 ? value : value.slice(0, index);
+    };
+    const stripTrailingSlash = (value) => {
+        if (value.length > 1 && value.endsWith("/")) {
+            return value.slice(0, -1);
+        }
+        return value;
+    };
+    const safeUrl = (input) => {
+        try {
+            return new URL(input, baseUrl);
+        }
+        catch {
+            return null;
+        }
+    };
+    const toPathSearch = (input) => {
+        const parsed = safeUrl(input);
+        if (!parsed)
+            return input;
+        return parsed.pathname + parsed.search;
+    };
+    const toPathname = (input) => {
+        const parsed = safeUrl(input);
+        return parsed ? parsed.pathname : input;
+    };
+    const buildUrlVariants = (input) => {
+        const variants = new Set();
+        const push = (value) => {
+            if (!value)
+                return;
+            variants.add(value);
+        };
+        const raw = String(input ?? "");
+        push(raw);
+        push(stripHash(raw));
+        push(stripTrailingSlash(raw));
+        push(stripTrailingSlash(stripHash(raw)));
+        const absolute = normalizeUrl(raw);
+        push(absolute);
+        const absoluteNoHash = stripHash(absolute);
+        push(absoluteNoHash);
+        push(stripTrailingSlash(absoluteNoHash));
+        const pathSearch = toPathSearch(raw);
+        push(pathSearch);
+        push(stripTrailingSlash(pathSearch));
+        const pathname = toPathname(raw);
+        push(pathname);
+        push(stripTrailingSlash(pathname));
+        return Array.from(variants);
+    };
+    const makeKey = (keyMethod, keyUrl, keyBody) => keyMethod.toUpperCase() + " " + normalizeUrl(keyUrl) + " " + normalizeBody(keyBody);
+    const urlVariants = buildUrlVariants(url);
+    const bodyValue = normalizeBody(body);
+    const methodValue = (method || "GET").toUpperCase();
+    const tryLookup = (keyMethod, keyBody) => {
+        if (!byKey)
+            return undefined;
+        for (const urlVariant of urlVariants) {
+            const record = byKey.get(makeKey(keyMethod, urlVariant, keyBody));
+            if (record)
+                return record;
+        }
+        return undefined;
+    };
+    const matchOrder = [
+        [methodValue, bodyValue],
+        [methodValue, ""],
+        ["GET", ""],
+        ["GET", bodyValue]
+    ];
+    for (const [keyMethod, keyBody] of matchOrder) {
+        const record = tryLookup(keyMethod, keyBody);
+        if (record)
+            return record;
+    }
+    const urlMatches = (inputUrl, recordUrl) => {
+        const inputAbs = stripHash(normalizeUrl(inputUrl));
+        const recordAbs = stripHash(normalizeUrl(recordUrl));
+        if (inputAbs === recordAbs)
+            return true;
+        const inputPathSearch = stripTrailingSlash(toPathSearch(inputUrl));
+        const recordPathSearch = stripTrailingSlash(toPathSearch(recordUrl));
+        if (inputPathSearch === recordPathSearch)
+            return true;
+        const inputPath = stripTrailingSlash(toPathname(inputUrl));
+        const recordPath = stripTrailingSlash(toPathname(recordUrl));
+        if (inputPath === recordPath)
+            return true;
+        return false;
+    };
+    const scanRecords = (keyMethod, keyBody) => {
+        for (const record of records || []) {
+            if (!record || !record.url || !record.method)
+                continue;
+            if (record.method.toUpperCase() !== keyMethod)
+                continue;
+            if (!urlMatches(url, record.url))
+                continue;
+            const recordBody = record.requestBody || record.requestBodyBase64 || "";
+            if (keyBody && recordBody !== keyBody)
+                continue;
+            return record;
+        }
+        return undefined;
+    };
+    for (const [keyMethod, keyBody] of matchOrder) {
+        const record = scanRecords(keyMethod, keyBody);
+        if (record)
+            return record;
+    }
+    return undefined;
+}
+const buildReplayScript = (apiPath, baseUrl) => {
     const basePayload = JSON.stringify(baseUrl);
-    const requestsPayload = JSON.stringify(requestsPath);
+    const apiPayload = JSON.stringify(apiPath);
     const context = { stage: "replay" };
     const hackerScripts = hackers_1.replayHackers
         .map((hacker) => `  // hacker:${hacker.id}\n${hacker.build(context)}`)
@@ -12,34 +150,25 @@ const buildReplayScript = (requestsPath, baseUrl) => {
     return `
 <script>
 (function(){
-  // Load the snapshot metadata before patching runtime APIs.
   const baseUrl = ${basePayload};
-  const requestsUrl = ${requestsPayload};
+  const apiUrl = ${apiPayload};
   const __pagepocketOriginalFetch = window.fetch ? window.fetch.bind(window) : null;
 
-  const loadSnapshot = async () => {
+  const loadApiSnapshot = async () => {
     try {
       if (!__pagepocketOriginalFetch) {
         throw new Error("Fetch is unavailable");
       }
-      const response = await __pagepocketOriginalFetch(requestsUrl);
+      const response = await __pagepocketOriginalFetch(apiUrl);
       if (!response.ok) {
-        throw new Error("Failed to load snapshot metadata");
+        throw new Error("Failed to load api.json");
       }
       return await response.json();
     } catch {
-      return {
-        url: baseUrl,
-        title: "",
-        capturedAt: "",
-        fetchXhrRecords: [],
-        networkRecords: [],
-        resources: []
-      };
+      return { version: "1.0", url: baseUrl, createdAt: 0, records: [] };
     }
   };
 
-  // Soften JSON parse failures to avoid halting replay flows.
   const originalResponseJson = Response && Response.prototype && Response.prototype.json;
   if (originalResponseJson) {
     Response.prototype.json = function(...args) {
@@ -51,7 +180,6 @@ const buildReplayScript = (requestsPath, baseUrl) => {
     };
   }
 
-  // Guard to reapply patches if overwritten later.
   const ensureReplayPatches = () => {
     try {
       if (!window.fetch.__pagepocketOriginal && typeof __pagepocketOriginalFetch === "function") {
@@ -66,134 +194,39 @@ const buildReplayScript = (requestsPath, baseUrl) => {
   };
 
   let records = [];
-  let networkRecords = [];
   const byKey = new Map();
 
-  const localResourceSet = new Set();
-  const resourceUrlMap = new Map();
-
   const normalizeUrl = (input) => {
     try { return new URL(input, baseUrl).toString(); } catch { return input; }
   };
 
-  let baseOrigin = "";
-  let baseDir = "";
-  try {
-    const parsedBase = new URL(baseUrl);
-    baseOrigin = parsedBase.origin;
-    baseDir = new URL(".", parsedBase).toString().replace(/\\/$/, "");
-  } catch {}
-
-
-  const expandUrlVariants = (value) => {
-    const variants = [];
-    if (typeof value === "string") {
-      variants.push(value);
-      variants.push(normalizeUrl(value));
-      if (baseOrigin && value.startsWith("/")) {
-        variants.push(baseOrigin + value);
-        if (baseDir) variants.push(baseDir + value);
-      } else if (baseDir) {
-        variants.push(baseDir + (value.startsWith("/") ? value : "/" + value));
-      }
-      try {
-        const parsed = new URL(value, baseUrl);
-        const pathWithSearch = (parsed.pathname || "") + (parsed.search || "");
-        if (baseOrigin && parsed.origin !== baseOrigin) {
-          variants.push(baseOrigin + pathWithSearch);
-          if (baseDir) {
-            const path = pathWithSearch.startsWith("/") ? pathWithSearch : "/" + pathWithSearch;
-            variants.push(baseDir + path);
-          }
-        }
-      } catch {}
-    }
-    return Array.from(new Set(variants.filter(Boolean)));
-  };
-
   const normalizeBody = (body) => {
     if (body === undefined || body === null) return "";
     if (typeof body === "string") return body;
     try { return String(body); } catch { return ""; }
   };
 
-  // Build a stable key so requests with identical method/url/body match the same response.
   const makeKey = (method, url, body) => method.toUpperCase() + " " + normalizeUrl(url) + " " + normalizeBody(body);
-  const makeVariantKeys = (method, url, body) => {
-    return expandUrlVariants(url).map((variant) => makeKey(method, variant, body));
-  };
-  const normalizeNetworkRecord = (record) => {
-    if (!record || typeof record !== "object") {
-      return record;
-    }
-    if (record.response && record.response.body !== undefined) {
-      const response = record.response || {};
-      const encoding = response.bodyEncoding || "text";
-      return {
-        url: record.url,
-        method: record.method || "GET",
-        requestBody: record.requestBody || "",
-        status: response.status,
-        statusText: response.statusText,
-        responseHeaders: response.headers,
-        responseBody: encoding === "text" ? response.body : undefined,
-        responseBodyBase64: encoding === "base64" ? response.body : undefined,
-        responseEncoding: encoding,
-        error: record.error,
-        timestamp: record.timestamp
-      };
-    }
-    return record;
-  };
+  const makeVariantKeys = (method, url, body) => [makeKey(method, url, body)];
+
+  const matchAPI = ${matchAPI.toString()};
 
   const primeLookups = (snapshot) => {
-    records = snapshot.fetchXhrRecords || [];
-    networkRecords = (snapshot.networkRecords || []).map(normalizeNetworkRecord);
+    records = snapshot.records || [];
     byKey.clear();
-    localResourceSet.clear();
-    resourceUrlMap.clear();
-
     for (const record of records) {
       if (!record || !record.url || !record.method) continue;
-      const keys = makeVariantKeys(record.method, record.url, record.requestBody || "");
-      for (const key of keys) {
-        if (!byKey.has(key)) {
-          byKey.set(key, record);
-        }
-      }
-    }
-
-    for (const record of networkRecords) {
-      if (!record || !record.url || !record.method) continue;
-      const keys = makeVariantKeys(record.method, record.url, record.requestBody || "");
+      const keys = makeVariantKeys(record.method, record.url, record.requestBody || record.requestBodyBase64 || "");
       for (const key of keys) {
         if (!byKey.has(key)) {
           byKey.set(key, record);
         }
       }
     }
-
-    // Track local resource files and map original URLs to local paths.
-    const resourceList = snapshot.resources || [];
-    for (const item of resourceList) {
-      if (!item || !item.localPath) continue;
-      localResourceSet.add(item.localPath);
-      localResourceSet.add("./" + item.localPath);
-      localResourceSet.add("/" + item.localPath);
-
-      if (item.url) {
-        const variants = expandUrlVariants(item.url);
-        for (const variant of variants) {
-          resourceUrlMap.set(variant, item.localPath);
-        }
-      }
-    }
   };
 
-
   const ready = (async () => {
-    // Deserialize the snapshot and prepare lookup tables for offline responses.
-    const snapshot = (await loadSnapshot()) || {};
+    const snapshot = (await loadApiSnapshot()) || {};
     primeLookups(snapshot);
     return snapshot;
   })();
@@ -201,80 +234,34 @@ const buildReplayScript = (requestsPath, baseUrl) => {
   const isLocalResource = (value) => {
     if (!value) return false;
     if (value.startsWith("data:") || value.startsWith("blob:")) return true;
-    return localResourceSet.has(value);
+    if (value.startsWith("/")) return true;
+    return false;
   };
 
-  // Lookup helpers for request records and local assets.
   const findRecord = (method, url, body) => {
-    const variants = expandUrlVariants(url);
-    for (const variant of variants) {
-      const key = makeKey(method, variant, body);
-      if (byKey.has(key)) return byKey.get(key);
-    }
-    for (const variant of variants) {
-      const fallbackKey = makeKey(method, variant, "");
-      if (byKey.has(fallbackKey)) return byKey.get(fallbackKey);
-    }
-    for (const variant of variants) {
-      const getKey = makeKey("GET", variant, "");
-      if (byKey.has(getKey)) return byKey.get(getKey);
-    }
-    return null;
+    return matchAPI({ records, byKey, baseUrl, method, url, body });
   };
 
   const findByUrl = (url) => {
     if (isLocalResource(url)) return null;
-    const variants = expandUrlVariants(url);
-    for (const variant of variants) {
-      const direct = byKey.get(makeKey("GET", variant, ""));
-      if (direct) return direct;
-    }
-    // Attempt a looser match: ignore querystring if needed.
-    for (const variant of variants) {
-      try {
-        const withoutQuery = new URL(variant).origin + new URL(variant).pathname;
-        const direct = byKey.get(makeKey("GET", withoutQuery, ""));
-        if (direct) return direct;
-      } catch {}
-    }
-    return null;
+    return matchAPI({ records, byKey, baseUrl, method: "GET", url, body: "" });
   };
 
-  const findLocalPath = (url) => {
-    if (!url) return null;
-    const variants = expandUrlVariants(url);
-    for (const variant of variants) {
-      const hit = resourceUrlMap.get(variant);
-      if (hit) return hit;
-    }
-    for (const variant of variants) {
-      try {
-        const withoutQuery = new URL(variant).origin + new URL(variant).pathname;
-        const hit = resourceUrlMap.get(withoutQuery);
-        if (hit) return hit;
-      } catch {}
-    }
-    // If still not found, fallback to data URLs if present.
-    return null;
-  };
+  const findLocalPath = () => null;
 
-  // Safe property injection for emulating XHR state transitions.
   const defineProp = (obj, key, value) => {
     try {
       Object.defineProperty(obj, key, { value, configurable: true });
     } catch {}
   };
 
-  // Base64 helpers for binary payloads.
   const decodeBase64 = (input) => {
     try {
       const binary = atob(input || "");
       const bytes = new Uint8Array(binary.length);
-
       Array.from(binary).forEach((char, index) => {
         bytes[index] = char.charCodeAt(0);
       });
-
       return bytes;
     } catch {
       return new Uint8Array();
@@ -295,7 +282,6 @@ const buildReplayScript = (requestsPath, baseUrl) => {
     }
   };
 
-  // Resolve a content type from recorded response headers.
   const getContentType = (record) => {
     const headers = record.responseHeaders || {};
     for (const key in headers) {
@@ -306,21 +292,18 @@ const buildReplayScript = (requestsPath, baseUrl) => {
     return "application/octet-stream";
   };
 
-  // Turn a recorded response into a data URL for inline usage.
   const toDataUrl = (record, fallbackType) => {
     if (!record) return "";
     const contentType = getContentType(record) || fallbackType || "application/octet-stream";
     if (record.responseEncoding === "base64" && record.responseBodyBase64) {
       return "data:" + contentType + ";base64," + record.responseBodyBase64;
     }
-
     if (record.responseBody) {
       return "data:" + contentType + ";base64," + textToBase64(record.responseBody);
     }
     return "data:" + (fallbackType || "application/octet-stream") + ",";
   };
 
-  // Build a real Response object from the recorded payload.
   const responseFromRecord = (record) => {
     const headers = new Headers(record.responseHeaders || {});
     if (record.responseEncoding === "base64" && record.responseBodyBase64) {

package/dist/resource-filter.d.ts

@@ -0,0 +1,2 @@
+import type { ResourceFilter } from "./types";
+export declare const createDefaultResourceFilter: () => ResourceFilter;

package/dist/resource-filter.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultResourceFilter = void 0;
+const DEFAULT_ALLOWED = new Set([
+    "document",
+    "stylesheet",
+    "script",
+    "image",
+    "font",
+    "media"
+]);
+const isSkippableUrl = (url) => url.startsWith("data:") ||
+    url.startsWith("blob:") ||
+    url.startsWith("mailto:") ||
+    url.startsWith("tel:") ||
+    url.startsWith("javascript:");
+const createDefaultResourceFilter = () => ({
+    shouldSave(req, res) {
+        if (isSkippableUrl(req.url)) {
+            return false;
+        }
+        if (req.resourceType && (req.resourceType === "fetch" || req.resourceType === "xhr")) {
+            return false;
+        }
+        if (res && res.status >= 400) {
+            return false;
+        }
+        if (req.resourceType) {
+            return DEFAULT_ALLOWED.has(req.resourceType);
+        }
+        return true;
+    }
+});
+exports.createDefaultResourceFilter = createDefaultResourceFilter;

package/dist/rewrite-links.d.ts

@@ -1,15 +1,13 @@
-import type { CheerioAPI } from "cheerio";
-import type { DownloadedResource } from "./download-resources";
-import { type ResourceReference, type SrcsetReference } from "./resources";
-import type { NetworkRecord } from "./types";
-type RewriteLinksInput = {
-    $: CheerioAPI;
-    resourceUrls: ResourceReference[];
-    srcsetItems: SrcsetReference[];
-    baseUrl: string;
-    assetsDirName: string;
-    resourceMap: Map<string, DownloadedResource>;
-    networkRecords: NetworkRecord[];
-};
-export declare const rewriteLinks: (input: RewriteLinksInput) => Promise<void>;
+type UrlResolver = (absoluteUrl: string) => string | null;
+export declare const rewriteJsText: (source: string, resolve: UrlResolver, baseUrl: string) => Promise<string>;
+export declare const rewriteEntryHtml: (input: {
+    html: string;
+    entryUrl: string;
+    apiPath: string;
+    resolve: UrlResolver;
+    rewriteLinks?: boolean;
+}) => Promise<{
+    html: string;
+    title?: string;
+}>;
 export {};