@uniweb/content-writer 0.1.1

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@uniweb/content-writer",
+  "version": "0.1.1",
+  "description": "ProseMirror document structure to Markdown converter",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "keywords": [
+    "markdown",
+    "prosemirror",
+    "serializer"
+  ],
+  "author": "Proximify Inc.",
+  "license": "GPL-3.0-or-later",
+  "dependencies": {
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "@uniweb/content-reader": "1.1.4"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "verbose": true
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uniweb/content-writer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/uniweb/content-writer/issues"
+  },
+  "homepage": "https://github.com/uniweb/content-writer#readme",
+  "scripts": {
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch"
+  }
+}

package/src/attributes.js

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Serialize attributes to curly brace syntax
+ *
+ * Inverse of content-reader's attributes.js.
+ * Produces syntax like: {role=hero width=1200 .class #id autoplay}
+ */
+
+/**
+ * Serialize an attributes object to curly brace syntax.
+ *
+ * @param {Object} attrs - Attributes object
+ * @param {string[]} [skipKeys=[]] - Keys to skip (already encoded elsewhere)
+ * @returns {string} Serialized attributes string (e.g., "{role=hero width=1200}") or empty string
+ */
+export function serializeAttributes(attrs, skipKeys = []) {
+  if (!attrs || typeof attrs !== 'object') return ''
+
+  const parts = []
+  const skipSet = new Set(skipKeys)
+
+  for (const [key, value] of Object.entries(attrs)) {
+    if (skipSet.has(key)) continue
+    if (value === null || value === undefined) continue
+
+    if (key === 'class') {
+      // Split class string into individual .class entries
+      const classes = String(value).split(/\s+/).filter(Boolean)
+      for (const cls of classes) {
+        parts.push(`.${cls}`)
+      }
+    } else if (key === 'id') {
+      parts.push(`#${value}`)
+    } else if (value === true) {
+      // Boolean attribute
+      parts.push(key)
+    } else {
+      // Key=value pair
+      const strValue = String(value)
+      if (strValue.includes(' ')) {
+        parts.push(`${key}="${strValue}"`)
+      } else {
+        parts.push(`${key}=${strValue}`)
+      }
+    }
+  }
+
+  if (parts.length === 0) return ''
+  return `{${parts.join(' ')}}`
+}

package/src/frontmatter.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview YAML frontmatter serialization
+ */
+
+import yaml from 'js-yaml'
+
+/**
+ * Serialize a params object to YAML frontmatter.
+ *
+ * @param {Object} params - Frontmatter parameters
+ * @returns {string} YAML frontmatter block (with --- fences) or empty string
+ */
+export function serializeFrontmatter(params) {
+  if (!params || typeof params !== 'object') return ''
+
+  // Filter out null/undefined values
+  const filtered = {}
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== null && value !== undefined) {
+      filtered[key] = value
+    }
+  }
+
+  if (Object.keys(filtered).length === 0) return ''
+
+  const yamlStr = yaml.dump(filtered, {
+    lineWidth: -1,        // Don't wrap long lines
+    quotingType: "'",     // Use single quotes when quoting is needed
+    forceQuotes: false,   // Only quote when necessary
+    noRefs: true,         // Don't use YAML references
+  }).trimEnd()
+
+  return `---\n${yamlStr}\n---`
+}

package/src/index.js

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview ProseMirror document to Markdown converter
+ *
+ * The inverse of @uniweb/content-reader. Serializes ProseMirror JSON
+ * documents back to Markdown text.
+ */
+
+export { serializeDoc as proseMirrorToMarkdown } from './serializer.js'
+export { serializeFrontmatter } from './frontmatter.js'
+export { docToPlainText } from './plain-text.js'
+
+import { serializeDoc } from './serializer.js'
+import { serializeFrontmatter } from './frontmatter.js'
+
+/**
+ * Serialize a complete section file (frontmatter + body).
+ *
+ * @param {Object} params - Frontmatter parameters (type, alignment, etc.)
+ * @param {Object} doc - ProseMirror document JSON
+ * @returns {string} Complete markdown file content
+ */
+export function serializeSection(params, doc) {
+  const frontmatter = serializeFrontmatter(params)
+  const body = serializeDoc(doc)
+
+  if (frontmatter && body) {
+    return `${frontmatter}\n\n${body}\n`
+  }
+  if (frontmatter) {
+    return `${frontmatter}\n`
+  }
+  if (body) {
+    return `${body}\n`
+  }
+  return ''
+}

