cocowiki 0.2.2

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "cocowiki",
+  "version": "0.2.2",
+  "type": "module",
+  "description": "Search-first static wiki framework powered by VitePress and Vue.",
+  "author": "Mueo",
+  "license": "MIT",
+  "homepage": "https://github.com/coconi-dev/cocowiki#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coconi-dev/cocowiki.git",
+    "directory": "packages/cocowiki"
+  },
+  "bugs": {
+    "url": "https://github.com/coconi-dev/cocowiki/issues"
+  },
+  "keywords": [
+    "wiki",
+    "vitepress",
+    "vue",
+    "markdown",
+    "static-site"
+  ],
+  "bin": {
+    "cocowiki": "./bin/cocowiki.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/config.ts",
+      "import": "./dist/config.js"
+    },
+    "./runtime": {
+      "types": "./src/node/vitepress.ts",
+      "import": "./dist/node/vitepress.js"
+    },
+    "./theme": "./src/theme/index.ts",
+    "./theme/customization": "./src/theme/customization.ts",
+    "./theme/components": "./src/theme/components/index.ts"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build:package": "esbuild src/config.ts src/node/vitepress.ts --bundle --platform=node --format=esm --packages=external --outdir=dist",
+    "typecheck": "vue-tsc --noEmit -p tsconfig.json",
+    "prepack": "esbuild src/config.ts src/node/vitepress.ts --bundle --platform=node --format=esm --packages=external --outdir=dist",
+    "prepublishOnly": "vue-tsc --noEmit -p tsconfig.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "fast-glob": "^3.3.3",
+    "gray-matter": "^4.0.3",
+    "markdown-it-container": "^4.0.0",
+    "minisearch": "^7.2.0",
+    "vite": "^5.4.14",
+    "vitepress": "^1.6.4",
+    "vue": "^3.5.42"
+  },
+  "devDependencies": {
+    "@types/markdown-it-container": "^2.0.12",
+    "@types/node": "^22.20.3",
+    "esbuild": "^0.21.3",
+    "typescript": "^5.7.3",
+    "vue-tsc": "^2.2.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/config.ts

@@ -0,0 +1,102 @@
+export interface CocoWikiNavigationItem {
+  text: string
+  link?: string
+  items?: CocoWikiNavigationItem[]
+}
+
+export interface CocoWikiDirectories {
+  content?: string
+  components?: string
+  data?: string
+  public?: string
+  out?: string
+}
+
+export interface CocoWikiThemeComponents {
+  Header?: string
+  Home?: string
+  Search?: string
+  Archive?: string
+  Contributors?: string
+  PageMeta?: string
+  PageOutline?: string
+  ContentSidebar?: string
+  PageNavigation?: string
+  PageFooter?: string
+  SearchOverlay?: string
+  Loading?: string
+  NotFound?: string
+}
+
+export interface CocoWikiThemeConfig {
+  /** A complete VitePress-compatible theme entry, relative to the project root. */
+  entry?: string
+  /** One or more style sheets, relative to the project root. */
+  styles?: string | string[]
+  /** Replace individual components while keeping the default CoCoWiki layout. */
+  components?: CocoWikiThemeComponents
+}
+
+export interface CocoWikiConfig {
+  title: string
+  description?: string
+  lang?: string
+  logo?: string
+  favicon?: string
+  base?: string
+  navigation?: CocoWikiNavigationItem[]
+  directories?: CocoWikiDirectories
+  theme?: CocoWikiThemeConfig
+  search?: {
+    enabled?: boolean
+    include?: string[]
+    exclude?: string[]
+  }
+  markdown?: { spoiler?: boolean; wikiLink?: boolean }
+  content?: {
+    outline?: boolean
+    sidebar?: 'none' | 'light' | 'outline'
+    showPrevNext?: boolean
+    showLastUpdated?: boolean
+  }
+  home?: {
+    name?: string
+    text?: string
+    tagline?: string
+    eyebrow?: string
+    note?: string
+    search?: { placeholder?: string }
+    visual?: {
+      image?: string
+      labels?: string[]
+    }
+    actions?: Array<{
+      text: string
+      link: string
+      theme?: 'brand' | 'alt'
+    }>
+  }
+}
+
+export interface CocoWikiPageMeta {
+  title: string
+  layout?: string
+  description?: string
+  type?: string
+  category?: string
+  tags?: string[]
+  aliases?: string[]
+  contributors?: string[]
+  image?: string
+  updated?: string
+  search?: boolean
+  archive?: boolean
+  outline?: boolean
+  sidebar?: 'none' | 'light' | 'outline'
+  showPrevNext?: boolean
+  showLastUpdated?: boolean
+}
+
+export function defineCocoWikiConfig(config: CocoWikiConfig): CocoWikiConfig {
+  return config
+}

package/src/env.d.ts

@@ -0,0 +1,17 @@
+declare module 'virtual:cocowiki-config' {
+  import type { CocoWikiConfig } from './config'
+  const config: CocoWikiConfig
+  export default config
+}
+
+declare module 'virtual:cocowiki-contributors' {
+  const contributors: Record<string, {
+    name?: string
+    initials?: string
+    role?: string
+    avatar?: string
+    url?: string
+    github?: string
+  }>
+  export default contributors
+}

package/src/node/content.ts

@@ -0,0 +1,86 @@
+import fg from 'fast-glob'
+import matter from 'gray-matter'
+import { readFile } from 'node:fs/promises'
+import { relative, sep } from 'node:path'
+import type { CocoWikiPageMeta } from '../config.ts'
+
+export interface SearchRecord extends CocoWikiPageMeta {
+  id: string
+  route: string
+  content: string
+  excerpt: string
+}
+
+function plainText(markdown: string) {
+  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: string, filename: string) {
+  const path = relative(contentRoot, filename).split(sep).join('/').replace(/(?:\.page\.json|\.md)$/, '')
+  return path === 'index' ? '/' : `/${path.replace(/\/index$/, '')}`
+}
+
+function recordFromMeta(filename: string, contentRoot: string, meta: Partial<CocoWikiPageMeta>, 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)
+  } satisfies SearchRecord
+}
+
+export async function scanContent(
+  contentRoot: string,
+  options: { include?: string[]; exclude?: string[] } = {}
+): Promise<SearchRecord[]> {
+  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 as Partial<CocoWikiPageMeta>
+
+    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')) as Partial<CocoWikiPageMeta>
+    return recordFromMeta(filename, contentRoot, meta, meta.description || '')
+  }))
+
+  return [...records, ...vuePageRecords]
+    .sort((a, b) => a.title.localeCompare(b.title, 'zh-CN'))
+}

