@pyreon/document 0.0.1

package/src/render.ts

@@ -0,0 +1,222 @@
+import type {
+  DocNode,
+  DocumentRenderer,
+  OutputFormat,
+  RenderOptions,
+  RenderResult,
+} from './types'
+
+// ─── Renderer Registry ──────────────────────────────────────────────────────
+
+const renderers = new Map<
+  string,
+  DocumentRenderer | (() => Promise<DocumentRenderer>)
+>()
+
+/**
+ * Register a custom renderer for a format.
+ *
+ * @example
+ * ```ts
+ * registerRenderer('thermal', {
+ *   render(node, options) {
+ *     // Walk nodes → ESC/POS commands
+ *     return escPosBuffer
+ *   },
+ * })
+ *
+ * await render(receipt, 'thermal')
+ * ```
+ */
+export function registerRenderer(
+  format: string,
+  renderer: DocumentRenderer | (() => Promise<DocumentRenderer>),
+): void {
+  renderers.set(format, renderer)
+}
+
+/**
+ * Remove a registered renderer.
+ */
+export function unregisterRenderer(format: string): void {
+  renderers.delete(format)
+}
+
+// ─── Built-in Renderer Loaders ──────────────────────────────────────────────
+
+// Built-in renderers are registered lazily — only loaded when first used.
+
+registerRenderer('html', () =>
+  import('./renderers/html').then((m) => m.htmlRenderer),
+)
+
+registerRenderer('email', () =>
+  import('./renderers/email').then((m) => m.emailRenderer),
+)
+
+registerRenderer('md', () =>
+  import('./renderers/markdown').then((m) => m.markdownRenderer),
+)
+
+registerRenderer('text', () =>
+  import('./renderers/text').then((m) => m.textRenderer),
+)
+
+registerRenderer('csv', () =>
+  import('./renderers/csv').then((m) => m.csvRenderer),
+)
+
+registerRenderer('pdf', () =>
+  import('./renderers/pdf').then((m) => m.pdfRenderer),
+)
+
+registerRenderer('docx', () =>
+  import('./renderers/docx').then((m) => m.docxRenderer),
+)
+
+registerRenderer('xlsx', () =>
+  import('./renderers/xlsx').then((m) => m.xlsxRenderer),
+)
+
+registerRenderer('pptx', () =>
+  import('./renderers/pptx').then((m) => m.pptxRenderer),
+)
+
+registerRenderer('slack', () =>
+  import('./renderers/slack').then((m) => m.slackRenderer),
+)
+
+registerRenderer('svg', () =>
+  import('./renderers/svg').then((m) => m.svgRenderer),
+)
+
+registerRenderer('teams', () =>
+  import('./renderers/teams').then((m) => m.teamsRenderer),
+)
+
+registerRenderer('discord', () =>
+  import('./renderers/discord').then((m) => m.discordRenderer),
+)
+
+registerRenderer('telegram', () =>
+  import('./renderers/telegram').then((m) => m.telegramRenderer),
+)
+
+registerRenderer('notion', () =>
+  import('./renderers/notion').then((m) => m.notionRenderer),
+)
+
+registerRenderer('confluence', () =>
+  import('./renderers/confluence').then((m) => m.confluenceRenderer),
+)
+
+registerRenderer('whatsapp', () =>
+  import('./renderers/whatsapp').then((m) => m.whatsappRenderer),
+)
+
+registerRenderer('google-chat', () =>
+  import('./renderers/google-chat').then((m) => m.googleChatRenderer),
+)
+
+// ─── Render Function ────────────────────────────────────────────────────────
+
+async function resolveRenderer(format: string): Promise<DocumentRenderer> {
+  const entry = renderers.get(format)
+  if (!entry) {
+    throw new Error(
+      `[@pyreon/document] No renderer registered for format '${format}'. Available: ${[...renderers.keys()].join(', ')}`,
+    )
+  }
+
+  if (typeof entry === 'function') {
+    const renderer = await entry()
+    // Cache the resolved renderer so we don't re-import
+    renderers.set(format, renderer)
+    return renderer
+  }
+
+  return entry
+}
+
+/**
+ * Render a document node tree to the specified format.
+ *
+ * @example
+ * ```tsx
+ * const doc = <Document title="Report"><Page>...</Page></Document>
+ *
+ * const html = await render(doc, 'html')    // → HTML string
+ * const pdf = await render(doc, 'pdf')      // → PDF Uint8Array
+ * const docx = await render(doc, 'docx')    // → DOCX Uint8Array
+ * const email = await render(doc, 'email')  // → email-safe HTML string
+ * const md = await render(doc, 'md')        // → Markdown string
+ * ```
+ */
+export async function render(
+  node: DocNode,
+  format: OutputFormat | string,
+  options?: RenderOptions,
+): Promise<RenderResult> {
+  const renderer = await resolveRenderer(format)
+  return renderer.render(node, options)
+}
+
+/** @internal For testing — reset renderer registry to defaults. */
+export function _resetRenderers(): void {
+  renderers.clear()
+  // Re-register built-in lazy loaders
+  registerRenderer('html', () =>
+    import('./renderers/html').then((m) => m.htmlRenderer),
+  )
+  registerRenderer('email', () =>
+    import('./renderers/email').then((m) => m.emailRenderer),
+  )
+  registerRenderer('md', () =>
+    import('./renderers/markdown').then((m) => m.markdownRenderer),
+  )
+  registerRenderer('text', () =>
+    import('./renderers/text').then((m) => m.textRenderer),
+  )
+  registerRenderer('csv', () =>
+    import('./renderers/csv').then((m) => m.csvRenderer),
+  )
+  registerRenderer('pdf', () =>
+    import('./renderers/pdf').then((m) => m.pdfRenderer),
+  )
+  registerRenderer('docx', () =>
+    import('./renderers/docx').then((m) => m.docxRenderer),
+  )
+  registerRenderer('xlsx', () =>
+    import('./renderers/xlsx').then((m) => m.xlsxRenderer),
+  )
+  registerRenderer('pptx', () =>
+    import('./renderers/pptx').then((m) => m.pptxRenderer),
+  )
+  registerRenderer('slack', () =>
+    import('./renderers/slack').then((m) => m.slackRenderer),
+  )
+  registerRenderer('svg', () =>
+    import('./renderers/svg').then((m) => m.svgRenderer),
+  )
+  registerRenderer('teams', () =>
+    import('./renderers/teams').then((m) => m.teamsRenderer),
+  )
+  registerRenderer('discord', () =>
+    import('./renderers/discord').then((m) => m.discordRenderer),
+  )
+  registerRenderer('telegram', () =>
+    import('./renderers/telegram').then((m) => m.telegramRenderer),
+  )
+  registerRenderer('notion', () =>
+    import('./renderers/notion').then((m) => m.notionRenderer),
+  )
+  registerRenderer('confluence', () =>
+    import('./renderers/confluence').then((m) => m.confluenceRenderer),
+  )
+  registerRenderer('whatsapp', () =>
+    import('./renderers/whatsapp').then((m) => m.whatsappRenderer),
+  )
+  registerRenderer('google-chat', () =>
+    import('./renderers/google-chat').then((m) => m.googleChatRenderer),
+  )
+}

