koguma 0.6.4 → 0.6.6

package/src/rich-text/markdown-to-koguma.ts

@@ -0,0 +1,164 @@
+/**
+ * markdown-to-koguma.ts — Lightweight markdown → KogumaDocument converter.
+ *
+ * Designed for seed content (author-controlled markdown), not arbitrary user input.
+ * Supports: headings, paragraphs, bold, italic, code, links, lists, code blocks, HR.
+ */
+import type {
+  KogumaDocument,
+  KogumaBlockNode,
+  KogumaInlineNode,
+  KogumaListItem
+} from '../config/types.ts';
+
+// ── Inline parsing ──────────────────────────────────────────────────
+
+function parseInline(text: string): KogumaInlineNode[] {
+  const nodes: KogumaInlineNode[] = [];
+  // Regex: links, bold, italic, inline code
+  const re =
+    /\[([^\]]+)\]\(([^)]+)\)|`([^`]+)`|\*\*(.+?)\*\*|\*(.+?)\*|([^[`*]+)/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = re.exec(text)) !== null) {
+    if (match[1] !== undefined && match[2] !== undefined) {
+      // Link
+      nodes.push({
+        type: 'link',
+        url: match[2],
+        children: [{ type: 'text', text: match[1] }]
+      });
+    } else if (match[3] !== undefined) {
+      // Inline code
+      nodes.push({ type: 'text', text: match[3], code: true });
+    } else if (match[4] !== undefined) {
+      // Bold
+      nodes.push({ type: 'text', text: match[4], bold: true });
+    } else if (match[5] !== undefined) {
+      // Italic
+      nodes.push({ type: 'text', text: match[5], italic: true });
+    } else if (match[6] !== undefined && match[6].length > 0) {
+      // Plain text
+      nodes.push({ type: 'text', text: match[6] });
+    }
+  }
+
+  return nodes.length > 0 ? nodes : [{ type: 'text', text }];
+}
+
+// ── Block parsing ───────────────────────────────────────────────────
+
+export function markdownToKoguma(markdown: string): KogumaDocument {
+  const lines = markdown.split('\n');
+  const nodes: KogumaBlockNode[] = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i]!;
+
+    // Blank line — skip
+    if (line.trim() === '') {
+      i++;
+      continue;
+    }
+
+    // Fenced code block
+    const codeMatch = line.match(/^```(\w*)$/);
+    if (codeMatch) {
+      const language = codeMatch[1] || undefined;
+      const codeLines: string[] = [];
+      i++;
+      while (i < lines.length && !lines[i]!.startsWith('```')) {
+        codeLines.push(lines[i]!);
+        i++;
+      }
+      i++; // skip closing ```
+      nodes.push({ type: 'code', language, text: codeLines.join('\n') });
+      continue;
+    }
+
+    // Heading
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const level = headingMatch[1]!.length as 1 | 2 | 3 | 4 | 5 | 6;
+      nodes.push({
+        type: 'heading',
+        level,
+        children: parseInline(headingMatch[2]!)
+      });
+      i++;
+      continue;
+    }
+
+    // Horizontal rule
+    if (/^(-{3,}|\*{3,}|_{3,})$/.test(line.trim())) {
+      nodes.push({ type: 'hr' });
+      i++;
+      continue;
+    }
+
+    // Unordered list
+    if (/^[-*+]\s/.test(line)) {
+      const items: KogumaListItem[] = [];
+      while (i < lines.length && /^[-*+]\s/.test(lines[i]!)) {
+        items.push({
+          children: parseInline(lines[i]!.replace(/^[-*+]\s/, ''))
+        });
+        i++;
+      }
+      nodes.push({ type: 'list', ordered: false, items });
+      continue;
+    }
+
+    // Ordered list
+    if (/^\d+\.\s/.test(line)) {
+      const items: KogumaListItem[] = [];
+      while (i < lines.length && /^\d+\.\s/.test(lines[i]!)) {
+        items.push({
+          children: parseInline(lines[i]!.replace(/^\d+\.\s/, ''))
+        });
+        i++;
+      }
+      nodes.push({ type: 'list', ordered: true, items });
+      continue;
+    }
+
+    // Blockquote
+    if (line.startsWith('> ')) {
+      const quoteLines: string[] = [];
+      while (i < lines.length && lines[i]!.startsWith('> ')) {
+        quoteLines.push(lines[i]!.slice(2));
+        i++;
+      }
+      nodes.push({
+        type: 'quote',
+        children: parseInline(quoteLines.join(' '))
+      });
+      continue;
+    }
+
+    // Paragraph (default)
+    const paraLines: string[] = [];
+    while (
+      i < lines.length &&
+      lines[i]!.trim() !== '' &&
+      !lines[i]!.startsWith('#') &&
+      !lines[i]!.startsWith('```') &&
+      !/^[-*+]\s/.test(lines[i]!) &&
+      !/^\d+\.\s/.test(lines[i]!) &&
+      !lines[i]!.startsWith('> ') &&
+      !/^(-{3,}|\*{3,}|_{3,})$/.test(lines[i]!.trim())
+    ) {
+      paraLines.push(lines[i]!);
+      i++;
+    }
+    if (paraLines.length > 0) {
+      nodes.push({
+        type: 'paragraph',
+        children: parseInline(paraLines.join(' '))
+      });
+    }
+  }
+
+  return { nodes };
+}