koguma 0.6.6 → 2.0.0

package/src/rich-text/plain.test.ts

@@ -1,208 +0,0 @@
-/**
- * plain.test.ts — unit tests for richTextToPlain()
- */
-import { describe, test, expect } from 'bun:test';
-import { richTextToPlain } from './plain.ts';
-import type { KogumaDocument } from '../config/types.ts';
-
-const emptyDoc: KogumaDocument = { nodes: [] };
-
-const simpleDoc: KogumaDocument = {
-  nodes: [
-    { type: 'paragraph', children: [{ type: 'text', text: 'Hello world' }] }
-  ]
-};
-
-const richDoc: KogumaDocument = {
-  nodes: [
-    { type: 'heading', level: 1, children: [{ type: 'text', text: 'Title' }] },
-    {
-      type: 'paragraph',
-      children: [
-        { type: 'text', text: 'Some ' },
-        { type: 'text', text: 'bold', bold: true },
-        { type: 'text', text: ' text' }
-      ]
-    },
-    {
-      type: 'list',
-      ordered: false,
-      items: [
-        { children: [{ type: 'text', text: 'Item one' }] },
-        { children: [{ type: 'text', text: 'Item two' }] }
-      ]
-    },
-    { type: 'hr' },
-    { type: 'code', text: 'const x = 1' }
-  ]
-};
-
-describe('richTextToPlain', () => {
-  test('null input returns empty string', () => {
-    expect(richTextToPlain(null)).toBe('');
-  });
-
-  test('undefined input returns empty string', () => {
-    expect(richTextToPlain(undefined)).toBe('');
-  });
-
-  test('empty doc returns empty string', () => {
-    expect(richTextToPlain(emptyDoc)).toBe('');
-  });
-
-  test('extracts plain text from paragraph', () => {
-    expect(richTextToPlain(simpleDoc)).toBe('Hello world');
-  });
-
-  test('extracts text from heading', () => {
-    const doc: KogumaDocument = {
-      nodes: [
-        {
-          type: 'heading',
-          level: 2,
-          children: [{ type: 'text', text: 'My Heading' }]
-        }
-      ]
-    };
-    expect(richTextToPlain(doc)).toBe('My Heading');
-  });
-
-  test('strips marks — just returns text content', () => {
-    const doc: KogumaDocument = {
-      nodes: [
-        {
-          type: 'paragraph',
-          children: [
-            { type: 'text', text: 'bold', bold: true },
-            { type: 'text', text: ' and ' },
-            { type: 'text', text: 'italic', italic: true }
-          ]
-        }
-      ]
-    };
-    expect(richTextToPlain(doc)).toBe('bold and italic');
-  });
-
-  test('extracts text from multiple block types', () => {
-    const result = richTextToPlain(richDoc);
-    expect(result).toContain('Title');
-    expect(result).toContain('Some bold text');
-    expect(result).toContain('Item one');
-    expect(result).toContain('Item two');
-    expect(result).toContain('const x = 1');
-  });
-
-  test('link contributes its text, not its URL', () => {
-    const doc: KogumaDocument = {
-      nodes: [
-        {
-          type: 'paragraph',
-          children: [
-            {
-              type: 'link',
-              url: 'https://example.com',
-              children: [{ type: 'text', text: 'click here' }]
-            }
-          ]
-        }
-      ]
-    };
-    const result = richTextToPlain(doc);
-    expect(result).toBe('click here');
-    expect(result).not.toContain('https://');
-  });
-
-  test('maxLength truncates with ellipsis', () => {
-    const result = richTextToPlain(richDoc, { maxLength: 10 });
-    expect(result.endsWith('…')).toBe(true);
-    expect(result.length).toBeLessThanOrEqual(11); // 10 + '…'
-  });
-
-  test('maxLength does not truncate when text is shorter', () => {
-    const result = richTextToPlain(simpleDoc, { maxLength: 500 });
-    expect(result).toBe('Hello world');
-    expect(result.endsWith('…')).toBe(false);
-  });
-
-  test('extracts text from nested list items', () => {
-    const doc: KogumaDocument = {
-      nodes: [
-        {
-          type: 'list',
-          ordered: false,
-          items: [
-            {
-              children: [{ type: 'text', text: 'Parent' }],
-              nestedList: {
-                ordered: false,
-                items: [{ children: [{ type: 'text', text: 'Child' }] }]
-              }
-            }
-          ]
-        }
-      ]
-    };
-    const result = richTextToPlain(doc);
-    expect(result).toContain('Parent');
-    expect(result).toContain('Child');
-  });
-
-  test('extracts text from table cells', () => {
-    const doc: KogumaDocument = {
-      nodes: [
-        {
-          type: 'table',
-          rows: [
-            {
-              isHeader: true,
-              cells: [{ children: [{ type: 'text', text: 'Name' }] }]
-            },
-            { cells: [{ children: [{ type: 'text', text: 'Alice' }] }] }
-          ]
-        }
-      ]
-    };
-    const result = richTextToPlain(doc);
-    expect(result).toContain('Name');
-    expect(result).toContain('Alice');
-  });
-
-  test('inline image alt text is included', () => {
-    const doc: KogumaDocument = {
-      nodes: [
-        {
-          type: 'paragraph',
-          children: [{ type: 'inline-image', url: 'img.jpg', alt: 'a cat' }]
-        }
-      ]
-    };
-    expect(richTextToPlain(doc)).toContain('a cat');
-  });
-
-  test('layout block columns are all extracted', () => {
-    const doc: KogumaDocument = {
-      nodes: [
-        {
-          type: 'layout',
-          columns: [
-            [
-              {
-                type: 'paragraph',
-                children: [{ type: 'text', text: 'Column 1' }]
-              }
-            ],
-            [
-              {
-                type: 'paragraph',
-                children: [{ type: 'text', text: 'Column 2' }]
-              }
-            ]
-          ]
-        }
-      ]
-    };
-    const result = richTextToPlain(doc);
-    expect(result).toContain('Column 1');
-    expect(result).toContain('Column 2');
-  });
-});