package/src/marks.js

@@ -0,0 +1,254 @@
+/**
+ * @fileoverview Serialize inline ProseMirror content (text nodes with marks) to markdown
+ *
+ * Handles mark interleaving, link/button/span wrapping, and bold/italic nesting.
+ */
+
+import { serializeAttributes } from './attributes.js'
+
+/**
+ * Check if a node has a specific mark type.
+ * @param {Object} node - ProseMirror inline node
+ * @param {string} type - Mark type
+ * @returns {Object|undefined} The mark object if found
+ */
+function findMark(node, type) {
+  return node.marks?.find(m => m.type === type)
+}
+
+/**
+ * Check if two marks are the same (same type and same attrs for link/button/span).
+ */
+function marksEqual(a, b) {
+  if (a.type !== b.type) return false
+  if (a.type === 'link' || a.type === 'button' || a.type === 'span') {
+    return JSON.stringify(a.attrs) === JSON.stringify(b.attrs)
+  }
+  return true
+}
+
+/**
+ * Serialize a link mark's suffix: (href "title"){attrs}
+ */
+function serializeLinkSuffix(mark) {
+  const { href, title, ...rest } = mark.attrs || {}
+  const titlePart = title ? ` "${title}"` : ''
+  const attrStr = serializeAttributes(rest, ['href', 'title'])
+  return `(${href}${titlePart})${attrStr}`
+}
+
+/**
+ * Serialize a button mark's suffix: (button:href "title"){attrs}
+ */
+function serializeButtonSuffix(mark) {
+  const { href, title, variant, ...rest } = mark.attrs || {}
+  const titlePart = title ? ` "${title}"` : ''
+  // Build attrs with variant first for consistent ordering
+  const extraAttrs = {}
+  if (variant && variant !== 'primary') {
+    extraAttrs.variant = variant
+  }
+  Object.assign(extraAttrs, rest)
+  const attrStr = serializeAttributes(extraAttrs, ['href', 'title'])
+  return `(button:${href}${titlePart})${attrStr}`
+}
+
+/**
+ * Serialize a span mark's suffix: {.class #id attrs}
+ */
+function serializeSpanSuffix(mark) {
+  return serializeAttributes(mark.attrs || {})
+}
+
+/**
+ * Serialize an inline image node (icon within a paragraph).
+ */
+function serializeInlineImage(node) {
+  const { src, alt, caption, role, library, name, ...rest } = node.attrs || {}
+
+  // Icon with library+name → compact dash format
+  if (library && name) {
+    const iconSrc = `${library}-${name}`
+    const extraAttrs = { ...rest }
+    // Remove icon-derived attrs from extra attrs
+    delete extraAttrs.size
+    delete extraAttrs.color
+    // Add back size and color if they exist
+    if (node.attrs.size) extraAttrs.size = node.attrs.size
+    if (node.attrs.color) extraAttrs.color = node.attrs.color
+    const attrStr = serializeAttributes(extraAttrs)
+    const altPart = alt || ''
+    return `![${altPart}](${iconSrc})${attrStr}`
+  }
+
+  // Icon with src and role=icon → icon:src prefix
+  if (role === 'icon' && src) {
+    const attrStr = serializeAttributes(rest, ['role'])
+    const altPart = alt || ''
+    const captionPart = caption ? ` "${caption}"` : ''
+    return `![${altPart}](icon:${src}${captionPart})${attrStr}`
+  }
+
+  // Regular image (shouldn't normally appear inline, but handle it)
+  return serializeBlockImage(node)
+}
+
+/**
+ * Serialize a block-level image node.
+ */
+export function serializeBlockImage(node) {
+  const { src, alt, caption, role, library, name, ...rest } = node.attrs || {}
+
+  // Icon with library+name → compact dash format
+  if (library && name) {
+    const iconSrc = `${library}-${name}`
+    const extraAttrs = { ...rest }
+    const attrStr = serializeAttributes(extraAttrs)
+    const altPart = alt || ''
+    return `![${altPart}](${iconSrc})${attrStr}`
+  }
+
+  // Build the src part
+  let srcPart = src || ''
+
+  // For non-default roles, use role:src prefix format (except for video/pdf which use attrs)
+  // Build attrs with role first for consistent ordering
+  const attrsToSerialize = {}
+  if (role && role !== 'image') {
+    if (role === 'icon' && src) {
+      srcPart = `icon:${src}`
+    } else {
+      attrsToSerialize.role = role
+    }
+  }
+  Object.assign(attrsToSerialize, rest)
+
+  const altPart = alt || ''
+  const captionPart = caption ? ` "${caption}"` : ''
+  const attrStr = serializeAttributes(attrsToSerialize)
+  return `![${altPart}](${srcPart}${captionPart})${attrStr}`
+}
+
+/**
+ * Serialize an array of inline ProseMirror nodes to a markdown string.
+ *
+ * @param {Array} content - Array of text/image nodes with optional marks
+ * @returns {string} Markdown string
+ */
+export function serializeInlineContent(content) {
+  if (!content || content.length === 0) return ''
+
+  // Pre-process: group nodes by wrapping marks (link, button, span)
+  const segments = groupByWrappingMarks(content)
+  return segments.map(seg => serializeSegment(seg)).join('')
+}
+
+/**
+ * Group consecutive nodes by shared wrapping marks (link, button, span).
+ * Returns an array of segments, where each segment is either:
+ * - { type: 'link'|'button'|'span', mark, nodes } — wrapped group
+ * - { type: 'plain', nodes } — unwrapped nodes
+ */
+function groupByWrappingMarks(content) {
+  const segments = []
+  let i = 0
+
+  while (i < content.length) {
+    const node = content[i]
+
+    // Check for wrapping marks: link, button, span
+    const linkMark = findMark(node, 'link')
+    const buttonMark = findMark(node, 'button')
+    const spanMark = findMark(node, 'span')
+    const wrappingMark = buttonMark || linkMark || spanMark
+
+    if (wrappingMark && node.type === 'text') {
+      // Collect consecutive nodes with the same wrapping mark
+      const group = [node]
+      let j = i + 1
+      while (j < content.length && content[j].type === 'text') {
+        const nextMark = findMark(content[j], wrappingMark.type)
+        if (nextMark && marksEqual(nextMark, wrappingMark)) {
+          group.push(content[j])
+          j++
+        } else {
+          break
+        }
+      }
+      segments.push({ type: wrappingMark.type, mark: wrappingMark, nodes: group })
+      i = j
+    } else {
+      // Plain node (no wrapping mark, or an image node)
+      segments.push({ type: 'plain', nodes: [node] })
+      i++
+    }
+  }
+
+  return segments
+}
+
+/**
+ * Serialize a segment (group of nodes with a common wrapping mark, or plain nodes).
+ */
+function serializeSegment(segment) {
+  if (segment.type === 'plain') {
+    return segment.nodes.map(n => serializePlainNode(n)).join('')
+  }
+
+  // Wrapped segment: serialize inner content (with the wrapping mark stripped)
+  const innerText = segment.nodes.map(node => {
+    // Strip the wrapping mark from this node's marks for inner serialization
+    const innerMarks = (node.marks || []).filter(m => !marksEqual(m, segment.mark))
+    return serializeTextWithMarks(node.text, innerMarks)
+  }).join('')
+
+  if (segment.type === 'link') {
+    return `[${innerText}]${serializeLinkSuffix(segment.mark)}`
+  }
+  if (segment.type === 'button') {
+    return `[${innerText}]${serializeButtonSuffix(segment.mark)}`
+  }
+  if (segment.type === 'span') {
+    return `[${innerText}]${serializeSpanSuffix(segment.mark)}`
+  }
+
+  return innerText
+}
+
+/**
+ * Serialize a plain node (no wrapping mark).
+ */
+function serializePlainNode(node) {
+  if (node.type === 'image') {
+    return serializeInlineImage(node)
+  }
+  if (node.type !== 'text') return ''
+  return serializeTextWithMarks(node.text, node.marks || [])
+}
+
+/**
+ * Serialize text with formatting marks (bold, italic, code).
+ */
+function serializeTextWithMarks(text, marks) {
+  if (!marks || marks.length === 0) return text
+
+  const hasCode = marks.some(m => m.type === 'code')
+  if (hasCode) {
+    return `\`${text}\``
+  }
+
+  const hasBold = marks.some(m => m.type === 'bold')
+  const hasItalic = marks.some(m => m.type === 'italic')
+
+  if (hasBold && hasItalic) {
+    return `***${text}***`
+  }
+  if (hasBold) {
+    return `**${text}**`
+  }
+  if (hasItalic) {
+    return `*${text}*`
+  }
+
+  return text
+}

