@cenk1cenk2/md-printer 2.21.0 → 3.1.0

package/dist/services/printer.service.mjs

@@ -0,0 +1,171 @@
+import { DEFAULT_PDF_OPTIONS } from "../constants/template.constants.mjs";
+import { OutputFileType } from "../constants/file.constants.mjs";
+import __decorateMetadata from "../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.mjs";
+import __decorate from "../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.mjs";
+import { I18nService } from "./i18n.service.mjs";
+import { MarkdownService } from "./markdown.service.mjs";
+import { inlineHtml } from "./template/assets.mjs";
+import { RendererService } from "./renderer/renderer.service.mjs";
+import { SignatureService } from "./signature/signature.service.mjs";
+import { TemplateService } from "./template/template.service.mjs";
+import { Injectable } from "@nestjs/common";
+import { basename, dirname, extname, join, resolve } from "path";
+import { FileSystemService, LoggerService } from "@cenk1cenk2/oclif-common";
+import { cloneDeep, mergeWith, uniq } from "es-toolkit";
+import { parse } from "yaml";
+//#region src/services/printer.service.ts
+let PrinterService = class PrinterService {
+	fs;
+	logger;
+	i18n;
+	markdown;
+	template;
+	renderer;
+	signature;
+	constructor(fs, logger, i18n, markdown, template, renderer, signature) {
+		this.fs = fs;
+		this.logger = logger;
+		this.i18n = i18n;
+		this.markdown = markdown;
+		this.template = template;
+		this.renderer = renderer;
+		this.signature = signature;
+		this.logger.setup(this.constructor.name);
+	}
+	async input(flags) {
+		let file;
+		let source;
+		if (flags.file !== void 0) {
+			file = resolve(flags.file);
+			if (!this.fs.exists(file)) throw new Error(`File does not exist: ${file}`);
+			source = await this.fs.read(file);
+		} else source = flags.stdin;
+		const type = flags.inputFiletype ?? (file ? extname(file).replace(/^\./, "") : "md");
+		if (type === "yaml" || type === "yml") return {
+			file,
+			directory: file ? dirname(file) : process.cwd(),
+			markdown: {
+				type: "root",
+				children: []
+			},
+			data: parse(source) ?? {}
+		};
+		return {
+			file,
+			directory: file ? dirname(file) : process.cwd(),
+			...this.markdown.parse(source)
+		};
+	}
+	async options(flags, input) {
+		const { data } = input;
+		const template = this.template.resolve(flags.template ?? data.template ?? "default");
+		const settings = await this.template.settings(template);
+		const output = flags.outputFiletype ?? data.outputFiletype ?? "pdf";
+		if (!Object.values(OutputFileType).includes(output)) throw new Error(`Output file type is not supported: ${output}, use one of ${Object.values(OutputFileType).join(", ")}.`);
+		const dest = flags.stdout ? void 0 : flags.output ?? data.dest ?? (input.file ? `${basename(input.file, extname(input.file))}.${output}` : void 0);
+		return {
+			template,
+			output,
+			dest: dest && resolve(dest),
+			title: flags.title ?? data.documentTitle,
+			language: flags.language ?? data.language ?? settings.i18n?.language ?? "en",
+			continuous: flags.continuous || data.continuous === true || settings.continuous === true,
+			media: settings.media ?? "screen",
+			highlight: settings.highlightStyle ?? "atom-one-dark",
+			pdf: this.pdfOptions(settings.pdfOptions, data.pdfOptions),
+			i18n: settings.i18n ?? {},
+			sign: this.signOptions(flags, settings.sign, data.sign)
+		};
+	}
+	bundle(options) {
+		return this.template.bundle(options.template);
+	}
+	/**
+	* Resolves the signing time and the visible signature description, which the template renders before the document is signed.
+	*/
+	async prepare(ctx) {
+		if (!ctx.options.sign.enabled) return;
+		if (ctx.options.output !== "pdf") throw new Error("Signing is only supported for PDF output.");
+		this.signature.adapter(ctx.options.sign.provider);
+		ctx.signingTime = /* @__PURE__ */ new Date();
+		ctx.certificate = ctx.options.sign.certificate ? await this.signature.certificate(ctx.options.sign.certificate, ctx.signingTime) : void 0;
+		ctx.signature = this.signature.describe(ctx.signingTime, ctx.certificate);
+	}
+	async document(ctx, bundle) {
+		const { input, options } = ctx;
+		const document = await this.template.render(options.template, bundle, {
+			data: input.data,
+			t: await this.i18n.load(join(options.template, "i18n"), {
+				...options.i18n,
+				language: options.language
+			}),
+			language: options.language,
+			signature: ctx.signature
+		}, this.markdown.resolve(input.markdown, bundle.directives), {
+			language: options.language,
+			title: options.title,
+			fallbackTitle: input.file && basename(input.file, extname(input.file)),
+			highlight: options.highlight
+		});
+		this.logger.debug("Rendered document: %d bytes, header: %d bytes, footer: %d bytes", document.html.length, document.header?.length ?? 0, document.footer?.length ?? 0);
+		return document;
+	}
+	async output(ctx, document) {
+		if (ctx.options.output === "html") {
+			const { content, assets } = await inlineHtml(document.html, ctx.input.directory, { confined: true });
+			return {
+				content: Buffer.from(content),
+				assets
+			};
+		}
+		const { pdf, assets } = await this.renderer.render(document, {
+			directory: ctx.input.directory,
+			pdf: ctx.options.pdf,
+			media: ctx.options.media,
+			continuous: ctx.options.continuous
+		});
+		return {
+			content: pdf,
+			assets
+		};
+	}
+	sign(ctx, pdf) {
+		return this.signature.sign(pdf, {
+			...ctx.options.sign,
+			date: ctx.signingTime,
+			certificate: ctx.certificate
+		});
+	}
+	signOptions(flags, ...sources) {
+		return {
+			...Object.assign({}, ...sources),
+			...flags.sign ? { enabled: true } : {},
+			...flags.signProvider ? { provider: flags.signProvider } : {},
+			...flags.signCertificate ? { certificate: flags.signCertificate } : {}
+		};
+	}
+	pdfOptions(...sources) {
+		const pdf = sources.reduce((merged, source) => mergeWith(merged, source ?? {}, (current, value) => Array.isArray(current) && Array.isArray(value) ? uniq([...current, ...value]) : void 0), cloneDeep(DEFAULT_PDF_OPTIONS));
+		if (typeof pdf.margin === "string") {
+			const [top, right = top, bottom = top, left = right] = pdf.margin.trim().split(/\s+/);
+			pdf.margin = {
+				top,
+				right,
+				bottom,
+				left
+			};
+		}
+		return pdf;
+	}
+};
+PrinterService = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [
+	typeof FileSystemService === "undefined" ? Object : FileSystemService,
+	typeof LoggerService === "undefined" ? Object : LoggerService,
+	typeof I18nService === "undefined" ? Object : I18nService,
+	typeof MarkdownService === "undefined" ? Object : MarkdownService,
+	typeof TemplateService === "undefined" ? Object : TemplateService,
+	typeof RendererService === "undefined" ? Object : RendererService,
+	typeof SignatureService === "undefined" ? Object : SignatureService
+])], PrinterService);
+//#endregion
+export { PrinterService };

