react-docs-ui 0.7.5 → 0.7.6

package/scripts/generate-doc-git-meta.mjs

@@ -0,0 +1,63 @@
+import { promisify } from "node:util"
+import { execFile } from "node:child_process"
+import { glob } from "glob"
+import path from "node:path"
+import fs from "node:fs/promises"
+
+const execFileAsync = promisify(execFile)
+const rootDir = process.cwd()
+const publicDir = path.join(rootDir, "public")
+const outputPath = path.join(publicDir, "doc-git-meta.json")
+
+async function getGitValue(args) {
+  try {
+    const { stdout } = await execFileAsync("git", args, { cwd: rootDir })
+    return stdout.trim()
+  } catch {
+    return ""
+  }
+}
+
+async function main() {
+  const repoRoot = (await getGitValue(["rev-parse", "--show-toplevel"])) || rootDir
+  const files = await glob("public/docs/**/*.{md,mdx}", {
+    cwd: rootDir,
+    absolute: true,
+    nodir: true,
+  })
+
+  const entries = []
+  for (const file of files) {
+    const relativePath = path.relative(repoRoot, file).replace(/\\/g, "/")
+    const [lastUpdated, author] = await Promise.all([
+      getGitValue(["log", "-1", "--format=%cI", "--", relativePath]),
+      getGitValue(["log", "-1", "--format=%an", "--", relativePath]),
+    ])
+    entries.push({
+      relativePath: path.relative(rootDir, file).replace(/\\/g, "/"),
+      meta: {
+        lastUpdated: lastUpdated || undefined,
+        author: author || undefined,
+      },
+    })
+  }
+  const docMeta = Object.fromEntries(
+    entries
+      .filter(({ meta }) => meta.lastUpdated || meta.author)
+      .map(({ relativePath, meta }) => [relativePath, meta])
+  )
+
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    files: docMeta,
+  }
+
+  await fs.mkdir(publicDir, { recursive: true })
+  await fs.writeFile(outputPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8")
+  console.log(`[doc-git-meta] Wrote ${Object.keys(docMeta).length} entries to public/doc-git-meta.json`)
+}
+
+main().catch((error) => {
+  console.error("[doc-git-meta] Failed:", error)
+  process.exitCode = 1
+})

package/scripts/generate-llms-files.mjs

