@ceedcv-maya/shared-editor-react 0.6.0 → 0.8.0

package/README.md

@@ -4,7 +4,7 @@ Unified TipTap editor for the Maya ecosystem.
 
 ## Components
 
-- **`<MayaEditor mode="lite" | "full" />`** — single editor with two visual modes. `lite` for short comments and alerts; `full` for templates and documents (BlockNote parity).
+- **`<MayaEditor mode="lite" | "full" />`** — single editor with two visual modes. `lite` for short comments and alerts; `full` for templates and documents.
 - **`<EditorContentHtml html />`** — read-only renderer with DOMPurify sanitisation (aligned with the server-side `TiptapHtmlRenderer`).
 - **`<EditorToolbar />`** — toolbar builder, used internally by `MayaEditor` and exposed for custom integrations.
 
@@ -14,10 +14,6 @@ Unified TipTap editor for the Maya ecosystem.
 - `AlertBlock` — variants info / warning / success / danger.
 - `CommentMark` — anchored-comment mark (paired with `AnchoredCommentController` server-side).
 
-## Conversion
-
-- `convertBlockNoteToTiptap(blocks)` — legacy → ProseMirror conversion. Mirror of the PHP `Maya\Editor\Renderers\BlockNoteToTiptap`.
-
 ## Document import & block splitting
 
 Helpers behind the "Import from Word → blocks" flow (`DocxBlockSplitter` in maya_dms):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ceedcv-maya/shared-editor-react",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -57,12 +57,11 @@
   "publishConfig": {
     "access": "public"
   },
