@cenk1cenk2/md-printer 2.21.0 → 3.0.0

package/dist/services/session/session.service.mjs

@@ -0,0 +1,115 @@
+import "../../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 { PrinterService } from "../printer.service.mjs";
+import { dirname, join, resolve } from "path";
+import { LoggerService } from "@cenk1cenk2/oclif-common";
+import { Injectable } from "@nestjs/common";
+import { EventEmitter } from "events";
+import { watch } from "chokidar";
+import { debounce } from "perfect-debounce";
+//#region src/services/session/session.service.ts
+let SessionService = class SessionService extends EventEmitter {
+	logger;
+	printer;
+	watcher;
+	bundle;
+	stopped = false;
+	modules = /* @__PURE__ */ new Set();
+	watched = /* @__PURE__ */ new Set();
+	version = 0;
+	building;
+	flags;
+	ignored = /* @__PURE__ */ new Set();
+	build = debounce(() => this.stopped ? Promise.resolve() : this.building = this.run(), 50);
+	constructor(logger, printer) {
+		super();
+		this.logger = logger;
+		this.printer = printer;
+		this.logger.setup(this.constructor.name);
+	}
+	async start(flags) {
+		this.flags = flags;
+		this.watcher = watch([], {
+			ignoreInitial: true,
+			atomic: true
+		}).on("change", (path) => this.changed(path)).on("add", (path) => this.changed(path)).on("unlink", (path) => this.changed(path));
+		await this.build();
+	}
+	async onModuleDestroy() {
+		await this.stop();
+	}
+	ignore(path) {
+		this.ignored.add(resolve(path));
+	}
+	async stop() {
+		this.stopped = true;
+		this.build.cancel();
+		await this.building;
+		await this.watcher?.close();
+		this.watcher = void 0;
+	}
+	changed(path) {
+		const file = resolve(path);
+		if (this.ignored.has(file)) return;
+		this.logger.debug("Changed: %s", file);
+		if (this.modules.has(file) || this.bundle && dirname(file) === join(this.bundle.template, "components")) this.bundle = void 0;
+		this.build();
+	}
+	async run() {
+		const started = performance.now();
+		this.emit("building");
+		try {
+			const input = await this.printer.input(this.flags);
+			const options = await this.printer.options(this.flags, input);
+			const template = join(options.template, "Template.svelte");
+			this.modules.add(template);
+			this.watch([
+				input.file,
+				template,
+				join(options.template, "settings.json"),
+				join(options.template, "i18n"),
+				join(options.template, "components"),
+				options.sign.certificate && resolve(options.sign.certificate)
+			]);
+			if (this.bundle?.template !== options.template) this.bundle = {
+				template: options.template,
+				bundle: this.printer.bundle(options)
+			};
+			const cached = this.bundle;
+			const bundle = await cached.bundle.catch((err) => {
+				if (this.bundle === cached) this.bundle = void 0;
+				throw err;
+			});
+			if (this.bundle !== cached) return;
+			this.modules = /* @__PURE__ */ new Set([template, ...bundle.modules]);
+			this.watch(bundle.modules);
+			const ctx = {
+				input,
+				options
+			};
+			await this.printer.prepare(ctx);
+			const document = await this.printer.document(ctx, bundle);
+			this.watch(document.dependencies);
+			const { content, assets } = await this.printer.output(ctx, document);
+			this.watch(assets);
+			this.emit("ready", {
+				version: ++this.version,
+				ms: Math.round(performance.now() - started),
+				ctx,
+				document,
+				output: content
+			});
+		} catch (err) {
+			this.emit("failed", err instanceof Error ? err : new Error(String(err)));
+		}
+	}
+	watch(paths) {
+		const fresh = paths.filter((path) => path && !this.watched.has(path));
+		for (const path of fresh) this.watched.add(path);
+		if (fresh.length) this.watcher.add(fresh);
+	}
+};
+SessionService = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof LoggerService === "undefined" ? Object : LoggerService, typeof PrinterService === "undefined" ? Object : PrinterService])], SessionService);
+//#endregion
+export { SessionService };

