ssb-chess-mithril 2.1.0 → 2.1.2

package/css/chessground-examples/src/units/perf.ts

@@ -1,46 +1,60 @@
-import { Unit } from './unit';
-import { Chessground }  from 'chessground';
+import { Unit } from "./unit";
+import { Chessground } from "@lichess-org/chessground";
 
+export const metaSquares: Unit = {
+  name: "Perf: meta squares",
+  run(cont) {
+    const cg = Chessground(cont, {
+      fen: "k7/8/8/8/8/4K3/4P3/8 w - - 0 1",
+      movable: {
+        free: false,
+        dests: new Map([
+          ["a8", ["b8", "a7", "b7"]],
+          ["e3", ["f2", "f3", "f4", "e4", "d2", "d3", "d4"]],
+        ]),
+      },
+    });
+    return cg;
+  },
+};
 export const move: Unit = {
-  name: 'Perf: piece move',
+  name: "Perf: piece move",
   run(cont) {
     const cg = Chessground(cont, {
-      animation: { duration: 500 }
+      animation: { duration: 500 },
     });
     const delay = 400;
     function run() {
       if (!cg.state.dom.elements.board.offsetParent) return;
-      cg.move('e2', 'a8');
+      cg.move("e2", "a8");
       setTimeout(() => {
-        cg.move('a8', 'e2');
+        cg.move("a8", "e2");
         setTimeout(run, delay);
       }, delay);
     }
     setTimeout(run, delay);
     return cg;
-  }
+  },
 };
 export const select: Unit = {
-  name: 'Perf: square select',
+  name: "Perf: square select",
   run(cont) {
     const cg = Chessground(cont, {
       movable: {
         free: false,
-        dests: {
-          e2: ['e3', 'e4', 'd3', 'f3']
-        }
-      }
+        dests: new Map([["e2", ["e3", "e4", "d3", "f3"]]]),
+      },
     });
     const delay = 500;
     function run() {
       if (!cg.state.dom.elements.board.offsetParent) return;
-      cg.selectSquare('e2');
+      cg.selectSquare("e2");
       setTimeout(() => {
-        cg.selectSquare('d4');
+        cg.selectSquare("d4");
         setTimeout(run, delay);
       }, delay);
     }
     setTimeout(run, delay);
     return cg;
-  }
+  },
 };

package/css/chessground-examples/src/units/play.ts

@@ -1,87 +1,87 @@
-import { Chess } from 'chess.js';
-import { Chessground }  from 'chessground';
-import { Unit } from './unit';
-import { toColor, toDests, aiPlay, playOtherSide } from '../util'
+import { Chess } from "chess.js";
+import { Chessground } from "@lichess-org/chessground";
+import { Unit } from "./unit";
+import { toColor, toDests, aiPlay, playOtherSide } from "../util";
 
 export const initial: Unit = {
-  name: 'Play legal moves from initial position',
+  name: "Play legal moves from initial position",
   run(el) {
     const chess = new Chess();
     const cg = Chessground(el, {
       movable: {
-        color: 'white',
+        color: "white",
         free: false,
         dests: toDests(chess),
       },
       draggable: {
-        showGhost: true
-      }
+        showGhost: true,
+      },
     });
     cg.set({
-      movable: { events: { after: playOtherSide(cg, chess) } }
+      movable: { events: { after: playOtherSide(cg, chess) } },
     });
     return cg;
-  }
+  },
 };
 
 export const castling: Unit = {
-  name: 'Castling',
+  name: "Castling",
   run(el) {
-    const fen = 'rnbqk2r/pppp1ppp/5n2/2b1p3/2B1P3/5N2/PPPP1PPP/RNBQK2R w KQkq - 4 4';
+    const fen = "rnbqk2r/pppp1ppp/5n2/2b1p3/2B1P3/5N2/PPPP1PPP/RNBQK2R w KQkq - 4 4";
     const chess = new Chess(fen);
     const cg = Chessground(el, {
       fen: fen,
       turnColor: toColor(chess),
       movable: {
-        color: 'white',
+        color: "white",
         free: false,
-        dests: toDests(chess)
-      }
+        dests: toDests(chess),
+      },
     });
     cg.set({
-      movable: { events: { after: playOtherSide(cg, chess) } }
+      movable: { events: { after: playOtherSide(cg, chess) } },
     });
     return cg;
-  }
+  },
 };
 
 export const vsRandom: Unit = {
-  name: 'Play vs random AI',
+  name: "Play vs random AI",
   run(el) {
     const chess = new Chess();
     const cg = Chessground(el, {
       movable: {
-        color: 'white',
+        color: "white",
         free: false,
-        dests: toDests(chess)
-      }
+        dests: toDests(chess),
+      },
     });
     cg.set({
       movable: {
         events: {
-          after: aiPlay(cg, chess, 1000, false)
-        }
-      }
+          after: aiPlay(cg, chess, 1000, false),
+        },
+      },
     });
     return cg;