package/src/renderers/confluence.ts

@@ -0,0 +1,231 @@
+import type {
+  DocChild,
+  DocNode,
+  DocumentRenderer,
+  RenderOptions,
+  TableColumn,
+} from '../types'
+
+/**
+ * Atlassian Document Format (ADF) renderer — for Jira and Confluence.
+ * ADF is the JSON format used by Atlassian's Document API.
+ * Can be posted to Confluence pages, Jira issue descriptions, and comments.
+ */
+
+function resolveColumn(col: string | TableColumn): TableColumn {
+  return typeof col === 'string' ? { header: col } : col
+}
+
+function getTextContent(children: DocChild[]): string {
+  return children
+    .map((c) =>
+      typeof c === 'string' ? c : getTextContent((c as DocNode).children),
+    )
+    .join('')
+}
+
+interface AdfNode {
+  type: string
+  content?: AdfNode[]
+  text?: string
+  marks?: { type: string; attrs?: Record<string, unknown> }[]
+  attrs?: Record<string, unknown>
+}
+
+function textNode(text: string, marks?: AdfNode['marks']): AdfNode {
+  return { type: 'text', text, ...(marks && marks.length > 0 ? { marks } : {}) }
+}
+
+function nodeToAdf(node: DocNode): AdfNode[] {
+  const p = node.props
+  const result: AdfNode[] = []
+
+  switch (node.type) {
+    case 'document':
+    case 'page':
+    case 'section':
+    case 'row':
+    case 'column':
+      for (const child of node.children) {
+        if (typeof child !== 'string') {
+          result.push(...nodeToAdf(child))
+        }
+      }
+      break
+
+    case 'heading': {
+      const level = Math.min(Math.max((p.level as number) ?? 1, 1), 6)
+      const text = getTextContent(node.children)
+      result.push({
+        type: 'heading',
+        attrs: { level },
+        content: [textNode(text, [{ type: 'strong' }])],
+      })
+      break
+    }
+
+    case 'text': {
+      const text = getTextContent(node.children)
+      const marks: AdfNode['marks'] = []
+      if (p.bold) marks.push({ type: 'strong' })
+      if (p.italic) marks.push({ type: 'em' })
+      if (p.underline) marks.push({ type: 'underline' })
+      if (p.strikethrough) marks.push({ type: 'strike' })
+      if (p.color)
+        marks.push({ type: 'textColor', attrs: { color: p.color as string } })
+      result.push({
+        type: 'paragraph',
+        content: [textNode(text, marks)],
+      })
+      break
+    }
+
+    case 'link': {
+      const href = p.href as string
+      const text = getTextContent(node.children)
+      result.push({
+        type: 'paragraph',
+        content: [textNode(text, [{ type: 'link', attrs: { href } }])],
+      })
+      break
+    }
+
+    case 'image': {
+      const src = p.src as string
+      if (src.startsWith('http')) {
+        result.push({
+          type: 'mediaSingle',
+          attrs: { layout: 'center' },
+          content: [
+            {
+              type: 'media',
+              attrs: {
+                type: 'external',
+                url: src,
+                width: (p.width as number) ?? undefined,
+                height: (p.height as number) ?? undefined,
+              },
+            },
+          ],
+        })
+      }
+      break
+    }
+
+    case 'table': {
+      const columns = ((p.columns ?? []) as (string | TableColumn)[]).map(
+        resolveColumn,
+      )
+      const rows = (p.rows ?? []) as (string | number)[][]
+
+      const headerRow: AdfNode = {
+        type: 'tableRow',
+        content: columns.map((col) => ({
+          type: 'tableHeader',
+          content: [
+            {
+              type: 'paragraph',
+              content: [textNode(col.header, [{ type: 'strong' }])],
+            },
+          ],
+        })),
+      }
+
+      const dataRows = rows.map((row) => ({
+        type: 'tableRow' as const,
+        content: columns.map((_, i) => ({
+          type: 'tableCell' as const,
+          content: [
+            {
+              type: 'paragraph' as const,
+              content: [textNode(String(row[i] ?? ''))],
+            },
+          ],
+        })),
+      }))
+
+      result.push({
+        type: 'table',
+        attrs: { isNumberColumnEnabled: false, layout: 'default' },
+        content: [headerRow, ...dataRows],
+      })
+      break
+    }
+
+    case 'list': {
+      const ordered = p.ordered as boolean | undefined
+      const type = ordered ? 'orderedList' : 'bulletList'
+      const items = node.children
+        .filter((c): c is DocNode => typeof c !== 'string')
+        .map((item) => ({
+          type: 'listItem' as const,
+          content: [
+            {
+              type: 'paragraph' as const,
+              content: [textNode(getTextContent(item.children))],
+            },
+          ],
+        }))
+      result.push({ type, content: items })
+      break
+    }
+
+    case 'code': {
+      const text = getTextContent(node.children)
+      const lang = (p.language as string) ?? null
+      result.push({
+        type: 'codeBlock',
+        attrs: { language: lang },
+        content: [textNode(text)],
+      })
+      break
+    }
+
+    case 'divider':
+    case 'page-break':
+      result.push({ type: 'rule' })
+      break
+
+    case 'spacer':
+      result.push({ type: 'paragraph', content: [] })
+      break
+
+    case 'button': {
+      const href = p.href as string
+      const text = getTextContent(node.children)
+      result.push({
+        type: 'paragraph',
+        content: [
+          textNode(text, [
+            { type: 'link', attrs: { href } },
+            { type: 'strong' },
+          ]),
+        ],
+      })
+      break
+    }
+
+    case 'quote': {
+      const text = getTextContent(node.children)
+      result.push({
+        type: 'blockquote',
+        content: [{ type: 'paragraph', content: [textNode(text)] }],
+      })
+      break
+    }
+  }
+
+  return result
+}
+
+export const confluenceRenderer: DocumentRenderer = {
+  async render(node: DocNode, _options?: RenderOptions): Promise<string> {
+    const content = nodeToAdf(node)
+    const adf = {
+      version: 1,
+      type: 'doc',
+      content,
+    }
+    return JSON.stringify(adf, null, 2)
+  },
+}

