mcp-ai-agent-guidelines/dist/tools/mermaid/validator.js

A comprehensive Model Context Protocol server providing advanced tools, resources, and prompts for implementing AI agent best practices

/**
 * Validator for Mermaid diagram syntax.
 * Optional runtime validation using mermaid.parse (if installed).
 */
let cachedMermaidParse = null;
let mermaidLoadPromise = null;
let mermaidLoadError = null;
let customMermaidModuleProvider = null;
/**
 * Reset the mermaid loader state.
 * Used for testing purposes.
 */
function resetMermaidLoaderState() {
    cachedMermaidParse = null;
    mermaidLoadPromise = null;
    mermaidLoadError = null;
}
/**
 * Set a custom mermaid module provider for testing.
 *
 * **Exported for tests only** - Use via `import { __setMermaidModuleProvider } from '@/tools/test-utils/mermaid'`
 * This function is re-exported from test-utils for convenience. Direct import is discouraged.
 *
 * @param provider - Custom module provider function
 * @internal
 */
export function __setMermaidModuleProvider(provider) {
    customMermaidModuleProvider = provider;
    resetMermaidLoaderState();
}
/**
 * Import the mermaid module.
 * @returns Mermaid module or custom provider result
 */
function importMermaidModule() {
    if (customMermaidModuleProvider) {
        return Promise.resolve(customMermaidModuleProvider());
    }
    return import("mermaid");
}
/**
 * Extract the parse function from mermaid module.
 * @param mod - Mermaid module object
 * @returns Parse function or null
 */
function extractMermaidParse(mod) {
    if (!mod)
        return null;
    // Direct function
    if (typeof mod === "function") {
        return mod;
    }
    // Module with parse method
    if (typeof mod.parse === "function") {
        const parse = mod.parse;
        return parse.bind(mod);
    }
    // Check default export
    const defaultExport = mod.default;
    if (typeof defaultExport === "function") {
        return defaultExport;
    }
    // Default export with parse method
    if (defaultExport &&
        typeof defaultExport.parse === "function") {
        const parse = defaultExport.parse;
        return parse.bind(defaultExport);
    }
    return null;
}
/**
 * Load and cache the mermaid parse function.
 * @returns Mermaid parse function
 * @throws Error if mermaid cannot be loaded
 */
async function loadMermaidParse() {
    if (cachedMermaidParse)
        return cachedMermaidParse;
    if (mermaidLoadError)
        throw mermaidLoadError;
    if (!mermaidLoadPromise) {
        mermaidLoadPromise = importMermaidModule()
            .then((mod) => {
            const parse = extractMermaidParse(mod);
            if (!parse) {
                throw new Error("Mermaid parse function unavailable");
            }
            cachedMermaidParse = parse;
            return parse;
        })
            .catch((error) => {
            const err = error instanceof Error ? error : new Error(String(error));
            mermaidLoadError = err;
            mermaidLoadPromise = null;
            throw err;
        });
    }
    return mermaidLoadPromise;
}
/**
 * Validate Mermaid diagram syntax.
 * @param code - Mermaid diagram code
 * @returns Validation result
 */
export async function validateDiagram(code) {
    try {
        const parse = await loadMermaidParse();
        // Some versions expose parse async; wrap in Promise.resolve
        await Promise.resolve(parse(code));
        return { valid: true };
    }
    catch (err) {
        const msg = err.message || String(err);
        // If mermaid is not installed/available, or requires DOM environment,
        // skip validation but allow diagram output
        if (/Cannot find module 'mermaid'|Cannot use import statement|module not found|DOMPurify|document is not defined|window is not defined|Mermaid parse function unavailable/i.test(msg)) {
            return { valid: true, skipped: true };
        }
        return { valid: false, error: msg };
    }
}
//# sourceMappingURL=validator.js.map