-  "description": "Unified rich-text editor for Maya: MayaEditor (TipTap) with lite/full modes, BlockNote→TipTap converter, HTML SSR renderer, anchored-comments support.",
+  "description": "Unified rich-text editor for Maya: MayaEditor (TipTap) with lite/full modes, HTML SSR renderer, anchored-comments support.",
   "keywords": [
     "react",
     "tiptap",
     "prosemirror",
-    "blocknote",
     "editor",
     "wysiwyg",
     "ceedcv",

package/src/components/EditorToolbar.tsx

@@ -198,7 +198,8 @@ export function EditorToolbar({
           <ListAndBlockButtons editor={editor} labels={L} />
           <TableAndMediaButtons editor={editor} labels={L} onImage={onImage} />
 
-          <span className="maya-editor-toolbar__sep" aria-hidden />
+
+          <div className="flex items-end gap-0.5 shrink-0 pl-1 border-l border-ui-border dark:border-ui-dark-border ml-auto">
           <DocumentButtons
             editor={editor}
             labels={L}
@@ -218,6 +219,7 @@ export function EditorToolbar({
             onInsertMarkdown={onInsertMarkdown}
             onToggleFullscreen={onToggleFullscreen}
           />
+          </div>
         </>
       )}
     </div>

package/src/components/EditorToolbarGroups.tsx

@@ -388,13 +388,14 @@ export function ViewModeButtons({
           <span style={{ fontFamily: 'ui-monospace, monospace', fontSize: 11 }}>{'<>'}</span>
         </Btn>
       )}
+      <span className="maya-editor-toolbar__sep" aria-hidden />
       {onToggleFullscreen && (
-        <Btn
-          onClick={onToggleFullscreen}
-          title={isFullscreen ? L.exitFullscreen : L.fullscreen}
-        >
-          {isFullscreen ? '⤓' : '⛶'}
-        </Btn>
+          <Btn
+            onClick={onToggleFullscreen}
+            title={isFullscreen ? L.exitFullscreen : L.fullscreen}
+          >
+            {isFullscreen ? '🗗' : '🗖'}
+          </Btn>
       )}
     </>
   );

package/src/components/MayaEditor.tsx

@@ -1,8 +1,10 @@
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { EditorContent, useEditor } from '@tiptap/react';
 import type { Editor } from '@tiptap/react';
 
 import { buildMayaEditorExtensions } from '../lib/editorExtensions';
+import { normalizeTiptapDocPayload } from '../lib/tiptapContentSemantics';
+import { isEditorReady } from '../lib/isEditorReady';
 import { useEditorContent, type EditorOutput } from '../hooks/useEditorContent';
 import { sanitizeEditorHtml } from '../lib/dompurifyConfig';
 import { markdownToHtml } from '../lib/markdownToHtml';
@@ -28,6 +30,11 @@ export interface MayaEditorProps {
   mode?: EditorMode;
   /** Debounced change callback (300ms). Payload depends on `output`. */
   onChange?: (payload: string | TiptapDoc) => void;
+  /**
+   * Llamado al perder el foco del editor, antes de HTML/Markdown o al destruir
+   * la instancia. El padre suele enlazarlo a `forceSave` del autoguardado.
+   */
+  onFlush?: () => void;
   /**
    * Output shape: `'html'` (default) emits a sanitisation-ready string;
    * `'json'` emits the full ProseMirror doc `{type:'doc', content:[…]}`,
@@ -94,6 +101,7 @@ export function MayaEditor({
   onCreateComment,
   onExportDocx,
   commentsById,
+  onFlush,
 }: MayaEditorProps) {
   const effectiveOutput: EditorOutput = output ?? (mode === 'full' ? 'json' : 'html');
   const [isFullscreen, setIsFullscreen] = useState(false);
@@ -115,6 +123,11 @@ export function MayaEditor({
   const [viewReady, setViewReady] = useState(false);
   const fileInputRef = useRef<HTMLInputElement | null>(null);
   const docxInputRef = useRef<HTMLInputElement | null>(null);
+  const wrapperRef = useRef<HTMLDivElement | null>(null);
+  const onChangeRef = useRef(onChange);
+  const onFlushRef = useRef(onFlush);
+  onChangeRef.current = onChange;
+  onFlushRef.current = onFlush;
 
   const extensions = useMemo(() => buildMayaEditorExtensions(mode), [mode]);
 
@@ -135,26 +148,67 @@ export function MayaEditor({
 
   useEditorContent(editor, onChange, { output: effectiveOutput });
 
+  const syncContentToParent = useCallback(() => {
+    if (!editor) return;
+    const handler = onChangeRef.current;
+    if (!handler) return;
+    const rawPayload =
+      effectiveOutput === 'json'
+        ? (editor.getJSON() as TiptapDoc)
+        : editor.getHTML();
+    const payload =
+      effectiveOutput === 'json'
+        ? normalizeTiptapDocPayload(rawPayload)
+        : rawPayload;
+    handler(payload);
+  }, [editor, effectiveOutput]);
+
+  const requestFlush = useCallback(() => {
+    syncContentToParent();
+    onFlushRef.current?.();
+  }, [syncContentToParent]);
+
   useEffect(() => {
     if (editor && onEditorReady) onEditorReady(editor);
   }, [editor, onEditorReady]);
 
   useEffect(() => {
+    if (!editor || !onFlush) return;
+    const onDestroy = () => requestFlush();
+    editor.on('destroy', onDestroy);
+    return () => {
+      editor.off('destroy', onDestroy);
+    };
+  }, [editor, onFlush, requestFlush]);
+
+  useEffect(() => {
+    setViewReady(false);
     if (!editor) return;
-    const bump = () => setSelectionVersion((v) => v + 1);
+
+    const bump = () => {
+      if (!isEditorReady(editor)) return;
+      setSelectionVersion((v) => v + 1);
+    };
     const markReady = () => setViewReady(true);
+    const markNotReady = () => setViewReady(false);
+
     editor.on('selectionUpdate', bump);
     editor.on('transaction', bump);
     editor.on('create', markReady);
-    // The editor may have already fired `create` before we got here
-    // (useEditor sometimes returns an instance that's already mounted).
+    editor.on('destroy', markNotReady);
+
     try {
-      if (editor.view && editor.view.dom) setViewReady(true);
-    } catch { /* view not ready yet — markReady will fire it */ }
+      if (editor.view?.dom) setViewReady(true);
+    } catch {
+      /* view not ready yet — markReady will fire on create */
+    }
+
     return () => {
       editor.off('selectionUpdate', bump);
       editor.off('transaction', bump);
       editor.off('create', markReady);
+      editor.off('destroy', markNotReady);
+      setViewReady(false);
     };
   }, [editor]);
 