package/src/rich-text/plain.ts

@@ -1,114 +0,0 @@
-/**
- * richTextToPlain.ts
- *
- * Extracts plain text from a KogumaDocument.
- * Useful for meta descriptions, search indexes, og:description, card previews.
- */
-import type {
-  KogumaDocument,
-  KogumaBlockNode,
-  KogumaInlineNode,
-  KogumaListItem
-} from '../config/types.ts';
-
-export interface PlainTextOptions {
-  /** Truncate output to this many characters, appending '…' if truncated */
-  maxLength?: number;
-}
-
-export function richTextToPlain(
-  doc: KogumaDocument | null | undefined,
-  opts?: PlainTextOptions
-): string {
-  if (!doc?.nodes?.length) return '';
-
-  const parts: string[] = [];
-
-  for (const node of doc.nodes) {
-    extractBlockText(node, parts);
-  }
-
-  let result = parts.join(' ').replace(/\s+/g, ' ').trim();
-
-  if (opts?.maxLength && result.length > opts.maxLength) {
-    result = result.slice(0, opts.maxLength).trimEnd() + '…';
-  }
-
-  return result;
-}
-
-function extractBlockText(node: KogumaBlockNode, out: string[]): void {
-  switch (node.type) {
-    case 'paragraph':
-    case 'heading':
-    case 'quote': {
-      const text = extractInlineText(node.children);
-      if (text) out.push(text);
-      break;
-    }
-
-    case 'list':
-      for (const item of node.items) {
-        extractListItemText(item, out);
-      }
-      break;
-
-    case 'code':
-      if (node.text) out.push(node.text);
-      break;
-
-    case 'table':
-      for (const row of node.rows) {
-        for (const cell of row.cells) {
-          const text = extractInlineText(cell.children);
-          if (text) out.push(text);
-        }
-      }
-      break;
-
-    case 'layout':
-      for (const column of node.columns) {
-        for (const block of column) {
-          extractBlockText(block, out);
-        }
-      }
-      break;
-
-    case 'image':
-      if (node.alt) out.push(node.alt);
-      break;
-
-    case 'hr':
-    case 'custom':
-      break;
-  }
-}
-
-function extractListItemText(item: KogumaListItem, out: string[]): void {
-  const text = extractInlineText(item.children);
-  if (text) out.push(text);
-  if (item.nestedList) {
-    for (const nested of item.nestedList.items) {
-      extractListItemText(nested, out);
-    }
-  }
-}
-
-function extractInlineText(nodes: KogumaInlineNode[]): string {
-  return nodes
-    .map(node => {
-      switch (node.type) {
-        case 'text':
-          return node.text;
-        case 'link':
-          return extractInlineText(node.children);
-        case 'line-break':
-          return '\n';
-        case 'inline-image':
-          return node.alt ?? '';
-        case 'custom':
-          return '';
-      }
-    })
-    .join('');
-}

