md2xhs 1.0.0

package/dist/assets-loader.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 资源加载器 - 从本地读取 CDN 资源
+ */
+export declare class AssetLoader {
+    private static assetsDir;
+    private static cache;
+    /**
+     * 读取本地资源文件
+     */
+    static loadAsset(filename: string): string;
+    /**
+     * 获取 KaTeX CSS
+     */
+    static getKatexCss(): string;
+    /**
+     * 获取 KaTeX JS
+     */
+    static getKatexJs(): string;
+    /**
+     * 获取 KaTeX Auto-render JS
+     */
+    static getKatexAutoRender(): string;
+    /**
+     * 获取 Mermaid JS
+     */
+    static getMermaidJs(): string;
+}

package/dist/assets-loader.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetLoader = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * 资源加载器 - 从本地读取 CDN 资源
+ */
+class AssetLoader {
+    /**
+     * 读取本地资源文件
+     */
+    static loadAsset(filename) {
+        if (this.cache.has(filename)) {
+            return this.cache.get(filename);
+        }
+        try {
+            const filePath = (0, path_1.join)(this.assetsDir, filename);
+            const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+            this.cache.set(filename, content);
+            return content;
+        }
+        catch (error) {
+            console.warn(`无法加载本地资源 ${filename}, 将使用 CDN`);
+            return '';
+        }
+    }
+    /**
+     * 获取 KaTeX CSS
+     */
+    static getKatexCss() {
+        return this.loadAsset('katex.min.css');
+    }
+    /**
+     * 获取 KaTeX JS
+     */
+    static getKatexJs() {
+        return this.loadAsset('katex.min.js');
+    }
+    /**
+     * 获取 KaTeX Auto-render JS
+     */
+    static getKatexAutoRender() {
+        return this.loadAsset('auto-render.min.js');
+    }
+    /**
+     * 获取 Mermaid JS
+     */
+    static getMermaidJs() {
+        return this.loadAsset('mermaid.min.js');
+    }
+}
+exports.AssetLoader = AssetLoader;
+AssetLoader.assetsDir = (0, path_1.join)(__dirname, 'assets');
+AssetLoader.cache = new Map();

package/dist/converter.d.ts

@@ -0,0 +1,87 @@
+import { Md2ImageOptions, ConvertResult } from './types';
+/**
+ * Markdown 转图片转换器
+ */
+export declare class Md2ImageConverter {
+    private browser;
+    private options;
+    constructor(options?: Md2ImageOptions);
+    /**
+     * 初始化浏览器
+     */
+    private initBrowser;
+    /**
+     * 关闭浏览器
+     */
+    close(): Promise<void>;
+    /**
+     * 获取背景样式
+     */
+    private getBackgroundStyle;
+    /**
+     * 计算目标高度(根据模式)
+     */
+    private calculateHeight;
+    /**
+     * 预处理 Markdown (支持卡片语法)
+     */
+    private preprocessMarkdown;
+    /**
+     * 生成扩展功能的脚本
+     */
+    private generateExtensionScripts;
+    /**
+     * 生成卡片样式
+     */
+    private generateCardStyles;
+    /**
+     * 生成完整的 HTML
+     */
+    private generateHTML;
+    /**
+     * 转换 Markdown 为图片
+     */
+    convert(markdown: string, outputPath?: string): Promise<ConvertResult>;
+    /**
+     * 批量转换
+     */
+    convertBatch(items: Array<{
+        markdown: string;
+        outputPath: string;
+    }>): Promise<ConvertResult[]>;
+    /**
+     * 从文件转换
+     * @param filePath Markdown 文件路径
+     * @param outputPath 可选,输出路径(不提供则生成同名 .png 文件)
+     */
+    convertFromFile(filePath: string, outputPath?: string): Promise<ConvertResult>;
+    /**
+     * 从目录批量转换
+     * @param dirPath 目录路径
+     * @param outputDir 可选,输出目录(不提供则输出到原文件所在目录)
+     * @param recursive 是否递归处理子目录,默认 false
+     */
+    convertFromDirectory(dirPath: string, outputDir?: string, recursive?: boolean): Promise<ConvertResult[]>;
+    /**
+     * 更新配置
+     */
+    updateOptions(options: Partial<Md2ImageOptions>): void;
+    /**
+     * 获取当前配置
+     */
+    getOptions(): Required<Md2ImageOptions>;
+}
+/**
+ * 便捷函数:快速转换
+ * 支持 Markdown 字符串或文件路径
+ * @param input Markdown 字符串或文件路径
+ * @param options 转换选项
+ */
+export declare function md2image(input: string, options?: Md2ImageOptions): Promise<ConvertResult>;
+/**
+ * 便捷函数:批量转换目录
+ * @param dirPath 目录路径
+ * @param options 转换选项
+ * @param recursive 是否递归处理子目录
+ */
+export declare function md2imageDir(dirPath: string, options?: Md2ImageOptions, recursive?: boolean): Promise<ConvertResult[]>;

