@react-chess-tools/react-chess-game 0.4.0 → 0.4.2

package/src/utils/__tests__/board.test.ts

@@ -0,0 +1,143 @@
+import { Chess } from "chess.js";
+import { getCustomSquareStyles } from "../board";
+import { getGameInfo } from "../chess";
+
+describe("Board Utilities", () => {
+  describe("getCustomSquareStyles", () => {
+    it("should return empty styles for initial position with no active square", () => {
+      const game = new Chess();
+      const orientation = "w";
+      const info = getGameInfo(game, orientation);
+      const activeSquare = null;
+
+      const styles = getCustomSquareStyles(game, info, activeSquare);
+
+      expect(Object.keys(styles).length).toBe(0);
+    });
+
+    it("should highlight last move squares", () => {
+      const game = new Chess();
+      game.move("e4");
+      game.move("e5");
+      const orientation = "w";
+      const info = getGameInfo(game, orientation);
+      const activeSquare = null;
+
+      const styles = getCustomSquareStyles(game, info, activeSquare);
+
+      expect(styles).toHaveProperty("e7");
+      expect(styles).toHaveProperty("e5");
+      expect(styles.e7).toHaveProperty(
+        "backgroundColor",
+        "rgba(255, 255, 0, 0.5)",
+      );
+      expect(styles.e5).toHaveProperty(
+        "backgroundColor",
+        "rgba(255, 255, 0, 0.5)",
+      );
+    });
+
+    it("should highlight active square", () => {
+      const game = new Chess();
+      const orientation = "w";
+      const info = getGameInfo(game, orientation);
+      const activeSquare = "e2";
+
+      const styles = getCustomSquareStyles(game, info, activeSquare);
+
+      expect(styles).toHaveProperty("e2");
+      expect(styles.e2).toHaveProperty(
+        "backgroundColor",
+        "rgba(255, 255, 0, 0.5)",
+      );
+    });
+
+    it("should highlight destination squares for active square", () => {
+      const game = new Chess();
+      const orientation = "w";
+      const info = getGameInfo(game, orientation);
+      const activeSquare = "e2";
+
+      const styles = getCustomSquareStyles(game, info, activeSquare);
+
+      expect(styles).toHaveProperty("e3");
+      expect(styles).toHaveProperty("e4");
+      expect(styles.e3).toHaveProperty("background");
+      expect(styles.e4).toHaveProperty("background");
+    });
+
+    it("should highlight destination squares with captures differently", () => {
+      const game = new Chess(
+        "rnbqkbnr/ppp1pppp/8/3p4/4P3/8/PPPP1PPP/RNBQKBNR w KQkq - 0 2",
+      );
+      const orientation = "w";
+      const info = getGameInfo(game, orientation);
+      const activeSquare = "e4";
+
+      const styles = getCustomSquareStyles(game, info, activeSquare);
+
+      expect(styles).toHaveProperty("d5");
+      expect(styles.d5.background).toContain("radial-gradient");
+      expect(styles.d5.background).toContain("85%");
+    });
+
+    it("should highlight king in check", () => {
+      // Set up a position where the king is in check
+      const game = new Chess(
+        "rnbqkbnr/ppp2ppp/8/3pp3/4P3/5Q2/PPPP1PPP/RNB1KBNR b KQkq - 1 3",
+      );
+
+      // We need to manually set the isCheck flag in the info object
+      const orientation = "b";
+      const info = getGameInfo(game, orientation);
+      const modifiedInfo = { ...info, isCheck: true };
+      const activeSquare = null;
+
+      const styles = getCustomSquareStyles(game, modifiedInfo, activeSquare);
+
+      // Black king on e8 should be highlighted as in check
+      expect(styles).toHaveProperty("e8");
+      expect(styles.e8).toHaveProperty(
+        "backgroundColor",
+        "rgba(255, 0, 0, 0.5)",
+      );
+    });
+
+    it("should combine multiple style effects", () => {
+      const game = new Chess(
+        "rnbqkbnr/ppp2ppp/8/3pp3/4P3/5Q2/PPPP1PPP/RNB1KBNR b KQkq - 1 3",
+      );
+      game.move("Ke7");
+      const orientation = "w";
+      const info = getGameInfo(game, orientation);
+      const activeSquare = "f3";
+
+      const styles = getCustomSquareStyles(game, info, activeSquare);
+
+      expect(styles).toHaveProperty("f3");
+      expect(styles.f3).toHaveProperty(
+        "backgroundColor",
+        "rgba(255, 255, 0, 0.5)",
+      );
+
+      expect(styles).toHaveProperty("e8");
+      expect(styles).toHaveProperty("e7");
+
+      expect(Object.keys(styles).length).toBeGreaterThan(3);
+    });
+
+    it("should highlight empty destination squares differently from capture squares", () => {
+      const game = new Chess();
+      const orientation = "w";
+      const info = getGameInfo(game, orientation);
+      const activeSquare = "b1";
+
+      const styles = getCustomSquareStyles(game, info, activeSquare);
+
+      expect(styles).toHaveProperty("a3");
+      expect(styles).toHaveProperty("c3");
+      expect(styles.a3.background).toContain("25%");
+      expect(styles.c3.background).toContain("25%");
+    });
+  });
+});

