@uniweb/content-writer 0.1.1

package/src/plain-text.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview Convert ProseMirror documents to plain text
+ *
+ * Strips all markdown formatting, returning just the text content
+ * with newlines for structure. Useful for word counting, search
+ * indexing, and generating summaries.
+ */
+
+/**
+ * Extract plain text from a ProseMirror document.
+ *
+ * @param {Object} doc - ProseMirror document ({ type: "doc", content: [...] })
+ * @returns {string} Plain text with newlines between blocks
+ */
+export function docToPlainText(doc) {
+  if (!doc?.content) return ''
+
+  return doc.content
+    .map(node => nodeToPlainText(node))
+    .filter(s => s !== '')
+    .join('\n\n')
+}
+
+/**
+ * Extract plain text from a single ProseMirror node.
+ * @param {Object} node
+ * @returns {string}
+ */
+function nodeToPlainText(node) {
+  switch (node.type) {
+    case 'heading':
+    case 'paragraph':
+      return inlineToPlainText(node.content)
+
+    case 'codeBlock':
+      return node.content?.[0]?.text || ''
+
+    case 'blockquote':
+      if (!node.content) return ''
+      return node.content
+        .map(child => nodeToPlainText(child))
+        .filter(Boolean)
+        .join('\n\n')
+
+    case 'bulletList':
+    case 'orderedList':
+      return listToPlainText(node)
+
+    case 'table':
+      return tableToPlainText(node)
+
+    case 'dataBlock':
+    case 'divider':
+    case 'image':
+    case 'inset_ref':
+      return ''
+
+    default:
+      return ''
+  }
+}
+
+/**
+ * Extract plain text from inline content (array of text/image nodes).
+ * @param {Array} content
+ * @returns {string}
+ */
+function inlineToPlainText(content) {
+  if (!content) return ''
+  return content
+    .filter(node => node.type === 'text')
+    .map(node => node.text || '')
+    .join('')
+}
+
+/**
+ * Extract plain text from a list node.
+ * @param {Object} node - bulletList or orderedList
+ * @returns {string}
+ */
+function listToPlainText(node) {
+  if (!node.content) return ''
+  return node.content
+    .map(item => listItemToPlainText(item))
+    .filter(Boolean)
+    .join('\n')
+}
+
+/**
+ * Extract plain text from a list item.
+ * @param {Object} node - listItem node
+ * @returns {string}
+ */
+function listItemToPlainText(node) {
+  if (!node.content) return ''
+  return node.content
+    .map(child => {
+      if (child.type === 'paragraph') return inlineToPlainText(child.content)
+      if (child.type === 'bulletList' || child.type === 'orderedList') return listToPlainText(child)
+      return ''
+    })
+    .filter(Boolean)
+    .join('\n')
+}
+
+/**
+ * Extract plain text from a table node.
+ * @param {Object} node - table node
+ * @returns {string}
+ */
+function tableToPlainText(node) {
+  if (!node.content) return ''
+  return node.content
+    .map(row => {
+      if (!row.content) return ''
+      return row.content
+        .map(cell => inlineToPlainText(cell.content?.[0]?.type === 'paragraph' ? cell.content[0].content : null))
+        .filter(Boolean)
+        .join(' ')
+    })
+    .filter(Boolean)
+    .join('\n')
+}

package/src/serializer.js

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview Core ProseMirror document serializer
+ *
+ * Iterates doc.content and dispatches to node serializers.
+ */
+
+import {
+  serializeHeading,
+  serializeParagraph,
+  serializeImage,
+  serializeInsetRef,
+  serializeCodeBlock,
+  serializeDataBlock,
+  serializeBlockquote,
+  serializeBulletList,
+  serializeOrderedList,
+  serializeDivider,
+  serializeTable,
+  setSerializer,
+} from './nodes.js'
+
+const NODE_SERIALIZERS = {
+  heading: serializeHeading,
+  paragraph: serializeParagraph,
+  image: serializeImage,
+  inset_ref: serializeInsetRef,
+  codeBlock: serializeCodeBlock,
+  dataBlock: serializeDataBlock,
+  blockquote: serializeBlockquote,
+  bulletList: serializeBulletList,
+  orderedList: serializeOrderedList,
+  divider: serializeDivider,
+  table: serializeTable,
+}
+
+/**
+ * Serialize a single ProseMirror node to markdown.
+ * @param {Object} node - ProseMirror node
+ * @returns {string|null} Markdown string or null
+ */
+export function serializeNode(node) {
+  const serializer = NODE_SERIALIZERS[node.type]
+  if (!serializer) return null
+  return serializer(node)
+}
+
+// Wire up the circular reference for blockquotes
+setSerializer(serializeNode)
+
+/**
+ * Serialize a ProseMirror document to markdown.
+ * @param {Object} doc - ProseMirror document ({ type: "doc", content: [...] })
+ * @returns {string} Markdown string
+ */
+export function serializeDoc(doc) {
+  if (!doc?.content) return ''
+
+  return doc.content
+    .map(node => serializeNode(node))
+    .filter(s => s !== null && s !== undefined)
+    .join('\n\n')
+}