package/src/node/markdown.ts

@@ -0,0 +1,115 @@
+import container from 'markdown-it-container'
+import type { SearchRecord } from './content.ts'
+
+function addSpoilerRule(md: any) {
+  md.core.ruler.after('inline', 'cocowiki-spoiler', (state: any) => {
+    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: RegExpExecArray | null
+        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="剧透内容，点击显示"><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: any, records: SearchRecord[], base: string) {
+  const prefix = base === '/' ? '' : base.replace(/\/$/, '')
+  const routes = new Map<string, string>()
+  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: any, silent: boolean) => {
+    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: any) {
+  const open = md.renderer.rules.table_open || ((tokens: any[], index: number, options: any, _env: any, renderer: any) => renderer.renderToken(tokens, index, options))
+  const close = md.renderer.rules.table_close || ((tokens: any[], index: number, options: any, _env: any, renderer: any) => renderer.renderToken(tokens, index, options))
+  md.renderer.rules.table_open = (...args: any[]) => `<div class="cw-table-scroll">${open(...args)}`
+  md.renderer.rules.table_close = (...args: any[]) => `${close(...args)}</div>`
+}
+
+const calloutPresets = {
+  info: { title: '信息', icon: 'i' },
+  tip: { title: '提示', icon: '✓' },
+  warning: { title: '注意', icon: '!' },
+  danger: { title: '警告', icon: '!' }
+} as const
+
+function addCalloutContainers(md: any) {
+  for (const [name, preset] of Object.entries(calloutPresets)) {
+    md.use(container, name, {
+      render(tokens: Array<{ nesting: number; info: string }>, index: number) {
+        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>\n`
+      }
+    })
+  }
+
+  md.use(container, 'details', {
+    render(tokens: Array<{ nesting: number; info: string }>, index: number) {
+      if (tokens[index].nesting !== 1) return '</details>\n'
+      const customTitle = tokens[index].info.trim().slice('details'.length).trim()
+      const title = md.utils.escapeHtml(customTitle || '详细信息')
+      return `<details class="cw-callout cw-callout--details"><summary>${title}</summary>\n`
+    }
+  })
+}
+
+export function applyCocoWikiMarkdown(
+  md: any,
+  records: SearchRecord[],
+  options: { spoiler?: boolean; wikiLink?: boolean; base?: string }
+) {
+  if (options.spoiler !== false) addSpoilerRule(md)
+  if (options.wikiLink !== false) addWikiLinkRule(md, records, options.base || '/')
+  addTableWrapper(md)
+  addCalloutContainers(md)
+}

package/src/node/project.ts

@@ -0,0 +1,25 @@
+import { resolve } from 'node:path'
+import type { CocoWikiConfig } from '../config.ts'
+
+export interface CocoWikiProjectPaths {
+  projectRoot: string
+  runtimeRoot: string
+  contentDir: string
+  componentsDir: string
+  dataDir: string
+  publicDir: string
+  outDir: string
+}
+
+export function resolveProjectPaths(projectRoot: string, config: CocoWikiConfig): CocoWikiProjectPaths {
+  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')
+  }
+}

package/src/node/vitepress.ts

@@ -0,0 +1,160 @@
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { relative, resolve } from 'node:path'
+import { defineConfig, type UserConfig } from 'vitepress'
+import { createLogger, type Plugin } from 'vite'
+import type { CocoWikiConfig } from '../config.ts'
+import { scanContent, type SearchRecord } from './content.ts'
+import { applyCocoWikiMarkdown } from './markdown.ts'
+import { resolveProjectPaths } from './project.ts'
+
+const CONFIG_ID = 'virtual:cocowiki-config'
+const CONTRIBUTORS_ID = 'virtual:cocowiki-contributors'
+const 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: string, color: string) => supportsColor ? `${color}${text}${ANSI.reset}` : text
+  const branded = (message: string) => {
+    const normalized = message.replace(/\[(?:vitepress|vite)\]/gi, label)
+    return normalized.includes(label) ? normalized : `${label} ${normalized}`
+  }
+  const optionsWithoutViteLabel = (options?: any) => options ? { ...options, timestamp: false } : options
+  const timestamp = (options?: any) => options?.timestamp
+    ? paint(`${new Date().toLocaleTimeString('en-GB', { hour12: false })} `, ANSI.dim)
+    : ''
+  const format = (message: string, color: string, options?: any) => `${timestamp(options)}${paint(branded(message), color)}`
+  const warned = new Set<string>()
+  return {
+    ...logger,
+    info: (message: string, options?: any) => logger.info(format(message, ANSI.cyan, options), optionsWithoutViteLabel(options)),
+    warn: (message: string, options?: any) => logger.warn(format(message, ANSI.yellow, options), optionsWithoutViteLabel(options)),
+    warnOnce: (message: string, options?: any) => {
+      if (warned.has(message)) return
+      warned.add(message)
+      logger.warn(format(message, ANSI.yellow, options), optionsWithoutViteLabel(options))
+    },
+    error: (message: string, options?: any) => logger.error(format(message, ANSI.red, options), optionsWithoutViteLabel(options))
+  }
+}
+
+function contentPlugin(
+  config: CocoWikiConfig,
+  contentDir: string,
+  dataDir: string,
+  initialRecords: SearchRecord[]
+): Plugin {
+  const records = initialRecords
+  const resolvedConfigId = `\0${CONFIG_ID}`
+  const resolvedContributorsId = `\0${CONTRIBUTORS_ID}`
+  const contributorsFile = resolve(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 readFile(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: ReturnType<typeof setTimeout> | undefined
+      const refreshContent = (file: string) => {
+        const path = relative(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(`刷新内容索引失败：${error instanceof Error ? error.message : String(error)}`)
+          }
+        }, 60)
+      }
+      const refreshContributors = (file: string) => {
+        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) })
+    }
+  }
+}
+
+export async function createVitePressConfig(
+  config: CocoWikiConfig,
+  projectRoot: string
+): Promise<UserConfig> {
+  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: resolve(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, resolve(import.meta.dirname, '../..')] } },
+      resolve: {
+        alias: {
+          '@components': paths.componentsDir,
+          '@data': paths.dataDir
+        }
+      }
+    },
+    markdown: {
+      lineNumbers: false,
+      config(md) {
+        applyCocoWikiMarkdown(md, records, { ...config.markdown, base })
+      }
+    }
+  })
+}