@pagepocket/lib 0.7.1 → 0.8.0

package/dist/v3/runner.js

@@ -0,0 +1,245 @@
+const emptyAsyncIterable = async function* () {
+    return;
+};
+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.artifacts = new Map();
+        this.channels = new Map();
+        this.deferred = new DeferredTracker();
+        this.finished = false;
+        this.elements = new ElementPatchRegistryImpl();
+        this.entry = input.entry;
+        this.options = input.options;
+        this.pocketOptions = input.pocketOptions;
+    }
+    provide(t, value) {
+        this.artifacts.set(t.id, value);
+    }
+    get(t) {
+        return this.artifacts.get(t.id);
+    }
+    require(t) {
+        const v = this.get(t);
+        if (v === undefined) {
+            throw new Error(`Missing artifact: ${t.id}`);
+        }
+        return v;
+    }
+    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;
+    }
+    finish(result) {
+        if (this.finished) {
+            return;
+        }
+        this.finished = true;
+        this.result = result;
+    }
+    defer(promise) {
+        this.deferred.add(promise);
+    }
+    _isFinished() {
+        return this.finished;
+    }
+    _getResult() {
+        return this.result;
+    }
+    _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 runCaptureV3 = async (input) => {
+    const rt = new RuntimeImpl({
+        entry: input.entry,
+        options: input.options,
+        pocketOptions: input.pocketOptions
+    });
+    for (const ch of input.declaredChannels ?? []) {
+        rt._ensureChannel(ch);
+    }
+    for (const unit of input.units) {
+        unit.attach(rt);
+    }
+    const pluginHost = {
+        entry: rt.entry,
+        options: rt.options,
+        subscribe: (t) => rt.subscribe(t),
+        hasPublisher: (t) => rt.hasPublisher(t),
+        elements: rt.elements,
+        defer: (p) => rt.defer(p)
+    };
+    for (const plugin of input.plugins ?? []) {
+        await plugin.setup(pluginHost);
+    }
+    try {
+        for (const unit of input.units) {
+            if (rt._isFinished()) {
+                break;
+            }
+            const out = await unit.run();
+            if (out) {
+                rt.finish(out);
+                break;
+            }
+        }
+    }
+    finally {
+        await rt._closeAllChannels();
+        await rt._awaitDeferred();
+    }
+    const result = rt._getResult();
+    if (!result) {
+        throw new Error("No terminal result. Ensure a terminal unit returns a CaptureResult or calls finish().");
+    }
+    return result;
+};
+export const runCapture = runCaptureV3;

package/dist/v3/types.d.ts

@@ -0,0 +1,39 @@
+import type { CompletionStrategy, ContentStore, PathResolver, ResourceFilter } from "../types.js";
+export type EntryInfo = {
+    kind: "url";
+    url: string;
+} | {
+    kind: "puppeteer-page";
+    page: unknown;
+    url?: string;
+} | {
+    kind: "cdp-tab";
+    tabId: number;
+    url?: string;
+} | {
+    kind: "html-string";
+    htmlString: string;
+    baseUrl: string;
+    url?: string;
+} | {
+    kind: "document";
+    baseUrl: string;
+    url?: string;
+};
+export interface CaptureOptions {
+    completion?: CompletionStrategy | CompletionStrategy[];
+    timeoutMs?: number;
+    maxDurationMs?: number;
+    filter?: ResourceFilter;
+    blacklist?: RegExp[];
+    pathResolver?: PathResolver;
+    contentStore?: ContentStore;
+    rewriteEntry?: boolean;
+    rewriteCSS?: boolean;
+    limits?: {
+        maxTotalBytes?: number;
+        maxSingleResourceBytes?: number;
+        maxResources?: number;
+    };
+}
+export type PagePocketOptions = import("../types.js").PagePocketOptions;

package/dist/v3/types.js

@@ -0,0 +1 @@
+export {};

package/dist/writers.js

@@ -34,7 +34,9 @@ const trimTrailingSlash = (value) => {
 };
 const buildSuffix = (pattern, index) => {
     const template = pattern ?? DEFAULT_SUFFIX_PATTERN;
-    return template.includes("{num}") ? template.replace("{num}", String(index)) : `${template}${index}`;
+    return template.includes("{num}")
+        ? template.replace("{num}", String(index))
+        : `${template}${index}`;
 };
 const appendDirectorySuffix = (basePath, suffix) => {
     return `${trimTrailingSlash(basePath)}${suffix}`;

package/package.json

@@ -1,9 +1,16 @@
 {
   "name": "@pagepocket/lib",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Library for rewriting HTML snapshots and inlining local resources.",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "files": [
     "dist"
   ],
@@ -12,8 +19,9 @@
   "license": "ISC",
   "dependencies": {
     "cheerio": "^1.0.0-rc.12",
-    "@pagepocket/interceptor": "0.7.1",
-    "@pagepocket/uni-fs": "0.7.1"
+    "@pagepocket/contracts": "0.8.0",
+    "@pagepocket/shared": "0.8.0",
+    "@pagepocket/uni-fs": "0.8.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.50.1",