package/tests/attributes.test.js

@@ -0,0 +1,103 @@
+import { serializeAttributes } from '../src/attributes.js'
+
+describe('Attribute Serialization', () => {
+  test('returns empty string for null/undefined/empty', () => {
+    expect(serializeAttributes(null)).toBe('')
+    expect(serializeAttributes(undefined)).toBe('')
+    expect(serializeAttributes({})).toBe('')
+  })
+
+  test('skips null and undefined values', () => {
+    expect(serializeAttributes({ role: null, src: undefined })).toBe('')
+  })
+
+  test('serializes key=value pairs', () => {
+    expect(serializeAttributes({ role: 'hero' })).toBe('{role=hero}')
+  })
+
+  test('serializes multiple key=value pairs', () => {
+    expect(serializeAttributes({ width: 800, height: 600 })).toBe('{width=800 height=600}')
+  })
+
+  test('quotes values with spaces', () => {
+    expect(serializeAttributes({ rel: 'noopener noreferrer' })).toBe('{rel="noopener noreferrer"}')
+  })
+
+  test('serializes boolean attributes', () => {
+    expect(serializeAttributes({ autoplay: true, muted: true })).toBe('{autoplay muted}')
+  })
+
+  test('serializes class as dot notation', () => {
+    expect(serializeAttributes({ class: 'featured' })).toBe('{.featured}')
+  })
+
+  test('serializes multiple classes', () => {
+    expect(serializeAttributes({ class: 'featured rounded shadow' })).toBe('{.featured .rounded .shadow}')
+  })
+
+  test('serializes id as hash notation', () => {
+    expect(serializeAttributes({ id: 'main-logo' })).toBe('{#main-logo}')
+  })
+
+  test('serializes mixed attributes', () => {
+    const result = serializeAttributes({
+      class: 'featured',
+      id: 'main-logo',
+      width: 800,
+      loading: 'lazy',
+    })
+    expect(result).toBe('{.featured #main-logo width=800 loading=lazy}')
+  })
+
+  test('skips specified keys', () => {
+    const result = serializeAttributes(
+      { src: './image.jpg', alt: 'Photo', role: 'hero' },
+      ['src', 'alt']
+    )
+    expect(result).toBe('{role=hero}')
+  })
+
+  test('skips all keys if all are in skipKeys', () => {
+    const result = serializeAttributes(
+      { src: './image.jpg', alt: 'Photo' },
+      ['src', 'alt']
+    )
+    expect(result).toBe('')
+  })
+
+  test('serializes video attributes', () => {
+    const result = serializeAttributes({
+      role: 'video',
+      poster: './poster.jpg',
+      autoplay: true,
+      muted: true,
+      loop: true,
+    })
+    expect(result).toBe('{role=video poster=./poster.jpg autoplay muted loop}')
+  })
+
+  test('serializes boolean with other attributes', () => {
+    const result = serializeAttributes({
+      role: 'video',
+      controls: true,
+      muted: true,
+    })
+    expect(result).toBe('{role=video controls muted}')
+  })
+
+  test('serializes download with string value', () => {
+    expect(serializeAttributes({ download: 'annual-report.pdf' })).toBe('{download=annual-report.pdf}')
+  })
+
+  test('serializes download as boolean', () => {
+    expect(serializeAttributes({ download: true })).toBe('{download}')
+  })
+
+  test('serializes data attributes', () => {
+    const result = serializeAttributes({
+      class: 'info',
+      'data-tooltip': 'More info',
+    })
+    expect(result).toBe('{.info data-tooltip="More info"}')
+  })
+})

package/tests/frontmatter.test.js

