pgn-manager 2.0.0 → 2.2.0

package/dist/index.d.ts

@@ -12,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 */

package/dist/index.js

@@ -16,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 */
@@ -33,6 +35,7 @@ class PGNManager {
         this.moveParent = new Map();
         this.ravParent = new Map();
         this.moveFen = new Map();
+        this.fenMove = new Map();
         this.moveColor = new Map();
         this.dfOnGame(this.game);
     }
@@ -42,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);
         }
@@ -70,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");
     };
     /**
@@ -267,56 +272,99 @@ class PGNManager {
      * @throws Error if the move parameter is invalid
      */
     pushMove = (moveId, newMove, result = "*") => {
-        const currentMove = this.getMove(moveId);
-        // check if it's a valid move
-        const chess = new Chess(this.getMoveFen(currentMove));
-        if (!chess.move(newMove)) {
-            throw Error("Invalid move");
+        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));
         }
-        // check if this is a new variation
-        let isNewVariation = false;
-        const parentRav = this.getParentRav(currentMove);
-        if (parentRav.moves[parentRav.moves.length - 1] != currentMove) {
-            isNewVariation = true;
+        // 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());
         }
-        // add the move to the game
-        let move = undefined;
-        if (isNewVariation) {
-            move = {
-                move: chess.history().slice(-1)[0],
-                ravs: undefined,
-                move_number: currentMove.move_number,
-                comments: [],
-            };
-            const newVar = {
-                moves: [move],
-                result,
-            };
-            currentMove.ravs.push(newVar);
-            // update class variables
-            this.moveParent.set(move, newVar);
-            this.ravParent.set(newVar, currentMove);
-            this.moveFen.set(move, chess.fen());
-            this.moveColor.set(move, this.getMoveColor(currentMove));
+        // 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 {
-            move = {
-                move: chess.history().slice(-1)[0],
-                ravs: undefined,
-                move_number: this.getMoveColor(currentMove) === "w"
-                    ? undefined
-                    : currentMove.move_number + 1,
-                comments: [],
-            };
-            parentRav.moves.push(move);
-            // update class variables
-            this.moveParent.set(move, parentRav);
-            this.moveFen.set(move, chess.fen());
-            this.moveColor.set(move, this.getMoveColor(currentMove) === "w" ? "b" : "w");
+            // 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 move;
+        return moveObj;
     };
     /**
      * Delete a move and all subsequent moves in its variation from the game
@@ -348,6 +396,7 @@ class PGNManager {
         // 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);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgn-manager",
-  "version": "2.0.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",