next-chessground 0.10.5 → 0.11.3

package/dist/index.es.js

@@ -6414,16 +6414,16 @@ const Chessboard = (props, ref) => {
 
     if (!move) {
       show();
+    }
+
+    if (theme.playSounds) {
+      audio(theme.sounds);
     } // pass the chess object to callback function
 
 
     if (typeof props.onMove === 'function') {
       await props.onMove(chess);
     }
-
-    if (theme.playSounds) {
-      audio(theme.sounds);
-    }
   };
 
   return /*#__PURE__*/React.createElement("div", {
@@ -6887,6 +6887,247 @@ const NextEditor = (props, ref) => {
 
 var NextEditor$1 = /*#__PURE__*/forwardRef(NextEditor);
 
+class Stockfish {
+  constructor() {
+    if (typeof window === 'undefined') {
+      return false;
+    }
+
+    if (!window.chessEngineWorker) {
+      const worker = process.env.STOCKFISH_PATH;
+      window.chessEngineWorker = new Worker(worker);
+    }
+
+    this.skillLevel = 20;
+    this.maxDepth = 40;
+    this.resolveTimeout = null;
+    this.isAnalyzing = false;
+    this.fen = constants.initialFen;
+  }
+
+  getTurnFromFen(fen) {
+    return fen.split(' ')[1];
+  }
+
+  normalizeScoreValue(value) {
+    const {
+      fen
+    } = this;
+    const turn = this.getTurnFromFen(fen);
+
+    if (turn === 'b') {
+      return -1 * value;
+    }
+
+    return value;
+  }
+
+  isInfoMessage(message) {
+    if (!message || !message.data) {
+      return false;
+    }
+
+    return message.data.startsWith('info');
+  }
+
+  setSkillLevel() {
+    /**
+     * skill level is 0-20, higher the stronger
+     * skill level maximum error is 0-5000, lower the stronger
+     * skill level probability is 1-1000, the higher the stronger
+     * seems to be working with max value for maxError and min value for probability
+     */
+    const maxError = 5000;
+    const probability = 1;
+    window.chessEngineWorker.postMessage('setoption name Skill Level value ' + this.skillLevel);
+    window.chessEngineWorker.postMessage('setoption name Skill Level Maximum Error value ' + maxError);
+    window.chessEngineWorker.postMessage('setoption name Skill Level Probability value ' + probability);
+  }
+
+  async init() {
+    await this.use_uci();
+    await this.is_ready();
+    this.setSkillLevel();
+  }
+
+  getScoreFromInfo(msg) {
+    if (msg.startsWith('info depth 0')) {
+      // This happens when game is over.
+      const split = msg.split(' ');
+      const type = split[4];
+      const value = this.normalizeScoreValue(Number(split[5]));
+      this.isAnalyzing = false;
+      return {
+        type,
+        value
+      };
+    } else if (msg.startsWith('info depth ')) {
+      const split = msg.split(' ');
+      const type = split[8];
+      const value = this.normalizeScoreValue(Number(split[9]));
+      return {
+        type,
+        value
+      };
+    }
+
+    return {
+      type: 'cp',
+      value: 0
+    };
+  }
+
+  parseData(data) {
+    const depth = data.split(' ')[2];
+    let pv = '';
+
+    if (data.indexOf(' pv ') > -1) {
+      pv = data.split(' pv ')[1].split(' bmc ')[0];
+    }
+
+    const score = this.getScoreFromInfo(data);
+    return {
+      depth,
+      pv,
+      score
+    };
+  }
+
+  use_uci() {
+    return new Promise(resolve => {
+      window.chessEngineWorker.postMessage('uci');
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data === 'uciok') {
+          resolve(message);
+        }
+      };
+    });
+  }
+
+  is_ready() {
+    return new Promise(resolve => {
+      window.chessEngineWorker.postMessage('isready');
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data === 'readyok') {
+          resolve(message);
+        }
+      };
+    });
+  }
+
+  set_position(fen) {
+    return new Promise(resolve => {
+      this.fen = fen;
+      window.chessEngineWorker.postMessage('position fen ' + fen);
+      resolve();
+    });
+  }
+
+  async new_position(fen) {
+    await this.stop();
+    await this.is_ready();
+    this.set_position(fen);
+    this.go_infinite();
+  }
+
+  set_multipv(numPv) {
+    window.chessEngineWorker.postMessage('setoption name MultiPV value ' + numPv);
+  }
+
+  get_score(fen, depth = 15) {
+    return new Promise(resolve => {
+      window.chessEngineWorker.postMessage('position fen ' + fen);
+      window.chessEngineWorker.postMessage('go depth 15');
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data.startsWith('info depth ' + depth)) {
+          const split = message.data.split(' ');
+          const type = split[8];
+          const value = Number(split[9]);
+          resolve({
+            type,
+            value
+          });
+        } else if (message.data.startsWith('info depth 0')) {
+          // This happens when game is over.
+          const split = message.data.split(' ');
+          const type = split[4];
+          const value = Number(split[5]);
+          resolve({
+            type,
+            value
+          });
+        }
+      };
+    });
+  }
+
+  go_depth(depth) {
+    return new Promise(resolve => {
+      window.chessEngineWorker.postMessage('go depth ' + depth);
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data.startsWith('bestmove')) {
+          resolve(message.data);
+        }
+      };
+    });
+  }
+
+  go_time(time) {
+    return new Promise(resolve => {
+      window.chessEngineWorker.postMessage('go movetime ' + time);
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data.startsWith('bestmove')) {
+          resolve(message.data);
+        }
+      };
+    });
+  }
+
+  go_infinite(callback) {
+    window.chessEngineWorker.postMessage('go infinite');
+    this.isAnalyzing = true;
+
+    window.chessEngineWorker.onmessage = message => {
+      if (this.isInfoMessage(message) && typeof callback === 'function') {
+        const msgData = this.parseData(message.data);
+
+        if (msgData.depth > this.maxDepth) {
+          this.stop();
+        }
+
+        callback(msgData);
+      }
+    };
+  }
+
+  stop() {
+    return new Promise(resolve => {
+      if (!this.isAnalyzing) {
+        resolve();
+      }
+
+      window.chessEngineWorker.postMessage('stop');
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data.startsWith('bestmove')) {
+          this.isAnalyzing = false;
+          resolve(message.data);
+        }
+      };
+    });
+  }
+
+  quit() {
+    window.chessEngineWorker.postMessage('quit');
+  }
+
+}
+
 function styleInject(css, ref) {
   if (ref === void 0) ref = {};
   var insertAt = ref.insertAt;
@@ -6941,4 +7182,4 @@ var css_248z$7 = ".flex {\n  display: flex;\n}\n.flex-col {\n  flex-direction: c
 styleInject(css_248z$7);
 
 export default NextChessground$1;
-export { NextChessground$1 as NextChessground, NextEditor$1 as NextEditor, constants, useChess, useChessground };
+export { NextChessground$1 as NextChessground, NextEditor$1 as NextEditor, Stockfish, constants, useChess, useChessground };

package/dist/index.js

@@ -6423,16 +6423,16 @@ const Chessboard = (props, ref) => {
 
     if (!move) {
       show();
+    }
+
+    if (theme.playSounds) {
+      audio(theme.sounds);
     } // pass the chess object to callback function
 
 
     if (typeof props.onMove === 'function') {
       await props.onMove(chess);
     }
-
-    if (theme.playSounds) {
-      audio(theme.sounds);
-    }
   };
 
   return /*#__PURE__*/React__default['default'].createElement("div", {
@@ -6896,6 +6896,247 @@ const NextEditor = (props, ref) => {
 
 var NextEditor$1 = /*#__PURE__*/React.forwardRef(NextEditor);
 
+class Stockfish {
+  constructor() {
+    if (typeof window === 'undefined') {
+      return false;
+    }
+
+    if (!window.chessEngineWorker) {
+      const worker = process.env.STOCKFISH_PATH;
+      window.chessEngineWorker = new Worker(worker);
+    }
+
+    this.skillLevel = 20;
+    this.maxDepth = 40;
+    this.resolveTimeout = null;
+    this.isAnalyzing = false;
+    this.fen = constants.initialFen;
+  }
+
+  getTurnFromFen(fen) {
+    return fen.split(' ')[1];
+  }
+
+  normalizeScoreValue(value) {
+    const {
+      fen
+    } = this;
+    const turn = this.getTurnFromFen(fen);
+
+    if (turn === 'b') {
+      return -1 * value;
+    }
+
+    return value;
+  }
+
+  isInfoMessage(message) {
+    if (!message || !message.data) {
+      return false;
+    }
+
+    return message.data.startsWith('info');
+  }
+
+  setSkillLevel() {
+    /**
+     * skill level is 0-20, higher the stronger
+     * skill level maximum error is 0-5000, lower the stronger
+     * skill level probability is 1-1000, the higher the stronger
+     * seems to be working with max value for maxError and min value for probability
+     */
+    const maxError = 5000;
+    const probability = 1;
+    window.chessEngineWorker.postMessage('setoption name Skill Level value ' + this.skillLevel);
+    window.chessEngineWorker.postMessage('setoption name Skill Level Maximum Error value ' + maxError);
+    window.chessEngineWorker.postMessage('setoption name Skill Level Probability value ' + probability);
+  }
+
+  async init() {
+    await this.use_uci();
+    await this.is_ready();
+    this.setSkillLevel();
+  }
+
+  getScoreFromInfo(msg) {
+    if (msg.startsWith('info depth 0')) {
+      // This happens when game is over.
+      const split = msg.split(' ');
+      const type = split[4];
+      const value = this.normalizeScoreValue(Number(split[5]));
+      this.isAnalyzing = false;
+      return {
+        type,
+        value
+      };
+    } else if (msg.startsWith('info depth ')) {
+      const split = msg.split(' ');
+      const type = split[8];
+      const value = this.normalizeScoreValue(Number(split[9]));
+      return {
+        type,
+        value
+      };
+    }
+
+    return {
+      type: 'cp',
+      value: 0
+    };
+  }
+
+  parseData(data) {
+    const depth = data.split(' ')[2];
+    let pv = '';
+
+    if (data.indexOf(' pv ') > -1) {
+      pv = data.split(' pv ')[1].split(' bmc ')[0];
+    }
+
+    const score = this.getScoreFromInfo(data);
+    return {
+      depth,
+      pv,
+      score
+    };
+  }
+
+  use_uci() {
+    return new Promise(resolve => {
+      window.chessEngineWorker.postMessage('uci');
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data === 'uciok') {
+          resolve(message);
+        }
+      };
+    });
+  }
+
+  is_ready() {
+    return new Promise(resolve => {
+      window.chessEngineWorker.postMessage('isready');
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data === 'readyok') {
+          resolve(message);
+        }
+      };
+    });
+  }
+
+  set_position(fen) {
+    return new Promise(resolve => {
+      this.fen = fen;
+      window.chessEngineWorker.postMessage('position fen ' + fen);
+      resolve();
+    });
+  }
+
+  async new_position(fen) {
+    await this.stop();
+    await this.is_ready();
+    this.set_position(fen);
+    this.go_infinite();
+  }
+
+  set_multipv(numPv) {
+    window.chessEngineWorker.postMessage('setoption name MultiPV value ' + numPv);
+  }
+
+  get_score(fen, depth = 15) {
+    return new Promise(resolve => {
+      window.chessEngineWorker.postMessage('position fen ' + fen);
+      window.chessEngineWorker.postMessage('go depth 15');
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data.startsWith('info depth ' + depth)) {
+          const split = message.data.split(' ');
+          const type = split[8];
+          const value = Number(split[9]);
+          resolve({
+            type,
+            value
+          });
+        } else if (message.data.startsWith('info depth 0')) {
+          // This happens when game is over.
+          const split = message.data.split(' ');
+          const type = split[4];
+          const value = Number(split[5]);
+          resolve({
+            type,
+            value
+          });
+        }
+      };
+    });
+  }
+
+  go_depth(depth) {
+    return new Promise(resolve => {
+      window.chessEngineWorker.postMessage('go depth ' + depth);
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data.startsWith('bestmove')) {
+          resolve(message.data);
+        }
+      };
+    });
+  }
+
+  go_time(time) {
+    return new Promise(resolve => {
+      window.chessEngineWorker.postMessage('go movetime ' + time);
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data.startsWith('bestmove')) {
+          resolve(message.data);
+        }
+      };
+    });
+  }
+
+  go_infinite(callback) {
+    window.chessEngineWorker.postMessage('go infinite');
+    this.isAnalyzing = true;
+
+    window.chessEngineWorker.onmessage = message => {
+      if (this.isInfoMessage(message) && typeof callback === 'function') {
+        const msgData = this.parseData(message.data);
+
+        if (msgData.depth > this.maxDepth) {
+          this.stop();
+        }
+
+        callback(msgData);
+      }
+    };
+  }
+
+  stop() {
+    return new Promise(resolve => {
+      if (!this.isAnalyzing) {
+        resolve();
+      }
+
+      window.chessEngineWorker.postMessage('stop');
+
+      window.chessEngineWorker.onmessage = message => {
+        if (message.data.startsWith('bestmove')) {
+          this.isAnalyzing = false;
+          resolve(message.data);
+        }
+      };
+    });
+  }
+
+  quit() {
+    window.chessEngineWorker.postMessage('quit');
+  }
+
+}
+
 function styleInject(css, ref) {
   if (ref === void 0) ref = {};
   var insertAt = ref.insertAt;
@@ -6951,6 +7192,7 @@ styleInject(css_248z$7);
 
 exports.NextChessground = NextChessground$1;
 exports.NextEditor = NextEditor$1;
+exports.Stockfish = Stockfish;
 exports.constants = constants;
 exports.default = NextChessground$1;
 exports.useChess = useChess;

package/index.js

@@ -3,6 +3,7 @@ import NextEditor from './components/NextEditor';
 import useChess from './hooks/use-chess';
 import useChessground from './hooks/use-chessground';
 import constants from './utils/constants';
+import Stockfish from './utils/stockfish';
 
 import './assets/css/board.css';
 import './assets/css/chess.css';
@@ -15,4 +16,11 @@ import './assets/css/tailwind.css';
 
 export default NextChessground;
 
-export { NextChessground, NextEditor, useChess, useChessground, constants };
+export {
+  NextChessground,
+  NextEditor,
+  Stockfish,
+  useChess,
+  useChessground,
+  constants,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-chessground",
-  "version": "0.10.5",
+  "version": "0.11.3",
   "description": "React and Next wrapper for Chessground with chessboard and pieces out of the box",
   "main": "dist/index.js",
   "module": "dist/index.es.js",