package/src/utils/__tests__/chess.test.ts

@@ -0,0 +1,198 @@
+import { Chess, Color } from "chess.js";
+import {
+  cloneGame,
+  getGameInfo,
+  isLegalMove,
+  requiresPromotion,
+  getDestinationSquares,
+  getCurrentFen,
+} from "../chess";
+
+describe("Chess Utilities", () => {
+  describe("cloneGame", () => {
+    it("should create a clone with the same state", () => {
+      const game = new Chess();
+      game.move("e4");
+      game.move("e5");
+
+      const clone = cloneGame(game);
+
+      expect(clone.fen()).toEqual(game.fen());
+      expect(clone.history()).toEqual(game.history());
+      expect(clone).not.toBe(game); // Different instances
+    });
+  });
+
+  describe("getGameInfo", () => {
+    it("should return correct game info for initial position", () => {
+      const game = new Chess();
+      const orientation: Color = "w";
+
+      const info = getGameInfo(game, orientation);
+
+      expect(info.turn).toBe("w");
+      expect(info.isPlayerTurn).toBe(true);
+      expect(info.isOpponentTurn).toBe(false);
+      expect(info.moveNumber).toBe(0);
+      expect(info.lastMove).toBeUndefined();
+      expect(info.isCheck).toBe(false);
+      expect(info.isCheckmate).toBe(false);
+      expect(info.isDraw).toBe(false);
+      expect(info.isGameOver).toBe(false);
+    });
+
+    it("should return correct game info after moves", () => {
+      const game = new Chess();
+      game.move("e4");
+      game.move("e5");
+      const orientation: Color = "w";
+
+      const info = getGameInfo(game, orientation);
+
+      expect(info.turn).toBe("w");
+      expect(info.isPlayerTurn).toBe(true);
+      expect(info.isOpponentTurn).toBe(false);
+      expect(info.moveNumber).toBe(2);
+      expect(info.lastMove).toEqual(
+        expect.objectContaining({
+          from: "e7",
+          to: "e5",
+          piece: "p",
+          color: "b",
+        }),
+      );
+    });
+
+    it("should return correct game info for checkmate position", () => {
+      const game = new Chess();
+      // Scholar's mate
+      game.move("e4");
+      game.move("e5");
+      game.move("Qh5");
+      game.move("Nc6");
+      game.move("Bc4");
+      game.move("Nf6");
+      game.move("Qxf7");
+
+      const whiteInfo = getGameInfo(game, "w");
+      expect(whiteInfo.isCheckmate).toBe(true);
+      expect(whiteInfo.isGameOver).toBe(true);
+      expect(whiteInfo.hasPlayerWon).toBe(true);
+      expect(whiteInfo.hasPlayerLost).toBe(false);
+
+      const blackInfo = getGameInfo(game, "b");
+      expect(blackInfo.hasPlayerWon).toBe(false);
+      expect(blackInfo.hasPlayerLost).toBe(true);
+    });
+  });
+
+  describe("isLegalMove", () => {
+    it("should return true for legal moves", () => {
+      const game = new Chess();
+
+      expect(isLegalMove(game, "e2e4")).toBe(true);
+      expect(isLegalMove(game, "g1f3")).toBe(true);
+    });
+
+    it("should return false for illegal moves", () => {
+      const game = new Chess();
+
+      expect(isLegalMove(game, "e2e5")).toBe(false);
+      expect(isLegalMove(game, "e7e5")).toBe(false); // Black's move, but white to move
+    });
+  });
+
+  describe("requiresPromotion", () => {
+    it("should return true for moves requiring promotion", () => {
+      const game = new Chess("8/P7/7k/8/8/8/8/7K w - - 0 1");
+
+      expect(requiresPromotion(game, "a7a8")).toBe(true);
+    });
+
+    it("should return false for moves not requiring promotion", () => {
+      const game = new Chess();
+
+      expect(requiresPromotion(game, "e2e4")).toBe(false);
+    });
+
+    it("should return false for illegal moves", () => {
+      const game = new Chess();
+
+      expect(requiresPromotion(game, "e2e5")).toBe(false);
+    });
+
+    it("throws if game is not passed", () => {
+      expect(() =>
+        requiresPromotion(null as unknown as Chess, "e2e4"),
+      ).toThrow();
+    });
+  });
+
+  describe("getDestinationSquares", () => {
+    it("should return correct destination squares for a piece", () => {
+      const game = new Chess();
+
+      const e2Destinations = getDestinationSquares(game, "e2");
+      expect(e2Destinations).toContain("e3");
+      expect(e2Destinations).toContain("e4");
+      expect(e2Destinations.length).toBe(2);
+
+      const g1Destinations = getDestinationSquares(game, "g1");
+      expect(g1Destinations).toContain("f3");
+      expect(g1Destinations).toContain("h3");
+      expect(g1Destinations.length).toBe(2);
+    });
+
+    it("should return empty array for squares with no legal moves", () => {
+      const game = new Chess();
+
+      expect(getDestinationSquares(game, "e3")).toEqual([]);
+    });
+  });
+
+  describe("getCurrentFen", () => {
+    it("should return the initial position when moveIndex is -1", () => {
+      const game = new Chess();
+      game.move("e4");
+
+      const initialFen =
+        "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+      expect(getCurrentFen(initialFen, game, -1)).toBe(initialFen);
+    });
+
+    it("should return the FEN after specific moves", () => {
+      const game = new Chess();
+      const initialFen = game.fen();
+
+      game.move("e4");
+      game.move("e5");
+      game.move("Nf3");
+
+      // After 1 move (e4)
+      const fenAfterOneMove = getCurrentFen(initialFen, game, 0);
+      expect(fenAfterOneMove).toMatch(
+        /rnbqkbnr\/pppppppp\/8\/8\/4P3\/8\/PPPP1PPP\/RNBQKBNR b KQkq/,
+      );
+
+      // After 2 moves (e4, e5)
+      const fenAfterTwoMoves = getCurrentFen(initialFen, game, 1);
+      expect(fenAfterTwoMoves).toMatch(
+        /rnbqkbnr\/pppp1ppp\/8\/4p3\/4P3\/8\/PPPP1PPP\/RNBQKBNR w KQkq/,
+      );
+
+      // After 3 moves (e4, e5, Nf3)
+      const fenAfterThreeMoves = getCurrentFen(initialFen, game, 2);
+      expect(fenAfterThreeMoves).toMatch(
+        /rnbqkbnr\/pppp1ppp\/8\/4p3\/4P3\/5N2\/PPPP1PPP\/RNBQKB1R b KQkq/,
+      );
+    });
+
+    it("should use provided FEN as starting position", () => {
+      const customFen =
+        "1r2r1k1/pp3pbp/1qp3p1/2B5/2BP2b1/Q1n2N2/P4PPP/3R1K1R b - - 0 17";
+      const game = new Chess();
+
+      expect(getCurrentFen(customFen, game, -1)).toBe(customFen);
+    });
+  });
+});

