hdoc-tools 0.51.0 → 0.52.1

package/.puppeteerrc.cjs

@@ -0,0 +1,12 @@
+// Disable Puppeteer's own bundled browser download (install.mjs). hdoc-tools
+// provisions Chrome + chrome-headless-shell itself via hdoc-install-browser.js,
+// which is idempotent, self-healing and retries — unlike the bundled download,
+// whose single partial-extract failure on some Windows Server boxes aborts the
+// whole `npm install`. Browsers are still fetched, just by our controlled path.
+//
+// Discovered by Puppeteer (cosmiconfig) walking up from node_modules/.../puppeteer
+// to this package root during install. skipDownload only affects provisioning,
+// not where the browser is launched from at runtime.
+module.exports = {
+	skipDownload: true,
+};

package/hdoc-build.js

@@ -11,10 +11,9 @@
 	const hdoc_build_onyx = require(path.join(__dirname, "hdoc-build-onyx.js"));
 	const hdoc_build_pdf = require(path.join(__dirname, "hdoc-build-pdf.js"));
 	const hdoc_index = require(path.join(__dirname, "hdoc-db.js"));
+	const hdoc_mermaid = require(path.join(__dirname, "hdoc-mermaid.js"));
 	const archiver = require("archiver");
 
-	const { execSync } = require("child_process");
-
 	const h_tags_to_search = ["h1", "h2", "h3"];
 	const image_extensions = ["png", "svg", "jpg"];
 
@@ -44,14 +43,6 @@
 		"mermaid-theme.yaml",
 	);
 
-	let mermaid_puppeteer_config_path = path.resolve(
-		templates_path,
-		"mermaid-puppeteer-config.json",
-	);
-	if (process.platform === "win32") {
-		mermaid_puppeteer_config_path = `"${mermaid_puppeteer_config_path}"`
-	}
-
 	const pdf_template_path = path.join(__dirname, "templates", "pdf");
 	const ui_css_path = path.join(__dirname, "ui", "css");
 	const pdf_template_file_path = path.join(pdf_template_path, "template.html");
@@ -70,6 +61,10 @@
 	const redirects = {};
 	const static_html_files = [];
 	const mermaid_failures = [];
+	// Mermaid diagrams collected during (synchronous) markdown rendering, then
+	// rendered to SVG in a batch afterwards (puppeteer is async; the markdown-it
+	// highlight callback is not). Keyed by output path to dedupe identical diagrams.
+	const mermaid_queue = new Map();
 
 	let bc = {}; // Breadcrumbs map
 	let book_read_time = 0;
@@ -117,38 +112,30 @@
 		typographer: true,
 		highlight: function (str, lang) {
 			if (lang === "mermaid" && process.env.GITHUB_ACTIONS !== 'true') {
-				try {
-					const tmpInput = hdoc.tmp_file_sync({ postfix: ".mmd" });
-					const outputFileName = `mermaid-${crypto.createHash("sha256").update(str).digest("hex").slice(0, 16)}.svg`;
-					const outputPath = path.join(mermaid_images_path, outputFileName);
-					const outputLink = `/_books/${doc_id}/mermaid-images/${outputFileName}`;
-
-					if (!str.startsWith('---')) {
-						str = '---\n' + fs.readFileSync(mermaid_theme_path, {encoding: 'utf-8'}) + `\n---\n${str}`;
-					}
-
-					fs.writeFileSync(tmpInput.name, str);
-					let cmd = `${__dirname}/node_modules/.bin/mmdc`;
-
-					if (process.platform === "win32") {
-						cmd = `"${cmd}.cmd"`;
-					}
-
-					cmd = `${cmd} -i "${tmpInput.name}" -o "${outputPath}" --backgroundColor transparent --puppeteerConfigFile ${mermaid_puppeteer_config_path}`;
-					console.log(`Generating Mermaid SVG found in ${currentMdFilePath.relativePath} - ${outputPath}`);
-					execSync(cmd);
-
-					if (!fs.existsSync(outputPath)) {
-						throw new Error("mmdc did not generate output");
-					}
-
-					tmpInput.removeCallback();
+				// markdown-it's highlight callback is synchronous, but Mermaid
+				// rendering is async (puppeteer). So here we only *queue* the
+				// diagram and emit the <img> tag pointing at its eventual SVG;
+				// the actual rendering happens in a batch after all markdown has
+				// been processed (see render_mermaid_queue, before validation/zip).
+				const outputFileName = `mermaid-${crypto.createHash("sha256").update(str).digest("hex").slice(0, 16)}.svg`;
+				const outputPath = path.join(mermaid_images_path, outputFileName);
+				const outputLink = `/_books/${doc_id}/mermaid-images/${outputFileName}`;
+
+				let definition = str;
+				if (!definition.startsWith('---')) {
+					definition = '---\n' + fs.readFileSync(mermaid_theme_path, {encoding: 'utf-8'}) + `\n---\n${definition}`;
+				}
 
-					return `<img class="mermaid-diagram" src="${outputLink}" alt="Mermaid Diagram">`;
-				} catch (err) {
-					mermaid_failures.push({path: currentMdFilePath.relativePath, error: err.message});
-					return ``;
+				// Dedupe identical diagrams (same hash -> same output file).
+				if (!mermaid_queue.has(outputPath)) {
+					mermaid_queue.set(outputPath, {
+						definition,
+						outputPath,
+						relativePath: currentMdFilePath.relativePath,
+					});
 				}
+
+				return `<img class="mermaid-diagram" src="${outputLink}" alt="Mermaid Diagram">`;
 			}
 		}
 	});