package/src/renderers/csv.ts

@@ -0,0 +1,67 @@
+import type {
+  DocNode,
+  DocumentRenderer,
+  RenderOptions,
+  TableColumn,
+} from '../types'
+
+function resolveColumn(col: string | TableColumn): TableColumn {
+  return typeof col === 'string' ? { header: col } : col
+}
+
+function escapeCsv(value: string): string {
+  if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+    return `"${value.replace(/"/g, '""')}"`
+  }
+  return value
+}
+
+function findTables(node: DocNode): DocNode[] {
+  const tables: DocNode[] = []
+  if (node.type === 'table') {
+    tables.push(node)
+  }
+  for (const child of node.children) {
+    if (typeof child !== 'string') {
+      tables.push(...findTables(child))
+    }
+  }
+  return tables
+}
+
+function tableToCsv(node: DocNode): string {
+  const columns = ((node.props.columns ?? []) as (string | TableColumn)[]).map(
+    resolveColumn,
+  )
+  const rows = (node.props.rows ?? []) as (string | number)[][]
+
+  const lines: string[] = []
+
+  // Caption as comment
+  if (node.props.caption) {
+    lines.push(`# ${node.props.caption}`)
+  }
+
+  // Header
+  lines.push(columns.map((c) => escapeCsv(c.header)).join(','))
+
+  // Rows
+  for (const row of rows) {
+    lines.push(row.map((cell) => escapeCsv(String(cell ?? ''))).join(','))
+  }
+
+  return lines.join('\n')
+}
+
+export const csvRenderer: DocumentRenderer = {
+  async render(node: DocNode, _options?: RenderOptions): Promise<string> {
+    const tables = findTables(node)
+
+    if (tables.length === 0) {
+      return '# No tables found in document\n'
+    }
+
+    // If multiple tables, separate with blank lines
+    return `${tables.map(tableToCsv).join('\n\n')}\n`
+  },
+}

