@pagepocket/lib 0.8.6 → 0.9.1

package/dist/replay/match-api.js

@@ -2,10 +2,12 @@ import { urlEquivalent } from "../utils.js";
 export function matchAPI(options) {
     const { records, byKey, baseUrl, method, url, body } = options;
     const normalizeBody = (value) => {
-        if (value === undefined || value === null)
+        if (value === undefined || value === null) {
             return "";
-        if (typeof value === "string")
+        }
+        if (typeof value === "string") {
             return value;
+        }
         try {
             return String(value);
         }
@@ -36,13 +38,14 @@ export function matchAPI(options) {
             return new URL(input, baseUrl);
         }
         catch {
-            return null;
+            return undefined;
         }
     };
     const toPathSearch = (input) => {
         const parsed = safeUrl(input);
-        if (!parsed)
+        if (!parsed) {
             return input;
+        }
         return parsed.pathname + parsed.search;
     };
     const toPathname = (input) => {
@@ -52,8 +55,9 @@ export function matchAPI(options) {
     const buildUrlVariants = (input) => {
         const variants = new Set();
         const push = (value) => {
-            if (!value)
+            if (!value) {
                 return;
+            }
             variants.add(value);
         };
         const raw = String(input ?? "");
@@ -79,12 +83,14 @@ export function matchAPI(options) {
     const bodyValue = normalizeBody(body);
     const methodValue = (method || "GET").toUpperCase();
     const tryLookup = (keyMethod, keyBody) => {
-        if (!byKey)
+        if (!byKey) {
             return undefined;
+        }
         for (const urlVariant of urlVariants) {
             const record = byKey.get(makeKey(keyMethod, urlVariant, keyBody));
-            if (record)
+            if (record) {
                 return record;
+            }
         }
         return undefined;
     };
@@ -96,15 +102,16 @@ export function matchAPI(options) {
     ];
     for (const [keyMethod, keyBody] of matchOrder) {
         const record = tryLookup(keyMethod, keyBody);
-        if (record)
+        if (record) {
             return record;
+        }
     }
-    const toUrlOrNull = (value) => {
+    const toUrlOrUndefined = (value) => {
         try {
             return new URL(value, baseUrl);
         }
         catch {
-            return null;
+            return undefined;
         }
     };
     const normalizePath = (value) => {
@@ -124,8 +131,8 @@ export function matchAPI(options) {
             return true;
         }
         // Relaxed fallback: allow origin mismatch but keep path/search stable.
-        const left = toUrlOrNull(inputUrl);
-        const right = toUrlOrNull(recordUrl);
+        const left = toUrlOrUndefined(inputUrl);
+        const right = toUrlOrUndefined(recordUrl);
         if (!left || !right) {
             return false;
         }
@@ -140,23 +147,28 @@ export function matchAPI(options) {
     };
     const scanRecords = (keyMethod, keyBody) => {
         for (const record of records || []) {
-            if (!record || !record.url || !record.method)
+            if (!record || !record.url || !record.method) {
                 continue;
-            if (record.method.toUpperCase() !== keyMethod)
+            }
+            if (record.method.toUpperCase() !== keyMethod) {
                 continue;
-            if (!urlMatches(url, record.url))
+            }
+            if (!urlMatches(url, record.url)) {
                 continue;
+            }
             const recordBody = record.requestBody || record.requestBodyBase64 || "";
-            if (keyBody && recordBody !== keyBody)
+            if (keyBody && recordBody !== keyBody) {
                 continue;
+            }
             return record;
         }
         return undefined;
     };
     for (const [keyMethod, keyBody] of matchOrder) {
         const record = scanRecords(keyMethod, keyBody);
-        if (record)
+        if (record) {
             return record;
+        }
     }
     return undefined;
 }

package/dist/replay/templates/replay-script-template.js

@@ -1,337 +1,21 @@
 import { matchAPISource } from "./match-api-source.js";
+import { buildReplayInjectedScriptPart1 } from "./replay-script-template.part-1.js";
+import { buildReplayInjectedScriptPart2 } from "./replay-script-template.part-2.js";
+import { buildReplayInjectedScriptPart3 } from "./replay-script-template.part-3.js";
 import { resourceProxyScript } from "./resource-proxy-script.js";
 export const buildReplayInjectedScript = (options) => {
     const { basePayload, apiPayload, hackerScripts } = options;
-    return `
-<script>
-(function(){
-  const baseUrl = ${basePayload};
-  const apiUrl = ${apiPayload};
-  const resourcesPathUrl = "/resources_path.json";
-  const __pagepocketOriginalFetch = window.fetch ? window.fetch.bind(window) : null;
-
-${resourceProxyScript}
-
-  const loadResourcesPath = async () => {
-    try {
-      const injected = window && window.__pagepocketResourcesPath;
-      if (injected && injected.version === "1.0" && Array.isArray(injected.items)) {
-        return injected;
-      }
-
-      if (!__pagepocketOriginalFetch) {
-        throw new Error("Fetch is unavailable");
-      }
-      const response = await __pagepocketOriginalFetch(resourcesPathUrl);
-      if (!response.ok) {
-        throw new Error("Failed to load resources_path.json");
-      }
-      const json = await response.json();
-      if (!json || json.version !== "1.0" || !Array.isArray(json.items)) {
-        throw new Error("Invalid resources_path.json");
-      }
-      return json;
-    } catch {
-      return { version: "1.0", createdAt: 0, items: [] };
-    }
-  };
-
-  const loadApiSnapshot = async () => {
-    try {
-      const injected = window && window.__pagepocketApiSnapshot;
-      if (injected && injected.version === "1.0" && Array.isArray(injected.records)) {
-        return injected;
-      }
-
-      if (!__pagepocketOriginalFetch) {
-        throw new Error("Fetch is unavailable");
-      }
-      const response = await __pagepocketOriginalFetch(apiUrl);
-      if (!response.ok) {
-        throw new Error("Failed to load api.json");
-      }
-      return await response.json();
-    } catch {
-      return { version: "1.0", url: baseUrl, createdAt: 0, records: [] };
-    }
-  };
-
-  const originalResponseJson = Response && Response.prototype && Response.prototype.json;
-  if (originalResponseJson) {
-    Response.prototype.json = function(...args) {
-      try {
-        return originalResponseJson.apply(this, args).catch(() => null);
-      } catch {
-        return Promise.resolve(null);
-      }
-    };
-  }
-
-  const ensureReplayPatches = () => {
-    try {
-      if (!window.fetch.__pagepocketOriginal && typeof __pagepocketOriginalFetch === "function") {
-        window.fetch.__pagepocketOriginal = __pagepocketOriginalFetch;
-      }
-    } catch {}
-    try {
-      if (!XMLHttpRequest.prototype.send.__pagepocketOriginal) {
-        XMLHttpRequest.prototype.send.__pagepocketOriginal = XMLHttpRequest.prototype.send;
-      }
-    } catch {}
-  };
-
-  let records = [];
-  const byKey = new Map();
-
-  let resourceIndex = null;
-  let embeddedByPath = new Map();
-  const blobUrlByPath = new Map();
-
-  const normalizeUrl = (input) => {
-    try { return new URL(input, baseUrl).toString(); } catch { return input; }
-  };
-
-  const normalizeBody = (body) => {
-    if (body === undefined || body === null) return "";
-    if (typeof body === "string") return body;
-    try { return String(body); } catch { return ""; }
-  };
-
-  const makeKey = (method, url, body) => method.toUpperCase() + " " + normalizeUrl(url) + " " + normalizeBody(body);
-  const makeVariantKeys = (method, url, body) => [makeKey(method, url, body)];
-
-  const matchAPI = ${matchAPISource};
-
-  const primeLookups = (snapshot) => {
-    records = snapshot.records || [];
-    byKey.clear();
-    for (const record of records) {
-      if (!record || !record.url || !record.method) continue;
-      const keys = makeVariantKeys(record.method, record.url, record.requestBody || record.requestBodyBase64 || "");
-      for (const key of keys) {
-        if (!byKey.has(key)) {
-          byKey.set(key, record);
-        }
-      }
-    }
-  };
-
-  const ready = (async () => {
-    const [apiSnapshot, resourcesPath] = await Promise.all([loadApiSnapshot(), loadResourcesPath()]);
-    resourceIndex = __pagepocketResourceProxy.buildIndex(resourcesPath || {});
-
-    embeddedByPath = new Map();
-    try {
-      const items = (resourcesPath && resourcesPath.items) || [];
-      for (const item of items) {
-        if (!item || !item.path || !item.data || item.dataEncoding !== "base64") {
-          continue;
-        }
-        embeddedByPath.set(item.path, item);
-      }
-    } catch {}
-
-    const snapshot = apiSnapshot || {};
-    primeLookups(snapshot);
-    return snapshot;
-  })();
-
-  const isLocalResource = (value) => {
-    if (!value) return false;
-    if (value.startsWith("data:") || value.startsWith("blob:")) return true;
-    // Protocol-relative URLs ("//host/path") are NOT local paths.
-    // Treat them as absolute URLs so they can be mapped via resources_path.json.
-    if (value.startsWith("//")) return false;
-    if (value.startsWith("/")) return true;
-    return false;
-  };
-
-  const findRecord = (method, url, body) => {
-    return matchAPI({ records, byKey, baseUrl, method, url, body });
-  };
-
-  const urlLookupCache = new Map();
-  const findByUrl = (url) => {
-    if (isLocalResource(url)) return null;
-    if (urlLookupCache.has(url)) {
-      return urlLookupCache.get(url);
-    }
-    const record = matchAPI({ records, byKey, baseUrl, method: "GET", url, body: "" });
-    urlLookupCache.set(url, record || null);
-    return record;
-  };
-
-  const findLocalPath = (url) => {
-    try {
-      if (!url || isLocalResource(String(url))) {
-        return null;
-      }
-      if (!resourceIndex) {
-        return null;
-      }
-
-      const resolvedPath = __pagepocketResourceProxy.resolveToLocalPath(String(url), baseUrl, resourceIndex);
-      if (!resolvedPath) {
-        return null;
-      }
-
-      const embedded = embeddedByPath && embeddedByPath.get(resolvedPath);
-      if (embedded && embedded.dataEncoding === "base64" && embedded.data) {
-        if (blobUrlByPath.has(resolvedPath)) {
-          return blobUrlByPath.get(resolvedPath);
-        }
-
-        const binary = atob(embedded.data);
-        const bytes = new Uint8Array(binary.length);
-        for (let i = 0; i < binary.length; i += 1) {
-          bytes[i] = binary.charCodeAt(i);
-        }
-
-        const mime = embedded.mimeType || "application/octet-stream";
-        const blob = new Blob([bytes], { type: mime });
-        const blobUrl = URL.createObjectURL(blob);
-        blobUrlByPath.set(resolvedPath, blobUrl);
-        return blobUrl;
-      }
-
-      return resolvedPath;
-    } catch {
-      return null;
-    }
-  };
-
-  /**
-   * Rewrite a resource URL to a snapshot-local URL.
-   *
-   * Strategy (in order):
-   * 1) If already local (data:/blob:/absolute path), keep as-is.
-   * 2) If resources_path.json can map it to a local file, return that path.
-   * 3) Otherwise, if we have a recorded body for the URL, return a data: URL
-   *    (used as a placeholder for some resource types).
-   * 4) Otherwise, keep the original URL.
-   */
-  const rewriteResourceUrl = (value, ctx) => {
-    try {
-      const raw = String(value || "");
-      if (!raw) {
-        return raw;
-      }
-
-      if (isLocalResource(raw)) {
-        return raw;
-      }
-
-      const localPath = findLocalPath(raw);
-      if (localPath) {
-        return localPath;
-      }
-
-      const fallbackType = ctx && ctx.fallbackType ? String(ctx.fallbackType) : undefined;
-      const record = findByUrl(raw);
-      if (record) {
-        const dataUrl = toDataUrl(record, fallbackType);
-        if (dataUrl) {
-          return dataUrl;
-        }
-      }
-
-      return raw;
-    } catch {
-      try {
-        return String(value || "");
-      } catch {
-        return value;
-      }
-    }
-  };
-
-  const defineProp = (obj, key, value) => {
-    try {
-      Object.defineProperty(obj, key, { value, configurable: true });
-    } catch {}
-  };
-
-  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();
-    }
-  };
-
-  const bytesToBase64 = (bytes) => {
-    const binary = Array.from(bytes, (value) => String.fromCharCode(value)).join("");
-    return btoa(binary);
-  };
-
-  const textToBase64 = (text) => {
-    try {
-      const bytes = new TextEncoder().encode(text || "");
-      return bytesToBase64(bytes);
-    } catch {
-      return btoa(text || "");
-    }
-  };
-
-  const getContentType = (record) => {
-    const headers = record.responseHeaders || {};
-    for (const key in headers) {
-      if (key.toLowerCase() === "content-type") {
-        return headers[key] || "application/octet-stream";
-      }
-    }
-    return "application/octet-stream";
-  };
-
-  const dataUrlCache = new Map();
-  const toDataUrl = (record, fallbackType) => {
-    if (!record) return "";
-    const contentType = getContentType(record) || fallbackType || "application/octet-stream";
-    const cacheKey = (record.url || "") + "|" + contentType + "|" + (record.responseEncoding || "") + "|" +
-      (record.responseBodyBase64 ? "b64:" + record.responseBodyBase64.length : "txt:" + (record.responseBody ? record.responseBody.length : 0));
-    if (dataUrlCache.has(cacheKey)) {
-      return dataUrlCache.get(cacheKey);
-    }
-    if (record.responseEncoding === "base64" && record.responseBodyBase64) {
-      const dataUrl = "data:" + contentType + ";base64," + record.responseBodyBase64;
-      dataUrlCache.set(cacheKey, dataUrl);
-      return dataUrl;
-    }
-    if (record.responseBody) {
-      const dataUrl = "data:" + contentType + ";base64," + textToBase64(record.responseBody);
-      dataUrlCache.set(cacheKey, dataUrl);
-      return dataUrl;
-    }
-    const dataUrl = "data:" + (fallbackType || "application/octet-stream") + ",";
-    dataUrlCache.set(cacheKey, dataUrl);
-    return dataUrl;
-  };
-
-  const responseFromRecord = (record) => {
-    const headers = new Headers(record.responseHeaders || {});
-    if (record.responseEncoding === "base64" && record.responseBodyBase64) {
-      const bytes = decodeBase64(record.responseBodyBase64);
-      return new Response(bytes, {
-        status: record.status || 200,
-        statusText: record.statusText || "OK",
-        headers
-      });
-    }
-    const bodyText = record.responseBody || "";
-    return new Response(bodyText, {
-      status: record.status || 200,
-      statusText: record.statusText || "OK",
-      headers
-    });
-  };
-
-${hackerScripts}
-})();
-</script>
-`;
+    return [
+        buildReplayInjectedScriptPart1({
+            basePayload,
+            apiPayload,
+            resourceProxyScript
+        }),
+        buildReplayInjectedScriptPart2({
+            matchAPISource
+        }),
+        buildReplayInjectedScriptPart3({
+            hackerScripts
+        })
+    ].join("");
 };

package/dist/replay/templates/replay-script-template.part-1.d.ts

@@ -0,0 +1,5 @@
+export declare const buildReplayInjectedScriptPart1: (options: {
+    basePayload: string;
+    apiPayload: string;
+    resourceProxyScript: string;
+}) => string;

package/dist/replay/templates/replay-script-template.part-1.js

@@ -0,0 +1,101 @@
+export const buildReplayInjectedScriptPart1 = (options) => {
+    const { basePayload, apiPayload, resourceProxyScript } = options;
+    return `
+<script>
+(function(){
+  const baseUrl = ${basePayload};
+  const apiUrl = ${apiPayload};
+  const resourcesPathUrl = "/resources_path.json";
+  const __pagepocketOriginalFetch = window.fetch ? window.fetch.bind(window) : null;
+
+${resourceProxyScript}
+
+  const loadResourcesPath = async () => {
+    try {
+      const injected = window && window.__pagepocketResourcesPath;
+      if (injected && injected.version === "1.0" && Array.isArray(injected.items)) {
+        return injected;
+      }
+
+      if (!__pagepocketOriginalFetch) {
+        throw new Error("Fetch is unavailable");
+      }
+      const response = await __pagepocketOriginalFetch(resourcesPathUrl);
+      if (!response.ok) {
+        throw new Error("Failed to load resources_path.json");
+      }
+      const json = await response.json();
+      if (!json || json.version !== "1.0" || !Array.isArray(json.items)) {
+        throw new Error("Invalid resources_path.json");
+      }
+      return json;
+    } catch {
+      return { version: "1.0", createdAt: 0, items: [] };
+    }
+  };
+
+  const loadApiSnapshot = async () => {
+    try {
+      const injected = window && window.__pagepocketApiSnapshot;
+      if (injected && injected.version === "1.0" && Array.isArray(injected.records)) {
+        return injected;
+      }
+
+      if (!__pagepocketOriginalFetch) {
+        throw new Error("Fetch is unavailable");
+      }
+      const response = await __pagepocketOriginalFetch(apiUrl);
+      if (!response.ok) {
+        throw new Error("Failed to load api.json");
+      }
+      return await response.json();
+    } catch {
+      return { version: "1.0", url: baseUrl, createdAt: 0, records: [] };
+    }
+  };
+
+  const originalResponseJson = Response && Response.prototype && Response.prototype.json;
+  if (originalResponseJson) {
+    Response.prototype.json = function(...args) {
+      try {
+        return originalResponseJson.apply(this, args).catch(() => null);
+      } catch {
+        return Promise.resolve(null);
+      }
+    };
+  }
+
+  const ensureReplayPatches = () => {
+    try {
+      if (!window.fetch.__pagepocketOriginal && typeof __pagepocketOriginalFetch === "function") {
+        window.fetch.__pagepocketOriginal = __pagepocketOriginalFetch;
+      }
+    } catch {}
+    try {
+      if (!XMLHttpRequest.prototype.send.__pagepocketOriginal) {
+        XMLHttpRequest.prototype.send.__pagepocketOriginal = XMLHttpRequest.prototype.send;
+      }
+    } catch {}
+  };
+
+  let records = [];
+  const byKey = new Map();
+
+  let resourceIndex = null;
+  let embeddedByPath = new Map();
+  const blobUrlByPath = new Map();
+
+  const normalizeUrl = (input) => {
+    try { return new URL(input, baseUrl).toString(); } catch { return input; }
+  };
+
+  const normalizeBody = (body) => {
+    if (body === undefined || body === null) return "";
+    if (typeof body === "string") return body;
+    try { return String(body); } catch { return ""; }
+  };
+
+  const makeKey = (method, url, body) => method.toUpperCase() + " " + normalizeUrl(url) + " " + normalizeBody(body);
+  const makeVariantKeys = (method, url, body) => [makeKey(method, url, body)];
+`;
+};

package/dist/replay/templates/replay-script-template.part-2.d.ts

@@ -0,0 +1,3 @@
+export declare const buildReplayInjectedScriptPart2: (options: {
+    matchAPISource: string;
+}) => string;