package/src/rich-text/snapshots.test.ts

@@ -1,284 +0,0 @@
-/**
- * snapshots.test.ts
- *
- * Golden snapshot tests — ensures lexicalToKoguma() output is stable
- * across refactors. If output changes unexpectedly, these fail.
- *
- * To update snapshots after an intentional change, delete the snapshot
- * assertions and re-run to get the new expected values.
- */
-import { describe, test, expect } from 'bun:test';
-import { lexicalToKoguma } from './lexical-to-koguma.ts';
-
-// ── Complex multi-node fixture (simulates a real blog post) ──────────
-
-const BLOG_POST_STATE = {
-  root: {
-    type: 'root',
-    version: 1,
-    children: [
-      {
-        type: 'heading',
-        version: 1,
-        tag: 'h1',
-        children: [
-          {
-            type: 'text',
-            text: 'Getting Started with Koguma',
-            format: 0,
-            version: 1
-          }
-        ]
-      },
-      {
-        type: 'paragraph',
-        version: 1,
-        format: 0,
-        children: [
-          { type: 'text', text: 'Koguma is a ', format: 0, version: 1 },
-          { type: 'text', text: 'lightweight', format: 2, version: 1 }, // italic
-          {
-            type: 'text',
-            text: " CMS that runs on Cloudflare's free tier.",
-            format: 0,
-            version: 1
-          }
-        ]
-      },
-      {
-        type: 'heading',
-        version: 1,
-        tag: 'h2',
-        children: [
-          { type: 'text', text: 'Key Features', 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: 'Schema-driven content types',
-                format: 0,
-                version: 1
-              }
-            ]
-          },
-          {
-            type: 'listitem',
-            version: 1,
-            value: 2,
-            children: [
-              { type: 'text', text: 'D1 SQLite storage', format: 0, version: 1 }
-            ]
-          },
-          {
-            type: 'listitem',
-            version: 1,
-            value: 3,
-            children: [
-              { type: 'text', text: 'R2 media storage', format: 0, version: 1 }
-            ]
-          }
-        ]
-      },
-      {
-        type: 'code',
-        version: 1,
-        language: 'typescript',
-        children: [
-          {
-            type: 'code-highlight',
-            text: 'import',
-            highlightType: 'keyword',
-            version: 1
-          },
-          { type: 'text', text: ' { defineConfig } ', format: 0, version: 1 },
-          {
-            type: 'code-highlight',
-            text: 'from',
-            highlightType: 'keyword',
-            version: 1
-          },
-          { type: 'text', text: " 'koguma'", format: 0, version: 1 }
-        ]
-      },
-      {
-        type: 'quote',
-        version: 1,
-        children: [
-          {
-            type: 'paragraph',
-            version: 1,
-            format: 0,
-            children: [
-              {
-                type: 'text',
-                text: 'Build something great.',
-                format: 0,
-                version: 1
-              }
-            ]
-          }
-        ]
-      },
-      { type: 'horizontalrule', version: 1, children: [] },
-      {
-        type: 'paragraph',
-        version: 1,
-        format: 0,
-        children: [
-          { type: 'text', text: 'Read the ', format: 0, version: 1 },
-          {
-            type: 'link',
-            version: 1,
-            url: 'https://docs.koguma.dev',
-            target: '_blank',
-            children: [
-              {
-                type: 'text',
-                text: 'full documentation',
-                format: 0,
-                version: 1
-              }
-            ]
-          },
-          { type: 'text', text: ' to get started.', format: 0, version: 1 }
-        ]
-      }
-    ]
-  }
-};
-
-// ── Snapshot assertions ───────────────────────────────────────────────
-
-describe('snapshots — KogumaDocument stability', () => {
-  test('blog post fixture produces stable output', () => {
-    const doc = lexicalToKoguma(BLOG_POST_STATE);
-
-    expect(doc).toEqual({
-      nodes: [
-        {
-          type: 'heading',
-          level: 1,
-          key: undefined,
-          children: [
-            {
-              type: 'text',
-              key: undefined,
-              text: 'Getting Started with Koguma'
-            }
-          ]
-        },
-        {
-          type: 'paragraph',
-          align: undefined,
-          key: undefined,
-          children: [
-            { type: 'text', key: undefined, text: 'Koguma is a ' },
-            { type: 'text', key: undefined, text: 'lightweight', italic: true },
-            {
-              type: 'text',
-              key: undefined,
-              text: " CMS that runs on Cloudflare's free tier."
-            }
-          ]
-        },
-        {
-          type: 'heading',
-          level: 2,
-          key: undefined,
-          children: [{ type: 'text', key: undefined, text: 'Key Features' }]
-        },
-        {
-          type: 'list',
-          ordered: false,
-          key: undefined,
-          items: [
-            {
-              key: undefined,
-              checked: undefined,
-              nestedList: undefined,
-              children: [
-                {
-                  type: 'text',
-                  key: undefined,
-                  text: 'Schema-driven content types'
-                }
-              ]
-            },
-            {
-              key: undefined,
-              checked: undefined,
-              nestedList: undefined,
-              children: [
-                { type: 'text', key: undefined, text: 'D1 SQLite storage' }
-              ]
-            },
-            {
-              key: undefined,
-              checked: undefined,
-              nestedList: undefined,
-              children: [
-                { type: 'text', key: undefined, text: 'R2 media storage' }
-              ]
-            }
-          ]
-        },
-        {
-          type: 'code',
-          language: 'typescript',
-          key: undefined,
-          text: "import { defineConfig } from 'koguma'"
-        },
-        {
-          type: 'quote',
-          key: undefined,
-          children: [
-            { type: 'text', key: undefined, text: 'Build something great.' }
-          ]
-        },
-        { type: 'hr', key: undefined },
-        {
-          type: 'paragraph',
-          align: undefined,
-          key: undefined,
-          children: [
-            { type: 'text', key: undefined, text: 'Read the ' },
-            {
-              type: 'link',
-              key: undefined,
-              url: 'https://docs.koguma.dev',
-              newTab: true,
-              children: [
-                { type: 'text', key: undefined, text: 'full documentation' }
-              ]
-            },
-            { type: 'text', key: undefined, text: ' to get started.' }
-          ]
-        }
-      ]
-    });
-  });
-
-  test('empty state is stable', () => {
-    const doc = lexicalToKoguma({
-      root: { type: 'root', version: 1, children: [] }
-    });
-    expect(doc).toEqual({ nodes: [] });
-  });
-
-  test('null input is stable', () => {
-    const doc = lexicalToKoguma(null);
-    expect(doc).toEqual({ nodes: [] });
-  });
-});