@umengfe/mcp-server-chart 0.0.1

package/build/services/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startHTTPStreamableServer = exports.startSSEMcpServer = exports.startStdioMcpServer = void 0;
+var stdio_1 = require("./stdio.js");
+Object.defineProperty(exports, "startStdioMcpServer", { enumerable: true, get: function () { return stdio_1.startStdioMcpServer; } });
+var sse_1 = require("./sse.js");
+Object.defineProperty(exports, "startSSEMcpServer", { enumerable: true, get: function () { return sse_1.startSSEMcpServer; } });
+var streamable_1 = require("./streamable.js");
+Object.defineProperty(exports, "startHTTPStreamableServer", { enumerable: true, get: function () { return streamable_1.startHTTPStreamableServer; } });

package/build/services/sse.d.ts

@@ -0,0 +1,2 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare const startSSEMcpServer: (server: Server, endpoint?: string, port?: number, host?: string) => Promise<void>;

package/build/services/sse.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startSSEMcpServer = void 0;
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const express_1 = __importDefault(require("express"));
+const logger_1 = require("../utils/logger.js");
+const startSSEMcpServer = (server_1, ...args_1) => __awaiter(void 0, [server_1, ...args_1], void 0, function* (server, endpoint = "/sse", port = 1122, host = "localhost") {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    const transports = {};
+    app.get(endpoint, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const transport = new sse_js_1.SSEServerTransport("/messages", res);
+        transports[transport.sessionId] = transport;
+        transport.onclose = () => {
+            delete transports[transport.sessionId];
+            logger_1.logger.info(`SSE Server disconnected: sessionId=${transport.sessionId}`);
+        };
+        yield server.connect(transport);
+        logger_1.logger.info(`SSE Server connected: sessionId=${transport.sessionId}`);
+    }));
+    app.post("/messages", (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const sessionId = req.query.sessionId;
+        if (!sessionId) {
+            logger_1.logger.warn("SSE Server sessionId parameter is missing");
+            return res.status(400).send("Missing sessionId parameter");
+        }
+        const transport = transports[sessionId];
+        if (!transport) {
+            logger_1.logger.warn(`SSE Server session not found: sessionId=${sessionId}`);
+            return res.status(404).send("Session not found");
+        }
+        try {
+            logger_1.logger.info(`SSE Server handling message: sessionId=${sessionId}`);
+            yield transport.handlePostMessage(req, res, req.body);
+        }
+        catch (e) {
+            logger_1.logger.error("SSE Server error handling message", e);
+            if (!res.headersSent)
+                res.status(500).send("Error handling request");
+        }
+    }));
+    app.listen(port, host, () => {
+        logger_1.logger.success(`SSE Server listening on http://${host}:${port}${endpoint}`);
+    });
+});
+exports.startSSEMcpServer = startSSEMcpServer;

package/build/services/stdio.d.ts

@@ -0,0 +1,2 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare function startStdioMcpServer(server: Server): Promise<void>;

package/build/services/stdio.js

@@ -0,0 +1,21 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStdioMcpServer = startStdioMcpServer;
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const logger_1 = require("../utils/logger.js");
+function startStdioMcpServer(server) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const transport = new stdio_js_1.StdioServerTransport();
+        yield server.connect(transport);
+        logger_1.logger.success("Stdio MCP Server started");
+    });
+}

package/build/services/streamable.d.ts

@@ -0,0 +1,2 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare const startHTTPStreamableServer: (createServer: () => Server, endpoint?: string, port?: number, host?: string) => Promise<void>;

package/build/services/streamable.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startHTTPStreamableServer = void 0;
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const cors_1 = __importDefault(require("cors"));
+const express_1 = __importDefault(require("express"));
+const logger_1 = require("../utils/logger.js");
+const startHTTPStreamableServer = (createServer_1, ...args_1) => __awaiter(void 0, [createServer_1, ...args_1], void 0, function* (createServer, endpoint = "/mcp", port = 1122, host = "localhost") {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    app.use((0, cors_1.default)({ origin: "*", exposedHeaders: ["Mcp-Session-Id"] }));
+    app.post(endpoint, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        // In stateless mode, create a new transport for each request to prevent
+        // request ID collisions. Different clients may use the same JSON-RPC request IDs,
+        // which would cause responses to be routed to the wrong HTTP connections if
+        // the transport state is shared.
+        try {
+            const server = createServer();
+            const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+                enableJsonResponse: true,
+            });
+            res.on("close", () => {
+                transport.close();
+                logger_1.logger.info("HTTP Streamable Server response closed");
+            });
+            yield server.connect(transport);
+            yield transport.handleRequest(req, res, req.body);
+            logger_1.logger.info("HTTP Streamable Server response connected");
+        }
+        catch (e) {
+            logger_1.logger.error("HTTP Streamable Server response error", e);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: { code: -32603, message: "Internal server error" },
+                    id: null,
+                });
+            }
+        }
+    }));
+    app.listen(port, host, () => {
+        logger_1.logger.success(`Streamable HTTP Server listening on http://${host}:${port}${endpoint}`);
+    });
+});
+exports.startHTTPStreamableServer = startHTTPStreamableServer;

