zengen 0.1.0

package/src/markdown.ts

@@ -0,0 +1,196 @@
+import { marked } from 'marked';
+import hljs from 'highlight.js';
+import { FileInfo, MarkdownProcessor } from './types';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as yaml from 'yaml';
+
+// 配置 marked 使用 highlight.js 进行代码高亮
+marked.setOptions({
+  highlight: function(code: string, lang: string) {
+    if (lang && hljs.getLanguage(lang)) {
+      try {
+        return hljs.highlight(code, { language: lang }).value;
+      } catch (err) {
+        console.warn(`Failed to highlight code with language ${lang}:`, err);
+      }
+    }
+    return hljs.highlightAuto(code).value;
+  },
+  pedantic: false,
+  gfm: true,
+  breaks: false,
+  sanitize: false,
+  smartLists: true,
+  smartypants: false,
+  xhtml: false
+} as any);
+
+export class MarkdownConverter {
+  private processors: MarkdownProcessor[] = [];
+
+  constructor(processors: MarkdownProcessor[] = []) {
+    this.processors = processors;
+  }
+
+  /**
+   * 添加处理器
+   */
+  addProcessor(processor: MarkdownProcessor): void {
+    this.processors.push(processor);
+  }
+
+  /**
+   * 解析 YAML frontmatter
+   */
+  private parseFrontmatter(content: string): {
+    metadata: Record<string, any>;
+    content: string;
+  } {
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n/;
+    const match = content.match(frontmatterRegex);
+
+    if (!match) {
+      return { metadata: {}, content };
+    }
+
+    try {
+      const metadata = yaml.parse(match[1]) || {};
+      const remainingContent = content.slice(match[0].length);
+      return { metadata, content: remainingContent };
+    } catch (error) {
+      console.warn('Failed to parse frontmatter:', error);
+      return { metadata: {}, content };
+    }
+  }
+
+  /**
+   * 从内容中提取标题
+   */
+  private extractTitle(content: string): string {
+    // 查找第一个一级标题
+    const h1Match = content.match(/^#\s+(.+)$/m);
+    if (h1Match) {
+      return h1Match[1].trim();
+    }
+
+    // 如果没有一级标题，查找第一个二级标题
+    const h2Match = content.match(/^##\s+(.+)$/m);
+    if (h2Match) {
+      return h2Match[1].trim();
+    }
+
+    return 'Untitled';
+  }
+
+  /**
+   * 转换 Markdown 文件
+   */
+  async convert(fileInfo: FileInfo): Promise<FileInfo> {
+    let { content, metadata } = this.parseFrontmatter(fileInfo.content);
+
+    // 应用前置处理器
+    for (const processor of this.processors) {
+      if (processor.beforeParse) {
+        content = await processor.beforeParse(content, fileInfo);
+      }
+    }
+
+    // 转换 Markdown 为 HTML
+    let html = marked.parse(content) as string;
+
+    // 应用后置处理器
+    for (const processor of this.processors) {
+      if (processor.afterParse) {
+        html = await processor.afterParse(html, fileInfo);
+      }
+    }
+
+    // 提取标题（如果 metadata 中没有）
+    if (!metadata.title) {
+      metadata.title = this.extractTitle(content);
+    }
+
+    return {
+      ...fileInfo,
+      content,
+      html,
+      metadata
+    };
+  }
+
+  /**
+   * 批量转换文件
+   */
+  async convertFiles(files: FileInfo[]): Promise<FileInfo[]> {
+    const results: FileInfo[] = [];
+
+    for (const file of files) {
+      try {
+        const result = await this.convert(file);
+        results.push(result);
+      } catch (error) {
+        console.error(`Failed to convert file ${file.path}:`, error);
+        // 即使转换失败，也保留原始文件信息
+        results.push(file);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * 从文件路径读取并转换
+   */
+  async convertFromPath(filePath: string, baseDir: string = ''): Promise<FileInfo> {
+    const content = await fs.readFile(filePath, 'utf-8');
+    const relativePath = baseDir ? path.relative(baseDir, filePath) : filePath;
+    const ext = path.extname(filePath);
+    const name = path.basename(filePath, ext);
+
+    const fileInfo: FileInfo = {
+      path: filePath,
+      relativePath,
+      name,
+      ext,
+      content
+    };
+
+    return this.convert(fileInfo);
+  }
+
+  /**
+   * 从目录读取所有 Markdown 文件并转换
+   */
+  async convertDirectory(dirPath: string): Promise<FileInfo[]> {
+    const files: FileInfo[] = [];
+
+    async function scanDirectory(currentPath: string) {
+      const entries = await fs.readdir(currentPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+
+        if (entry.isDirectory()) {
+          await scanDirectory(fullPath);
+        } else if (entry.isFile() && entry.name.endsWith('.md')) {
+          const content = await fs.readFile(fullPath, 'utf-8');
+          const relativePath = path.relative(dirPath, fullPath);
+          const ext = path.extname(entry.name);
+          const name = path.basename(entry.name, ext);
+
+          files.push({
+            path: fullPath,
+            relativePath,
+            name,
+            ext,
+            content
+          });
+        }
+      }
+    }
+
+    await scanDirectory(dirPath);
+    return this.convertFiles(files);
+  }
+}

package/src/navigation.ts

@@ -0,0 +1,191 @@
+import { NavigationItem, FileInfo } from './types';
+import * as path from 'path';
+
+export class NavigationGenerator {
+  /**
+   * 从文件信息生成导航结构
+   */
+  generate(files: FileInfo[]): NavigationItem[] {
+    // 按路径排序
+    const sortedFiles = [...files].sort((a, b) =>
+      a.relativePath.localeCompare(b.relativePath)
+    );
+
+    // 构建树形结构
+    const root: NavigationItem[] = [];
+
+    for (const file of sortedFiles) {
+      this.addFileToNavigation(root, file);
+    }
+
+    return root;
+  }
+
+  /**
+   * 将文件添加到导航树中
+   */
+  private addFileToNavigation(navigation: NavigationItem[], file: FileInfo): void {
+    const parts = file.relativePath.split('/');
+    let currentLevel = navigation;
+
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const isLastPart = i === parts.length - 1;
+      const isMarkdownFile = part.endsWith('.md');
+
+      // 如果是 Markdown 文件，移除扩展名
+      const displayName = isMarkdownFile ? part.replace(/\.md$/, '') : part;
+
+      // 生成标题（使用文件名或 metadata 中的标题）
+      const title = file.metadata?.title || this.formatTitle(displayName);
+
+      // 生成路径
+      const itemPath = isMarkdownFile
+        ? `/${file.relativePath.replace(/\.md$/, '.html')}`
+        : `/${parts.slice(0, i + 1).join('/')}`;
+
+      if (isLastPart) {
+        // 添加文件节点
+        currentLevel.push({
+          title,
+          path: itemPath
+        });
+      } else {
+        // 查找或创建目录节点
+        let dirItem = currentLevel.find(item =>
+          item.title === displayName && !item.path.endsWith('.html')
+        );
+
+        if (!dirItem) {
+          dirItem = {
+            title: this.formatTitle(displayName),
+            path: itemPath,
+            children: []
+          };
+          currentLevel.push(dirItem);
+        }
+
+        // 确保 children 存在
+        if (!dirItem.children) {
+          dirItem.children = [];
+        }
+
+        // 进入下一层
+        currentLevel = dirItem.children;
+      }
+    }
+  }
+
+  /**
+   * 格式化标题（将连字符/下划线转换为空格并首字母大写）
+   */
+  private formatTitle(name: string): string {
+    // 移除扩展名
+    const baseName = name.replace(/\.[^/.]+$/, '');
+
+    // 将连字符、下划线、点替换为空格
+    const withSpaces = baseName.replace(/[-_.]/g, ' ');
+
+    // 首字母大写每个单词
+    return withSpaces
+      .split(' ')
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join(' ');
+  }
+
+  /**
+   * 生成扁平化导航（所有页面在同一层级）
+   */
+  generateFlat(files: FileInfo[]): NavigationItem[] {
+    return files.map(file => {
+      const title = file.metadata?.title || this.formatTitle(file.name);
+      const itemPath = `/${file.relativePath.replace(/\.md$/, '.html')}`;
+
+      return {
+        title,
+        path: itemPath
+      };
+    }).sort((a, b) => a.title.localeCompare(b.title));
+  }
+
+  /**
+   * 生成面包屑导航
+   */
+  generateBreadcrumbs(filePath: string, navigation: NavigationItem[]): NavigationItem[] {
+    const parts = filePath.split('/').filter(part => part);
+    const breadcrumbs: NavigationItem[] = [];
+    let currentNav = navigation;
+
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const isLast = i === parts.length - 1;
+      const searchPath = `/${parts.slice(0, i + 1).join('/')}`;
+
+      // 在当前层级查找匹配的导航项
+      const foundItem = this.findNavigationItem(currentNav, searchPath);
+
+      if (foundItem) {
+        breadcrumbs.push({
+          title: foundItem.title,
+          path: foundItem.path
+        });
+
+        if (foundItem.children && !isLast) {
+          currentNav = foundItem.children;
+        }
+      }
+    }
+
+    return breadcrumbs;
+  }
+
+  /**
+   * 在导航树中查找项目
+   */
+  private findNavigationItem(navigation: NavigationItem[], searchPath: string): NavigationItem | null {
+    for (const item of navigation) {
+      if (item.path === searchPath) {
+        return item;
+      }
+
+      if (item.children) {
+        const found = this.findNavigationItem(item.children, searchPath);
+        if (found) {
+          return found;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * 生成站点地图 XML
+   */
+  generateSitemap(files: FileInfo[], baseUrl: string = 'https://example.com'): string {
+    const urls = files.map(file => {
+      const path = `/${file.relativePath.replace(/\.md$/, '.html')}`;
+      const lastmod = file.metadata?.last_modified || file.metadata?.date || new Date().toISOString().split('T')[0];
+
+      return `  <url>
+    <loc>${baseUrl}${path}</loc>
+    <lastmod>${lastmod}</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>0.8</priority>
+  </url>`;
+    }).join('\n');
+
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}
+</urlset>`;
+  }
+
+  /**
+   * 生成 JSON 格式的导航数据（用于前端动态加载）
+   */
+  generateJsonNavigation(files: FileInfo[]): string {
+    const navigation = this.generate(files);
+    return JSON.stringify(navigation, null, 2);
+  }
+}