@@ -0,0 +1,34 @@
+import fs from "node:fs/promises"
+import path from "node:path"
+import { glob } from "glob"
+
+const rootDir = process.cwd()
+const publicDir = path.join(rootDir, "public")
+
+function stripFrontmatter(source) {
+  if (!source.startsWith("---\n")) return source
+  const endIndex = source.indexOf("\n---\n", 4)
+  return endIndex === -1 ? source : source.slice(endIndex + 5)
+}
+
+async function main() {
+  const files = await glob("public/docs/**/*.{md,mdx}", { cwd: rootDir, absolute: true, nodir: true })
+  const docs = await Promise.all(files.map(async (file) => {
+    const relative = path.relative(rootDir, file).replace(/\\/g, "/")
+    const urlPath = relative.replace(/^public\/docs\//, "").replace(/\.(md|mdx)$/i, "")
+    const content = stripFrontmatter(await fs.readFile(file, "utf8")).trim()
+    return { relative, urlPath, content }
+  }))
+
+  const llms = docs.map((doc) => `- /${doc.urlPath} | ${doc.relative}`).join("\n")
+  const llmsFull = docs.map((doc) => `# /${doc.urlPath}\n\n${doc.content}`).join("\n\n")
+
+  await fs.writeFile(path.join(publicDir, "llms.txt"), `${llms}\n`, "utf8")
+  await fs.writeFile(path.join(publicDir, "llms-full.txt"), `${llmsFull}\n`, "utf8")
+  console.log(`[llms] Wrote ${docs.length} docs to llms.txt and llms-full.txt`)
+}
+
+main().catch((error) => {
+  console.error("[llms] Failed:", error)
+  process.exitCode = 1
+})

package/scripts/generate-search-index.mjs

@@ -0,0 +1,236 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+const ROOT_DIR = process.cwd()
+const PUBLIC_DIR = path.join(ROOT_DIR, 'public')
+const DOCS_DIR = path.join(PUBLIC_DIR, 'docs')
+
+const SEARCH_INDEX_VERSION = '2.0.0'
+const MAX_CONTENT_LENGTH = 300
+
+function isChinese(text) {
+  return /[\u4e00-\u9fa5]/.test(text)
+}
+
+function tokenize(text) {
+  if (!text) return []
+  const tokens = []
+  const parts = text.split(/(\s+|[，。！？、；：""''（）【】《》\n\r]+)/)
+  for (const part of parts) {
+    if (!part.trim()) continue
+    if (isChinese(part)) {
+      const chars = part.split('')
+      for (let i = 0; i < chars.length - 1; i++) {
+        tokens.push(chars[i] + chars[i + 1])
+      }
+      tokens.push(...chars.filter(c => c.trim()))
+    } else {
+      const words = part.toLowerCase().split(/[^a-zA-Z0-9]+/).filter(w => w.length > 0)
+      tokens.push(...words)
+    }
+  }
+  return [...new Set(tokens)]
+}
+
+function parseFrontmatter(content) {
+  const normalized = content.replace(/^\uFEFF/, '')
+  const lines = normalized.split(/\r?\n/)
+  const data = {}
+  let contentStart = 0
+  if (lines[0]?.startsWith('---')) {
+    let i = 1
+    while (i < lines.length && !lines[i]?.startsWith('---')) {
+      const line = lines[i]
+      const colonIndex = line?.indexOf(':') ?? -1
+      if (colonIndex > 0 && line) {
+        const key = line.substring(0, colonIndex).trim()
+        const value = line.substring(colonIndex + 1).trim()
+        data[key] = value
+      }
+      i++
+    }
+    if (i < lines.length && lines[i]?.startsWith('---')) {
+      contentStart = i + 1
+    }
+  }
+  return { data, content: lines.slice(contentStart).join('\n') }
+}
+
+function cleanContent(text) {
+  return text
+    .replace(/\s+/g, ' ')
+    .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1')
+    .replace(/[#*`_~>|]/g, '')
+    .replace(/\$\$?[^$]+\$\$?/g, '')
+    .trim()
+}
+
+function extractTextContent(node) {
+  if (!node || typeof node !== 'object') return ''
+  if (node.type === 'text') return node.value || ''
+  if (node.type === 'inlineCode') return `\`${node.value || ''}\``
+  if (node.type === 'code') return node.value || ''
+  if ('children' in node && Array.isArray(node.children)) {
+    return node.children.map(extractTextContent).join(' ')
+  }
+  return ''
+}
+
+async function parseMarkdown(content) {
+  const { unified } = await import('unified')
+  const remarkParse = (await import('remark-parse')).default
+  const remarkGfm = (await import('remark-gfm')).default
+  const remarkMath = (await import('remark-math')).default
+
+  const { data: frontmatter, content: markdownContent } = parseFrontmatter(content)
+  const processor = unified().use(remarkParse).use(remarkGfm).use(remarkMath)
+  const tree = processor.parse(markdownContent)
+
+  const title = frontmatter.title || ''
+  const sections = []
+  let currentSection = null
+  let contentParts = []
+
+  const saveCurrentSection = () => {
+    if (currentSection && contentParts.length > 0) {
+      currentSection.content = cleanContent(contentParts.join(' '))
+      sections.push(currentSection)
+    }
+    contentParts = []
+  }
+
+  for (const node of tree.children) {
+    if (node.type === 'heading') {
+      saveCurrentSection()
+      currentSection = {
+        title: extractTextContent(node),
+        content: '',
+        level: node.depth,
+      }
+    } else if (currentSection) {
+      const text = extractTextContent(node)
+      if (text) contentParts.push(text)
+    }
+  }
+
+  saveCurrentSection()
+
+  if (sections.length === 0 && title) {
+    const allContent = []
+    for (const node of tree.children) {
+      const text = extractTextContent(node)
+      if (text) allContent.push(text)
+    }
+    if (allContent.length > 0) {
+      sections.push({
+        title,
+        content: cleanContent(allContent.join(' ')),
+        level: 1,
+      })
+    }
+  }
+
+  return { title, sections }
+}
+
+function scanDocsDirectory(docsDir, baseDir, lang, results = []) {
+  if (!fs.existsSync(docsDir)) return results
+  const entries = fs.readdirSync(docsDir, { withFileTypes: true })
+  for (const entry of entries) {
+    const fullPath = path.join(docsDir, entry.name)
+    if (entry.isDirectory()) {
+      scanDocsDirectory(fullPath, baseDir, lang, results)
+    } else if (entry.isFile() && ['.md', '.mdx'].includes(path.extname(entry.name))) {
+      results.push({ filePath: fullPath, relativePath: path.relative(baseDir, fullPath), lang })
+    }
+  }
+  return results
+}
+
+function generateId(docPath, sectionTitle) {
+  const base = docPath.replace(/[\/\\]/g, '-')
+  const anchor = sectionTitle.toLowerCase().replace(/[^\w\u4e00-\u9fa5]+/g, '-').replace(/^-+|-+$/g, '')
+  return anchor ? `${base}--${anchor}` : base
+}
+
+function buildUrl(lang, docPath, sectionTitle) {
+  const anchor = sectionTitle.toLowerCase().replace(/[^\w\u4e00-\u9fa5]+/g, '-').replace(/^-+|-+$/g, '')
+  let url = `/${lang}/${docPath}`
+  if (anchor) url += `#${anchor}`
+  return url
+}
+
+function truncateContent(content, maxLength) {
+  if (content.length <= maxLength) return content
+  return content.slice(0, maxLength)
+}
+
+async function generateSearchIndex(lang) {
+  console.log(`Generating search index for language: ${lang}`)
+  const docsLangDir = path.join(DOCS_DIR, lang)
+  const files = scanDocsDirectory(docsLangDir, path.join(PUBLIC_DIR, 'docs'), lang)
+  const sections = []
+
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(file.filePath, 'utf-8')
+      const docPath = file.relativePath
+        .replace(new RegExp(`^${lang}[/\\\\]`), '')
+        .replace(/\.(md|mdx)$/, '')
+        .replace(/[/\\]index$/, '')
+      
+      const parsed = await parseMarkdown(content)
+
+      for (const section of parsed.sections) {
+        const id = generateId(docPath, section.title)
+        const url = buildUrl(lang, docPath, section.title)
+        const fullText = section.title + ' ' + section.content
+        const tokens = await tokenize(fullText)
+
+        sections.push({
+          id,
+          pageTitle: parsed.title,
+          sectionTitle: section.title,
+          content: truncateContent(section.content, MAX_CONTENT_LENGTH),
+          url,
+          lang,
+          tokens,
+        })
+      }
+    } catch (error) {
+      console.warn(`Failed to process ${file.filePath}:`, error.message)
+    }
+  }
+  
+  return {
+    version: SEARCH_INDEX_VERSION,
+    generatedAt: Date.now(),
+    lang,
+    sections,
+  }
+}
+
+async function main() {
+  console.log('Starting search index generation...')
+  if (!fs.existsSync(DOCS_DIR)) {
+    console.error('Docs directory not found:', DOCS_DIR)
+    process.exit(1)
+  }
+
+  const entries = fs.readdirSync(DOCS_DIR, { withFileTypes: true })
+  const langs = entries.filter(e => e.isDirectory()).map(e => e.name)
+  console.log('Found languages:', langs.join(', '))
+
+  for (const lang of langs) {
+    const index = await generateSearchIndex(lang)
+    const outputPath = path.join(PUBLIC_DIR, `search-index-${lang}.json`)
+    fs.writeFileSync(outputPath, JSON.stringify(index))
+    console.log(`Generated: ${outputPath} (${index.sections.length} sections)`)
+  }
+  console.log('Search index generation complete!')
+}
+
+main().catch(error => {
+  console.error('Error generating search index:', error)
+  process.exit(1)
+})

package/scripts/generate-shiki-bundle.mjs

@@ -0,0 +1,80 @@
+import fs from "node:fs"
+import path from "node:path"
+import yaml from "js-yaml"
+
+const rootDir = process.cwd()
+const configDir = path.join(rootDir, "public", "config")
+const outputFile = path.join(rootDir, "src", "generated", "shiki-bundle.ts")
+const defaultLangs = [
+  "javascript", "typescript", "jsx", "tsx", "bash", "shell",
+  "python", "java", "c", "cpp", "csharp", "go", "rust", "ruby",
+  "php", "swift", "kotlin", "sql", "json", "yaml", "toml",
+  "markdown", "html", "css", "scss", "less", "vue", "svelte",
+  "docker", "nginx", "xml", "diff", "regex",
+]
+const langAliasMap = {
+  js: "javascript",
+  ts: "typescript",
+  sh: "shell",
+  shell: "bash",
+  yml: "yaml",
+  md: "markdown",
+  rb: "ruby",
+  py: "python",
+  dockerfile: "docker",
+  conf: "nginx",
+}
+
+function resolveLang(lang) {
+  const normalized = String(lang || "").trim().toLowerCase()
+  return normalized ? langAliasMap[normalized] || normalized : null
+}
+
+function readYamlConfig(fileName) {
+  const filePath = path.join(configDir, fileName)
+  return fs.existsSync(filePath) ? yaml.load(fs.readFileSync(filePath, "utf8")) : null
+}
+
+function collectBundleConfig() {
+  const configs = ["site.yaml", "site.en.yaml"].map(readYamlConfig).filter(Boolean)
+  const langs = new Set()
+  const themes = new Set()
+  for (const config of configs) {
+    const configuredLangs = config?.codeHighlight?.langs
+    const sourceLangs = Array.isArray(configuredLangs) && configuredLangs.length > 0 ? configuredLangs : defaultLangs
+    sourceLangs.forEach(lang => {
+      const resolved = resolveLang(lang)
+      if (resolved) langs.add(resolved)
+    })
+    themes.add(String(config?.codeHighlight?.lightTheme || "github-light").trim())
+    themes.add(String(config?.codeHighlight?.darkTheme || "github-dark").trim())
+  }
+  if (langs.size === 0) defaultLangs.forEach(lang => langs.add(resolveLang(lang)))
+  if (themes.size === 0) {
+    themes.add("github-light")
+    themes.add("github-dark")
+  }
+  return { langs: Array.from(langs).sort(), themes: Array.from(themes).sort() }
+}
+
+function toObjectEntries(values, basePath) {
+  return values.map(value => `    ${JSON.stringify(value)}: () => import(${JSON.stringify(`${basePath}/${value}`)}),`).join("\n")
+}
+
+function main() {
+  const bundleConfig = collectBundleConfig()
+  const fileContent = `export const siteShikiBundle = {
+  langs: {
+${toObjectEntries(bundleConfig.langs, "shiki/langs")}
+  },
+  themes: {
+${toObjectEntries(bundleConfig.themes, "shiki/themes")}
+  },
+}
+`
+  fs.mkdirSync(path.dirname(outputFile), { recursive: true })
+  fs.writeFileSync(outputFile, fileContent, "utf8")
+  console.log(`[shiki-bundle] generated ${path.relative(rootDir, outputFile)} with ${bundleConfig.langs.length} languages and ${bundleConfig.themes.length} themes`)
+}
+
+main()