chess-snap 1.0.0

package/dist/src/renderer.js

@@ -0,0 +1,145 @@
+import { createCanvas, loadImage } from '@napi-rs/canvas';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const _filename = fileURLToPath(import.meta.url);
+const _dirname = dirname(_filename);
+import { cols, filePaths } from './config.js';
+import * as fs from 'fs/promises';
+const imageCache = new Map();
+/**
+ * Ensures the piece image for a given style is loaded into memory exactly once.
+ */
+async function getPieceImage(style, pieceKey) {
+    const cacheKey = `${style}_${pieceKey}`;
+    if (imageCache.has(cacheKey)) {
+        return imageCache.get(cacheKey);
+    }
+    const fileName = filePaths[pieceKey];
+    if (!fileName)
+        throw new Error(`Unknown piece key: ${pieceKey}`);
+    const imgPath = resolve(_dirname, `../src/assets/pieces/${style}/${fileName}.png`);
+    try {
+        const image = await loadImage(imgPath);
+        imageCache.set(cacheKey, image);
+        return image;
+    }
+    catch (err) {
+        throw new Error(`Failed to load piece image from ${imgPath}: ${err}`);
+    }
+}
+/**
+ * Renders the algebraic notations (A-H, 1-8) around the board.
+ */
+function drawNotations(ctx, size, flipped, light, dark, padding, notationStyle, notationColor) {
+    const paddingTop = padding[0];
+    const paddingLeft = padding[3];
+    const paddingBottom = padding[2];
+    const paddingRight = padding[1];
+    const squareSize = size / 8;
+    const fontSize = Math.max(16, Math.floor(squareSize / 3.5));
+    ctx.font = `bold ${fontSize}px sans-serif`;
+    ctx.textBaseline = 'top';
+    const rows = flipped ? [1, 2, 3, 4, 5, 6, 7, 8] : [8, 7, 6, 5, 4, 3, 2, 1];
+    const columns = flipped ? [...cols].reverse() : cols;
+    for (let i = 0; i < 8; i++) {
+        const ySquare = (squareSize * i) + paddingTop;
+        const xSquare = (squareSize * i) + paddingLeft;
+        if (notationStyle === 'inside') {
+            const isLightSquareForNumber = (i % 2 === 0);
+            ctx.fillStyle = notationColor || (isLightSquareForNumber ? dark : light);
+            ctx.lineWidth = 1.5;
+            ctx.strokeStyle = notationColor ? "rgba(0,0,0,0.5)" : (isLightSquareForNumber ? light : dark);
+            ctx.strokeText(rows[i].toString(), paddingLeft + 4, ySquare + 4);
+            ctx.fillText(rows[i].toString(), paddingLeft + 4, ySquare + 4);
+            const isLightSquareForLetter = (i % 2 !== 0);
+            ctx.fillStyle = notationColor || (isLightSquareForLetter ? dark : light);
+            const textWidth = ctx.measureText(columns[i]).width;
+            const letterX = xSquare + squareSize - textWidth - 2;
+            const letterY = size - fontSize - 2 + paddingTop;
+            ctx.lineWidth = 1.5;
+            ctx.strokeStyle = notationColor ? "rgba(0,0,0,0.5)" : (isLightSquareForLetter ? light : dark);
+            ctx.strokeText(columns[i], letterX, letterY);
+            ctx.fillText(columns[i], letterX, letterY);
+        }
+        else {
+            ctx.fillStyle = notationColor || dark;
+            ctx.textBaseline = 'middle';
+            ctx.textAlign = 'center';
+            const numberY = ySquare + (squareSize / 2);
+            ctx.fillText(rows[i].toString(), paddingLeft / 2, numberY);
+            const letterX = xSquare + (squareSize / 2);
+            const letterY = (paddingTop / 2) - 4;
+            ctx.fillText(columns[i], letterX, letterY);
+            ctx.textBaseline = 'top';
+            ctx.textAlign = 'left';
+        }
+    }
+}
+/**
+ * The core buffer generator function.
+ */
+export async function generateBoardBuffer(chess, options, highlightedSquares) {
+    const canvasWidth = options.size + options.padding[1] + options.padding[3];
+    const canvasHeight = options.size + options.padding[0] + options.padding[2];
+    const canvas = createCanvas(canvasWidth, canvasHeight);
+    const ctx = canvas.getContext('2d');
+    ctx.fillStyle = options.light;
+    ctx.fillRect(0, 0, canvasWidth, canvasHeight);
+    const squareSize = options.size / 8;
+    const paddingTop = options.padding[0];
+    const paddingLeft = options.padding[3];
+    const rowFn = options.flipped ? (r) => r + 1 : (r) => 8 - r;
+    const colFn = options.flipped ? (c) => c : (c) => 7 - c;
+    for (let i = 0; i < 8; i++) {
+        for (let j = 0; j < 8; j++) {
+            const coordCol = cols[colFn(j)];
+            const coordRow = rowFn(i);
+            const coords = `${coordCol}${coordRow}`;
+            const x = (squareSize * (7 - j)) + paddingLeft;
+            const y = (squareSize * i) + paddingTop;
+            if ((i + j) % 2 !== 0) {
+                ctx.fillStyle = options.dark;
+                ctx.fillRect(x, y, squareSize, squareSize);
+            }
+            if (highlightedSquares.includes(coords)) {
+                ctx.fillStyle = options.highlight;
+                ctx.fillRect(x, y, squareSize, squareSize);
+            }
+            const piece = chess.get(coords);
+            if (piece) {
+                const pieceKey = `${piece.color}${piece.type}`;
+                try {
+                    const img = await getPieceImage(options.style, pieceKey);
+                    ctx.drawImage(img, x, y, squareSize, squareSize);
+                }
+                catch (e) {
+                    console.error(`Missing piece image for: ${pieceKey} in style ${options.style}`);
+                }
+            }
+        }
+    }
+    if (options.notationStyle === 'outside') {
+        ctx.lineWidth = 2;
+        ctx.strokeStyle = options.dark;
+        ctx.strokeRect(paddingLeft, paddingTop, options.size, options.size);
+    }
+    if (options.notations) {
+        drawNotations(ctx, options.size, options.flipped, options.light, options.dark, options.padding, options.notationStyle, options.notationColor);
+    }
+    const format = options.format;
+    const quality = options.quality;
+    const mimeType = `image/${format}`;
+    if (format === 'jpeg' || format === 'webp') {
+        return canvas.toBuffer(mimeType, quality);
+    }
+    else {
+        return canvas.toBuffer('image/png');
+    }
+}
+/**
+ * Helper to write a buffer to file securely.
+ */
+export async function writePNG(buffer, filePath) {
+    await fs.writeFile(filePath, buffer);
+    return filePath;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,27 @@
+export type PieceStyle = 'neo' | 'glass' | 'wood' | 'game_room' | 'merida' | 'alpha' | 'cheq' | 'cburnett' | 'game_room_gothic' | 'game_room_space' | 'leipzig' | 'neo_wood';
+export interface ChessImageOptions {
+    /** Pixel size of the generated board (e.g. 720) */
+    size?: number;
+    /** Padding around the board [top, right, bottom, left] */
+    padding?: [number, number, number, number];
+    /** Color of light squares */
+    light?: string;
+    /** Color of dark squares */
+    dark?: string;
+    /** Color of highlighted squares */
+    highlight?: string;
+    /** Desired style of standard pieces */
+    style?: PieceStyle;
+    /** View the board from Black's perspective */
+    flipped?: boolean;
+    /** Draw algebraic notations (A-H, 1-8) around the board */
+    notations?: boolean;
+    /** Custom color for the notation texts */
+    notationColor?: string;
+    /** Placement of the notations */
+    notationStyle?: 'inside' | 'outside';
+    /** Image output format (png, jpeg, webp) */
+    format?: 'png' | 'jpeg' | 'webp';
+    /** Image quality (0-100) for jpeg and webp formats */
+    quality?: number;
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+export type PieceStyle = 'neo' | 'glass' | 'wood' | 'game_room' | 'merida' | 'alpha' | 'cheq' | 'cburnett' | 'game_room_gothic' | 'game_room_space' | 'leipzig' | 'neo_wood';
+export interface ChessImageOptions {
+    /** Pixel size of the generated board (e.g. 720) */
+    size?: number;
+    /** Padding around the board [top, right, bottom, left] */
+    padding?: [number, number, number, number];
+    /** Color of light squares */
+    light?: string;
+    /** Color of dark squares */
+    dark?: string;
+    /** Color of highlighted squares */
+    highlight?: string;
+    /** Desired style of standard pieces */
+    style?: PieceStyle;
+    /** View the board from Black's perspective */
+    flipped?: boolean;
+    /** Draw algebraic notations (A-H, 1-8) around the board */
+    notations?: boolean;
+    /** Custom color for the notation texts */
+    notationColor?: string;
+    /** Placement of the notations */
+    notationStyle?: 'inside' | 'outside';
+    /** Image output format (png, jpeg, webp) */
+    format?: 'png' | 'jpeg' | 'webp';
+    /** Image quality (0-100) for jpeg and webp formats */
+    quality?: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "chess-snap",
+  "version": "1.0.0",
+  "description": "Generate high-quality Chess Boards (like chess.com & lichess) through FEN, PGN & Arrays using Napi-RS.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --experimental-test-coverage --test --loader ts-node/esm tests/index.test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "src/assets"
+  ],
+  "keywords": [
+    "chess",
+    "board",
+    "generator",
+    "image",
+    "canvas",
+    "napi",
+    "fen",
+    "pgn",
+    "lichess",
+    "chess.com",
+    "snapshot"
+  ],
+  "author": "Carlyle Katto",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kogakisaki/chess-snap.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@napi-rs/canvas": "^0.1.97",
+    "chess.js": "^1.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.2"
+  }
+}