@tessera-editor/core 0.1.0

package/src/wordpaste.ts

@@ -0,0 +1,56 @@
+/**
+ * Word paste cleaning (acceptance §9, v1.1).
+ *
+ * Word export HTML is full of Office plumbing that ProseMirror's default
+ * schema-based cleaning handles badly (mso styles leak as text, namespace
+ * tags become unknown nodes, empty paragraphs multiply). When pasted HTML
+ * is detected as Word source, these rules run BEFORE PM parses it:
+ *
+ *  R1  drop comments incl. `<!--[if ...]>...<![endif]-->` conditionals
+ *  R2  drop <style>/<script>/<meta>/<link> blocks and tags
+ *  R3  strip Office namespace tags entirely (<o:p>, <w:*, <st1:*>, <v:*>)
+ *  R4  drop class / style / lang attributes (visual plumbing; bold/italic/
+ *      underline survive via <b>/<i>/<u> tags which PM keeps)
+ *  R5  drop Word list markers ("l" bullets in mso-list spans are removed
+ *      with R3/R4; list paragraphs become plain paragraphs — semantic list
+ *      reconstruction is explicitly out of scope for v1.1)
+ *  R6  &nbsp; collapses to a normal space
+ *  R7  empty paragraphs (<p></p>, <p><br></p>, whitespace-only) are removed
+ */
+
+export function isWordHtml(html: string): boolean {
+  return (
+    html.includes('urn:schemas-microsoft-com:office:word') ||
+    html.includes('urn:schemas-microsoft-com:office:office') ||
+    /mso-[\w-]+/.test(html) ||
+    /\bMso\w+/.test(html) ||
+    /<w:/i.test(html) ||
+    /<o:/i.test(html)
+  )
+}
+
+export function cleanWordHtml(html: string): string {
+  let out = html
+  // R1 comments + conditionals
+  out = out.replace(/<!--\[if[\s\S]*?<!\[endif\]-->/gi, '')
+  out = out.replace(/<!--[\s\S]*?-->/g, '')
+  // R2 style/script blocks, meta/link tags, xml prolog
+  out = out.replace(/<(style|script)\b[\s\S]*?<\/\1>/gi, '')
+  out = out.replace(/<(meta|link)\b[^>]*>/gi, '')
+  out = out.replace(/<\?xml[^>]*\?>/gi, '')
+  out = out.replace(/<!DOCTYPE[^>]*>/gi, '')
+  // R3 office namespace tags
+  out = out.replace(/<\/?[a-z][a-z0-9]*:[^>]*>/gi, '')
+  // R4 visual-plumbing attributes (double- and single-quoted)
+  out = out.replace(/\s(class|style|lang|xml:lang|face)\s*=\s*"[^"]*"/gi, '')
+  out = out.replace(/\s(class|style|lang|xml:lang|face)\s*=\s*'[^']*'/gi, '')
+  // R6 non-breaking spaces
+  out = out.replace(/&nbsp;/gi, ' ')
+  // R7 empty paragraphs (iterate: nested whitespace collapses progressively)
+  let prev = ''
+  while (out !== prev) {
+    prev = out
+    out = out.replace(/<p\b[^>]*>(\s|<br\s*\/?>)*<\/p>/gi, '')
+  }
+  return out.trim()
+}

package/src/writeback.ts

@@ -0,0 +1,156 @@
+import type { Editor, JSONContent } from '@tiptap/core'
+
+/**
+ * Write-back protocol (ADR-0001 / product-definition §4): AI and host code
+ * mutate the document by stable block IDs — never whole-doc rewrites.
+ * Semantics mirror SliteML's modifyRange / appendBlocks / removeBlocks.
+ */
+
+export interface BlockHandle {
+  /** stable block id (UniqueID extension); null when the block predates ids */
+  id: string | null
+  type: string
+  pos: number
+  node: import('@tiptap/pm/model').Node
+}
+
+/** Top-level blocks with their ids, in document order. */
+export function getTopLevelBlocks(editor: Editor): BlockHandle[] {
+  const blocks: BlockHandle[] = []
+  editor.state.doc.forEach((node, offset) => {
+    blocks.push({ id: (node.attrs.id as string | undefined) ?? null, type: node.type.name, pos: offset, node })
+  })
+  return blocks
+}
+
+function findBlockPosById(editor: Editor, id: string): number | null {
+  let found: number | null = null
+  editor.state.doc.forEach((node, offset) => {
+    if (found === null && node.attrs.id === id) {
+      found = offset
+    }
+  })
+  return found
+}
+
+function newBlockId(): string {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID()
+  }
+  return `tessera-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
+}
+
+function resolveBlocks(editor: Editor, blocks: JSONContent[]) {
+  return blocks.map(json => {
+    const clean = { ...json }
+    // Write-back content carries fresh ids of its own: UniqueID skips nodes
+    // that already have one, so the ids land inside the same transaction
+    // (single undo step) instead of a follow-up append.
+    clean.attrs = { ...(clean.attrs ?? {}), id: newBlockId() }
+    return editor.state.schema.nodeFromJSON(clean)
+  })
+}
+
+export interface ModifyRangeOptions {
+  /** first block to replace (default: first block in doc) */
+  fromId?: string
+  /** last block to replace, inclusive (default: fromId) */
+  toId?: string
+  content: JSONContent[]
+}
+
+/**
+ * Replace the inclusive block range [fromId … toId] with `content`.
+ * One transaction → one undo step.
+ */
+export function modifyRange(editor: Editor, options: ModifyRangeOptions): boolean {
+  const blocks = getTopLevelBlocks(editor).filter(b => b.id)
+  if (blocks.length === 0) {
+    return false
+  }
+  const ids = blocks.map(b => b.id as string)
+  const fromId = options.fromId ?? ids[0]
+  const toId = options.toId ?? fromId
+
+  let fromIndex = ids.indexOf(fromId)
+  let toIndex = ids.indexOf(toId)
+  if (fromIndex === -1 || toIndex === -1) {
+    return false
+  }
+  if (fromIndex > toIndex) {
+    ;[fromIndex, toIndex] = [toIndex, fromIndex]
+  }
+
+  const fromBlock = blocks[fromIndex]
+  const toBlock = blocks[toIndex]
+  const from = fromBlock.pos
+  const to = toBlock.pos + toBlock.node.nodeSize
+
+  const nodes = resolveBlocks(editor, options.content)
+  const tr = editor.state.tr
+  tr.replaceWith(from, to, nodes)
+  editor.view.dispatch(tr)
+  return true
+}
+
+export interface AppendBlocksOptions {
+  /** insert after this block (default: end of document) */
+  afterId?: string
+  content: JSONContent[]
+}
+
+/** Append blocks after `afterId` (or at the document end). */
+export function appendBlocks(editor: Editor, options: AppendBlocksOptions): boolean {
+  const nodes = resolveBlocks(editor, options.content)
+  if (nodes.length === 0) {
+    return false
+  }
+  let insertPos = editor.state.doc.content.size
+  if (options.afterId) {
+    const pos = findBlockPosById(editor, options.afterId)
+    if (pos === null) {
+      return false
+    }
+    const node = editor.state.doc.nodeAt(pos)
+    if (!node) {
+      return false
+    }
+    insertPos = pos + node.nodeSize
+  }
+  const tr = editor.state.tr
+  tr.insert(insertPos, nodes)
+  editor.view.dispatch(tr)
+  return true
+}
+
+/** Remove blocks by ids. One transaction → one undo step. */
+export function removeBlocks(editor: Editor, ids: string[]): boolean {
+  if (ids.length === 0) {
+    return false
+  }
+  const ranges: { from: number; to: number }[] = []
+  editor.state.doc.forEach((node, offset) => {
+    if (node.attrs.id && ids.includes(node.attrs.id)) {
+      ranges.push({ from: offset, to: offset + node.nodeSize })
+    }
+  })
+  if (ranges.length === 0) {
+    return false
+  }
+  const tr = editor.state.tr
+  for (let i = ranges.length - 1; i >= 0; i--) {
+    tr.delete(ranges[i].from, ranges[i].to)
+  }
+  editor.view.dispatch(tr)
+  return true
+}
+
+/** Read a block (and its subtree) by id as canonical JSON. */
+export function getBlockJson(editor: Editor, id: string): JSONContent | null {
+  const pos = findBlockPosById(editor, id)
+  if (pos === null) {
+    return null
+  }
+  const node = editor.state.doc.nodeAt(pos)
+  return node ? node.toJSON() : null
+}