koishi-plugin-img-tool 0.0.1 → 0.0.2

package/lib/index.d.ts

@@ -0,0 +1,15 @@
+import { Context, Schema } from "koishi";
+export declare const name = "img-tool";
+export declare const using: readonly ["canvas"];
+export interface Config {
+}
+export declare const Config: Schema<Config>;
+declare module "koishi" {
+    interface Context {
+        canvas: {
+            createCanvas: (width: number, height: number) => any;
+            loadImage: (data: Buffer) => Promise<any>;
+        };
+    }
+}
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,258 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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_gif_encoder_2 = __toESM(require("gif-encoder-2"));
+var import_gifuct_js = require("gifuct-js");
+var name = "img-tool";
+var using = ["canvas"];
+var Config = import_koishi.Schema.object({});
+function selectFirstImageElement(content) {
+  if (!content) return;
+  const nodes = import_koishi.h.parse(content);
+  return import_koishi.h.select(nodes, "img") ?? import_koishi.h.select(nodes, "image");
+}
+__name(selectFirstImageElement, "selectFirstImageElement");
+function getImageSrc(el) {
+  const src = el?.attrs?.src ?? el?.attrs?.url;
+  return typeof src === "string" && src.length ? src : void 0;
+}
+__name(getImageSrc, "getImageSrc");
+function findImageSrc(session) {
+  const direct = selectFirstImageElement(session.content);
+  const directSrc = getImageSrc(direct);
+  if (directSrc) return directSrc;
+  const quote = session.quote;
+  const quoteContent = quote?.content;
+  const quoteEl = selectFirstImageElement(quoteContent);
+  const quoteSrc = getImageSrc(quoteEl);
+  if (quoteSrc) return quoteSrc;
+  const quoteElements = quote?.elements;
+  if (quoteElements) {
+    const quoteEl2 = import_koishi.h.select(quoteElements, "img") ?? import_koishi.h.select(quoteElements, "image");
+    const quoteSrc2 = getImageSrc(quoteEl2);
+    if (quoteSrc2) return quoteSrc2;
+  }
+}
+__name(findImageSrc, "findImageSrc");
+function isGif(buffer) {
+  if (buffer.length < 6) return false;
+  const head = buffer.subarray(0, 6).toString("ascii");
+  return head === "GIF87a" || head === "GIF89a";
+}
+__name(isGif, "isGif");
+function toArrayBuffer(buffer) {
+  return buffer.buffer.slice(
+    buffer.byteOffset,
+    buffer.byteOffset + buffer.byteLength
+  );
+}
+__name(toArrayBuffer, "toArrayBuffer");
+function mirrorDraw(out, srcCanvas, mode) {
+  const w = srcCanvas.width;
+  const h2 = srcCanvas.height;
+  out.clearRect(0, 0, w, h2);
+  if (mode === "left") {
+    const rightWidth = Math.floor(w / 2);
+    const leftKeepWidth = w - rightWidth;
+    out.drawImage(srcCanvas, 0, 0, leftKeepWidth, h2, 0, 0, leftKeepWidth, h2);
+    out.save();
+    out.translate(w, 0);
+    out.scale(-1, 1);
+    out.drawImage(srcCanvas, 0, 0, rightWidth, h2, 0, 0, rightWidth, h2);
+    out.restore();
+    return;
+  }
+  if (mode === "right") {
+    const leftWidth = Math.floor(w / 2);
+    const rightKeepWidth = w - leftWidth;
+    out.drawImage(
+      srcCanvas,
+      leftWidth,
+      0,
+      rightKeepWidth,
+      h2,
+      leftWidth,
+      0,
+      rightKeepWidth,
+      h2
+    );
+    out.save();
+    out.translate(w, 0);
+    out.scale(-1, 1);
+    out.drawImage(
+      srcCanvas,
+      w - leftWidth,
+      0,
+      leftWidth,
+      h2,
+      w - leftWidth,
+      0,
+      leftWidth,
+      h2
+    );
+    out.restore();
+    return;
+  }
+  if (mode === "up") {
+    const bottomHeight = Math.floor(h2 / 2);
+    const topKeepHeight = h2 - bottomHeight;
+    out.drawImage(srcCanvas, 0, 0, w, topKeepHeight, 0, 0, w, topKeepHeight);
+    out.save();
+    out.translate(0, h2);
+    out.scale(1, -1);
+    out.drawImage(srcCanvas, 0, 0, w, bottomHeight, 0, 0, w, bottomHeight);
+    out.restore();
+    return;
+  }
+  const topHeight = Math.floor(h2 / 2);
+  const bottomKeepHeight = h2 - topHeight;
+  out.drawImage(
+    srcCanvas,
+    0,
+    topHeight,
+    w,
+    bottomKeepHeight,
+    0,
+    topHeight,
+    w,
+    bottomKeepHeight
+  );
+  out.save();
+  out.translate(0, h2);
+  out.scale(1, -1);
+  out.drawImage(
+    srcCanvas,
+    0,
+    h2 - topHeight,
+    w,
+    topHeight,
+    0,
+    h2 - topHeight,
+    w,
+    topHeight
+  );
+  out.restore();
+}
+__name(mirrorDraw, "mirrorDraw");
+async function mirrorStaticImage(canvas, buffer, mode) {
+  const img = await canvas.loadImage(buffer);
+  const w = img.width;
+  const h2 = img.height;
+  const srcCanvas = canvas.createCanvas(w, h2);
+  const src = srcCanvas.getContext("2d");
+  src.drawImage(img, 0, 0, w, h2);
+  const outCanvas = canvas.createCanvas(w, h2);
+  const out = outCanvas.getContext("2d");
+  mirrorDraw(out, srcCanvas, mode);
+  return {
+    buffer: outCanvas.toBuffer("image/png"),
+    mime: "image/png"
+  };
+}
+__name(mirrorStaticImage, "mirrorStaticImage");
+async function mirrorGifImage(canvas, buffer, mode) {
+  const gif = (0, import_gifuct_js.parseGIF)(toArrayBuffer(buffer));
+  const frames = (0, import_gifuct_js.decompressFrames)(gif, true);
+  if (!frames.length) throw new Error("GIF has no frames");
+  const width = gif.lsd?.width ?? frames[0].dims?.width;
+  const height = gif.lsd?.height ?? frames[0].dims?.height;
+  if (!width || !height) throw new Error("Unable to determine GIF size");
+  const srcCanvas = canvas.createCanvas(width, height);
+  const src = srcCanvas.getContext("2d");
+  const outCanvas = canvas.createCanvas(width, height);
+  const out = outCanvas.getContext("2d");
+  const encoder = new import_gif_encoder_2.default(width, height);
+  encoder.start();
+  encoder.setRepeat(0);
+  encoder.setQuality?.(10);
+  for (const frame of frames) {
+    const patch = frame.patch;
+    if (!patch || patch.length !== width * height * 4) {
+      throw new Error("Unsupported GIF frame patch format");
+    }
+    const imageData = src.createImageData(width, height);
+    imageData.data.set(patch);
+    src.putImageData(imageData, 0, 0);
+    mirrorDraw(out, srcCanvas, mode);
+    const delayCs = typeof frame.delay === "number" ? frame.delay : 0;
+    encoder.setDelay(Math.max(0, delayCs * 10));
+    encoder.addFrame(out);
+  }
+  encoder.finish();
+  const outBuffer = Buffer.from(encoder.out.getData());
+  return { buffer: outBuffer, mime: "image/gif" };
+}
+__name(mirrorGifImage, "mirrorGifImage");
+async function handleMirror(ctx, session, mode) {
+  const src = findImageSrc(session);
+  if (!src) return "未找到图片：请在消息中附带图片，或引用一条包含图片的消息。";
+  const canvas = ctx.canvas;
+  if (!canvas?.createCanvas || !canvas?.loadImage) {
+    return "未检测到 canvas 服务：请安装并启用 Koishi 的 canvas 服务插件后再使用本功能。";
+  }
+  const arrayBuffer = await ctx.http.get(src, {
+    responseType: "arraybuffer"
+  });
+  const input = Buffer.from(arrayBuffer);
+  const result = isGif(input) ? await mirrorGifImage(canvas, input, mode) : await mirrorStaticImage(canvas, input, mode);
+  return import_koishi.h.img(result.buffer, result.mime);
+}
+__name(handleMirror, "handleMirror");
+function apply(ctx, config) {
+  ctx.command("左对称", "以左侧为基准生成左右对称图片").action(async ({ session }) => {
+    return handleMirror(ctx, session, "left");
+  });
+  ctx.command("右对称", "以右侧为基准生成左右对称图片").action(async ({ session }) => {
+    return handleMirror(ctx, session, "right");
+  });
+  ctx.command("上对称", "以上侧为基准生成上下对称图片").action(async ({ session }) => {
+    return handleMirror(ctx, session, "up");
+  });
+  ctx.command("下对称", "以下侧为基准生成上下对称图片").action(async ({ session }) => {
+    return handleMirror(ctx, session, "down");
+  });
+}
+__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-img-tool",
   "description": "modify img",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [