@pagepocket/lib 0.6.3 → 0.7.0

package/dist/replace-elements.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyReplaceElements = void 0;
+const defaultApply = {
+    scope: "document",
+    limit: "all",
+    onReplaced: "stop"
+};
+const isPlainObject = (value) => typeof value === "object" && value !== null;
+const normalizeApply = (apply) => ({
+    scope: apply?.scope ?? defaultApply.scope,
+    limit: apply?.limit ?? defaultApply.limit,
+    onReplaced: apply?.onReplaced ?? defaultApply.onReplaced
+});
+const normalizeMatchToSelector = (match) => {
+    if (typeof match === "string") {
+        return { selector: match, filter: null };
+    }
+    return { selector: match.selector ?? "*", filter: match };
+};
+const getNodeName = (el) => {
+    if (!el || typeof el !== "object")
+        return null;
+    const name = el.name;
+    return typeof name === "string" ? name : null;
+};
+const getNodeType = (el) => {
+    if (!el || typeof el !== "object")
+        return null;
+    const type = el.type;
+    return typeof type === "string" ? type : null;
+};
+const tagNameMatches = (el, expected) => {
+    if (!expected)
+        return true;
+    const name = getNodeName(el);
+    if (!name)
+        return false;
+    return name.toLowerCase() === expected.toLowerCase();
+};
+const idMatches = (_$, $el, expected) => {
+    if (!expected)
+        return true;
+    return ($el.attr("id") || "") === expected;
+};
+const attrsMatch = ($el, attrs) => {
+    if (!attrs)
+        return true;
+    for (const [name, expected] of Object.entries(attrs)) {
+        const actual = $el.attr(name);
+        if (expected === true) {
+            if (actual === undefined)
+                return false;
+            continue;
+        }
+        if (typeof expected === "string") {
+            if (actual !== expected)
+                return false;
+            continue;
+        }
+        if (expected instanceof RegExp) {
+            if (actual === undefined)
+                return false;
+            if (!expected.test(actual))
+                return false;
+            continue;
+        }
+    }
+    return true;
+};
+const elementMatchesFilter = ($, $el, filter) => {
+    if (!filter || typeof filter === "string")
+        return true;
+    const el = $el.get(0);
+    if (!el)
+        return false;
+    if (!tagNameMatches(el, filter.tagName))
+        return false;
+    if (!idMatches($, $el, filter.id))
+        return false;
+    if (!attrsMatch($el, filter.attrs))
+        return false;
+    return true;
+};
+const isHtmlElement = ($, $el) => {
+    if (!$el || !$el.length)
+        return false;
+    if (!$el.closest("html").length)
+        return false;
+    const el = $el.get(0);
+    if (!el)
+        return false;
+    // Cheerio nodes for tags have a "type" of "tag".
+    const type = getNodeType(el);
+    if (type && type !== "tag")
+        return false;
+    return true;
+};
+const applyReplaceAction = ($, $el, action) => {
+    switch (action.type) {
+        case "replaceWithHtml": {
+            $el.replaceWith(action.html);
+            return;
+        }
+        case "replaceWithElement": {
+            const next = $(`<${action.tagName}></${action.tagName}>`);
+            if (action.attrs) {
+                for (const [key, value] of Object.entries(action.attrs)) {
+                    if (value === null) {
+                        next.removeAttr(key);
+                        continue;
+                    }
+                    next.attr(key, value);
+                }
+            }
+            if (action.html !== undefined) {
+                next.html(action.html);
+            }
+            else if (action.textContent !== undefined) {
+                next.text(action.textContent);
+            }
+            $el.replaceWith(next);
+            return;
+        }
+        case "renameTag": {
+            const to = action.to;
+            const keepAttributes = action.keepAttributes !== false;
+            const keepChildren = action.keepChildren !== false;
+            const next = $(`<${to}></${to}>`);
+            if (keepAttributes) {
+                const attrs = ($el.attr() ?? {});
+                for (const [key, value] of Object.entries(attrs)) {
+                    next.attr(key, value);
+                }
+            }
+            if (keepChildren) {
+                next.append($el.contents());
+            }
+            $el.replaceWith(next);
+            return;
+        }
+        case "remove": {
+            $el.remove();
+            return;
+        }
+        default: {
+            const exhaustive = action;
+            throw new Error(`Unknown replace action: ${String(exhaustive?.type ?? "")}`);
+        }
+    }
+};
+const normalizeReplaceElementsConfig = (replaceElements) => {
+    const items = [];
+    replaceElements.forEach((item, ruleIndex) => {
+        if (typeof item === "function") {
+            items.push({
+                kind: "fn",
+                ruleIndex,
+                query: "*",
+                run: item,
+                apply: normalizeApply(undefined)
+            });
+            return;
+        }
+        if (!isPlainObject(item)) {
+            throw new Error("replaceElements item must be a rule object or function");
+        }
+        if ("run" in item && typeof item.run === "function") {
+            const fnItem = item;
+            items.push({
+                kind: "fn",
+                ruleIndex,
+                query: fnItem.query,
+                run: fnItem.run,
+                apply: normalizeApply(fnItem.apply)
+            });
+            return;
+        }
+        const rule = item;
+        items.push({ kind: "rule", ruleIndex, rule, apply: normalizeApply(rule.apply) });
+    });
+    return items;
+};
+const runFnRuleOnSelection = async (input) => {
+    const { $, item } = input;
+    const selection = $(item.query).toArray();
+    const limit = item.apply.limit;
+    const max = limit === "all" ? selection.length : Math.max(0, limit);
+    for (let i = 0; i < selection.length && i < max; i += 1) {
+        const el = selection[i];
+        const $el = $(el);
+        if (!isHtmlElement($, $el)) {
+            continue;
+        }
+        const ctx = {
+            $,
+            $el,
+            url: input.url,
+            entryUrl: input.entryUrl,
+            ruleIndex: item.ruleIndex,
+            matchIndex: i
+        };
+        const result = await item.run(ctx);
+        if (!result) {
+            continue;
+        }
+        const actions = Array.isArray(result) ? result : [result];
+        for (const action of actions) {
+            applyReplaceAction($, $el, action);
+        }
+    }
+};
+const applyReplaceElements = async (input) => {
+    if (!input.replaceElements || input.replaceElements.length === 0) {
+        return;
+    }
+    const items = normalizeReplaceElementsConfig(input.replaceElements);
+    const active = items.filter((it) => it.apply.scope === "allFrames" || input.isEntryDocument);
+    const replacedByIndex = new WeakSet();
+    for (const item of active) {
+        if (item.kind === "fn") {
+            // Function rule uses its own query to select targets.
+            // Note: "onReplaced" semantics are best-effort for function rules.
+            await runFnRuleOnSelection({
+                $: input.$,
+                entryUrl: input.entryUrl,
+                url: input.url,
+                item
+            });
+            continue;
+        }
+        // Object rules: we can respect onReplaced by skipping elements already replaced.
+        const { selector, filter } = normalizeMatchToSelector(item.rule.match);
+        const selection = input.$(selector).toArray();
+        const limit = item.apply.limit;
+        const max = limit === "all" ? selection.length : Math.max(0, limit);
+        let replacedCount = 0;
+        for (let i = 0; i < selection.length && replacedCount < max; i += 1) {
+            const el = selection[i];
+            if (item.apply.onReplaced === "stop" && replacedByIndex.has(el)) {
+                continue;
+            }
+            const $el = input.$(selection[i]);
+            if (!isHtmlElement(input.$, $el)) {
+                continue;
+            }
+            if (!elementMatchesFilter(input.$, $el, filter)) {
+                continue;
+            }
+            applyReplaceAction(input.$, $el, item.rule.replace);
+            replacedCount += 1;
+            if (item.apply.onReplaced === "stop") {
+                replacedByIndex.add(el);
+            }
+        }
+    }
+};
+exports.applyReplaceElements = applyReplaceElements;