package/dist/services/renderer/browser.mjs

@@ -0,0 +1,41 @@
+import which from "which";
+//#region src/services/renderer/browser.ts
+var BrowserNotFoundError = class extends Error {
+	tried;
+	constructor(tried) {
+		super([
+			"Can not find a Chromium-based browser to print with.",
+			`Tried: ${tried.join(", ")}`,
+			"Pass --browser <path> or set PUPPETEER_EXECUTABLE_PATH."
+		].join("\n"));
+		this.tried = tried;
+	}
+};
+/**
+* Resolves the browser executable: explicit path, environment overrides, then Brave, Chrome, Chromium and Edge from PATH.
+*/
+function discoverBrowser(explicit, env) {
+	const candidates = explicit ? [explicit] : [
+		env.PUPPETEER_EXECUTABLE_PATH,
+		env.CHROME_PATH,
+		"brave",
+		"brave-browser",
+		"brave-browser-stable",
+		"google-chrome-stable",
+		"google-chrome",
+		"chromium",
+		"chromium-browser",
+		"microsoft-edge-stable",
+		"microsoft-edge"
+	].filter(Boolean);
+	for (const candidate of candidates) {
+		const path = which.sync(candidate, {
+			path: env.PATH,
+			nothrow: true
+		});
+		if (path) return path;
+	}
+	throw new BrowserNotFoundError(candidates);
+}
+//#endregion
+export { BrowserNotFoundError, discoverBrowser };

package/dist/services/renderer/browser.service.mjs

