@openclaw/whatsapp 2026.5.24-beta.2 → 2026.5.26-beta.1

package/node_modules/@jimp/plugin-print/src/index.node.test.ts

@@ -1,302 +0,0 @@
-import { expect, test, describe } from "vitest";
-import "@jimp/test-utils/image-snapshot";
-import { HorizontalAlign, VerticalAlign, createJimp } from "@jimp/core";
-import png from "@jimp/js-png";
-import jpeg from "@jimp/js-jpeg";
-
-import { methods, measureText, measureTextHeight } from "./index.js";
-import { loadFont } from "./load-font.js";
-import * as fonts from "./fonts.js";
-
-const Jimp = createJimp({ plugins: [methods], formats: [png, jpeg] });
-
-async function createTextImage(
-  width: number,
-  height: number,
-  font: string,
-  {
-    x = 0,
-    y = 0,
-    text,
-    maxWidth,
-    maxHeight,
-  }: {
-    text:
-      | string
-      | {
-          text: string;
-          alignmentX?: HorizontalAlign;
-          alignmentY?: VerticalAlign;
-        };
-    maxWidth?: number;
-    maxHeight?: number;
-    x?: number;
-    y?: number;
-  },
-) {
-  const loadedFont = await loadFont(font);
-  const image = new Jimp({ width, height, color: 0xffffffff });
-
-  return image
-    .print({ font: loadedFont, x, y, text, maxWidth, maxHeight })
-    .getBuffer("image/png");
-}
-
-describe("Write text over image", function () {
-  const fontDefs = {
-    SANS_8_BLACK: { w: 28, h: 28, bg: 0xffffffff },
-
-    SANS_16_BLACK: { w: 54, h: 54, bg: 0xffffffff },
-    SANS_32_BLACK: { w: 114, h: 114, bg: 0xffffffff },
-    SANS_64_BLACK: { w: 220, h: 220, bg: 0xffffffff },
-
-    SANS_8_WHITE: { w: 28, h: 28, bg: 0x000000ff },
-
-    SANS_16_WHITE: { w: 54, h: 54, bg: 0x000000ff },
-    SANS_32_WHITE: { w: 114, h: 114, bg: 0x000000ff },
-    SANS_64_WHITE: { w: 220, h: 220, bg: 0x000000ff },
-  };
-
-  Object.entries(fontDefs).forEach(([fontName, conf]) => {
-    test("Jimp preset " + fontName + " bitmap font", async () => {
-      const font = await loadFont(fonts[fontName as keyof typeof fonts]);
-      const image = new Jimp({ width: conf.w, height: conf.h, color: conf.bg });
-      const output = await image
-        .print({
-          font,
-          x: 0,
-          y: 0,
-          text: "This is only a test.",
-          maxWidth: image.bitmap.width,
-        })
-        .getBuffer("image/png");
-
-      expect(output).toMatchImageSnapshot();
-    });
-  });
-
-  test("Jimp preset SANS_16_BLACK bitmap font positioned", async () => {
-    const font = await loadFont(fonts.SANS_16_BLACK);
-    const image = new Jimp({ width: 300, height: 100, color: 0xff8800ff });
-    const output = await image
-      .print({
-        font,
-        x: 150,
-        y: 50,
-        text: "This is only a test.",
-        maxWidth: 100,
-      })
-      .getBuffer("image/png");
-
-    expect(output).toMatchImageSnapshot();
-  });
-
-  test("Jimp loads font from URL", async () => {
-    const font = await loadFont(
-      "https://raw.githubusercontent.com/jimp-dev/jimp/main/plugins/plugin-print/fonts/open-sans/open-sans-16-black/open-sans-16-black.fnt",
-    );
-    const image = new Jimp({ width: 300, height: 100, color: 0xff8800ff });
-    const output = await image
-      .print({
-        font,
-        x: 150,
-        y: 50,
-        text: "This is only a test.",
-        maxWidth: 100,
-      })
-      .getBuffer("image/png");
-
-    expect(output).toMatchImageSnapshot();
-  });
-
-  test("Max width works without spaces", async () => {
-    const font = await loadFont(
-      "https://raw.githubusercontent.com/jimp-dev/jimp/main/plugins/plugin-print/fonts/open-sans/open-sans-16-black/open-sans-16-black.fnt",
-    );
-    const image = new Jimp({ width: 300, height: 100, color: 0xff8800ff });
-    const output = await image
-      .print({
-        font,
-        x: 150,
-        y: 50,
-        text: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-        maxWidth: 100,
-      })
-      .getBuffer("image/png");
-
-    expect(output).toMatchImageSnapshot();
-  });
-
-  test("Jimp renders ? for unknown characters", async () => {
-    const font = await loadFont(fonts.SANS_16_BLACK);
-    const image = new Jimp({ width: 300, height: 100, color: 0xff8800ff });
-    const output = await image
-      .print({ font, x: 0, y: 0, text: "ツ ツ ツ", maxWidth: 100 })
-      .getBuffer("image/png");
-
-    expect(output).toMatchImageSnapshot();
-  });
-
-  test("Jimp can print numbers too", async () => {
-    const font = await loadFont(fonts.SANS_16_BLACK);
-    const image = new Jimp({ width: 300, height: 100, color: 0xff8800ff });
-    const output = await image
-      .print({ font, x: 0, y: 0, text: 12345678, maxWidth: 100 })
-      .getBuffer("image/png");
-
-    expect(output).toMatchImageSnapshot();
-  });
-
-  test("left-align text by default", async () => {
-    const textImage = await createTextImage(320, 240, fonts.SANS_16_BLACK, {
-      text: "This is only a test.",
-      maxWidth: 100,
-    });
-
-    expect(textImage).toMatchImageSnapshot();
-  });
-
-  test("left-align text by default when passing object", async () => {
-    const textImage = await createTextImage(320, 240, fonts.SANS_16_BLACK, {
-      text: { text: "This is only a test." },
-      maxWidth: 100,
-    });
-
-    expect(textImage).toMatchImageSnapshot();
-  });
-
-  test("left-align text when passing object with alignmentX", async () => {
-    const textImage = await createTextImage(320, 240, fonts.SANS_16_BLACK, {
-      text: {
-        text: "This is only a test.",
-        alignmentX: HorizontalAlign.LEFT,
-      },
-      maxWidth: 100,
-    });
-
-    expect(textImage).toMatchImageSnapshot();
-  });
-
-  test("center-align text when passing object with alignmentX", async () => {
-    const textImage = await createTextImage(320, 240, fonts.SANS_16_BLACK, {
-      text: {
-        text: "This is only a test.",
-        alignmentX: HorizontalAlign.CENTER,
-      },
-      maxWidth: 100,
-    });
-
-    expect(textImage).toMatchImageSnapshot();
-  });
-
-  test("right-align text when passing object with alignmentX", async () => {
-    const textImage = await createTextImage(320, 240, fonts.SANS_16_BLACK, {
-      text: {
-        text: "This is only a test.",
-        alignmentX: HorizontalAlign.RIGHT,
-      },
-      maxWidth: 100,
-    });
-
-    expect(textImage).toMatchImageSnapshot();
-  });
-
-  test("middle-align text when passing object with alignmentY", async () => {
-    const textImage = await createTextImage(320, 240, fonts.SANS_16_BLACK, {
-      text: {
-        text: "This is only a test.",
-        alignmentY: VerticalAlign.MIDDLE,
-      },
-      maxWidth: 100,
-      maxHeight: 240,
-    });
-
-    expect(textImage).toMatchImageSnapshot();
-  });
-
-  test("middle-align text when passing object with alignmentY can offset y", async () => {
-    const textImage = await createTextImage(320, 240, fonts.SANS_16_BLACK, {
-      y: 50,
-      text: {
-        text: "This is only a test.",
-        alignmentY: VerticalAlign.MIDDLE,
-      },
-      maxWidth: 100,
-      maxHeight: 240,
-    });
-
-    expect(textImage).toMatchImageSnapshot();
-  });
-
-  test("bottom-align text when passing object with alignmentY", async () => {
-    const textImage = await createTextImage(320, 240, fonts.SANS_16_BLACK, {
-      text: {
-        text: "This is only a test.",
-        alignmentY: VerticalAlign.BOTTOM,
-      },
-      maxWidth: 100,
-      maxHeight: 240,
-    });
-
-    expect(textImage).toMatchImageSnapshot();
-  });
-
-  test("bottom-align text when passing object with alignmentY offset y", async () => {
-    const textImage = await createTextImage(320, 240, fonts.SANS_16_BLACK, {
-      y: 100,
-      text: {
-        text: "This is only a test.",
-        alignmentY: VerticalAlign.BOTTOM,
-      },
-      maxWidth: 100,
-      maxHeight: 100,
-    });
-
-    expect(textImage).toMatchImageSnapshot();
-  });
-
-  test("exposes print y position in cb", async () => {
-    const loadedFont = await loadFont(fonts.SANS_16_BLACK);
-    const image = new Jimp({ width: 500, height: 500, color: 0xffffffff });
-
-    image.print({
-      font: loadedFont,
-      x: 0,
-      y: 0,
-      text: "One two three four fix six seven eight nine ten eleven twelve",
-      maxWidth: 250,
-      cb: ({ x, y }) => {
-        image.print({
-          font: loadedFont,
-          x,
-          y: y + 50,
-          text: "thirteen fourteen fifteen sixteen seventeen eighteen nineteen twenty",
-          maxWidth: 250,
-        });
-      },
-    });
-
-    const output = await image.getBuffer("image/png");
-    expect(output).toMatchImageSnapshot();
-  });
-
-  test("measureText is consistent with measureTextWidth", async () => {
-    const font = await loadFont(fonts.SANS_16_BLACK);
-
-    const text = "n n n";
-    const width = measureText(font, text);
-    const height = measureTextHeight(font, text, width);
-    const lineHeight = measureTextHeight(font, text, Infinity);
-
-    expect(height).toEqual(lineHeight);
-  });
-
-  test("text with newlines, default alignment", async () => {
-    const textImage = await createTextImage(100, 240, fonts.SANS_16_BLACK, {
-      text: "This \nis only \na \ntest.",
-      maxWidth: 300,
-    });
-
-    expect(textImage).toMatchImageSnapshot();
-  });
-});

