koishi-plugin-img-tool 0.0.1 → 1.0.1

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+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>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,239 @@
+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.select(content.elements, "img");
+  return nodes?.[0];
+}
+__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.event.message);
+  const directSrc = getImageSrc(direct);
+  if (directSrc) return directSrc;
+  const quote = session.quote;
+  const quoteEl = selectFirstImageElement(quote);
+  const quoteSrc = getImageSrc(quoteEl);
+  if (quoteSrc) return quoteSrc;
+  const quoteElements = quote?.elements;
+  if (quoteElements) {
+    const quoteEl2 = import_koishi.h.select(quoteElements, "img")?.[0];
+    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 mirrorPixels(src, width, height, mode) {
+  const dst = new Uint8ClampedArray(src.length);
+  const ceilHalfW = Math.ceil(width / 2);
+  const floorHalfW = Math.floor(width / 2);
+  const ceilHalfH = Math.ceil(height / 2);
+  const floorHalfH = Math.floor(height / 2);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      let sx = x;
+      let sy = y;
+      if (mode === "left") {
+        sx = x < ceilHalfW ? x : width - 1 - x;
+      } else if (mode === "right") {
+        sx = x < floorHalfW ? width - 1 - x : x;
+      } else if (mode === "up") {
+        sy = y < ceilHalfH ? y : height - 1 - y;
+      } else {
+        sy = y < floorHalfH ? height - 1 - y : y;
+      }
+      const si = (sy * width + sx) * 4;
+      const di = (y * width + x) * 4;
+      dst[di] = src[si];
+      dst[di + 1] = src[si + 1];
+      dst[di + 2] = src[si + 2];
+      dst[di + 3] = src[si + 3];
+    }
+  }
+  return dst;
+}
+__name(mirrorPixels, "mirrorPixels");
+async function mirrorStaticImage(canvas, buffer, mode) {
+  let img;
+  let srcCanvas;
+  let outCanvas;
+  try {
+    img = await canvas.loadImage(buffer);
+    const w = img.naturalWidth ?? img.width;
+    const h2 = img.naturalHeight ?? img.height;
+    srcCanvas = await canvas.createCanvas(w, h2);
+    const src = srcCanvas.getContext("2d");
+    src.drawImage(img, 0, 0, w, h2);
+    outCanvas = await canvas.createCanvas(w, h2);
+    const out = outCanvas.getContext("2d");
+    const srcImageData = src.getImageData(0, 0, w, h2);
+    const outImageData = out.createImageData(w, h2);
+    outImageData.data.set(mirrorPixels(srcImageData.data, w, h2, mode));
+    out.putImageData(outImageData, 0, 0);
+    return {
+      buffer: await outCanvas.toBuffer("image/png"),
+      mime: "image/png"
+    };
+  } finally {
+    await Promise.allSettled([
+      img?.dispose?.(),
+      srcCanvas?.dispose?.(),
+      outCanvas?.dispose?.()
+    ]);
+  }
+}
+__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 screenCanvas = await canvas.createCanvas(width, height);
+  const screen = screenCanvas.getContext("2d");
+  const outCanvas = await canvas.createCanvas(width, height);
+  const out = outCanvas.getContext("2d");
+  try {
+    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;
+      const dims = frame.dims || {};
+      const left = dims.left ?? 0;
+      const top = dims.top ?? 0;
+      const pw = dims.width ?? width;
+      const ph = dims.height ?? height;
+      if (!patch || patch.length !== pw * ph * 4) {
+        throw new Error("Unsupported GIF frame patch format");
+      }
+      const disposalType = frame.disposalType ?? 0;
+      const restore = disposalType === 3 ? screen.getImageData(0, 0, width, height) : null;
+      const region = screen.getImageData(left, top, pw, ph);
+      for (let i = 0; i < patch.length; i += 4) {
+        if (patch[i + 3] === 0) continue;
+        region.data[i] = patch[i];
+        region.data[i + 1] = patch[i + 1];
+        region.data[i + 2] = patch[i + 2];
+        region.data[i + 3] = patch[i + 3];
+      }
+      screen.putImageData(region, left, top);
+      const screenData = screen.getImageData(0, 0, width, height);
+      const outData = out.createImageData(width, height);
+      outData.data.set(mirrorPixels(screenData.data, width, height, mode));
+      out.putImageData(outData, 0, 0);
+      const delayMs = typeof frame.delay === "number" ? frame.delay : 100;
+      encoder.setDelay(Math.max(20, delayMs));
+      encoder.addFrame(out);
+      if (disposalType === 2) {
+        screen.clearRect(left, top, pw, ph);
+      } else if (disposalType === 3 && restore) {
+        screen.putImageData(restore, 0, 0);
+      }
+    }
+    encoder.finish();
+    const outBuffer = Buffer.from(encoder.out.getData());
+    return { buffer: outBuffer, mime: "image/gif" };
+  } finally {
+    await Promise.allSettled([screenCanvas.dispose?.(), outCanvas.dispose?.()]);
+  }
+}
+__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": "1.0.1",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [