@pyreon/document 0.12.8 → 0.12.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/document",
-  "version": "0.12.8",
+  "version": "0.12.9",
   "description": "Universal document rendering for Pyreon — one template, every output format (HTML, PDF, DOCX, email, XLSX, Markdown, and more)",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/document#readme",
   "bugs": {
@@ -42,8 +42,8 @@
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.8.9",
-    "@pyreon/core": "^0.12.8",
-    "@pyreon/reactivity": "^0.12.8",
+    "@pyreon/core": "^0.12.9",
+    "@pyreon/reactivity": "^0.12.9",
     "@types/pdfmake": "^0.3.2",
     "@vitus-labs/tools-lint": "^1.15.5",
     "docx": "^9.6.0",
@@ -52,8 +52,8 @@
     "pptxgenjs": "^4.0.1"
   },
   "peerDependencies": {
-    "@pyreon/core": "^0.12.8",
-    "@pyreon/reactivity": "^0.12.8"
+    "@pyreon/core": "^0.12.9",
+    "@pyreon/reactivity": "^0.12.9"
   },
   "optionalDependencies": {
     "docx": "^9.6.0",

package/src/tests/integration.test.ts

@@ -0,0 +1,306 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import {
+  _resetRenderers,
+  Button,
+  Code,
+  createDocument,
+  Divider,
+  Document,
+  Heading,
+  Link,
+  List,
+  ListItem,
+  Page,
+  Quote,
+  render,
+  Table,
+  Text,
+} from '../index'
+
+afterEach(() => {
+  _resetRenderers()
+})
+
+// ─── Slack Renderer ────────────────────────────────────────────────────────
+
+describe('Slack renderer', () => {
+  it('renders heading as header block', async () => {
+    const doc = Document({ children: Heading({ children: 'Title' }) })
+    const result = (await render(doc, 'slack')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.blocks).toBeDefined()
+    const header = parsed.blocks.find((b: any) => b.type === 'header')
+    expect(header).toBeDefined()
+    expect(header.text.text).toBe('Title')
+  })
+
+  it('renders bold text with Slack mrkdwn', async () => {
+    const doc = Document({ children: Text({ bold: true, children: 'important' }) })
+    const result = (await render(doc, 'slack')) as string
+    const parsed = JSON.parse(result)
+    const section = parsed.blocks.find((b: any) => b.type === 'section')
+    expect(section.text.text).toBe('*important*')
+  })
+
+  it('renders divider block', async () => {
+    const doc = Document({ children: Divider() })
+    const result = (await render(doc, 'slack')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.blocks.some((b: any) => b.type === 'divider')).toBe(true)
+  })
+
+  it('renders button as action block', async () => {
+    const doc = Document({
+      children: Button({ href: 'https://example.com', children: 'Click' }),
+    })
+    const result = (await render(doc, 'slack')) as string
+    const parsed = JSON.parse(result)
+    const action = parsed.blocks.find((b: any) => b.type === 'actions')
+    expect(action).toBeDefined()
+    expect(action.elements[0].text.text).toBe('Click')
+  })
+
+  it('renders list as mrkdwn', async () => {
+    const doc = Document({
+      children: List({
+        ordered: true,
+        children: [ListItem({ children: 'one' }), ListItem({ children: 'two' })],
+      }),
+    })
+    const result = (await render(doc, 'slack')) as string
+    const parsed = JSON.parse(result)
+    const section = parsed.blocks.find((b: any) => b.type === 'section')
+    expect(section.text.text).toContain('1. one')
+    expect(section.text.text).toContain('2. two')
+  })
+
+  it('renders table as code block', async () => {
+    const doc = Document({
+      children: Table({ columns: ['Name', 'Price'], rows: [['Widget', '$10']] }),
+    })
+    const result = (await render(doc, 'slack')) as string
+    const parsed = JSON.parse(result)
+    const section = parsed.blocks.find((b: any) => b.type === 'section')
+    expect(section.text.text).toContain('*Name*')
+    expect(section.text.text).toContain('Widget')
+  })
+
+  it('renders quote with >', async () => {
+    const doc = Document({ children: Quote({ children: 'wise words' }) })
+    const result = (await render(doc, 'slack')) as string
+    const parsed = JSON.parse(result)
+    const section = parsed.blocks.find((b: any) => b.type === 'section')
+    expect(section.text.text).toContain('> wise words')
+  })
+})
+
+// ─── Discord Renderer ──────────────────────────────────────────────────────
+
+describe('Discord renderer', () => {
+  it('renders document as embed JSON', async () => {
+    const doc = Document({
+      title: 'Report',
+      children: [
+        Heading({ children: 'Report' }),
+        Text({ children: 'Summary text.' }),
+      ],
+    })
+    const result = (await render(doc, 'discord')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.embeds).toBeDefined()
+    expect(parsed.embeds[0].title).toBe('Report')
+    expect(parsed.embeds[0].description).toContain('Summary text.')
+  })
+
+  it('renders bold and italic text', async () => {
+    const doc = Document({
+      children: [
+        Text({ bold: true, children: 'bold' }),
+        Text({ italic: true, children: 'italic' }),
+      ],
+    })
+    const result = (await render(doc, 'discord')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.embeds[0].description).toContain('**bold**')
+    expect(parsed.embeds[0].description).toContain('*italic*')
+  })
+
+  it('renders small table as embed fields', async () => {
+    const doc = Document({
+      children: Table({
+        columns: ['Name', 'Price'],
+        rows: [['Widget', '$10'], ['Gadget', '$20']],
+      }),
+    })
+    const result = (await render(doc, 'discord')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.embeds[0].fields).toBeDefined()
+    expect(parsed.embeds[0].fields.length).toBe(2)
+  })
+})
+
+// ─── Telegram Renderer ─────────────────────────────────────────────────────
+
+describe('Telegram renderer', () => {
+  it('renders heading as bold', async () => {
+    const doc = Document({ children: Heading({ children: 'Title' }) })
+    const result = (await render(doc, 'telegram')) as string
+    expect(result).toContain('<b>Title</b>')
+  })
+
+  it('renders text with formatting', async () => {
+    const doc = Document({
+      children: Text({ bold: true, italic: true, children: 'styled' }),
+    })
+    const result = (await render(doc, 'telegram')) as string
+    expect(result).toContain('<b>')
+    expect(result).toContain('<i>')
+    expect(result).toContain('styled')
+  })
+
+  it('renders link as anchor', async () => {
+    const doc = Document({
+      children: Link({ href: 'https://example.com', children: 'click' }),
+    })
+    const result = (await render(doc, 'telegram')) as string
+    expect(result).toContain('href="https://example.com"')
+    expect(result).toContain('click')
+  })
+
+  it('renders code with language class', async () => {
+    const doc = Document({
+      children: Code({ language: 'python', children: 'x = 1' }),
+    })
+    const result = (await render(doc, 'telegram')) as string
+    expect(result).toContain('language-python')
+    expect(result).toContain('x = 1')
+  })
+
+  it('renders quote as blockquote', async () => {
+    const doc = Document({ children: Quote({ children: 'wise' }) })
+    const result = (await render(doc, 'telegram')) as string
+    expect(result).toContain('<blockquote>wise</blockquote>')
+  })
+
+  it('escapes HTML in text', async () => {
+    const doc = Document({
+      children: Text({ children: '<script>alert(1)</script>' }),
+    })
+    const result = (await render(doc, 'telegram')) as string
+    expect(result).not.toContain('<script>')
+    expect(result).toContain('&lt;script&gt;')
+  })
+})
+
+// ─── SVG Renderer ──────────────────────────────────────────────────────────
+
+describe('SVG renderer', () => {
+  it('renders a simple document as SVG', async () => {
+    const doc = Document({
+      children: [Heading({ children: 'Title' }), Text({ children: 'Body' })],
+    })
+    const svg = (await render(doc, 'svg')) as string
+    expect(svg).toContain('<svg')
+    expect(svg).toContain('Title')
+    expect(svg).toContain('Body')
+  })
+})
+
+// ─── Builder — Messaging Formats ───────────────────────────────────────────
+
+describe('builder — messaging formats', () => {
+  it('toSlack produces valid JSON', async () => {
+    const result = await createDocument()
+      .heading('Alert')
+      .text('Something happened.')
+      .toSlack()
+    const parsed = JSON.parse(result as string)
+    expect(parsed.blocks).toBeDefined()
+  })
+
+  it('toDiscord produces embed JSON', async () => {
+    const result = await createDocument()
+      .heading('Update')
+      .text('New version released.')
+      .toDiscord()
+    const parsed = JSON.parse(result as string)
+    expect(parsed.embeds).toBeDefined()
+  })
+
+  it('toTelegram produces HTML string', async () => {
+    const result = await createDocument()
+      .heading('Notice')
+      .text('Please read.')
+      .toTelegram()
+    expect(result).toContain('<b>Notice</b>')
+  })
+
+  it('toSvg produces SVG string', async () => {
+    const result = await createDocument()
+      .heading('Chart Title')
+      .toSvg()
+    expect(result).toContain('<svg')
+  })
+})
+
+// ─── Cross-Format Consistency ──────────────────────────────────────────────
+
+describe('cross-format consistency', () => {
+  const invoice = Document({
+    title: 'Invoice',
+    children: Page({
+      children: [
+        Heading({ children: 'Invoice #42' }),
+        Table({
+          columns: ['Item', 'Price'],
+          rows: [['Widget', '$10'], ['Gadget', '$20']],
+        }),
+        Text({ bold: true, children: 'Total: $30' }),
+      ],
+    }),
+  })
+
+  it('all text formats contain the same content', async () => {
+    const html = (await render(invoice, 'html')) as string
+    const md = (await render(invoice, 'md')) as string
+    const text = (await render(invoice, 'text')) as string
+    const email = (await render(invoice, 'email')) as string
+
+    for (const output of [html, md, email]) {
+      expect(output).toContain('Invoice')
+      expect(output).toContain('Widget')
+      expect(output).toContain('$10')
+    }
+    // Text renderer uppercases headings
+    expect(text).toContain('INVOICE')
+    expect(text).toContain('Widget')
+    expect(text).toContain('$10')
+  })
+})
+
+// ─── Builder — add() and section() ─────────────────────────────────────────
+
+describe('builder — add and section', () => {
+  it('add() accepts a single node', () => {
+    const doc = createDocument().add(Heading({ children: 'Added' }))
+    const node = doc.build()
+    expect(node.type).toBe('document')
+  })
+
+  it('add() accepts an array of nodes', () => {
+    const doc = createDocument().add([
+      Text({ children: 'A' }),
+      Text({ children: 'B' }),
+    ])
+    const node = doc.build()
+    expect(node.type).toBe('document')
+  })
+
+  it('section() wraps children in a Section node', async () => {
+    const doc = createDocument().section([
+      Text({ children: 'inside section' }),
+    ])
+    const html = await doc.toHtml()
+    expect(html).toContain('inside section')
+  })
+})

package/src/tests/renderers-coverage.test.ts

@@ -0,0 +1,615 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import {
+  _resetRenderers,
+  Button,
+  Code,
+  Column,
+  Divider,
+  Document,
+  Heading,
+  Image,
+  Link,
+  List,
+  ListItem,
+  Page,
+  PageBreak,
+  Quote,
+  Row,
+  render,
+  Section,
+  Spacer,
+  Table,
+  Text,
+} from '../index'
+
+afterEach(() => {
+  _resetRenderers()
+})
+
+// ─── Helper: full document with all node types ─────────────────────────────
+
+function createFullDoc() {
+  return Document({
+    title: 'Test Report',
+    subject: 'Coverage',
+    children: [
+      Page({
+        children: [
+          Heading({ level: 1, children: 'Main Title' }),
+          Heading({ level: 2, children: 'Subtitle' }),
+          Text({ bold: true, children: 'Bold text' }),
+          Text({ italic: true, children: 'Italic text' }),
+          Text({ strikethrough: true, children: 'Striked text' }),
+          Text({ underline: true, color: '#ff0000', children: 'Underline colored' }),
+          Link({ href: 'https://example.com', children: 'Link text' }),
+          Image({ src: 'https://example.com/img.png', alt: 'Alt text', width: 200, height: 100 }),
+          Table({
+            columns: ['Name', 'Price', 'Qty'],
+            rows: [
+              ['Widget', '$10', '5'],
+              ['Gadget', '$20', '3'],
+            ],
+            striped: true,
+            caption: 'Products',
+          }),
+          List({
+            ordered: true,
+            children: [ListItem({ children: 'First' }), ListItem({ children: 'Second' })],
+          }),
+          List({
+            children: [ListItem({ children: 'Bullet A' }), ListItem({ children: 'Bullet B' })],
+          }),
+          Code({ language: 'typescript', children: 'const x = 42' }),
+          Divider({ color: '#ccc', thickness: 2 }),
+          PageBreak(),
+          Spacer({ height: 20 }),
+          Button({ href: 'https://example.com/pay', background: '#4f46e5', color: '#fff', children: 'Pay Now' }),
+          Quote({ borderColor: '#4f46e5', children: 'A wise quote' }),
+          Section({
+            direction: 'row',
+            gap: 12,
+            children: [
+              Row({
+                gap: 10,
+                children: [
+                  Column({ width: '50%', children: Text({ children: 'Left' }) }),
+                  Column({ width: '50%', children: Text({ children: 'Right' }) }),
+                ],
+              }),
+            ],
+          }),
+        ],
+      }),
+    ],
+  })
+}
+
+// ─── Discord Renderer ──────────────────────────────────────────────────────
+
+describe('Discord renderer', () => {
+  it('renders full document as Discord embed JSON', async () => {
+    const doc = createFullDoc()
+    const result = (await render(doc, 'discord')) as string
+    const parsed = JSON.parse(result)
+
+    expect(parsed.embeds).toBeDefined()
+    expect(parsed.embeds).toHaveLength(1)
+    expect(parsed.embeds[0].title).toBe('Main Title')
+    expect(parsed.embeds[0].description).toContain('**Bold text**')
+    expect(parsed.embeds[0].description).toContain('*Italic text*')
+    expect(parsed.embeds[0].description).toContain('~~Striked text~~')
+    // Image extraction is depth-first; it finds the first HTTP image
+    // The embed may or may not include the image depending on traversal
+    expect(parsed.embeds[0].description).toBeDefined()
+  })
+
+  it('uses code block for large tables', async () => {
+    const doc = Document({
+      children: Table({
+        columns: ['A', 'B', 'C', 'D'],
+        rows: Array.from({ length: 15 }, (_, i) => [i, i + 1, i + 2, i + 3]),
+      }),
+    })
+    const result = (await render(doc, 'discord')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.embeds[0].description).toContain('```')
+  })
+
+  it('uses embed fields for small tables', async () => {
+    const doc = Document({
+      children: Table({
+        columns: ['Name', 'Price'],
+        rows: [['Widget', '$10']],
+      }),
+    })
+    const result = (await render(doc, 'discord')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.embeds[0].fields).toBeDefined()
+  })
+
+  it('renders link and button', async () => {
+    const doc = Document({
+      children: [
+        Link({ href: 'https://example.com', children: 'Click' }),
+        Button({ href: 'https://example.com', children: 'Action' }),
+      ],
+    })
+    const result = (await render(doc, 'discord')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.embeds[0].description).toContain('[Click]')
+    expect(parsed.embeds[0].description).toContain('[**Action**]')
+  })
+
+  it('renders divider and page break', async () => {
+    const doc = Document({ children: [Divider(), PageBreak()] })
+    const result = (await render(doc, 'discord')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.embeds[0].description).toContain('───')
+  })
+
+  it('renders code block', async () => {
+    const doc = Document({ children: Code({ language: 'js', children: 'let x = 1' }) })
+    const result = (await render(doc, 'discord')) as string
+    expect(result).toContain('```js')
+  })
+
+  it('renders quote', async () => {
+    const doc = Document({ children: Quote({ children: 'wise' }) })
+    const result = (await render(doc, 'discord')) as string
+    expect(result).toContain('> wise')
+  })
+
+  it('renders list', async () => {
+    const doc = Document({
+      children: List({
+        ordered: true,
+        children: [ListItem({ children: 'one' })],
+      }),
+    })
+    const result = (await render(doc, 'discord')) as string
+    expect(result).toContain('1. one')
+  })
+})
+
+// ─── Google Chat Renderer ──────────────────────────────────────────────────
+
+describe('Google Chat renderer', () => {
+  it('renders full document as Card V2', async () => {
+    const doc = createFullDoc()
+    const result = (await render(doc, 'google-chat')) as string
+    const parsed = JSON.parse(result)
+
+    expect(parsed.cardsV2).toBeDefined()
+    // When document has a title prop, that's used as card header
+    expect(parsed.cardsV2[0].card.header?.title).toBe('Test Report')
+    expect(parsed.cardsV2[0].card.sections[0].widgets.length).toBeGreaterThan(0)
+  })
+
+  it('renders heading as decorated text', async () => {
+    const doc = Document({ children: Heading({ children: 'Hello' }) })
+    const result = (await render(doc, 'google-chat')) as string
+    const parsed = JSON.parse(result)
+    const widgets = parsed.cardsV2[0].card.sections[0].widgets
+    expect(widgets.some((w: any) => w.decoratedText?.text?.includes('<b>Hello</b>'))).toBe(true)
+  })
+
+  it('renders image with http src', async () => {
+    const doc = Document({ children: Image({ src: 'https://example.com/img.png', alt: 'test' }) })
+    const result = (await render(doc, 'google-chat')) as string
+    const parsed = JSON.parse(result)
+    const widgets = parsed.cardsV2[0].card.sections[0].widgets
+    expect(widgets.some((w: any) => w.image?.imageUrl)).toBe(true)
+  })
+
+  it('renders code block', async () => {
+    const doc = Document({ children: Code({ children: 'const x = 1' }) })
+    const result = (await render(doc, 'google-chat')) as string
+    expect(result).toContain('<code>')
+  })
+
+  it('renders divider', async () => {
+    const doc = Document({ children: Divider() })
+    const result = (await render(doc, 'google-chat')) as string
+    const parsed = JSON.parse(result)
+    const widgets = parsed.cardsV2[0].card.sections[0].widgets
+    expect(widgets.some((w: any) => w.divider)).toBe(true)
+  })
+
+  it('renders button', async () => {
+    const doc = Document({ children: Button({ href: 'https://example.com', children: 'Click' }) })
+    const result = (await render(doc, 'google-chat')) as string
+    expect(result).toContain('buttonList')
+  })
+
+  it('renders quote', async () => {
+    const doc = Document({ children: Quote({ children: 'quoted' }) })
+    const result = (await render(doc, 'google-chat')) as string
+    expect(result).toContain('quoted')
+  })
+
+  it('renders list', async () => {
+    const doc = Document({
+      children: List({
+        ordered: true,
+        children: [ListItem({ children: 'one' })],
+      }),
+    })
+    const result = (await render(doc, 'google-chat')) as string
+    expect(result).toContain('1. one')
+  })
+
+  it('renders table', async () => {
+    const doc = Document({
+      children: Table({
+        columns: ['A', 'B'],
+        rows: [['x', 'y']],
+      }),
+    })
+    const result = (await render(doc, 'google-chat')) as string
+    expect(result).toContain('<b>A</b>')
+  })
+
+  it('renders text formatting', async () => {
+    const doc = Document({
+      children: [
+        Text({ bold: true, children: 'bold' }),
+        Text({ italic: true, children: 'italic' }),
+        Text({ strikethrough: true, children: 'strike' }),
+      ],
+    })
+    const result = (await render(doc, 'google-chat')) as string
+    expect(result).toContain('<b>bold</b>')
+    expect(result).toContain('<i>italic</i>')
+    expect(result).toContain('<s>strike</s>')
+  })
+
+  it('renders spacer as no-op', async () => {
+    const doc = Document({ children: Spacer({ height: 20 }) })
+    const result = (await render(doc, 'google-chat')) as string
+    // Spacer produces no widgets
+    const parsed = JSON.parse(result)
+    expect(parsed.cardsV2[0].card.sections[0].widgets).toHaveLength(0)
+  })
+
+  it('extracts title from first heading when document has no title', async () => {
+    const doc = Document({
+      children: [Heading({ children: 'Extracted Title' }), Text({ children: 'body' })],
+    })
+    const result = (await render(doc, 'google-chat')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.cardsV2[0].card.header.title).toBe('Extracted Title')
+  })
+})
+
+// ─── Confluence Renderer ───────────────────────────────────────────────────
+
+describe('Confluence renderer', () => {
+  it('renders full document as ADF', async () => {
+    const doc = createFullDoc()
+    const result = (await render(doc, 'confluence')) as string
+    const parsed = JSON.parse(result)
+
+    expect(parsed.version).toBe(1)
+    expect(parsed.type).toBe('doc')
+    expect(parsed.content.length).toBeGreaterThan(0)
+  })
+
+  it('renders heading with level', async () => {
+    const doc = Document({ children: Heading({ level: 3, children: 'H3' }) })
+    const result = (await render(doc, 'confluence')) as string
+    const parsed = JSON.parse(result)
+    const heading = parsed.content.find((n: any) => n.type === 'heading')
+    expect(heading.attrs.level).toBe(3)
+  })
+
+  it('renders text with marks', async () => {
+    const doc = Document({
+      children: Text({ bold: true, italic: true, underline: true, strikethrough: true, color: '#ff0000', children: 'styled' }),
+    })
+    const result = (await render(doc, 'confluence')) as string
+    const parsed = JSON.parse(result)
+    const para = parsed.content.find((n: any) => n.type === 'paragraph')
+    const marks = para.content[0].marks
+    expect(marks.some((m: any) => m.type === 'strong')).toBe(true)
+    expect(marks.some((m: any) => m.type === 'em')).toBe(true)
+    expect(marks.some((m: any) => m.type === 'underline')).toBe(true)
+    expect(marks.some((m: any) => m.type === 'strike')).toBe(true)
+    expect(marks.some((m: any) => m.type === 'textColor')).toBe(true)
+  })
+
+  it('renders link', async () => {
+    const doc = Document({ children: Link({ href: 'https://example.com', children: 'link' }) })
+    const result = (await render(doc, 'confluence')) as string
+    expect(result).toContain('"link"')
+  })
+
+  it('renders image with http src', async () => {
+    const doc = Document({ children: Image({ src: 'https://example.com/img.png', width: 100 }) })
+    const result = (await render(doc, 'confluence')) as string
+    expect(result).toContain('mediaSingle')
+  })
+
+  it('skips image with non-http src', async () => {
+    const doc = Document({ children: Image({ src: '/local/img.png' }) })
+    const result = (await render(doc, 'confluence')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.content.filter((n: any) => n.type === 'mediaSingle')).toHaveLength(0)
+  })
+
+  it('renders table', async () => {
+    const doc = Document({
+      children: Table({
+        columns: ['Name'],
+        rows: [['val']],
+      }),
+    })
+    const result = (await render(doc, 'confluence')) as string
+    expect(result).toContain('tableRow')
+    expect(result).toContain('tableHeader')
+  })
+
+  it('renders list', async () => {
+    const doc = Document({
+      children: List({
+        ordered: true,
+        children: [ListItem({ children: 'item' })],
+      }),
+    })
+    const result = (await render(doc, 'confluence')) as string
+    expect(result).toContain('orderedList')
+  })
+
+  it('renders bullet list', async () => {
+    const doc = Document({
+      children: List({
+        children: [ListItem({ children: 'item' })],
+      }),
+    })
+    const result = (await render(doc, 'confluence')) as string
+    expect(result).toContain('bulletList')
+  })
+
+  it('renders code block', async () => {
+    const doc = Document({ children: Code({ language: 'js', children: 'x' }) })
+    const result = (await render(doc, 'confluence')) as string
+    expect(result).toContain('codeBlock')
+  })
+
+  it('renders divider and page break', async () => {
+    const doc = Document({ children: [Divider(), PageBreak()] })
+    const result = (await render(doc, 'confluence')) as string
+    expect(result).toContain('"rule"')
+  })
+
+  it('renders spacer as empty paragraph', async () => {
+    const doc = Document({ children: Spacer({ height: 10 }) })
+    const result = (await render(doc, 'confluence')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.content.some((n: any) => n.type === 'paragraph')).toBe(true)
+  })
+
+  it('renders button as styled link', async () => {
+    const doc = Document({ children: Button({ href: 'https://example.com', children: 'Go' }) })
+    const result = (await render(doc, 'confluence')) as string
+    expect(result).toContain('"strong"')
+    expect(result).toContain('"link"')
+  })
+
+  it('renders quote', async () => {
+    const doc = Document({ children: Quote({ children: 'quoted' }) })
+    const result = (await render(doc, 'confluence')) as string
+    expect(result).toContain('blockquote')
+  })
+})
+
+// ─── WhatsApp Renderer ─────────────────────────────────────────────────────
+
+describe('WhatsApp renderer', () => {
+  it('renders full document', async () => {
+    const doc = createFullDoc()
+    const result = (await render(doc, 'whatsapp')) as string
+
+    expect(result).toContain('*Main Title*')
+    expect(result).toContain('*Bold text*')
+    expect(result).toContain('_Italic text_')
+    expect(result).toContain('~Striked text~')
+    expect(result).toContain('Pay Now')
+    expect(result).toContain('> A wise quote')
+  })
+
+  it('renders table with caption', async () => {
+    const doc = Document({
+      children: Table({
+        columns: ['A', 'B'],
+        rows: [['x', 'y']],
+        caption: 'My Table',
+      }),
+    })
+    const result = (await render(doc, 'whatsapp')) as string
+    expect(result).toContain('_My Table_')
+    expect(result).toContain('*A*')
+  })
+
+  it('renders code block', async () => {
+    const doc = Document({ children: Code({ children: 'hello' }) })
+    const result = (await render(doc, 'whatsapp')) as string
+    expect(result).toContain('```hello```')
+  })
+
+  it('renders divider', async () => {
+    const doc = Document({ children: Divider() })
+    const result = (await render(doc, 'whatsapp')) as string
+    expect(result).toContain('───')
+  })
+
+  it('renders spacer as newline', async () => {
+    const doc = Document({ children: Spacer({ height: 10 }) })
+    const result = (await render(doc, 'whatsapp')) as string
+    expect(result).toBe('')  // just whitespace, trimmed
+  })
+
+  it('skips images', async () => {
+    const doc = Document({ children: Image({ src: 'https://example.com/img.png' }) })
+    const result = (await render(doc, 'whatsapp')) as string
+    expect(result).toBe('')
+  })
+
+  it('renders link', async () => {
+    const doc = Document({ children: Link({ href: 'https://example.com', children: 'Click' }) })
+    const result = (await render(doc, 'whatsapp')) as string
+    expect(result).toContain('Click: https://example.com')
+  })
+
+  it('renders button', async () => {
+    const doc = Document({ children: Button({ href: 'https://example.com', children: 'Go' }) })
+    const result = (await render(doc, 'whatsapp')) as string
+    expect(result).toContain('*Go*: https://example.com')
+  })
+
+  it('renders list', async () => {
+    const doc = Document({
+      children: List({
+        ordered: true,
+        children: [ListItem({ children: 'one' }), ListItem({ children: 'two' })],
+      }),
+    })
+    const result = (await render(doc, 'whatsapp')) as string
+    expect(result).toContain('1. one')
+    expect(result).toContain('2. two')
+  })
+
+  it('renders section/row/column', async () => {
+    const doc = Document({
+      children: Section({
+        children: Row({
+          children: [
+            Column({ children: Text({ children: 'left' }) }),
+            Column({ children: Text({ children: 'right' }) }),
+          ],
+        }),
+      }),
+    })
+    const result = (await render(doc, 'whatsapp')) as string
+    expect(result).toContain('left')
+    expect(result).toContain('right')
+  })
+})
+
+// ─── Notion Renderer ───────────────────────────────────────────────────────
+
+describe('Notion renderer', () => {
+  it('renders full document as Notion blocks', async () => {
+    const doc = createFullDoc()
+    const result = (await render(doc, 'notion')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.children).toBeDefined()
+    expect(parsed.children.length).toBeGreaterThan(0)
+  })
+
+  it('renders heading', async () => {
+    const doc = Document({ children: Heading({ level: 2, children: 'H2' }) })
+    const result = (await render(doc, 'notion')) as string
+    const parsed = JSON.parse(result)
+    const h2 = parsed.children.find((b: any) => b.type === 'heading_2')
+    expect(h2).toBeDefined()
+  })
+
+  it('renders button as bold link', async () => {
+    const doc = Document({ children: Button({ href: 'https://example.com', children: 'Go' }) })
+    const result = (await render(doc, 'notion')) as string
+    expect(result).toContain('"bold": true')
+  })
+
+  it('renders quote', async () => {
+    const doc = Document({ children: Quote({ children: 'quoted' }) })
+    const result = (await render(doc, 'notion')) as string
+    expect(result).toContain('"quote"')
+  })
+
+  it('renders spacer as empty paragraph', async () => {
+    const doc = Document({ children: Spacer({ height: 10 }) })
+    const result = (await render(doc, 'notion')) as string
+    const parsed = JSON.parse(result)
+    const para = parsed.children.find((b: any) => b.type === 'paragraph')
+    expect(para).toBeDefined()
+  })
+
+  it('renders divider', async () => {
+    const doc = Document({ children: Divider() })
+    const result = (await render(doc, 'notion')) as string
+    const parsed = JSON.parse(result)
+    expect(parsed.children.some((b: any) => b.type === 'divider')).toBe(true)
+  })
+})
+
+// ─── Telegram Renderer ─────────────────────────────────────────────────────
+
+describe('Telegram renderer', () => {
+  it('renders full document as Telegram HTML', async () => {
+    const doc = createFullDoc()
+    const result = (await render(doc, 'telegram')) as string
+
+    expect(result).toContain('<b>Main Title</b>')
+    expect(result).toContain('<b>Bold text</b>')
+    expect(result).toContain('<i>Italic text</i>')
+    expect(result).toContain('<s>Striked text</s>')
+    expect(result).toContain('<a href="https://example.com">Link text</a>')
+  })
+
+  it('renders code block', async () => {
+    const doc = Document({ children: Code({ language: 'js', children: 'x = 1' }) })
+    const result = (await render(doc, 'telegram')) as string
+    expect(result).toContain('<pre>')
+    expect(result).toContain('<code')
+  })
+
+  it('renders quote', async () => {
+    const doc = Document({ children: Quote({ children: 'quoted' }) })
+    const result = (await render(doc, 'telegram')) as string
+    expect(result).toContain('<blockquote>')
+  })
+
+  it('renders button as link', async () => {
+    const doc = Document({ children: Button({ href: 'https://example.com', children: 'Go' }) })
+    const result = (await render(doc, 'telegram')) as string
+    expect(result).toContain('<a href=')
+    expect(result).toContain('Go')
+  })
+})
+
+// ─── Teams Renderer ────────────────────────────────────────────────────────
+
+describe('Teams renderer', () => {
+  it('renders full document as adaptive card', async () => {
+    const doc = createFullDoc()
+    const result = (await render(doc, 'teams')) as string
+    const parsed = JSON.parse(result)
+
+    expect(parsed.type).toBe('AdaptiveCard')
+    expect(parsed.body.length).toBeGreaterThan(0)
+  })
+
+  it('renders heading', async () => {
+    const doc = Document({ children: Heading({ level: 1, children: 'Title' }) })
+    const result = (await render(doc, 'teams')) as string
+    expect(result).toContain('Title')
+  })
+
+  it('renders link', async () => {
+    const doc = Document({ children: Link({ href: 'https://example.com', children: 'Click' }) })
+    const result = (await render(doc, 'teams')) as string
+    expect(result).toContain('https://example.com')
+  })
+
+  it('renders image', async () => {
+    const doc = Document({ children: Image({ src: 'https://example.com/img.png', alt: 'img' }) })
+    const result = (await render(doc, 'teams')) as string
+    expect(result).toContain('https://example.com/img.png')
+  })
+
+  it('renders button as action', async () => {
+    const doc = Document({ children: Button({ href: 'https://example.com', children: 'Go' }) })
+    const result = (await render(doc, 'teams')) as string
+    expect(result).toContain('Action.OpenUrl')
+  })
+})

package/src/tests/utils-coverage.test.ts

@@ -0,0 +1,412 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+  _resetRenderers,
+  createDocument,
+  Document,
+  isDocNode,
+  Page,
+  registerRenderer,
+  render,
+  Table,
+  Text,
+  unregisterRenderer,
+} from '../index'
+import {
+  sanitizeColor,
+  sanitizeCss,
+  sanitizeHref,
+  sanitizeImageSrc,
+  sanitizeStyle,
+  sanitizeXmlColor,
+} from '../sanitize'
+import { download } from '../download'
+
+afterEach(() => {
+  _resetRenderers()
+})
+
+// ─── Sanitize utilities ────────────────────────────────────────────────────
+
+describe('sanitizeCss', () => {
+  it('returns empty string for null/undefined', () => {
+    expect(sanitizeCss(undefined)).toBe('')
+    expect(sanitizeCss(undefined as any)).toBe('')
+  })
+
+  it('strips dangerous characters', () => {
+    expect(sanitizeCss('color; background{}')).toBe('color background')
+    // Strips quotes, parens, and url() prefix
+    const urlResult = sanitizeCss("url('bad')")
+    expect(urlResult).not.toContain('url(')
+    // expression() is stripped
+    const exprResult = sanitizeCss('expression(alert())')
+    expect(exprResult).not.toContain('expression(')
+    // javascript: is stripped
+    const jsResult = sanitizeCss('javascript:void(0)')
+    expect(jsResult).not.toContain('javascript:')
+  })
+
+  it('allows safe CSS values', () => {
+    expect(sanitizeCss('red')).toBe('red')
+    expect(sanitizeCss('12px')).toBe('12px')
+    expect(sanitizeCss('#fff')).toBe('#fff')
+  })
+})
+
+describe('sanitizeColor', () => {
+  it('returns empty string for null/undefined', () => {
+    expect(sanitizeColor(undefined)).toBe('')
+  })
+
+  it('allows hex colors', () => {
+    expect(sanitizeColor('#fff')).toBe('#fff')
+    expect(sanitizeColor('#ff0000')).toBe('#ff0000')
+    expect(sanitizeColor('#ff000080')).toBe('#ff000080')
+  })
+
+  it('allows named colors', () => {
+    expect(sanitizeColor('red')).toBe('red')
+    expect(sanitizeColor('blue')).toBe('blue')
+  })
+
+  it('allows rgb/rgba/hsl/hsla', () => {
+    expect(sanitizeColor('rgb(255, 0, 0)')).toBe('rgb(255, 0, 0)')
+    expect(sanitizeColor('rgba(255, 0, 0, 0.5)')).toBe('rgba(255, 0, 0, 0.5)')
+    expect(sanitizeColor('hsl(0, 100%, 50%)')).toBe('hsl(0, 100%, 50%)')
+    expect(sanitizeColor('hsla(0, 100%, 50%, 0.5)')).toBe('hsla(0, 100%, 50%, 0.5)')
+  })
+
+  it('allows special keywords', () => {
+    expect(sanitizeColor('transparent')).toBe('transparent')
+    expect(sanitizeColor('inherit')).toBe('inherit')
+    expect(sanitizeColor('currentColor')).toBe('currentColor')
+    expect(sanitizeColor('initial')).toBe('initial')
+    expect(sanitizeColor('unset')).toBe('unset')
+  })
+
+  it('rejects invalid values', () => {
+    expect(sanitizeColor('javascript:alert(1)')).toBe('')
+    expect(sanitizeColor('expression(something)')).toBe('')
+    expect(sanitizeColor('#xyz')).toBe('')
+  })
+})
+
+describe('sanitizeXmlColor', () => {
+  it('returns fallback for null/undefined', () => {
+    expect(sanitizeXmlColor(undefined)).toBe('000000')
+    expect(sanitizeXmlColor(undefined, 'ffffff')).toBe('ffffff')
+  })
+
+  it('strips # from hex', () => {
+    expect(sanitizeXmlColor('#ff0000')).toBe('ff0000')
+  })
+
+  it('passes through valid hex', () => {
+    expect(sanitizeXmlColor('4f46e5')).toBe('4f46e5')
+  })
+
+  it('returns fallback for invalid hex', () => {
+    expect(sanitizeXmlColor('not-hex')).toBe('000000')
+  })
+})
+
+describe('sanitizeHref', () => {
+  it('returns empty string for null/undefined', () => {
+    expect(sanitizeHref(undefined)).toBe('')
+  })
+
+  it('allows http/https URLs', () => {
+    expect(sanitizeHref('https://example.com')).toBe('https://example.com')
+    expect(sanitizeHref('http://example.com')).toBe('http://example.com')
+  })
+
+  it('blocks javascript: protocol', () => {
+    expect(sanitizeHref('javascript:alert(1)')).toBe('')
+    expect(sanitizeHref('  javascript:void(0)')).toBe('')
+  })
+
+  it('blocks vbscript: protocol', () => {
+    expect(sanitizeHref('vbscript:run')).toBe('')
+  })
+
+  it('blocks non-image data: URIs', () => {
+    expect(sanitizeHref('data:text/html,<script>alert(1)</script>')).toBe('')
+  })
+
+  it('allows data:image URIs', () => {
+    expect(sanitizeHref('data:image/png;base64,abc')).toBe('data:image/png;base64,abc')
+  })
+})
+
+describe('sanitizeImageSrc', () => {
+  it('returns empty string for null/undefined', () => {
+    expect(sanitizeImageSrc(undefined)).toBe('')
+  })
+
+  it('allows http URLs', () => {
+    expect(sanitizeImageSrc('https://example.com/img.png')).toBe('https://example.com/img.png')
+  })
+
+  it('blocks javascript: protocol', () => {
+    expect(sanitizeImageSrc('javascript:alert(1)')).toBe('')
+  })
+
+  it('blocks vbscript: protocol', () => {
+    expect(sanitizeImageSrc('vbscript:run')).toBe('')
+  })
+
+  it('blocks non-image data: URIs', () => {
+    expect(sanitizeImageSrc('data:text/html,bad')).toBe('')
+  })
+
+  it('allows data:image URIs', () => {
+    expect(sanitizeImageSrc('data:image/png;base64,abc')).toBe('data:image/png;base64,abc')
+  })
+})
+
+describe('sanitizeStyle', () => {
+  it('returns empty string for null/undefined', () => {
+    expect(sanitizeStyle(undefined)).toBe('')
+  })
+
+  it('sanitizes CSS in style attribute', () => {
+    expect(sanitizeStyle('color: red')).toBe('color: red')
+    expect(sanitizeStyle('expression(alert())')).not.toContain('expression(')
+  })
+})
+
+// ─── Node construction edge cases ──────────────────────────────────────────
+
+describe('isDocNode', () => {
+  it('returns false for null', () => {
+    expect(isDocNode(null)).toBe(false)
+  })
+
+  it('returns false for string', () => {
+    expect(isDocNode('hello')).toBe(false)
+  })
+
+  it('returns false for number', () => {
+    expect(isDocNode(42)).toBe(false)
+  })
+
+  it('returns false for plain object without required keys', () => {
+    expect(isDocNode({ type: 'foo' })).toBe(false)
+    expect(isDocNode({ type: 'foo', props: {} })).toBe(false)
+  })
+
+  it('returns true for valid DocNode', () => {
+    expect(isDocNode({ type: 'text', props: {}, children: [] })).toBe(true)
+  })
+})
+
+describe('normalizeChildren edge cases', () => {
+  it('handles number children', () => {
+    const node = Text({ children: 42 as any })
+    expect(node.children).toEqual(['42'])
+  })
+
+  it('handles false/null children', () => {
+    const node = Text({ children: false as any })
+    expect(node.children).toEqual([])
+
+    const node2 = Text({ children: null as any })
+    expect(node2.children).toEqual([])
+  })
+
+  it('handles nested array children', () => {
+    const node = Page({ children: [['a', 'b'], 'c'] as any })
+    expect(node.children).toEqual(['a', 'b', 'c'])
+  })
+
+  it('throws on plain object children', () => {
+    expect(() => {
+      Text({ children: { invalid: true } as any })
+    }).toThrow('Invalid child')
+  })
+})
+
+// ─── Download function ─────────────────────────────────────────────────────
+
+describe('download', () => {
+  it('throws for filename with unknown extension', async () => {
+    const doc = Document({ children: Text({ children: 'hello' }) })
+    // "noext" becomes ".noext" as extension which is unknown
+    await expect(download(doc, 'file.noext')).rejects.toThrow('Unknown file extension')
+  })
+
+  it('throws for unknown extension', async () => {
+    const doc = Document({ children: Text({ children: 'hello' }) })
+    await expect(download(doc, 'file.zzz')).rejects.toThrow("Unknown file extension '.zzz'")
+  })
+
+  it('downloads html file', async () => {
+    const doc = Document({ children: Text({ children: 'hello' }) })
+    // Mock URL.createObjectURL and element click
+    const urlSpy = vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:mock')
+    const revokeSpy = vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => {})
+    const clickSpy = vi.fn()
+    vi.spyOn(document, 'createElement').mockReturnValue({
+      set href(_: string) {},
+      set download(_: string) {},
+      click: clickSpy,
+    } as any)
+
+    await download(doc, 'file.html')
+
+    expect(clickSpy).toHaveBeenCalled()
+    expect(revokeSpy).toHaveBeenCalled()
+
+    urlSpy.mockRestore()
+    revokeSpy.mockRestore()
+    vi.restoreAllMocks()
+  })
+})
+
+// ─── Render function edge cases ────────────────────────────────────────────
+
+describe('render — edge cases', () => {
+  it('throws for unregistered format', async () => {
+    const doc = Document({ children: Text({ children: 'hello' }) })
+    unregisterRenderer('nonexistent') // just to exercise the path
+    await expect(render(doc, 'nonexistent')).rejects.toThrow("No renderer registered")
+  })
+
+  it('registerRenderer with direct renderer (not lazy loader)', async () => {
+    registerRenderer('test-format', {
+      async render(_node, _options) {
+        return 'test-output'
+      },
+    })
+    const doc = Document({ children: Text({ children: 'hello' }) })
+    const result = await render(doc, 'test-format')
+    expect(result).toBe('test-output')
+  })
+
+  it('lazy renderer is cached after first use', async () => {
+    let loadCount = 0
+    registerRenderer('counted', () => {
+      loadCount++
+      return Promise.resolve({
+        async render() {
+          return 'ok'
+        },
+      })
+    })
+    const doc = Document({ children: Text({ children: 'hello' }) })
+    await render(doc, 'counted')
+    await render(doc, 'counted')
+    expect(loadCount).toBe(1) // Only loaded once
+  })
+})
+
+// ─── createDocument builder ────────────────────────────────────────────────
+
+describe('createDocument builder', () => {
+  it('builds and renders to html', async () => {
+    const result = await createDocument({ title: 'Test' })
+      .heading('Title')
+      .text('paragraph')
+      .toHtml()
+
+    expect(result).toContain('Title')
+    expect(result).toContain('paragraph')
+  })
+
+  it('builds with table', async () => {
+    const result = await createDocument()
+      .table({ columns: ['A', 'B'], rows: [['x', 'y']] })
+      .toMarkdown()
+
+    expect(result).toContain('A')
+    expect(result).toContain('x')
+  })
+
+  it('builds with all methods', async () => {
+    const builder = createDocument({ title: 'Full' })
+      .heading('H1')
+      .text('para', { bold: true })
+      .link('link', { href: 'https://example.com' })
+      .image('https://example.com/img.png', { width: 100 })
+      .table({ columns: ['Col'], rows: [['val']] })
+      .code('x = 1', { language: 'js' })
+      .divider()
+      .spacer(20)
+      .list(['a', 'b'])
+      .quote('quoted')
+      .button('Go', { href: 'https://example.com' })
+      .pageBreak()
+
+    const text = await builder.toText()
+    expect(text).toContain('H1')
+    expect(text).toContain('para')
+  })
+
+  it('toMarkdown works', async () => {
+    const result = await createDocument().heading('Title').toMarkdown()
+    expect(result).toContain('Title')
+  })
+
+  it('toCsv works with table', async () => {
+    // CSV requires a table in the document
+    const doc = Document({
+      children: Table({ columns: ['A', 'B'], rows: [['1', '2']] }),
+    })
+    const result = (await render(doc, 'csv')) as string
+    expect(result).toContain('A')
+    expect(result).toContain('1')
+  })
+
+  it('toSlack works', async () => {
+    const result = await createDocument().heading('Title').toSlack()
+    const parsed = JSON.parse(result)
+    expect(parsed.blocks).toBeDefined()
+  })
+
+  it('toSvg works', async () => {
+    const result = await createDocument().heading('Title').toSvg()
+    expect(result).toContain('<svg')
+  })
+
+  it('toTeams works', async () => {
+    const result = await createDocument().heading('Title').toTeams()
+    expect(result).toContain('AdaptiveCard')
+  })
+
+  it('toDiscord works', async () => {
+    const result = await createDocument().heading('Title').toDiscord()
+    expect(result).toContain('embeds')
+  })
+
+  it('toTelegram works', async () => {
+    const result = await createDocument().heading('Title').toTelegram()
+    expect(result).toContain('Title')
+  })
+
+  it('toNotion works', async () => {
+    const result = await createDocument().heading('Title').toNotion()
+    const parsed = JSON.parse(result)
+    expect(parsed.children).toBeDefined()
+    expect(parsed.children.length).toBeGreaterThan(0)
+  })
+
+  it('toConfluence works', async () => {
+    const result = await createDocument().heading('Title').toConfluence()
+    expect(result).toContain('"doc"')
+  })
+
+  it('toWhatsApp works', async () => {
+    const result = await createDocument().heading('Title').toWhatsApp()
+    expect(result).toContain('*Title*')
+  })
+
+  it('toGoogleChat works', async () => {
+    const result = await createDocument().heading('Title').toGoogleChat()
+    expect(result).toContain('cardsV2')
+  })
+
+  it('toEmail works', async () => {
+    const result = await createDocument().heading('Title').toEmail()
+    expect(result).toContain('Title')
+  })
+})