package/build/utils/callTool.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Call a tool to generate a chart based on the provided name and arguments.
+ * @param tool The name of the tool to call, e.g., "generate_area_chart".
+ * @param args The arguments for the tool, which should match the expected schema for the chart type.
+ * @returns
+ */
+export declare function callTool(tool: string, args?: object): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    _meta: {
+        description: string;
+        spec: {
+            type: "area" | "bar" | "boxplot" | "column" | "district-map" | "dual-axes" | "fishbone-diagram" | "flow-diagram" | "funnel" | "histogram" | "line" | "liquid" | "mind-map" | "network-graph" | "organization-chart" | "path-map" | "pie" | "pin-map" | "radar" | "sankey" | "scatter" | "treemap" | "venn" | "violin" | "word-cloud";
+        };
+    };
+}>;

package/build/utils/callTool.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callTool = callTool;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const zod_1 = require("zod");
+const Charts = __importStar(require("../charts/index.js"));
+const logger_1 = require("./logger.js");
+const validator_1 = require("./validator.js");
+// Chart type mapping
+const CHART_TYPE_MAP = {
+    generate_area_chart: "area",
+    generate_bar_chart: "bar",
+    generate_boxplot_chart: "boxplot",
+    generate_column_chart: "column",
+    generate_district_map: "district-map",
+    generate_dual_axes_chart: "dual-axes",
+    generate_fishbone_diagram: "fishbone-diagram",
+    generate_flow_diagram: "flow-diagram",
+    generate_funnel_chart: "funnel",
+    generate_histogram_chart: "histogram",
+    generate_line_chart: "line",
+    generate_liquid_chart: "liquid",
+    generate_mind_map: "mind-map",
+    generate_network_graph: "network-graph",
+    generate_organization_chart: "organization-chart",
+    generate_path_map: "path-map",
+    generate_pie_chart: "pie",
+    generate_pin_map: "pin-map",
+    generate_radar_chart: "radar",
+    generate_sankey_chart: "sankey",
+    generate_scatter_chart: "scatter",
+    generate_treemap_chart: "treemap",
+    generate_venn_chart: "venn",
+    generate_violin_chart: "violin",
+    generate_word_cloud_chart: "word-cloud",
+};
+/**
+ * Call a tool to generate a chart based on the provided name and arguments.
+ * @param tool The name of the tool to call, e.g., "generate_area_chart".
+ * @param args The arguments for the tool, which should match the expected schema for the chart type.
+ * @returns
+ */
+function callTool(tool_1) {
+    return __awaiter(this, arguments, void 0, function* (tool, args = {}) {
+        logger_1.logger.info(`Calling tool: ${tool}`);
+        const chartType = CHART_TYPE_MAP[tool];
+        if (!chartType) {
+            logger_1.logger.error(`Unknown tool: ${tool}`);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${tool}.`);
+        }
+        try {
+            // Validate input using Zod before sending to API.
+            // Select the appropriate schema based on the chart type.
+            const schema = Charts[chartType].schema;
+            if (schema) {
+                // Use safeParse instead of parse and try-catch.
+                const result = zod_1.z.object(schema).safeParse(args);
+                if (!result.success) {
+                    logger_1.logger.error(`Invalid parameters: ${result.error.message}`);
+                    throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Invalid parameters: ${result.error.message}`);
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `\`\`\`vis-chart 
+          ${JSON.stringify(Object.assign({ type: chartType }, args))} 
+        \`\`\``,
+                    },
+                ],
+                _meta: {
+                    description: "This is the chart's spec and configuration, which can be renderred to corresponding chart by AntV GPT-Vis chart components.",
+                    spec: Object.assign({ type: chartType }, args),
+                },
+            };
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to generate chart: ${error.message || "Unknown error"}.`);
+            if (error instanceof types_js_1.McpError)
+                throw error;
+            if (error instanceof validator_1.ValidateError)
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, error.message);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to generate chart: ${(error === null || error === void 0 ? void 0 : error.message) || "Unknown error."}`);
+        }
+    });
+}

