pgn-manager 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Harsh Kumar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# pgn-manager

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import { ParsedPGN, Move, Rav, Header } 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 {
+    private rawPGN;
+    private game;
+    private sortedMoves;
+    private moveFen;
+    private moveParent;
+    private ravParent;
+    constructor(pgn: string);
+    private dfOnGame;
+    private dfsOnGame;
+    get pgn(): string;
+    get parsedPGN(): ParsedPGN;
+    get headers(): Array<Header>;
+    getMove: (moveNumber: number) => Move;
+    getMoveNumber: (move: Move) => number;
+    nextMove: (move: Move | undefined) => Move;
+    hasNextMove: (move: Move) => boolean;
+    previousMove: (move: Move) => Move | undefined;
+    getFirstMove: () => Move;
+    getLastMove: () => any;
+    getMoveFen: (move: Move) => string;
+    getParentRav: (move: Move) => Rav | null;
+}
+export default PGNManager;

package/dist/index.js

@@ -0,0 +1,152 @@
+"use strict";
+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");
+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 {
+    rawPGN;
+    game;
+    sortedMoves;
+    moveFen;
+    moveParent;
+    ravParent;
+    constructor(pgn) {
+        this.rawPGN = pgn;
+        this.game = pgn_parser_1.default.parse(pgn + " *")[0];
+        this.sortedMoves = [];
+        this.moveParent = new Map();
+        this.ravParent = new Map();
+        this.moveFen = new Map();
+        this.dfOnGame(this.game);
+    }
+    dfOnGame = (game) => {
+        this.sortedMoves = [];
+        var chessGame = new Chess(exports.FEN_START_POSITION);
+        for (let move of game.moves) {
+            this.dfsOnGame(move, game, chessGame);
+        }
+    };
+    dfsOnGame = (move, parent, chessGame) => {
+        this.sortedMoves.push(move);
+        this.moveParent.set(move, parent);
+        if (move.ravs) {
+            for (let rav of move.ravs) {
+                this.ravParent.set(rav, move);
+                let newVarChessGame = new Chess(chessGame.fen());
+                for (let ravMove of rav.moves) {
+                    this.dfsOnGame(ravMove, rav, newVarChessGame);
+                }
+            }
+        }
+        // move only after variations are processed
+        if (!chessGame.move(move.move, { sloppy: false }) &&
+            !chessGame.move(move.move, { sloppy: true }))
+            console.log("Invalid move: " + move.move);
+        this.moveFen.set(move, chessGame.fen());
+    };
+    get pgn() {
+        return this.rawPGN;
+    }
+    get parsedPGN() {
+        return this.game;
+    }
+    get headers() {
+        if (!this.game || !this.game.headers)
+            return [];
+        return this.game.headers;
+    }
+    getMove = (moveNumber) => {
+        let move = this.sortedMoves[moveNumber - 1];
+        return move;
+    };
+    getMoveNumber = (move) => {
+        return this.sortedMoves.indexOf(move) + 1;
+    };
+    nextMove = (move) => {
+        if (!move) {
+            if (this.sortedMoves.length == 0) {
+                throw Error("No moves in game");
+            }
+            return this.sortedMoves[0];
+        }
+        if (move == this.game.moves[this.game.moves.length - 1] ||
+            move === this.sortedMoves[this.sortedMoves.length - 1]) {
+            return move;
+        }
+        let parentRav = this.moveParent.get(move);
+        let tempNextMove = this.getMove(this.getMoveNumber(move) + 1);
+        if (parentRav) {
+            let indexInParent = parentRav.moves.indexOf(move);
+            if (indexInParent == parentRav.moves.length - 1) {
+                let superParent = this.ravParent.get(parentRav);
+                if (superParent) {
+                    tempNextMove = this.nextMove(superParent);
+                }
+            }
+            else {
+                tempNextMove = parentRav.moves[indexInParent + 1];
+            }
+        }
+        return tempNextMove;
+    };
+    hasNextMove = (move) => {
+        return !move || this.nextMove(move) !== move;
+    };
+    previousMove = (move) => {
+        if (!move) {
+            if (this.sortedMoves.length == 0) {
+                throw Error("No moves in game");
+            }
+            throw Error("Invalid 'move' parameter while getting previous move");
+        }
+        let currentMoveNumber = this.getMoveNumber(move);
+        if (currentMoveNumber == 0) {
+            return undefined;
+        }
+        let parentRav = this.moveParent.get(move);
+        let tempPrevMove = this.getMove(currentMoveNumber - 1);
+        if (parentRav) {
+            let indexInParent = parentRav.moves.indexOf(move);
+            if (indexInParent == 0) {
+                let superParent = this.ravParent.get(parentRav);
+                if (superParent) {
+                    tempPrevMove = superParent;
+                }
+            }
+            else {
+                tempPrevMove = parentRav.moves[indexInParent - 1];
+            }
+        }
+        return tempPrevMove;
+    };
+    getFirstMove = () => {
+        if (this.sortedMoves.length == 0) {
+            throw Error("No moves in game");
+        }
+        return this.sortedMoves[0];
+    };
+    getLastMove = () => {
+        if (this.sortedMoves.length == 0) {
+            throw Error("No moves in game");
+        }
+        return this.game.moves[this.game.moves.length - 1];
+    };
+    getMoveFen = (move) => {
+        if (!move) {
+            throw Error("Invalid 'move' parameter while getting fen");
+        }
+        let moveFen = this.moveFen.get(move);
+        return moveFen ? moveFen : exports.FEN_EMPTY_POSITION;
+    };
+    getParentRav = (move) => {
+        if (!move) {
+            throw Error("Invalid 'move' parameter while getting parent rav");
+        }
+        let parentRav = this.moveParent.get(move);
+        return parentRav ? parentRav : null;
+    };
+}
+exports.default = PGNManager;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "pgn-manager",
+  "version": "1.0.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",
+    "prepublishOnly": "npm run compile",
+    "compile": "npm run clean && tsc -p .",
+    "watch": "tsc -w -p .",
+    "clean": "rm -rf dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hadron43/pgn-manager.git"
+  },
+  "keywords": [
+    "Chess",
+    "PGN",
+    "Portal",
+    "Game",
+    "Notation"
+  ],
+  "author": "Harsh Kumar <hadron43@yahoo.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/hadron43/pgn-manager/issues"
+  },
+  "homepage": "https://github.com/hadron43/pgn-manager#readme",
+  "devDependencies": {
+    "chess.js": "0.12.0",
+    "pgn-parser": "2.1.0",
+    "typescript": "4.5.2"
+  },
+  "files": [
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/lib"
+  ]
+}