@@ -0,0 +1,69 @@
+import { serializeFrontmatter } from '../src/frontmatter.js'
+
+describe('Frontmatter Serialization', () => {
+  test('returns empty string for null/undefined/empty', () => {
+    expect(serializeFrontmatter(null)).toBe('')
+    expect(serializeFrontmatter(undefined)).toBe('')
+    expect(serializeFrontmatter({})).toBe('')
+  })
+
+  test('serializes simple params', () => {
+    const result = serializeFrontmatter({ type: 'Hero' })
+    expect(result).toBe('---\ntype: Hero\n---')
+  })
+
+  test('serializes multiple params', () => {
+    const result = serializeFrontmatter({
+      type: 'Hero',
+      alignment: 'center',
+    })
+    expect(result).toBe('---\ntype: Hero\nalignment: center\n---')
+  })
+
+  test('skips null and undefined values', () => {
+    const result = serializeFrontmatter({
+      type: 'Hero',
+      background: null,
+      variant: undefined,
+      alignment: 'center',
+    })
+    expect(result).toBe('---\ntype: Hero\nalignment: center\n---')
+  })
+
+  test('returns empty string when all values are null', () => {
+    expect(serializeFrontmatter({ a: null, b: undefined })).toBe('')
+  })
+
+  test('serializes nested objects', () => {
+    const result = serializeFrontmatter({
+      type: 'Section',
+      params: { width: 1200, layout: 'grid' },
+    })
+    expect(result).toContain('type: Section')
+    expect(result).toContain('params:')
+    expect(result).toContain('width: 1200')
+    expect(result).toContain('layout: grid')
+    expect(result).toMatch(/^---\n/)
+    expect(result).toMatch(/\n---$/)
+  })
+
+  test('serializes boolean values', () => {
+    const result = serializeFrontmatter({ hidden: true })
+    expect(result).toBe('---\nhidden: true\n---')
+  })
+
+  test('serializes numeric values', () => {
+    const result = serializeFrontmatter({ order: 3 })
+    expect(result).toBe('---\norder: 3\n---')
+  })
+
+  test('serializes arrays', () => {
+    const result = serializeFrontmatter({
+      type: 'Page',
+      tags: ['featured', 'news'],
+    })
+    expect(result).toContain('tags:')
+    expect(result).toContain('- featured')
+    expect(result).toContain('- news')
+  })
+})

package/tests/marks.test.js

