next-chessground 0.10.2 → 0.11.0

package/dist/index.es.js

@@ -5952,14 +5952,24 @@ const fen = {
   initial: 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1',
   empty: '8/8/8/8/8/8/8/8 w - - 0 1'
 };
-const initial$1 = fen.initial;
+const initialFen = fen.initial;
+const emptyFen = fen.empty;
+const constants = {
+  fen,
+  initialFen,
+  emptyFen
+};
 
 const useChess = props => {
-  const [fen, setFen] = useState(props.fen || initial$1);
-  const [chess$1] = useState(new chess.Chess(fen)); // reinitialize when FEN changes from props
+  const [fen, setFen] = useState(props.fen || initialFen);
+  const [chess$1, setChess] = useState(new chess.Chess(fen)); // reinitialize when FEN changes from props
 
   useEffect(() => {
-    setFen(props.fen);
+    if (props.fen) {
+      setFen(props.fen);
+      setChess(new chess.Chess(props.fen));
+      setLastMove([]);
+    }
   }, [props.fen]);
   const [lastMove, setLastMove] = useState([]);
   const promotion = props.lastMove && props.lastMove.promotion;
@@ -6404,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", {
@@ -6830,19 +6840,19 @@ const FenOptions = ({
 };
 
 const NextEditor = (props, ref) => {
-  const [fen$1, setFen] = useState(props.fen || fen.empty);
+  const [fen, setFen] = useState(props.fen || constants.emptyFen);
   const [selected, setSelected] = useState({
     role: null,
     color: null
   });
   useEffect(() => {
     if (typeof props.onSelect === 'function') {
-      props.onSelect(fen$1);
+      props.onSelect(fen);
     }
-  }, [fen$1]);
+  }, [fen]);
 
   const onSelect = key => {
-    const array = fen$1.split(' ');
+    const array = fen.split(' ');
     array.shift();
     const options = array.join(' ');
     const position = dropPiece(ref.current.board, selected, key);
@@ -6851,7 +6861,7 @@ const NextEditor = (props, ref) => {
   };
 
   const handleChange = options => {
-    const position = fen$1.split(' ')[0];
+    const position = fen.split(' ')[0];
     const withOptions = [position, options, '- 0 1'].join(' ');
     setFen(withOptions);
   };
@@ -6865,7 +6875,7 @@ const NextEditor = (props, ref) => {
   }), /*#__PURE__*/React.createElement(Chessboard$1, _extends({}, props, {
     ref: ref,
     onSelect: onSelect,
-    fen: fen$1
+    fen: fen
   })), /*#__PURE__*/React.createElement(EditorPieces, {
     selected: selected,
     selectPiece: setSelected,
@@ -6877,6 +6887,222 @@ 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.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();
+    });
+  }
+
+  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);
+        }
+      };
+    });
+  }
+
+  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;
@@ -6931,4 +7157,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, fen, useChess, useChessground };
+export { NextChessground$1 as NextChessground, NextEditor$1 as NextEditor, Stockfish, constants, useChess, useChessground };

package/dist/index.js

@@ -5961,14 +5961,24 @@ const fen = {
   initial: 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1',
   empty: '8/8/8/8/8/8/8/8 w - - 0 1'
 };
-const initial$1 = fen.initial;
+const initialFen = fen.initial;
+const emptyFen = fen.empty;
+const constants = {
+  fen,
+  initialFen,
+  emptyFen
+};
 
 const useChess = props => {
-  const [fen, setFen] = React.useState(props.fen || initial$1);
-  const [chess$1] = React.useState(new chess.Chess(fen)); // reinitialize when FEN changes from props
+  const [fen, setFen] = React.useState(props.fen || initialFen);
+  const [chess$1, setChess] = React.useState(new chess.Chess(fen)); // reinitialize when FEN changes from props
 
   React.useEffect(() => {
-    setFen(props.fen);
+    if (props.fen) {
+      setFen(props.fen);
+      setChess(new chess.Chess(props.fen));
+      setLastMove([]);
+    }
   }, [props.fen]);
   const [lastMove, setLastMove] = React.useState([]);
   const promotion = props.lastMove && props.lastMove.promotion;
@@ -6413,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", {
@@ -6839,19 +6849,19 @@ const FenOptions = ({
 };
 
 const NextEditor = (props, ref) => {
-  const [fen$1, setFen] = React.useState(props.fen || fen.empty);
+  const [fen, setFen] = React.useState(props.fen || constants.emptyFen);
   const [selected, setSelected] = React.useState({
     role: null,
     color: null
   });
   React.useEffect(() => {
     if (typeof props.onSelect === 'function') {
-      props.onSelect(fen$1);
+      props.onSelect(fen);
     }
-  }, [fen$1]);
+  }, [fen]);
 
   const onSelect = key => {
-    const array = fen$1.split(' ');
+    const array = fen.split(' ');
     array.shift();
     const options = array.join(' ');
     const position = dropPiece(ref.current.board, selected, key);
@@ -6860,7 +6870,7 @@ const NextEditor = (props, ref) => {
   };
 
   const handleChange = options => {
-    const position = fen$1.split(' ')[0];
+    const position = fen.split(' ')[0];
     const withOptions = [position, options, '- 0 1'].join(' ');
     setFen(withOptions);
   };
@@ -6874,7 +6884,7 @@ const NextEditor = (props, ref) => {
   }), /*#__PURE__*/React__default['default'].createElement(Chessboard$1, _extends({}, props, {
     ref: ref,
     onSelect: onSelect,
-    fen: fen$1
+    fen: fen
   })), /*#__PURE__*/React__default['default'].createElement(EditorPieces, {
     selected: selected,
     selectPiece: setSelected,
@@ -6886,6 +6896,222 @@ 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.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();
+    });
+  }
+
+  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);
+        }
+      };
+    });
+  }
+
+  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,7 +7167,8 @@ styleInject(css_248z$7);
 
 exports.NextChessground = NextChessground$1;
 exports.NextEditor = NextEditor$1;
+exports.Stockfish = Stockfish;
+exports.constants = constants;
 exports.default = NextChessground$1;
-exports.fen = fen;
 exports.useChess = useChess;
 exports.useChessground = useChessground;

package/index.js

@@ -2,7 +2,8 @@ import NextChessground from './components/NextChessground';
 import NextEditor from './components/NextEditor';
 import useChess from './hooks/use-chess';
 import useChessground from './hooks/use-chessground';
-import fen from './utils/fen';
+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, fen };
+export {
+  NextChessground,
+  NextEditor,
+  Stockfish,
+  useChess,
+  useChessground,
+  constants,
+};

package/package.json

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