cm-chessboard 8.12.4 → 8.12.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cm-chessboard",
-  "version": "8.12.4",
+  "version": "8.12.6",
   "description": "A JavaScript chessboard which is lightweight, ES6 module based, responsive, SVG rendered and without dependencies.",
   "keywords": [
     "chess",

package/src/extensions/markers/README.md

@@ -28,6 +28,33 @@ Removes markers from the board.
 Only set `type` to remove all markers of `type` from the board. Set `type` to `undefined`, to remove all types
 of markers from a square. Call without parameters to remove all markers from the board.
 
+## Marker type identity
+
+Marker types are matched by **object reference**, not by structural
+equality. Two type objects that only *look* the same are intentionally
+treated as different types — this lets you have several visually
+identical marker types that can be managed independently.
+
+Always keep your marker types as module-level constants and pass the
+**same reference** to `addMarker` and `removeMarkers`:
+
+```js
+// ✅ works — same reference
+const myType = {class: "marker-frame", slice: "markerFrame"}
+board.addMarker(myType, "e4")
+board.removeMarkers(myType)        // removed
+
+// ❌ silently does nothing — different reference, even though the
+// object looks identical
+board.addMarker({class: "marker-frame", slice: "markerFrame"}, "e4")
+board.removeMarkers({class: "marker-frame", slice: "markerFrame"})
+```
+
+The same applies to the exported `MARKER_TYPE.*` constants: import them
+once and reuse that reference — don't clone them (e.g. via
+`JSON.parse(JSON.stringify(...))` or a framework store that
+deep-copies), or `removeMarkers` won't find a match.
+
 ## Create your own custom markers
 
 Just create an object like `const myMarker = {class: "markerCssClass", slice: "markerSliceId"}`, where `class` is the

package/src/view/PositionAnimationsQueue.js

@@ -246,7 +246,10 @@ export class PositionAnimationsQueue extends PromiseQueue {
 
     async enqueuePositionChange(positionFrom, positionTo, animated) {
         if(positionFrom.getFen() === positionTo.getFen()) {
-            return Promise.resolve()
+            // No diff to animate. Still go through the queue so the promise
+            // resolves after any animations already in flight (e.g. an
+            // earlier movePiece from a drag). See issue #154.
+            return super.enqueue(() => Promise.resolve())
         } else {
             return super.enqueue(() => new Promise((resolve) => {
                 let duration = animated ? this.chessboard.props.style.animationDuration : 0

package/test/TestChessboard.js

@@ -69,6 +69,36 @@ describe("TestChessboard", () => {
         chessboard.destroy()
     })
 
+    // Regression for https://github.com/shaack/cm-chessboard/issues/154
+    //
+    // A setPosition() call with a null diff (positionFrom === positionTo)
+    // used to bypass the animation queue entirely and resolve on the next
+    // microtask. That's wrong when an earlier animation — here the animated
+    // movePiece — is still in the queue: the setPosition promise must wait
+    // for that to drain before resolving, otherwise callers following the
+    // "await setPosition(...); then continue" pattern run their
+    // continuation before the board is visually settled.
+    it("setPosition should wait for pending animations even on a null diff (#154)", async () => {
+        const chessboard = new Chessboard(document.getElementById("TestPosition"), {
+            assetsUrl: "../assets/",
+            position: FEN.start,
+            style: {animationDuration: 100}
+        })
+        let movePieceResolved = false
+        const movePromise = chessboard.movePiece("e2", "e4", true).then(() => {
+            movePieceResolved = true
+        })
+        // Same FEN as the position after movePiece → null diff inside
+        // setPosition. The animated movePiece above is still queued.
+        const targetFen = "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR"
+        const setPromise = chessboard.setPosition(targetFen, true).then(() => {
+            assert.equal(movePieceResolved, true,
+                "setPosition resolved before the pending movePiece animation finished")
+        })
+        await Promise.all([movePromise, setPromise])
+        chessboard.destroy()
+    })
+
     // Regression for a production crash: the ResizeObserver callback defers
     // handleResize() via setTimeout to avoid "ResizeObserver loop completed"
     // warnings. If destroy() is called between the observer firing and the