-  }
+  },
 };
 
 export const fullRandom: Unit = {
-  name: 'Watch 2 random AIs',
+  name: "Watch 2 random AIs",
   run(el) {
     const chess = new Chess();
     const cg = Chessground(el, {
       animation: {
-        duration: 1000
+        duration: 1000,
       },
       movable: {
-        free: false
-      }
+        free: false,
+      },
     });
     function makeMove() {
       if (!cg.state.dom.elements.board.offsetParent) return;
-      const moves = chess.moves({verbose:true});
+      const moves = chess.moves({ verbose: true });
       const move = moves[Math.floor(Math.random() * moves.length)];
       chess.move(move.san);
       cg.move(move.from, move.to);
@@ -89,56 +89,75 @@ export const fullRandom: Unit = {
     }
     setTimeout(makeMove, 700);
     return cg;
-  }
-}
+  },
+};
 
 export const slowAnim: Unit = {
-  name: 'Play vs random AI; slow animations',
+  name: "Play vs random AI; slow animations",
   run(el) {
     const chess = new Chess();
     const cg = Chessground(el, {
       animation: {
-        duration: 5000
+        duration: 5000,
       },
       movable: {
-        color: 'white',
+        color: "white",
         free: false,
-        dests: toDests(chess)
-      }
+        dests: toDests(chess),
+      },
     });
     cg.set({
       movable: {
         events: {
-          after: aiPlay(cg, chess, 1000, false)
-        }
-      }
+          after: aiPlay(cg, chess, 1000, false),
+        },
+      },
     });
     return cg;
-  }
+  },
 };
 
 export const conflictingHold: Unit = {
-  name: 'Conflicting hold/premove',
+  name: "Conflicting hold/premove",
   run(el) {
     const cg = Chessground(el, {
-      fen: '8/8/5p2/4P3/8/8/8/8',
-      turnColor: 'black',
+      fen: "8/8/5p2/4P3/8/8/8/8",
+      turnColor: "black",
       movable: {
-        color: 'white',
+        color: "white",
         free: false,
-        dests: {e5: ['f6']}
-      }
+        dests: new Map([["e5", ["f6"]]]),
+      },
     });
     setTimeout(() => {
-      cg.move('f6', 'e5');
+      cg.move("f6", "e5");
       cg.playPremove();
       cg.set({
-        turnColor: 'white',
+        turnColor: "white",
         movable: {
-          dests: undefined
-        }
+          dests: undefined,
+        },
       });
     }, 1000);
     return cg;
-  }
+  },
+};
+
+export const jsHover: Unit = {
+  name: "JS hover for safari",
+  run(el) {
+    const chess = new Chess();
+    const cg = Chessground(el, {
+      movable: {
+        color: "white",
+        free: false,
+        dests: toDests(chess),
+      },
+      jsHover: true,
+    });
+    cg.set({
+      movable: { events: { after: playOtherSide(cg, chess) } },
+    });
+    return cg;
+  },
 };