@rimelight/cms 0.0.1

package/src/markdown/parser.ts

@@ -0,0 +1,347 @@
+import type { BaseBlock, HeadingLevel } from "../core/types/blocks"
+import type { InlineNode } from "../core/types/inline"
+
+function genId(): string {
+  return typeof crypto !== "undefined" && crypto.randomUUID
+    ? crypto.randomUUID()
+    : Math.random().toString(36).slice(2, 11)
+}
+
+export function parseInlines(text: string): InlineNode[] {
+  if (!text) return []
+
+  const inlines: InlineNode[] = []
+  // Regex to match markdown links: [text](url)
+  const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g
+  let lastIndex = 0
+  let match: RegExpExecArray | null
+
+  while ((match = linkRegex.exec(text)) !== null) {
+    const beforeText = text.substring(lastIndex, match.index)
+    if (beforeText) {
+      inlines.push(...parseFormattedText(beforeText))
+    }
+
+    const linkText = match[1] || ""
+    const linkUrl = match[2] || ""
+
+    inlines.push({
+      type: "link",
+      url: linkUrl,
+      children: [{ type: "text", text: linkText }]
+    })
+
+    lastIndex = linkRegex.lastIndex
+  }
+
+  const remainingText = text.substring(lastIndex)
+  if (remainingText) {
+    inlines.push(...parseFormattedText(remainingText))
+  }
+
+  return inlines.length > 0 ? inlines : [{ type: "text", text }]
+}
+
+function parseFormattedText(str: string): InlineNode[] {
+  if (!str) return []
+
+  // Tokenize bold, italic, code marks
+  // Format: `code`, **bold**, *italic*, ~~strikethrough~~
+  const result: InlineNode[] = []
+  const tokenRegex = /(`[^`]+`|\*\*[^*]+\*\*|\*[^*]+\*|~~[^~]+~~)/g
+  let lastIdx = 0
+  let match: RegExpExecArray | null
+
+  while ((match = tokenRegex.exec(str)) !== null) {
+    const rawBefore = str.substring(lastIdx, match.index)
+    if (rawBefore) {
+      result.push({ type: "text", text: rawBefore })
+    }
+
+    const token = match[1] || ""
+    if (token.startsWith("`") && token.endsWith("`")) {
+      result.push({
+        type: "text",
+        text: token.slice(1, -1),
+        marks: ["code"]
+      })
+    } else if (token.startsWith("**") && token.endsWith("**")) {
+      result.push({
+        type: "text",
+        text: token.slice(2, -2),
+        marks: ["bold"]
+      })
+    } else if (token.startsWith("*") && token.endsWith("*")) {
+      result.push({
+        type: "text",
+        text: token.slice(1, -1),
+        marks: ["italic"]
+      })
+    } else if (token.startsWith("~~") && token.endsWith("~~")) {
+      result.push({
+        type: "text",
+        text: token.slice(2, -2),
+        marks: ["strikethrough"]
+      })
+    }
+
+    lastIdx = tokenRegex.lastIndex
+  }
+
+  const remaining = str.substring(lastIdx)
+  if (remaining) {
+    result.push({ type: "text", text: remaining })
+  }
+
+  return result
+}
+
+export function parseMarkdownTable(tableText: string): BaseBlock | null {
+  const lines = tableText
+    .trim()
+    .split("\n")
+    .map((l) => l.trim())
+    .filter(Boolean)
+  if (lines.length < 2) return null
+
+  const parseRow = (line: string) =>
+    line
+      .replace(/^\|/, "")
+      .replace(/\|$/, "")
+      .split("|")
+      .map((c) => c.trim())
+
+  const headerCells = parseRow(lines[0] || "")
+  const alignCells = parseRow(lines[1] || "")
+
+  // Verify second line is alignment separator (e.g. ---, :---:, ---:)
+  if (!alignCells.every((c) => /^[:-]+$/.test(c))) {
+    return null
+  }
+
+  const columns = headerCells.map((header, idx) => {
+    const alignStr = alignCells[idx] || ""
+    let align: "left" | "center" | "right" = "left"
+    if (alignStr.startsWith(":") && alignStr.endsWith(":")) {
+      align = "center"
+    } else if (alignStr.endsWith(":")) {
+      align = "right"
+    }
+    return {
+      key: `col_${idx}`,
+      header,
+      align
+    }
+  })
+
+  const rows: Record<string, string>[] = []
+  for (let i = 2; i < lines.length; i++) {
+    const cells = parseRow(lines[i] || "")
+    const rowObj: Record<string, string> = {}
+    columns.forEach((col, idx) => {
+      rowObj[col.key] = cells[idx] || ""
+    })
+    rows.push(rowObj)
+  }
+
+  return {
+    id: genId(),
+    type: "TableBlock",
+    props: {
+      columns,
+      rows,
+      caption: ""
+    }
+  }
+}
+
+export function markdownToBlocks(markdown: string): BaseBlock[] {
+  if (!markdown) return []
+
+  // Strip frontmatter if present
+  let cleanMd = markdown.trim()
+  if (cleanMd.startsWith("---")) {
+    const endFm = cleanMd.indexOf("---", 3)
+    if (endFm !== -1) {
+      cleanMd = cleanMd.substring(endFm + 3).trim()
+    }
+  }
+
+  const rootBlocks: BaseBlock[] = []
+  const sectionStack: { level: number; block: BaseBlock }[] = []
+
+  const appendToCurrentScope = (block: BaseBlock) => {
+    if (sectionStack.length > 0) {
+      const topSection = sectionStack[sectionStack.length - 1]!.block
+      if (!topSection.children) topSection.children = []
+      if (!topSection.props.children) topSection.props.children = []
+      topSection.children.push(block)
+      topSection.props.children.push(block)
+    } else {
+      rootBlocks.push(block)
+    }
+  }
+
+  const lines = cleanMd.split("\n")
+  let i = 0
+
+  while (i < lines.length) {
+    const line = lines[i] || ""
+    const trimmed = line.trim()
+
+    if (!trimmed) {
+      i++
+      continue
+    }
+
+    // 1. Code Block Fence (```)
+    if (trimmed.startsWith("```")) {
+      const lang = trimmed.slice(3).trim()
+      const codeLines: string[] = []
+      i++
+      while (i < lines.length && !(lines[i] || "").trim().startsWith("```")) {
+        codeLines.push(lines[i] || "")
+        i++
+      }
+      i++ // Skip closing ```
+      appendToCurrentScope({
+        id: genId(),
+        type: "CodeBlock",
+        props: {
+          language: lang || "text",
+          code: codeLines.join("\n"),
+          caption: ""
+        }
+      })
+      continue
+    }
+
+    // 2. Headings (# to ######)
+    const headingMatch = line.match(/^(#{1,6})\s(.*)$/)
+    if (headingMatch) {
+      const hashes = headingMatch[1] || ""
+      const title = (headingMatch[2] || "").trim()
+      const level = Math.min(6, Math.max(2, hashes.length)) as HeadingLevel
+
+      const newSection: BaseBlock = {
+        id: genId(),
+        type: "SectionBlock",
+        children: [],
+        props: {
+          title,
+          level,
+          description: "",
+          children: []
+        }
+      }
+
+      // Pop sections with higher or equal level
+      while (sectionStack.length > 0 && sectionStack[sectionStack.length - 1]!.level >= level) {
+        sectionStack.pop()
+      }
+
+      appendToCurrentScope(newSection)
+      sectionStack.push({ level, block: newSection })
+      i++
+      continue
+    }
+
+    // 3. Callouts / Blockquotes (> [!NOTE], > [!WARNING], > etc.)
+    if (trimmed.startsWith(">")) {
+      const calloutLines: string[] = []
+      while (i < lines.length && (lines[i] || "").trim().startsWith(">")) {
+        calloutLines.push((lines[i] || "").trim().replace(/^>\s?/, ""))
+        i++
+      }
+      const firstLine = calloutLines[0] || ""
+      const variantMatch = firstLine.match(/^\[!([A-Z]+)\]/i)
+      let variant = "info"
+      let contentLines = calloutLines
+
+      if (variantMatch) {
+        variant = (variantMatch[1] || "info").toLowerCase()
+        contentLines = calloutLines.slice(1)
+      }
+
+      const childMd = contentLines.join("\n").trim()
+      const calloutChildren = childMd ? markdownToBlocks(childMd) : []
+
+      appendToCurrentScope({
+        id: genId(),
+        type: "CalloutBlock",
+        children: calloutChildren,
+        props: {
+          variant,
+          children: calloutChildren
+        }
+      })
+      continue
+    }
+
+    // 4. Markdown Table (| Header | Header |)
+    if (trimmed.startsWith("|") && trimmed.endsWith("|")) {
+      const tableLines: string[] = []
+      while (
+        i < lines.length &&
+        (lines[i] || "").trim().startsWith("|") &&
+        (lines[i] || "").trim().endsWith("|")
+      ) {
+        tableLines.push(lines[i] || "")
+        i++
+      }
+      const tableBlock = parseMarkdownTable(tableLines.join("\n"))
+      if (tableBlock) {
+        appendToCurrentScope(tableBlock)
+        continue
+      }
+    }
+
+    // 5. Image (![alt](src))
+    const imageMatch = trimmed.match(/^!\[([^\]]*)\]\(([^)]+)\)$/)
+    if (imageMatch) {
+      appendToCurrentScope({
+        id: genId(),
+        type: "ImageBlock",
+        props: {
+          alt: imageMatch[1] || "",
+          src: imageMatch[2] || "",
+          caption: ""
+        }
+      })
+      i++
+      continue
+    }
+
+    // 6. Regular Paragraph (gather lines until blank line or block start)
+    const paragraphLines: string[] = []
+    while (
+      i < lines.length &&
+      (lines[i] || "").trim() &&
+      !(lines[i] || "").trim().startsWith("```") &&
+      !(lines[i] || "").trim().startsWith("#") &&
+      !(lines[i] || "").trim().startsWith(">") &&
+      !((lines[i] || "").trim().startsWith("|") && (lines[i] || "").trim().endsWith("|")) &&
+      !/^[0-9]+\.\s/.test((lines[i] || "").trim())
+    ) {
+      paragraphLines.push(lines[i] || "")
+      i++
+    }
+
+    if (paragraphLines.length > 0) {
+      const paragraphText = paragraphLines.join(" ").trim()
+      const inlines = parseInlines(paragraphText)
+      appendToCurrentScope({
+        id: genId(),
+        type: "ParagraphBlock",
+        props: {
+          text: inlines
+        }
+      })
+    } else {
+      // Advance if no block consumed
+      i++
+    }
+  }
+
+  return rootBlocks
+}