@@ -0,0 +1,315 @@
+import { serializeInlineContent } from '../src/marks.js'
+
+describe('Inline Content Serialization', () => {
+  test('serializes plain text', () => {
+    const content = [{ type: 'text', text: 'Hello world' }]
+    expect(serializeInlineContent(content)).toBe('Hello world')
+  })
+
+  test('serializes bold text', () => {
+    const content = [
+      { type: 'text', text: 'Some ' },
+      { type: 'text', text: 'bold', marks: [{ type: 'bold' }] },
+      { type: 'text', text: ' text' },
+    ]
+    expect(serializeInlineContent(content)).toBe('Some **bold** text')
+  })
+
+  test('serializes italic text', () => {
+    const content = [
+      { type: 'text', text: 'Some ' },
+      { type: 'text', text: 'italic', marks: [{ type: 'italic' }] },
+      { type: 'text', text: ' text' },
+    ]
+    expect(serializeInlineContent(content)).toBe('Some *italic* text')
+  })
+
+  test('serializes bold italic text', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'bold italic both',
+        marks: [{ type: 'bold' }, { type: 'italic' }],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe('***bold italic both***')
+  })
+
+  test('serializes nested formatting (bold with italic inside)', () => {
+    const content = [
+      { type: 'text', text: 'bold ', marks: [{ type: 'bold' }] },
+      {
+        type: 'text',
+        text: 'then italic',
+        marks: [{ type: 'italic' }, { type: 'bold' }],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe('**bold *****then italic***')
+  })
+
+  test('serializes inline code', () => {
+    const content = [
+      { type: 'text', text: 'Use the ' },
+      { type: 'text', text: "console.log('test')", marks: [{ type: 'code' }] },
+      { type: 'text', text: ' function.' },
+    ]
+    expect(serializeInlineContent(content)).toBe("Use the `console.log('test')` function.")
+  })
+
+  test('serializes simple link', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'Link text',
+        marks: [
+          { type: 'link', attrs: { href: 'https://example.com', title: 'Title' } },
+        ],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe('[Link text](https://example.com "Title")')
+  })
+
+  test('serializes link without title', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'Link',
+        marks: [
+          { type: 'link', attrs: { href: 'https://example.com', title: null } },
+        ],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe('[Link](https://example.com)')
+  })
+
+  test('serializes link with attributes', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'External Link',
+        marks: [
+          {
+            type: 'link',
+            attrs: {
+              href: 'https://example.com',
+              title: null,
+              target: '_blank',
+              rel: 'noopener noreferrer',
+            },
+          },
+        ],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe(
+      '[External Link](https://example.com){target=_blank rel="noopener noreferrer"}'
+    )
+  })
+
+  test('serializes download link (boolean)', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'Download PDF',
+        marks: [
+          {
+            type: 'link',
+            attrs: { href: './document.pdf', title: null, download: true },
+          },
+        ],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe('[Download PDF](./document.pdf){download}')
+  })
+
+  test('serializes download link with filename', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'Get Report',
+        marks: [
+          {
+            type: 'link',
+            attrs: { href: './data.pdf', title: null, download: 'annual-report.pdf' },
+          },
+        ],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe(
+      '[Get Report](./data.pdf){download=annual-report.pdf}'
+    )
+  })
+
+  test('serializes button link', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'Button Text',
+        marks: [
+          {
+            type: 'button',
+            attrs: { href: 'https://example.com', title: null, variant: 'primary' },
+          },
+        ],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe('[Button Text](button:https://example.com)')
+  })
+
+  test('serializes button with non-default variant', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'Get Started',
+        marks: [
+          {
+            type: 'button',
+            attrs: { href: 'https://example.com', title: null, variant: 'secondary', size: 'lg' },
+          },
+        ],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe(
+      '[Get Started](button:https://example.com){variant=secondary size=lg}'
+    )
+  })
+
+  test('serializes button with icon', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'Learn More',
+        marks: [
+          {
+            type: 'button',
+            attrs: { href: 'https://example.com', title: null, variant: 'primary', icon: 'arrow-right' },
+          },
+        ],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe(
+      '[Learn More](button:https://example.com){icon=arrow-right}'
+    )
+  })
+
+  test('serializes span with class', () => {
+    const content = [
+      { type: 'text', text: 'This is ' },
+      {
+        type: 'text',
+        text: 'highlighted text',
+        marks: [{ type: 'span', attrs: { class: 'highlight' } }],
+      },
+      { type: 'text', text: ' in a sentence.' },
+    ]
+    expect(serializeInlineContent(content)).toBe(
+      'This is [highlighted text]{.highlight} in a sentence.'
+    )
+  })
+
+  test('serializes span with multiple classes', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'important note',
+        marks: [{ type: 'span', attrs: { class: 'callout bold' } }],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe('[important note]{.callout .bold}')
+  })
+
+  test('serializes span with id and class', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'key term',
+        marks: [{ type: 'span', attrs: { class: 'highlight', id: 'glossary-term' } }],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe('[key term]{.highlight #glossary-term}')
+  })
+
+  test('serializes span with custom attributes', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'tooltip text',
+        marks: [{ type: 'span', attrs: { class: 'info', 'data-tooltip': 'More info' } }],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe('[tooltip text]{.info data-tooltip="More info"}')
+  })
+
+  test('serializes inline icon image', () => {
+    const content = [
+      {
+        type: 'image',
+        attrs: {
+          src: null,
+          caption: null,
+          alt: null,
+          role: 'icon',
+          library: 'lu',
+          name: 'home',
+        },
+      },
+      { type: 'text', text: ' ' },
+      {
+        type: 'text',
+        text: 'Sports',
+        marks: [
+          { type: 'link', attrs: { href: '/sports', title: null } },
+        ],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe('![](lu-home) [Sports](/sports)')
+  })
+
+  test('serializes multiple spans in same paragraph', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'first',
+        marks: [{ type: 'span', attrs: { class: 'highlight' } }],
+      },
+      { type: 'text', text: ' normal ' },
+      {
+        type: 'text',
+        text: 'second',
+        marks: [{ type: 'span', attrs: { class: 'muted' } }],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe('[first]{.highlight} normal [second]{.muted}')
+  })
+
+  test('serializes link and span in same paragraph', () => {
+    const content = [
+      {
+        type: 'text',
+        text: 'Link',
+        marks: [{ type: 'link', attrs: { href: 'https://example.com', title: null } }],
+      },
+      { type: 'text', text: ' and ' },
+      {
+        type: 'text',
+        text: 'span',
+        marks: [{ type: 'span', attrs: { class: 'highlight' } }],
+      },
+    ]
+    expect(serializeInlineContent(content)).toBe(
+      '[Link](https://example.com) and [span]{.highlight}'
+    )
+  })
+
+  test('returns empty string for empty content', () => {
+    expect(serializeInlineContent([])).toBe('')
+    expect(serializeInlineContent(null)).toBe('')
+    expect(serializeInlineContent(undefined)).toBe('')
+  })
+
+  test('serializes text with special characters', () => {
+    const content = [
+      { type: 'text', text: `text with 'single', "double", & specials` },
+    ]
+    expect(serializeInlineContent(content)).toBe(`text with 'single', "double", & specials`)
+  })
+})