koishi-plugin-drf 0.0.2 → 0.0.4

package/lib/index.d.ts

@@ -1,5 +1,35 @@
-import { Context, Schema } from 'koishi';
+import { Context, Schema, h } from 'koishi';
+declare module 'koishi' {
+    interface Context {
+        canvas: CanvasService;
+    }
+}
+interface CanvasRenderingContext2D<C extends Canvas = Canvas, I extends Image = Image> extends Omit<globalThis.CanvasRenderingContext2D, 'drawImage' | 'canvas'> {
+    canvas: C;
+    drawImage(image: C | I, dx: number, dy: number): void;
+    drawImage(image: C | I, dx: number, dy: number, dw: number, dh: number): void;
+    drawImage(image: C | I, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
+}
+interface Canvas {
+    width: number;
+    height: number;
+    getContext(type: '2d'): CanvasRenderingContext2D;
+    toBuffer(type: 'image/png'): Promise<Buffer>;
+    toDataURL(type: 'image/png'): Promise<string>;
+    dispose(): Promise<void>;
+}
+interface Image {
+    readonly naturalWidth: number;
+    readonly naturalHeight: number;
+    dispose(): Promise<void>;
+}
+declare abstract class CanvasService {
+    abstract createCanvas(width: number, height: number): Promise<Canvas>;
+    abstract loadImage(source: string | URL | Buffer | ArrayBufferLike): Promise<Image>;
+    render(width: number, height: number, callback: (ctx: CanvasRenderingContext2D) => Promise<void>): Promise<h>;
+}
 export declare const name = "function-plotter";
+export declare const using: readonly ["canvas"];
 export interface Config {
     width: number;
     height: number;
@@ -13,3 +43,4 @@ export interface Config {
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;
+export {};

package/lib/index.js

@@ -0,0 +1,144 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name,
+  using: () => using
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var import_mathjs = require("mathjs");
+var name = "function-plotter";
+var using = ["canvas"];
+var Config = import_koishi.Schema.object({
+  width: import_koishi.Schema.number().default(800).description("图像宽度"),
+  height: import_koishi.Schema.number().default(600).description("图像高度"),
+  xMin: import_koishi.Schema.number().default(-10).description("X轴最小值"),
+  xMax: import_koishi.Schema.number().default(10).description("X轴最大值"),
+  step: import_koishi.Schema.number().default(0.1).description("绘图步长"),
+  backgroundColor: import_koishi.Schema.string().default("white").description("背景颜色"),
+  lineColor: import_koishi.Schema.string().default("blue").description("线条颜色"),
+  gridColor: import_koishi.Schema.string().default("#e0e0e0").description("网格颜色"),
+  showGrid: import_koishi.Schema.boolean().default(true).description("显示网格")
+});
+function apply(ctx, config) {
+  if (!ctx.canvas) {
+    ctx.logger.warn("canvas 插件未安装，函数绘图功能将不可用");
+    return;
+  }
+  ctx.command("drf <expression>", "绘制函数图像").alias("函数绘图").example("drf f(x)=x^2").action(async ({ session }, expression) => {
+    if (!expression) {
+      return "请输入函数表达式，例如：drf f(x)=x^2";
+    }
+    try {
+      const compiled = (0, import_mathjs.compile)(expression);
+      const scope = { x: 0 };
+      return await ctx.canvas.render(config.width, config.height, async (ctxCanvas) => {
+        ctxCanvas.fillStyle = config.backgroundColor;
+        ctxCanvas.fillRect(0, 0, config.width, config.height);
+        const xAxis = config.height / 2;
+        const yAxis = config.width / 2;
+        const xScale = config.width / (config.xMax - config.xMin);
+        const yScale = config.height / 20;
+        if (config.showGrid) {
+          ctxCanvas.strokeStyle = config.gridColor;
+          ctxCanvas.lineWidth = 1;
+          for (let x = Math.ceil(config.xMin); x <= config.xMax; x++) {
+            if (x === 0) continue;
+            const xPos = yAxis + x * xScale;
+            ctxCanvas.beginPath();
+            ctxCanvas.moveTo(xPos, 0);
+            ctxCanvas.lineTo(xPos, config.height);
+            ctxCanvas.stroke();
+          }
+          for (let y = -10; y <= 10; y++) {
+            if (y === 0) continue;
+            const yPos = xAxis - y * yScale;
+            ctxCanvas.beginPath();
+            ctxCanvas.moveTo(0, yPos);
+            ctxCanvas.lineTo(config.width, yPos);
+            ctxCanvas.stroke();
+          }
+        }
+        ctxCanvas.strokeStyle = "black";
+        ctxCanvas.lineWidth = 2;
+        ctxCanvas.beginPath();
+        ctxCanvas.moveTo(0, xAxis);
+        ctxCanvas.lineTo(config.width, xAxis);
+        ctxCanvas.stroke();
+        ctxCanvas.beginPath();
+        ctxCanvas.moveTo(yAxis, 0);
+        ctxCanvas.lineTo(yAxis, config.height);
+        ctxCanvas.stroke();
+        ctxCanvas.fillStyle = "black";
+        ctxCanvas.font = "12px Arial";
+        ctxCanvas.fillText("X", config.width - 15, xAxis - 5);
+        ctxCanvas.fillText("Y", yAxis + 5, 15);
+        ctxCanvas.strokeStyle = config.lineColor;
+        ctxCanvas.lineWidth = 3;
+        ctxCanvas.beginPath();
+        let isFirstPoint = true;
+        for (let x = config.xMin; x <= config.xMax; x += config.step) {
+          scope.x = x;
+          let y;
+          try {
+            y = compiled.evaluate(scope);
+            if (typeof y !== "number" || !isFinite(y)) {
+              isFirstPoint = true;
+              continue;
+            }
+            if (y < -100) y = -100;
+            if (y > 100) y = 100;
+            const xPixel = yAxis + x * xScale;
+            const yPixel = xAxis - y * yScale;
+            if (isFirstPoint) {
+              ctxCanvas.moveTo(xPixel, yPixel);
+              isFirstPoint = false;
+            } else {
+              ctxCanvas.lineTo(xPixel, yPixel);
+            }
+          } catch (error) {
+            isFirstPoint = true;
+            continue;
+          }
+        }
+        ctxCanvas.stroke();
+        ctxCanvas.fillStyle = "#333";
+        ctxCanvas.font = "bold 16px Arial";
+        ctxCanvas.textAlign = "center";
+        ctxCanvas.fillText(expression, config.width / 2, 25);
+      });
+    } catch (error) {
+      ctx.logger.error("绘制函数图像时出错:", error);
+      return `绘制函数图像时出错: ${error.message}`;
+    }
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name,
+  using
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-drf",
   "description": "draw math function in your group",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -34,5 +34,9 @@
       "en": "draw math function in your group",
       "zh": "在你的群组中绘制函数图像"
     }
+  },
+  "dependencies": {
+    "canvas": "^3.2.0",
+    "mathjs": "^14.7.0"
   }
 }