@standby/mcp-server-chart 0.9.10

package/build/charts/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports["word-cloud"] = exports.waterfall = exports.violin = exports.venn = exports.treemap = exports.scatter = exports.sankey = exports.radar = exports.pie = exports["organization-chart"] = exports["network-graph"] = exports["mind-map"] = exports.liquid = exports.line = exports.histogram = exports.funnel = exports["flow-diagram"] = exports["fishbone-diagram"] = exports["dual-axes"] = exports.column = exports.boxplot = exports.bar = exports.area = void 0;
+/**
+ * export all charts as named exports to match the chart type
+ */
+var area_1 = require("./area.js");
+Object.defineProperty(exports, "area", { enumerable: true, get: function () { return area_1.area; } });
+var bar_1 = require("./bar.js");
+Object.defineProperty(exports, "bar", { enumerable: true, get: function () { return bar_1.bar; } });
+var boxplot_1 = require("./boxplot.js");
+Object.defineProperty(exports, "boxplot", { enumerable: true, get: function () { return boxplot_1.boxplot; } });
+var column_1 = require("./column.js");
+Object.defineProperty(exports, "column", { enumerable: true, get: function () { return column_1.column; } });
+var dual_axes_1 = require("./dual-axes.js");
+Object.defineProperty(exports, "dual-axes", { enumerable: true, get: function () { return dual_axes_1.dualAxes; } });
+var fishbone_diagram_1 = require("./fishbone-diagram.js");
+Object.defineProperty(exports, "fishbone-diagram", { enumerable: true, get: function () { return fishbone_diagram_1.fishboneDiagram; } });
+var flow_diagram_1 = require("./flow-diagram.js");
+Object.defineProperty(exports, "flow-diagram", { enumerable: true, get: function () { return flow_diagram_1.flowDiagram; } });
+var funnel_1 = require("./funnel.js");
+Object.defineProperty(exports, "funnel", { enumerable: true, get: function () { return funnel_1.funnel; } });
+var histogram_1 = require("./histogram.js");
+Object.defineProperty(exports, "histogram", { enumerable: true, get: function () { return histogram_1.histogram; } });
+var line_1 = require("./line.js");
+Object.defineProperty(exports, "line", { enumerable: true, get: function () { return line_1.line; } });
+var liquid_1 = require("./liquid.js");
+Object.defineProperty(exports, "liquid", { enumerable: true, get: function () { return liquid_1.liquid; } });
+var mind_map_1 = require("./mind-map.js");
+Object.defineProperty(exports, "mind-map", { enumerable: true, get: function () { return mind_map_1.mindMap; } });
+var network_graph_1 = require("./network-graph.js");
+Object.defineProperty(exports, "network-graph", { enumerable: true, get: function () { return network_graph_1.networkGraph; } });
+var organization_chart_1 = require("./organization-chart.js");
+Object.defineProperty(exports, "organization-chart", { enumerable: true, get: function () { return organization_chart_1.organizationChart; } });
+var pie_1 = require("./pie.js");
+Object.defineProperty(exports, "pie", { enumerable: true, get: function () { return pie_1.pie; } });
+var radar_1 = require("./radar.js");
+Object.defineProperty(exports, "radar", { enumerable: true, get: function () { return radar_1.radar; } });
+var sankey_1 = require("./sankey.js");
+Object.defineProperty(exports, "sankey", { enumerable: true, get: function () { return sankey_1.sankey; } });
+var scatter_1 = require("./scatter.js");
+Object.defineProperty(exports, "scatter", { enumerable: true, get: function () { return scatter_1.scatter; } });
+var treemap_1 = require("./treemap.js");
+Object.defineProperty(exports, "treemap", { enumerable: true, get: function () { return treemap_1.treemap; } });
+var venn_1 = require("./venn.js");
+Object.defineProperty(exports, "venn", { enumerable: true, get: function () { return venn_1.venn; } });
+var violin_1 = require("./violin.js");
+Object.defineProperty(exports, "violin", { enumerable: true, get: function () { return violin_1.violin; } });
+var waterfall_1 = require("./waterfall.js");
+Object.defineProperty(exports, "waterfall", { enumerable: true, get: function () { return waterfall_1.waterfall; } });
+var word_cloud_1 = require("./word-cloud.js");
+Object.defineProperty(exports, "word-cloud", { enumerable: true, get: function () { return word_cloud_1.wordCloud; } });

package/build/charts/line.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const line: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            time: z.ZodString;
+            value: z.ZodNumber;
+            group: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+            startAtZero: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            lineWidth: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        axisXTitle: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        axisYTitle: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/line.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.line = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+// Line chart data schema
+const data = zod_1.z.object({
+    time: zod_1.z.string(),
+    value: zod_1.z.number(),
+    group: zod_1.z.string().optional(),
+});
+// Line chart input schema
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for line chart, it should be an array of objects, each object contains a `time` field and a `value` field, such as, [{ time: '2015', value: 23 }, { time: '2016', value: 32 }], when the data is grouped by time, the `group` field should be used to specify the group, such as, [{ time: '2015', value: 23, group: 'A' }, { time: '2015', value: 32, group: 'B' }].")
+        .nonempty({ message: "Line chart data cannot be empty." }),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        texture: base_1.TextureSchema,
+        startAtZero: base_1.StartAtZeroSchema,
+        lineWidth: zod_1.z
+            .number()
+            .optional()
+            .describe("Line width for the lines of chart, such as 4."),
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+    axisXTitle: base_1.AxisXTitleSchema,
+    axisYTitle: base_1.AxisYTitleSchema,
+};
+// Line chart tool descriptor
+const tool = {
+    name: "generate_line_chart",
+    description: "Generate a line chart to show trends over time, such as, the ratio of Apple computer sales to Apple's profits changed from 2000 to 2016.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Line Chart",
+        readOnlyHint: true,
+    },
+};
+exports.line = {
+    schema,
+    tool,
+};

package/build/charts/liquid.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export declare const liquid: {
+    schema: {
+        percent: z.ZodNumber;
+        shape: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            rect: "rect";
+            circle: "circle";
+            pin: "pin";
+            triangle: "triangle";
+        }>>>;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+            color: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/liquid.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.liquid = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+const schema = {
+    percent: zod_1.z
+        .number()
+        .describe("The percentage value to display in the liquid chart, should be a number between 0 and 1, where 1 represents 100%. For example, 0.75 represents 75%.")
+        .min(0, { message: "Value must be at least 0." })
+        .max(1, { message: "Value must be at most 1." }),
+    shape: zod_1.z
+        .enum(["circle", "rect", "pin", "triangle"])
+        .optional()
+        .default("circle")
+        .describe("The shape of the liquid chart, can be 'circle', 'rect', 'pin', or 'triangle'. Default is 'circle'."),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        texture: base_1.TextureSchema,
+        color: zod_1.z
+            .string()
+            .optional()
+            .describe("Custom color for the liquid chart, if not specified, defaults to the theme color."),
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+};
+const tool = {
+    name: "generate_liquid_chart",
+    description: "Generate a liquid chart to visualize a single value as a percentage, such as, the current occupancy rate of a reservoir or the completion percentage of a project.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Liquid Chart",
+        readOnlyHint: true,
+    },
+};
+exports.liquid = {
+    schema,
+    tool,
+};