package/src/markdown/serializer.ts

@@ -0,0 +1,219 @@
+import type { BaseBlock, HeadingLevel } from "../core/types/blocks"
+import type { InlineNode, TextInlineNode, LinkInlineNode } from "../core/types/inline"
+
+export function inlinesToMarkdown(
+  inlines: InlineNode[] | { en?: string } | string | undefined
+): string {
+  if (!inlines) return ""
+  if (typeof inlines === "string") return inlines
+  if (!Array.isArray(inlines)) {
+    return (inlines as any).en || ""
+  }
+
+  return inlines
+    .map((node) => {
+      if (node.type === "text") {
+        let text = (node as TextInlineNode).text || ""
+        const marks = (node as TextInlineNode).marks || []
+        if (marks.includes("code")) text = `\`${text}\``
+        if (marks.includes("bold")) text = `**${text}**`
+        if (marks.includes("italic")) text = `*${text}*`
+        if (marks.includes("strikethrough")) text = `~~${text}~~`
+        return text
+      }
+      if (node.type === "link") {
+        const link = node as LinkInlineNode
+        const linkText = (link.children || []).map((c) => c.text).join("") || link.url
+        return `[${linkText}](${link.url})`
+      }
+      if (node.type === "page_mention") {
+        const title = (node as any).displayTitle || (node as any).pageSlug || "Page"
+        return `[${title}](/${(node as any).pageSlug || ""})`
+      }
+      return ""
+    })
+    .join("")
+}
+
+export function blocksToMarkdown(
+  blocks: BaseBlock[] = [],
+  options: { sectionLevel?: number } = {}
+): string {
+  if (!Array.isArray(blocks) || blocks.length === 0) return ""
+
+  const baseLevel = options.sectionLevel ?? 2
+  const lines: string[] = []
+
+  for (const block of blocks) {
+    if (!block) continue
+    const children = block.children || block.props?.children || []
+
+    switch (block.type) {
+      case "SectionBlock": {
+        const level = (block.props?.level as HeadingLevel) || (baseLevel as HeadingLevel)
+        const hashes = "#".repeat(Math.min(6, Math.max(1, level)))
+        const title = block.props?.title || ""
+        if (title) {
+          lines.push(`${hashes} ${title}`)
+        }
+        if (block.props?.description) {
+          lines.push(`_${block.props.description}_`)
+        }
+        if (children.length > 0) {
+          lines.push(blocksToMarkdown(children, { sectionLevel: Math.min(6, level + 1) }))
+        }
+        break
+      }
+
+      case "ParagraphBlock": {
+        const text = inlinesToMarkdown(block.props?.text)
+        if (text) lines.push(text)
+        break
+      }
+
+      case "CalloutBlock": {
+        const variant = (block.props?.variant || "info").toUpperCase()
+        const childMd = blocksToMarkdown(children, options)
+        const calloutHeader = `> [!${variant}]`
+        if (childMd) {
+          const indented = childMd
+            .split("\n")
+            .map((l) => (l.trim() ? `> ${l}` : `>`))
+            .join("\n")
+          lines.push(`${calloutHeader}\n${indented}`)
+        } else {
+          lines.push(calloutHeader)
+        }
+        break
+      }
+
+      case "CodeBlock": {
+        const lang = block.props?.language || ""
+        const code = block.props?.code || ""
+        const caption = block.props?.caption ? `\n_${block.props.caption}_` : ""
+        lines.push(`\`\`\`${lang}\n${code}\n\`\`\`${caption}`)
+        break
+      }
+
+      case "TableBlock": {
+        const columns = block.props?.columns || []
+        const rows = block.props?.rows || []
+        if (columns.length > 0) {
+          const headerRow = `| ${columns.map((c: any) => c.header || c.key).join(" | ")} |`
+          const alignRow = `| ${columns
+            .map((c: any) => {
+              if (c.align === "center") return ":---:"
+              if (c.align === "right") return "---:"
+              return "---"
+            })
+            .join(" | ")} |`
+          const bodyRows = rows.map(
+            (r: any) => `| ${columns.map((c: any) => r[c.key] || "").join(" | ")} |`
+          )
+          const tableMd = [headerRow, alignRow, ...bodyRows].join("\n")
+          const caption = block.props?.caption ? `\n_${block.props.caption}_` : ""
+          lines.push(`${tableMd}${caption}`)
+        }
+        break
+      }
+
+      case "ImageBlock": {
+        const alt = block.props?.alt || ""
+        const src = block.props?.src || ""
+        const caption = block.props?.caption ? `\n_${block.props.caption}_` : ""
+        lines.push(`![${alt}](${src})${caption}`)
+        break
+      }
+
+      case "TabsBlock": {
+        for (const tab of children) {
+          const tabLabel = tab.props?.label || "Tab"
+          const tabChildren = tab.children || tab.props?.children || []
+          lines.push(`#### ${tabLabel}\n\n${blocksToMarkdown(tabChildren, options)}`)
+        }
+        break
+      }
+
+      case "TabItemBlock": {
+        const label = block.props?.label || "Tab"
+        lines.push(`#### ${label}\n\n${blocksToMarkdown(children, options)}`)
+        break
+      }
+
+      case "StepsBlock": {
+        let stepIndex = 1
+        for (const step of children) {
+          const title = step.props?.title || `Step ${stepIndex}`
+          const desc = step.props?.description ? ` - ${step.props.description}` : ""
+          const stepChildren = step.children || step.props?.children || []
+          lines.push(`${stepIndex}. **${title}**${desc}`)
+          if (stepChildren.length > 0) {
+            lines.push(blocksToMarkdown(stepChildren, options))
+          }
+          stepIndex++
+        }
+        break
+      }
+
+      case "StepItemBlock": {
+        const title = block.props?.title || "Step"
+        const desc = block.props?.description ? ` - ${block.props.description}` : ""
+        lines.push(`- **${title}**${desc}`)
+        if (children.length > 0) {
+          lines.push(blocksToMarkdown(children, options))
+        }
+        break
+      }
+
+      case "CardsBlock": {
+        for (const card of children) {
+          const title = card.props?.title || ""
+          const href = card.props?.href || "#"
+          const desc = card.props?.description ? `: ${card.props.description}` : ""
+          lines.push(`- [${title}](${href})${desc}`)
+        }
+        break
+      }
+
+      case "CardBlock": {
+        const title = block.props?.title || ""
+        const href = block.props?.href || "#"
+        const desc = block.props?.description ? `: ${block.props.description}` : ""
+        lines.push(`- [${title}](${href})${desc}`)
+        break
+      }
+
+      case "FileTreeBlock": {
+        const renderTree = (nodes: any[], prefix = ""): string[] => {
+          const treeLines: string[] = []
+          for (const node of nodes) {
+            const icon = node.isDir ? "📁 " : "📄 "
+            const comment = node.comment ? ` # ${node.comment}` : ""
+            treeLines.push(`${prefix}${icon}${node.name}${comment}`)
+            if (node.children && node.children.length > 0) {
+              treeLines.push(...renderTree(node.children, `${prefix}  `))
+            }
+          }
+          return treeLines
+        }
+        const treeNodes = block.props?.tree || []
+        lines.push(`\`\`\`text\n${renderTree(treeNodes).join("\n")}\n\`\`\``)
+        break
+      }
+
+      case "DialogueBlock": {
+        lines.push(`**${block.props?.character}:** "${block.props?.line || ""}"`)
+        break
+      }
+
+      default: {
+        if (block.props?.text) {
+          lines.push(inlinesToMarkdown(block.props.text))
+        }
+        break
+      }
+    }
+  }
+
+  return lines.filter(Boolean).join("\n\n")
+}