koguma 0.6.6 → 2.0.0

package/src/rich-text/lexical-to-koguma.test.ts

@@ -1,906 +0,0 @@
-/**
- * lexical-to-koguma.test.ts
- *
- * Unit tests for the Lexical → KogumaDocument converter.
- * Uses raw JSON fixtures — no Lexical package required.
- */
-import { describe, test, expect } from 'bun:test';
-import { lexicalToKoguma } from './lexical-to-koguma.ts';
-
-// ── Fixtures ──────────────────────────────────────────────────────────
-
-const emptyState = { root: { type: 'root', children: [], version: 1 } };
-
-const paragraphState = {
-  root: {
-    type: 'root',
-    version: 1,
-    children: [
-      {
-        type: 'paragraph',
-        version: 1,
-        format: 0,
-        children: [{ type: 'text', text: 'Hello world', format: 0, version: 1 }]
-      }
-    ]
-  }
-};
-
-// ── Null / edge cases ────────────────────────────────────────────────
-
-describe('lexicalToKoguma — edge cases', () => {
-  test('null input returns empty document', () => {
-    expect(lexicalToKoguma(null)).toEqual({ nodes: [] });
-  });
-
-  test('undefined input returns empty document', () => {
-    expect(lexicalToKoguma(undefined)).toEqual({ nodes: [] });
-  });
-
-  test('empty object returns empty document', () => {
-    expect(lexicalToKoguma({})).toEqual({ nodes: [] });
-  });
-
-  test('empty root.children returns empty document', () => {
-    expect(lexicalToKoguma(emptyState)).toEqual({ nodes: [] });
-  });
-});
-
-// ── Paragraph ────────────────────────────────────────────────────────
-
-describe('lexicalToKoguma — paragraph', () => {
-  test('plain paragraph', () => {
-    const doc = lexicalToKoguma(paragraphState);
-    expect(doc.nodes).toHaveLength(1);
-    expect(doc.nodes[0].type).toBe('paragraph');
-    const p = doc.nodes[0] as { type: 'paragraph'; children: unknown[] };
-    expect(p.children).toHaveLength(1);
-  });
-
-  test('paragraph alignment: center', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 2,
-            children: [{ type: 'text', text: 'hi', format: 0, version: 1 }]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    expect((doc.nodes[0] as { align?: string }).align).toBe('center');
-  });
-
-  test('paragraph alignment: right', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 3,
-            children: [{ type: 'text', text: 'hi', format: 0, version: 1 }]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    expect((doc.nodes[0] as { align?: string }).align).toBe('right');
-  });
-});
-
-// ── Text formatting (bitmask) ─────────────────────────────────────────
-
-describe('lexicalToKoguma — text format bitmask', () => {
-  function textNode(format: number) {
-    return {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 0,
-            children: [{ type: 'text', text: 'X', format, version: 1 }]
-          }
-        ]
-      }
-    };
-  }
-
-  function getTextNode(state: unknown) {
-    const doc = lexicalToKoguma(state);
-    const p = doc.nodes[0] as {
-      children: Array<{
-        bold?: boolean;
-        italic?: boolean;
-        underline?: boolean;
-        strikethrough?: boolean;
-        code?: boolean;
-        subscript?: boolean;
-        superscript?: boolean;
-      }>;
-    };
-    return p.children[0];
-  }
-
-  test('bold (format=1)', () =>
-    expect(getTextNode(textNode(1)).bold).toBe(true));
-  test('italic (format=2)', () =>
-    expect(getTextNode(textNode(2)).italic).toBe(true));
-  test('strikethrough (format=4)', () =>
-    expect(getTextNode(textNode(4)).strikethrough).toBe(true));
-  test('underline (format=8)', () =>
-    expect(getTextNode(textNode(8)).underline).toBe(true));
-  test('code (format=16)', () =>
-    expect(getTextNode(textNode(16)).code).toBe(true));
-  test('subscript (format=32)', () =>
-    expect(getTextNode(textNode(32)).subscript).toBe(true));
-  test('superscript (format=64)', () =>
-    expect(getTextNode(textNode(64)).superscript).toBe(true));
-
-  test('bold+italic combined (format=3)', () => {
-    const t = getTextNode(textNode(3));
-    expect(t.bold).toBe(true);
-    expect(t.italic).toBe(true);
-  });
-
-  test('no flags when format=0', () => {
-    const t = getTextNode(textNode(0));
-    expect(t.bold).toBeUndefined();
-    expect(t.italic).toBeUndefined();
-  });
-});
-
-// ── Headings ──────────────────────────────────────────────────────────
-
-describe('lexicalToKoguma — heading', () => {
-  [1, 2, 3, 4, 5, 6].forEach(level => {
-    test(`h${level}`, () => {
-      const state = {
-        root: {
-          type: 'root',
-          version: 1,
-          children: [
-            {
-              type: 'heading',
-              version: 1,
-              tag: `h${level}`,
-              children: [
-                {
-                  type: 'text',
-                  text: `Heading ${level}`,
-                  format: 0,
-                  version: 1
-                }
-              ]
-            }
-          ]
-        }
-      };
-      const doc = lexicalToKoguma(state);
-      const h = doc.nodes[0] as { type: string; level: number };
-      expect(h.type).toBe('heading');
-      expect(h.level).toBe(level);
-    });
-  });
-});
-
-// ── Lists ─────────────────────────────────────────────────────────────
-
-describe('lexicalToKoguma — lists', () => {
-  test('unordered list', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'list',
-            version: 1,
-            listType: 'bullet',
-            start: 1,
-            tag: 'ul',
-            children: [
-              {
-                type: 'listitem',
-                version: 1,
-                value: 1,
-                children: [
-                  { type: 'text', text: 'Item 1', format: 0, version: 1 }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const list = doc.nodes[0] as {
-      type: string;
-      ordered: boolean;
-      items: unknown[];
-    };
-    expect(list.type).toBe('list');
-    expect(list.ordered).toBe(false);
-    expect(list.items).toHaveLength(1);
-  });
-
-  test('ordered list', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'list',
-            version: 1,
-            listType: 'number',
-            start: 1,
-            tag: 'ol',
-            children: [
-              {
-                type: 'listitem',
-                version: 1,
-                value: 1,
-                children: [
-                  { type: 'text', text: 'First', format: 0, version: 1 }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    expect((doc.nodes[0] as { ordered: boolean }).ordered).toBe(true);
-  });
-
-  test('checklist — checked item', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'list',
-            version: 1,
-            listType: 'check',
-            start: 1,
-            tag: 'ul',
-            children: [
-              {
-                type: 'listitem',
-                version: 1,
-                value: 1,
-                checked: true,
-                children: [
-                  { type: 'text', text: 'Done', format: 0, version: 1 }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const list = doc.nodes[0] as { items: Array<{ checked?: boolean }> };
-    expect(list.items[0].checked).toBe(true);
-  });
-
-  test('checklist — unchecked item', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'list',
-            version: 1,
-            listType: 'check',
-            start: 1,
-            tag: 'ul',
-            children: [
-              {
-                type: 'listitem',
-                version: 1,
-                value: 1,
-                checked: false,
-                children: [
-                  { type: 'text', text: 'Pending', format: 0, version: 1 }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const list = doc.nodes[0] as { items: Array<{ checked?: boolean }> };
-    expect(list.items[0].checked).toBe(false);
-  });
-
-  test('nested list', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'list',
-            version: 1,
-            listType: 'bullet',
-            start: 1,
-            tag: 'ul',
-            children: [
-              {
-                type: 'listitem',
-                version: 1,
-                value: 1,
-                children: [
-                  { type: 'text', text: 'Parent', format: 0, version: 1 },
-                  {
-                    type: 'list',
-                    version: 1,
-                    listType: 'bullet',
-                    start: 1,
-                    tag: 'ul',
-                    children: [
-                      {
-                        type: 'listitem',
-                        version: 1,
-                        value: 1,
-                        children: [
-                          { type: 'text', text: 'Child', format: 0, version: 1 }
-                        ]
-                      }
-                    ]
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const list = doc.nodes[0] as {
-      items: Array<{ nestedList?: { items: unknown[] } }>;
-    };
-    expect(list.items[0].nestedList).toBeDefined();
-    expect(list.items[0].nestedList!.items).toHaveLength(1);
-  });
-});
-
-// ── Quote ─────────────────────────────────────────────────────────────
-
-describe('lexicalToKoguma — quote', () => {
-  test('blockquote wrapping a paragraph', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'quote',
-            version: 1,
-            children: [
-              {
-                type: 'paragraph',
-                version: 1,
-                format: 0,
-                children: [
-                  { type: 'text', text: 'A quote', format: 0, version: 1 }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const q = doc.nodes[0] as {
-      type: string;
-      children: Array<{ text: string }>;
-    };
-    expect(q.type).toBe('quote');
-    expect(q.children[0].text).toBe('A quote');
-  });
-});
-
-// ── Code ─────────────────────────────────────────────────────────────
-
-describe('lexicalToKoguma — code block', () => {
-  test('extracts text from CodeHighlightNode children', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'code',
-            version: 1,
-            language: 'typescript',
-            children: [
-              {
-                type: 'code-highlight',
-                text: 'const',
-                highlightType: 'keyword',
-                version: 1
-              },
-              { type: 'text', text: ' x = 1', format: 0, version: 1 }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const code = doc.nodes[0] as {
-      type: string;
-      language?: string;
-      text: string;
-    };
-    expect(code.type).toBe('code');
-    expect(code.language).toBe('typescript');
-    expect(code.text).toBe('const x = 1');
-  });
-
-  test('code block with linebreak', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'code',
-            version: 1,
-            language: 'javascript',
-            children: [
-              { type: 'code-highlight', text: 'function foo()', version: 1 },
-              { type: 'linebreak', version: 1 },
-              { type: 'code-highlight', text: '  return 1', version: 1 }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const code = doc.nodes[0] as { text: string };
-    expect(code.text).toBe('function foo()\n  return 1');
-  });
-});
-
-// ── Horizontal Rule ───────────────────────────────────────────────────
-
-describe('lexicalToKoguma — hr', () => {
-  test('horizontal rule', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [{ type: 'horizontalrule', version: 1, children: [] }]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    expect(doc.nodes[0].type).toBe('hr');
-  });
-});
-
-// ── Links ─────────────────────────────────────────────────────────────
-
-describe('lexicalToKoguma — links', () => {
-  test('link node', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 0,
-            children: [
-              {
-                type: 'link',
-                version: 1,
-                url: 'https://example.com',
-                target: null,
-                children: [
-                  { type: 'text', text: 'Example', format: 0, version: 1 }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const p = doc.nodes[0] as {
-      children: Array<{ type: string; url: string; newTab?: boolean }>;
-    };
-    const link = p.children[0];
-    expect(link.type).toBe('link');
-    expect(link.url).toBe('https://example.com');
-    expect(link.newTab).toBeUndefined();
-  });
-
-  test('link with newTab=true', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 0,
-            children: [
-              {
-                type: 'link',
-                version: 1,
-                url: 'https://example.com',
-                newTab: true,
-                children: [
-                  { type: 'text', text: 'Link', format: 0, version: 1 }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const p = doc.nodes[0] as { children: Array<{ newTab?: boolean }> };
-    expect(p.children[0].newTab).toBe(true);
-  });
-
-  test('autolink node', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 0,
-            children: [
-              {
-                type: 'autolink',
-                version: 1,
-                url: 'https://auto.com',
-                target: null,
-                children: [
-                  { type: 'text', text: 'auto.com', format: 0, version: 1 }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const p = doc.nodes[0] as { children: Array<{ type: string }> };
-    expect(p.children[0].type).toBe('link');
-  });
-});
-
-// ── Line break ────────────────────────────────────────────────────────
-
-describe('lexicalToKoguma — line-break', () => {
-  test('linebreak node produces line-break inline', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 0,
-            children: [
-              { type: 'text', text: 'Line 1', format: 0, version: 1 },
-              { type: 'linebreak', version: 1 },
-              { type: 'text', text: 'Line 2', format: 0, version: 1 }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const p = doc.nodes[0] as { children: Array<{ type: string }> };
-    expect(p.children[1].type).toBe('line-break');
-  });
-});
-
-// ── Table ─────────────────────────────────────────────────────────────
-
-describe('lexicalToKoguma — table', () => {
-  test('basic table with header and body rows', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'table',
-            version: 1,
-            children: [
-              {
-                type: 'tablerow',
-                version: 1,
-                children: [
-                  {
-                    type: 'tablecell',
-                    version: 1,
-                    children: [
-                      { type: 'text', text: 'Name', format: 0, version: 1 }
-                    ]
-                  },
-                  {
-                    type: 'tablecell',
-                    version: 1,
-                    children: [
-                      { type: 'text', text: 'Age', format: 0, version: 1 }
-                    ]
-                  }
-                ]
-              },
-              {
-                type: 'tablerow',
-                version: 1,
-                children: [
-                  {
-                    type: 'tablecell',
-                    version: 1,
-                    children: [
-                      { type: 'text', text: 'Alice', format: 0, version: 1 }
-                    ]
-                  },
-                  {
-                    type: 'tablecell',
-                    version: 1,
-                    children: [
-                      { type: 'text', text: '30', format: 0, version: 1 }
-                    ]
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const table = doc.nodes[0] as {
-      type: string;
-      rows: Array<{ isHeader?: boolean; cells: unknown[] }>;
-    };
-    expect(table.type).toBe('table');
-    expect(table.rows).toHaveLength(2);
-    expect(table.rows[0].isHeader).toBe(true);
-    expect(table.rows[1].isHeader).toBe(false);
-    expect(table.rows[0].cells).toHaveLength(2);
-  });
-});
-
-// ── Layout ────────────────────────────────────────────────────────────
-
-describe('lexicalToKoguma — layout', () => {
-  test('layout container with two columns', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'layoutcontainer',
-            version: 1,
-            children: [
-              {
-                type: 'layoutitem',
-                version: 1,
-                children: [
-                  {
-                    type: 'paragraph',
-                    version: 1,
-                    format: 0,
-                    children: [
-                      { type: 'text', text: 'Column 1', format: 0, version: 1 }
-                    ]
-                  }
-                ]
-              },
-              {
-                type: 'layoutitem',
-                version: 1,
-                children: [
-                  {
-                    type: 'paragraph',
-                    version: 1,
-                    format: 0,
-                    children: [
-                      { type: 'text', text: 'Column 2', format: 0, version: 1 }
-                    ]
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const layout = doc.nodes[0] as { type: string; columns: unknown[][] };
-    expect(layout.type).toBe('layout');
-    expect(layout.columns).toHaveLength(2);
-  });
-});
-
-// ── Custom / embed nodes ──────────────────────────────────────────────
-
-describe('lexicalToKoguma — custom and embed nodes', () => {
-  test('unknown block node falls through to custom', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          { type: 'tweet', version: 1, tweetId: '123456', children: [] }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const node = doc.nodes[0] as {
-      type: string;
-      name: string;
-      data: Record<string, unknown>;
-    };
-    expect(node.type).toBe('custom');
-    expect(node.name).toBe('tweet');
-    expect(node.data.tweetId).toBe('123456');
-  });
-
-  test('hashtag node produces custom inline', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 0,
-            children: [
-              { type: 'hashtag', version: 1, hashtag: 'react', text: '#react' }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const p = doc.nodes[0] as {
-      children: Array<{
-        type: string;
-        name: string;
-        data: Record<string, unknown>;
-      }>;
-    };
-    expect(p.children[0].type).toBe('custom');
-    expect(p.children[0].name).toBe('hashtag');
-    expect(p.children[0].data.tag).toBe('react');
-  });
-
-  test('emoji node flattens to text', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 0,
-            children: [{ type: 'emoji', version: 1, text: '😀' }]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const p = doc.nodes[0] as {
-      children: Array<{ type: string; text: string }>;
-    };
-    expect(p.children[0].type).toBe('text');
-    expect(p.children[0].text).toBe('😀');
-  });
-
-  test('keyword and autocomplete nodes are stripped', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 0,
-            children: [
-              { type: 'text', text: 'Hello', format: 0, version: 1 },
-              { type: 'keyword', version: 1, text: 'keyword' },
-              { type: 'autocomplete', version: 1, text: 'ghost' }
-            ]
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const p = doc.nodes[0] as { children: unknown[] };
-    expect(p.children).toHaveLength(1); // only the text node
-  });
-
-  test('overflow and autocomplete block nodes are stripped', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 0,
-            children: [{ type: 'text', text: 'Hi', format: 0, version: 1 }]
-          },
-          { type: 'overflow', version: 1, children: [] },
-          { type: 'autocomplete', version: 1, children: [] }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    expect(doc.nodes).toHaveLength(1); // only the paragraph
-  });
-});
-
-// ── Image ─────────────────────────────────────────────────────────────
-
-describe('lexicalToKoguma — image', () => {
-  test('block image', () => {
-    const state = {
-      root: {
-        type: 'root',
-        version: 1,
-        children: [
-          {
-            type: 'image',
-            version: 1,
-            src: 'https://example.com/img.jpg',
-            altText: 'A photo',
-            width: 800,
-            height: 600,
-            children: []
-          }
-        ]
-      }
-    };
-    const doc = lexicalToKoguma(state);
-    const img = doc.nodes[0] as {
-      type: string;
-      url: string;
-      alt?: string;
-      width?: number;
-      height?: number;
-    };
-    expect(img.type).toBe('image');
-    expect(img.url).toBe('https://example.com/img.jpg');
-    expect(img.alt).toBe('A photo');
-    expect(img.width).toBe(800);
-    expect(img.height).toBe(600);
-  });
-});