@pagepocket/lib 0.8.6 → 0.9.0

package/dist/snapshot-builder/rewrite-resource.d.ts

@@ -1,7 +1,7 @@
 import type { BuildOptions, StoredResource } from "./types.js";
 export declare const maybeRewriteStylesheet: (input: {
     resource: StoredResource;
-    resolve: (absoluteUrl: string) => string | null;
+    resolve: (absoluteUrl: string) => string | undefined;
     contentStore: BuildOptions["capture"]["contentStore"];
     rewriteCSS: boolean;
 }) => Promise<{
@@ -10,7 +10,7 @@ export declare const maybeRewriteStylesheet: (input: {
 }>;
 export declare const maybeRewriteScript: (input: {
     resource: StoredResource;
-    resolve: (absoluteUrl: string) => string | null;
+    resolve: (absoluteUrl: string) => string | undefined;
     contentStore: BuildOptions["capture"]["contentStore"];
 }) => Promise<{
     contentRef: import("../types.js").ContentRef;

package/dist/snapshot-builder/rewrite-resource.js

@@ -9,7 +9,7 @@ export const maybeRewriteStylesheet = async (input) => {
     const stream = await input.contentStore.open(input.resource.contentRef);
     const bytes = await streamToUint8Array(stream);
     const decoded = decodeUtf8(bytes);
-    if (decoded === null) {
+    if (typeof decoded === "undefined") {
         return { contentRef: input.resource.contentRef, size: input.resource.size };
     }
     const rewritten = await rewriteCssText({
@@ -35,7 +35,7 @@ export const maybeRewriteScript = async (input) => {
     const stream = await input.contentStore.open(input.resource.contentRef);
     const bytes = await streamToUint8Array(stream);
     const decoded = decodeUtf8(bytes);
-    if (decoded === null) {
+    if (typeof decoded === "undefined") {
         return { contentRef: input.resource.contentRef, size: input.resource.size };
     }
     const rewritten = await rewriteJsText(decoded, input.resolve, input.resource.request.url);

package/dist/types.d.ts

@@ -4,7 +4,7 @@
  * NOTE: This repo previously sourced these from a dedicated `@pagepocket/interceptor` package.
  * That package has been removed; the contracts live in `@pagepocket/lib` now.
  */
-import type { Cheerio, CheerioAPI } from "cheerio";
+import type { AnyCheerio, AnyCheerioApi } from "./cheerio/types.js";
 export type ResourceType = "document" | "stylesheet" | "script" | "image" | "font" | "media" | "xhr" | "fetch" | "other" | (string & {});
 export type BodySource = {
     kind: "buffer";
@@ -205,8 +205,8 @@ export interface ReplaceElementRule {
     apply?: ApplyOptions;
 }
 export interface ReplaceElementContext {
-    $: CheerioAPI;
-    $el: Cheerio<any>;
+    $: AnyCheerioApi;
+    $el: AnyCheerio;
     url: string;
     entryUrl: string;
     ruleIndex: number;

package/dist/units/internal/async-queue.d.ts

@@ -0,0 +1,9 @@
+export declare const emptyAsyncIterable: <T>() => AsyncIterable<T>;
+export declare class AsyncQueue<T> {
+    private values;
+    private pending;
+    private done;
+    push(value: T): void;
+    close(): void;
+    iterate(): AsyncGenerator<T>;
+}

package/dist/units/internal/async-queue.js

@@ -0,0 +1,57 @@
+export const emptyAsyncIterable = () => ({
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => ({ value: undefined, done: true })
+        };
+    }
+});
+export class AsyncQueue {
+    constructor() {
+        this.values = [];
+        this.pending = [];
+        this.done = false;
+    }
+    push(value) {
+        if (this.done) {
+            return;
+        }
+        const resolve = this.pending.shift();
+        if (resolve) {
+            resolve({ value, done: false });
+            return;
+        }
+        this.values.push(value);
+    }
+    close() {
+        if (this.done) {
+            return;
+        }
+        this.done = true;
+        for (const resolve of this.pending) {
+            resolve({ value: undefined, done: true });
+        }
+        this.pending = [];
+    }
+    async *iterate() {
+        while (true) {
+            if (this.values.length > 0) {
+                const v = this.values.shift();
+                if (v === undefined) {
+                    continue;
+                }
+                yield v;
+                continue;
+            }
+            if (this.done) {
+                return;
+            }
+            const next = await new Promise((resolve) => {
+                this.pending.push(resolve);
+            });
+            if (next.done) {
+                return;
+            }
+            yield next.value;
+        }
+    }
+}

package/dist/units/internal/deferred-tracker.d.ts

@@ -0,0 +1,5 @@
+export declare class DeferredTracker {
+    private promises;
+    add(p: Promise<unknown>): void;
+    awaitAll(): Promise<void>;
+}

package/dist/units/internal/deferred-tracker.js

@@ -0,0 +1,13 @@
+export class DeferredTracker {
+    constructor() {
+        this.promises = [];
+    }
+    add(p) {
+        this.promises.push(p);
+    }
+    async awaitAll() {
+        const ps = this.promises;
+        this.promises = [];
+        await Promise.allSettled(ps);
+    }
+}

package/dist/units/internal/runtime.d.ts

@@ -0,0 +1,37 @@
+import type { ChannelToken, ReplaceElementsConfig } from "@pagepocket/contracts";
+import { type ElementPatchRegistry, type UnitContext, type UnitPatch, type UnitRuntime } from "../contracts-bridge.js";
+import type { CaptureOptions, EntryInfo, PagePocketOptions } from "../types.js";
+declare class ElementPatchRegistryImpl implements ElementPatchRegistry {
+    private items;
+    contribute(_source: {
+        type: "unit" | "plugin";
+        name: string;
+    }, rules: ReplaceElementsConfig): void;
+    contributeLazy(_source: {
+        type: "unit" | "plugin";
+        name: string;
+    }, build: () => ReplaceElementsConfig | Promise<ReplaceElementsConfig>): void;
+    compile(): Promise<ReplaceElementsConfig>;
+}
+export declare class RuntimeImpl implements UnitRuntime {
+    readonly entry: EntryInfo;
+    readonly options: CaptureOptions;
+    readonly pocketOptions: PagePocketOptions;
+    private channels;
+    private deferred;
+    readonly elements: ElementPatchRegistryImpl;
+    constructor(input: {
+        entry: EntryInfo;
+        options: CaptureOptions;
+        pocketOptions: PagePocketOptions;
+    });
+    publish<T>(t: ChannelToken<T>, value: T): void;
+    subscribe<T>(t: ChannelToken<T>): AsyncIterable<T>;
+    hasPublisher(t: ChannelToken<unknown>): boolean;
+    defer(promise: Promise<unknown>): void;
+    _ensureChannel(t: ChannelToken<unknown>): void;
+    _closeAllChannels(): Promise<void>;
+    _awaitDeferred(): Promise<void>;
+}
+export declare const mergePatchIntoFreshContext: (patch: UnitPatch) => UnitContext;
+export {};

package/dist/units/internal/runtime.js

@@ -0,0 +1,113 @@
+import { TERMINAL_RESULT_KEY } from "../contracts-bridge.js";
+import { AsyncQueue, emptyAsyncIterable } from "./async-queue.js";
+import { DeferredTracker } from "./deferred-tracker.js";
+class ElementPatchRegistryImpl {
+    constructor() {
+        this.items = [];
+    }
+    contribute(_source, rules) {
+        this.items.push({ rules });
+    }
+    contributeLazy(_source, build) {
+        this.items.push({ build });
+    }
+    async compile() {
+        const out = [];
+        for (const item of this.items) {
+            if (item.rules) {
+                out.push(...item.rules);
+                continue;
+            }
+            if (item.build) {
+                const rules = await item.build();
+                out.push(...rules);
+            }
+        }
+        return out;
+    }
+}
+export class RuntimeImpl {
+    constructor(input) {
+        this.channels = new Map();
+        this.deferred = new DeferredTracker();
+        this.elements = new ElementPatchRegistryImpl();
+        this.entry = input.entry;
+        this.options = input.options;
+        this.pocketOptions = input.pocketOptions;
+    }
+    publish(t, value) {
+        const state = this.channels.get(t.id);
+        if (!state || state.closed) {
+            return;
+        }
+        state.hasPublisher = true;
+        for (const sub of state.subs) {
+            sub.push(value);
+        }
+    }
+    subscribe(t) {
+        if (!this.channels.has(t.id)) {
+            this.channels.set(t.id, { hasPublisher: false, subs: new Set(), closed: false });
+        }
+        const state = this.channels.get(t.id);
+        if (!state || state.closed) {
+            return emptyAsyncIterable();
+        }
+        const q = new AsyncQueue();
+        const sub = {
+            push: (v) => q.push(v),
+            close: () => q.close()
+        };
+        state.subs.add(sub);
+        const owner = this;
+        return (async function* () {
+            try {
+                for await (const v of q.iterate()) {
+                    yield v;
+                }
+            }
+            finally {
+                const s = owner.channels.get(t.id);
+                s?.subs.delete(sub);
+                q.close();
+            }
+        })();
+    }
+    hasPublisher(t) {
+        return this.channels.get(t.id)?.hasPublisher === true;
+    }
+    defer(promise) {
+        this.deferred.add(promise);
+    }
+    _ensureChannel(t) {
+        if (this.channels.has(t.id)) {
+            return;
+        }
+        this.channels.set(t.id, { hasPublisher: false, subs: new Set(), closed: false });
+    }
+    async _closeAllChannels() {
+        for (const state of this.channels.values()) {
+            if (state.closed) {
+                continue;
+            }
+            state.closed = true;
+            for (const sub of state.subs) {
+                sub.close();
+            }
+            state.subs.clear();
+        }
+    }
+    async _awaitDeferred() {
+        await this.deferred.awaitAll();
+    }
+}
+export const mergePatchIntoFreshContext = (patch) => {
+    const next = { value: {} };
+    for (const [k, v] of Object.entries(patch)) {
+        if (k === TERMINAL_RESULT_KEY) {
+            continue;
+        }
+        next.value[k] = v;
+    }
+    return next;
+};

package/dist/units/runner.js

@@ -1,179 +1,5 @@
 import { TERMINAL_RESULT_KEY } from "./contracts-bridge.js";
-const emptyAsyncIterable = () => ({
-    [Symbol.asyncIterator]() {
-        return {
-            next: async () => ({ value: undefined, done: true })
-        };
-    }
-});
-class AsyncQueue {
-    constructor() {
-        this.values = [];
-        this.pending = [];
-        this.done = false;
-    }
-    push(value) {
-        if (this.done) {
-            return;
-        }
-        const resolve = this.pending.shift();
-        if (resolve) {
-            resolve({ value, done: false });
-            return;
-        }
-        this.values.push(value);
-    }
-    close() {
-        if (this.done) {
-            return;
-        }
-        this.done = true;
-        for (const resolve of this.pending) {
-            resolve({ value: undefined, done: true });
-        }
-        this.pending = [];
-    }
-    async *iterate() {
-        while (true) {
-            if (this.values.length > 0) {
-                const v = this.values.shift();
-                if (v === undefined) {
-                    continue;
-                }
-                yield v;
-                continue;
-            }
-            if (this.done) {
-                return;
-            }
-            const next = await new Promise((resolve) => {
-                this.pending.push(resolve);
-            });
-            if (next.done) {
-                return;
-            }
-            yield next.value;
-        }
-    }
-}
-class DeferredTracker {
-    constructor() {
-        this.promises = [];
-    }
-    add(p) {
-        this.promises.push(p);
-    }
-    async awaitAll() {
-        const ps = this.promises;
-        this.promises = [];
-        await Promise.allSettled(ps);
-    }
-}
-class ElementPatchRegistryImpl {
-    constructor() {
-        this.items = [];
-    }
-    contribute(_source, rules) {
-        this.items.push({ rules });
-    }
-    contributeLazy(_source, build) {
-        this.items.push({ build });
-    }
-    async compile() {
-        const out = [];
-        for (const item of this.items) {
-            if (item.rules) {
-                out.push(...item.rules);
-                continue;
-            }
-            if (item.build) {
-                const rules = await item.build();
-                out.push(...rules);
-            }
-        }
-        return out;
-    }
-}
-class RuntimeImpl {
-    constructor(input) {
-        this.channels = new Map();
-        this.deferred = new DeferredTracker();
-        this.elements = new ElementPatchRegistryImpl();
-        this.entry = input.entry;
-        this.options = input.options;
-        this.pocketOptions = input.pocketOptions;
-    }
-    publish(t, value) {
-        const state = this.channels.get(t.id);
-        if (!state || state.closed) {
-            // No subscribers or closed: drop.
-            return;
-        }
-        state.hasPublisher = true;
-        for (const sub of state.subs) {
-            sub.push(value);
-        }
-    }
-    subscribe(t) {
-        // subscribe MUST be safe.
-        // Important: subscribe must also be able to receive future publishes.
-        // If no publisher ever publishes, the iterator will just complete on close.
-        if (!this.channels.has(t.id)) {
-            this.channels.set(t.id, { hasPublisher: false, subs: new Set(), closed: false });
-        }
-        const state = this.channels.get(t.id);
-        if (!state || state.closed) {
-            return emptyAsyncIterable();
-        }
-        const q = new AsyncQueue();
-        const sub = {
-            push: (v) => q.push(v),
-            close: () => q.close()
-        };
-        state.subs.add(sub);
-        const owner = this;
-        return (async function* () {
-            try {
-                for await (const v of q.iterate()) {
-                    yield v;
-                }
-            }
-            finally {
-                // best-effort cleanup
-                const s = owner.channels.get(t.id);
-                s?.subs.delete(sub);
-                q.close();
-            }
-        })();
-    }
-    hasPublisher(t) {
-        return this.channels.get(t.id)?.hasPublisher === true;
-    }
-    defer(promise) {
-        this.deferred.add(promise);
-    }
-    _ensureChannel(t) {
-        if (this.channels.has(t.id)) {
-            return;
-        }
-        this.channels.set(t.id, { hasPublisher: false, subs: new Set(), closed: false });
-    }
-    async _closeAllChannels() {
-        for (const state of this.channels.values()) {
-            if (state.closed) {
-                continue;
-            }
-            state.closed = true;
-            for (const sub of state.subs) {
-                sub.close();
-            }
-            state.subs.clear();
-        }
-    }
-    async _awaitDeferred() {
-        await this.deferred.awaitAll();
-    }
-}
+import { mergePatchIntoFreshContext, RuntimeImpl } from "./internal/runtime.js";
 export const runCapture = async (input) => {
     const rt = new RuntimeImpl({
         entry: input.entry,
@@ -198,15 +24,8 @@ export const runCapture = async (input) => {
             pluginSetupValues.set(plugin, v);
         }
     }
-    const mergePatch = (ctx, patch) => {
-        const next = { value: {} };
-        for (const [k, v] of Object.entries(patch)) {
-            if (k === TERMINAL_RESULT_KEY) {
-                continue;
-            }
-            next.value[k] = v;
-        }
-        return next;
+    const mergePatch = (_ctx, patch) => {
+        return mergePatchIntoFreshContext(patch);
     };
     let ctx = { value: {} };
     let result;

package/dist/utils.d.ts

@@ -5,7 +5,7 @@ export declare const stripLeadingSlash: (value: string) => string;
 export declare const ensureLeadingSlash: (value: string) => string;
 export declare const sanitizePosixPath: (value: string) => string;
 export declare const bytesToBase64: (bytes: Uint8Array) => string;
-export declare const decodeUtf8: (bytes: Uint8Array) => string | null;
+export declare const decodeUtf8: (bytes: Uint8Array) => string | undefined;
 export declare const isUtf8Text: (bytes: Uint8Array, mimeType?: string) => boolean;
 export declare const toUint8Array: (body: BodySource) => Promise<Uint8Array>;
 export declare const bodyToTextOrBase64: (bytes: Uint8Array, mimeType?: string) => {

package/dist/utils.js

@@ -46,12 +46,12 @@ export const decodeUtf8 = (bytes) => {
         return decoder.decode(bytes);
     }
     catch {
-        return null;
+        return undefined;
     }
 };
 export const isUtf8Text = (bytes, mimeType) => {
     const decoded = decodeUtf8(bytes);
-    if (decoded === null) {
+    if (typeof decoded === "undefined") {
         return false;
     }
     if (mimeType) {
@@ -95,7 +95,7 @@ export const bodyToTextOrBase64 = (bytes, mimeType) => {
     }
     return { encoding: "base64", base64: bytesToBase64(bytes) };
 };
-const toUrlOrNull = (input, baseUrl) => {
+const toUrlOrUndefined = (input, baseUrl) => {
     try {
         if (baseUrl) {
             return new URL(input, baseUrl);
@@ -103,7 +103,7 @@ const toUrlOrNull = (input, baseUrl) => {
         return new URL(input);
     }
     catch {
-        return null;
+        return undefined;
     }
 };
 const stripTrailingSlash = (value) => value.replace(/\/+$/, "");
@@ -142,8 +142,8 @@ const areProtocolsEquivalent = (a, b) => {
  */
 export const urlEquivalent = (a, b, options = {}) => {
     const { baseUrl, ignoreHash = true, ignoreDefaultPort = true, normalizeTrailingSlash: shouldNormalizeTrailingSlash = true } = options;
-    const left = toUrlOrNull(String(a), baseUrl);
-    const right = toUrlOrNull(String(b), baseUrl);
+    const left = toUrlOrUndefined(String(a), baseUrl);
+    const right = toUrlOrUndefined(String(b), baseUrl);
     if (!left || !right) {
         return false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagepocket/lib",
-  "version": "0.8.6",
+  "version": "0.9.0",
   "description": "Library for rewriting HTML snapshots and inlining local resources.",
   "type": "module",
   "main": "dist/index.js",
@@ -19,9 +19,10 @@
   "license": "ISC",
   "dependencies": {
     "cheerio": "^1.0.0-rc.12",
-    "@pagepocket/shared": "0.8.6",
-    "@pagepocket/contracts": "0.8.6",
-    "@pagepocket/uni-fs": "0.8.6"
+    "domhandler": "^5.0.3",
+    "@pagepocket/uni-fs": "0.9.0",
+    "@pagepocket/shared": "0.9.0",
+    "@pagepocket/contracts": "0.9.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.50.1",