package/src/renderers/discord.ts

@@ -0,0 +1,192 @@
+import type {
+  DocChild,
+  DocNode,
+  DocumentRenderer,
+  RenderOptions,
+  TableColumn,
+} from '../types'
+
+/**
+ * Discord renderer — outputs embed JSON for Discord webhooks/bots.
+ * Uses Discord's markdown subset and embed structure.
+ */
+
+function resolveColumn(col: string | TableColumn): TableColumn {
+  return typeof col === 'string' ? { header: col } : col
+}
+
+function getTextContent(children: DocChild[]): string {
+  return children
+    .map((c) =>
+      typeof c === 'string' ? c : getTextContent((c as DocNode).children),
+    )
+    .join('')
+}
+
+interface DiscordField {
+  name: string
+  value: string
+  inline?: boolean
+}
+
+/** Extract the first h1 title and first HTTP image from the tree. */
+function extractMeta(node: DocNode): { title?: string; imageUrl?: string } {
+  if (node.type === 'heading') {
+    const level = (node.props.level as number) ?? 1
+    if (level === 1) return { title: getTextContent(node.children) }
+  }
+  if (node.type === 'image') {
+    const src = node.props.src as string
+    if (src.startsWith('http')) return { imageUrl: src }
+  }
+  for (const child of node.children) {
+    if (typeof child !== 'string') {
+      const result = extractMeta(child)
+      if (result.title || result.imageUrl) return result
+    }
+  }
+  return {}
+}
+
+function nodeToMarkdown(
+  node: DocNode,
+  meta: { title?: string },
+): { content: string; fields: DiscordField[] } {
+  const p = node.props
+  let content = ''
+  const fields: DiscordField[] = []
+
+  switch (node.type) {
+    case 'document':
+    case 'page':
+    case 'section':
+    case 'row':
+    case 'column':
+      for (const child of node.children) {
+        if (typeof child !== 'string') {
+          const result = nodeToMarkdown(child, meta)
+          content += result.content
+          fields.push(...result.fields)
+        }
+      }
+      break
+
+    case 'heading': {
+      const text = getTextContent(node.children)
+      const level = (p.level as number) ?? 1
+      // Skip the first h1 — it's used as embed title
+      if (level === 1 && text === meta.title) {
+        break
+      }
+      content += `**${text}**\n\n`
+      break
+    }
+
+    case 'text': {
+      let text = getTextContent(node.children)
+      if (p.bold) text = `**${text}**`
+      if (p.italic) text = `*${text}*`
+      if (p.strikethrough) text = `~~${text}~~`
+      content += `${text}\n\n`
+      break
+    }
+
+    case 'link': {
+      const href = p.href as string
+      const text = getTextContent(node.children)
+      content += `[${text}](${href})\n\n`
+      break
+    }
+
+    case 'image':
+      // Image handled via extractMeta — embedded as embed.image
+      break
+
+    case 'table': {
+      const columns = ((p.columns ?? []) as (string | TableColumn)[]).map(
+        resolveColumn,
+      )
+      const rows = (p.rows ?? []) as (string | number)[][]
+
+      // Use Discord embed fields for small tables
+      if (columns.length <= 3 && rows.length <= 10) {
+        for (const col of columns) {
+          const colIdx = columns.indexOf(col)
+          const values = rows.map((row) => String(row[colIdx] ?? '')).join('\n')
+          fields.push({
+            name: col.header,
+            value: values || '-',
+            inline: true,
+          })
+        }
+      } else {
+        // Fallback to code block for large tables
+        const header = columns.map((c) => c.header).join(' | ')
+        const separator = columns.map(() => '---').join(' | ')
+        const body = rows
+          .map((row) => row.map((c) => String(c ?? '')).join(' | '))
+          .join('\n')
+        content += `\`\`\`\n${header}\n${separator}\n${body}\n\`\`\`\n\n`
+      }
+      break
+    }
+
+    case 'list': {
+      const ordered = p.ordered as boolean | undefined
+      const items = node.children
+        .filter((c): c is DocNode => typeof c !== 'string')
+        .map((item, i) => {
+          const prefix = ordered ? `${i + 1}.` : '•'
+          return `${prefix} ${getTextContent(item.children)}`
+        })
+        .join('\n')
+      content += `${items}\n\n`
+      break
+    }
+
+    case 'code': {
+      const lang = (p.language as string) ?? ''
+      const text = getTextContent(node.children)
+      content += `\`\`\`${lang}\n${text}\n\`\`\`\n\n`
+      break
+    }
+
+    case 'divider':
+    case 'page-break':
+      content += '───────────\n\n'
+      break
+
+    case 'button': {
+      const href = p.href as string
+      const text = getTextContent(node.children)
+      content += `[**${text}**](${href})\n\n`
+      break
+    }
+
+    case 'quote': {
+      const text = getTextContent(node.children)
+      content += `> ${text}\n\n`
+      break
+    }
+  }
+
+  return { content, fields }
+}
+
+export const discordRenderer: DocumentRenderer = {
+  async render(node: DocNode, _options?: RenderOptions): Promise<string> {
+    const meta = extractMeta(node)
+    const { content, fields } = nodeToMarkdown(node, meta)
+
+    const embed: Record<string, unknown> = {
+      title: meta.title ?? (node.props.title as string) ?? undefined,
+      description: content.trim() || undefined,
+      color: 0x4f46e5,
+    }
+
+    if (fields.length > 0) embed.fields = fields
+    if (meta.imageUrl) embed.image = { url: meta.imageUrl }
+
+    return JSON.stringify({ embeds: [embed] }, null, 2)
+  },
+}