cm-chess 2.3.4 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cm-chess",
-  "version": "2.3.4",
+  "version": "2.4.0",
   "description": "Like chess.js, but in ES6 and can handle variations (tree-structured move history)",
   "main": "./src/cm-chess/Chess.js",
   "scripts": {
@@ -24,11 +24,11 @@
   },
   "homepage": "https://github.com/shaack/cm-chess#readme",
   "dependencies": {
-    "chess.mjs": "^1.2.0",
+    "chess.mjs": "^1.3.1",
     "cm-pgn": "^2.1.9",
     "modrator": "^1.2.1"
   },
   "devDependencies": {
-    "teevi": "^2.1.11"
+    "teevi": "^2.2.2"
   }
 }

package/src/cm-chess/Chess.js

@@ -5,7 +5,7 @@
  */
 import {Pgn} from "../../lib/cm-pgn/Pgn.js"
 import {TAGS} from "../../lib/cm-pgn/Header.js"
-import {Chess as ChessJs} from "../../lib/chess.mjs/Chess.js"
+import {Chess as ChessJs, SQUARES} from "../../lib/chess.mjs/Chess.js"
 
 export const PIECES = {
     p: {name: "pawn", value: 1},
@@ -26,6 +26,21 @@ export const FEN = {
     start: "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
 }
 
+export const EVENT_TYPE = {
+    illegalMove: "illegalMove",
+    legalMove: "legalMove",
+    undoMove: "undoMove",
+    initialized: "initialized"
+}
+
+function publishEvent(observers, eventType, data = {}) {
+    for (const observer of observers) {
+        setTimeout(() => {
+            observer(eventType, data)
+        })
+    }
+}
+
 /**
  * Like chess.js, but handles variations and is written in ES5
  * Uses chess.js for validation and cm-pgn for the history and PGN header
@@ -33,12 +48,13 @@ export const FEN = {
 export class Chess {
 
     constructor(fenOrProps = FEN.start) {
-        if(typeof fenOrProps === "string") {
+        this.observers = []
+        if (typeof fenOrProps === "string") {
             this.load(fenOrProps)
         } else {
-            if(fenOrProps.fen) {
+            if (fenOrProps.fen) {
                 this.load(fenOrProps.fen)
-            } else if(fenOrProps.pgn) {
+            } else if (fenOrProps.pgn) {
                 this.loadPgn(fenOrProps.pgn)
             } else {
                 this.load(FEN.start)
@@ -49,14 +65,11 @@ export class Chess {
     /**
      * @returns {string} the FEN of the last move, or the setUpFen(), if no move was made.
      */
-    fen() {
-        const lastMove = this.lastMove()
-        if (lastMove) {
-            return lastMove.fen
-        } else if (this.setUpFen()) {
-            return this.setUpFen()
+    fen(move = this.lastMove()) {
+        if (move) {
+            return move.fen
         } else {
-            return FEN.start
+            return this.setUpFen()
         }
     }
 
@@ -169,6 +182,7 @@ export class Chess {
         } else {
             throw Error("Invalid fen " + fen)
         }
+        publishEvent(this.observers, EVENT_TYPE.initialized, {fen: fen})
     }
 
     /**
@@ -178,6 +192,7 @@ export class Chess {
      */
     loadPgn(pgn) {
         this.pgn = new Pgn(pgn)
+        publishEvent(this.observers, EVENT_TYPE.initialized, {pgn: pgn})
     }
 
     /**
@@ -189,12 +204,40 @@ export class Chess {
      */
     move(move, previousMove = undefined, sloppy = true) {
         try {
-            return this.pgn.history.addMove(move, previousMove, sloppy)
+            const moveResult = this.pgn.history.addMove(move, previousMove, sloppy)
+            publishEvent(this.observers, EVENT_TYPE.legalMove, {move: move, previousMove: previousMove})
+            return moveResult
         } catch (e) {
+            publishEvent(this.observers, EVENT_TYPE.illegalMove, {move: move, previousMove: previousMove})
             return null
         }
     }
 
+    /**
+     * Return all valid moves
+     * @param options {{ square: "e2", piece: "n", verbose: true }}
+     * Fields with { verbose: true }
+     * - `color` indicates the color of the moving piece (w or b).
+     * - `from` and `to` fields are from and to squares in algebraic notation.
+     * - `piece`, `captured`, and `promotion` fields contain the lowercase representation of the applicable piece (pnbrqk). The captured and promotion fields are only present when the move is a valid capture or promotion.
+     * - `san` is the move in Standard Algebraic Notation (SAN).
+     * - `flags` field contains one or more of the string values:
+     *      n - a non-capture
+     *      b - a pawn push of two squares
+     *      e - an en passant capture
+     *      c - a standard capture
+     *      p - a promotion
+     *      k - kingside castling
+     *      q - queenside castling
+     *   A flags value of pc would mean that a pawn captured a piece on the 8th rank and promoted.
+     * @param previousMove
+     * @returns {{}}
+     */
+    moves(options = undefined, previousMove = this.lastMove()) {
+        const chessJs = new ChessJs(this.fen(previousMove))
+        return chessJs.moves(options)
+    }
+
     /**
      * Don't make a move, just validate, if it would be a correct move
      * @param move
@@ -231,7 +274,7 @@ export class Chess {
         const chessJs = move ? new ChessJs(move.fen) : new ChessJs()
         let result = []
         for (let i = 0; i < 64; i++) {
-            const square = chessJs.SQUARES[i]
+            const square = SQUARES[i]
             const piece = chessJs.get(square)
             if (piece) {
                 piece.square = square
@@ -277,6 +320,7 @@ export class Chess {
             return element.ply === move.ply
         })
         move.variation = move.variation.splice(index)
+        publishEvent(this.observers, EVENT_TYPE.undoMove, {move: move})
     }
 
     plyCount() {
@@ -284,12 +328,14 @@ export class Chess {
     }
 
     fenOfPly(plyNumber) {
-        if(plyNumber > 0) {
+        if (plyNumber > 0) {
             return this.history()[plyNumber - 1].fen
         } else {
             return this.setUpFen()
         }
     }
 
-
+    addObserver(callback) {
+        this.observers.push(callback)
+    }
 }

package/test/TestChess.js

@@ -217,7 +217,31 @@ describe("Chess", function () {
         assert.notEqual(chess.validateMove("Nf3"), null)
         assert.equal(chess.validateMove("xyz"), null)
         assert.equal(chess.validateMove("e6"), null)
+    })
 
+    it("should publish events", function() {
+        return new Promise((resolve, reject) => {
+            const chess = new Chess()
+            chess.addObserver((event, data) => {
+                if(event === "legalMove" && data.move === "e4") {
+                    resolve()
+                } else {
+                    reject("error event")
+                }
+            })
+            chess.move("e4")
+        })
+    })
+
+    it("should provide valid moves", function() {
+        const chess = new Chess()
+        assert.equal(chess.moves().length, 20)
+        chess.move("Nc3")
+        assert.equal(chess.moves().length, 20)
+        chess.move("e5")
+        assert.equal(chess.moves().length, 22)
+        assert.equal(JSON.stringify(chess.moves({ square: "e2"})), '["e3","e4"]')
+        assert.equal(JSON.stringify(chess.moves({ piece: "n" })), '["Na4","Nb5","Nd5","Ne4","Nb1","Nf3","Nh3"]')
     })
 
 })