package/dist/services/signature/adapters/a-trust.adapter.mjs

@@ -1,23 +1,17 @@
 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 { isLoopbackRequest } from "../../loopback.mjs";
 import { SignatureAdapter } from "../signature.adapter.mjs";
+import { readFile } from "fs/promises";
 import { LoggerService } from "@cenk1cenk2/oclif-common";
 import { Injectable } from "@nestjs/common";
 import { spawn } from "child_process";
-import { readFile } from "fs/promises";
+import { once } from "events";
 import { createServer } from "http";
-
+import getRawBody from "raw-body";
 //#region src/services/signature/adapters/a-trust.adapter.ts
-var _ATrustAdapter;
 let ATrustAdapter = class ATrustAdapter extends SignatureAdapter {
-	static {
-		_ATrustAdapter = this;
-	}
 	logger;
-	static ENDPOINT = "https://service.a-trust.at/mobile/https-security-layer-request/default.aspx";
-	static NAMESPACE = "http://www.buergerkarte.at/namespaces/securitylayer/1.2#";
-	static TIMEOUT = 6e5;
-	static PAGE = "./a-trust.html";
 	name = "a-trust";
 	constructor(logger) {
 		super();
@@ -28,21 +22,20 @@ let ATrustAdapter = class ATrustAdapter extends SignatureAdapter {
 		return this.collect(await this.session(this.request(request)));
 	}
 	request({ pdf, excluded: [from, to] }) {
-		const data = Buffer.from(pdf).fill(0, from, to + 1);
 		return [
 			"<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
-			`<sl:CreateCMSSignatureRequest xmlns:sl="${_ATrustAdapter.NAMESPACE}" Structure="detached" PAdESCompatibility="true">`,
+			"<sl:CreateCMSSignatureRequest xmlns:sl=\"http://www.buergerkarte.at/namespaces/securitylayer/1.2#\" Structure=\"detached\" PAdESCompatibility=\"true\">",
 			"<sl:KeyboxIdentifier>SecureSignatureKeypair</sl:KeyboxIdentifier>",
 			"<sl:DataObject>",
 			"<sl:MetaInfo><sl:MimeType>application/pdf</sl:MimeType></sl:MetaInfo>",
-			`<sl:Content><sl:Base64Content>${data.toString("base64")}</sl:Base64Content></sl:Content>`,
+			`<sl:Content><sl:Base64Content>${Buffer.from(pdf).fill(0, from, to + 1).toString("base64")}</sl:Base64Content></sl:Content>`,
 			`<sl:ExcludedByteRange><sl:From>${from}</sl:From><sl:To>${to}</sl:To></sl:ExcludedByteRange>`,
 			"</sl:DataObject>",
 			"</sl:CreateCMSSignatureRequest>"
 		].join("");
 	}
 	async session(request) {
-		let url = _ATrustAdapter.ENDPOINT;
+		let url = "https://service.a-trust.at/mobile/https-security-layer-request/default.aspx";
 		let response = await fetch(url, {
 			method: "POST",
 			body: new URLSearchParams([["XMLRequest", request]]),
@@ -58,13 +51,15 @@ let ATrustAdapter = class ATrustAdapter extends SignatureAdapter {
 	}
 	async collect(login) {
 		let resolve;
-		let reject;
-		const result = new Promise((done, fail) => {
+		const result = new Promise((done) => {
 			resolve = done;
-			reject = fail;
 		});
-		const page = await readFile(new URL(_ATrustAdapter.PAGE, import.meta.url));
+		const page = await readFile(new URL("./a-trust.html", import.meta.url));
 		const server = createServer(async (req, res) => {
+			if (!isLoopbackRequest(req, req.method === "POST" ? `http://127.0.0.1:${server.address().port}` : void 0)) {
+				res.writeHead(403);
+				return res.end();
+			}
 			if (req.method === "GET" && req.url === "/session") {
 				res.setHeader("content-type", "application/json");
 				res.writeHead(200);
@@ -75,8 +70,14 @@ let ATrustAdapter = class ATrustAdapter extends SignatureAdapter {
 				res.writeHead(200);
 				return res.end(page);
 			}
-			let body = "";
-			for await (const chunk of req) body += chunk;
+			const body = await getRawBody(req, {
+				limit: "1mb",
+				encoding: true
+			}).catch((err) => {
+				res.writeHead(err.status ?? 400);
+				res.end();
+			});
+			if (body === void 0) return;
 			const cms = (body.match(/<(?:\w+:)?CMSSignature>([^<]+)</)?.[1] ?? body).replace(/\s+/g, "");
 			if (!/^MII[A-Za-z0-9+/=]+$/.test(cms)) {
 				res.writeHead(400);
@@ -86,31 +87,20 @@ let ATrustAdapter = class ATrustAdapter extends SignatureAdapter {
 			res.end("Signature received, you can close this tab.");
 			resolve(Buffer.from(cms, "base64"));
 		});
-		await new Promise((done) => server.listen(0, "127.0.0.1", done));
+		server.listen(0, "127.0.0.1");
+		await once(server, "listening");
 		const url = `http://127.0.0.1:${server.address().port}/`;
 		this.logger.info("Sign the document in the browser, then paste the signature back: %s", url);
 		this.open(url);
-		const timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("Timed out waiting for the signature.")), _ATrustAdapter.TIMEOUT);
-		return result.finally(() => {
-			clearTimeout(timeout);
-			server.close();
-		});
+		return result.finally(() => server.close());
 	}
 	open(url) {
-		const [command, ...args] = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? [
-			"cmd",
-			"/c",
-			"start",
-			"",
-			url
-		] : ["xdg-open", url];
-		spawn(command, args, {
+		spawn("xdg-open", [url], {
 			stdio: "ignore",
 			detached: true
 		}).on("error", (err) => this.logger.warn("Can not open the browser, open the link manually: %s", err.message)).unref();
 	}
 };
-ATrustAdapter = _ATrustAdapter = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof LoggerService === "undefined" ? Object : LoggerService])], ATrustAdapter);
-
+ATrustAdapter = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof LoggerService === "undefined" ? Object : LoggerService])], ATrustAdapter);
 //#endregion
-export { ATrustAdapter };
+export { ATrustAdapter };

package/dist/services/signature/index.mjs

@@ -1,5 +1,4 @@
 import { SignatureAdapter } from "./signature.adapter.mjs";
 import { ATrustAdapter } from "./adapters/a-trust.adapter.mjs";
 import { SignatureService } from "./signature.service.mjs";
-
-export { ATrustAdapter, SignatureAdapter, SignatureService };
+export { ATrustAdapter, SignatureAdapter, SignatureService };

package/dist/services/signature/signature.adapter.mjs

@@ -1,5 +1,4 @@
 //#region src/services/signature/signature.adapter.ts
 var SignatureAdapter = class {};
-
 //#endregion
-export { SignatureAdapter };
+export { SignatureAdapter };

package/dist/services/signature/signature.service.mjs

@@ -8,7 +8,6 @@ import { plainAddPlaceholder } from "@signpdf/placeholder-plain";
 import { SUBFILTER_ETSI_CADES_DETACHED, findByteRange, removeTrailingNewLine } from "@signpdf/utils";
 import { X509Certificate } from "crypto";
 import { homedir } from "os";
-
 //#region src/services/signature/signature.service.ts
 var _SignatureService;
 let SignatureService = class SignatureService {
@@ -92,6 +91,5 @@ let SignatureService = class SignatureService {
 	}
 };
 SignatureService = _SignatureService = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof FileSystemService === "undefined" ? Object : FileSystemService, typeof ATrustAdapter === "undefined" ? Object : ATrustAdapter])], SignatureService);
