@pagepocket/lib 0.7.1 → 0.8.0

package/dist/replay-script.js

@@ -1,632 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildReplayScript = void 0;
-exports.matchAPI = matchAPI;
-const hackers_1 = require("./hackers");
-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) => {
+import { replayHackers } from "./hackers/index.js";
+import { matchAPI } from "./replay/match-api.js";
+import { buildReplayInjectedScript } from "./replay/templates/replay-script-template.js";
+export const buildReplayScript = (apiPath, baseUrl) => {
     const basePayload = JSON.stringify(baseUrl);
     const apiPayload = JSON.stringify(apiPath);
     const context = { stage: "replay" };
-    const hackerScripts = hackers_1.replayHackers
+    const hackerScripts = replayHackers
         .map((hacker) => `  // hacker:${hacker.id}\n${hacker.build(context)}`)
         .join("\n");
-    const resourceProxyScript = `
-  const __pagepocketResourceProxy = (() => {
-    const stripHash = (value) => {
-      const input = String(value || "");
-      const index = input.indexOf("#");
-      return index === -1 ? input : input.slice(0, index);
-    };
-
-    const stripTrailingSlash = (value) => {
-      const input = String(value || "");
-      if (!input || input === "/") return input;
-      return input.endsWith("/") ? input.slice(0, -1) : input;
-    };
-
-    const looksAlreadyEscapedForStaticServers = (value) => {
-      return /%25[0-9a-fA-F]{2}/.test(String(value || ""));
-    };
-
-    const escapePercentForStaticServersOnce = (value) => {
-      const input = String(value || "");
-      if (!input) return input;
-      if (looksAlreadyEscapedForStaticServers(input)) return input;
-      return input.split("%").join("%25");
-    };
-
-    const isLikelyHostname = (value) => {
-      const input = String(value || "");
-      if (!input) return false;
-      if (input === "localhost") return true;
-      return input.includes(".");
-    };
-
-    const encodeEmbeddedUrlTailIfPresent = (pathname) => {
-      const raw = String(pathname || "");
-      if (!raw.includes("/http")) return null;
-      const parts = raw.split("/");
-      for (let i = 0; i < parts.length; i += 1) {
-        const scheme = parts[i];
-        if (scheme !== "http:" && scheme !== "https:") continue;
-        const hasDoubleSlash = parts[i + 1] === "";
-        const host = parts[i + 2] || "";
-        if (!hasDoubleSlash || !isLikelyHostname(host)) continue;
-        const embedded = scheme + "//" + parts.slice(i + 2).join("/");
-        const encoded = encodeURIComponent(embedded);
-        const nextParts = parts.slice(0, i).concat(encoded);
-        const rebuilt = nextParts.join("/") || "/";
-        return rebuilt.startsWith("/") ? rebuilt : "/" + rebuilt;
-      }
-      return null;
-    };
-
-    const makePathnameVariants = (pathname) => {
-      const variants = new Set();
-      const push = (value) => {
-        if (!value) return;
-        variants.add(value);
-      };
-
-      const raw = String(pathname || "");
-      push(raw);
-      push(stripTrailingSlash(raw));
-
-      const encodedTail = encodeEmbeddedUrlTailIfPresent(raw);
-      if (encodedTail && encodedTail !== raw) {
-        push(encodedTail);
-        push(stripTrailingSlash(encodedTail));
-      }
-
-      return Array.from(variants);
-    };
-
-    const toUrlOrNull = (value, base) => {
-      try {
-        return new URL(String(value || ""), String(base || ""));
-      } catch {
-        return null;
-      }
-    };
-
-    const getBasename = (pathname) => {
-      const clean = String(pathname || "").split("?")[0] || "";
-      const parts = clean.split("/").filter(Boolean);
-      return parts[parts.length - 1] || "";
-    };
-
-    const makeSuffixes = (pathname) => {
-      const parts = String(pathname || "").split("/").filter(Boolean);
-      const out = [];
-      for (let i = 0; i < parts.length; i += 1) {
-        out.push({ key: "/" + parts.slice(i).join("/"), depth: parts.length - i });
-      }
-      return out;
-    };
-
-    const toArray = (value) => {
-      if (!value) return [];
-      return Array.isArray(value) ? value : [value];
-    };
-
-    const addMulti = (map, key, value) => {
-      const existing = map.get(key);
-      if (!existing) {
-        map.set(key, value);
-        return;
-      }
-      if (Array.isArray(existing)) {
-        existing.push(value);
-        return;
-      }
-      map.set(key, [existing, value]);
-    };
-
-    const uniqByPath = (items) => {
-      const seen = new Set();
-      const out = [];
-      for (const item of items || []) {
-        const p = item && item.path;
-        if (!p || seen.has(p)) continue;
-        seen.add(p);
-        out.push(item);
-      }
-      return out;
-    };
-
-    const chooseUnique = (items, baseUrl, depth) => {
-      const unique = uniqByPath(items);
-      if (unique.length === 0) return null;
-      if (unique.length === 1) return unique[0];
-
-      try {
-        const base = new URL(String(baseUrl || ""));
-        const sameOrigin = unique.filter((i) => i && i.origin === base.origin);
-        if (sameOrigin.length === 1) {
-          return sameOrigin[0];
-        }
-        if (sameOrigin.length > 1) {
-          items = sameOrigin;
-        }
-      } catch {}
-
-      if (depth < 2) {
-        return null;
-      }
-
-      return null;
-    };
-
-    const buildIndex = (snapshot) => {
-      const byExactUrl = new Map();
-      const byPathnameWithSearch = new Map();
-      const byPathname = new Map();
-      const byBasename = new Map();
-
-      for (const item of (snapshot && snapshot.items) || []) {
-        if (!item || !item.url || !item.path) continue;
-        let parsed = null;
-        try {
-          parsed = new URL(item.url);
-        } catch {
-          parsed = null;
-        }
-        if (!parsed) continue;
-
-        const pathname = parsed.pathname || "/";
-        const pathnameWithSearch = pathname + (parsed.search || "");
-        const basename = getBasename(pathname);
-
-        const indexed = {
-          url: parsed.toString(),
-          origin: parsed.origin,
-          pathname,
-          pathnameWithSearch,
-          basename,
-          path: item.path,
-          resourceType: item.resourceType,
-          mimeType: item.mimeType,
-          size: item.size
-        };
-
-        if (!byExactUrl.has(indexed.url)) {
-          byExactUrl.set(indexed.url, indexed);
-        }
-        addMulti(byPathnameWithSearch, pathnameWithSearch, indexed);
-        addMulti(byPathname, pathname, indexed);
-        if (basename) {
-          addMulti(byBasename, basename, indexed);
-        }
-      }
-
-      return { byExactUrl, byPathnameWithSearch, byPathname, byBasename };
-    };
-
-    const resolveToLocalPath = (requestUrl, baseUrl, index) => {
-      if (!requestUrl) return null;
-      const abs = toUrlOrNull(String(requestUrl), baseUrl);
-      if (!abs) return null;
-
-      const absString = abs.toString();
-      const exact = index && index.byExactUrl && index.byExactUrl.get(absString);
-      if (exact) return escapePercentForStaticServersOnce(exact.path);
-
-      const withoutHash = stripHash(absString);
-      if (withoutHash !== absString) {
-        const found = index.byExactUrl.get(withoutHash);
-        if (found) return escapePercentForStaticServersOnce(found.path);
-      }
-
-      const pathname = abs.pathname || "/";
-      const pathnameVariants = makePathnameVariants(pathname);
-      const search = abs.search || "";
-      const pathnameWithSearchVariants = pathnameVariants.map((p) => String(p) + search);
-
-      for (const key of pathnameWithSearchVariants) {
-        const items = toArray(index.byPathnameWithSearch.get(key));
-        const chosen = chooseUnique(items, baseUrl, 99);
-        if (chosen) return escapePercentForStaticServersOnce(chosen.path);
-      }
-
-      for (const key of pathnameVariants) {
-        const items = toArray(index.byPathname.get(key));
-        const chosen = chooseUnique(items, baseUrl, 99);
-        if (chosen) return escapePercentForStaticServersOnce(chosen.path);
-      }
-
-      for (const variant of pathnameVariants) {
-        for (const suffix of makeSuffixes(variant)) {
-          const items = toArray(index.byPathname.get(suffix.key));
-          const chosen = chooseUnique(items, baseUrl, suffix.depth);
-          if (chosen) return escapePercentForStaticServersOnce(chosen.path);
-        }
-      }
-
-      const basename = getBasename(pathname);
-      if (basename) {
-        const items = toArray(index.byBasename.get(basename));
-        const chosen = chooseUnique(items, baseUrl, 1);
-        if (chosen) return escapePercentForStaticServersOnce(chosen.path);
-      }
-
-      return null;
-    };
-
-    return { buildIndex, resolveToLocalPath };
-  })();
-  `;
-    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 {
-      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 {
-      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;
-
-  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 = ${matchAPI.toString()};
-
-  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 || {});
-
-    const snapshot = apiSnapshot || {};
-    primeLookups(snapshot);
-    return snapshot;
-  })();
-
-  const isLocalResource = (value) => {
-    if (!value) return false;
-    if (value.startsWith("data:") || value.startsWith("blob:")) return true;
-    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;
-      }
-      return __pagepocketResourceProxy.resolveToLocalPath(String(url), baseUrl, resourceIndex);
-    } catch {
-      return null;
-    }
-  };
-
-  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
+    return buildReplayInjectedScript({
+        basePayload,
+        apiPayload,
+        hackerScripts
     });