package/build/charts/mind-map.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const mindMap: {
+    schema: {
+        data: z.ZodType<import("../utils/validator").TreeDataType, unknown, z.core.$ZodTypeInternals<import("../utils/validator").TreeDataType, unknown>>;
+        style: z.ZodOptional<z.ZodObject<{
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/mind-map.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mindMap = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const validator_1 = require("../utils/validator.js");
+const base_1 = require("./base.js");
+const fishbone_diagram_1 = require("./fishbone-diagram.js");
+// Mind map node schema
+// The recursive schema is not supported by gemini, and other clients, so we use a non-recursive schema which can represent a tree structure with a fixed depth.
+// Ref: https://github.com/antvis/mcp-server-chart/issues/155
+// Ref: https://github.com/antvis/mcp-server-chart/issues/132
+const MindMapNodeSchema = fishbone_diagram_1.FishboneNodeSchema;
+// Mind map chart input schema
+const schema = {
+    data: MindMapNodeSchema.describe("Data for mind map chart which is a hierarchical structure, such as, { name: 'main topic', children: [{ name: 'topic 1', children: [{ name:'subtopic 1-1' }] }, and the maximum depth is 3.").refine(validator_1.validatedTreeDataSchema, {
+        message: "Invalid parameters: node name is not unique.",
+        path: ["data"],
+    }),
+    style: zod_1.z
+        .object({
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+};
+// Mind map chart tool descriptor
+const tool = {
+    name: "generate_mind_map",
+    description: "Generate a mind map chart to organizes and presents information in a hierarchical structure with branches radiating from a central topic, such as, a diagram showing the relationship between a main topic and its subtopics.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Mind Map",
+        readOnlyHint: true,
+    },
+};
+exports.mindMap = {
+    schema,
+    tool,
+};

package/build/charts/network-graph.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export declare const networkGraph: {
+    schema: {
+        data: z.ZodObject<{
+            nodes: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strip>>;
+            edges: z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                target: z.ZodString;
+                name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        style: z.ZodOptional<z.ZodObject<{
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/network-graph.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networkGraph = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const validator_1 = require("../utils/validator.js");
+const base_1 = require("./base.js");
+// Network graph input schema
+const schema = {
+    data: zod_1.z
+        .object({
+        nodes: zod_1.z
+            .array(base_1.NodeSchema)
+            .nonempty({ message: "At least one node is required." }),
+        edges: zod_1.z.array(base_1.EdgeSchema),
+    })
+        .describe("Data for network graph chart, such as, { nodes: [{ name: 'node1' }, { name: 'node2' }], edges: [{ source: 'node1', target: 'node2', name: 'edge1' }] }")
+        .refine(validator_1.validatedNodeEdgeDataSchema, {
+        message: "Invalid parameters",
+        path: ["data", "edges"],
+    }),
+    style: zod_1.z
+        .object({
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+};
+// Network graph tool descriptor
+const tool = {
+    name: "generate_network_graph",
+    description: "Generate a network graph chart to show relationships (edges) between entities (nodes), such as, relationships between people in social networks.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Network Graph",
+        readOnlyHint: true,
+    },
+};
+exports.networkGraph = {
+    schema,
+    tool,
+};

package/build/charts/organization-chart.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export declare const organizationChart: {
+    schema: {
+        data: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        orient: z.ZodDefault<z.ZodEnum<{
+            horizontal: "horizontal";
+            vertical: "vertical";
+        }>>;
+        style: z.ZodOptional<z.ZodObject<{
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/organization-chart.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.organizationChart = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+// The recursive schema is not supported by gemini, and other clients, so we use a non-recursive schema which can represent a tree structure with a fixed depth.
+// Ref: https://github.com/antvis/mcp-server-chart/issues/155
+// Ref: https://github.com/antvis/mcp-server-chart/issues/132
+const OrganizationChartNodeSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    children: zod_1.z
+        .array(zod_1.z.object({
+        name: zod_1.z.string(),
+        description: zod_1.z.string().optional(),
+        children: zod_1.z
+            .array(zod_1.z.object({
+            name: zod_1.z.string(),
+            description: zod_1.z.string().optional(),
+            children: zod_1.z
+                .array(zod_1.z.object({
+                name: zod_1.z.string(),
+                description: zod_1.z.string().optional(),
+            }))
+                .optional(),
+        }))
+            .optional(),
+    }))
+        .optional(),
+});
+const schema = {
+    data: OrganizationChartNodeSchema.describe("Data for organization chart which is a hierarchical structure, such as, { name: 'CEO', description: 'Chief Executive Officer', children: [{ name: 'CTO', description: 'Chief Technology Officer', children: [{ name: 'Dev Manager', description: 'Development Manager' }] }] }, and the maximum depth is 3."),
+    orient: zod_1.z
+        .enum(["horizontal", "vertical"])
+        .default("vertical")
+        .describe("Orientation of the organization chart, either horizontal or vertical. Default is vertical, when the level of the chart is more than 3, it is recommended to use horizontal orientation."),
+    style: zod_1.z
+        .object({
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+};
+const tool = {
+    name: "generate_organization_chart",
+    description: "Generate an organization chart to visualize the hierarchical structure of an organization, such as, a diagram showing the relationship between a CEO and their direct reports.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Organization Chart",
+        readOnlyHint: true,
+    },
+};
+exports.organizationChart = {
+    schema,
+    tool,
+};

package/build/charts/pie.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const pie: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            value: z.ZodNumber;
+        }, z.core.$strip>>;
+        innerRadius: z.ZodDefault<z.ZodNumber>;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/pie.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pie = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+// Pie chart data schema
+const data = zod_1.z.object({
+    category: zod_1.z.string(),
+    value: zod_1.z.number(),
+});
+// Pie chart input schema
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for pie chart, it should be an array of objects, each object contains a `category` field and a `value` field, such as, [{ category: '分类一', value: 27 }].")
+        .nonempty({ message: "Pie chart data cannot be empty." }),
+    innerRadius: zod_1.z
+        .number()
+        .default(0)
+        .describe("Set the innerRadius of pie chart, the value between 0 and 1. Set the pie chart as a donut chart. Set the value to 0.6 or number in [0 ,1] to enable it."),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+};
+// Pie chart tool descriptor
+const tool = {
+    name: "generate_pie_chart",
+    description: "Generate a pie chart to show the proportion of parts, such as, market share and budget allocation.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Pie Chart",
+        readOnlyHint: true,
+    },
+};
+exports.pie = {
+    schema,
+    tool,
+};

package/build/charts/radar.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const radar: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodNumber;
+            group: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+            lineWidth: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};