@pagepocket/lib 0.4.0

package/dist/rewrite-links.d.ts

@@ -0,0 +1,15 @@
+import type { CheerioAPI } from "cheerio";
+import { type ResourceReference, type SrcsetReference } from "./resources";
+import type { NetworkRecord } from "./types";
+import type { DownloadedResource } from "./download-resources";
+type RewriteLinksInput = {
+    $: CheerioAPI;
+    resourceUrls: ResourceReference[];
+    srcsetItems: SrcsetReference[];
+    baseUrl: string;
+    assetsDirName: string;
+    resourceMap: Map<string, DownloadedResource>;
+    networkRecords: NetworkRecord[];
+};
+export declare const rewriteLinks: (input: RewriteLinksInput) => Promise<void>;
+export {};

package/dist/rewrite-links.js

@@ -0,0 +1,263 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteLinks = void 0;
+const css_rewrite_1 = require("./css-rewrite");
+const network_records_1 = require("./network-records");
+const resources_1 = require("./resources");
+const shouldSkipValue = (value, assetsDirName) => {
+    const trimmed = value.trim();
+    return (!trimmed ||
+        trimmed.startsWith("data:") ||
+        trimmed.startsWith("blob:") ||
+        trimmed.startsWith("mailto:") ||
+        trimmed.startsWith("tel:") ||
+        trimmed.startsWith("javascript:") ||
+        trimmed.startsWith("#") ||
+        trimmed.includes(assetsDirName));
+};
+const buildLinkBase = (baseUrl) => {
+    try {
+        const parsed = new URL(baseUrl);
+        const baseOrigin = parsed.origin;
+        const baseDir = new URL(".", parsed).toString().replace(/\/$/, "");
+        return { baseOrigin, baseDir };
+    }
+    catch {
+        return { baseOrigin: "", baseDir: "" };
+    }
+};
+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 buildNetworkLookup = (records) => {
+    const networkRecordByUrl = new Map();
+    for (const record of records) {
+        if (record?.url && !networkRecordByUrl.has(record.url)) {
+            networkRecordByUrl.set(record.url, record);
+        }
+    }
+    return networkRecordByUrl;
+};
+const rewriteLinks = async (input) => {
+    const { readAsURL } = await Promise.resolve().then(() => __importStar(require("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);
+                }
+            }
+            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);
+        }
+    }
+    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);
+                continue;
+            }
+            const nextUrl = await resolveLocalUrl(rawUrl);
+            if (!nextUrl) {
+                rewrittenParts.push(part);
+                continue;
+            }
+            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 (rewritten !== original) {
+                input.$(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);
+    }
+};
+exports.rewriteLinks = rewriteLinks;

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+export type FetchRecord = {
+    kind: "fetch" | "xhr";
+    url: string;
+    method: string;
+    requestBody?: string;
+    status?: number;
+    statusText?: string;
+    responseHeaders?: Record<string, string>;
+    responseBody?: string;
+    error?: string;
+    timestamp: number;
+};
+export type NetworkRecord = {
+    url: string;
+    method: string;
+    requestHeaders?: Record<string, string>;
+    requestBody?: string;
+    status?: number;
+    statusText?: string;
+    responseHeaders?: Record<string, string>;
+    responseBody?: string;
+    responseBodyBase64?: string;
+    responseEncoding?: "text" | "base64";
+    error?: string;
+    timestamp: number;
+};
+export type LighterceptorResponseRecord = {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+    bodyEncoding: "text" | "base64";
+};
+export type LighterceptorNetworkRecord = {
+    url: string;
+    source?: string;
+    method: string;
+    timestamp: number;
+    response?: LighterceptorResponseRecord;
+    error?: string;
+};
+export type SnapshotData = {
+    url: string;
+    title: string;
+    capturedAt: string;
+    fetchXhrRecords: FetchRecord[];
+    networkRecords: LighterceptorNetworkRecord[];
+    resources: Array<{
+        url: string;
+        localPath: string;
+        contentType?: string | null;
+        size?: number;
+    }>;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@pagepocket/lib",
+  "version": "0.4.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "cheerio": "^1.0.0-rc.12",
+    "uni-fs": "npm:@pagepocket/uni-fs@0.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "prettier": "^3.7.4",
+    "tsx": "^4.19.3",
+    "typescript": "^5.4.5"
+  },
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "tsx --test specs/**/*.test.ts"
+  }
+}