@doki-land/dejavu-engine 0.0.0

package/bin/dejavu.mjs

@@ -0,0 +1,379 @@
+#!/usr/bin/env node
+
+import {
+    DejavuEngine,
+    DejavuLanguage,
+    parse,
+} from "../dist/index.js";
+import {
+    readFileSync,
+    writeFileSync,
+    existsSync,
+    readdirSync,
+    statSync,
+    mkdirSync,
+} from "fs";
+import { join, resolve, extname, basename, relative } from "path";
+
+const VERSION = "0.1.0";
+
+const COLORS = {
+    reset: "\x1b[0m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+    gray: "\x1b[90m",
+};
+
+function color(text, colorName) {
+    return `${COLORS[colorName] || ""}${text}${COLORS.reset}`;
+}
+
+function printBanner() {
+    console.log(color("╭──────────────────────────────────────╮", "cyan"));
+    console.log(color("│", "cyan") + color("   DejaVu 模板引擎 CLI               ", "white") + color("│", "cyan"));
+    console.log(color("╰──────────────────────────────────────╯", "cyan"));
+    console.log();
+}
+
+function printHelp() {
+    console.log(color("DejaVu Engine - 模板引擎命令行工具", "white"));
+    console.log();
+    console.log(color("用法:", "cyan"));
+    console.log("  dejavu <命令> [选项]");
+    console.log();
+    console.log(color("命令:", "cyan"));
+    console.log("  render <template> [data]     渲染模板文件");
+    console.log("  check <template>             检查模板语法");
+    console.log("  build <dir> [output]         批量编译模板目录");
+    console.log("  help                         显示帮助信息");
+    console.log("  version                      显示版本号");
+    console.log();
+    console.log(color("选项:", "cyan"));
+    console.log("  -d, --data <json>            JSON 数据文件路径");
+    console.log("  -o, --output <path>          输出文件路径");
+    console.log("  -e, --encoding <enc>         文件编码 (默认 utf-8)");
+    console.log("  --start <str>                代码块开始定界符 (默认 {{)");
+    console.log("  --end <str>                  代码块结束定界符 (默认 }})");
+    console.log("  --comment-start <str>        注释开始定界符 (默认 {#)");
+    console.log("  --comment-end <str>          注释结束定界符 (默认 #})");
+    console.log();
+    console.log(color("示例:", "cyan"));
+    console.log("  dejavu render template.html");
+    console.log("  dejavu render template.html -d data.json");
+    console.log("  dejavu render template.html -o output.html");
+    console.log("  dejavu check template.html");
+    console.log("  dejavu build ./templates ./dist");
+    console.log();
+    console.log(color("文档: https://github.com/doki-land/dejavu-engine", "gray"));
+}
+
+function printVersion() {
+    console.log(`DejaVu Engine v${VERSION}`);
+}
+
+function parseArgs(args) {
+    const result = {
+        command: null,
+        template: null,
+        data: null,
+        output: null,
+        encoding: "utf-8",
+        startDelimiter: "{{",
+        endDelimiter: "}}",
+        commentStart: "{#",
+        commentEnd: "#}",
+        extraArgs: [],
+    };
+
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        
+        if (arg === "-d" || arg === "--data") {
+            result.data = args[++i];
+        } else if (arg === "-o" || arg === "--output") {
+            result.output = args[++i];
+        } else if (arg === "-e" || arg === "--encoding") {
+            result.encoding = args[++i];
+        } else if (arg === "--start") {
+            result.startDelimiter = args[++i];
+        } else if (arg === "--end") {
+            result.endDelimiter = args[++i];
+        } else if (arg === "--comment-start") {
+            result.commentStart = args[++i];
+        } else if (arg === "--comment-end") {
+            result.commentEnd = args[++i];
+        } else if (!arg.startsWith("-")) {
+            if (!result.command) {
+                result.command = arg;
+            } else if (!result.template) {
+                result.template = arg;
+            } else {
+                result.extraArgs.push(arg);
+            }
+        }
+        i++;
+    }
+
+    return result;
+}
+
+function createLanguage(options) {
+    return new DejavuLanguage().withTemplate({
+        codeStart: options.startDelimiter,
+        codeEnd: options.endDelimiter,
+        commentStart: options.commentStart,
+        commentEnd: options.commentEnd,
+    });
+}
+
+function loadJsonData(dataPath) {
+    if (!dataPath) return {};
+    
+    if (!existsSync(dataPath)) {
+        console.error(color("✗ 数据文件未找到:", "red"), color(dataPath, "blue"));
+        process.exit(1);
+    }
+    
+    try {
+        const content = readFileSync(dataPath, "utf-8");
+        return JSON.parse(content);
+    } catch (error) {
+        console.error(color("✗ 解析 JSON 数据失败:", "red"), error.message);
+        process.exit(1);
+    }
+}
+
+function renderCommand(options) {
+    if (!options.template) {
+        console.error(color("✗ 缺少模板文件路径", "red"));
+        console.log(color("  用法: dejavu render <template> [-d data.json] [-o output]", "gray"));
+        process.exit(1);
+    }
+
+    const templatePath = resolve(options.template);
+    
+    if (!existsSync(templatePath)) {
+        console.error(color("✗ 模板文件未找到:", "red"), color(templatePath, "blue"));
+        process.exit(1);
+    }
+
+    console.log(color("渲染模板:", "cyan"), color(relative(process.cwd(), templatePath), "blue"));
+
+    try {
+        const templateContent = readFileSync(templatePath, options.encoding);
+        const language = createLanguage(options);
+        const data = loadJsonData(options.data);
+
+        const engine = new DejavuEngine();
+        const templateName = basename(templatePath);
+        engine.registerTemplate(templateName, templateContent, language);
+        
+        const result = engine.renderTemplate(templateName, data);
+
+        if (options.output) {
+            const outputPath = resolve(options.output);
+            writeFileSync(outputPath, result, options.encoding);
+            console.log(color("✓ 输出已写入:", "green"), color(relative(process.cwd(), outputPath), "blue"));
+        } else {
+            console.log();
+            console.log(color("─".repeat(40), "gray"));
+            console.log(result);
+            console.log(color("─".repeat(40), "gray"));
+        }
+
+        console.log(color("✓ 渲染完成", "green"));
+
+    } catch (error) {
+        console.error(color("✗ 渲染失败:", "red"), error.message);
+        if (error.stack) {
+            console.error(color("  堆栈:", "gray"), error.stack.split("\n").slice(1, 3).join("\n  "));
+        }
+        process.exit(1);
+    }
+}
+
+function checkCommand(options) {
+    if (!options.template) {
+        console.error(color("✗ 缺少模板文件路径", "red"));
+        console.log(color("  用法: dejavu check <template>", "gray"));
+        process.exit(1);
+    }
+
+    const templatePath = resolve(options.template);
+    
+    if (!existsSync(templatePath)) {
+        console.error(color("✗ 模板文件未找到:", "red"), color(templatePath, "blue"));
+        process.exit(1);
+    }
+
+    console.log(color("检查模板:", "cyan"), color(relative(process.cwd(), templatePath), "blue"));
+
+    try {
+        const templateContent = readFileSync(templatePath, options.encoding);
+        const language = createLanguage(options);
+
+        const ast = parse(templateContent, language);
+        
+        let statementCount = 0;
+        let expressionCount = 0;
+        let textCount = 0;
+
+        for (const node of ast.body) {
+            if (node.type === "Statement") statementCount++;
+            else if (node.type === "Expression") expressionCount++;
+            else if (node.type === "Text") textCount++;
+        }
+
+        console.log();
+        console.log(color("✓ 语法检查通过", "green"));
+        console.log();
+        console.log(color("  文本节点: ", "white") + color(textCount, "blue"));
+        console.log(color("  表达式:   ", "white") + color(expressionCount, "blue"));
+        console.log(color("  语句:     ", "white") + color(statementCount, "blue"));
+
+    } catch (error) {
+        console.error(color("✗ 语法错误:", "red"), error.message);
+        process.exit(1);
+    }
+}
+
+function buildCommand(options) {
+    const inputDir = options.template;
+    const outputDir = options.output || options.extraArgs[0] || "./dist";
+
+    if (!inputDir) {
+        console.error(color("✗ 缺少输入目录路径", "red"));
+        console.log(color("  用法: dejavu build <input-dir> [output-dir]", "gray"));
+        process.exit(1);
+    }
+
+    const inputPath = resolve(inputDir);
+    const outputPath = resolve(outputDir);
+
+    if (!existsSync(inputPath)) {
+        console.error(color("✗ 输入目录未找到:", "red"), color(inputPath, "blue"));
+        process.exit(1);
+    }
+
+    console.log(color("输入目录:", "cyan"), color(relative(process.cwd(), inputPath), "blue"));
+    console.log(color("输出目录:", "cyan"), color(relative(process.cwd(), outputPath), "blue"));
+    console.log();
+
+    try {
+        if (!existsSync(outputPath)) {
+            mkdirSync(outputPath, { recursive: true });
+        }
+
+        const engine = new DejavuEngine();
+        const language = createLanguage(options);
+        let processedCount = 0;
+        let errorCount = 0;
+
+        function processDirectory(dir, outDir) {
+            const entries = readdirSync(dir);
+            
+            for (const entry of entries) {
+                const fullPath = join(dir, entry);
+                const stat = statSync(fullPath);
+                
+                if (stat.isDirectory()) {
+                    const newOutDir = join(outDir, entry);
+                    if (!existsSync(newOutDir)) {
+                        mkdirSync(newOutDir, { recursive: true });
+                    }
+                    processDirectory(fullPath, newOutDir);
+                } else {
+                    const ext = extname(entry);
+                    if (ext === ".html" || ext === ".htm" || ext === ".dejavu" || ext === ".doki") {
+                        try {
+                            const content = readFileSync(fullPath, options.encoding);
+                            const templateName = relative(inputPath, fullPath);
+                            
+                            engine.registerTemplate(templateName, content, language);
+                            const result = engine.renderTemplate(templateName, {});
+                            
+                            const outFileName = entry.replace(/\.(dejavu|doki)$/, ".html");
+                            const outFilePath = join(outDir, outFileName);
+                            
+                            writeFileSync(outFilePath, result, options.encoding);
+                            
+                            console.log(color("  ✓ ", "green") + color(relative(process.cwd(), fullPath), "gray"));
+                            processedCount++;
+                        } catch (error) {
+                            console.log(color("  ✗ ", "red") + color(relative(process.cwd(), fullPath), "gray") + color(` - ${error.message}`, "red"));
+                            errorCount++;
+                        }
+                    }
+                }
+            }
+        }
+
+        processDirectory(inputPath, outputPath);
+
+        console.log();
+        console.log(color("✓ 构建完成", "green"));
+        console.log(color("  处理文件: ", "white") + color(processedCount, "blue"));
+        if (errorCount > 0) {
+            console.log(color("  失败文件: ", "white") + color(errorCount, "red"));
+        }
+
+    } catch (error) {
+        console.error(color("✗ 构建失败:", "red"), error.message);
+        process.exit(1);
+    }
+}
+
+function main() {
+    const args = process.argv.slice(2);
+
+    if (args.length === 0) {
+        printBanner();
+        printHelp();
+        process.exit(0);
+    }
+
+    const options = parseArgs(args);
+
+    switch (options.command) {
+        case "help":
+        case "--help":
+        case "-h":
+            printBanner();
+            printHelp();
+            break;
+
+        case "version":
+        case "--version":
+        case "-v":
+            printVersion();
+            break;
+
+        case "render":
+            printBanner();
+            renderCommand(options);
+            break;
+
+        case "check":
+            printBanner();
+            checkCommand(options);
+            break;
+
+        case "build":
+            printBanner();
+            buildCommand(options);
+            break;
+
+        default:
+            console.error(color("✗ 未知命令:", "red"), options.command || "");
+            console.log();
+            printHelp();
+            process.exit(1);
+    }
+}
+
+main();