@uniweb/content-writer 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/content-writer",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "ProseMirror document structure to Markdown converter",
   "type": "module",
   "main": "src/index.js",
@@ -19,7 +19,7 @@
   },
   "devDependencies": {
     "jest": "^29.7.0",
-    "@uniweb/content-reader": "1.1.4"
+    "@uniweb/content-reader": "1.1.5"
   },
   "jest": {
     "testEnvironment": "node",

package/src/marks.js

@@ -222,6 +222,10 @@ function serializePlainNode(node) {
   if (node.type === 'image') {
     return serializeInlineImage(node)
   }
+  if (node.type === 'math_inline') {
+    const latex = node.attrs?.latex || ''
+    return node.attrs?.display ? '$$' + latex + '$$' : '$' + latex + '$'
+  }
   if (node.type !== 'text') return ''
   return serializeTextWithMarks(node.text, node.marks || [])
 }

package/src/nodes.js

@@ -60,6 +60,30 @@ export function serializeCodeBlock(node) {
   return `\`\`\`${lang}${tag}\n${text}\n\`\`\``
 }
 
+/**
+ * Serialize a display-math node back to markdown.
+ *
+ * Labeled math (with an id) always uses the fenced form `` ```math:<id> ``
+ * because `$$...$$` has no label syntax.
+ *
+ * Single-line LaTeX uses `$$...$$` (compact, ecosystem-standard).
+ * Multi-line LaTeX uses fenced ```math (friendlier diffs, no ambiguity
+ * with paragraphs that contain a stray `$$`).
+ *
+ * @param {Object} node - math_display node with attrs.latex and optional attrs.id
+ * @returns {string} Markdown math block
+ */
+export function serializeMathDisplay(node) {
+  const latex = node.attrs?.latex || ''
+  const id = node.attrs?.id
+  if (id) {
+    return '```math:' + id + '\n' + latex + '\n```'
+  }
+  return latex.includes('\n')
+    ? '```math\n' + latex + '\n```'
+    : '$$' + latex + '$$'
+}
+
 /**
  * Serialize a data block node.
  * @param {Object} node - Data block node with attrs.tag and attrs.data

package/src/serializer.js

@@ -16,6 +16,7 @@ import {
   serializeOrderedList,
   serializeDivider,
   serializeTable,
+  serializeMathDisplay,
   setSerializer,
 } from './nodes.js'
 
@@ -31,6 +32,7 @@ const NODE_SERIALIZERS = {
   orderedList: serializeOrderedList,
   divider: serializeDivider,
   table: serializeTable,
+  math_display: serializeMathDisplay,
 }
 
 /**

package/tests/math.test.js

@@ -0,0 +1,72 @@
+/**
+ * Math round-trip tests: markdown → content-reader → content-writer → content-reader.
+ *
+ * The identity we check is at the ProseMirror-doc level, not the markdown
+ * string — content-writer is free to normalise whitespace or attribute
+ * order as long as the re-parsed doc matches the original.
+ *
+ * The `mathml` attribute is expected to drift across the round trip only
+ * if Temml output is non-deterministic; in practice it is stable, so we
+ * assert both `latex` and `mathml` survive.
+ */
+
+import { markdownToProseMirror } from '@uniweb/content-reader'
+import { proseMirrorToMarkdown } from '../src/index.js'
+
+function roundTrip(markdown) {
+  const parsed = markdownToProseMirror(markdown)
+  const serialized = proseMirrorToMarkdown(parsed)
+  const reparsed = markdownToProseMirror(serialized)
+  return { parsed, serialized, reparsed }
+}
+
+describe('Math round-trip', () => {
+  test('inline math: $x^2$', () => {
+    const { parsed, reparsed } = roundTrip('Let $x^2$ be a square.')
+    expect(reparsed).toEqual(parsed)
+  })
+
+  test('block display math: $$...$$', () => {
+    const { parsed, reparsed } = roundTrip('$$\\sum_{i=1}^n i$$')
+    expect(reparsed).toEqual(parsed)
+  })
+
+  test('multi-line block math uses fenced ```math form', () => {
+    const input = '```math\n\\int_0^\\infty\ne^{-x}\\,dx\n```'
+    const { parsed, serialized, reparsed } = roundTrip(input)
+    expect(serialized.startsWith('```math')).toBe(true)
+    expect(reparsed).toEqual(parsed)
+  })
+
+  test('mixed paragraph: text, inline math, more text', () => {
+    const { parsed, reparsed } = roundTrip(
+      'Given $a + b$ we derive $c$.',
+    )
+    expect(reparsed).toEqual(parsed)
+  })
+
+  test('inline math_display via $$...$$ mid-paragraph', () => {
+    const { parsed, reparsed } = roundTrip('text $$x^2$$ more')
+    expect(reparsed).toEqual(parsed)
+  })
+
+  test('inline math serializes with single $ delimiters', () => {
+    const { serialized } = roundTrip('value is $\\pi$.')
+    expect(serialized).toContain('$\\pi$')
+  })
+
+  test('block math serializes with $$ delimiters on single line', () => {
+    const { serialized } = roundTrip('$$E = mc^2$$')
+    expect(serialized).toContain('$$E = mc^2$$')
+  })
+
+  test('labeled fenced math preserves id through roundtrip', () => {
+    const input = '```math:einstein\nE = mc^2\n```'
+    const { parsed, serialized, reparsed } = roundTrip(input)
+    expect(serialized).toContain('```math:einstein')
+    expect(reparsed).toEqual(parsed)
+    // The id is carried as an attribute on math_display.
+    const node = parsed.content.find((n) => n.type === 'math_display')
+    expect(node?.attrs?.id).toBe('einstein')
+  })
+})