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

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;
  },
};