package/dist/replay-script.js

@@ -147,13 +147,280 @@ const buildReplayScript = (apiPath, baseUrl) => {
     const hackerScripts = hackers_1.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) {
@@ -196,6 +463,8 @@ const buildReplayScript = (apiPath, baseUrl) => {
   let records = [];
   const byKey = new Map();
 
+  let resourceIndex = null;
+
   const normalizeUrl = (input) => {
     try { return new URL(input, baseUrl).toString(); } catch { return input; }
   };
@@ -226,7 +495,10 @@ const buildReplayScript = (apiPath, baseUrl) => {
   };
 
   const ready = (async () => {
-    const snapshot = (await loadApiSnapshot()) || {};
+    const [apiSnapshot, resourcesPath] = await Promise.all([loadApiSnapshot(), loadResourcesPath()]);
+    resourceIndex = __pagepocketResourceProxy.buildIndex(resourcesPath || {});
+
+    const snapshot = apiSnapshot || {};
     primeLookups(snapshot);
     return snapshot;
   })();
@@ -253,7 +525,19 @@ const buildReplayScript = (apiPath, baseUrl) => {
     return record;
   };
 
-  const findLocalPath = () => null;
+  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 {

package/dist/resource-proxy.d.ts

@@ -0,0 +1,34 @@
+import type { ResourceType } from "./types";
+export type ResourcesPathSnapshotItem = {
+    url: string;
+    path: string;
+    resourceType?: ResourceType;
+    mimeType?: string;
+    size?: number;
+};
+export type ResourcesPathSnapshot = {
+    version: "1.0";
+    createdAt: number;
+    items: ResourcesPathSnapshotItem[];
+};
+type IndexedItem = ResourcesPathSnapshotItem & {
+    parsed: URL;
+    pathname: string;
+    pathnameWithSearch: string;
+    basename: string;
+};
+type MultiMap<K, V> = Map<K, V | V[]>;
+export type ResourceProxyIndex = {
+    byExactUrl: Map<string, IndexedItem>;
+    byPathnameWithSearch: MultiMap<string, IndexedItem>;
+    byPathname: MultiMap<string, IndexedItem>;
+    byBasename: MultiMap<string, IndexedItem>;
+};
+export declare const buildResourceProxyIndex: (snapshot: ResourcesPathSnapshot) => ResourceProxyIndex;
+type ResolveOptions = {
+    requestUrl: string;
+    baseUrl: string;
+    index: ResourceProxyIndex;
+};
+export declare const resolveToLocalPath: (options: ResolveOptions) => string | undefined;
+export {};