pgn-manager 1.1.0 → 2.2.0

package/README.md

@@ -65,7 +65,6 @@ const headers = manager.headers;
 - `getLastMove()`: Get the last move of the game
 - `getMoveFen(moveOrMoveId: Move | number)`: Get FEN position after move
 - `getParentRav(moveOrMoveId: Move | number)`: Get parent variation for move
-- `getChessJSInstance(moveOrMoveId: Move | number)`: Get or create a ChessJS instance for the position after the specified move
 - `getMoveColor(moveOrMoveId: Move | number)`: Gets the color of the player who made the move ("w" for white or "b" for black)
 
 ## Examples 🎯

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-import { ParsedPGN, Move, Rav, Header } from "pgn-parser";
+import { ShortMove } from "chess.js";
+import * as pgnParser from "pgn-parser";
+import type { ParsedPGN, Move, Rav, Header, Result } from "pgn-parser";
 export declare const FEN_START_POSITION = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 export declare const FEN_EMPTY_POSITION = "8/8/8/8/8/8/8/8";
 declare class PGNManager {
@@ -10,6 +12,8 @@ declare class PGNManager {
     private sortedMoves;
     /** Map of moves to their FEN position strings */
     private moveFen;
+    /** Map of FEN position string to their move object */
+    private fenMove;
     /** Map of moves to their parent variations (or null for mainline) */
     private moveParent;
     /** Map of variations to their parent moves */
@@ -53,7 +57,7 @@ declare class PGNManager {
      * @param moveNumber - The 1-based index of the move
      * @returns The move object at the specified position
      */
-    getMove: (moveNumber: number) => Move;
+    getMove: (moveNumber: number) => pgnParser.Move;
     /**
      * Gets the number of a move in the sequence
      * @param move - The move object
@@ -85,13 +89,13 @@ declare class PGNManager {
      * @returns The first move
      * @throws Error if there are no moves in the game
      */
-    getFirstMove: () => Move;
+    getFirstMove: () => pgnParser.Move;
     /**
      * Gets the last move in the game
      * @returns The last move
      * @throws Error if there are no moves in the game
      */
-    getLastMove: () => any;
+    getLastMove: () => pgnParser.Move;
     /**
      * Gets the FEN string for a specific move
      * @param moveOrId - The move object or move number
@@ -113,5 +117,20 @@ declare class PGNManager {
      * @throws Error if the move parameter is invalid
      */
     getMoveColor: (moveOrId: Move | number) => "w" | "b";
+    /***
+     * Pushes a new move into the game
+     * @param moveId - The ID of the move to push
+     * @param newMove - The move object to add
+     * @param result - The result of the game after this move (default is "*")
+     * @returns The newly created move object
+     * @throws Error if the move parameter is invalid
+     */
+    pushMove: (moveId: number, newMove: ShortMove, result?: Result) => Move;
+    /**
+     * Delete a move and all subsequent moves in its variation from the game
+     * @param moveId - The ID of the move to delete from
+     * @throws Error if the move parameter is invalid
+     */
+    deleteMove: (moveId: number) => void;
 }
 export default PGNManager;

package/dist/index.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FEN_EMPTY_POSITION = exports.FEN_START_POSITION = void 0;
 const ChessJS = require("chess.js");
 const Chess = typeof ChessJS === "function" ? ChessJS : ChessJS.Chess;
-const pgn_parser_1 = require("pgn-parser");
+const pgnParser = require("pgn-parser");
+const utils_1 = require("./utils");
 exports.FEN_START_POSITION = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 exports.FEN_EMPTY_POSITION = "8/8/8/8/8/8/8/8";
 class PGNManager {
@@ -15,6 +16,8 @@ class PGNManager {
     sortedMoves;
     /** Map of moves to their FEN position strings */
     moveFen;
+    /** Map of FEN position string to their move object */
+    fenMove = new Map();
     /** Map of moves to their parent variations (or null for mainline) */
     moveParent;
     /** Map of variations to their parent moves */
@@ -27,11 +30,12 @@ class PGNManager {
      */
     constructor(pgn) {
         this.rawPGN = pgn;
-        this.game = pgn_parser_1.default.parse(pgn + " *")[0];
+        this.game = pgnParser.parse(pgn + " *")[0];
         this.sortedMoves = [];
         this.moveParent = new Map();
         this.ravParent = new Map();
         this.moveFen = new Map();
+        this.fenMove = new Map();
         this.moveColor = new Map();
         this.dfOnGame(this.game);
     }
@@ -41,7 +45,8 @@ class PGNManager {
      */
     dfOnGame = (game) => {
         this.sortedMoves = [];
-        var chessGame = new Chess(exports.FEN_START_POSITION);
+        var chessGame = new Chess(game.headers?.find((h) => h.name.toUpperCase() === "FEN")?.value ||
+            exports.FEN_START_POSITION);
         for (let move of game.moves) {
             this.dfsOnGame(move, game, chessGame);
         }
@@ -69,6 +74,7 @@ class PGNManager {
             !chessGame.move(move.move, { sloppy: true }))
             console.log("Invalid move: " + move.move);
         this.moveFen.set(move, chessGame.fen());
+        this.fenMove.set(chessGame.fen(), move);
         this.moveColor.set(move, chessGame.turn() === "w" ? "b" : "w");
     };
     /**
@@ -224,7 +230,7 @@ class PGNManager {
      */
     getMoveFen = (moveOrId) => {
         const move = typeof moveOrId === "number" ? this.getMove(moveOrId) : moveOrId;
-        if (!move) {
+        if (!move || !this.moveFen.has(move)) {
             throw Error("Invalid 'move' parameter while getting fen");
         }
         let moveFen = this.moveFen.get(move);
@@ -238,7 +244,7 @@ class PGNManager {
      */
     getParentRav = (moveOrId) => {
         const move = typeof moveOrId === "number" ? this.getMove(moveOrId) : moveOrId;
-        if (!move) {
+        if (!move || !this.moveParent.has(move)) {
             throw Error("Invalid 'move' parameter while getting parent rav");
         }
         let parentRav = this.moveParent.get(move);
@@ -252,10 +258,154 @@ class PGNManager {
      */
     getMoveColor = (moveOrId) => {
         const move = typeof moveOrId === "number" ? this.getMove(moveOrId) : moveOrId;
-        if (!move) {
+        if (!move || !this.moveColor.has(move)) {
             throw Error("Invalid 'move' parameter while getting move color");
         }
         return this.moveColor.get(move);
     };
+    /***
+     * Pushes a new move into the game
+     * @param moveId - The ID of the move to push
+     * @param newMove - The move object to add
+     * @param result - The result of the game after this move (default is "*")
+     * @returns The newly created move object
+     * @throws Error if the move parameter is invalid
+     */
+    pushMove = (moveId, newMove, result = "*") => {
+        let chess;
+        let parentRav;
+        let current = null;
+        // 1) Initialize Chess and parent variation
+        if (moveId === 0) {
+            parentRav = this.parsedPGN;
+            const fenHdr = this.headers.find((h) => h.name.toLowerCase() === "fen");
+            const startFen = fenHdr ? fenHdr.value : exports.FEN_START_POSITION;
+            chess = new Chess(startFen);
+        }
+        else {
+            current = this.getMove(moveId);
+            if (!current)
+                throw new Error("Invalid moveId while pushing a new move!");
+            parentRav = this.moveParent.get(current) || this.parsedPGN;
+            chess = new Chess(this.getMoveFen(current));
+        }
+        // 2) Play the SAN move (strict → sloppy)
+        const played = chess.move(newMove, { sloppy: false }) ||
+            chess.move(newMove, { sloppy: true });
+        if (!played)
+            throw new Error("Invalid move");
+        const san = chess.history().slice(-1)[0];
+        const nextToMove = chess.turn(); // 'w' or 'b'
+        // If the FEN already exists, we are trying to add a move that is already played
+        if (this.fenMove.has(chess.fen())) {
+            return this.fenMove.get(chess.fen());
+        }
+        // 3) Build move object with provisional move_number
+        const provisionalNumber = (() => {
+            if (!current) {
+                return 1; // brand‐new mainline
+            }
+            const currNum = current.move_number || this.previousMove(current)?.move_number;
+            const currColor = this.getMoveColor(current);
+            return currColor === "w" ? currNum : currNum + 1;
+        })();
+        const moveObj = {
+            move: san,
+            ravs: undefined,
+            move_number: provisionalNumber,
+            comments: [],
+        };
+        // 4) Insert into structure & flag first‐of‐variation
+        let isFirstOfVariation = false;
+        if (!current) {
+            // brand-new mainline => variation of first move if exists
+            const first = parentRav.moves[0];
+            if (first) {
+                isFirstOfVariation = true;
+                const newRav = { moves: [moveObj], result };
+                first.ravs = first.ravs || [];
+                first.ravs.push(newRav);
+                this.moveParent.set(moveObj, newRav);
+                this.ravParent.set(newRav, first);
+            }
+            else {
+                parentRav.moves.push(moveObj);
+                this.moveParent.set(moveObj, parentRav);
+            }
+        }
+        else {
+            // existing‐move branch
+            const lastInRav = parentRav.moves[parentRav.moves.length - 1];
+            const isContinuation = lastInRav === current;
+            if (!isContinuation) {
+                // new variation off the next move
+                isFirstOfVariation = true;
+                const anchor = this.nextMove(current) || current;
+                anchor.ravs = anchor.ravs || [];
+                const newRav = { moves: [moveObj], result };
+                anchor.ravs.push(newRav);
+                this.moveParent.set(moveObj, newRav);
+                this.ravParent.set(newRav, anchor);
+            }
+            else {
+                // continuation
+                parentRav.moves.push(moveObj);
+                this.moveParent.set(moveObj, parentRav);
+            }
+        }
+        // 5) Conditionally remove move_number
+        // Keep it only if first‐of‐variation OR new move is White to play
+        if (!(isFirstOfVariation || nextToMove === "b")) {
+            delete moveObj.move_number;
+        }
+        // 6) Final bookkeeping
+        this.moveFen.set(moveObj, chess.fen());
+        this.fenMove.set(chess.fen(), moveObj);
+        this.moveColor.set(moveObj, nextToMove === "w" ? "b" : "w");
+        this.rawPGN = (0, utils_1.regeneratePGN)(this.game, this.moveColor);
+        this.dfOnGame(this.game);
+        return moveObj;
+    };
+    /**
+     * Delete a move and all subsequent moves in its variation from the game
+     * @param moveId - The ID of the move to delete from
+     * @throws Error if the move parameter is invalid
+     */
+    deleteMove = (moveId) => {
+        const move = this.getMove(moveId);
+        if (!move) {
+            throw Error("Invalid move");
+        }
+        // delete the move and subsequent moves from the game
+        const parentRav = this.getParentRav(move);
+        const index = parentRav.moves.indexOf(move);
+        const deletedMoves = parentRav.moves.splice(index);
+        // collect all moves and variations that need cleanup
+        const movsToClean = [];
+        const ravsToClean = [];
+        for (const deletedMove of deletedMoves) {
+            movsToClean.push(deletedMove);
+            if (deletedMove.ravs) {
+                for (const rav of deletedMove.ravs) {
+                    ravsToClean.push(rav);
+                }
+            }
+        }
+        // Sort moves by their moveId in decreasing order
+        movsToClean.sort((a, b) => this.getMoveNumber(b) - this.getMoveNumber(a));
+        // clean up all maps at once
+        movsToClean.forEach((move) => {
+            this.moveParent.delete(move);
+            this.fenMove.delete(this.getMoveFen(move));
+            this.moveFen.delete(move);
+            this.moveColor.delete(move);
+        });
+        ravsToClean.forEach((rav) => {
+            this.ravParent.delete(rav);
+        });
+        // update the PGN and rebuild internal state
+        this.rawPGN = (0, utils_1.regeneratePGN)(this.game, this.moveColor);
+        this.dfOnGame(this.game);
+    };
 }
 exports.default = PGNManager;

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "pgn-manager",
-  "version": "1.1.0",
+  "version": "2.2.0",
   "description": "Libraray built on top of chess.js and pgn-parser to load and process PGN files in typescript.",
   "main": "dist/index",
   "typings": "dist/index",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
     "prepublishOnly": "npm run compile",
     "compile": "npm run clean && tsc -p .",
     "watch": "tsc -w -p .",
@@ -32,7 +34,11 @@
   },
   "devDependencies": {
     "@types/chess.js": "^0.11.2",
-    "typescript": "4.5.2"
+    "@types/jest": "^30.0.0",
+    "@types/pgn-parser": "^2.1.0",
+    "jest": "^30.0.4",
+    "ts-jest": "^29.4.0",
+    "typescript": "^5.8.3"
   },
   "files": [
     "dist/index.js",