@@ -214,6 +268,8 @@ export function MayaEditor({
 
   if (!editor) return null;
 
+  const editorReady = viewReady && isEditorReady(editor);
+
   const handlePickImage = async (file: File) => {
     if (!uploadFile) return;
     try {
@@ -251,6 +307,7 @@ export function MayaEditor({
   };
 
   const enterSource = (target: 'html' | 'markdown') => {
+    requestFlush();
     const currentHtml = editor.getHTML();
     const text = target === 'html' ? currentHtml : htmlToMarkdown(currentHtml);
     setSourceText(text);
@@ -293,8 +350,16 @@ export function MayaEditor({
 
   return (
     <div
+      ref={wrapperRef}
       className={`maya-editor-wrapper${isFullscreen ? ' is-fullscreen' : ''}${isDark ? ' is-dark' : ''}`}
+      onBlur={(e) => {
+        if (!onFlush) return;
+        const next = e.relatedTarget as Node | null;
+        if (next && wrapperRef.current?.contains(next)) return;
+        requestFlush();
+      }}
     >
+      {editorReady && (
       <EditorToolbar
         editor={editor}
         mode={mode}
@@ -312,7 +377,8 @@ export function MayaEditor({
         onToggleFind={mode === 'full' ? () => setFindOpen((v) => !v) : undefined}
         labels={toolbarLabels}
       />
-      {mode === 'full' && (
+      )}
+      {mode === 'full' && editorReady && (
         <FindReplaceBar
           editor={editor}
           open={findOpen}

package/src/hooks/useEditorContent.ts

@@ -1,6 +1,11 @@
 import { useEffect, useRef } from 'react';
 import type { Editor } from '@tiptap/react';
 import type { TiptapDoc } from '../types';
+import {
+  canonicalTiptapContentJson,
+  isSemanticallyEmptyEditorHtml,
+  normalizeTiptapDocPayload,
+} from '../lib/tiptapContentSemantics';
 
 export type EditorOutput = 'html' | 'json';
 
@@ -24,16 +29,38 @@ export function useEditorContent(
   const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const handlerRef = useRef(onChange);
   handlerRef.current = onChange;
+  const lastEmittedRef = useRef<string | null>(null);
 
   useEffect(() => {
     if (!editor) return;
+    lastEmittedRef.current = null;
 
     const handleUpdate = () => {
       if (timeoutRef.current) clearTimeout(timeoutRef.current);
       timeoutRef.current = setTimeout(() => {
-        const payload = output === 'json'
+        const rawPayload = output === 'json'
           ? (editor.getJSON() as TiptapDoc)
           : editor.getHTML();
+        const payload = output === 'json'
+          ? normalizeTiptapDocPayload(rawPayload)
+          : rawPayload;
+
+        const fingerprint = output === 'json'
+          ? canonicalTiptapContentJson((payload as TiptapDoc).content)
+          : payload;
+
+        if (typeof fingerprint === 'string' && fingerprint === lastEmittedRef.current) {
+          return;
+        }
+
+        if (output === 'html' && typeof payload === 'string' && isSemanticallyEmptyEditorHtml(payload)) {
+          if (lastEmittedRef.current === '') return;
+          lastEmittedRef.current = '';
+          handlerRef.current?.(payload);
+          return;
+        }
+
+        lastEmittedRef.current = typeof fingerprint === 'string' ? fingerprint : null;
         handlerRef.current?.(payload);
       }, delayMs);
     };

package/src/index.ts

@@ -12,7 +12,6 @@ export { Indent } from './extensions/Indent';
 export type { IndentOptions } from './extensions/Indent';
 export { ColorPicker } from './components/ColorPicker';
 
-export { convertBlockNoteToTiptap } from './serializers/BlockNoteToTiptap';
 export { useEditorContent } from './hooks/useEditorContent';
 export { getAnchorRange, setAnchorRange, rebaseAnchors } from './lib/CommentAnchor';
 export type { AnchorRange } from './lib/CommentAnchor';
@@ -25,6 +24,17 @@ export { splitHtmlIntoBlocks } from './lib/splitHtmlIntoBlocks';
 export type { BlockChunk, BlockChunkType } from './lib/splitHtmlIntoBlocks';
 export { htmlToTiptapDoc } from './lib/htmlToTiptapDoc';
 export { buildMayaEditorExtensions } from './lib/editorExtensions';
+export { isEditorReady } from './lib/isEditorReady';
+export {
+  canonicalTiptapContentJson,
+  htmlVisibleTextLength,
+  isEmptyTiptapBlockNode,
+  isSemanticallyEmptyEditorHtml,
+  isSemanticallyEmptyTiptapContent,
+  normalizeTiptapContentForCompare,
+  normalizeTiptapDocPayload,
+  tiptapContentEquals,
+} from './lib/tiptapContentSemantics';
 export { docxToHtml, docxToHtmlResult } from './lib/docxToHtml';
 export type { DocxConversionMessage, DocxConversionResult } from './lib/docxToHtml';
 export { SourceInputDialog } from './components/SourceInputDialog';
@@ -38,9 +48,6 @@ export type {
   TiptapNode,
   TiptapDoc,
   AnchoredComment,
-  BlockNoteBlock,
-  BlockNoteInline,
-  BlockNoteStyles,
 } from './types';
 
 export { default as esTranslations } from './i18n/es.json';

package/src/lib/isEditorReady.ts

@@ -0,0 +1,13 @@
+import type { Editor } from '@tiptap/react';
+
+/**
+ * TipTap puede exponer una instancia con `commandManager === null` tras destroy
+ * o antes del evento `create`. Solo la UI que invoca comandos debe usar esto.
+ */
+export function isEditorReady(editor: Editor | null | undefined): editor is Editor {
+  if (!editor) {
+    return false;
+  }
+
+  return !editor.isDestroyed;
+}

package/src/lib/tiptapContentSemantics.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import {
+  canonicalTiptapContentJson,
+  isSemanticallyEmptyTiptapContent,
+  normalizeTiptapContentForCompare,
+  tiptapContentEquals,
+} from './tiptapContentSemantics';
+
+describe('tiptapContentSemantics', () => {
+  it('treats a lone empty paragraph as semantically empty', () => {
+    const empty = [{ type: 'paragraph', content: [] }];
+    expect(isSemanticallyEmptyTiptapContent(empty)).toBe(true);
+    expect(normalizeTiptapContentForCompare(empty)).toEqual([]);
+  });
+
+  it('strips trailing empty paragraph so phantom TipTap nodes do not differ', () => {
+    const withText = [{ type: 'paragraph', content: [{ type: 'text', text: 'Hola' }] }];
+    const withPhantom = [
+      ...withText,
+      { type: 'paragraph', content: [] },
+    ];
+    expect(tiptapContentEquals(withText, withPhantom)).toBe(true);
+    expect(canonicalTiptapContentJson(withPhantom)).toBe(canonicalTiptapContentJson(withText));
+  });
+
+  it('detects real edits after normalization', () => {
+    const a = [{ type: 'paragraph', content: [{ type: 'text', text: 'A' }] }];
+    const b = [{ type: 'paragraph', content: [{ type: 'text', text: 'B' }] }];
+    expect(tiptapContentEquals(a, b)).toBe(false);
+  });
+
+  it('keeps non-empty images as filled', () => {
+    const nodes = [{ type: 'image', attrs: { src: 'https://example.com/x.png' } }];
+    expect(isSemanticallyEmptyTiptapContent(nodes)).toBe(false);
+  });
+});

package/src/lib/tiptapContentSemantics.ts

@@ -0,0 +1,141 @@
+import type { TiptapDoc, TiptapNode } from '../types';
+
+const MEANINGFUL_BLOCK_TYPES = new Set([
+  'image',
+  'table',
+  'iframeBlock',
+  'alertBlock',
+  'horizontalRule',
+  'codeBlock',
+]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function asNode(value: unknown): TiptapNode | null {
+  return isRecord(value) && typeof value.type === 'string' ? (value as TiptapNode) : null;
+}
+
+function inlineTextLength(nodes: unknown): number {
+  if (!Array.isArray(nodes)) return 0;
+
+  let length = 0;
+  for (const raw of nodes) {
+    const node = asNode(raw);
+    if (!node) continue;
+    if (node.type === 'text' && typeof node.text === 'string') {
+      length += node.text.replace(/\u00a0/g, ' ').trim().length;
+    } else if (node.type === 'hardBreak') {
+      continue;
+    } else if (Array.isArray(node.content)) {
+      length += inlineTextLength(node.content);
+    }
+  }
+
+  return length;
+}
+
+/** True for TipTap/BlockNote blocks with no visible text and no embedded media. */
+export function isEmptyTiptapBlockNode(node: unknown): boolean {
+  const n = asNode(node);
+  if (!n?.type) return true;
+
+  if (MEANINGFUL_BLOCK_TYPES.has(n.type)) {
+    if (n.type === 'horizontalRule') return false;
+    if (n.type === 'image') {
+      return !String(n.attrs?.src ?? '').trim();
+    }
+    if (n.type === 'codeBlock') {
+      return inlineTextLength(n.content ?? []) === 0;
+    }
+    return false;
+  }
+
+  if (n.type === 'bulletList' || n.type === 'orderedList' || n.type === 'taskList') {
+    const items = Array.isArray(n.content) ? n.content : [];
+    return items.length === 0 || items.every((item) => isEmptyTiptapBlockNode(item));
+  }
+
+  if (n.type === 'listItem' || n.type === 'taskItem') {
+    const inner = Array.isArray(n.content) ? n.content : [];
+    return inner.length === 0 || inner.every((child) => isEmptyTiptapBlockNode(child));
+  }
+
+  if (n.type === 'blockquote') {
+    const inner = Array.isArray(n.content) ? n.content : [];
+    return inner.length === 0 || inner.every((child) => isEmptyTiptapBlockNode(child));
+  }
+
+  // paragraph, heading, legacy BlockNote blocks, etc.
+  return inlineTextLength(n.content ?? []) === 0;
+}
+
+function toContentArray(value: unknown): unknown[] {
+  if (value == null) return [];
+  if (Array.isArray(value)) return value;
+  if (isRecord(value) && value.type === 'doc' && Array.isArray(value.content)) {
+    return value.content;
+  }
+  return [];
+}
+
+/**
+ * Strips trailing empty paragraphs TipTap adds for cursor placement.
+ * Returns a new array; does not mutate the input.
+ */
+export function normalizeTiptapContentForCompare(value: unknown): unknown[] {
+  const nodes = [...toContentArray(value)];
+  while (nodes.length > 0 && isEmptyTiptapBlockNode(nodes[nodes.length - 1])) {
+    nodes.pop();
+  }
+  return nodes;
+}
+
+/**
+ * True when content has no meaningful text or media (e.g. only `<p></p>` / `paragraph: []`).
+ */
+export function isSemanticallyEmptyTiptapContent(value: unknown): boolean {
+  const nodes = normalizeTiptapContentForCompare(value);
+  if (nodes.length === 0) return true;
+  return nodes.every((node) => isEmptyTiptapBlockNode(node));
+}
+
+export function canonicalTiptapContentJson(value: unknown): string {
+  try {
+    return JSON.stringify(normalizeTiptapContentForCompare(value));
+  } catch {
+    return '';
+  }
+}
+
+export function tiptapContentEquals(a: unknown, b: unknown): boolean {
+  return canonicalTiptapContentJson(a) === canonicalTiptapContentJson(b);
+}
+
+/**
+ * Visible character count of editor HTML (ignores tags). Matches logs comment validation.
+ */
+export function htmlVisibleTextLength(html: string): number {
+  const text = html
+    .replace(/<[^>]+>/g, '')
+    .replace(/&nbsp;/gi, ' ')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&')
+    .trim();
+  return text.length;
+}
+
+export function isSemanticallyEmptyEditorHtml(html: string): boolean {
+  return htmlVisibleTextLength(html) === 0;
+}
+
+/** Payload shape for MayaEditor `output="json"`. */
+export function normalizeTiptapDocPayload(payload: string | TiptapDoc): string | TiptapDoc {
+  if (typeof payload === 'string') return payload;
+  return {
+    ...payload,
+    content: normalizeTiptapContentForCompare(payload.content) as TiptapDoc['content'],
+  };
+}

package/src/types.ts

@@ -29,28 +29,3 @@ export interface AnchoredComment {
   anchorIsValid: boolean;
   anchorLastSyncedAt: string | null;
 }
-
-export interface BlockNoteStyles {
-  bold?: boolean;
-  italic?: boolean;
-  underline?: boolean;
-  strike?: boolean;
-  code?: boolean;
-  textColor?: string;
-  backgroundColor?: string;
-}
-
-export interface BlockNoteInline {
-  type: string;
-  text?: string;
-  styles?: BlockNoteStyles;
-  href?: string;
-  content?: BlockNoteInline[];
-}
-
-export interface BlockNoteBlock {
-  type: string;
-  props?: Record<string, unknown>;
-  content?: BlockNoteInline[] | { rows?: Array<{ cells: unknown[] }> };
-  children?: BlockNoteBlock[];
-}

package/src/serializers/BlockNoteToTiptap.ts

@@ -1,223 +0,0 @@
-/**
- * JS mirror of Maya\Editor\Renderers\BlockNoteToTiptap (PHP).
- *
- * Same input/output as the PHP version — used for round-trip oracle tests
- * (BlockNote → Tiptap → HTML via both renderers must produce identical
- * output) and at-runtime when the frontend reads legacy `content` columns
- * during the migration window.
- */
-import type {
-  BlockNoteBlock,
-  BlockNoteInline,
-  BlockNoteStyles,
-  TiptapDoc,
-  TiptapMark,
-  TiptapNode,
-} from '../types';
-
-type ListBlockType = 'bulletListItem' | 'numberedListItem' | 'checkListItem';
-
-const LIST_TO_LIST_NODE: Record<ListBlockType, 'bulletList' | 'orderedList' | 'taskList'> = {
-  bulletListItem: 'bulletList',
-  numberedListItem: 'orderedList',
-  checkListItem: 'taskList',
-};
-
-export function convertBlockNoteToTiptap(blocks: BlockNoteBlock[]): TiptapDoc {
-  const content: TiptapNode[] = [];
-  let i = 0;
-  const n = blocks.length;
-  while (i < n) {
-    const block = blocks[i];
-    if (!block || typeof block !== 'object') {
-      i++;
-      continue;
-    }
-    const type = String(block.type ?? 'paragraph');
-
-    if (type === 'bulletListItem' || type === 'numberedListItem' || type === 'checkListItem') {
-      const listType = LIST_TO_LIST_NODE[type as ListBlockType];
-      const items: TiptapNode[] = [];
-      while (
-        i < n &&
-        blocks[i] &&
-        (blocks[i].type === type)
-      ) {
-        items.push(convertListItem(blocks[i], type as ListBlockType));
-        i++;
-      }
-      content.push({ type: listType, content: items });
-      continue;
-    }
-
-    content.push(convertBlock(block));
-    i++;
-  }
-
-  return { type: 'doc', content };
-}
-
-function convertBlock(block: BlockNoteBlock): TiptapNode {
-  const type = String(block.type ?? 'paragraph');
-  const props = (block.props ?? {}) as Record<string, unknown>;
-  const inline = convertInline((block.content as BlockNoteInline[] | undefined) ?? []);
-  const attrs = propsToAttrs(props);
-
-  switch (type) {
-    case 'heading': {
-      const lvl = Math.max(1, Math.min(6, Number(props.level ?? 2) || 2));
-      return { type: 'heading', attrs: { ...attrs, level: lvl }, content: inline };
-    }
-    case 'paragraph':
-      return { type: 'paragraph', attrs, content: inline };
-    case 'quote':
-      return {
-        type: 'blockquote',
-        attrs,
-        content: [{ type: 'paragraph', content: inline }],
-      };
-    case 'codeBlock':
-      return { type: 'codeBlock', attrs, content: inline };
-    case 'image':
-      return {
-        type: 'image',
-        attrs: {
-          src: String(props.url ?? ''),
-          alt: String(props.caption ?? ''),
-          caption: String(props.caption ?? ''),
-        },
-      };
-    case 'table':
-      return convertTable((block.content as { rows?: unknown[] } | undefined) ?? {});
-    default:
-      return {
-        type: 'paragraph',
-        attrs: { ...attrs, 'data-original-type': type },
-        content: inline,
-      };
-  }
-}
-
-function convertListItem(block: BlockNoteBlock, blockType: ListBlockType): TiptapNode {
-  const props = (block.props ?? {}) as Record<string, unknown>;
-  const inline = convertInline((block.content as BlockNoteInline[] | undefined) ?? []);
-  const attrs = propsToAttrs(props);
-
-  const itemContent: TiptapNode[] = [{ type: 'paragraph', content: inline }];
-
-  const children = block.children ?? [];
-  if (children.length > 0) {
-    const childDoc = convertBlockNoteToTiptap(children);
-    for (const childNode of childDoc.content) {
-      itemContent.push(childNode);
-    }
-  }
-
-  if (blockType === 'checkListItem') {
-    return {
-      type: 'taskItem',
-      attrs: { ...attrs, checked: !!props.checked },
-      content: itemContent,
-    };
-  }
-
-  return { type: 'listItem', attrs, content: itemContent };
-}
-
-function convertTable(content: { rows?: unknown[] }): TiptapNode {
-  const rows = Array.isArray(content.rows) ? content.rows : [];
-  const proseRows: TiptapNode[] = [];
-  let isFirstRow = true;
-  for (const row of rows) {
-    if (!row || typeof row !== 'object' || !Array.isArray((row as { cells?: unknown[] }).cells)) {
-      continue;
-    }
-    const cells: TiptapNode[] = [];
-    for (const cell of (row as { cells: unknown[] }).cells) {
-      let cellContent: TiptapNode[] = [];
-      const cellAttrs: Record<string, unknown> = {};
-      if (cell && typeof cell === 'object') {
-        const cellObj = cell as { content?: unknown; props?: { colspan?: unknown; rowspan?: unknown } };
-        if (Array.isArray(cellObj.content)) {
-          cellContent = convertInline(cellObj.content as BlockNoteInline[]);
-          if (cellObj.props) {
-            if (cellObj.props.colspan != null) {
-              cellAttrs.colspan = Number(cellObj.props.colspan) || 1;
-            }
-            if (cellObj.props.rowspan != null) {
-              cellAttrs.rowspan = Number(cellObj.props.rowspan) || 1;
-            }
-          }
-        } else if (Array.isArray(cell)) {
-          cellContent = convertInline(cell as BlockNoteInline[]);
-        }
-      }
-      cells.push({
-        type: isFirstRow ? 'tableHeader' : 'tableCell',
-        attrs: cellAttrs,
-        content: [{ type: 'paragraph', content: cellContent }],
-      });
-    }
-    proseRows.push({ type: 'tableRow', content: cells });
-    isFirstRow = false;
-  }
-
-  return { type: 'table', content: proseRows };
-}
-
-function convertInline(content: BlockNoteInline[]): TiptapNode[] {
-  const out: TiptapNode[] = [];
-  for (const span of content) {
-    if (!span || typeof span !== 'object') continue;
-    const type = String(span.type ?? 'text');
-    if (type === 'text') {
-      const text = String(span.text ?? '');
-      if (text === '') continue;
-      const marks = stylesToMarks(span.styles ?? {});
-      const node: TiptapNode = { type: 'text', text };
-      if (marks.length > 0) node.marks = marks;
-      out.push(node);
-    } else if (type === 'link') {
-      const href = String(span.href ?? '');
-      const linkMark: TiptapMark = { type: 'link', attrs: { href } };
-      for (const inner of span.content ?? []) {
-        if (!inner || inner.type !== 'text') continue;
-        const text = String(inner.text ?? '');
-        if (text === '') continue;
-        const marks = [...stylesToMarks(inner.styles ?? {}), linkMark];
-        out.push({ type: 'text', text, marks });
-      }
-    }
-  }
-  return out;
-}
-
-function stylesToMarks(styles: BlockNoteStyles): TiptapMark[] {
-  const marks: TiptapMark[] = [];
-  if (styles.bold) marks.push({ type: 'bold' });
-  if (styles.italic) marks.push({ type: 'italic' });
-  if (styles.underline) marks.push({ type: 'underline' });
-  if (styles.strike) marks.push({ type: 'strike' });
-  if (styles.code) marks.push({ type: 'code' });
-  if (styles.textColor && styles.textColor !== 'default') {
-    marks.push({ type: 'textStyle', attrs: { color: styles.textColor } });
-  }
-  if (styles.backgroundColor && styles.backgroundColor !== 'default') {
-    marks.push({ type: 'highlight', attrs: { color: styles.backgroundColor } });
-  }
-  return marks;
-}
-
-function propsToAttrs(props: Record<string, unknown>): Record<string, unknown> {
-  const attrs: Record<string, unknown> = {};
-  if (props.textColor && props.textColor !== 'default') {
-    attrs.textColor = String(props.textColor);
-  }
-  if (props.backgroundColor && props.backgroundColor !== 'default') {
-    attrs.backgroundColor = String(props.backgroundColor);
-  }
-  if (props.textAlignment) {
-    attrs.textAlign = String(props.textAlignment);
-  }
-  return attrs;
-}