@@ -0,0 +1,56 @@
+import { PRINTER_MODULE_OPTIONS } from "../../constants/template.constants.mjs";
+import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.mjs";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.mjs";
+import { discoverBrowser } from "./browser.mjs";
+import __decorateParam from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateParam.mjs";
+import { Inject, Injectable } from "@nestjs/common";
+import { LoggerService } from "@cenk1cenk2/oclif-common";
+import puppeteer from "puppeteer-core";
+//#region src/services/renderer/browser.service.ts
+let BrowserService = class BrowserService {
+	logger;
+	options;
+	browser;
+	constructor(logger, options) {
+		this.logger = logger;
+		this.options = options;
+		this.logger.setup(this.constructor.name);
+	}
+	executable() {
+		return discoverBrowser(this.options.browser, process.env);
+	}
+	get() {
+		this.browser ??= this.launch().catch((err) => {
+			this.browser = void 0;
+			throw err;
+		});
+		return this.browser;
+	}
+	async onModuleDestroy() {
+		const browser = await this.browser?.catch(() => void 0);
+		this.browser = void 0;
+		await browser?.close();
+	}
+	async launch() {
+		const executablePath = this.executable();
+		this.logger.debug("Launching browser: %s", executablePath);
+		const browser = await puppeteer.launch({
+			executablePath,
+			handleSIGINT: false,
+			handleSIGTERM: false,
+			handleSIGHUP: false,
+			args: process.getuid?.() === 0 || process.env.CI ? ["--no-sandbox"] : []
+		});
+		browser.on("disconnected", () => {
+			this.browser = void 0;
+		});
+		return browser;
+	}
+};
+BrowserService = __decorate([
+	Injectable(),
+	__decorateParam(1, Inject(PRINTER_MODULE_OPTIONS)),
+	__decorateMetadata("design:paramtypes", [typeof LoggerService === "undefined" ? Object : LoggerService, Object])
+], BrowserService);
+//#endregion
+export { BrowserService };

package/dist/services/renderer/renderer.service.mjs