package/dist/converter.js

@@ -0,0 +1,421 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Md2ImageConverter = void 0;
+exports.md2image = md2image;
+exports.md2imageDir = md2imageDir;
+const marked_1 = require("marked");
+const puppeteer_1 = __importDefault(require("puppeteer"));
+const path_1 = require("path");
+const types_1 = require("./types");
+const styles_1 = require("./styles");
+const assets_loader_1 = require("./assets-loader");
+const file_utils_1 = require("./file-utils");
+/**
+ * Markdown 转图片转换器
+ */
+class Md2ImageConverter {
+    constructor(options = {}) {
+        this.browser = null;
+        // 设置默认选项
+        this.options = {
+            mode: options.mode || types_1.ExportMode.XHS,
+            width: options.width || 640,
+            padding: options.padding || 40,
+            fontSize: options.fontSize || 18,
+            backgroundPreset: options.backgroundPreset || 'purple',
+            customBackground: options.customBackground,
+            scale: options.scale || 3,
+            outputPath: options.outputPath || (0, path_1.join)(process.cwd(), 'output.png'),
+            extensions: {
+                enableMath: options.extensions?.enableMath !== false,
+                enableDiagram: options.extensions?.enableDiagram !== false,
+                enableCard: options.extensions?.enableCard !== false,
+            },
+        };
+        // 配置 marked
+        marked_1.marked.setOptions({
+            breaks: true,
+            gfm: true,
+        });
+    }
+    /**
+     * 初始化浏览器
+     */
+    async initBrowser() {
+        if (!this.browser) {
+            this.browser = await puppeteer_1.default.launch({
+                headless: true,
+                args: ['--no-sandbox', '--disable-setuid-sandbox'],
+            });
+        }
+    }
+    /**
+     * 关闭浏览器
+     */
+    async close() {
+        if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+        }
+    }
+    /**
+     * 获取背景样式
+     */
+    getBackgroundStyle() {
+        if (this.options.customBackground) {
+            return (0, styles_1.generateCustomBackground)(this.options.customBackground);
+        }
+        return styles_1.BACKGROUND_PRESETS[this.options.backgroundPreset];
+    }
+    /**
+     * 计算目标高度(根据模式)
+     */
+    calculateHeight(mode, width) {
+        switch (mode) {
+            case types_1.ExportMode.XHS:
+            case 'xhs':
+                // 小红书 3:4 比例
+                return Math.round((width / 3) * 4);
+            case types_1.ExportMode.PYQ:
+            case 'pyq':
+                // 朋友圈 1290:2796 比例
+                return Math.round(width * (2796 / 1290));
+            case types_1.ExportMode.FREE:
+            case 'free':
+            default:
+                return null; // 自适应高度
+        }
+    }
+    /**
+     * 预处理 Markdown (支持卡片语法)
+     */
+    preprocessMarkdown(markdown) {
+        let processed = markdown;
+        // 处理卡片语法 :::card
+        if (this.options.extensions.enableCard) {
+            processed = processed.replace(/:::card(?:\s+(info|success|warning|error))?\s*\n([\s\S]*?)\n:::/g, (_match, type, content) => {
+                const cardClass = type ? `card-${type}` : '';
+                return `<div class="madopic-card ${cardClass}">\n<div class="card-content">\n\n${content}\n\n</div>\n</div>`;
+            });
+        }
+        return processed;
+    }
+    /**
+     * 生成扩展功能的脚本
+     */
+    generateExtensionScripts() {
+        const scripts = [];
+        // KaTeX 数学公式支持
+        if (this.options.extensions.enableMath) {
+            scripts.push(`
+        <script>
+          // 等待 KaTeX 加载完成后渲染数学公式
+          window.addEventListener('load', function() {
+            if (typeof renderMathInElement !== 'undefined') {
+              renderMathInElement(document.body, {
+                delimiters: [
+                  {left: '$$', right: '$$', display: true},
+                  {left: '$', right: '$', display: false},
+                  {left: '\\\\[', right: '\\\\]', display: true},
+                  {left: '\\\\(', right: '\\\\)', display: false}
+                ],
+                throwOnError: false
+              });
+            }
+          });
+        </script>
+      `);
+        }
+        // Mermaid 图表支持
+        if (this.options.extensions.enableDiagram) {
+            scripts.push(`
+        <script>
+          // 初始化 Mermaid
+          if (typeof mermaid !== 'undefined') {
+            mermaid.initialize({
+              startOnLoad: true,
+              theme: 'default',
+              themeVariables: {
+                primaryColor: '#6366f1',
+                primaryTextColor: '#1f2937',
+                primaryBorderColor: '#4f46e5',
+                lineColor: '#6b7280',
+                secondaryColor: '#f3f4f6',
+                tertiaryColor: '#ffffff'
+              }
+            });
+          }
+        </script>
+      `);
+        }
+        return scripts.join('\n');
+    }
+    /**
+     * 生成卡片样式
+     */
+    generateCardStyles() {
+        if (!this.options.extensions.enableCard) {
+            return '';
+        }
+        return `
+      .madopic-card {
+        margin: 20px 0;
+        padding: 20px 24px;
+        background: linear-gradient(135deg, rgba(99, 102, 241, 0.12) 0%, rgba(139, 92, 246, 0.12) 100%);
+        border: 1px solid rgba(99, 102, 241, 0.2);
+        border-radius: 10px;
+        box-shadow: 0 4px 20px rgba(99, 102, 241, 0.1);
+        transition: all 0.3s ease;
+      }
+
+      .madopic-card .card-content {
+        color: var(--text-light);
+        line-height: 1.7;
+      }
+
+      .madopic-card.card-info {
+        background: linear-gradient(135deg, rgba(59, 130, 246, 0.12) 0%, rgba(29, 78, 216, 0.12) 100%);
+        border-color: rgba(59, 130, 246, 0.2);
+      }
+
+      .madopic-card.card-success {
+        background: linear-gradient(135deg, rgba(16, 185, 129, 0.12) 0%, rgba(5, 150, 105, 0.12) 100%);
+        border-color: rgba(16, 185, 129, 0.2);
+      }
+
+      .madopic-card.card-warning {
+        background: linear-gradient(135deg, rgba(245, 158, 11, 0.12) 0%, rgba(217, 119, 6, 0.12) 100%);
+        border-color: rgba(245, 158, 11, 0.2);
+      }
+
+      .madopic-card.card-error {
+        background: linear-gradient(135deg, rgba(239, 68, 68, 0.12) 0%, rgba(220, 38, 38, 0.12) 100%);
+        border-color: rgba(239, 68, 68, 0.2);
+      }
+    `;
+    }
+    /**
+     * 生成完整的 HTML
+     */
+    generateHTML(markdownContent) {
+        // 预处理 Markdown
+        const preprocessed = this.preprocessMarkdown(markdownContent);
+        const htmlContent = marked_1.marked.parse(preprocessed);
+        const backgroundStyle = this.getBackgroundStyle();
+        const fontSizeVars = (0, styles_1.generateFontSizeVars)(this.options.fontSize);
+        const targetHeight = this.calculateHeight(this.options.mode, this.options.width);
+        const posterHeightStyle = targetHeight
+            ? `height: ${targetHeight}px; min-height: ${targetHeight}px; overflow: hidden;`
+            : 'min-height: 600px;';
+        const contentMaxHeightStyle = targetHeight
+            ? `max-height: ${targetHeight - this.options.padding * 2}px; overflow: hidden;`
+            : '';
+        // 生成内联资源
+        const inlineAssets = [];
+        const inlineScripts = [];
+        if (this.options.extensions.enableMath) {
+            // 内联 KaTeX CSS
+            const katexCss = assets_loader_1.AssetLoader.getKatexCss();
+            if (katexCss) {
+                inlineAssets.push(`<style>${katexCss}</style>`);
+            }
+            // 内联 KaTeX JS
+            const katexJs = assets_loader_1.AssetLoader.getKatexJs();
+            const autoRenderJs = assets_loader_1.AssetLoader.getKatexAutoRender();
+            if (katexJs && autoRenderJs) {
+                inlineScripts.push(`<script>${katexJs}</script>`);
+                inlineScripts.push(`<script>${autoRenderJs}</script>`);
+            }
+        }
+        if (this.options.extensions.enableDiagram) {
+            // 内联 Mermaid JS
+            const mermaidJs = assets_loader_1.AssetLoader.getMermaidJs();
+            if (mermaidJs) {
+                inlineScripts.push(`<script>${mermaidJs}</script>`);
+            }
+        }
+        return `
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Markdown to Image</title>
+  ${inlineAssets.join('\n  ')}
+  ${inlineScripts.join('\n  ')}
+  <style>
+    ${styles_1.FULL_STYLES}
+    ${this.generateCardStyles()}
+  </style>
+</head>
+<body>
+  <div class="markdown-poster" style="
+    background: ${backgroundStyle};
+    width: ${this.options.width}px;
+    padding: ${this.options.padding}px;
+    ${posterHeightStyle}
+  ">
+    <div class="poster-content" style="
+      ${fontSizeVars}
+      ${contentMaxHeightStyle}
+    ">
+      ${htmlContent}
+    </div>
+  </div>
+  ${this.generateExtensionScripts()}
+</body>
+</html>
+    `.trim();
+    }
+    /**
+     * 转换 Markdown 为图片
+     */
+    async convert(markdown, outputPath) {
+        await this.initBrowser();
+        if (!this.browser) {
+            throw new Error('浏览器初始化失败');
+        }
+        const page = await this.browser.newPage();
+        try {
+            // 生成 HTML 内容
+            const htmlContent = this.generateHTML(markdown);
+            // 设置页面内容
+            await page.setContent(htmlContent, {
+                waitUntil: 'networkidle0',
+            });
+            // 等待渲染完成
+            await page.waitForSelector('.markdown-poster', { timeout: 5000 });
+            // 如果启用了扩展功能,等待额外时间确保渲染完成
+            if (this.options.extensions.enableMath || this.options.extensions.enableDiagram) {
+                // 等待 1.5 秒确保 KaTeX 和 Mermaid 渲染完成
+                await new Promise(resolve => setTimeout(resolve, 1500));
+            }
+            // 获取元素尺寸
+            const element = await page.$('.markdown-poster');
+            if (!element) {
+                throw new Error('无法找到 .markdown-poster 元素');
+            }
+            const boundingBox = await element.boundingBox();
+            if (!boundingBox) {
+                throw new Error('无法获取元素边界框');
+            }
+            // 截图
+            const finalOutputPath = outputPath || this.options.outputPath;
+            // 设置设备像素比以提高清晰度
+            await page.setViewport({
+                width: this.options.width,
+                height: boundingBox.height,
+                deviceScaleFactor: this.options.scale,
+            });
+            await element.screenshot({
+                path: finalOutputPath,
+                type: 'png',
+                omitBackground: false,
+            });
+            return {
+                imagePath: finalOutputPath,
+                width: Math.round(boundingBox.width),
+                height: Math.round(boundingBox.height),
+            };
+        }
+        finally {
+            await page.close();
+        }
+    }
+    /**
+     * 批量转换
+     */
+    async convertBatch(items) {
+        await this.initBrowser();
+        const results = [];
+        for (const item of items) {
+            const result = await this.convert(item.markdown, item.outputPath);
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * 从文件转换
+     * @param filePath Markdown 文件路径
+     * @param outputPath 可选,输出路径(不提供则生成同名 .png 文件)
+     */
+    async convertFromFile(filePath, outputPath) {
+        const markdown = await (0, file_utils_1.readMarkdownFile)(filePath);
+        const finalOutputPath = outputPath || (0, file_utils_1.generateOutputPath)(filePath);
+        return this.convert(markdown, finalOutputPath);
+    }
+    /**
+     * 从目录批量转换
+     * @param dirPath 目录路径
+     * @param outputDir 可选,输出目录(不提供则输出到原文件所在目录)
+     * @param recursive 是否递归处理子目录,默认 false
+     */
+    async convertFromDirectory(dirPath, outputDir, recursive = false) {
+        const markdownFiles = await (0, file_utils_1.getMarkdownFiles)(dirPath, recursive);
+        const results = [];
+        for (const filePath of markdownFiles) {
+            const outputPath = (0, file_utils_1.generateOutputPath)(filePath, outputDir);
+            const result = await this.convertFromFile(filePath, outputPath);
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * 更新配置
+     */
+    updateOptions(options) {
+        this.options = {
+            ...this.options,
+            ...options,
+        };
+    }
+    /**
+     * 获取当前配置
+     */
+    getOptions() {
+        return { ...this.options };
+    }
+}
+exports.Md2ImageConverter = Md2ImageConverter;
+/**
+ * 便捷函数:快速转换
+ * 支持 Markdown 字符串或文件路径
+ * @param input Markdown 字符串或文件路径
+ * @param options 转换选项
+ */
+async function md2image(input, options) {
+    const converter = new Md2ImageConverter(options);
+    try {
+        // 检测输入是文件路径还是 Markdown 内容
+        const isFilePath = await (0, file_utils_1.isFile)(input);
+        if (isFilePath) {
+            // 如果是文件路径
+            return await converter.convertFromFile(input, options?.outputPath);
+        }
+        else {
+            // 否则当作 Markdown 内容
+            return await converter.convert(input);
+        }
+    }
+    finally {
+        await converter.close();
+    }
+}
+/**
+ * 便捷函数:批量转换目录
+ * @param dirPath 目录路径
+ * @param options 转换选项
+ * @param recursive 是否递归处理子目录
+ */
+async function md2imageDir(dirPath, options, recursive = false) {
+    const converter = new Md2ImageConverter(options);
+    try {
+        return await converter.convertFromDirectory(dirPath, options?.outputPath, recursive);
+    }
+    finally {
+        await converter.close();
+    }
+}

package/dist/extensions.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 扩展功能配置
+ */
+export interface ExtensionOptions {
+    /**
+     * 是否启用数学公式支持 (KaTeX)
+     * @default false
+     */
+    enableMath?: boolean;
+    /**
+     * 是否启用图表支持 (Mermaid)
+     * @default false
+     */
+    enableDiagram?: boolean;
+    /**
+     * 是否启用卡片语法
+     * @default true
+     */
+    enableCard?: boolean;
+}

package/dist/extensions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/file-utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 判断路径是否为文件
+ */
+export declare function isFile(path: string): Promise<boolean>;
+/**
+ * 判断路径是否为目录
+ */
+export declare function isDirectory(path: string): Promise<boolean>;
+/**
+ * 读取 Markdown 文件内容
+ */
+export declare function readMarkdownFile(filePath: string): Promise<string>;
+/**
+ * 获取目录中所有的 Markdown 文件
+ */
+export declare function getMarkdownFiles(dirPath: string, recursive?: boolean): Promise<string[]>;
+/**
+ * 生成输出文件路径
+ * 例如: './docs/README.md' -> './docs/README.png'
+ */
+export declare function generateOutputPath(inputPath: string, outputDir?: string): string;