-
 //#endregion
-export { SignatureService };
+export { SignatureService };

package/dist/services/template/Document.svelte

@@ -0,0 +1,21 @@
+<!--
+  @component
+  HTML document around the rendered template body.
+-->
+<script>
+  /** @type {import('@interfaces').DocumentShellProps} */
+  let { lang, title, head, body } = $props()
+</script>
+
+<html {lang}>
+  <head>
+    <meta charset="utf-8" />
+    {#if title !== undefined}
+      <title>{title}</title>
+    {/if}
+    <!-- eslint-disable-next-line svelte/no-at-html-tags -- styles and head elements rendered by md-printer -->
+    {@html head}
+  </head>
+  <!-- eslint-disable-next-line svelte/no-at-html-tags -- the template body rendered by md-printer -->
+  <body>{@html body}</body>
+</html>

package/dist/services/template/Margin.svelte

@@ -0,0 +1,15 @@
+<!--
+  @component
+  Wrapper for a header or footer snippet printed into Chrome's isolated page margin, which ignores the page stylesheet and defaults to a tiny font.
+-->
+<script>
+  /** @type {import('@interfaces').MarginShellProps} */
+  let { styles, body } = $props()
+</script>
+
+<!-- eslint-disable-next-line svelte/no-at-html-tags -- styles collected by md-printer for the isolated margin document -->
+{@html styles}
+<div style="font-size: 10px; width: 100%; box-sizing: border-box; -webkit-print-color-adjust: exact; print-color-adjust: exact">
+  <!-- eslint-disable-next-line svelte/no-at-html-tags -- the header or footer snippet rendered by md-printer -->
+  {@html body}
+</div>

package/dist/services/template/assets.mjs

@@ -0,0 +1,127 @@
+import { readFile, realpath } from "fs/promises";
+import { isAbsolute, relative, sep } from "path";
+import { toHtml } from "hast-util-to-html";
+import { visit } from "unist-util-visit";
+import { fileURLToPath, pathToFileURL } from "url";
+import { fromHtml } from "hast-util-from-html";
+import { transform, transformStyleAttribute } from "lightningcss";
+import mime from "mime";
+import { parseSrcset, stringifySrcset } from "srcset";
+//#region src/services/template/assets.ts
+const REFERENCES = {
+	img: ["src", "srcSet"],
+	source: ["src", "srcSet"],
+	input: ["src"],
+	video: ["poster"],
+	image: ["href", "xLinkHref"]
+};
+function mimeType(path) {
+	return mime.getType(path) ?? "application/octet-stream";
+}
+/**
+* Images and fonts, the assets that can be embedded into a page as data URIs.
+*/
+function isInlinableAsset(path) {
+	return /^(image|font)\//.test(mime.getType(path) ?? "");
+}
+function dataUri(path, content) {
+	return `data:${mimeType(path)};base64,${content.toString("base64")}`;
+}
+/**
+* Resolves symlinks first, so a link inside the directory can not reach a file outside of it.
+*/
+async function resolveConfined(path, base) {
+	const [real, root] = await Promise.all([realpath(path), realpath(base)]).catch(() => []);
+	if (!real) return;
+	const rel = relative(root, real);
+	return rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel) ? void 0 : real;
+}
+/**
+* Replaces local image references in HTML with data URIs: the image attributes, `style` attributes and `<style>` elements.
+* Remote references are fetched as well when `remote` is set, which Chrome's isolated header/footer templates need.
+* Document content is `confined` to its directory, the same rule the PDF renderer applies to the assets a page loads.
+*/
+async function inlineHtml(markup, base, options = {}) {
+	const assets = /* @__PURE__ */ new Set();
+	const inline = inliner(base, options, assets);
+	const tree = fromHtml(markup, { fragment: !/^<!doctype/i.test(markup) });
+	const pending = [];
+	visit(tree, "element", (node) => {
+		const { properties } = node;
+		for (const name of REFERENCES[node.tagName] ?? []) {
+			const value = properties[name];
+			if (typeof value !== "string") continue;
+			pending.push((async () => {
+				properties[name] = name === "srcSet" ? stringifySrcset(await Promise.all(parseSrcset(value).map(async (candidate) => ({
+					...candidate,
+					url: await inline(candidate.url) ?? candidate.url
+				})))) : await inline(value) ?? value;
+			})());
+		}
+		if (typeof properties.style === "string") {
+			const style = properties.style;
+			pending.push(stylesheet(style, inline, true).then((css) => {
+				properties.style = css;
+			}));
+		}
+		if (node.tagName === "style") {
+			for (const child of node.children) if (child.type === "text") pending.push(stylesheet(child.value, inline).then((css) => {
+				child.value = css;
+			}));
+		}
+	});
+	await Promise.all(pending);
+	return {
+		content: toHtml(tree, { characterReferences: { useNamedReferences: true } }),
+		assets: [...assets]
+	};
+}
+/**
+* Replaces local `url()` references in CSS with data URIs, with the same options as `inlineHtml`.
+*/
+async function inlineCss(css, base, options = {}) {
+	const assets = /* @__PURE__ */ new Set();
+	return {
+		content: await stylesheet(css, inliner(base, options, assets)),
+		assets: [...assets]
+	};
+}
+function inliner(base, { remote = false, confined = false, cache = /* @__PURE__ */ new Map() }, assets) {
+	return async (reference) => {
+		const asset = await (cache.get(reference) ?? cache.set(reference, load(reference, base, remote, confined)).get(reference));
+		if (asset?.path) assets.add(asset.path);
+		return asset?.uri;
+	};
+}
+async function stylesheet(css, inline, attribute = false) {
+	const options = {
+		filename: "style.css",
+		code: Buffer.from(css),
+		analyzeDependencies: { preserveImports: true },
+		errorRecovery: true
+	};
+	const { code, dependencies } = attribute ? transformStyleAttribute({
+		...options,
+		analyzeDependencies: true
+	}) : transform(options);
+	return (await Promise.all(dependencies.map(async (dependency) => [`"${dependency.placeholder}"`, JSON.stringify(dependency.type === "url" && await inline(dependency.url) || dependency.url)]))).reduce((result, [placeholder, value]) => result.replace(placeholder, () => value), code.toString());
+}
+async function load(reference, base, remote, confined) {
+	const url = reference.startsWith("#") ? void 0 : URL.parse(reference, pathToFileURL(`${base}${sep}`));
+	if (url?.protocol === "http:" || url?.protocol === "https:") {
+		if (!remote) return;
+		const response = await fetch(url).catch(() => void 0);
+		if (!response?.ok) return;
+		return { uri: `data:${response.headers.get("content-type") ?? mimeType(url.pathname)};base64,${Buffer.from(await response.arrayBuffer()).toString("base64")}` };
+	}
+	if (url?.protocol !== "file:" || url.host) return;
+	const path = fileURLToPath(url);
+	const file = confined ? await resolveConfined(path, base) : path;
+	if (!file || !isInlinableAsset(path)) return;
+	return readFile(file).then((content) => ({
+		uri: dataUri(path, content),
+		path: file
+	}), () => void 0);
+}
+//#endregion
+export { dataUri, inlineCss, inlineHtml, isInlinableAsset, mimeType, resolveConfined };