package/node_modules/@jimp/plugin-print/src/index.ts

@@ -1,220 +0,0 @@
-import { HorizontalAlign, VerticalAlign } from "@jimp/core";
-import { JimpClass } from "@jimp/types";
-import { methods as blitMethods } from "@jimp/plugin-blit";
-import { z } from "zod";
-
-import { measureText, measureTextHeight, splitLines } from "./measure-text.js";
-import { BmCharacter, BmFont } from "./types.js";
-
-export { measureText, measureTextHeight } from "./measure-text.js";
-export * from "./types.js";
-
-const PrintOptionsSchema = z.object({
-  /** the x position to draw the image */
-  x: z.number(),
-  /** the y position to draw the image */
-  y: z.number(),
-  /** the text to print */
-  text: z.union([
-    z.union([z.string(), z.number()]),
-    z.object({
-      text: z.union([z.string(), z.number()]),
-      alignmentX: z.nativeEnum(HorizontalAlign).optional(),
-      alignmentY: z.nativeEnum(VerticalAlign).optional(),
-    }),
-  ]),
-  /** the boundary width to draw in */
-  maxWidth: z.number().optional(),
-  /** the boundary height to draw in */
-  maxHeight: z.number().optional(),
-  /** a callback for when complete that ahs the end co-ordinates of the text */
-  cb: z
-    .function(z.tuple([z.object({ x: z.number(), y: z.number() })]))
-    .optional(),
-});
-
-export type PrintOptions = z.infer<typeof PrintOptionsSchema>;
-
-function xOffsetBasedOnAlignment<I extends JimpClass>(
-  font: BmFont<I>,
-  line: string,
-  maxWidth: number,
-  alignment: HorizontalAlign
-) {
-  if (alignment === HorizontalAlign.LEFT) {
-    return 0;
-  }
-
-  if (alignment === HorizontalAlign.CENTER) {
-    return (maxWidth - measureText(font, line)) / 2;
-  }
-
-  return maxWidth - measureText(font, line);
-}
-
-function drawCharacter<I extends JimpClass>(
-  image: I,
-  font: BmFont<I>,
-  x: number,
-  y: number,
-  char: BmCharacter
-) {
-  if (char.width > 0 && char.height > 0) {
-    const characterPage = font.pages[char.page];
-
-    if (characterPage) {
-      image = blitMethods.blit(image, {
-        src: characterPage,
-        x: x + char.xoffset,
-        y: y + char.yoffset,
-        srcX: char.x,
-        srcY: char.y,
-        srcW: char.width,
-        srcH: char.height,
-      });
-    }
-  }
-
-  return image;
-}
-
-function printText<I extends JimpClass>(
-  image: I,
-  font: BmFont<I>,
-  x: number,
-  y: number,
-  text: string,
-  defaultCharWidth: number
-) {
-  for (let i = 0; i < text.length; i++) {
-    const stringChar = text[i]!;
-
-    let char;
-
-    if (font.chars[stringChar]) {
-      char = stringChar;
-    } else if (/\s/.test(stringChar)) {
-      char = "";
-    } else {
-      char = "?";
-    }
-
-    const fontChar = font.chars[char] || { xadvance: undefined };
-    const fontKerning = font.kernings[char];
-
-    if (fontChar) {
-      drawCharacter(image, font, x, y, fontChar as BmCharacter);
-    }
-
-    const nextChar = text[i + 1];
-    const kerning =
-      fontKerning && nextChar && fontKerning[nextChar]
-        ? fontKerning[nextChar] || 0
-        : 0;
-
-    x += kerning + (fontChar.xadvance || defaultCharWidth);
-  }
-}
-
-export const methods = {
-  /**
-   * Draws a text on a image on a given boundary
-   * @param font a bitmap font loaded from `Jimp.loadFont` command
-   * @param x the x position to start drawing the text
-   * @param y the y position to start drawing the text
-   * @param text the text to draw (string or object with `text`, `alignmentX`, and/or `alignmentY`)
-   * @example
-   * ```ts
-   * import { Jimp } from "jimp";
-   *
-   * const image = await Jimp.read("test/image.png");
-   * const font = await Jimp.loadFont(Jimp.FONT_SANS_32_BLACK);
-   *
-   * image.print({ font, x: 10, y: 10, text: "Hello world!" });
-   * ```
-   */
-  print<I extends JimpClass>(
-    image: I,
-    {
-      font,
-      ...options
-    }: PrintOptions & {
-      /** the BMFont instance */
-      font: BmFont<I>;
-    }
-  ) {
-    let {
-      // eslint-disable-next-line prefer-const
-      x,
-      y,
-      text,
-      // eslint-disable-next-line prefer-const
-      maxWidth = Infinity,
-      // eslint-disable-next-line prefer-const
-      maxHeight = Infinity,
-      // eslint-disable-next-line prefer-const
-      cb = () => {},
-    } = PrintOptionsSchema.parse(options);
-
-    let alignmentX: HorizontalAlign;
-    let alignmentY: VerticalAlign;
-
-    if (
-      typeof text === "object" &&
-      text.text !== null &&
-      text.text !== undefined
-    ) {
-      alignmentX = text.alignmentX || HorizontalAlign.LEFT;
-      alignmentY = text.alignmentY || VerticalAlign.TOP;
-      ({ text } = text);
-    } else {
-      alignmentX = HorizontalAlign.LEFT;
-      alignmentY = VerticalAlign.TOP;
-      text = text.toString();
-    }
-
-    if (typeof text === "number") {
-      text = text.toString();
-    }
-
-    if (maxHeight !== Infinity && alignmentY === VerticalAlign.BOTTOM) {
-      y += maxHeight - measureTextHeight(font, text, maxWidth);
-    } else if (maxHeight !== Infinity && alignmentY === VerticalAlign.MIDDLE) {
-      y += maxHeight / 2 - measureTextHeight(font, text, maxWidth) / 2;
-    }
-
-    const defaultCharWidth = Object.entries(font.chars).find(
-      (c) => c[1].xadvance
-    )?.[1].xadvance;
-
-    if (typeof defaultCharWidth !== "number") {
-      throw new Error("Could not find default character width");
-    }
-
-    const { lines, longestLine } = splitLines(font, text, maxWidth);
-
-    lines.forEach((line) => {
-      const lineString = line.join(" ");
-      const alignmentWidth = xOffsetBasedOnAlignment(
-        font,
-        lineString,
-        maxWidth,
-        alignmentX
-      );
-
-      printText(
-        image,
-        font,
-        x + alignmentWidth,
-        y,
-        lineString,
-        defaultCharWidth
-      );
-      y += font.common.lineHeight;
-    });
-
-    cb.bind(image)({ x: x + longestLine, y });
-
-    return image;
-  },
-};

package/node_modules/@jimp/plugin-print/src/load-bitmap-font.ts

@@ -1,165 +0,0 @@
-import parseASCII from "parse-bmfont-ascii";
-import parseXML from "parse-bmfont-xml";
-import readBinary from "parse-bmfont-binary";
-import { BmCharacter, BmKerning, BmFont, BmCommonProps } from "./types.js";
-import png from "@jimp/js-png";
-import { createJimp } from "@jimp/core";
-import path from "path";
-import xmlPackage from "simple-xml-to-json";
-
-const { convertXML } = xmlPackage;
-
-export const isWebWorker =
-  typeof self !== "undefined" && self.document === undefined;
-
-const CharacterJimp = createJimp({ formats: [png] });
-const HEADER = Buffer.from([66, 77, 70, 3]);
-
-function isBinary(buf: Buffer | string) {
-  if (typeof buf === "string") {
-    return buf.substring(0, 3) === "BMF";
-  }
-
-  const startOfHeader = buf.slice(0, 4);
-
-  return (
-    buf.length > 4 &&
-    startOfHeader[0] === HEADER[0] &&
-    startOfHeader[1] === HEADER[1] &&
-    startOfHeader[2] === HEADER[2]
-  );
-}
-
-export interface LoadedFont {
-  chars: BmCharacter[];
-  kernings: BmKerning[];
-  common: BmCommonProps;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  info: Record<string, any>;
-  pages: string[];
-}
-
-function parseFont(file: string, data: Buffer | string): LoadedFont {
-  if (isBinary(data)) {
-    if (typeof data === "string") {
-      data = Buffer.from(data, "binary");
-    }
-
-    return readBinary(data);
-  }
-
-  data = data.toString().trim();
-
-  if (/.json$/.test(file) || data.charAt(0) === "{") {
-    return JSON.parse(data);
-  }
-
-  if (/.xml$/.test(file) || data.charAt(0) === "<") {
-    return parseXML(data);
-  }
-
-  return parseASCII(data);
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function parseNumbersInObject<T extends Record<string, any>>(obj: T) {
-  for (const key in obj) {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (obj as any)[key] = parseInt(obj[key], 10);
-    } catch {
-      // do nothing
-    }
-
-    if (typeof obj[key] === "object") {
-      parseNumbersInObject(obj[key]);
-    }
-  }
-
-  return obj;
-}
-
-/**
- *
- * @param bufferOrUrl A URL to a file or a buffer
- * @returns
- */
-export async function loadBitmapFontData(
-  bufferOrUrl: string | Buffer
-): Promise<LoadedFont> {
-  if (isWebWorker && typeof bufferOrUrl === "string") {
-    const res = await fetch(bufferOrUrl);
-    const text = await res.text();
-    const json = convertXML(text);
-
-    const font = json.font.children.reduce(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (acc: Record<string, any>, i: any) => ({ ...acc, ...i }),
-      {}
-    );
-    const pages: LoadedFont["pages"] = [];
-    const chars: LoadedFont["chars"] = [];
-    const kernings: LoadedFont["kernings"] = [];
-
-    for (let i = 0; i < font.pages.children.length; i++) {
-      const p = font.pages.children[i].page;
-      const id = parseInt(p.id, 10);
-      pages[id] = parseNumbersInObject(p.file);
-    }
-
-    for (let i = 0; i < font.chars.children.length; i++) {
-      chars.push(parseNumbersInObject(font.chars.children[i].char));
-    }
-
-    for (let i = 0; i < font.kernings.children.length; i++) {
-      kernings.push(parseNumbersInObject(font.kernings.children[i].kerning));
-    }
-
-    return {
-      info: font.info,
-      common: font.common,
-      pages,
-      chars,
-      kernings,
-    } satisfies LoadedFont;
-  } else if (typeof bufferOrUrl === "string") {
-    const res = await fetch(bufferOrUrl);
-    const text = await res.text();
-
-    return parseFont(bufferOrUrl, text);
-  } else {
-    return parseFont("", bufferOrUrl);
-  }
-}
-
-type RawFont = Awaited<ReturnType<typeof loadBitmapFontData>>;
-export type ResolveBmFont = Omit<BmFont, "pages"> & Pick<RawFont, "pages">;
-
-export async function processBitmapFont(file: string, font: LoadedFont) {
-  const chars: Record<string, BmCharacter> = {};
-  const kernings: Record<string, BmKerning> = {};
-
-  for (let i = 0; i < font.chars.length; i++) {
-    const char = font.chars[i]!;
-    chars[String.fromCharCode(char.id)] = char;
-  }
-
-  for (let i = 0; i < font.kernings.length; i++) {
-    const firstString = String.fromCharCode(font.kernings[i]!.first);
-
-    kernings[firstString] = kernings[firstString]! || {};
-    kernings[firstString]![String.fromCharCode(font.kernings[i]!.second)] =
-      font.kernings[i]!.amount;
-  }
-
-  return {
-    ...font,
-    chars,
-    kernings,
-    pages: await Promise.all(
-      font.pages.map(async (page) =>
-        CharacterJimp.read(path.join(path.dirname(file), page))
-      )
-    ),
-  };
-}