chess2img 0.1.0

package/dist/index.js

@@ -0,0 +1,626 @@
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/types/errors.ts
+var ValidationError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ValidationError";
+  }
+};
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ParseError";
+  }
+};
+var ThemeError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ThemeError";
+  }
+};
+var RenderError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RenderError";
+  }
+};
+var IOError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "IOError";
+  }
+};
+
+// src/core/parsers.ts
+import { Chess } from "chess.js";
+
+// src/core/board.ts
+var FILES = ["a", "b", "c", "d", "e", "f", "g", "h"];
+var RANKS = ["8", "7", "6", "5", "4", "3", "2", "1"];
+var SQUARES = RANKS.flatMap(
+  (rank) => FILES.map((file) => `${file}${rank}`)
+);
+function createEmptyBoardPosition() {
+  return {
+    squares: Object.fromEntries(
+      SQUARES.map((square) => [square, null])
+    )
+  };
+}
+
+// src/core/validators.ts
+var SQUARE_PATTERN = /^[a-h][1-8]$/;
+var PIECE_PATTERN = /^[prnbqkPRNBQK]$/;
+function validateSize(size) {
+  if (!Number.isFinite(size) || size <= 0) {
+    throw new ValidationError(`Invalid board size: ${size}`);
+  }
+  return Math.round(size);
+}
+function normalizePadding(padding) {
+  const candidate = padding ?? [0, 0, 0, 0];
+  if (!Array.isArray(candidate) || candidate.length !== 4 || candidate.some((value) => !Number.isFinite(value) || value < 0)) {
+    throw new ValidationError("Padding must be a 4-item array of non-negative numbers");
+  }
+  return [
+    Math.round(candidate[0]),
+    Math.round(candidate[1]),
+    Math.round(candidate[2]),
+    Math.round(candidate[3])
+  ];
+}
+function validateSquare(square) {
+  const normalized = square.trim().toLowerCase();
+  if (!SQUARE_PATTERN.test(normalized)) {
+    throw new ValidationError(`Invalid square: ${square}`);
+  }
+  return normalized;
+}
+function validateBoardCell(cell) {
+  if (cell === null || cell === "" || cell === " ") {
+    return null;
+  }
+  if (typeof cell !== "string" || !PIECE_PATTERN.test(cell)) {
+    throw new ValidationError(`Invalid board piece: ${String(cell)}`);
+  }
+  return cell;
+}
+function validateBoardArray(board) {
+  if (!Array.isArray(board) || board.length !== 8) {
+    throw new ValidationError("Board array must have exactly 8 ranks");
+  }
+  return board.map((rank, rankIndex) => {
+    if (!Array.isArray(rank) || rank.length !== 8) {
+      throw new ValidationError(`Board rank ${rankIndex} must contain exactly 8 files`);
+    }
+    return rank.map(validateBoardCell);
+  });
+}
+function validateThemeName(name) {
+  const normalized = name.trim().toLowerCase();
+  if (!/^[a-z0-9-]+$/.test(normalized)) {
+    throw new ValidationError(`Invalid theme name: ${name}`);
+  }
+  return normalized;
+}
+
+// src/core/parsers.ts
+var PIECE_SYMBOL_TO_KEY = {
+  K: "wK",
+  Q: "wQ",
+  R: "wR",
+  B: "wB",
+  N: "wN",
+  P: "wP",
+  k: "bK",
+  q: "bQ",
+  r: "bR",
+  b: "bB",
+  n: "bN",
+  p: "bP"
+};
+function chessBoardToBoardArray(board) {
+  return board.map(
+    (rank) => rank.map((piece) => {
+      if (!piece) {
+        return null;
+      }
+      return piece.color === "w" ? piece.type.toUpperCase() : piece.type;
+    })
+  );
+}
+function parseFEN(fen) {
+  const chess = new Chess();
+  try {
+    chess.load(fen);
+  } catch (error) {
+    throw new ParseError("Invalid FEN", { cause: error });
+  }
+  return parseBoardArray(chessBoardToBoardArray(chess.board()));
+}
+function parsePGN(pgn) {
+  const chess = new Chess();
+  try {
+    chess.loadPgn(pgn);
+  } catch (error) {
+    throw new ParseError("Invalid PGN", { cause: error });
+  }
+  return parseBoardArray(chessBoardToBoardArray(chess.board()));
+}
+function parseBoardArray(board) {
+  const validatedBoard = validateBoardArray(board);
+  const position = createEmptyBoardPosition();
+  validatedBoard.forEach((rank, rankIndex) => {
+    rank.forEach((cell, fileIndex) => {
+      if (cell === null) {
+        return;
+      }
+      const pieceKey = PIECE_SYMBOL_TO_KEY[cell];
+      if (!pieceKey) {
+        throw new ValidationError(`Invalid board piece: ${cell}`);
+      }
+      const square = `${FILES[fileIndex]}${8 - rankIndex}`;
+      position.squares[square] = pieceKey;
+    });
+  });
+  return position;
+}
+
+// src/core/highlights.ts
+function normalizeHighlights(input) {
+  return [...new Set(input.map(validateSquare))].sort();
+}
+
+// src/render/canvas-renderer.ts
+import { createCanvas as createCanvas2 } from "canvas";
+
+// src/core/geometry.ts
+function createBoardGeometry({
+  size,
+  padding,
+  flipped
+}) {
+  const [top, right, bottom, left] = padding;
+  const squareSize = size / 8;
+  const squares = Object.fromEntries(
+    SQUARES.map((square, index) => {
+      const fileIndex = index % 8;
+      const rankIndex = Math.floor(index / 8);
+      const x = left + (flipped ? 7 - fileIndex : fileIndex) * squareSize;
+      const y = top + (flipped ? 7 - rankIndex : rankIndex) * squareSize;
+      return [square, { x, y, size: squareSize }];
+    })
+  );
+  return {
+    imageWidth: left + size + right,
+    imageHeight: top + size + bottom,
+    squareSize,
+    boardX: left,
+    boardY: top,
+    boardSize: size,
+    squares
+  };
+}
+
+// src/render/asset-cache.ts
+function createRasterCacheKey(themeName, pieceKey, squareSize, backend) {
+  return `${themeName}:${pieceKey}:${squareSize}:${backend}`;
+}
+var RasterAssetCache = class {
+  cache = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.cache.get(key);
+  }
+  set(key, value) {
+    this.cache.set(key, value);
+  }
+};
+var SourceAssetCache = class {
+  cache = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.cache.get(key);
+  }
+  set(key, value) {
+    this.cache.set(key, value);
+  }
+};
+
+// src/render/rasterizer.ts
+import { readFile } from "fs/promises";
+import { createCanvas, loadImage } from "canvas";
+import { Resvg } from "@resvg/resvg-js";
+var svgSourceCache = new SourceAssetCache();
+async function readSvgSource(filePath) {
+  const cached = svgSourceCache.get(filePath);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const source = await readFile(filePath, "utf8");
+    svgSourceCache.set(filePath, source);
+    return source;
+  } catch (error) {
+    throw new RenderError(`Failed to read SVG asset: ${filePath}`, { cause: error });
+  }
+}
+async function rasterizeSvgAsset(filePath, squareSize) {
+  try {
+    const svgSource = await readSvgSource(filePath);
+    const resvg = new Resvg(svgSource, {
+      fitTo: {
+        mode: "width",
+        value: squareSize
+      }
+    });
+    const pngBuffer = resvg.render().asPng();
+    const image = await loadImage(pngBuffer);
+    const canvas = createCanvas(squareSize, squareSize);
+    const context = canvas.getContext("2d");
+    context.drawImage(image, 0, 0, squareSize, squareSize);
+    return canvas;
+  } catch (error) {
+    throw new RenderError(`Failed to rasterize SVG asset: ${filePath}`, { cause: error });
+  }
+}
+
+// src/render/canvas-renderer.ts
+var pieceRasterCache = new RasterAssetCache();
+function isDarkSquare(square) {
+  const fileIndex = square.charCodeAt(0) - 97;
+  const rankNumber = Number(square[1]);
+  return (fileIndex + rankNumber) % 2 === 1;
+}
+async function getPieceRaster(themeName, pieceKey, assetPath2, squareSize) {
+  const cacheKey = createRasterCacheKey(themeName, pieceKey, squareSize, "png-canvas");
+  const cached = pieceRasterCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const raster = await rasterizeSvgAsset(assetPath2, squareSize);
+  pieceRasterCache.set(cacheKey, raster);
+  return raster;
+}
+var CanvasPngRenderer = class {
+  async render(request) {
+    try {
+      const geometry = createBoardGeometry({
+        size: request.size,
+        padding: request.padding,
+        flipped: request.flipped
+      });
+      const canvas = createCanvas2(geometry.imageWidth, geometry.imageHeight);
+      const context = canvas.getContext("2d");
+      context.fillStyle = request.colors.lightSquare;
+      context.fillRect(0, 0, geometry.imageWidth, geometry.imageHeight);
+      for (const square of SQUARES) {
+        const squareGeometry = geometry.squares[square];
+        context.fillStyle = isDarkSquare(square) ? request.colors.darkSquare : request.colors.lightSquare;
+        context.fillRect(
+          squareGeometry.x,
+          squareGeometry.y,
+          squareGeometry.size,
+          squareGeometry.size
+        );
+        if (request.highlights.includes(square)) {
+          context.fillStyle = request.colors.highlight;
+          context.fillRect(
+            squareGeometry.x,
+            squareGeometry.y,
+            squareGeometry.size,
+            squareGeometry.size
+          );
+        }
+        const pieceKey = request.board.squares[square];
+        if (!pieceKey) {
+          continue;
+        }
+        const assetPath2 = request.theme.pieces[pieceKey].source;
+        const raster = await getPieceRaster(
+          request.theme.name,
+          pieceKey,
+          assetPath2,
+          Math.round(geometry.squareSize)
+        );
+        context.drawImage(
+          raster,
+          squareGeometry.x,
+          squareGeometry.y,
+          squareGeometry.size,
+          squareGeometry.size
+        );
+      }
+      return canvas.toBuffer("image/png");
+    } catch (error) {
+      if (error instanceof RenderError) {
+        throw error;
+      }
+      throw new RenderError("Failed to render chess board", { cause: error });
+    }
+  }
+};
+
+// src/utils/io.ts
+import { writeFile } from "fs/promises";
+async function writeBufferToFile(filePath, buffer) {
+  try {
+    await writeFile(filePath, buffer);
+  } catch (error) {
+    throw new IOError(`Failed to write file: ${filePath}`, { cause: error });
+  }
+}
+
+// src/themes/builtins.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+
+// src/themes/validation.ts
+var REQUIRED_PIECES = [
+  "wK",
+  "wQ",
+  "wR",
+  "wB",
+  "wN",
+  "wP",
+  "bK",
+  "bQ",
+  "bR",
+  "bB",
+  "bN",
+  "bP"
+];
+function validateThemeDefinition(theme) {
+  const normalizedName = validateThemeName(theme.name);
+  if (!theme.displayName.trim()) {
+    throw new ValidationError("Theme displayName is required");
+  }
+  if (!theme.license.trim()) {
+    throw new ValidationError("Theme license is required");
+  }
+  if (!theme.attribution.trim()) {
+    throw new ValidationError("Theme attribution is required");
+  }
+  for (const pieceKey of REQUIRED_PIECES) {
+    const asset = theme.pieces[pieceKey];
+    if (!asset || asset.kind !== "svg" || !asset.source.trim()) {
+      throw new ThemeError(`Theme "${normalizedName}" is missing SVG asset ${pieceKey}`);
+    }
+  }
+  return {
+    ...theme,
+    name: normalizedName
+  };
+}
+
+// src/themes/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerTheme(theme) {
+  const validatedTheme = validateThemeDefinition(theme);
+  if (registry.has(validatedTheme.name)) {
+    throw new ThemeError(`Theme "${validatedTheme.name}" is already registered`);
+  }
+  registry.set(validatedTheme.name, validatedTheme);
+  return validatedTheme;
+}
+function getTheme(name) {
+  return registry.get(name.trim().toLowerCase());
+}
+
+// src/themes/builtins.ts
+var builtInThemeNames = [
+  "merida",
+  "alpha",
+  "cburnett",
+  "cheq",
+  "leipzig"
+];
+var PIECE_KEYS = [
+  "wK",
+  "wQ",
+  "wR",
+  "wB",
+  "wN",
+  "wP",
+  "bK",
+  "bQ",
+  "bR",
+  "bB",
+  "bN",
+  "bP"
+];
+var initialized = false;
+function assetPath(themeName, pieceKey) {
+  const candidates = [
+    resolve(__dirname, "../../assets/themes", themeName, `${pieceKey}.svg`),
+    resolve(__dirname, "../assets/themes", themeName, `${pieceKey}.svg`),
+    resolve(process.cwd(), "assets/themes", themeName, `${pieceKey}.svg`)
+  ];
+  const match = candidates.find((candidate) => existsSync(candidate));
+  return match ?? candidates[0];
+}
+function createBuiltInTheme(themeName) {
+  return {
+    name: themeName,
+    displayName: themeName[0].toUpperCase() + themeName.slice(1),
+    license: "MIT",
+    attribution: "Project-authored built-in SVG theme",
+    pieces: Object.fromEntries(
+      PIECE_KEYS.map((pieceKey) => [
+        pieceKey,
+        {
+          kind: "svg",
+          source: assetPath(themeName, pieceKey)
+        }
+      ])
+    )
+  };
+}
+function initializeBuiltInThemes() {
+  if (initialized) {
+    return;
+  }
+  for (const themeName of builtInThemeNames) {
+    registerTheme(createBuiltInTheme(themeName));
+  }
+  initialized = true;
+}
+
+// src/themes/resolver.ts
+function resolveTheme({ theme, style }) {
+  initializeBuiltInThemes();
+  if (typeof theme === "object" && theme !== null) {
+    try {
+      return validateThemeDefinition(theme);
+    } catch (error) {
+      if (error instanceof ThemeError) {
+        throw error;
+      }
+      if (error instanceof ValidationError) {
+        throw new ThemeError(error.message, { cause: error });
+      }
+      throw error;
+    }
+  }
+  const requestedName = typeof theme === "string" ? theme : style ?? "merida";
+  const resolvedTheme = getTheme(requestedName);
+  if (!resolvedTheme) {
+    throw new ThemeError(`Unknown theme: ${requestedName}`);
+  }
+  return resolvedTheme;
+}
+
+// src/utils/normalization.ts
+var DEFAULT_SIZE = 480;
+var DEFAULT_PADDING = [0, 0, 0, 0];
+var DEFAULT_COLORS = {
+  lightSquare: "#f0d9b5",
+  darkSquare: "#b58863",
+  highlight: "rgba(255, 206, 0, 0.45)"
+};
+function normalizeColors(colors) {
+  return {
+    lightSquare: colors?.lightSquare ?? DEFAULT_COLORS.lightSquare,
+    darkSquare: colors?.darkSquare ?? DEFAULT_COLORS.darkSquare,
+    highlight: colors?.highlight ?? DEFAULT_COLORS.highlight
+  };
+}
+function normalizeRenderInputs(options) {
+  return {
+    size: validateSize(options.size ?? DEFAULT_SIZE),
+    padding: normalizePadding(options.padding ?? DEFAULT_PADDING),
+    flipped: options.flipped ?? false,
+    theme: resolveTheme({
+      theme: options.theme,
+      style: options.style
+    }),
+    highlightSquares: normalizeHighlights(options.highlightSquares ?? []),
+    colors: normalizeColors(options.colors)
+  };
+}
+
+// src/api/class-api.ts
+var ChessImageGenerator = class {
+  position = null;
+  defaults;
+  highlights = [];
+  constructor(options = {}) {
+    this.defaults = { ...options };
+    normalizeRenderInputs({
+      ...this.defaults,
+      highlightSquares: []
+    });
+  }
+  async loadFEN(fen) {
+    this.position = parseFEN(fen);
+    this.clearHighlights();
+  }
+  async loadPGN(pgn) {
+    this.position = parsePGN(pgn);
+    this.clearHighlights();
+  }
+  async loadBoard(board) {
+    this.position = parseBoardArray(board);
+    this.clearHighlights();
+  }
+  setHighlights(squares) {
+    this.highlights = normalizeHighlights(squares);
+  }
+  clearHighlights() {
+    this.highlights = [];
+  }
+  async toBuffer() {
+    if (!this.position) {
+      throw new ValidationError("No board position loaded");
+    }
+    const renderer = new CanvasPngRenderer();
+    const normalized = normalizeRenderInputs({
+      ...this.defaults,
+      highlightSquares: this.highlights
+    });
+    return renderer.render({
+      board: this.position,
+      theme: normalized.theme,
+      highlights: normalized.highlightSquares,
+      size: normalized.size,
+      padding: normalized.padding,
+      flipped: normalized.flipped,
+      colors: normalized.colors
+    });
+  }
+  async toFile(filePath) {
+    const buffer = await this.toBuffer();
+    await writeBufferToFile(filePath, buffer);
+  }
+};
+
+// src/api/functional-api.ts
+function parseInputPosition(options) {
+  if (typeof options.fen === "string") {
+    return parseFEN(options.fen);
+  }
+  if (typeof options.pgn === "string") {
+    return parsePGN(options.pgn);
+  }
+  if (Array.isArray(options.board)) {
+    return parseBoardArray(options.board);
+  }
+  throw new ValidationError("Exactly one of fen, pgn, or board must be provided");
+}
+async function renderChess(options) {
+  const provided = [
+    typeof options.fen === "string" ? options.fen : void 0,
+    typeof options.pgn === "string" ? options.pgn : void 0,
+    Array.isArray(options.board) ? options.board : void 0
+  ].filter((value) => value !== void 0);
+  if (provided.length !== 1) {
+    throw new ValidationError("Exactly one of fen, pgn, or board must be provided");
+  }
+  const position = parseInputPosition(options);
+  const renderer = new CanvasPngRenderer();
+  const normalized = normalizeRenderInputs(options);
+  return renderer.render({
+    board: position,
+    theme: normalized.theme,
+    highlights: normalized.highlightSquares,
+    size: normalized.size,
+    padding: normalized.padding,
+    flipped: normalized.flipped,
+    colors: normalized.colors
+  });
+}
+export {
+  ChessImageGenerator,
+  IOError,
+  ParseError,
+  RenderError,
+  ThemeError,
+  ValidationError,
+  registerTheme,
+  renderChess
+};
+//# sourceMappingURL=index.js.map