@openpolicy/renderers 0.0.14

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# @openpolicy/renderers
+
+## 0.0.14
+
+### Patch Changes
+
+- 2372fdb: - Adds @openpolicy/react library.
+  - Adds PDF renderer

package/package.json

@@ -0,0 +1,20 @@
+{
+	"name": "@openpolicy/renderers",
+	"version": "0.0.14",
+	"type": "module",
+	"exports": {
+		".": "./src/index.ts"
+	},
+	"scripts": {
+		"check-types": "tsc --noEmit",
+		"test": "bun test"
+	},
+	"dependencies": {
+		"pdfkit": "^0.18.0"
+	},
+	"devDependencies": {
+		"@openpolicy/core": "workspace:*",
+		"@openpolicy/tooling": "workspace:*",
+		"@types/pdfkit": "^0.17.5"
+	}
+}

package/src/html.test.ts

@@ -0,0 +1,166 @@
+import { expect, test } from "bun:test";
+import type { Document } from "@openpolicy/core";
+import { renderHTML } from "./html";
+
+function doc(sections: Document["sections"]): Document {
+	return { type: "document", policyType: "privacy", sections };
+}
+
+test("renders heading as <h2>", () => {
+	const result = renderHTML(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [{ type: "heading", value: "Introduction" }],
+			},
+		]),
+	);
+	expect(result).toContain("<h2>Introduction</h2>");
+});
+
+test("renders paragraph as <p>", () => {
+	const result = renderHTML(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "paragraph",
+						children: [{ type: "text", value: "Hello world" }],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toContain("<p>Hello world</p>");
+});
+
+test("renders bold as <strong>", () => {
+	const result = renderHTML(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "paragraph",
+						children: [{ type: "bold", value: "Important" }],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toContain("<strong>Important</strong>");
+});
+
+test("renders link as <a>", () => {
+	const result = renderHTML(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "paragraph",
+						children: [
+							{ type: "link", href: "https://example.com", value: "here" },
+						],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toContain('<a href="https://example.com">here</a>');
+});
+
+test("renders heading with level 3 as <h3>", () => {
+	const result = renderHTML(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [{ type: "heading", level: 3, value: "Sub-section" }],
+			},
+		]),
+	);
+	expect(result).toContain("<h3>Sub-section</h3>");
+});
+
+test("renders ordered list as <ol>/<li>", () => {
+	const result = renderHTML(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "list",
+						ordered: true,
+						items: [
+							{
+								type: "listItem",
+								children: [{ type: "text", value: "First" }],
+							},
+							{
+								type: "listItem",
+								children: [{ type: "text", value: "Second" }],
+							},
+						],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toContain("<ol>");
+	expect(result).toContain("<li>First</li>");
+	expect(result).toContain("<li>Second</li>");
+});
+
+test("renders italic as <em>", () => {
+	const result = renderHTML(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "paragraph",
+						children: [{ type: "italic", value: "emphasis" }],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toContain("<em>emphasis</em>");
+});
+
+test("renders list as <ul>/<li>", () => {
+	const result = renderHTML(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "list",
+						items: [
+							{
+								type: "listItem",
+								children: [{ type: "text", value: "Alpha" }],
+							},
+							{
+								type: "listItem",
+								children: [{ type: "text", value: "Beta" }],
+							},
+						],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toContain("<ul>");
+	expect(result).toContain("<li>Alpha</li>");
+	expect(result).toContain("<li>Beta</li>");
+});

package/src/html.ts

@@ -0,0 +1,65 @@
+import type {
+	Document,
+	InlineNode,
+	ListItemNode,
+	ListNode,
+} from "@openpolicy/core";
+
+function escapeHtml(str: string): string {
+	return str
+		.replace(/&/g, "&")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;");
+}
+
+function renderInline(node: InlineNode): string {
+	switch (node.type) {
+		case "text":
+			return escapeHtml(node.value);
+		case "bold":
+			return `<strong>${escapeHtml(node.value)}</strong>`;
+		case "italic":
+			return `<em>${escapeHtml(node.value)}</em>`;
+		case "link":
+			return `<a href="${escapeHtml(node.href)}">${escapeHtml(node.value)}</a>`;
+	}
+}
+
+function renderListItem(item: ListItemNode): string {
+	const content = item.children
+		.map((child) =>
+			child.type === "list"
+				? renderList(child)
+				: renderInline(child as InlineNode),
+		)
+		.join("");
+	return `<li>${content}</li>`;
+}
+
+function renderList(node: ListNode): string {
+	const tag = node.ordered ? "ol" : "ul";
+	const items = node.items.map(renderListItem).join("");
+	return `<${tag}>${items}</${tag}>`;
+}
+
+export function renderHTML(doc: Document): string {
+	return doc.sections
+		.map((section) => {
+			// biome-ignore lint/suspicious/useIterableCallbackReturn: typed
+			const blocks = section.content.map((node) => {
+				switch (node.type) {
+					case "heading": {
+						const level = node.level ?? 2;
+						return `<h${level}>${escapeHtml(node.value)}</h${level}>`;
+					}
+					case "paragraph":
+						return `<p>${node.children.map(renderInline).join("")}</p>`;
+					case "list":
+						return renderList(node);
+				}
+			});
+			return blocks.join("\n");
+		})
+		.join("\n");
+}

package/src/index.test.ts

@@ -0,0 +1,28 @@
+import { expect, test } from "bun:test";
+import type { PolicyInput } from "@openpolicy/core";
+import { compilePolicy } from "./index";
+
+const input: PolicyInput = {
+	type: "privacy",
+	effectiveDate: "2026-01-01",
+	company: {
+		name: "Acme Inc.",
+		legalName: "Acme Corporation",
+		address: "123 Main St, Springfield, USA",
+		contact: "privacy@acme.com",
+	},
+	dataCollected: { "Account Information": ["Name", "Email"] },
+	legalBasis: "Legitimate interests",
+	retention: { "Account data": "Until deletion" },
+	cookies: { essential: true, analytics: false, marketing: false },
+	thirdParties: [],
+	userRights: ["access"],
+	jurisdictions: ["us"],
+};
+
+test("compilePolicy routes privacy input to markdown", async () => {
+	const results = await compilePolicy(input);
+	expect(results).toBeArray();
+	expect(results[0]?.format).toBe("markdown");
+	expect(results[0]?.content).toContain("Acme Inc.");
+});

package/src/index.ts

@@ -0,0 +1,63 @@
+import type {
+	CompileOptions,
+	OutputFormat,
+	PolicyInput,
+} from "@openpolicy/core";
+import { compile } from "@openpolicy/core";
+
+export { renderHTML } from "./html";
+export { renderMarkdown } from "./markdown";
+export { renderPDF } from "./pdf";
+
+function filenameFor(type: PolicyInput["type"], ext: string): string {
+	switch (type) {
+		case "privacy":
+			return `privacy-policy.${ext}`;
+		case "terms":
+			return `terms-of-service.${ext}`;
+		case "cookie":
+			return `cookie-policy.${ext}`;
+	}
+}
+
+export async function compilePolicy(
+	input: PolicyInput,
+	options?: CompileOptions,
+): Promise<
+	{ format: OutputFormat; filename: string; content: string | Buffer }[]
+> {
+	const doc = compile(input);
+	const formats = options?.formats ?? ["markdown"];
+	return Promise.all(
+		formats.map(async (format) => {
+			switch (format) {
+				case "markdown": {
+					const { renderMarkdown } = await import("./markdown");
+					return {
+						format,
+						filename: filenameFor(input.type, "md"),
+						content: renderMarkdown(doc),
+					};
+				}
+				case "html": {
+					const { renderHTML } = await import("./html");
+					return {
+						format,
+						filename: filenameFor(input.type, "html"),
+						content: renderHTML(doc),
+					};
+				}
+				case "pdf": {
+					const { renderPDF } = await import("./pdf");
+					return {
+						format,
+						filename: filenameFor(input.type, "pdf"),
+						content: await renderPDF(doc),
+					};
+				}
+				default:
+					throw new Error(`Format not yet implemented: ${format}`);
+			}
+		}),
+	);
+}

package/src/markdown.test.ts

@@ -0,0 +1,230 @@
+import { expect, test } from "bun:test";
+import type { Document } from "@openpolicy/core";
+import { renderMarkdown } from "./markdown";
+
+function doc(sections: Document["sections"]): Document {
+	return { type: "document", policyType: "privacy", sections };
+}
+
+test("renders a heading node", () => {
+	const result = renderMarkdown(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [{ type: "heading", value: "Introduction" }],
+			},
+		]),
+	);
+	expect(result).toBe("## Introduction");
+});
+
+test("renders a paragraph with text", () => {
+	const result = renderMarkdown(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "paragraph",
+						children: [{ type: "text", value: "Hello world" }],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toBe("Hello world");
+});
+
+test("renders bold and link inline nodes", () => {
+	const result = renderMarkdown(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "paragraph",
+						children: [
+							{ type: "bold", value: "Important" },
+							{ type: "text", value: ": see " },
+							{ type: "link", href: "https://example.com", value: "here" },
+						],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toBe("**Important**: see [here](https://example.com)");
+});
+
+test("renders a list with items", () => {
+	const result = renderMarkdown(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "list",
+						items: [
+							{
+								type: "listItem",
+								children: [{ type: "text", value: "Alpha" }],
+							},
+							{
+								type: "listItem",
+								children: [{ type: "text", value: "Beta" }],
+							},
+						],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toBe("- Alpha\n- Beta");
+});
+
+test("renders nested list with indented items", () => {
+	const result = renderMarkdown(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "list",
+						items: [
+							{
+								type: "listItem",
+								children: [
+									{ type: "text", value: "Parent" },
+									{
+										type: "list",
+										items: [
+											{
+												type: "listItem",
+												children: [{ type: "text", value: "Child" }],
+											},
+										],
+									},
+								],
+							},
+						],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toBe("- Parent\n  - Child");
+});
+
+test("joins multiple sections with dividers", () => {
+	const result = renderMarkdown(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [{ type: "heading", value: "One" }],
+			},
+			{
+				type: "section",
+				id: "s2",
+				content: [{ type: "heading", value: "Two" }],
+			},
+		]),
+	);
+	expect(result).toBe("## One\n\n---\n\n## Two");
+});
+
+test("renders heading with level 3", () => {
+	const result = renderMarkdown(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [{ type: "heading", level: 3, value: "Sub-section" }],
+			},
+		]),
+	);
+	expect(result).toBe("### Sub-section");
+});
+
+test("renders heading with level 1", () => {
+	const result = renderMarkdown(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [{ type: "heading", level: 1, value: "Title" }],
+			},
+		]),
+	);
+	expect(result).toBe("# Title");
+});
+
+test("renders ordered list with numbered items", () => {
+	const result = renderMarkdown(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "list",
+						ordered: true,
+						items: [
+							{
+								type: "listItem",
+								children: [{ type: "text", value: "First" }],
+							},
+							{
+								type: "listItem",
+								children: [{ type: "text", value: "Second" }],
+							},
+						],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toBe("1. First\n2. Second");
+});
+
+test("renders italic inline node", () => {
+	const result = renderMarkdown(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{
+						type: "paragraph",
+						children: [{ type: "italic", value: "emphasis" }],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toBe("_emphasis_");
+});
+
+test("joins multiple content nodes within a section with blank lines", () => {
+	const result = renderMarkdown(
+		doc([
+			{
+				type: "section",
+				id: "s1",
+				content: [
+					{ type: "heading", value: "Title" },
+					{
+						type: "paragraph",
+						children: [{ type: "text", value: "Body text." }],
+					},
+				],
+			},
+		]),
+	);
+	expect(result).toBe("## Title\n\nBody text.");
+});

package/src/markdown.ts

@@ -0,0 +1,70 @@
+import type {
+	Document,
+	InlineNode,
+	ListItemNode,
+	ListNode,
+} from "@openpolicy/core";
+
+function renderInline(node: InlineNode): string {
+	switch (node.type) {
+		case "text":
+			return node.value;
+		case "bold":
+			return `**${node.value}**`;
+		case "italic":
+			return `_${node.value}_`;
+		case "link":
+			return `[${node.value}](${node.href})`;
+	}
+}
+
+function renderListItem(
+	item: ListItemNode,
+	indent = "",
+	ordered = false,
+	index = 0,
+): string {
+	const parts: string[] = [];
+	let nestedList: ListNode | null = null;
+	for (const child of item.children) {
+		if (child.type === "list") {
+			nestedList = child;
+		} else {
+			parts.push(renderInline(child));
+		}
+	}
+	const bullet = ordered ? `${index + 1}.` : "-";
+	const line = `${indent}${bullet} ${parts.join("")}`;
+	if (nestedList) {
+		const nested = nestedList.items
+			.map((i, idx) =>
+				renderListItem(i, `${indent}  `, nestedList!.ordered, idx),
+			)
+			.join("\n");
+		return `${line}\n${nested}`;
+	}
+	return line;
+}
+
+export function renderMarkdown(doc: Document): string {
+	return doc.sections
+		.map((section) => {
+			// biome-ignore lint/suspicious/useIterableCallbackReturn: typed
+			const blocks = section.content.map((node) => {
+				switch (node.type) {
+					case "heading": {
+						const hashes = "#".repeat(node.level ?? 2);
+						return `${hashes} ${node.value}`;
+					}
+					case "paragraph":
+						return node.children.map(renderInline).join("");
+					case "list":
+						return node.items
+							.map((item, idx) => renderListItem(item, "", node.ordered, idx))
+							.join("\n");
+				}
+			});
+			return blocks.join("\n\n");
+		})
+		.join("\n\n---\n\n");
+}

package/src/pdf.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from "bun:test";
+import { compile } from "@openpolicy/core";
+import { renderPDF } from "./pdf";
+
+const input = {
+	type: "privacy" as const,
+	effectiveDate: "2026-01-01",
+	company: {
+		name: "Acme Inc.",
+		legalName: "Acme Corporation",
+		address: "123 Main St",
+		contact: "privacy@acme.com",
+	},
+	dataCollected: { "Account Information": ["Name", "Email"] },
+	legalBasis: "Legitimate interests",
+	retention: { "Account data": "Until deletion" },
+	cookies: { essential: true, analytics: false, marketing: false },
+	thirdParties: [],
+	userRights: ["access" as const],
+	jurisdictions: ["us" as const],
+};
+
+test("renderPDF returns a Buffer", async () => {
+	const doc = compile(input);
+	const result = await renderPDF(doc);
+	expect(result).toBeInstanceOf(Buffer);
+	expect(result.length).toBeGreaterThan(100);
+});
+
+test("renderPDF output begins with PDF magic bytes", async () => {
+	const doc = compile(input);
+	const result = await renderPDF(doc);
+	expect(result.slice(0, 5).toString("ascii")).toBe("%PDF-");
+});

package/src/pdf.ts

@@ -0,0 +1,158 @@
+import type {
+	Document,
+	DocumentSection,
+	InlineNode,
+	ListItemNode,
+	ListNode,
+} from "@openpolicy/core";
+import PDFDocument from "pdfkit";
+
+const FONT_REGULAR = "Helvetica";
+const FONT_BOLD = "Helvetica-Bold";
+const FONT_ITALIC = "Helvetica-Oblique";
+const SIZE_HEADING_BASE = 16;
+const SIZE_BODY = 11;
+const COLOR_BODY = "#374151";
+const COLOR_HEADING = "#111827";
+const COLOR_LINK = "#2563eb";
+
+function headingSize(level: number): number {
+	// H1=16, H2=14, H3=13, H4=12, H5=11, H6=10
+	return Math.max(10, SIZE_HEADING_BASE - (level - 1) * 1.5);
+}
+
+function renderInlineNodes(
+	doc: InstanceType<typeof PDFDocument>,
+	nodes: InlineNode[],
+): void {
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		const continued = i < nodes.length - 1;
+		switch (node!.type) {
+			case "text":
+				doc
+					.font(FONT_REGULAR)
+					.fillColor(COLOR_BODY)
+					.text(node!.value, { continued });
+				break;
+			case "bold":
+				doc
+					.font(FONT_BOLD)
+					.fillColor(COLOR_HEADING)
+					.text(node!.value, { continued });
+				break;
+			case "italic":
+				doc
+					.font(FONT_ITALIC)
+					.fillColor(COLOR_BODY)
+					.text(node!.value, { continued });
+				break;
+			case "link":
+				doc
+					.font(FONT_REGULAR)
+					.fillColor(COLOR_LINK)
+					.text(node!.value, { continued, link: node!.href, underline: true });
+				doc.fillColor(COLOR_BODY);
+				break;
+		}
+	}
+}
+
+function renderListItem(
+	doc: InstanceType<typeof PDFDocument>,
+	item: ListItemNode,
+	depth: number,
+	ordered: boolean,
+	index: number,
+): void {
+	const indent = doc.page.margins.left + 10 + depth * 15;
+	const bullet = ordered ? `${index + 1}.` : depth === 0 ? "•" : "◦";
+
+	const inlineNodes = item.children.filter(
+		(c): c is InlineNode => c.type !== "list",
+	);
+	const nested =
+		item.children.find((c): c is ListNode => c.type === "list") ?? null;
+
+	doc
+		.font(FONT_REGULAR)
+		.fontSize(SIZE_BODY)
+		.fillColor(COLOR_BODY)
+		.text(`${bullet} `, { continued: true, indent });
+
+	if (inlineNodes.length > 0) {
+		renderInlineNodes(doc, inlineNodes);
+	} else {
+		doc.text("");
+	}
+
+	if (nested) {
+		for (let i = 0; i < nested.items.length; i++) {
+			renderListItem(
+				doc,
+				nested.items[i]!,
+				depth + 1,
+				nested.ordered ?? false,
+				i,
+			);
+		}
+	}
+}
+
+function renderSection(
+	doc: InstanceType<typeof PDFDocument>,
+	section: DocumentSection,
+	isFirst: boolean,
+): void {
+	if (!isFirst) {
+		doc.moveDown(0.5);
+		doc
+			.moveTo(doc.page.margins.left, doc.y)
+			.lineTo(doc.page.width - doc.page.margins.right, doc.y)
+			.strokeColor("#e5e7eb")
+			.lineWidth(0.5)
+			.stroke();
+		doc.moveDown(0.5);
+	}
+
+	for (const node of section.content) {
+		switch (node.type) {
+			case "heading":
+				doc
+					.font(FONT_BOLD)
+					.fontSize(headingSize(node.level ?? 2))
+					.fillColor(COLOR_HEADING)
+					.text(node.value)
+					.moveDown(0.3);
+				break;
+			case "paragraph":
+				doc.font(FONT_REGULAR).fontSize(SIZE_BODY);
+				renderInlineNodes(doc, node.children);
+				doc.moveDown(0.3);
+				break;
+			case "list":
+				doc.fontSize(SIZE_BODY);
+				for (let i = 0; i < node.items.length; i++) {
+					renderListItem(doc, node.items[i]!, 0, node.ordered ?? false, i);
+				}
+				doc.moveDown(0.3);
+				break;
+		}
+	}
+}
+
+export function renderPDF(document: Document): Promise<Buffer> {
+	return new Promise<Buffer>((resolve, reject) => {
+		const pdf = new PDFDocument({ margin: 50, size: "A4" });
+		const chunks: Buffer[] = [];
+		pdf.on("data", (chunk: Buffer) => chunks.push(chunk));
+		pdf.on("end", () => resolve(Buffer.concat(chunks)));
+		pdf.on("error", reject);
+
+		for (let i = 0; i < document.sections.length; i++) {
+			renderSection(pdf, document.sections[i]!, i === 0);
+		}
+
+		pdf.end();
+	});
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "@openpolicy/tooling/base",
+	"compilerOptions": {
+		"rootDir": "src",
+		"outDir": "dist"
+	},
+	"include": ["src"]
+}