package/build/utils/env.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Get the VIS_REQUEST_SERVER from environment variables.
+ */
+export declare function getVisRequestServer(): string;
+/**
+ * Get the `SERVICE_ID` from environment variables.
+ */
+export declare function getServiceIdentifier(): string | undefined;
+/**
+ * Get the list of disabled tools from environment variables.
+ */
+export declare function getDisabledTools(): string[];

package/build/utils/env.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVisRequestServer = getVisRequestServer;
+exports.getServiceIdentifier = getServiceIdentifier;
+exports.getDisabledTools = getDisabledTools;
+const node_process_1 = __importDefault(require("node:process"));
+/**
+ * Get the VIS_REQUEST_SERVER from environment variables.
+ */
+function getVisRequestServer() {
+    return (node_process_1.default.env.VIS_REQUEST_SERVER ||
+        "https://antv-studio.alipay.com/api/gpt-vis");
+}
+/**
+ * Get the `SERVICE_ID` from environment variables.
+ */
+function getServiceIdentifier() {
+    return node_process_1.default.env.SERVICE_ID;
+}
+/**
+ * Get the list of disabled tools from environment variables.
+ */
+function getDisabledTools() {
+    const disabledTools = node_process_1.default.env.DISABLED_TOOLS;
+    if (!disabledTools || disabledTools === "undefined") {
+        return [];
+    }
+    return disabledTools.split(",");
+}

package/build/utils/generate.d.ts

@@ -0,0 +1,25 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Generate a chart URL using the provided configuration.
+ * @param type The type of chart to generate
+ * @param options Chart options
+ * @returns {Promise<string>} The generated chart URL.
+ * @throws {Error} If the chart generation fails.
+ */
+export declare function generateChartUrl(type: string, options: Record<string, any>): Promise<object>;
+type ResponseResult = {
+    metadata: unknown;
+    /**
+     * @docs https://modelcontextprotocol.io/specification/2025-03-26/server/tools#tool-result
+     */
+    content: CallToolResult["content"];
+    isError?: CallToolResult["isError"];
+};
+/**
+ * Generate a map
+ * @param tool - The tool name
+ * @param input - The input
+ * @returns
+ */
+export declare function generateMap(tool: string, input: unknown): Promise<ResponseResult>;
+export {};

package/build/utils/generate.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateChartUrl = generateChartUrl;
+exports.generateMap = generateMap;
+const axios_1 = __importDefault(require("axios"));
+const env_1 = require("./env.js");
+/**
+ * Generate a chart URL using the provided configuration.
+ * @param type The type of chart to generate
+ * @param options Chart options
+ * @returns {Promise<string>} The generated chart URL.
+ * @throws {Error} If the chart generation fails.
+ */
+function generateChartUrl(type, 
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const url = (0, env_1.getVisRequestServer)();
+        const response = yield axios_1.default.post(url, Object.assign(Object.assign({ type }, options), { source: "mcp-server-chart" }), {
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        const { success, errorMessage, resultObj } = response.data;
+        if (!success) {
+            throw new Error(errorMessage);
+        }
+        return resultObj;
+    });
+}
+/**
+ * Generate a map
+ * @param tool - The tool name
+ * @param input - The input
+ * @returns
+ */
+function generateMap(tool, input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const url = (0, env_1.getVisRequestServer)();
+        const response = yield axios_1.default.post(url, {
+            serviceId: (0, env_1.getServiceIdentifier)(),
+            tool,
+            input,
+            source: "mcp-server-chart",
+        }, {
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        const { success, errorMessage, resultObj } = response.data;
+        if (!success) {
+            throw new Error(errorMessage);
+        }
+        return resultObj;
+    });
+}

package/build/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { callTool } from "./callTool";
+export { generateChartUrl } from "./generate";
+export { zodToJsonSchema } from "./schema";

