cocowiki 0.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mueo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,12 @@
+# CoCoWiki
+
+CoCoWiki 是一个基于 VitePress 深度封装的、搜索优先的轻量静态 Wiki 框架，支持 Markdown、Vue 专属页面、自定义 Markdown 语法、构建期搜索和纯静态部署。
+
+```bash
+pnpm create cocowiki my-wiki
+cd my-wiki
+pnpm install
+pnpm dev
+```
+
+项目主页与完整说明位于 [CoCoWiki 源码仓库](https://github.com/coconi-dev/cocowiki)。

package/bin/cocowiki.mjs

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+import fg from 'fast-glob'
+import { existsSync } from 'node:fs'
+import { copyFile, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { basename, dirname, relative, resolve, sep } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { loadConfigFromFile } from 'vite'
+import { build, createServer, serve } from 'vitepress'
+
+const VERSION = JSON.parse(await readFile(fileURLToPath(new URL('../package.json', import.meta.url)), 'utf8')).version
+const COLOR = { reset: '\x1b[0m', dim: '\x1b[2m', cyan: '\x1b[36m', green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m', violet: '\x1b[38;5;141m' }
+const supportsColor = Boolean(process.stdout.isTTY && !process.env.NO_COLOR)
+const paint = (color, text) => supportsColor ? `${color}${text}${COLOR.reset}` : text
+const brand = paint(COLOR.violet, '[cocowiki]')
+const command = process.argv[2] || 'dev'
+const projectRoot = process.cwd()
+const configFile = resolve(projectRoot, 'cocowiki.config.ts')
+const THEME_COMPONENT_NAMES = new Set([
+  'Header', 'Home', 'Search', 'Archive', 'Contributors', 'PageMeta',
+  'PageOutline', 'ContentSidebar', 'PageNavigation', 'PageFooter',
+  'SearchOverlay', 'Loading', 'NotFound'
+])
+
+const log = {
+  info(message) { console.log(`${brand} ${paint(COLOR.cyan, message)}`) },
+  success(message) { console.log(`${brand} ${paint(COLOR.green, `✓ ${message}`)}`) },
+  warn(message) { console.warn(`${brand} ${paint(COLOR.yellow, `⚠ ${message}`)}`) },
+  error(message) { console.error(`${brand} ${paint(COLOR.red, `✗ ${message}`)}`) }
+}
+
+function fail(message) {
+  log.error(message)
+  process.exit(1)
+}
+
+function pathForImport(fromDirectory, target) {
+  const path = relative(fromDirectory, target).split(sep).join('/')
+  return path.startsWith('.') ? path : `./${path}`
+}
+
+function isInside(parent, filename) {
+  const path = relative(parent, filename)
+  return path !== '' && !path.startsWith('..') && !path.startsWith(`..${sep}`)
+}
+
+function componentName(filename) {
+  const stem = basename(filename, '.vue')
+  return stem.split(/[-_.\s]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('')
+}
+
+async function writeIfChanged(filename, content) {
+  try {
+    if (await readFile(filename, 'utf8') === content) return false
+  } catch {}
+  await mkdir(dirname(filename), { recursive: true })
+  await writeFile(filename, content)
+  return true
+}
+
+function parseOptions(args) {
+  const options = {}
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index]
+    if (argument === '--host') {
+      const value = args[index + 1]
+      options.host = value && !value.startsWith('-') ? (index += 1, value) : true
+    }
+    if (argument === '--port') options.port = Number(args[index += 1])
+  }
+  return options
+}
+
+function previewUrl(serverUrl, requestedBase = '/') {
+  const url = new URL(serverUrl)
+  const path = requestedBase.replace(/^\/+|\/+$/g, '')
+  url.pathname = path ? `/${path}/` : '/'
+  return url.href
+}
+
+async function readProjectConfig() {
+  if (!existsSync(configFile)) fail('未找到 cocowiki.config.ts。')
+  const loaded = await loadConfigFromFile({ command: command === 'build' ? 'build' : 'serve', mode: command === 'build' ? 'production' : 'development' }, configFile, projectRoot)
+  if (!loaded?.config?.title) fail('配置文件必须提供 title。')
+  return loaded.config
+}
+
+function resolvePaths(config) {
+  const directories = config.directories || {}
+  return {
+    runtimeRoot: resolve(projectRoot, '.cocowiki/site'),
+    contentDir: resolve(projectRoot, directories.content || 'content'),
+    componentsDir: resolve(projectRoot, directories.components || 'components')
+  }
+}
+
+async function writeVuePage(source, routeFile) {
+  const metadataFile = source.replace(/\.page\.vue$/, '.page.json')
+  const metadata = existsSync(metadataFile) ? JSON.parse(await readFile(metadataFile, 'utf8')) : {}
+  const title = metadata.title || basename(source, '.page.vue')
+  const componentImport = pathForImport(dirname(routeFile), source)
+  const frontmatter = { ...metadata, layout: 'special', title }
+  const frontmatterLines = Object.entries(frontmatter).map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+  await writeIfChanged(routeFile, `---\n${frontmatterLines.join('\n')}\n---\n\n<script setup lang="ts">\nimport CocoPage from ${JSON.stringify(componentImport)}\n</script>\n\n<CocoPage />\n`)
+}
+
+async function syncContentFile(paths, changedFile) {
+  const path = relative(paths.contentDir, changedFile)
+  if (!path || path.startsWith('..')) return
+
+  if (path.endsWith('.page.json')) {
+    const source = changedFile.replace(/\.page\.json$/, '.page.vue')
+    const routeFile = resolve(paths.runtimeRoot, path.replace(/\.page\.json$/, '.md'))
+    if (existsSync(source)) await writeVuePage(source, routeFile)
+    return
+  }
+
+  if (path.endsWith('.page.vue')) {
+    const routeFile = resolve(paths.runtimeRoot, path.replace(/\.page\.vue$/, '.md'))
+    if (existsSync(changedFile)) await writeVuePage(changedFile, routeFile)
+    else await rm(routeFile, { force: true })
+    return
+  }
+
+  const destination = resolve(paths.runtimeRoot, path)
+  if (existsSync(changedFile)) {
+    await mkdir(dirname(destination), { recursive: true })
+    await copyFile(changedFile, destination)
+  } else {
+    await rm(destination, { force: true })
+  }
+}
+
+async function prepareRuntime(config, { clean = true, syncContent = true } = {}) {
+  const paths = resolvePaths(config)
+  if (!existsSync(paths.contentDir)) fail(`内容目录不存在：${paths.contentDir}`)
+
+  if (clean) await rm(paths.runtimeRoot, { recursive: true, force: true })
+  const configDirectory = resolve(paths.runtimeRoot, '.vitepress')
+  const themeDirectory = resolve(configDirectory, 'theme')
+  await mkdir(themeDirectory, { recursive: true })
+
+  if (syncContent) {
+    const files = await fg('**/*', { cwd: paths.contentDir, onlyFiles: true, dot: true, ignore: ['**/*.page.json'] })
+    for (const file of files) {
+      const source = resolve(paths.contentDir, file)
+      if (file.endsWith('.page.vue')) await writeVuePage(source, resolve(paths.runtimeRoot, file.replace(/\.page\.vue$/, '.md')))
+      else {
+        const destination = resolve(paths.runtimeRoot, file)
+        await mkdir(dirname(destination), { recursive: true })
+        await copyFile(source, destination)
+      }
+    }
+  }
+
+  const configImport = pathForImport(configDirectory, configFile)
+  await writeIfChanged(resolve(configDirectory, 'config.mts'), `import userConfig from ${JSON.stringify(configImport)}\nimport { createVitePressConfig } from 'cocowiki/runtime'\nexport default createVitePressConfig(userConfig, ${JSON.stringify(projectRoot)})\n`)
+
+  const selectedTheme = config.theme?.entry
+    ? pathForImport(themeDirectory, resolve(projectRoot, config.theme.entry))
+    : 'cocowiki/theme'
+  const configuredStyles = config.theme?.styles
+  const themeStyles = (Array.isArray(configuredStyles) ? configuredStyles : configuredStyles ? [configuredStyles] : [])
+    .map((style) => `import ${JSON.stringify(pathForImport(themeDirectory, resolve(projectRoot, style)))}`)
+  const componentEntries = Object.entries(config.theme?.components || {})
+  const invalidComponents = componentEntries.filter(([name]) => !THEME_COMPONENT_NAMES.has(name))
+  if (invalidComponents.length) {
+    fail(`未知主题组件：${invalidComponents.map(([name]) => name).join('、')}。`)
+  }
+  const globalComponentFiles = existsSync(paths.componentsDir)
+    ? await fg('**/*.vue', { cwd: paths.componentsDir, onlyFiles: true })
+    : []
+  const componentNames = new Map()
+  for (const file of globalComponentFiles) {
+    const name = componentName(file)
+    if (!name) fail(`无法从组件文件名生成全局名称：${file}`)
+    const duplicate = componentNames.get(name)
+    if (duplicate) fail(`全局组件名称冲突：${duplicate} 与 ${file} 都会注册为 ${name}。`)
+    componentNames.set(name, file)
+  }
+  const overrideDeclarations = componentEntries.map(([name, entry], index) => {
+    const source = pathForImport(themeDirectory, resolve(projectRoot, entry))
+    return `const ThemeComponent${index} = defineAsyncComponent(() => import(${JSON.stringify(source)}))`
+  })
+  const overrides = componentEntries.map(([name], index) => `${JSON.stringify(name)}: ThemeComponent${index}`).join(', ')
+  const componentsPattern = `${pathForImport(themeDirectory, paths.componentsDir)}/**/*.vue`
+  await writeIfChanged(resolve(themeDirectory, 'index.ts'), `import { defineAsyncComponent } from 'vue'\nimport baseTheme from ${JSON.stringify(selectedTheme)}\nimport { cocoWikiThemeComponentsKey } from 'cocowiki/theme/customization'\n${themeStyles.join('\n')}\nconst modules = import.meta.glob(${JSON.stringify(componentsPattern)})\n${overrideDeclarations.join('\n')}\nconst themeComponentOverrides = { ${overrides} }\nfunction componentName(path) {\n  const stem = path.split('/').pop()?.replace(/\\.vue$/, '') || ''\n  return stem.split(/[-_.\\s]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('')\n}\nexport default {\n  ...baseTheme,\n  enhanceApp(context) {\n    baseTheme.enhanceApp?.(context)\n    context.app.provide(cocoWikiThemeComponentsKey, themeComponentOverrides)\n    for (const [path, loader] of Object.entries(modules)) {\n      const name = componentName(path)\n      if (name) context.app.component(name, defineAsyncComponent(loader))\n    }\n  }\n}\n`)
+
+  return paths.runtimeRoot
+}
+
+if (!new Set(['dev', 'build', 'preview']).has(command)) {
+  fail(`未知命令“${command}”，可用命令为 dev、build、preview。`)
+}
+
+try {
+  let config = await readProjectConfig()
+  const runtimeRoot = await prepareRuntime(config)
+  const options = parseOptions(process.argv.slice(3))
+
+  if (command === 'build') {
+    console.log('')
+    log.info(`CoCoWiki v${VERSION} · 正在生成静态站点`)
+    await build(runtimeRoot)
+    log.success(`构建完成：${resolve(projectRoot, config.directories?.out || 'dist')}`)
+    console.log('')
+  } else if (command === 'preview') {
+    console.log('')
+    log.info(`CoCoWiki v${VERSION} · 静态预览`)
+    await serve({ root: runtimeRoot, port: options.port, host: options.host })
+  } else {
+    const server = await createServer(runtimeRoot, options)
+    await server.listen()
+    let refreshTimer
+    let refreshing = false
+    let refreshQueued = false
+    const changedFiles = new Set()
+    let configChanged = false
+    let componentsChanged = false
+
+    const watchProjectPaths = () => {
+      const paths = resolvePaths(config)
+      server.watcher.add([paths.contentDir, paths.componentsDir, configFile])
+      return paths
+    }
+    let watchedPaths = watchProjectPaths()
+
+    const refreshRuntime = async () => {
+      if (refreshing) {
+        refreshQueued = true
+        return
+      }
+      refreshing = true
+      try {
+        if (configChanged) {
+          configChanged = false
+          const nextConfig = await readProjectConfig()
+          const nextPaths = resolvePaths(nextConfig)
+          const directoriesChanged = nextPaths.contentDir !== watchedPaths.contentDir || nextPaths.componentsDir !== watchedPaths.componentsDir
+          config = nextConfig
+          await prepareRuntime(config, { clean: directoriesChanged, syncContent: directoriesChanged })
+          watchedPaths = watchProjectPaths()
+          if (directoriesChanged) changedFiles.clear()
+          log.info('配置已更新')
+        }
+        if (componentsChanged) {
+          componentsChanged = false
+          await prepareRuntime(config, { clean: false, syncContent: false })
+        }
+        const files = [...changedFiles]
+        changedFiles.clear()
+        await Promise.all(files.map((file) => syncContentFile(watchedPaths, file)))
+      } catch (error) {
+        log.error(error instanceof Error ? error.message : String(error))
+      } finally {
+        refreshing = false
+        if (refreshQueued) {
+          refreshQueued = false
+          void refreshRuntime()
+        }
+      }
+    }
+
+    server.watcher.on('all', (event, file) => {
+      if (file === configFile) configChanged = true
+      else if (isInside(watchedPaths.componentsDir, file)) {
+        // Existing components are already part of Vite's module graph. Only a
+        // changed file list requires regenerating the global registration entry.
+        if (event === 'add' || event === 'unlink') componentsChanged = true
+        else return
+      } else if (isInside(watchedPaths.contentDir, file)) {
+        if (event === 'add' || event === 'change' || event === 'unlink') changedFiles.add(file)
+        else return
+      }
+      else return
+      clearTimeout(refreshTimer)
+      refreshTimer = setTimeout(() => void refreshRuntime(), 80)
+    })
+    const serverUrl = server.resolvedUrls?.local[0] || `http://localhost:${options.port || 5173}/`
+    const url = previewUrl(serverUrl, config.base)
+    console.log('')
+    log.info(`CoCoWiki v${VERSION}`)
+    log.success(`本地预览：${url}`)
+    console.log('')
+    const close = async () => { await server.close(); process.exit(0) }
+    process.on('SIGINT', close)
+    process.on('SIGTERM', close)
+  }
+} catch (error) {
+  console.log('')
+  log.error(error instanceof Error ? error.message : String(error))
+  console.log('')
+  process.exit(1)
+}

package/dist/config.js

@@ -0,0 +1,7 @@
+// src/config.ts
+function defineCocoWikiConfig(config) {
+  return config;
+}
+export {
+  defineCocoWikiConfig
+};

package/dist/node/vitepress.js

@@ -0,0 +1,321 @@
+// src/node/vitepress.ts
+import { existsSync } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+import { relative as relative2, resolve as resolve2 } from "node:path";
+import { defineConfig } from "vitepress";
+import { createLogger } from "vite";
+
+// src/node/content.ts
+import fg from "fast-glob";
+import matter from "gray-matter";
+import { readFile } from "node:fs/promises";
+import { relative, sep } from "node:path";
+function plainText(markdown) {
+  return markdown.replace(/```[\s\S]*?```/g, " ").replace(/<[^>]+>/g, " ").replace(/!\[[^\]]*\]\([^)]*\)/g, " ").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/\[\[([^\]]+)\]\]/g, "$1").replace(/[#>*_`~|:-]/g, " ").replace(/\s+/g, " ").trim();
+}
+function routeFromFile(contentRoot, filename) {
+  const path = relative(contentRoot, filename).split(sep).join("/").replace(/(?:\.page\.json|\.md)$/, "");
+  return path === "index" ? "/" : `/${path.replace(/\/index$/, "")}`;
+}
+function recordFromMeta(filename, contentRoot, meta, content = "") {
+  const route = routeFromFile(contentRoot, filename);
+  return {
+    id: route,
+    route,
+    title: meta.title || route.split("/").pop() || "Untitled",
+    layout: meta.layout,
+    description: meta.description || "",
+    type: meta.type || "",
+    category: meta.category || "",
+    tags: meta.tags || [],
+    aliases: meta.aliases || [],
+    contributors: meta.contributors || [],
+    image: meta.image,
+    updated: meta.updated,
+    search: meta.search,
+    archive: meta.archive,
+    content,
+    excerpt: meta.description || content.slice(0, 120)
+  };
+}
+async function scanContent(contentRoot, options = {}) {
+  const filenames = await fg(options.include || ["**/*.md"], {
+    cwd: contentRoot,
+    absolute: true,
+    ignore: options.exclude || []
+  });
+  const pageMetadata = await fg("**/*.page.json", {
+    cwd: contentRoot,
+    absolute: true,
+    ignore: options.exclude || []
+  });
+  const records = await Promise.all(filenames.map(async (filename) => {
+    const source = await readFile(filename, "utf8");
+    const parsed = matter(source);
+    const content = plainText(parsed.content);
+    const firstHeading = parsed.content.match(/^#\s+(.+)$/m)?.[1]?.trim();
+    const meta = parsed.data;
+    return recordFromMeta(filename, contentRoot, { ...meta, title: meta.title || firstHeading }, content);
+  }));
+  const vuePageRecords = await Promise.all(pageMetadata.map(async (filename) => {
+    const meta = JSON.parse(await readFile(filename, "utf8"));
+    return recordFromMeta(filename, contentRoot, meta, meta.description || "");
+  }));
+  return [...records, ...vuePageRecords].sort((a, b) => a.title.localeCompare(b.title, "zh-CN"));
+}
+
+// src/node/markdown.ts
+import container from "markdown-it-container";
+function addSpoilerRule(md) {
+  md.core.ruler.after("inline", "cocowiki-spoiler", (state) => {
+    for (const blockToken of state.tokens) {
+      if (blockToken.type !== "inline" || !blockToken.children) continue;
+      const children = [];
+      for (const token of blockToken.children) {
+        if (token.type !== "text" || !token.content.includes("||")) {
+          children.push(token);
+          continue;
+        }
+        const pattern = /\|\|([^|]+?)\|\|/g;
+        let cursor = 0;
+        let match;
+        while (match = pattern.exec(token.content)) {
+          if (match.index > cursor) {
+            const text = new state.Token("text", "", 0);
+            text.content = token.content.slice(cursor, match.index);
+            children.push(text);
+          }
+          const spoiler = new state.Token("html_inline", "", 0);
+          spoiler.content = `<button class="cw-spoiler" type="button" aria-expanded="false" aria-label="\u5267\u900F\u5185\u5BB9\uFF0C\u70B9\u51FB\u663E\u793A"><span>${md.utils.escapeHtml(match[1])}</span></button>`;
+          children.push(spoiler);
+          cursor = pattern.lastIndex;
+        }
+        if (cursor === 0) {
+          children.push(token);
+        } else if (cursor < token.content.length) {
+          const text = new state.Token("text", "", 0);
+          text.content = token.content.slice(cursor);
+          children.push(text);
+        }
+      }
+      blockToken.children = children;
+    }
+  });
+}
+function addWikiLinkRule(md, records, base) {
+  const prefix = base === "/" ? "" : base.replace(/\/$/, "");
+  const routes = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    routes.set(record.title, record.route);
+    for (const alias of record.aliases || []) routes.set(alias, record.route);
+  }
+  md.inline.ruler.before("link", "cocowiki-wikilink", (state, silent) => {
+    const start = state.pos;
+    if (state.src.slice(start, start + 2) !== "[[") return false;
+    const end = state.src.indexOf("]]", start + 2);
+    if (end < 0) return false;
+    const name = state.src.slice(start + 2, end).trim();
+    if (!name) return false;
+    if (!silent) {
+      const route = routes.get(name) || `/search?q=${encodeURIComponent(name)}`;
+      const token = state.push("html_inline", "", 0);
+      token.content = `<a class="cw-wikilink" href="${prefix}${route}">${md.utils.escapeHtml(name)}</a>`;
+    }
+    state.pos = end + 2;
+    return true;
+  });
+}
+function addTableWrapper(md) {
+  const open = md.renderer.rules.table_open || ((tokens, index, options, _env, renderer) => renderer.renderToken(tokens, index, options));
+  const close = md.renderer.rules.table_close || ((tokens, index, options, _env, renderer) => renderer.renderToken(tokens, index, options));
+  md.renderer.rules.table_open = (...args) => `<div class="cw-table-scroll">${open(...args)}`;
+  md.renderer.rules.table_close = (...args) => `${close(...args)}</div>`;
+}
+var calloutPresets = {
+  info: { title: "\u4FE1\u606F", icon: "i" },
+  tip: { title: "\u63D0\u793A", icon: "\u2713" },
+  warning: { title: "\u6CE8\u610F", icon: "!" },
+  danger: { title: "\u8B66\u544A", icon: "!" }
+};
+function addCalloutContainers(md) {
+  for (const [name, preset] of Object.entries(calloutPresets)) {
+    md.use(container, name, {
+      render(tokens, index) {
+        if (tokens[index].nesting !== 1) return "</aside>\n";
+        const customTitle = tokens[index].info.trim().slice(name.length).trim();
+        const title = md.utils.escapeHtml(customTitle || preset.title);
+        return `<aside class="cw-callout cw-callout--${name}"><span class="cw-callout__icon" aria-hidden="true">${preset.icon}</span><p class="cw-callout__title">${title}</p>
+`;
+      }
+    });
+  }
+  md.use(container, "details", {
+    render(tokens, index) {
+      if (tokens[index].nesting !== 1) return "</details>\n";
+      const customTitle = tokens[index].info.trim().slice("details".length).trim();
+      const title = md.utils.escapeHtml(customTitle || "\u8BE6\u7EC6\u4FE1\u606F");
+      return `<details class="cw-callout cw-callout--details"><summary>${title}</summary>
+`;
+    }
+  });
+}
+function applyCocoWikiMarkdown(md, records, options) {
+  if (options.spoiler !== false) addSpoilerRule(md);
+  if (options.wikiLink !== false) addWikiLinkRule(md, records, options.base || "/");
+  addTableWrapper(md);
+  addCalloutContainers(md);
+}
+
+// src/node/project.ts
+import { resolve } from "node:path";
+function resolveProjectPaths(projectRoot, config) {
+  const directories = config.directories || {};
+  return {
+    projectRoot,
+    runtimeRoot: resolve(projectRoot, ".cocowiki/site"),
+    contentDir: resolve(projectRoot, directories.content || "content"),
+    componentsDir: resolve(projectRoot, directories.components || "components"),
+    dataDir: resolve(projectRoot, directories.data || "data"),
+    publicDir: resolve(projectRoot, directories.public || "public"),
+    outDir: resolve(projectRoot, directories.out || "dist")
+  };
+}
+
+// src/node/vitepress.ts
+var CONFIG_ID = "virtual:cocowiki-config";
+var CONTRIBUTORS_ID = "virtual:cocowiki-contributors";
+var ANSI = { reset: "\x1B[0m", dim: "\x1B[2m", cyan: "\x1B[36m", yellow: "\x1B[33m", red: "\x1B[31m" };
+function createCocoWikiLogger() {
+  const logger = createLogger();
+  const label = "[cocowiki]";
+  const supportsColor = Boolean(process.stdout.isTTY && !process.env.NO_COLOR);
+  const paint = (text, color) => supportsColor ? `${color}${text}${ANSI.reset}` : text;
+  const branded = (message) => {
+    const normalized = message.replace(/\[(?:vitepress|vite)\]/gi, label);
+    return normalized.includes(label) ? normalized : `${label} ${normalized}`;
+  };
+  const optionsWithoutViteLabel = (options) => options ? { ...options, timestamp: false } : options;
+  const timestamp = (options) => options?.timestamp ? paint(`${(/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", { hour12: false })} `, ANSI.dim) : "";
+  const format = (message, color, options) => `${timestamp(options)}${paint(branded(message), color)}`;
+  const warned = /* @__PURE__ */ new Set();
+  return {
+    ...logger,
+    info: (message, options) => logger.info(format(message, ANSI.cyan, options), optionsWithoutViteLabel(options)),
+    warn: (message, options) => logger.warn(format(message, ANSI.yellow, options), optionsWithoutViteLabel(options)),
+    warnOnce: (message, options) => {
+      if (warned.has(message)) return;
+      warned.add(message);
+      logger.warn(format(message, ANSI.yellow, options), optionsWithoutViteLabel(options));
+    },
+    error: (message, options) => logger.error(format(message, ANSI.red, options), optionsWithoutViteLabel(options))
+  };
+}
+function contentPlugin(config, contentDir, dataDir, initialRecords) {
+  const records = initialRecords;
+  const resolvedConfigId = `\0${CONFIG_ID}`;
+  const resolvedContributorsId = `\0${CONTRIBUTORS_ID}`;
+  const contributorsFile = resolve2(dataDir, "contributors.json");
+  async function refresh() {
+    const nextRecords = await scanContent(contentDir, config.search);
+    records.splice(0, records.length, ...nextRecords);
+  }
+  return {
+    name: "cocowiki-content-index",
+    resolveId(id) {
+      if (id === CONFIG_ID) return resolvedConfigId;
+      if (id === CONTRIBUTORS_ID) return resolvedContributorsId;
+    },
+    async load(id) {
+      if (id === resolvedConfigId) return `export default ${JSON.stringify(config)}`;
+      if (id === resolvedContributorsId) {
+        const contributors = existsSync(contributorsFile) ? JSON.parse(await readFile2(contributorsFile, "utf8")) : {};
+        return `export default ${JSON.stringify(contributors)}`;
+      }
+    },
+    configureServer(server) {
+      server.middlewares.use((request, response, next) => {
+        if (!request.url?.split("?")[0]?.endsWith("/search-index.json")) return next();
+        response.statusCode = 200;
+        response.setHeader("Content-Type", "application/json; charset=utf-8");
+        response.setHeader("Cache-Control", "no-store");
+        response.end(JSON.stringify(records));
+      });
+      server.watcher.add([contentDir, contributorsFile]);
+      let refreshTimer;
+      const refreshContent = (file) => {
+        const path = relative2(contentDir, file);
+        if (!path || path.startsWith("..") || !path.endsWith(".md") && !path.endsWith(".page.json")) return;
+        clearTimeout(refreshTimer);
+        refreshTimer = setTimeout(async () => {
+          try {
+            await refresh();
+            server.ws.send({ type: "custom", event: "cocowiki:content-updated" });
+          } catch (error) {
+            server.config.logger.error(`\u5237\u65B0\u5185\u5BB9\u7D22\u5F15\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`);
+          }
+        }, 60);
+      };
+      const refreshContributors = (file) => {
+        if (file !== contributorsFile) return;
+        const module = server.moduleGraph.getModuleById(resolvedContributorsId);
+        if (module) server.moduleGraph.invalidateModule(module);
+        server.ws.send({ type: "full-reload" });
+      };
+      server.watcher.on("add", refreshContent);
+      server.watcher.on("change", refreshContent);
+      server.watcher.on("unlink", refreshContent);
+      server.watcher.on("add", refreshContributors);
+      server.watcher.on("change", refreshContributors);
+      server.watcher.on("unlink", refreshContributors);
+    },
+    generateBundle() {
+      this.emitFile({ type: "asset", fileName: "search-index.json", source: JSON.stringify(records) });
+    }
+  };
+}
+async function createVitePressConfig(config, projectRoot) {
+  const paths = resolveProjectPaths(projectRoot, config);
+  const records = await scanContent(paths.contentDir, config.search);
+  const requestedBase = config.base || "/";
+  const base = `/${requestedBase.replace(/^\/+|\/+$/g, "")}${requestedBase === "/" ? "" : "/"}`;
+  const favicon = config.favicon || config.logo || "/favicon.svg";
+  const faviconType = favicon.endsWith(".svg") ? "image/svg+xml" : favicon.endsWith(".ico") ? "image/x-icon" : "image/png";
+  const customLogger = createCocoWikiLogger();
+  return defineConfig({
+    title: config.title,
+    description: config.description,
+    lang: config.lang || "zh-CN",
+    base,
+    srcDir: paths.runtimeRoot,
+    cleanUrls: true,
+    outDir: paths.outDir,
+    cacheDir: resolve2(projectRoot, ".cocowiki/cache"),
+    lastUpdated: true,
+    head: [
+      ["link", { rel: "icon", type: faviconType, href: `${base}${favicon.replace(/^\//, "")}` }],
+      ["meta", { name: "theme-color", content: "#ffffff", media: "(prefers-color-scheme: light)" }],
+      ["meta", { name: "theme-color", content: "#0f1013", media: "(prefers-color-scheme: dark)" }]
+    ],
+    vite: {
+      customLogger,
+      publicDir: paths.publicDir,
+      plugins: [contentPlugin(config, paths.contentDir, paths.dataDir, records)],
+      server: { fs: { allow: [projectRoot, resolve2(import.meta.dirname, "../..")] } },
+      resolve: {
+        alias: {
+          "@components": paths.componentsDir,
+          "@data": paths.dataDir
+        }
+      }
+    },
+    markdown: {
+      lineNumbers: false,
+      config(md) {
+        applyCocoWikiMarkdown(md, records, { ...config.markdown, base });
+      }
+    }
+  });
+}
+export {
+  createVitePressConfig
+};