@tessera-editor/core 0.1.0

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@tessera-editor/core",
+  "version": "0.1.0",
+  "description": "Tessera framework-agnostic editor core",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./styles.css": {
+      "development": "./src/styles/tessera.css",
+      "default": "./dist/tessera.css"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@tiptap/core": "^3.31.3",
+    "@tiptap/extension-color": "^3.31.3",
+    "@tiptap/extension-highlight": "^3.31.3",
+    "@tiptap/extension-list": "^3.31.3",
+    "@tiptap/extension-table": "^3.31.3",
+    "@tiptap/extension-text-style": "^3.31.3",
+    "@tiptap/extension-unique-id": "^3.31.3",
+    "@tiptap/extensions": "^3.31.3",
+    "@tiptap/pm": "^3.31.3",
+    "@tiptap/starter-kit": "^3.31.3",
+    "@tiptap/suggestion": "^3.31.3",
+    "markdown-it": "^15.0.1",
+    "prosemirror-markdown": "^1.13.7",
+    "prosemirror-tables": "^1.8.5"
+  },
+  "devDependencies": {
+    "@types/markdown-it": "^14.2.0",
+    "jsdom": "^30.0.1",
+    "vitest": "^5.0.0"
+  },
+  "keywords": [
+    "rich-text",
+    "editor",
+    "tiptap",
+    "prosemirror",
+    "wysiwyg"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mofishless/tessera-editor.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/mofishless/tessera-editor/tree/main/packages/core#readme",
+  "bugs": "https://github.com/mofishless/tessera-editor/issues",
+  "sideEffects": [
+    "*.css"
+  ],
+  "module": "./dist/index.js",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "build": "tsup"
+  }
+}

package/src/__tests__/markdown.test.ts

