@pagepocket/lib 0.7.1 → 0.8.0

package/dist/replay/templates/resource-proxy-script.js

@@ -0,0 +1,274 @@
+export 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 byCanonicalUrl = new Map();
+      const byPathnameWithSearch = new Map();
+      const byPathname = new Map();
+      const byBasename = new Map();
+
+      const canonicalizeHttpUrlForIndex = (url) => {
+        try {
+          if (!url || !url.protocol) return String(url || "");
+          if (url.protocol === "http:" || url.protocol === "https:") {
+            return "//" + url.host + (url.pathname || "") + (url.search || "");
+          }
+          return url.toString();
+        } catch {
+          return String(url || "");
+        }
+      };
+
+      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(),
+          canonicalUrl: canonicalizeHttpUrlForIndex(parsed),
+          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);
+        }
+
+        if (!byCanonicalUrl.has(indexed.canonicalUrl)) {
+          byCanonicalUrl.set(indexed.canonicalUrl, indexed);
+        }
+        addMulti(byPathnameWithSearch, pathnameWithSearch, indexed);
+        addMulti(byPathname, pathname, indexed);
+        if (basename) {
+          addMulti(byBasename, basename, indexed);
+        }
+      }
+
+      return { byExactUrl, byCanonicalUrl, 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 canonicalAbs = "//" + abs.host + (abs.pathname || "") + (abs.search || "");
+      const canonicalExact = index && index.byCanonicalUrl && index.byCanonicalUrl.get(canonicalAbs);
+      if (canonicalExact) return escapePercentForStaticServersOnce(canonicalExact.path);
+
+      const withoutHash = stripHash(absString);
+      if (withoutHash !== absString) {
+        const found = index.byExactUrl.get(withoutHash);
+        if (found) return escapePercentForStaticServersOnce(found.path);
+
+        try {
+          const w = new URL(withoutHash);
+          const canonicalWithoutHash = "//" + w.host + (w.pathname || "") + (w.search || "");
+          const canonicalFound = index && index.byCanonicalUrl && index.byCanonicalUrl.get(canonicalWithoutHash);
+          if (canonicalFound) return escapePercentForStaticServersOnce(canonicalFound.path);
+        } catch {}
+      }
+
+      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 };
+  })();
+`;

package/dist/replay-script.d.ts

@@ -1,11 +1,4 @@
-import type { ApiRecord } from "./types";
-export type MatchApiOptions = {
-    records: ApiRecord[];
-    byKey?: Map<string, ApiRecord>;
-    baseUrl: string;
-    method: string;
-    url: string;
-    body?: unknown;
-};
-export declare function matchAPI(options: MatchApiOptions): ApiRecord | undefined;
+import { matchAPI, type MatchApiOptions } from "./replay/match-api.js";
 export declare const buildReplayScript: (apiPath: string, baseUrl: string) => string;
+export { matchAPI };
+export type { MatchApiOptions };