@pagepocket/lib 0.4.2 → 0.5.0

package/dist/rewrite-links.js

@@ -33,11 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rewriteLinks = void 0;
+exports.rewriteEntryHtml = exports.rewriteJsText = void 0;
+const cheerio = __importStar(require("cheerio"));
 const css_rewrite_1 = require("./css-rewrite");
-const network_records_1 = require("./network-records");
-const resources_1 = require("./resources");
-const shouldSkipValue = (value, assetsDirName) => {
+const hack_html_1 = require("./hack-html");
+const shouldSkipValue = (value) => {
     const trimmed = value.trim();
     return (!trimmed ||
         trimmed.startsWith("data:") ||
@@ -45,219 +45,207 @@ const shouldSkipValue = (value, assetsDirName) => {
         trimmed.startsWith("mailto:") ||
         trimmed.startsWith("tel:") ||
         trimmed.startsWith("javascript:") ||
-        trimmed.startsWith("#") ||
-        trimmed.includes(assetsDirName));
+        trimmed.startsWith("#"));
 };
-const buildLinkBase = (baseUrl) => {
+const resolveUrlValue = (value, baseUrl, resolve) => {
+    if (shouldSkipValue(value)) {
+        return null;
+    }
     try {
-        const parsed = new URL(baseUrl);
-        const baseOrigin = parsed.origin;
-        const baseDir = new URL(".", parsed).toString().replace(/\/$/, "");
-        return { baseOrigin, baseDir };
+        const absolute = new URL(value, baseUrl).toString();
+        return resolve(absolute);
     }
     catch {
-        return { baseOrigin: "", baseDir: "" };
+        return null;
     }
 };
-const expandUrlVariants = (value, baseUrl, baseOrigin, baseDir) => {
-    const variants = [];
-    if (typeof value === "string") {
-        variants.push(value);
-        try {
-            variants.push(new URL(value, baseUrl).toString());
-        }
-        catch {
-            // ignore
-        }
-        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 {
-            // ignore
-        }
-    }
-    return Array.from(new Set(variants.filter(Boolean)));
+const rewriteSrcsetValue = (value, baseUrl, resolve) => {
+    const parts = value.split(",").map((part) => part.trim());
+    const rewritten = parts.map((part) => {
+        const [rawUrl, descriptor] = part.split(/\s+/, 2);
+        if (!rawUrl)
+            return part;
+        const resolved = resolveUrlValue(rawUrl, baseUrl, resolve);
+        if (!resolved)
+            return part;
+        return descriptor ? `${resolved} ${descriptor}` : resolved;
+    });
+    return rewritten.join(", ");
 };
-const buildNetworkLookup = (records) => {
-    const networkRecordByUrl = new Map();
-    for (const record of records) {
-        if (record?.url && !networkRecordByUrl.has(record.url)) {
-            networkRecordByUrl.set(record.url, record);
-        }
+const rewriteMetaRefresh = (content, baseUrl, resolve) => {
+    const parts = content.split(";");
+    if (parts.length < 2)
+        return content;
+    const urlPartIndex = parts.findIndex((part) => part.trim().toLowerCase().startsWith("url="));
+    if (urlPartIndex === -1)
+        return content;
+    const urlPart = parts[urlPartIndex];
+    const rawUrl = urlPart.split("=").slice(1).join("=").trim();
+    const resolved = resolveUrlValue(rawUrl, baseUrl, resolve);
+    if (!resolved)
+        return content;
+    const next = `url=${resolved}`;
+    const nextParts = parts.slice();
+    nextParts[urlPartIndex] = next;
+    return nextParts.join(";");
+};
+const rewriteJsText = async (source, resolve, baseUrl) => {
+    const replaceSpecifier = async (specifier) => {
+        const trimmed = specifier.trim();
+        if (shouldSkipValue(trimmed)) {
+            return specifier;
+        }
+        const resolved = resolveUrlValue(trimmed, baseUrl, resolve);
+        return resolved ?? specifier;
+    };
+    const importFromPattern = /(\bimport\s+[^'"]*?\sfrom\s+)(["'])([^"']+)\2/g;
+    const importSideEffectPattern = /(\bimport\s+)(["'])([^"']+)\2/g;
+    const dynamicImportPattern = /(\bimport\s*\(\s*)(["'])([^"']+)\2(\s*\))/g;
+    let replaced = "";
+    let lastIndex = 0;
+    for (const match of source.matchAll(importFromPattern)) {
+        const index = match.index ?? 0;
+        replaced += source.slice(lastIndex, index);
+        const prefix = match[1] || "";
+        const quote = match[2] || "";
+        const specifier = match[3] || "";
+        const next = await replaceSpecifier(specifier);
+        replaced += `${prefix}${quote}${next}${quote}`;
+        lastIndex = index + match[0].length;
+    }
+    replaced += source.slice(lastIndex);
+    let final = "";
+    lastIndex = 0;
+    for (const match of replaced.matchAll(importSideEffectPattern)) {
+        const index = match.index ?? 0;
+        final += replaced.slice(lastIndex, index);
+        const prefix = match[1] || "";
+        const quote = match[2] || "";
+        const specifier = match[3] || "";
+        const next = await replaceSpecifier(specifier);
+        final += `${prefix}${quote}${next}${quote}`;
+        lastIndex = index + match[0].length;
     }
-    return networkRecordByUrl;
+    final += replaced.slice(lastIndex);
+    let dynamicFinal = "";
+    lastIndex = 0;
+    for (const match of final.matchAll(dynamicImportPattern)) {
+        const index = match.index ?? 0;
+        dynamicFinal += final.slice(lastIndex, index);
+        const prefix = match[1] || "";
+        const quote = match[2] || "";
+        const specifier = match[3] || "";
+        const suffix = match[4] || "";
+        const next = await replaceSpecifier(specifier);
+        dynamicFinal += `${prefix}${quote}${next}${quote}${suffix}`;
+        lastIndex = index + match[0].length;
+    }
+    dynamicFinal += final.slice(lastIndex);
+    return dynamicFinal;
 };
-const rewriteLinks = async (input) => {
-    const { readAsURL } = await Promise.resolve().then(() => __importStar(require("@pagepocket/uni-fs")));
-    const networkRecordByUrl = buildNetworkLookup(input.networkRecords);
-    const { baseOrigin, baseDir } = buildLinkBase(input.baseUrl);
-    const localUrlCache = new Map();
-    const resolveLocalUrl = async (value) => {
-        if (shouldSkipValue(value, input.assetsDirName)) {
-            return null;
-        }
-        const variants = expandUrlVariants(value, input.baseUrl, baseOrigin, baseDir);
-        for (const variant of variants) {
-            const resource = input.resourceMap.get(variant);
-            if (!resource) {
-                continue;
-            }
-            const cacheKey = resource.extension
-                ? `${resource.filename}.${resource.extension}`
-                : resource.filename;
-            if (localUrlCache.has(cacheKey)) {
-                return localUrlCache.get(cacheKey) ?? null;
-            }
-            const localUrl = await readAsURL(`${input.assetsDirName}/${resource.filename}`, resource.extension);
-            localUrlCache.set(cacheKey, localUrl);
-            return localUrl;
-        }
-        for (const variant of variants) {
-            const record = networkRecordByUrl.get(variant);
-            if (record) {
-                return (0, network_records_1.toDataUrlFromRecord)(record);
-            }
-        }
-        for (const variant of variants) {
-            try {
-                const parsed = new URL(variant);
-                const withoutQuery = parsed.origin + parsed.pathname;
-                const record = networkRecordByUrl.get(withoutQuery);
-                if (record) {
-                    return (0, network_records_1.toDataUrlFromRecord)(record);
-                }
+exports.rewriteJsText = rewriteJsText;
+const rewriteEntryHtml = async (input) => {
+    const $ = cheerio.load(input.html);
+    const baseUrl = input.entryUrl;
+    const resolve = input.resolve;
+    const shouldRewriteLinks = input.rewriteLinks !== false;
+    const rewriteAttr = (selector, attr) => {
+        $(selector).each((_, element) => {
+            const value = $(element).attr(attr);
+            if (!value)
+                return;
+            const resolved = resolveUrlValue(value, baseUrl, resolve);
+            if (resolved) {
+                $(element).attr(attr, resolved);
             }
-            catch {
-                // ignore
-            }
-        }
-        return null;
+        });
     };
-    for (const resource of input.resourceUrls) {
-        const rawValue = input.$(resource.element).attr(resource.attr);
-        if (!rawValue) {
-            continue;
-        }
-        const nextUrl = await resolveLocalUrl(rawValue);
-        if (nextUrl) {
-            input.$(resource.element).attr(resource.attr, nextUrl);
-        }
+    const rewriteDataAttrs = (selector, attr) => rewriteAttr(selector, attr);
+    if (shouldRewriteLinks) {
+        rewriteAttr("script[src]", "src");
+        rewriteAttr("img[src]", "src");
+        rewriteAttr("source[src]", "src");
+        rewriteAttr("video[src]", "src");
+        rewriteAttr("audio[src]", "src");
+        rewriteAttr("track[src]", "src");
+        rewriteAttr("iframe[src]", "src");
+        rewriteAttr("embed[src]", "src");
+        rewriteAttr("object[data]", "data");
+        rewriteAttr("link[href]", "href");
+        rewriteAttr("[poster]", "poster");
+        rewriteDataAttrs("[data-src]", "data-src");
+        rewriteDataAttrs("[data-href]", "data-href");
+        rewriteDataAttrs("[data-poster]", "data-poster");
+        rewriteDataAttrs("[data-url]", "data-url");
+        $("img[srcset], source[srcset]").each((_, element) => {
+            const value = $(element).attr("srcset");
+            if (!value)
+                return;
+            const rewritten = rewriteSrcsetValue(value, baseUrl, resolve);
+            $(element).attr("srcset", rewritten);
+        });
+        $("meta[http-equiv]").each((_, element) => {
+            const httpEquiv = ($(element).attr("http-equiv") || "").toLowerCase();
+            if (httpEquiv !== "refresh")
+                return;
+            const content = $(element).attr("content");
+            if (!content)
+                return;
+            const rewritten = rewriteMetaRefresh(content, baseUrl, resolve);
+            $(element).attr("content", rewritten);
+        });
     }
-    for (const item of input.srcsetItems) {
-        const parts = item.value.split(",").map((part) => part.trim());
-        const rewrittenParts = [];
-        for (const part of parts) {
-            const [rawUrl, descriptor] = part.split(/\s+/, 2);
-            if (!rawUrl) {
-                rewrittenParts.push(part);
+    if (shouldRewriteLinks) {
+        const inlineStyles = $("style").toArray();
+        for (const element of inlineStyles) {
+            const cssText = $(element).html();
+            if (!cssText)
                 continue;
+            const rewritten = await (0, css_rewrite_1.rewriteCssText)({
+                cssText,
+                cssUrl: baseUrl,
+                resolveUrl: resolve
+            });
+            if (rewritten !== cssText) {
+                $(element).html(rewritten);
             }
-            const nextUrl = await resolveLocalUrl(rawUrl);
-            if (!nextUrl) {
-                rewrittenParts.push(part);
+        }
+        const inlineStyleElements = $("[style]").toArray();
+        for (const element of inlineStyleElements) {
+            const styleText = $(element).attr("style");
+            if (!styleText)
                 continue;
+            const rewritten = await (0, css_rewrite_1.rewriteCssText)({
+                cssText: styleText,
+                cssUrl: baseUrl,
+                resolveUrl: resolve
+            });
+            if (rewritten !== styleText) {
+                $(element).attr("style", rewritten);
             }
-            rewrittenParts.push(descriptor ? `${nextUrl} ${descriptor}` : nextUrl);
         }
-        input.$(item.element).attr("srcset", rewrittenParts.join(", "));
     }
-    const rewriteModuleImports = async (source) => {
-        const replaceSpecifier = async (specifier) => {
-            const trimmed = specifier.trim();
-            if (shouldSkipValue(trimmed, input.assetsDirName)) {
-                return specifier;
-            }
-            const next = await resolveLocalUrl(trimmed);
-            return next ?? specifier;
-        };
-        const importFromPattern = /(\bimport\s+[^'"]*?\sfrom\s+)(["'])([^"']+)\2/g;
-        const importSideEffectPattern = /(\bimport\s+)(["'])([^"']+)\2/g;
-        let replaced = "";
-        let lastIndex = 0;
-        for (const match of source.matchAll(importFromPattern)) {
-            const index = match.index ?? 0;
-            replaced += source.slice(lastIndex, index);
-            const prefix = match[1] || "";
-            const quote = match[2] || "";
-            const specifier = match[3] || "";
-            const next = await replaceSpecifier(specifier);
-            replaced += `${prefix}${quote}${next}${quote}`;
-            lastIndex = index + match[0].length;
-        }
-        replaced += source.slice(lastIndex);
-        let final = "";
-        lastIndex = 0;
-        for (const match of replaced.matchAll(importSideEffectPattern)) {
-            const index = match.index ?? 0;
-            final += replaced.slice(lastIndex, index);
-            const prefix = match[1] || "";
-            const quote = match[2] || "";
-            const specifier = match[3] || "";
-            const next = await replaceSpecifier(specifier);
-            final += `${prefix}${quote}${next}${quote}`;
-            lastIndex = index + match[0].length;
-        }
-        final += replaced.slice(lastIndex);
-        return final;
-    };
-    const rewritePromises = [];
-    const moduleScripts = input.$('script[type="module"]').toArray();
-    for (const element of moduleScripts) {
-        const src = input.$(element).attr("src");
-        if (src) {
-            continue;
-        }
-        const original = input.$(element).html();
-        if (!original) {
-            continue;
-        }
-        rewritePromises.push(rewriteModuleImports(original).then((rewritten) => {
+    if (shouldRewriteLinks) {
+        const moduleScripts = $('script[type="module"]').toArray();
+        for (const element of moduleScripts) {
+            const src = $(element).attr("src");
+            if (src)
+                continue;
+            const original = $(element).html();
+            if (!original)
+                continue;
+            const rewritten = await (0, exports.rewriteJsText)(original, resolve, baseUrl);
             if (rewritten !== original) {
-                input.$(element).html(rewritten);
+                $(element).html(rewritten);
             }
-        }));
-    }
-    for (const resource of input.resourceMap.values()) {
-        const isCss = (resource.contentType && resource.contentType.includes("text/css")) ||
-            resource.extension.toLowerCase() === "css";
-        if (!isCss) {
-            continue;
         }
-        const cssUrl = resource.url;
-        rewritePromises.push((0, css_rewrite_1.rewriteCssUrls)({
-            filename: `${input.assetsDirName}/${resource.filename}`,
-            extension: resource.extension,
-            cssUrl,
-            resolveUrl: async (absoluteUrl) => {
-                const direct = input.resourceMap.get(absoluteUrl);
-                if (direct) {
-                    return readAsURL(`${input.assetsDirName}/${direct.filename}`, direct.extension);
-                }
-                const fallback = (0, resources_1.toAbsoluteUrl)(input.baseUrl, absoluteUrl);
-                const record = networkRecordByUrl.get(fallback) || networkRecordByUrl.get(absoluteUrl);
-                return record ? (0, network_records_1.toDataUrlFromRecord)(record) : null;
-            }
-        }).then(() => { }));
-    }
-    if (rewritePromises.length) {
-        await Promise.all(rewritePromises);
     }
+    (0, hack_html_1.hackHtml)({
+        $,
+        baseUrl: baseUrl,
+        apiPath: input.apiPath
+    });
+    const title = $("title").first().text() || undefined;
+    return { html: $.html(), title };
 };
-exports.rewriteLinks = rewriteLinks;
+exports.rewriteEntryHtml = rewriteEntryHtml;

package/dist/snapshot-builder.d.ts

@@ -0,0 +1,15 @@
+import type { ContentStore, PageSnapshot, PathResolver } from "./types";
+import type { ApiEntry, StoredResource } from "./network-store";
+type BuildOptions = {
+    entryUrl: string;
+    createdAt: number;
+    resources: StoredResource[];
+    apiEntries: ApiEntry[];
+    contentStore: ContentStore;
+    pathResolver?: PathResolver;
+    rewriteEntry: boolean;
+    rewriteCSS: boolean;
+    warnings: string[];
+};
+export declare const buildSnapshot: (input: BuildOptions) => Promise<PageSnapshot>;
+export {};