package/src/utils/board.ts

@@ -34,8 +34,8 @@ export const getCustomSquareStyles = (
     destinationSquares.forEach((square) => {
       customSquareStyles[square] = {
         background:
-          game.get(square) && game.get(square).color !== turn
-            ? "radial-gradient(circle, rgba(0,0,0,.1) 85%, transparent 85%)"
+          game.get(square) && game.get(square)?.color !== turn
+            ? "radial-gradient(circle, rgba(1, 0, 0, 0.1) 85%, transparent 85%)"
             : "radial-gradient(circle, rgba(0,0,0,.1) 25%, transparent 25%)",
       };
     });

package/src/utils/chess.ts

@@ -33,8 +33,8 @@ export const getGameInfo = (game: Chess, orientation: Color) => {
   const isThreefoldRepetition = game.isThreefoldRepetition();
   const isInsufficientMaterial = game.isInsufficientMaterial();
   const isGameOver = game.isGameOver();
-  const hasPlayerWon = isPlayerTurn && isGameOver && !isDraw;
-  const hasPlayerLost = isOpponentTurn && isGameOver && !isDraw;
+  const hasPlayerWon = isOpponentTurn && isGameOver && !isDraw;
+  const hasPlayerLost = isPlayerTurn && isGameOver && !isDraw;
   const isDrawn = game.isDraw();
   return {
     turn,
@@ -74,14 +74,17 @@ export const requiresPromotion = (
   game: Chess,
   move: Parameters<Chess["move"]>[0],
 ) => {
-  const copy = cloneGame(game);
-  const result = copy.move(move);
+  try {
+    const copy = cloneGame(game);
+    const result = copy.move(move);
 
-  if (result === null) {
-    return false;
+    return result.flags.indexOf("p") !== -1;
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("Invalid move")) {
+      return false;
+    }
+    throw e;
   }
-
-  return result.flags.indexOf("p") !== -1;
 };
 
 export const getDestinationSquares = (game: Chess, square: Square) => {
@@ -101,6 +104,7 @@ export const getCurrentFen = (
     }
   } else {
     const moves = game.history().slice(0, currentMoveIndex + 1);
+
     if (fen) {
       tempGame.load(fen);
     }