package/dist/services/template/render.entry.ts

@@ -0,0 +1,32 @@
+import Template from 'md-printer:template'
+import components from 'md-printer:template-components'
+import { render } from 'svelte/server'
+
+import Document from './Document.svelte'
+import Margin from './Margin.svelte'
+import Nodes from '../../components/Nodes.svelte'
+import type { DocumentShellProps, MarginShellProps, MarkdownNode, RenderedPart, TemplateProps } from '@interfaces'
+
+export { components }
+
+/**
+ * Entry of every template bundle, compiled at runtime together with the template it renders.
+ */
+export function part(props: TemplateProps, context: [string, unknown][]): Promise<RenderedPart> {
+  return Promise.resolve(render(Template, { props, context: new Map(context) }))
+}
+
+/**
+ * The markdown as one HTML string, for templates that place it with `{@html content}`. Plain HTML is kept as is, without Svelte's hydration markers.
+ */
+export function content(nodes: MarkdownNode[], context: [string, unknown][]): string {
+  return nodes.map((node) => (node.type === 'html' ? node.html : render(Nodes, { props: { nodes: [node] }, context: new Map(context) }).body)).join('')
+}
+
+export function document(props: DocumentShellProps): string {
+  return `<!doctype html>${render(Document, { props }).body}`
+}
+
+export function margin(props: MarginShellProps): string {
+  return render(Margin, { props }).body
+}