@@ -0,0 +1,198 @@
+import { PAGE_BREAK_CLASS } from "../../constants/template.constants.mjs";
+import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.mjs";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.mjs";
+import { BrowserService } from "./browser.service.mjs";
+import { mimeType, resolveConfined } from "../template/assets.mjs";
+import { Injectable } from "@nestjs/common";
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { LoggerService } from "@cenk1cenk2/oclif-common";
+import { fileURLToPath, pathToFileURL } from "url";
+//#region src/services/renderer/renderer.service.ts
+var _RendererService;
+let RendererService = class RendererService {
+	static {
+		_RendererService = this;
+	}
+	logger;
+	browser;
+	static ORIGIN = "http://md-printer.local";
+	static DOCUMENT = "/__document.html";
+	static SECTION = "data-md-printer-section";
+	constructor(logger, browser) {
+		this.logger = logger;
+		this.browser = browser;
+		this.logger.setup(this.constructor.name);
+	}
+	async render(rendered, options) {
+		const page = await (await this.browser.get()).newPage();
+		try {
+			const assets = await this.load(page, rendered, options);
+			const sections = await this.split(page);
+			const pdf = options.continuous ? await this.continuous(page, options, sections) : await this.paginated(page, rendered, options);
+			return {
+				pdf: Buffer.from(pdf),
+				assets
+			};
+		} finally {
+			await page.close();
+		}
+	}
+	async load(page, rendered, options) {
+		const assets = /* @__PURE__ */ new Set();
+		const base = resolve(options.directory);
+		await page.setRequestInterception(true);
+		page.on("request", (request) => {
+			this.intercept(request, rendered, base, assets).catch(async (err) => {
+				this.logger.debug("Request handling failed for %s: %s", request.url(), err);
+				await request.abort().catch(() => void 0);
+			});
+		});
+		await page.emulateMediaType(options.media);
+		await page.goto(_RendererService.ORIGIN + _RendererService.DOCUMENT, { waitUntil: "load" });
+		await page.evaluate(async () => {
+			for (const image of Array.from(document.images)) image.loading = "eager";
+			await document.fonts.ready;
+			await Promise.all(Array.from(document.images).map((image) => image.decode().catch(() => void 0)));
+		});
+		return [...assets];
+	}
+	async intercept(request, rendered, base, assets) {
+		const url = new URL(request.url());
+		if (url.origin !== _RendererService.ORIGIN) await request.continue();
+		else if (url.pathname === "/favicon.ico") await request.respond({
+			status: 204,
+			body: ""
+		});
+		else if (url.pathname === _RendererService.DOCUMENT) await request.respond({
+			status: 200,
+			contentType: "text/html; charset=utf-8",
+			body: rendered.html
+		});
+		else {
+			const path = fileURLToPath(new URL(`.${url.pathname}`, pathToFileURL(`${base}/`)));
+			const confined = await resolveConfined(path, base);
+			const body = confined && await readFile(confined).catch(() => void 0);
+			if (body) {
+				assets.add(path);
+				await request.respond({
+					status: 200,
+					contentType: mimeType(path),
+					body
+				});
+			} else {
+				this.logger.warn("Can not load asset: %s", path);
+				await request.respond({
+					status: 404,
+					body: ""
+				});
+			}
+		}
+	}
+	/**
+	* Cuts the body into top-level sections at every page break, cloning the containers a break sits in, so a break works anywhere: inside
+	* flex or grid layouts, where CSS fragmentation ignores it, and in continuous mode, where every section becomes a page of its own height.
+	*/
+	split(page) {
+		return page.evaluate((selector, attribute) => {
+			const markers = Array.from(document.body.querySelectorAll(selector));
+			if (!markers.length) return 1;
+			const sections = markers.map((marker) => {
+				const range = document.createRange();
+				const section = document.createElement("div");
+				range.setStart(document.body, 0);
+				range.setEndBefore(marker);
+				section.append(range.extractContents());
+				marker.remove();
+				return section;
+			});
+			sections.push(document.createElement("div"));
+			sections.at(-1).append(...Array.from(document.body.childNodes));
+			sections.forEach((section, index) => section.setAttribute(attribute, String(index)));
+			document.body.replaceChildren(...sections);
+			const style = document.createElement("style");
+			style.textContent = `[${attribute}]:not(:last-child) { break-after: page; }`;
+			document.head.append(style);
+			return sections.length;
+		}, `.${PAGE_BREAK_CLASS}`, _RendererService.SECTION);
+	}
+	paginated(page, rendered, options) {
+		return page.pdf({
+			...options.pdf,
+			displayHeaderFooter: options.pdf.displayHeaderFooter ?? Boolean(rendered.header || rendered.footer),
+			headerTemplate: rendered.header ?? "<span></span>",
+			footerTemplate: rendered.footer ?? "<span></span>"
+		});
+	}
+	/**
+	* Prints everything as one tall page. Chrome itself resolves the paper size (from a one page probe print) and the margins (as CSS lengths),
+	* so md-printer never has to know paper formats or length units.
+	*/
+	async continuous(page, options, sections) {
+		const [, points] = Buffer.from(await page.pdf({
+			...options.pdf,
+			displayHeaderFooter: false,
+			pageRanges: "1"
+		})).toString("latin1").match(/\/MediaBox\s*\[\s*[\d.]+\s+[\d.]+\s+([\d.]+)/);
+		const width = Math.round(Number(points) * 96 / 72);
+		const margin = await page.evaluate((lengths) => {
+			const probe = document.createElement("div");
+			probe.style.position = "absolute";
+			probe.style.visibility = "hidden";
+			Object.assign(probe.style, {
+				marginTop: lengths?.top,
+				marginRight: lengths?.right,
+				marginBottom: lengths?.bottom,
+				marginLeft: lengths?.left
+			});
+			document.body.append(probe);
+			const style = getComputedStyle(probe);
+			const resolved = {
+				top: parseFloat(style.marginTop),
+				right: parseFloat(style.marginRight),
+				bottom: parseFloat(style.marginBottom),
+				left: parseFloat(style.marginLeft)
+			};
+			probe.remove();
+			return resolved;
+		}, Object.fromEntries(Object.entries(options.pdf.margin ?? {}).map(([side, length]) => [side, typeof length === "number" ? `${length}px` : length])));
+		await page.setViewport({
+			width: Math.max(Math.round(width - margin.left - margin.right), 1),
+			height: 800
+		});
+		const totals = (await page.evaluate(async (attribute, single) => {
+			await document.fonts.ready;
+			return (single ? [document.body] : Array.from(document.body.querySelectorAll(`:scope > [${attribute}]`))).map((element) => {
+				const top = element.getBoundingClientRect().top;
+				return Math.max(element.scrollHeight, single ? document.documentElement.scrollHeight : 0, ...Array.from(element.querySelectorAll("*")).map((child) => child.getBoundingClientRect().bottom - top));
+			});
+		}, _RendererService.SECTION, sections === 1)).map((height) => Math.ceil(height + margin.top + margin.bottom + 96 / 2.54));
+		if (totals.some((total) => total * .75 > 65535)) {
+			this.logger.warn("Content is %dpx tall, which is more than a single PDF page can hold, falling back to paginated output.", Math.max(...totals));
+			return page.pdf({
+				...options.pdf,
+				displayHeaderFooter: false
+			});
+		}
+		const pdf = {
+			...options.pdf,
+			displayHeaderFooter: false
+		};
+		delete pdf.format;
+		delete pdf.landscape;
+		if (sections === 1) return page.pdf({
+			...pdf,
+			width: `${width}px`,
+			height: `${totals[0]}px`,
+			pageRanges: "1"
+		});
+		await page.addStyleTag({ content: totals.map((total, index) => `@page md-printer-${index} { size: ${width}px ${total}px; } [${_RendererService.SECTION}="${index}"] { page: md-printer-${index}; }`).join("\n") });
+		return page.pdf({
+			...pdf,
+			preferCSSPageSize: true
+		});
+	}
+};
+RendererService = _RendererService = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof LoggerService === "undefined" ? Object : LoggerService, typeof BrowserService === "undefined" ? Object : BrowserService])], RendererService);
+//#endregion
+export { RendererService };