package/build/utils/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodToJsonSchema = exports.generateChartUrl = exports.callTool = void 0;
+var callTool_1 = require("./callTool.js");
+Object.defineProperty(exports, "callTool", { enumerable: true, get: function () { return callTool_1.callTool; } });
+var generate_1 = require("./generate.js");
+Object.defineProperty(exports, "generateChartUrl", { enumerable: true, get: function () { return generate_1.generateChartUrl; } });
+var schema_1 = require("./schema.js");
+Object.defineProperty(exports, "zodToJsonSchema", { enumerable: true, get: function () { return schema_1.zodToJsonSchema; } });

package/build/utils/logger.d.ts

@@ -0,0 +1,28 @@
+declare function setIsStdio(isStdio: boolean): void;
+/**
+ * Log info message
+ */
+declare function info(message: string, ...args: unknown[]): void;
+/**
+ * Log warning message
+ */
+declare function warn(message: string, ...args: unknown[]): void;
+/**
+ * Log error message
+ */
+declare function error(message: string, error?: unknown): void;
+/**
+ * Log success message
+ */
+declare function success(message: string, ...args: unknown[]): void;
+/**
+ * Logger object for backward compatibility
+ */
+export declare const logger: {
+    info: typeof info;
+    warn: typeof warn;
+    error: typeof error;
+    success: typeof success;
+    setIsStdio: typeof setIsStdio;
+};
+export {};

package/build/utils/logger.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+/**
+ * Unified logger for consistent logging across the application
+ */
+const prefix = "[MCP-Server-Chart]";
+/**
+ * Indicates if the logger is in stdio mode.
+ * When true, logs are directed to stderr for info, warn, and success messages, using console.error.
+ * When false, logs are directed to stdout.
+ */
+let IS_STDIO = true;
+function setIsStdio(isStdio) {
+    IS_STDIO = isStdio;
+}
+function getPrefix() {
+    const timestamp = new Date().toISOString();
+    return `${prefix} ${timestamp}`;
+}
+/**
+ * Log info message
+ */
+function info(message, ...args) {
+    const fn = IS_STDIO ? console.error : console.log;
+    fn(`${getPrefix()} ℹ️  ${message}`, ...args);
+}
+/**
+ * Log warning message
+ */
+function warn(message, ...args) {
+    const fn = IS_STDIO ? console.warn : console.log;
+    fn(`${getPrefix()} ⚠️  ${message}`, ...args);
+}
+/**
+ * Log error message
+ */
+function error(message, error) {
+    console.error(`${getPrefix()} ❌ ${message}`, error || "");
+}
+/**
+ * Log success message
+ */
+function success(message, ...args) {
+    const fn = IS_STDIO ? console.error : console.log;
+    fn(`${getPrefix()} ✅ ${message}`, ...args);
+}
+/**
+ * Logger object for backward compatibility
+ */
+exports.logger = {
+    info,
+    warn,
+    error,
+    success,
+    setIsStdio,
+};

package/build/utils/schema.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const zodToJsonSchema: (schema: Record<string, z.ZodType<any>>) => import("zod-to-json-schema").JsonSchema7Type & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+    } | undefined;
+};

package/build/utils/schema.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodToJsonSchema = void 0;
+const zod_1 = require("zod");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+// TODO: use zod v4 JSON to schema to replace zod-to-json-schema when v4 is stable
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+const zodToJsonSchema = (schema) => {
+    return (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object(schema), {
+        rejectedAdditionalProperties: undefined,
+        $refStrategy: "none",
+    });
+};
+exports.zodToJsonSchema = zodToJsonSchema;

package/build/utils/validator.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The Error class for validation errors in zod.
+ */
+export declare class ValidateError extends Error {
+    constructor(message: string);
+}
+export type NodeEdgeDataType = {
+    nodes: Array<{
+        name: string;
+    }>;
+    edges: Array<{
+        name: string;
+        source: string;
+        target: string;
+    }>;
+};
+export type TreeDataType = {
+    name: string;
+    children?: TreeDataType[];
+};
+/**
+ * Valid node name is unique.
+ * Valid edge source and target are existing in nodes.
+ * Valid edge source edge target pair are unique.
+ * @param data
+ * @returns boolean
+ */
+export declare const validatedNodeEdgeDataSchema: (data: NodeEdgeDataType) => boolean;
+/**
+ * Valid TreeData name is unique.
+ * @param data
+ * @returns boolean
+ */
+export declare const validatedTreeDataSchema: (data: TreeDataType) => boolean;