@@ -197,6 +184,35 @@
 	// generates a PDF, and writes the final HTML to disk ready for indexing.
 	// Markdown files are rendered to HTML first; static HTML files are processed
 	// in place. Both paths share the same post-processing pipeline.
+	// Render every queued-but-not-yet-rendered Mermaid diagram to its SVG file,
+	// reusing the already-open browser. Each diagram's render is memoized on the
+	// queue entry (item.promise), so concurrent transform_file calls and the final
+	// safety flush never render the same diagram twice. Failures are collected in
+	// mermaid_failures rather than thrown, matching the previous mmdc behavior.
+	const flush_mermaid_queue = async () => {
+		await Promise.all(
+			[...mermaid_queue.values()].map((item) => {
+				if (!item.promise) {
+					item.promise = (async () => {
+						try {
+							console.log(`Generating Mermaid SVG found in ${item.relativePath} - ${item.outputPath}`);
+							const svg = await hdoc_mermaid.render_svg(browser, item.definition, {
+								backgroundColor: "transparent",
+							});
+							if (!svg || svg.indexOf("<svg") === -1) {
+								throw new Error("Mermaid produced no SVG output");
+							}
+							fs.writeFileSync(item.outputPath, svg);
+						} catch (err) {
+							mermaid_failures.push({ path: item.relativePath, error: err.message });
+						}
+					})();
+				}
+				return item.promise;
+			}),
+		);
+	};
+
 	const transform_file = async (file_path) => {
 		const is_markdown = path.extname(file_path.path) === '.md';
 		if (is_markdown) conversion_attempted++;
@@ -254,6 +270,11 @@
 			// Render markdown into HTML
 			html_txt = md.render(md_txt);
 
+			// md.render() synchronously queued any Mermaid diagrams in this file.
+			// Render them to SVG now (memoized/deduped) so the files exist before
+			// PDF generation below reads them, and before validation/zipping.
+			await flush_mermaid_queue();
+
 			// Single pass: wrap h2/h3 divs + extract heading, paragraph, read-time.
 			// Replaces separate wrapHContent + getFirstHTMLHeading + get_html_read_time calls.
 			const extracted = hdoc.wrapAndExtract(html_txt, h_tags_to_search);
@@ -1279,6 +1300,10 @@
 			);
 		}
 
+		// Safety net: render any Mermaid diagrams not already flushed during
+		// transform_file (no-op if all are done — rendering is memoized per diagram).
+		await flush_mermaid_queue();
+
 		// Output to console
 		console.log(`\n                MD files found: ${conversion_attempted}`);
 		console.log(`Successfully converted to HTML: ${conversion_success}`);
@@ -1418,7 +1443,7 @@
 				const zip_path = path.join(work_path, `${doc_id}.zip`);
 
 				const output = fs.createWriteStream(zip_path);
-				const archive = archiver("zip");
+				const archive = new archiver.ZipArchive();
 				archive.on("error", (err) => {
 					throw err;
 				});