@@ -0,0 +1,138 @@
+// @vitest-environment jsdom
+import { describe, it, expect } from 'vitest'
+import { Editor } from '@tiptap/core'
+import { createTesseraExtensions } from '../preset'
+import { docToMarkdown, markdownToDoc, stableJson } from '../markdown'
+import type { JSONContent } from '@tiptap/core'
+
+function makeEditor() {
+  return new Editor({ extensions: createTesseraExtensions({ locale: 'zh-CN' }) })
+}
+
+const richDoc: JSONContent = {
+  type: 'doc',
+  content: [
+    { type: 'heading', attrs: { level: 2 }, content: [{ type: 'text', text: 'Title' }] },
+    {
+      type: 'paragraph',
+      content: [
+        { type: 'text', marks: [{ type: 'bold' }], text: 'bold' },
+        { type: 'text', text: ' and ' },
+        { type: 'text', marks: [{ type: 'italic' }], text: 'italic' },
+        { type: 'text', text: ' and ' },
+        { type: 'text', marks: [{ type: 'underline' }], text: 'underline' },
+        { type: 'text', text: ' and ' },
+        { type: 'text', marks: [{ type: 'strike' }], text: 'strike' },
+        { type: 'text', text: ' and ' },
+        { type: 'text', marks: [{ type: 'code' }], text: 'inline' },
+        { type: 'text', text: ' and ' },
+        { type: 'text', marks: [{ type: 'highlight' }], text: 'highlight' },
+        { type: 'text', text: ' and a ' },
+        { type: 'text', marks: [{ type: 'link', attrs: { href: 'https://example.com' } }], text: 'link' },
+      ],
+    },
+    { type: 'blockquote', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Quoted' }] }] },
+    {
+      type: 'bulletList',
+      content: [{ type: 'listItem', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Bullet' }] }] }],
+    },
+    {
+      type: 'orderedList',
+      content: [{ type: 'listItem', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Numbered' }] }] }],
+    },
+    {
+      type: 'taskList',
+      content: [
+        { type: 'taskItem', attrs: { checked: true }, content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Done' }] }] },
+        { type: 'taskItem', attrs: { checked: false }, content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Todo' }] }] },
+      ],
+    },
+    { type: 'codeBlock', attrs: { language: 'ts' }, content: [{ type: 'text', text: 'const x = 1' }] },
+    {
+      type: 'hint',
+      attrs: { variant: 'warning' },
+      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Careful' }] }],
+    },
+    {
+      type: 'collapsible',
+      attrs: { open: true },
+      content: [
+        { type: 'collapsibleSummary', content: [{ type: 'text', text: 'Summary line' }] },
+        { type: 'collapsibleContent', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Body' }] }] },
+      ],
+    },
+    { type: 'imageBlock', attrs: { src: 'https://example.com/a.png', alt: 'pic', width: 320, align: 'center' } },
+    { type: 'horizontalRule' },
+  ],
+}
+
+/** Trailing empty paragraphs (TrailingNode) are whitespace: not preserved in Markdown. */
+function dropTrailingEmptyParagraph(json: JSONContent): JSONContent {
+  const content = json.content ? [...json.content] : []
+  while (content.length > 0) {
+    const last = content[content.length - 1]!
+    if (last.type === 'paragraph' && !last.content) {
+      content.pop()
+    } else {
+      break
+    }
+  }
+  return { ...json, content }
+}
+
+describe('markdown interchange', () => {
+  it('round-trips a representative document (ids stripped)', () => {
+    const editor = makeEditor()
+    editor.commands.setContent(richDoc)
+    const canonical = dropTrailingEmptyParagraph(stableJson(editor.getJSON()))
+    const mdText = docToMarkdown(editor.state.doc, editor.state.schema)
+    expect(mdText).toContain('#'.repeat(2) + ' Title')
+    expect(mdText).toContain('**bold**')
+    expect(mdText).toContain('- [x] Done')
+    expect(mdText).toContain('data-type="hint"')
+    expect(mdText).toContain('data-type="collapsible"')
+
+    const back = dropTrailingEmptyParagraph(stableJson(markdownToDoc(mdText, editor.state.schema)))
+    expect(back).toEqual(canonical)
+    editor.destroy()
+  })
+
+  it('imports plain markdown with GFM task lists', () => {
+    const editor = makeEditor()
+    const json = markdownToDoc('# Hello\n\n- [x] done\n- [ ] todo\n\n> quote', editor.state.schema)
+    const types = json.content?.map(n => n.type)
+    expect(types).toEqual(['heading', 'taskList', 'blockquote'])
+    const task = json.content?.[1]
+    expect(task?.content?.map(i => i.attrs?.checked)).toEqual([true, false])
+    editor.destroy()
+  })
+
+  it('exports Markdown from canonical JSON without an editor instance doc', () => {
+    const editor = makeEditor()
+    const mdText = docToMarkdown(richDoc, editor.state.schema)
+    expect(mdText).toContain('```ts')
+    editor.destroy()
+  })
+
+  it('does not throw on JSON-only marks (textStyle/color, aiAttribution) and keeps the text', () => {
+    const editor = makeEditor()
+    const doc: JSONContent = {
+      type: 'doc',
+      content: [
+        {
+          type: 'paragraph',
+          content: [
+            { type: 'text', marks: [{ type: 'textStyle', attrs: { color: '#d9414f' } }], text: 'red ' },
+            { type: 'text', marks: [{ type: 'aiAttribution', attrs: { pending: true } }], text: 'ai-written' },
+          ],
+        },
+      ],
+    }
+    // regression: an uncovered mark type made the serializer THROW and crash
+    // the host app on export
+    const mdText = docToMarkdown(doc, editor.state.schema)
+    expect(mdText).toContain('red')
+    expect(mdText).toContain('ai-written')
+    editor.destroy()
+  })
+})

package/src/__tests__/v11.test.ts

@@ -0,0 +1,184 @@
+// @vitest-environment jsdom
+import { describe, it, expect } from 'vitest'
+import { Editor } from '@tiptap/core'
+import { createTesseraExtensions, tableToCsvAt, diffDocs, docToMarkdown, markdownToDoc, stableJson, listCommentRanges } from '../index'
+import type { StorageService, DocSnapshot } from '../index'
+
+function makeEditor() {
+  return new Editor({ extensions: createTesseraExtensions({ locale: 'zh-CN' }) })
+}
+
+function buildTable(editor: Editor, rows: { header: string[]; body: string[][] }) {
+  const content = [
+    {
+      type: 'table',
+      attrs: { types: ['text', 'number', 'checkbox'] },
+      content: [
+        {
+          type: 'tableRow',
+          content: rows.header.map(h => ({ type: 'tableHeader', content: [{ type: 'paragraph', content: [{ type: 'text', text: h }] }] })),
+        },
+        ...rows.body.map(cells => ({
+          type: 'tableRow',
+          content: cells.map((c, i) => ({
+            type: 'tableCell',
+            attrs: i === 1 ? { value: Number(c) } : i === 2 ? { value: c === 'true' } : undefined,
+            content: [{ type: 'paragraph', ...(i === 0 ? { content: [{ type: 'text', text: c }] } : {}) }],
+          })),
+        })),
+      ],
+    },
+  ]
+  editor.commands.setContent({ type: 'doc', content })
+}
+
+describe('typed tables', () => {
+  it('creates via command and round-trips typed attrs', () => {
+    const editor = makeEditor()
+    editor.commands.setContent({ type: 'doc', content: [{ type: 'paragraph' }] })
+    editor.commands.setTextSelection(1)
+    expect(editor.commands.insertTableTyped({ rows: 2, cols: 3, withHeaderRow: true })).toBe(true)
+    const table = editor.state.doc.child(0)
+    expect(table.type.name).toBe('table')
+    // types attr defaults to text per column
+    editor.commands.setTextSelection(2)
+    expect(editor.commands.setColumnType(1, 'number')).toBe(true)
+    const updated = editor.state.doc.child(0)
+    expect(updated.attrs.types).toEqual(['text', 'number', 'text'])
+    editor.destroy()
+  })
+
+  it('sorts body rows by a number column and keeps header', () => {
+    const editor = makeEditor()
+    buildTable(editor, {
+      header: ['名称', '数量', '完成'],
+      body: [
+        ['b', '5', 'false'],
+        ['a', '9', 'true'],
+        ['c', '1', 'false'],
+      ],
+    })
+    editor.commands.setTextSelection(3)
+    expect(editor.commands.sortTableByColumn(1, 'asc')).toBe(true)
+    const table = editor.state.doc.child(0)
+    const firstRow = table.content.child(1)! // skip header
+    expect(firstRow.child(0).textContent).toBe('c')
+    const lastRow = table.content.child(3)!
+    expect(lastRow.child(0).textContent).toBe('a')
+    editor.destroy()
+  })
+
+  it('exports CSV with typed formatting', () => {
+    const editor = makeEditor()
+    buildTable(editor, {
+      header: ['名称', '数量', '完成'],
+      body: [
+        ['a', '9', 'true'],
+        ['b', '5', 'false'],
+      ],
+    })
+    editor.commands.setTextSelection(3)
+    const csv = tableToCsvAt(editor)
+    expect(csv).toContain('名称,数量,完成')
+    expect(csv).toContain('a,9,✔')
+    expect(csv).toContain('b,5,')
+    editor.destroy()
+  })
+
+  it('round-trips through markdown as semantic HTML', () => {
+    const editor = makeEditor()
+    buildTable(editor, {
+      header: ['名称', '数量', '完成'],
+      body: [['a', '9', 'true']],
+    })
+    const dropTrailing = (json: import("@tiptap/core").JSONContent) => {
+      const content = [...(json.content ?? [])]
+      while (content.length && content[content.length - 1]!.type === 'paragraph' && !content[content.length - 1]!.content) {
+        content.pop()
+      }
+      return { ...json, content }
+    }
+    const canonical = stableJson(dropTrailing(editor.getJSON()))
+    const mdText = docToMarkdown(editor.state.doc, editor.state.schema)
+    expect(mdText).toContain('<table')
+    expect(mdText).toContain('data-types')
+    const back = stableJson(dropTrailing(markdownToDoc(mdText, editor.state.schema)))
+    expect(back).toEqual(canonical)
+    editor.destroy()
+  })
+})
+
+describe('diff', () => {
+  it('classifies added / removed / changed blocks by id', () => {
+    const before = {
+      type: 'doc',
+      content: [
+        { type: 'paragraph', attrs: { id: 'p1' }, content: [{ type: 'text', text: 'hello world' }] },
+        { type: 'paragraph', attrs: { id: 'p2' }, content: [{ type: 'text', text: 'gone' }] },
+      ],
+    }
+    const after = {
+      type: 'doc',
+      content: [
+        { type: 'paragraph', attrs: { id: 'p1' }, content: [{ type: 'text', text: 'hello there' }] },
+        { type: 'paragraph', attrs: { id: 'p3' }, content: [{ type: 'text', text: 'new block' }] },
+      ],
+    }
+    const entries = diffDocs(before, after)
+    const byId = Object.fromEntries(entries.filter(e => e.id).map(e => [e.id, e.kind]))
+    expect(byId.p1).toBe('changed')
+    expect(byId.p2).toBe('removed')
+    expect(byId.p3).toBe('added')
+    const changed = entries.find(e => e.id === 'p1')!
+    expect(changed.wordDiff?.some(p => p.type === 'del' && p.text.includes('world'))).toBe(true)
+    expect(changed.wordDiff?.some(p => p.type === 'add' && p.text.includes('there'))).toBe(true)
+  })
+})
+
+describe('history snapshots', () => {
+  it('captures into the injected storage on command', async () => {
+    const saved: DocSnapshot[] = []
+    const storage: StorageService = {
+      saveSnapshot: async snap => {
+        saved.push(snap)
+      },
+      listSnapshots: async () => saved,
+    }
+    const editor = makeEditor()
+    ;(editor.storage as unknown as Record<string, unknown>).tesseraServices = { storage }
+    editor.commands.setContent({ type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'v1' }] }] })
+    expect(editor.commands.captureSnapshot('manual')).toBe(true)
+    await new Promise(r => setTimeout(r, 20))
+    expect(saved).toHaveLength(1)
+    expect(saved[0]!.label).toBe('manual')
+    expect(JSON.stringify(saved[0]!.doc)).toContain('v1')
+    editor.destroy()
+  })
+})
+
+describe('comments', () => {
+  it('adds, resolves and lists comment threads in doc order', () => {
+    const editor = makeEditor()
+    editor.commands.setContent({
+      type: 'doc',
+      content: [
+        { type: 'paragraph', content: [{ type: 'text', text: 'first second' }] },
+      ],
+    })
+    editor.commands.setTextSelection({ from: 1, to: 6 })
+    expect(editor.commands.addCommentThread('t1')).toBe(true)
+    editor.commands.setTextSelection({ from: 7, to: 13 })
+    expect(editor.commands.addCommentThread('t2')).toBe(true)
+
+    const ranges = listCommentRanges(editor.state)
+    expect(ranges.map(r => r.threadId)).toEqual(['t1', 't2'])
+
+    expect(editor.commands.setCommentResolved('t1', true)).toBe(true)
+    const after = listCommentRanges(editor.state)
+    expect(after.find(r => r.threadId === 't1')?.resolved).toBe(true)
+
+    expect(editor.commands.removeCommentThread('t2')).toBe(true)
+    expect(listCommentRanges(editor.state).map(r => r.threadId)).toEqual(['t1'])
+    editor.destroy()
+  })
+})

package/src/__tests__/v112.test.ts

@@ -0,0 +1,184 @@
+// @vitest-environment jsdom
+import { describe, it, expect } from 'vitest'
+import { Editor } from '@tiptap/core'
+import { createTesseraExtensions } from '../preset'
+import { EMOJI_ITEMS, filterEmojiItems } from '../extensions/emoji'
+import { findGalleryRuns } from '../extensions/gallery'
+import { getTesseraMetrics } from '../extensions/metrics'
+import { isWordHtml, cleanWordHtml } from '../wordpaste'
+import { findBlockPosById, deleteBlockById, blockAnchorUrl } from '../blockmenu'
+
+function makeEditor() {
+  return new Editor({ extensions: createTesseraExtensions({ locale: 'zh-CN' }) })
+}
+
+describe('emoji picker data + filtering', () => {
+  it('every item has a char and a name', () => {
+    expect(EMOJI_ITEMS.length).toBeGreaterThan(50)
+    for (const item of EMOJI_ITEMS) {
+      expect(item.char.length).toBeGreaterThan(0)
+      expect(item.name.length).toBeGreaterThan(0)
+      expect(Array.isArray(item.keywords)).toBe(true)
+    }
+  })
+
+  it('empty query returns everything; keyword query filters; junk query empties', () => {
+    expect(filterEmojiItems('')).toHaveLength(EMOJI_ITEMS.length)
+    const smiles = filterEmojiItems('smile')
+    expect(smiles.length).toBeGreaterThan(0)
+    expect(smiles.every(i => i.name.includes('smile') || i.keywords.some(k => k.includes('smile')))).toBe(true)
+    expect(filterEmojiItems('zzzznotanemoji')).toHaveLength(0)
+  })
+
+  it('keywords search covers chinese-adjacent semantics via name (rocket etc.)', () => {
+    expect(filterEmojiItems('rocket').map(i => i.char)).toContain('🚀')
+    expect(filterEmojiItems('done').map(i => i.char)).toContain('✅')
+  })
+})
+
+describe('image gallery runs', () => {
+  function docWith(...blocks: ('p' | 'img')[]) {
+    return {
+      type: 'doc',
+      content: blocks.map(b =>
+        b === 'img'
+          ? { type: 'imageBlock', attrs: { src: 'https://example.com/x.png' } }
+          : { type: 'paragraph', content: [{ type: 'text', text: 'sep' }] },
+      ),
+    }
+  }
+
+  it('flags runs of >= 2 consecutive images only', () => {
+    const editor = makeEditor()
+    editor.commands.setContent(docWith('p', 'img', 'img', 'p', 'img', 'img', 'img', 'p'))
+    const runs = findGalleryRuns(editor.state.doc)
+    expect(runs.map(r => r.size)).toEqual([2, 3])
+    editor.destroy()
+  })
+
+  it('single images do not form a gallery', () => {
+    const editor = makeEditor()
+    editor.commands.setContent(docWith('img', 'p', 'img'))
+    expect(findGalleryRuns(editor.state.doc)).toHaveLength(0)
+    editor.destroy()
+  })
+})
+
+describe('word paste cleaning rules', () => {
+  it('detects Word sources', () => {
+    expect(isWordHtml('<p xmlns:w="urn:schemas-microsoft-com:office:word">x</p>')).toBe(true)
+    expect(isWordHtml('<p class="MsoNormal">x</p>')).toBe(true)
+    expect(isWordHtml('<p style="mso-list:l0">x</p>')).toBe(true)
+    expect(isWordHtml('<p>plain text</p>')).toBe(false)
+  })
+
+  const rules: Array<{ name: string; input: string; expected: string }> = [
+    {
+      name: 'R1 drops conditional comments',
+      input: '<!--[if gte mso 9]><xml><w:WordDocument></w:WordDocument></xml><![endif]--><p>Hi</p>',
+      expected: '<p>Hi</p>',
+    },
+    {
+      name: 'R2 drops style blocks and meta tags',
+      input: '<style>.MsoNormal{margin:0}</style><meta charset="utf-8"><p>Hi</p>',
+      expected: '<p>Hi</p>',
+    },
+    {
+      name: 'R3 strips office namespace tags',
+      input: '<o:p><w:sdt>Hi</w:sdt></o:p>',
+      expected: 'Hi',
+    },
+    {
+      name: 'R4 drops class/style/lang attributes, keeps semantic tags',
+      input: '<p class="MsoNormal" style="margin:0in"><b>Bold</b><i>Italic</i></p>',
+      expected: '<p><b>Bold</b><i>Italic</i></p>',
+    },
+    {
+      name: 'R6 collapses non-breaking spaces',
+      input: '<p>a&nbsp;b</p>',
+      expected: '<p>a b</p>',
+    },
+    {
+      name: 'R7 removes empty paragraphs',
+      input: '<p>a</p><p></p><p><br></p><p>   </p><p>b</p>',
+      expected: '<p>a</p><p>b</p>',
+    },
+  ]
+
+  for (const rule of rules) {
+    it(rule.name, () => {
+      expect(cleanWordHtml(rule.input)).toBe(rule.expected)
+    })
+  }
+
+  it('keeps bold/italic semantics for PM to parse', () => {
+    const editor = makeEditor()
+    const cleaned = cleanWordHtml(
+      '<p class="MsoNormal"><span style="font-weight:bold">Word</span> paste <b>test</b></p>',
+    )
+    editor.commands.setContent(`<div>${cleaned}</div>`)
+    const text = editor.state.doc.textContent
+    expect(text).toContain('Word')
+    expect(text).toContain('paste')
+    editor.destroy()
+  })
+})
+
+describe('performance metrics', () => {
+  it('counts blocks/words/images/tables and serializes within budget', () => {
+    const editor = makeEditor()
+    editor.commands.setContent({
+      type: 'doc',
+      content: [
+        { type: 'paragraph', content: [{ type: 'text', text: 'one two three' }] },
+        { type: 'imageBlock', attrs: { src: 'https://example.com/a.png' } },
+        { type: 'paragraph', content: [{ type: 'text', text: 'four five' }] },
+      ],
+    })
+    const before = getTesseraMetrics(editor)
+    expect(before.blocks).toBe(3)
+    expect(before.words).toBe(5)
+    expect(before.images).toBe(1)
+    expect(before.tables).toBe(0)
+    expect(before.serializeMs).toBeGreaterThanOrEqual(0)
+
+    editor.commands.setTextSelection(editor.state.doc.content.size - 2)
+    editor.commands.insertTableTyped({ rows: 2, cols: 2, withHeaderRow: true })
+    const after = getTesseraMetrics(editor)
+    expect(after.tables).toBe(1)
+    editor.destroy()
+  })
+})
+
+describe('block menu helpers', () => {
+  it('finds blocks by stable id and computes anchor urls', () => {
+    const editor = makeEditor()
+    editor.commands.setContent({
+      type: 'doc',
+      content: [
+        { type: 'paragraph', attrs: { id: 'block-a' }, content: [{ type: 'text', text: 'A' }] },
+        { type: 'paragraph', attrs: { id: 'block-b' }, content: [{ type: 'text', text: 'B' }] },
+      ],
+    })
+    expect(findBlockPosById(editor, 'block-b')).toBeGreaterThan(0)
+    expect(findBlockPosById(editor, 'missing')).toBeNull()
+    expect(blockAnchorUrl('block-a')).toMatch(/#block-block-a$/)
+    editor.destroy()
+  })
+
+  it('deletes a block by id and reports misses', () => {
+    const editor = makeEditor()
+    editor.commands.setContent({
+      type: 'doc',
+      content: [
+        { type: 'paragraph', attrs: { id: 'keep' }, content: [{ type: 'text', text: 'keep' }] },
+        { type: 'paragraph', attrs: { id: 'drop' }, content: [{ type: 'text', text: 'drop' }] },
+      ],
+    })
+    expect(deleteBlockById(editor, 'missing')).toBe(false)
+    expect(deleteBlockById(editor, 'drop')).toBe(true)
+    expect(editor.state.doc.childCount).toBe(1)
+    expect(editor.state.doc.textContent).toBe('keep')
+    editor.destroy()
+  })
+})