package/dist/services/template/svelte.plugin.mjs

@@ -0,0 +1,66 @@
+import "../../constants/template.constants.mjs";
+import { dataUri, isInlinableAsset } from "./assets.mjs";
+import { readFile, readdir } from "fs/promises";
+import { basename, dirname, extname, join } from "path";
+import { pathToFileURL } from "url";
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { compile, preprocess } from "svelte/compiler";
+//#region src/services/template/svelte.plugin.ts
+/**
+* `svelte` resolves to md-printer's copy, since templates can live outside any `node_modules`. `<style lang="postcss">` blocks are collected
+* instead of compiled per component, so the template's stylesheet goes through Tailwind once. `md-printer:template-components` maps the shared
+* components and the template's `components/*.svelte` by name, the template's winning.
+*/
+function sveltePlugin({ template, components, root, stylesheets }) {
+	const require = createRequire(root);
+	return {
+		name: "md-printer:svelte",
+		resolveId(id) {
+			if (id === "md-printer:template") return template;
+			if (id === "@cenk1cenk2/md-printer/components") return components;
+			if (id === "md-printer:template-components") return `\0${id}`;
+			if (id === "svelte" || id.startsWith("svelte/")) return {
+				id: pathToFileURL(require.resolve(id)).href,
+				external: true
+			};
+			return null;
+		},
+		async load(id) {
+			if (id === `\0md-printer:template-components`) {
+				const directory = join(dirname(template), "components");
+				const files = existsSync(directory) ? (await readdir(directory)).filter((file) => extname(file) === ".svelte").sort() : [];
+				return [
+					`import * as shared from ${JSON.stringify("@cenk1cenk2/md-printer/components")}`,
+					...files.map((file, index) => `import $${index} from ${JSON.stringify(join(directory, file))}`),
+					"const { Markdown, ...builtins } = shared",
+					`export default { ...builtins, ${files.map((file, index) => `${JSON.stringify(basename(file, ".svelte"))}: $${index}`).join(", ")} }`
+				].join("\n");
+			}
+			if (!isInlinableAsset(id)) return null;
+			return `export default ${JSON.stringify(dataUri(id, await readFile(id)))}`;
+		},
+		async transform(code, id) {
+			if (extname(id) !== ".svelte") return null;
+			const { code: source } = await preprocess(code, { style: ({ content, attributes }) => {
+				if (attributes.lang !== "postcss") return;
+				stylesheets.push({
+					file: id,
+					source: content
+				});
+				return { code: "" };
+			} }, { filename: id });
+			const { js } = compile(source, {
+				filename: id,
+				generate: "server",
+				css: "injected"
+			});
+			return {
+				code: js.code,
+				map: js.map
+			};
+		}
+	};
+}
+//#endregion
+export { sveltePlugin };