package/src/nodes.js

@@ -0,0 +1,232 @@
+/**
+ * @fileoverview Block-level node serializers
+ *
+ * Each function takes a ProseMirror node and returns a markdown string.
+ */
+
+import { serializeInlineContent, serializeBlockImage } from './marks.js'
+import { serializeAttributes } from './attributes.js'
+
+/**
+ * Serialize a heading node.
+ * @param {Object} node - Heading node with attrs.level and content
+ * @returns {string} Markdown heading
+ */
+export function serializeHeading(node) {
+  const prefix = '#'.repeat(node.attrs?.level || 1)
+  const text = serializeInlineContent(node.content)
+  return `${prefix} ${text}`
+}
+
+/**
+ * Serialize a paragraph node.
+ * @param {Object} node - Paragraph node with content
+ * @returns {string} Markdown paragraph text
+ */
+export function serializeParagraph(node) {
+  return serializeInlineContent(node.content)
+}
+
+/**
+ * Serialize an image node (block-level).
+ * @param {Object} node - Image node with attrs
+ * @returns {string} Markdown image
+ */
+export function serializeImage(node) {
+  return serializeBlockImage(node)
+}
+
+/**
+ * Serialize an inset_ref node (component reference).
+ * @param {Object} node - Inset ref node with attrs.component
+ * @returns {string} Markdown component reference
+ */
+export function serializeInsetRef(node) {
+  const { component, alt, ...rest } = node.attrs || {}
+  const altPart = alt || ''
+  const attrStr = serializeAttributes(rest)
+  return `![${altPart}](@${component})${attrStr}`
+}
+
+/**
+ * Serialize a code block node.
+ * @param {Object} node - Code block node with attrs.language and content
+ * @returns {string} Fenced code block
+ */
+export function serializeCodeBlock(node) {
+  const lang = node.attrs?.language || ''
+  const tag = node.attrs?.tag ? `:${node.attrs.tag}` : ''
+  const text = node.content?.[0]?.text || ''
+  return `\`\`\`${lang}${tag}\n${text}\n\`\`\``
+}
+
+/**
+ * Serialize a data block node.
+ * @param {Object} node - Data block node with attrs.tag and attrs.data
+ * @returns {string} Tagged fenced code block with serialized data
+ */
+export function serializeDataBlock(node) {
+  const { tag, data } = node.attrs || {}
+  const serialized = JSON.stringify(data, null, 2)
+  return `\`\`\`json:${tag}\n${serialized}\n\`\`\``
+}
+
+/**
+ * Serialize a blockquote node.
+ * @param {Object} node - Blockquote node with content
+ * @returns {string} Blockquote with > prefix
+ */
+export function serializeBlockquote(node) {
+  if (!node.content) return '>'
+
+  // Recursively serialize the blockquote's content
+  const { serializeNode } = await_serializer()
+  const innerLines = node.content
+    .map(child => serializeNode(child))
+    .filter(Boolean)
+    .join('\n\n')
+
+  return innerLines
+    .split('\n')
+    .map(line => line ? `> ${line}` : '>')
+    .join('\n')
+}
+
+/**
+ * Serialize a bullet list node.
+ * @param {Object} node - Bullet list node with content (listItem nodes)
+ * @param {number} [indent=0] - Indentation level
+ * @returns {string} Markdown bullet list
+ */
+export function serializeBulletList(node, indent = 0) {
+  if (!node.content) return ''
+  const prefix = '  '.repeat(indent)
+  return node.content
+    .map(item => serializeListItem(item, `${prefix}- `, indent))
+    .join('\n')
+}
+
+/**
+ * Serialize an ordered list node.
+ * @param {Object} node - Ordered list node with attrs.start and content
+ * @param {number} [indent=0] - Indentation level
+ * @returns {string} Markdown ordered list
+ */
+export function serializeOrderedList(node, indent = 0) {
+  if (!node.content) return ''
+  const start = node.attrs?.start || 1
+  const prefix = '  '.repeat(indent)
+  return node.content
+    .map((item, i) => serializeListItem(item, `${prefix}${start + i}. `, indent))
+    .join('\n')
+}
+
+/**
+ * Serialize a list item.
+ * @param {Object} node - List item node with content
+ * @param {string} bullet - The bullet prefix (e.g., "- " or "1. ")
+ * @param {number} indent - Current indentation level
+ * @returns {string} Markdown list item
+ */
+function serializeListItem(node, bullet, indent) {
+  if (!node.content) return bullet
+
+  const parts = []
+
+  for (let i = 0; i < node.content.length; i++) {
+    const child = node.content[i]
+
+    if (i === 0 && child.type === 'paragraph') {
+      // First child paragraph is the item text
+      parts.push(bullet + serializeInlineContent(child.content))
+    } else if (child.type === 'bulletList') {
+      parts.push(serializeBulletList(child, indent + 1))
+    } else if (child.type === 'orderedList') {
+      parts.push(serializeOrderedList(child, indent + 1))
+    } else if (child.type === 'paragraph') {
+      // Additional paragraphs in the same list item
+      const pad = ' '.repeat(bullet.length)
+      parts.push(pad + serializeInlineContent(child.content))
+    }
+  }
+
+  return parts.join('\n')
+}
+
+/**
+ * Serialize a divider node.
+ * @returns {string} Markdown horizontal rule
+ */
+export function serializeDivider() {
+  return '---'
+}
+
+/**
+ * Serialize a table node.
+ * @param {Object} node - Table node with content (tableRow nodes)
+ * @returns {string} GFM table
+ */
+export function serializeTable(node) {
+  if (!node.content || node.content.length === 0) return ''
+
+  const rows = node.content
+  const headerRow = rows[0]
+  const bodyRows = rows.slice(1)
+
+  // Serialize header cells
+  const headerCells = headerRow.content.map(cell => serializeTableCell(cell))
+
+  // Build alignment row from header cell attrs
+  const alignments = headerRow.content.map(cell => {
+    const align = cell.attrs?.align
+    if (align === 'left') return ':---'
+    if (align === 'center') return ':---:'
+    if (align === 'right') return '---:'
+    return '---'
+  })
+
+  // Serialize body rows
+  const bodyLines = bodyRows.map(row =>
+    '| ' + row.content.map(cell => serializeTableCell(cell)).join(' | ') + ' |'
+  )
+
+  const headerLine = '| ' + headerCells.join(' | ') + ' |'
+  const alignLine = '| ' + alignments.join(' | ') + ' |'
+
+  return [headerLine, alignLine, ...bodyLines].join('\n')
+}
+
+/**
+ * Serialize a table cell's content.
+ * @param {Object} cell - Table cell node
+ * @returns {string} Cell content as inline markdown
+ */
+function serializeTableCell(cell) {
+  if (!cell.content) return ''
+  // Table cells contain paragraphs; serialize their inline content
+  return cell.content
+    .map(child => {
+      if (child.type === 'paragraph') {
+        return serializeInlineContent(child.content)
+      }
+      return ''
+    })
+    .join(' ')
+}
+
+// Lazy reference to serializeNode to handle circular dependency with blockquote
+let _serializeNode = null
+function await_serializer() {
+  if (!_serializeNode) {
+    throw new Error('Serializer not initialized — call setSerializer() first')
+  }
+  return { serializeNode: _serializeNode }
+}
+
+/**
+ * Set the serializer reference for recursive node serialization (blockquotes).
+ * @param {Function} fn - The serializeNode function from serializer.js
+ */
+export function setSerializer(fn) {
+  _serializeNode = fn
+}