@uniweb/content-writer 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/content-writer",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "ProseMirror document structure to Markdown converter",
   "type": "module",
   "main": "src/index.js",
@@ -19,7 +19,7 @@
   },
   "devDependencies": {
     "vitest": "^4.1.7",
-    "@uniweb/content-reader": "1.1.12"
+    "@uniweb/content-reader": "1.1.14"
   },
   "directories": {
     "test": "tests"

package/src/index.js

@@ -6,6 +6,7 @@
  */
 
 export { serializeDoc as proseMirrorToMarkdown } from './serializer.js'
+export { serializeInlineContent } from './marks.js'
 export { serializeFrontmatter } from './frontmatter.js'
 export { docToPlainText } from './plain-text.js'
 export { normalizeDialect } from './normalize.js'

package/src/marks.js

@@ -287,6 +287,12 @@ function serializePlainNode(node) {
     const latex = node.attrs?.latex || ''
     return node.attrs?.display ? '$$' + latex + '$$' : '$' + latex + '$'
   }
+  if (node.type === 'hardBreak') {
+    // Backslash rather than the two-trailing-spaces spelling: it survives
+    // editors, formatters and pre-commit hooks that strip trailing whitespace,
+    // and it is visible in a diff. Both spellings read back as a hard break.
+    return '\\\n'
+  }
   if (node.type !== 'text') {
     // No silent drops: an inline node we have no markdown form for is
     // still omitted (we can't invent one) but reported loudly, the same

package/src/normalize.js

@@ -180,6 +180,16 @@ function mapEditorNode(node) {
       return mapVideo(node)
     case 'UniwebIcon':
       return mapUniwebIcon(node)
+    case 'text':
+      // Legacy hard break: content-reader used to emit a hard break as a
+      // standalone "\n" text node. Self-heal it to the node form so old
+      // documents converge on the next write.
+      //
+      // Deliberately narrow — ONLY a text node whose text is exactly "\n".
+      // A newline INSIDE a larger text node is a SOFT break (an ordinary
+      // wrapped paragraph), which is a space and must stay one; mapping those
+      // would inject a visible break into every wrapped paragraph.
+      return node.text === '\n' ? { type: 'hardBreak' } : null
     default:
       return null
   }

package/tests/normalize.test.js

@@ -195,4 +195,27 @@ describe('no-silent-drop guard: unmappable nodes are reported, not lost', () =>
     expect(md).toBe('before  after')
     expect(warnings.some((m) => m.includes('FancyInlineWidget'))).toBe(true)
   })
+
+  test('a legacy standalone "\\n" text node self-heals to a hard break', () => {
+    const md = proseMirrorToMarkdown(
+      doc(
+        para(
+          { type: 'text', text: 'line one' },
+          { type: 'text', text: '\n' },
+          { type: 'text', text: 'line two' }
+        )
+      )
+    )
+    expect(md.trim()).toBe('line one\\\nline two')
+    expect(warnings).toEqual([]) // healed, not reported as unmapped
+  })
+
+  test('a newline INSIDE a text node is a soft break and must not be converted', () => {
+    // The narrow rule matters: this is an ordinary wrapped paragraph, which is
+    // a space. Converting it would inject a break into every wrapped paragraph.
+    const md = proseMirrorToMarkdown(
+      doc(para({ type: 'text', text: 'wrapped\nparagraph' }))
+    )
+    expect(md.trim()).toBe('wrapped\nparagraph')
+  })
 })

package/tests/roundtrip.test.js

@@ -358,3 +358,34 @@ describe('Round-trip: Mixed Content', () => {
     expect(reparsed).toEqual(parsed)
   })
 })
+
+describe('Round-trip: Hard breaks', () => {
+  // A hard break used to become a "\n" text node, which re-parsed as a SOFT
+  // break — so the break was silently downgraded on every round trip. It is a
+  // `hardBreak` node now, and both markdown spellings converge on the
+  // backslash form.
+  testRoundTrip('line one\\\nline two', 'backslash hard break')
+  testRoundTrip('a\\\nb\\\nc', 'consecutive hard breaks')
+  testRoundTrip('**bold**\\\nplain', 'hard break after a mark')
+
+  test('two-space spelling normalizes to backslash and keeps the break', () => {
+    const parsed = markdownToProseMirror('line one  \nline two')
+    expect(parsed.content[0].content).toEqual([
+      { type: 'text', text: 'line one' },
+      { type: 'hardBreak' },
+      { type: 'text', text: 'line two' }
+    ])
+    // One-time source normalization; the break itself survives.
+    const serialized = proseMirrorToMarkdown(parsed).trim()
+    expect(serialized).toBe('line one\\\nline two')
+    expect(markdownToProseMirror(serialized)).toEqual(parsed)
+  })
+
+  test('a soft break stays soft — it is a space, not a break', () => {
+    const parsed = markdownToProseMirror('wrapped\nparagraph')
+    expect(parsed.content[0].content).toEqual([
+      { type: 'text', text: 'wrapped\nparagraph' }
+    ])
+    expect(proseMirrorToMarkdown(parsed).trim()).toBe('wrapped\nparagraph')
+  })
+})