@projektemacher/vivliostyle-batch-cli 0.1.2 → 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/{LICENCE → LICENSE} +1 -1
- package/README.md +94 -30
- package/dist/index.d.ts +309 -42
- package/dist/vivliostyle-batch-cli.js +2507 -415
- package/package.json +38 -23
- package/scripts/convert-docs-pdf.mjs +520 -0
- package/src/metadata.ts +154 -0
- package/src/render/chrome.ts +103 -0
- package/src/render/pdf-postprocess.ts +293 -0
- package/src/render/pdf.ts +504 -0
- package/src/render/srgb.icc +0 -0
- package/src/render/viewer.ts +46 -0
- package/src/render/xmp.ts +183 -0
- package/src/server.ts +317 -0
- package/src/vivliostyle-cli.ts +1460 -447
|
@@ -0,0 +1,504 @@
|
|
|
1
|
+
// src/render/pdf.ts
|
|
2
|
+
|
|
3
|
+
// Copyright (c) 2026 Christian Mahnke
|
|
4
|
+
// Licensed under the MIT License.
|
|
5
|
+
|
|
6
|
+
/**
|
|
7
|
+
* PDF rendering on top of the Vivliostyle viewer and Chrome's print-to-PDF.
|
|
8
|
+
*
|
|
9
|
+
* The viewer page is served by our own static server (see src/server.ts), so
|
|
10
|
+
* the document's origin — and therefore the base URI of the scripts the page
|
|
11
|
+
* runs — is the site we serve, not an internal viewer base.
|
|
12
|
+
*
|
|
13
|
+
* Printed pages run through the post-processing step (see
|
|
14
|
+
* src/render/pdf-postprocess.ts), which stamps the document metadata and
|
|
15
|
+
* applies the requested PDF/A or PDF/X labeling.
|
|
16
|
+
*/
|
|
17
|
+
|
|
18
|
+
import { mkdirSync, writeFileSync } from "node:fs";
|
|
19
|
+
import { dirname } from "node:path";
|
|
20
|
+
import puppeteer from "puppeteer-core";
|
|
21
|
+
import { PDFDocument } from "pdf-lib";
|
|
22
|
+
import log from "loglevel";
|
|
23
|
+
import { chromeArgs, resolveBrowserExecutable } from "./chrome.js";
|
|
24
|
+
import { postProcessPdf } from "./pdf-postprocess.js";
|
|
25
|
+
import type { PdfLabel } from "./xmp.js";
|
|
26
|
+
|
|
27
|
+
export type ViewerParams = Record<string, string | number | boolean | undefined>;
|
|
28
|
+
|
|
29
|
+
/** URL of the viewer page, with the publication and layout parameters. */
|
|
30
|
+
export function buildViewerUrl(viewerPageUrl: string, params: ViewerParams): string {
|
|
31
|
+
const parts: string[] = [];
|
|
32
|
+
|
|
33
|
+
for (const [key, value] of Object.entries(params)) {
|
|
34
|
+
if (value === undefined || value === "") continue;
|
|
35
|
+
parts.push(`${key}=${String(value).replaceAll("&", "%26")}`);
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
const query = parts.join("&");
|
|
39
|
+
return query === "" ? viewerPageUrl : `${viewerPageUrl}#${query}`;
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
export type RenderPdfRequest = {
|
|
43
|
+
/** Absolute URL of the document on our static server. */
|
|
44
|
+
documentUrl: string;
|
|
45
|
+
/** Absolute URL of the viewer page on our static server. */
|
|
46
|
+
viewerPageUrl: string;
|
|
47
|
+
/** Absolute path of the PDF to write. */
|
|
48
|
+
output: string;
|
|
49
|
+
viewerParams?: ViewerParams;
|
|
50
|
+
title?: string;
|
|
51
|
+
author?: string;
|
|
52
|
+
subject?: string;
|
|
53
|
+
keywords?: string;
|
|
54
|
+
language?: string;
|
|
55
|
+
/** Standards labeling applied to the printed PDF (PDF/A or PDF/X). */
|
|
56
|
+
pdfLabel?: PdfLabel;
|
|
57
|
+
/** ICC profile embedded as the OutputIntent; required whenever a label is set. */
|
|
58
|
+
iccProfile?: Uint8Array;
|
|
59
|
+
iccProfileName?: string;
|
|
60
|
+
/** Hard limit for the whole render. */
|
|
61
|
+
timeoutMs?: number;
|
|
62
|
+
/** Wait for the page to report that it settled before printing. */
|
|
63
|
+
waitForSettle?: boolean;
|
|
64
|
+
/**
|
|
65
|
+
* Redraw canvas/WebGL content at `clientSize * canvasScale` backing pixels
|
|
66
|
+
* before printing (layout/CSS size unchanged). Values `<= 1` skip the step.
|
|
67
|
+
* Wired from `--pixel-ratio` so `--pixel-ratio 2` stays sharp past 96dpi.
|
|
68
|
+
*/
|
|
69
|
+
canvasScale?: number;
|
|
70
|
+
/** Pause after the upscale call so charts can repaint (default 500ms). */
|
|
71
|
+
canvasSettleMs?: number;
|
|
72
|
+
chromeExecutable?: string;
|
|
73
|
+
extraChromeArgs?: string[];
|
|
74
|
+
};
|
|
75
|
+
|
|
76
|
+
export type RenderPdfResult = {
|
|
77
|
+
output: string;
|
|
78
|
+
bytes: number;
|
|
79
|
+
pageCount: number;
|
|
80
|
+
settle: { reason: string; waitedMs: number } | null;
|
|
81
|
+
};
|
|
82
|
+
|
|
83
|
+
const DEFAULT_TIMEOUT_MS = 300_000;
|
|
84
|
+
|
|
85
|
+
/** The wrapper owns the producer/creator entries of every PDF it prints. */
|
|
86
|
+
const TOOL_IDENTITY = "vivliostyle-batch-cli";
|
|
87
|
+
|
|
88
|
+
function pdfMetadata(request: RenderPdfRequest) {
|
|
89
|
+
return {
|
|
90
|
+
...(request.title === undefined ? {} : { title: request.title }),
|
|
91
|
+
...(request.author === undefined ? {} : { author: request.author }),
|
|
92
|
+
...(request.subject === undefined ? {} : { subject: request.subject }),
|
|
93
|
+
...(request.keywords === undefined ? {} : { keywords: request.keywords }),
|
|
94
|
+
...(request.language === undefined ? {} : { language: request.language }),
|
|
95
|
+
creator: TOOL_IDENTITY,
|
|
96
|
+
producer: TOOL_IDENTITY
|
|
97
|
+
};
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
type SettleState = { reason: string; at: number };
|
|
101
|
+
|
|
102
|
+
export type FrameRenderCapability = {
|
|
103
|
+
url: string;
|
|
104
|
+
ready: boolean;
|
|
105
|
+
fixture: string | null;
|
|
106
|
+
webgl: boolean;
|
|
107
|
+
webgl2: boolean;
|
|
108
|
+
webgpu: boolean;
|
|
109
|
+
canvasCount: number;
|
|
110
|
+
canvases: string;
|
|
111
|
+
iframeCount: number | null;
|
|
112
|
+
dpr: number;
|
|
113
|
+
resized: string | null;
|
|
114
|
+
/** A-Frame scenes materialized into 2D overlay canvases for print. */
|
|
115
|
+
materialized?: number;
|
|
116
|
+
/** Scene-graph state at print time (debug aid). */
|
|
117
|
+
sceneDiag?: string | null;
|
|
118
|
+
};
|
|
119
|
+
|
|
120
|
+
/**
|
|
121
|
+
* Runs inside one frame (viewer window or a document/iframe within it):
|
|
122
|
+
* scrolls JS-painted elements into view so out-of-process iframes rasterize,
|
|
123
|
+
* reports GPU capabilities and canvas sizes, and — when the page exposes the
|
|
124
|
+
* `window.__vivResize(factor)` hook — redraws at HiDPI backing resolution.
|
|
125
|
+
*
|
|
126
|
+
* Blindly rewriting `canvas.width` here would blank WebGL contexts without
|
|
127
|
+
* `preserveDrawingBuffer`, so generic canvases are left for the page to redraw
|
|
128
|
+
* via the dispatched `resize` event; only the explicit hook changes pixels.
|
|
129
|
+
*/
|
|
130
|
+
export function buildFrameProbeScript(factor: number): string {
|
|
131
|
+
return `(async function(factor){
|
|
132
|
+
function nextFrame(){ return new Promise(function(r){ requestAnimationFrame(function(){ requestAnimationFrame(r); }); }); }
|
|
133
|
+
var canvases = Array.prototype.slice.call(document.querySelectorAll("canvas"));
|
|
134
|
+
var iframes = Array.prototype.slice.call(document.querySelectorAll("iframe"));
|
|
135
|
+
canvases.forEach(function(c){ try{ c.scrollIntoView({block:"nearest"}); }catch(e){} });
|
|
136
|
+
iframes.forEach(function(f){ try{ f.scrollIntoView({block:"nearest"}); }catch(e){} });
|
|
137
|
+
function canvasSizes(){
|
|
138
|
+
return Array.prototype.slice.call(document.querySelectorAll("canvas")).map(function(c){
|
|
139
|
+
return c.width+"x"+c.height+"@"+Math.round(c.clientWidth)+"x"+Math.round(c.clientHeight);
|
|
140
|
+
}).join(",");
|
|
141
|
+
}
|
|
142
|
+
var resized = null;
|
|
143
|
+
if (factor > 1 && typeof window.__vivResize === "function") {
|
|
144
|
+
try { window.__vivResize(factor); } catch(e){ resized = "error:"+String(e); }
|
|
145
|
+
}
|
|
146
|
+
try { window.dispatchEvent(new Event("resize")); } catch(e){}
|
|
147
|
+
// Bridge the viewer's broken page lifecycle. A-Frame scenes can end up
|
|
148
|
+
// loaded-but-never-playing in the paginated tree (render loop, default
|
|
149
|
+
// lights and asset loads all missed their window) while the same page
|
|
150
|
+
// renders fine in a real browser. Start the scene's own loop and give
|
|
151
|
+
// collapsed scenes a box (their display:block stylesheet does not reach
|
|
152
|
+
// the re-parented tree, so unsized unknown elements stay inline).
|
|
153
|
+
try {
|
|
154
|
+
var bridgeScenes = document.querySelectorAll("a-scene");
|
|
155
|
+
for (var bi = 0; bi < bridgeScenes.length; bi++) {
|
|
156
|
+
var bridgeScene = bridgeScenes[bi];
|
|
157
|
+
if (!bridgeScene.isPlaying && typeof bridgeScene.play === "function") {
|
|
158
|
+
try { bridgeScene.play(); } catch (e) {}
|
|
159
|
+
}
|
|
160
|
+
if (bridgeScene.clientWidth === 0 || bridgeScene.clientHeight === 0) {
|
|
161
|
+
var sized = bridgeScene.parentElement;
|
|
162
|
+
while (sized && (sized.clientWidth === 0 || sized.clientHeight === 0)) sized = sized.parentElement;
|
|
163
|
+
if (sized) {
|
|
164
|
+
bridgeScene.style.display = "block";
|
|
165
|
+
bridgeScene.style.width = sized.clientWidth + "px";
|
|
166
|
+
bridgeScene.style.height = sized.clientHeight + "px";
|
|
167
|
+
if (typeof bridgeScene.resize === "function") bridgeScene.resize();
|
|
168
|
+
}
|
|
169
|
+
}
|
|
170
|
+
}
|
|
171
|
+
await nextFrame();
|
|
172
|
+
} catch(e){}
|
|
173
|
+
// Give each scene what it needs to render like the browser does, then
|
|
174
|
+
// materialize its WebGL canvas into a 2D overlay (2D canvases always
|
|
175
|
+
// survive print-to-PDF): re-kick unloaded assets, swap unlit materials for
|
|
176
|
+
// flat ones when no lights exist, render, and blit synchronously.
|
|
177
|
+
var materialized = 0;
|
|
178
|
+
var sceneDiag = "";
|
|
179
|
+
try {
|
|
180
|
+
var scenes = document.querySelectorAll("a-scene");
|
|
181
|
+
for (var si = 0; si < scenes.length; si++) {
|
|
182
|
+
var sceneEl = scenes[si];
|
|
183
|
+
// The viewer clones scenes into its page boxes; only the VISIBLE one
|
|
184
|
+
// (with a box) is what the PDF will show. The hidden original's render
|
|
185
|
+
// would materialize nothing.
|
|
186
|
+
if (!(sceneEl.clientWidth > 0 && sceneEl.clientHeight > 0)) continue;
|
|
187
|
+
if (!sceneEl.renderer || !sceneEl.camera) continue;
|
|
188
|
+
try {
|
|
189
|
+
var gltfEl = sceneEl.querySelector("[gltf-model]");
|
|
190
|
+
if (gltfEl) {
|
|
191
|
+
var gmObj = gltfEl.object3D;
|
|
192
|
+
sceneDiag += " gmKids=" + gmObj.children.length + "/" + (gltfEl.components["gltf-model"] ? String(gltfEl.components["gltf-model"].model !== null) : "nocomp");
|
|
193
|
+
}
|
|
194
|
+
sceneDiag += " tree=" + sceneEl.object3D.children.map(function (c) { return c.type + (c.children ? ":" + c.children.length : ""); }).join("|").slice(0, 110);
|
|
195
|
+
} catch (e) {
|
|
196
|
+
sceneDiag += " diagErr " + String(e).slice(0, 50);
|
|
197
|
+
}
|
|
198
|
+
try {
|
|
199
|
+
var assetItems = sceneEl.querySelectorAll("a-asset-item");
|
|
200
|
+
var assetWaits = [];
|
|
201
|
+
for (var ai = 0; ai < assetItems.length; ai++) {
|
|
202
|
+
var assetEl = assetItems[ai];
|
|
203
|
+
if (assetEl.hasLoaded) continue;
|
|
204
|
+
assetWaits.push(
|
|
205
|
+
new Promise(function (resolve) {
|
|
206
|
+
var settled = false;
|
|
207
|
+
var finish = function () {
|
|
208
|
+
if (settled) return;
|
|
209
|
+
settled = true;
|
|
210
|
+
resolve();
|
|
211
|
+
};
|
|
212
|
+
assetEl.addEventListener("loaded", finish, { once: true });
|
|
213
|
+
assetEl.addEventListener("error", finish, { once: true });
|
|
214
|
+
setTimeout(finish, 8000);
|
|
215
|
+
var src = assetEl.getAttribute("src");
|
|
216
|
+
if (src) assetEl.setAttribute("src", src);
|
|
217
|
+
})
|
|
218
|
+
);
|
|
219
|
+
}
|
|
220
|
+
if (assetWaits.length > 0) {
|
|
221
|
+
await Promise.race([Promise.all(assetWaits), new Promise(function (r) { setTimeout(r, 9000); })]);
|
|
222
|
+
}
|
|
223
|
+
} catch (e) {}
|
|
224
|
+
try {
|
|
225
|
+
var lightsFound = 0;
|
|
226
|
+
sceneEl.object3D.traverse(function (n) { if (n.isLight) lightsFound++; });
|
|
227
|
+
if (lightsFound === 0) {
|
|
228
|
+
var basicCtor = null;
|
|
229
|
+
sceneEl.object3D.traverse(function (n) {
|
|
230
|
+
if (n.isMesh && n.material && n.material.isMeshBasicMaterial && basicCtor === null) basicCtor = n.material.constructor;
|
|
231
|
+
});
|
|
232
|
+
if (basicCtor) {
|
|
233
|
+
sceneEl.object3D.traverse(function (n) {
|
|
234
|
+
if (!n.isMesh || !n.material || n.material.isMeshBasicMaterial) return;
|
|
235
|
+
try {
|
|
236
|
+
var m = n.material;
|
|
237
|
+
var flat = new basicCtor({ color: m.color ? m.color.clone() : undefined });
|
|
238
|
+
flat.side = m.side;
|
|
239
|
+
flat.transparent = m.transparent;
|
|
240
|
+
flat.opacity = m.opacity;
|
|
241
|
+
if (m.map) flat.map = m.map;
|
|
242
|
+
n.material = flat;
|
|
243
|
+
} catch (e) {}
|
|
244
|
+
});
|
|
245
|
+
}
|
|
246
|
+
}
|
|
247
|
+
} catch(e){}
|
|
248
|
+
try {
|
|
249
|
+
sceneEl.renderer.render(sceneEl.object3D, sceneEl.camera);
|
|
250
|
+
var glCanvas = sceneEl.canvas;
|
|
251
|
+
if (!glCanvas || glCanvas.width === 0 || glCanvas.height === 0) continue;
|
|
252
|
+
var overlay = document.createElement("canvas");
|
|
253
|
+
overlay.setAttribute("data-viv-gl-overlay", "");
|
|
254
|
+
overlay.width = glCanvas.width;
|
|
255
|
+
overlay.height = glCanvas.height;
|
|
256
|
+
overlay.style.position = "absolute";
|
|
257
|
+
overlay.style.pointerEvents = "none";
|
|
258
|
+
overlay.style.width = glCanvas.clientWidth + "px";
|
|
259
|
+
overlay.style.height = glCanvas.clientHeight + "px";
|
|
260
|
+
var cr = glCanvas.getBoundingClientRect();
|
|
261
|
+
var pr = (glCanvas.offsetParent || document.body).getBoundingClientRect();
|
|
262
|
+
overlay.style.left = cr.left - pr.left + "px";
|
|
263
|
+
overlay.style.top = cr.top - pr.top + "px";
|
|
264
|
+
overlay.style.zIndex = "1";
|
|
265
|
+
(glCanvas.parentNode || document.body).appendChild(overlay);
|
|
266
|
+
overlay.getContext("2d").drawImage(glCanvas, 0, 0);
|
|
267
|
+
// Empty capture = the scene never initialized in this tree (its
|
|
268
|
+
// framework lifecycle was lost to the viewer's re-parenting). Replace
|
|
269
|
+
// it with a fresh copy: the custom-element upgrade re-runs the full
|
|
270
|
+
// framework lifecycle (assets, lights, render loop) in the now-sized
|
|
271
|
+
// tree.
|
|
272
|
+
var empty = true;
|
|
273
|
+
try {
|
|
274
|
+
var dd = overlay.getContext("2d").getImageData(0, 0, overlay.width, overlay.height).data;
|
|
275
|
+
for (var di = 3; di < dd.length; di += 256) {
|
|
276
|
+
if (dd[di] > 0) {
|
|
277
|
+
empty = false;
|
|
278
|
+
break;
|
|
279
|
+
}
|
|
280
|
+
}
|
|
281
|
+
} catch (e) {
|
|
282
|
+
empty = false;
|
|
283
|
+
}
|
|
284
|
+
if (empty) {
|
|
285
|
+
var fresh = sceneEl.cloneNode(true);
|
|
286
|
+
sceneEl.parentNode.replaceChild(fresh, sceneEl);
|
|
287
|
+
sceneEl = fresh;
|
|
288
|
+
// Enough time for the fresh scene's asset fetches (a real GLB over
|
|
289
|
+
// the network) + first renders.
|
|
290
|
+
await new Promise(function (r) {
|
|
291
|
+
setTimeout(r, 8000);
|
|
292
|
+
});
|
|
293
|
+
if (!sceneEl.renderer || !sceneEl.camera) continue;
|
|
294
|
+
}
|
|
295
|
+
sceneEl.renderer.render(sceneEl.object3D, sceneEl.camera);
|
|
296
|
+
var gl2 = sceneEl.canvas;
|
|
297
|
+
if (!gl2 || gl2.width === 0 || gl2.height === 0) continue;
|
|
298
|
+
overlay.width = gl2.width;
|
|
299
|
+
overlay.height = gl2.height;
|
|
300
|
+
overlay.getContext("2d").drawImage(gl2, 0, 0);
|
|
301
|
+
materialized++;
|
|
302
|
+
try {
|
|
303
|
+
var od = overlay.getContext("2d").getImageData(0, 0, overlay.width, overlay.height).data;
|
|
304
|
+
var alphaN = 0;
|
|
305
|
+
var orangeN = 0;
|
|
306
|
+
for (var oi = 3; oi < od.length; oi += 16) {
|
|
307
|
+
if (od[oi] > 0) alphaN++;
|
|
308
|
+
if (od[oi - 3] > 150 && od[oi - 2] > 60 && od[oi - 2] < 200 && od[oi - 1] < 110 && od[oi - 3] > od[oi - 2] + 40) orangeN++;
|
|
309
|
+
}
|
|
310
|
+
glSample = [alphaN, orangeN];
|
|
311
|
+
} catch (e) {}
|
|
312
|
+
} catch (e) {}
|
|
313
|
+
}
|
|
314
|
+
} catch(e){}
|
|
315
|
+
// Hooks like echarts re-init dispose the canvas synchronously; let layout
|
|
316
|
+
// settle a frame before measuring so sizes reflect the repainted state.
|
|
317
|
+
// This also lets render loops refill their drawing buffers after the
|
|
318
|
+
// resize above — drawImage on a just-resized WebGL canvas would read the
|
|
319
|
+
// cleared buffer.
|
|
320
|
+
try { await nextFrame(); } catch(e){}
|
|
321
|
+
if (resized === null && factor > 1 && typeof window.__vivResize === "function") resized = canvasSizes();
|
|
322
|
+
var webgl = false, webgl2 = false;
|
|
323
|
+
try {
|
|
324
|
+
var t = document.createElement("canvas");
|
|
325
|
+
webgl = !!t.getContext("webgl");
|
|
326
|
+
var t2 = document.createElement("canvas");
|
|
327
|
+
webgl2 = !!t2.getContext("webgl2");
|
|
328
|
+
} catch(e){}
|
|
329
|
+
return {
|
|
330
|
+
url: String(location.href),
|
|
331
|
+
ready: window.__vivReady === true,
|
|
332
|
+
fixture: typeof window.__vivFixture === "string" ? window.__vivFixture : null,
|
|
333
|
+
webgl: webgl, webgl2: webgl2,
|
|
334
|
+
webgpu: typeof navigator !== "undefined" && "gpu" in navigator,
|
|
335
|
+
canvasCount: document.querySelectorAll("canvas").length, canvases: canvasSizes(),
|
|
336
|
+
iframeCount: document.querySelectorAll("iframe").length,
|
|
337
|
+
dpr: typeof window.devicePixelRatio === "number" ? window.devicePixelRatio : 1,
|
|
338
|
+
resized: resized,
|
|
339
|
+
materialized: materialized,
|
|
340
|
+
sceneDiag: sceneDiag
|
|
341
|
+
};
|
|
342
|
+
})(${JSON.stringify(factor)})`;
|
|
343
|
+
}
|
|
344
|
+
|
|
345
|
+
/** Best-effort capability + HiDPI pass over every frame before `page.pdf()`. */
|
|
346
|
+
export async function prepareForPrint(
|
|
347
|
+
page: {
|
|
348
|
+
frames: () => Array<{ url?: () => string; evaluate: (script: string) => Promise<unknown> }>;
|
|
349
|
+
},
|
|
350
|
+
options: { canvasScale?: number; settleMs?: number } = {}
|
|
351
|
+
): Promise<FrameRenderCapability[]> {
|
|
352
|
+
const factor = options.settleMs !== undefined && options.canvasScale === undefined ? 1 : (options.canvasScale ?? 1);
|
|
353
|
+
const scale = Number.isFinite(factor) && factor > 1 ? factor : 1;
|
|
354
|
+
const script = buildFrameProbeScript(scale);
|
|
355
|
+
const out: FrameRenderCapability[] = [];
|
|
356
|
+
for (const frame of page.frames()) {
|
|
357
|
+
try {
|
|
358
|
+
out.push((await frame.evaluate(script)) as FrameRenderCapability);
|
|
359
|
+
} catch (err) {
|
|
360
|
+
// Cross-origin embeds that refuse evaluation still print as pixels.
|
|
361
|
+
log.trace("frame probe failed", frame.url?.() ?? "(frame)", err instanceof Error ? err.message : String(err));
|
|
362
|
+
continue;
|
|
363
|
+
}
|
|
364
|
+
}
|
|
365
|
+
if (scale > 1) {
|
|
366
|
+
await new Promise((resolve) => setTimeout(resolve, options.settleMs ?? 500));
|
|
367
|
+
}
|
|
368
|
+
return out;
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
/** One-line summary for logs: capabilities per frame that owns content. */
|
|
372
|
+
export function summarizeCapabilities(caps: FrameRenderCapability[]): string {
|
|
373
|
+
return caps
|
|
374
|
+
.filter((c) => c.canvasCount > 0 || (c.iframeCount ?? 0) > 0 || c.fixture !== null)
|
|
375
|
+
.map(
|
|
376
|
+
(c) =>
|
|
377
|
+
`${c.fixture ?? c.url} canvases=[${c.canvases}] iframes=${c.iframeCount} ` +
|
|
378
|
+
`webgl=${String(c.webgl)}/2=${String(c.webgl2)} webgpu=${String(c.webgpu)}` +
|
|
379
|
+
(c.resized !== null ? ` resized=[${c.resized}]` : "") +
|
|
380
|
+
(c.materialized ? ` materialized=${c.materialized} ${c.sceneDiag ?? ""}` : "")
|
|
381
|
+
)
|
|
382
|
+
.join(" | ");
|
|
383
|
+
}
|
|
384
|
+
|
|
385
|
+
export async function renderPdf(request: RenderPdfRequest): Promise<RenderPdfResult> {
|
|
386
|
+
const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
|
|
387
|
+
const executablePath = resolveBrowserExecutable(request.chromeExecutable);
|
|
388
|
+
|
|
389
|
+
if (executablePath === null) {
|
|
390
|
+
throw new Error(
|
|
391
|
+
"No Chrome/Chromium found. Install one (e.g. `npx @puppeteer/browsers install chrome@stable`) or pass --executable-browser <path>."
|
|
392
|
+
);
|
|
393
|
+
}
|
|
394
|
+
|
|
395
|
+
const viewerUrl = buildViewerUrl(request.viewerPageUrl, {
|
|
396
|
+
src: request.documentUrl,
|
|
397
|
+
bookMode: false,
|
|
398
|
+
renderAllPages: true,
|
|
399
|
+
...request.viewerParams
|
|
400
|
+
});
|
|
401
|
+
log.trace("viewerUrl", viewerUrl);
|
|
402
|
+
|
|
403
|
+
const browser = await puppeteer.launch({
|
|
404
|
+
executablePath,
|
|
405
|
+
headless: true,
|
|
406
|
+
args: chromeArgs(request.extraChromeArgs ?? []),
|
|
407
|
+
acceptInsecureCerts: true
|
|
408
|
+
});
|
|
409
|
+
|
|
410
|
+
const startedAt = Date.now();
|
|
411
|
+
let settle: RenderPdfResult["settle"] = null;
|
|
412
|
+
|
|
413
|
+
try {
|
|
414
|
+
const page = await browser.newPage();
|
|
415
|
+
page.setDefaultTimeout(timeoutMs);
|
|
416
|
+
page.setDefaultNavigationTimeout(timeoutMs);
|
|
417
|
+
|
|
418
|
+
page.on("pageerror", (err: unknown) => log.warn(`[render] page error: ${err instanceof Error ? err.message : String(err)}`));
|
|
419
|
+
// Viewer and page errors are the usual reason a render produces nothing.
|
|
420
|
+
// Debug/info console messages (fetch traces from the runtime script) are
|
|
421
|
+
// shown at debug level, so -d traces every page-side request.
|
|
422
|
+
const debugConsole = log.getLevel() <= log.levels.DEBUG;
|
|
423
|
+
page.on("console", (message) => {
|
|
424
|
+
const type = message.type();
|
|
425
|
+
if (type !== "error" && type !== "warn" && !(debugConsole && (type === "debug" || type === "info"))) return;
|
|
426
|
+
const where = message.location();
|
|
427
|
+
log[debugConsole && type !== "error" && type !== "warn" ? "trace" : "warn"](
|
|
428
|
+
`[render] console.${type}: ${message.text()}${where.url === "" ? "" : ` (${where.url})`}`
|
|
429
|
+
);
|
|
430
|
+
});
|
|
431
|
+
page.on("requestfailed", (request) => {
|
|
432
|
+
log.warn(`[render] request failed: ${request.url()} (${request.failure()?.errorText ?? "unknown"})`);
|
|
433
|
+
});
|
|
434
|
+
|
|
435
|
+
// Print media has to be active *before* the document loads: the page's print
|
|
436
|
+
// stylesheet is what gives JS-driven containers their size, and a chart that
|
|
437
|
+
// initialises against a zero-sized box never recovers.
|
|
438
|
+
await page.emulateMediaType("print");
|
|
439
|
+
|
|
440
|
+
await page.goto(viewerUrl, { waitUntil: "domcontentloaded" });
|
|
441
|
+
|
|
442
|
+
// The viewer's contract: coreViewer exists and has finished typesetting.
|
|
443
|
+
await page.waitForFunction(() => (window as { coreViewer?: unknown }).coreViewer !== undefined);
|
|
444
|
+
await page.waitForFunction(() => (window as { coreViewer?: { readyState?: string } }).coreViewer?.readyState === "complete", {
|
|
445
|
+
polling: 500
|
|
446
|
+
});
|
|
447
|
+
|
|
448
|
+
if (request.waitForSettle === true) {
|
|
449
|
+
const handle = await page.waitForFunction(
|
|
450
|
+
() => {
|
|
451
|
+
const settleState = (window as { __vivSettle?: { done?: boolean; reason?: string; at?: number } }).__vivSettle;
|
|
452
|
+
// Pages with mocked/measured async work set __vivReady when painted;
|
|
453
|
+
// Vivliostyle re-runs document scripts in the viewer context, so both
|
|
454
|
+
// live on the same window the renderer polls here.
|
|
455
|
+
const ready = (window as { __vivReady?: boolean }).__vivReady === true;
|
|
456
|
+
if (ready) return { reason: "ready", at: 0 };
|
|
457
|
+
return settleState?.done === true ? { reason: settleState.reason ?? "settled", at: settleState.at ?? 0 } : false;
|
|
458
|
+
},
|
|
459
|
+
{ polling: 200, timeout: timeoutMs }
|
|
460
|
+
);
|
|
461
|
+
const state = (await handle.jsonValue()) as SettleState;
|
|
462
|
+
|
|
463
|
+
settle = { reason: state.reason, waitedMs: Date.now() - startedAt };
|
|
464
|
+
log.trace("settle", settle);
|
|
465
|
+
}
|
|
466
|
+
|
|
467
|
+
// Iframes/canvas/WebGL/WebGPU rasterize as pixels in print-to-PDF: force
|
|
468
|
+
// off-screen frames to paint, redraw HiDPI-aware pages at backing scale.
|
|
469
|
+
try {
|
|
470
|
+
const caps = await prepareForPrint(page, {
|
|
471
|
+
canvasScale: request.canvasScale,
|
|
472
|
+
settleMs: request.canvasSettleMs
|
|
473
|
+
});
|
|
474
|
+
const summary = summarizeCapabilities(caps);
|
|
475
|
+
if (summary !== "") log.info(`[render] frames: ${summary}`);
|
|
476
|
+
if (caps.length > 0 && caps.every((c) => !c.webgpu)) {
|
|
477
|
+
log.trace("[render] WebGPU unavailable in this Chrome (best-effort software rendering)");
|
|
478
|
+
}
|
|
479
|
+
} catch (err) {
|
|
480
|
+
log.warn(`[render] pre-print probe failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
|
|
481
|
+
}
|
|
482
|
+
|
|
483
|
+
const pdf = await page.pdf({
|
|
484
|
+
margin: { top: 0, bottom: 0, left: 0, right: 0 },
|
|
485
|
+
printBackground: true,
|
|
486
|
+
preferCSSPageSize: true,
|
|
487
|
+
tagged: true
|
|
488
|
+
});
|
|
489
|
+
|
|
490
|
+
const stamped = await postProcessPdf(pdf, {
|
|
491
|
+
metadata: pdfMetadata(request),
|
|
492
|
+
...(request.pdfLabel === undefined ? {} : { label: request.pdfLabel }),
|
|
493
|
+
...(request.iccProfile === undefined ? {} : { iccProfile: request.iccProfile, iccProfileName: request.iccProfileName })
|
|
494
|
+
});
|
|
495
|
+
mkdirSync(dirname(request.output), { recursive: true });
|
|
496
|
+
writeFileSync(request.output, stamped);
|
|
497
|
+
|
|
498
|
+
const pageCount = await PDFDocument.load(stamped).then((doc) => doc.getPageCount());
|
|
499
|
+
|
|
500
|
+
return { output: request.output, bytes: stamped.length, pageCount, settle };
|
|
501
|
+
} finally {
|
|
502
|
+
await browser.close();
|
|
503
|
+
}
|
|
504
|
+
}
|
|
Binary file
|
|
@@ -0,0 +1,46 @@
|
|
|
1
|
+
// src/render/viewer.ts
|
|
2
|
+
|
|
3
|
+
// Copyright (c) 2026 Christian Mahnke
|
|
4
|
+
// Licensed under the MIT License.
|
|
5
|
+
|
|
6
|
+
/**
|
|
7
|
+
* Locates the Vivliostyle viewer that renders the document.
|
|
8
|
+
*
|
|
9
|
+
* The viewer is served by our own static server (see src/server.ts) so that the
|
|
10
|
+
* document's origin — and with it the base URI of the scripts the page runs — is
|
|
11
|
+
* the site we serve.
|
|
12
|
+
*/
|
|
13
|
+
|
|
14
|
+
import { existsSync } from "node:fs";
|
|
15
|
+
import { createRequire } from "node:module";
|
|
16
|
+
import { dirname, join, resolve } from "node:path";
|
|
17
|
+
|
|
18
|
+
const require = createRequire(import.meta.url);
|
|
19
|
+
|
|
20
|
+
/** Directory of `@vivliostyle/viewer/lib`, which holds index.html and assets. */
|
|
21
|
+
export function resolveViewerLibDir(): string {
|
|
22
|
+
const candidates: string[] = [];
|
|
23
|
+
|
|
24
|
+
try {
|
|
25
|
+
candidates.push(dirname(require.resolve("@vivliostyle/viewer/package.json")));
|
|
26
|
+
} catch {
|
|
27
|
+
// fall through to the paths below
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
candidates.push(
|
|
31
|
+
resolve(dirname(fileURLOfSelf()), "../node_modules/@vivliostyle/viewer"),
|
|
32
|
+
"/usr/local/lib/node_modules/@vivliostyle/viewer",
|
|
33
|
+
"/usr/lib/node_modules/@vivliostyle/viewer"
|
|
34
|
+
);
|
|
35
|
+
|
|
36
|
+
for (const candidate of candidates) {
|
|
37
|
+
const libDir = join(candidate, "lib");
|
|
38
|
+
if (existsSync(join(libDir, "index.html"))) return libDir;
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
throw new Error("Could not find @vivliostyle/viewer. Install it as a dependency of this package.");
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
function fileURLOfSelf(): string {
|
|
45
|
+
return new URL(import.meta.url).pathname;
|
|
46
|
+
}
|