-  };
-
-${hackerScripts}
-})();
-</script>
-`;
 };
-exports.buildReplayScript = buildReplayScript;
+// Exported for unit tests; runtime replay uses injected matchAPISource.
+export { matchAPI };

package/dist/resource-filter.d.ts

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

package/dist/resource-filter.js

@@ -1,13 +1,10 @@
-"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 = () => ({
+export const createDefaultResourceFilter = () => ({
     shouldSave(req, res) {
         if (isSkippableUrl(req.url)) {
             return false;
@@ -24,4 +21,3 @@ const createDefaultResourceFilter = () => ({
         return true;
     }
 });
-exports.createDefaultResourceFilter = createDefaultResourceFilter;

package/dist/resource-proxy/escape-percent.d.ts

@@ -0,0 +1 @@
+export declare const escapePercentForStaticServersOnce: (value: string) => string;

package/dist/resource-proxy/escape-percent.js

@@ -0,0 +1,12 @@
+const looksAlreadyEscapedForStaticServers = (value) => {
+    return /%25[0-9a-fA-F]{2}/.test(value);
+};
+export const escapePercentForStaticServersOnce = (value) => {
+    if (!value) {
+        return value;
+    }
+    if (looksAlreadyEscapedForStaticServers(value)) {
+        return value;
+    }
+    return value.split("%").join("%25");
+};

package/dist/resource-proxy/multimap.d.ts

@@ -0,0 +1,3 @@
+export type MultiMap<K, V> = Map<K, V | V[]>;
+export declare const addMulti: <K, V>(map: MultiMap<K, V>, key: K, value: V) => void;
+export declare const toArray: <T>(value: T | T[] | undefined) => T[];