@mirasen/chessboard 1.0.6 → 1.0.7

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @mirasen/chessboard
 
+## 1.0.7
+
+### Patch Changes
+
+- 92c3a69: Fix promotion animation planning when cancelling deferred promotion moves after a previous promotion.
+- 92c3a69: Fix piece suppression updates during deferred move animations.
+
 ## 1.0.6
 
 ### Patch Changes

package/README.md

@@ -47,6 +47,7 @@ Mirasen Chessboard provides a complete modern interaction and visual baseline ou
 
 - Real built-in chess interaction
 - Easy game/rules layer integration
+- Works on desktop and mobile out of the box, with pointer-based mouse and touch interaction
 - State-diff animation beyond simple move events
 - Extension-driven architecture
 - First-party baseline extensions

package/dist/animation/planner.js

@@ -2,6 +2,7 @@ import assert from '@ktarmyshov/assert';
 import { isNonEmptyPieceCode } from '../state/board/check.js';
 import { fileOf, rankOf } from '../state/board/coords.js';
 import { SQUARE_COUNT } from '../state/board/types/internal.js';
+import { baseMovesEqual } from '../state/change/helpers.js';
 // ---------------------------------------------------------------------------
 // Precomputed squared distance: (dFile² + dRank²) for all square pairs.
 // Max value = 7² + 7² = 98, fits in Uint8.  Index: a * 64 + b.
@@ -55,7 +56,7 @@ function buildExcludeForDrop(lastMove) {
 function buildEffectiveAnimationPlanningSnapshot(state) {
     const request = state.change.deferredUIMoveRequest;
     if (request === null)
-        return state; // nothing to do
+        return { ...state, lastMoveSource: 'state' }; // nothing to do
     const newPieces = new Uint8Array(state.board.pieces);
     const from = request.sourceSquare;
     const to = request.destination.to;
@@ -73,40 +74,41 @@ function buildEffectiveAnimationPlanningSnapshot(state) {
         piece: pieceCode
     };
     const newChange = {
+        ...state.change,
         deferredUIMoveRequest: null,
         lastMove: newLastMove
     };
     return {
         ...state,
         board: newBoard,
-        change: newChange
+        change: newChange,
+        lastMoveSource: 'projected-deferred-ui-move'
     };
 }
-/**
- * When a promotion was already auto-resolved/auto-promoted (no deferredUIMoveRequest but
- * lastMove.promotedTo is set), the current board already contains the promoted
- * piece (e.g. queen) on the target square.  For animation planning we
- * temporarily replace it with the original piece (pawn) so that the greedy
- * matching can build a proper move track from→to instead of separate fades.
- *
- * After the animation finishes the promoted piece will "snap" into view on
- * the next render frame.
- */
-function buildPromotionEffectiveCurrent(state) {
-    const lastMove = state.change.lastMove;
-    if (state.change.deferredUIMoveRequest !== null ||
+function normalizePromotionEffectiveCurrent(previous, current) {
+    const lastMove = current.change.lastMove;
+    if (current.change.deferredUIMoveRequest !== null ||
         lastMove === null ||
         lastMove.promotedTo === undefined) {
-        return state; // not an auto-resolved/auto-promoted move — nothing to do
+        return current;
     }
-    const newPieces = new Uint8Array(state.board.pieces);
+    if (previous.lastMoveSource === 'projected-deferred-ui-move') {
+        const previousLastMove = previous.change.lastMove;
+        if (previousLastMove === null || !baseMovesEqual(previousLastMove, lastMove)) {
+            return current;
+        }
+    }
+    else if (previous.board.pieces[lastMove.from] !== lastMove.piece) {
+        return current;
+    }
+    const newPieces = new Uint8Array(current.board.pieces);
     newPieces[lastMove.to] = lastMove.piece;
     const newBoard = {
-        ...state.board,
+        ...current.board,
         pieces: newPieces
     };
     return {
-        ...state,
+        ...current,
         board: newBoard
     };
 }
@@ -231,8 +233,8 @@ export function calculateAnimationPlan(input) {
     // 2) Detect lifted-piece drop and prepare exclude spec
     const droppedMove = detectLiftedPieceDrop(effectivePrevious, effectiveCurrent);
     const exclude = droppedMove !== null ? buildExcludeForDrop(droppedMove) : EMPTY_EXCLUDE;
-    // 3) Normalize current for auto-resolved/auto-promoted move (pawn→queen on target square)
-    const planningCurrent = buildPromotionEffectiveCurrent(effectiveCurrent);
+    // 3) Normalize current promoted piece when the promoted move belongs to this transition
+    const planningCurrent = normalizePromotionEffectiveCurrent(effectivePrevious, effectiveCurrent);
     // 4) Calculate tracks
     const tracks = calculateTracks(effectivePrevious.board, planningCurrent.board, exclude);
     // 5) Build suppressedSquares: track-derived + excluded drop endpoints

package/dist/animation/types.d.ts

@@ -30,14 +30,17 @@ export interface AnimationSession {
     duration: number;
 }
 export type AnimationSessionSnapshot = ReadonlyDeep<AnimationSession>;
-export interface AnimationPlanningSnapshot {
+export interface AnimationPlanningInputSnapshot {
     readonly board: BoardStateSnapshot;
     readonly change: ChangeStateSnapshot;
     readonly interaction: InteractionStateSnapshot;
 }
+export interface AnimationPlanningSnapshot extends AnimationPlanningInputSnapshot {
+    readonly lastMoveSource: 'state' | 'projected-deferred-ui-move';
+}
 export interface AnimationPlanningInput {
-    previous: AnimationPlanningSnapshot;
-    current: AnimationPlanningSnapshot;
+    previous: AnimationPlanningInputSnapshot;
+    current: AnimationPlanningInputSnapshot;
 }
 export interface AnimationPlan {
     readonly tracks: readonly AnimationTrack[];

package/dist/extensions/first-party/main-renderer/pieces/update.js

@@ -6,7 +6,7 @@ import { calculateSuppressedSquares } from './suppress.js';
 export function rendererPiecesOnUpdate(state, context, animationSuppressedSquares) {
     if (!isUpdateContextRenderable(context) ||
         !context.mutation.hasMutation({
-            prefixes: ['state.board.', 'state.interaction.'],
+            prefixes: ['state.'],
             causes: ['layout.refreshGeometry']
         })) {
         return;

package/dist/state/board/fen/main.d.ts

@@ -0,0 +1,10 @@
+import { FenString } from '../types/input.js';
+import { ParsedPosition } from '../types/internal.js';
+/**
+ * Parse a FEN string into a {@link ParsedPosition}.
+ *
+ * Only the first two FEN fields (piece placement + active color) are required
+ * for a board-only representation. The remaining fields (castling, en-passant,
+ * half-move clock, full-move number) are accepted but ignored.
+ */
+export declare function parseFen(fen: FenString): ParsedPosition;

package/dist/state/board/fen/main.js

@@ -0,0 +1,94 @@
+import { SQUARE_COUNT } from '../types/internal.js';
+/**
+ * Direct FEN character → PieceCode lookup.
+ * Uppercase = White, lowercase = Black.
+ */
+const FEN_PIECE_MAP = {
+    P: 1 /* PieceCode.WhitePawn */,
+    N: 2 /* PieceCode.WhiteKnight */,
+    B: 3 /* PieceCode.WhiteBishop */,
+    R: 4 /* PieceCode.WhiteRook */,
+    Q: 5 /* PieceCode.WhiteQueen */,
+    K: 6 /* PieceCode.WhiteKing */,
+    p: 9 /* PieceCode.BlackPawn */,
+    n: 10 /* PieceCode.BlackKnight */,
+    b: 11 /* PieceCode.BlackBishop */,
+    r: 12 /* PieceCode.BlackRook */,
+    q: 13 /* PieceCode.BlackQueen */,
+    k: 14 /* PieceCode.BlackKing */
+};
+/**
+ * Parse the piece-placement section of a FEN string into a Uint8Array[64].
+ *
+ * FEN ranks are ordered 8→1 (top to bottom), but our board indexing is
+ * a1=0, b1=1, ..., h1=7, a2=8, ..., h8=63.
+ * So rank 8 maps to indices 56–63 and rank 1 to indices 0–7.
+ */
+function parsePiecePlacement(placement) {
+    const pieces = new Uint8Array(SQUARE_COUNT); // initialized to 0 (PieceCode.Empty)
+    const ranks = placement.split('/');
+    if (ranks.length !== 8) {
+        throw new Error(`Invalid FEN piece placement: expected 8 ranks separated by '/', got ${ranks.length}`);
+    }
+    for (let rankIdx = 0; rankIdx < 8; rankIdx++) {
+        // FEN rank index 0 = rank 8 (board row 7), index 7 = rank 1 (board row 0)
+        const boardRow = 7 - rankIdx;
+        const baseSquare = boardRow * 8;
+        const rankStr = ranks[rankIdx];
+        let file = 0;
+        for (let i = 0; i < rankStr.length; i++) {
+            const ch = rankStr[i];
+            if (ch >= '1' && ch <= '8') {
+                // Skip empty squares
+                file += ch.charCodeAt(0) - '0'.charCodeAt(0);
+            }
+            else {
+                const piece = FEN_PIECE_MAP[ch];
+                if (piece === undefined) {
+                    throw new Error(`Invalid FEN piece character: '${ch}'`);
+                }
+                if (file >= 8) {
+                    throw new Error(`Invalid FEN piece placement: too many squares in rank ${8 - rankIdx}`);
+                }
+                pieces[baseSquare + file] = piece;
+                file++;
+            }
+        }
+        if (file !== 8) {
+            throw new Error(`Invalid FEN piece placement: rank ${8 - rankIdx} has ${file} squares instead of 8`);
+        }
+    }
+    return pieces;
+}
+/**
+ * Parse the active-color field of a FEN string.
+ */
+function parseTurn(turn) {
+    switch (turn) {
+        case 'w':
+            return 0 /* ColorCode.White */;
+        case 'b':
+            return 8 /* ColorCode.Black */;
+        default:
+            throw new Error(`Invalid FEN turn field: expected 'w' or 'b', got '${turn}'`);
+    }
+}
+/**
+ * Parse a FEN string into a {@link ParsedPosition}.
+ *
+ * Only the first two FEN fields (piece placement + active color) are required
+ * for a board-only representation. The remaining fields (castling, en-passant,
+ * half-move clock, full-move number) are accepted but ignored.
+ */
+export function parseFen(fen) {
+    const parts = fen
+        .replace(/^\uFEFF/, '')
+        .trim()
+        .split(/\s+/);
+    if (parts.length < 2) {
+        throw new Error(`Invalid FEN string: expected at least 2 space-separated fields, got ${parts.length}`);
+    }
+    const pieces = parsePiecePlacement(parts[0]);
+    const turn = parseTurn(parts[1]);
+    return { pieces, turn };
+}

package/dist/state/board/position.js

@@ -1,4 +1,4 @@
-import { parse } from '@echecs/fen';
+import { parseFen } from './fen/main.js';
 import { normalizeColor, normalizePiece, normalizeSquare } from './normalize.js';
 import { SQUARE_COUNT } from './types/internal.js';
 const START_POSITION_RECORD_STRING = {
@@ -63,18 +63,7 @@ function isPositionInputObject(input) {
     return typeof input === 'object' && input !== null && !Array.isArray(input);
 }
 function boardParsePositionInputFen(input) {
-    const position = parse(input);
-    if (!position) {
-        throw new Error('Failed to parse FEN string');
-    }
-    const piecePositionRecord = {};
-    for (const [square, piece] of position.board) {
-        piecePositionRecord[square] = { role: piece.type, color: piece.color };
-    }
-    return {
-        pieces: boardParsePositionInputRecord(piecePositionRecord),
-        turn: normalizeColor(position.turn)
-    };
+    return parseFen(input);
 }
 export function boardParsePosition(input) {
     if (input === 'start') {

package/dist/state/change/helpers.d.ts

@@ -1,7 +1,8 @@
-import type { MoveRequest, MoveRequestBase, MoveSnapshot } from '../board/types/internal.js';
+import type { MoveBaseSnapshot, MoveRequest, MoveRequestBase, MoveSnapshot } from '../board/types/internal.js';
 import { MoveDestinationSnapshot } from '../interaction/types/internal.js';
 import { ChangeStateSnapshot } from './types/main.js';
 import { PendingUIMoveRequestSnapshot } from './types/ui-move.js';
+export declare function baseMovesEqual(moveA: MoveBaseSnapshot, moveB: MoveBaseSnapshot): boolean;
 export declare function movesEqual(moveA: MoveSnapshot | null, moveB: MoveSnapshot | null): boolean;
 export declare function moveRequestBasesEqual(requestA: MoveRequestBase | null, requestB: MoveRequestBase | null): boolean;
 export declare function moveRequestsEqual(requestA: MoveRequest | null, requestB: MoveRequest | null): boolean;

package/dist/state/change/helpers.js

@@ -1,5 +1,5 @@
 import { setsEqual } from '../../helpers/util.js';
-function baseMovesEqual(moveA, moveB) {
+export function baseMovesEqual(moveA, moveB) {
     const diffs = [
         moveA.from !== moveB.from,
         moveA.to !== moveB.to,

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@mirasen/chessboard",
 	"description": "Framework-agnostic TypeScript chessboard platform with real chess interaction built in.",
-	"version": "1.0.6",
+	"version": "1.0.7",
 	"license": "MIT",
 	"author": {
 		"name": "Mirasen",
@@ -79,6 +79,7 @@
 		"@eslint/js": "^10.0.1",
 		"@types/node": "^25.5.0",
 		"@vitest/coverage-istanbul": "^4.1.0",
+		"chess.js": "^1.4.0",
 		"eslint": "^10.0.2",
 		"eslint-config-prettier": "^10.1.2",
 		"globals": "^17.4.0",
@@ -96,7 +97,6 @@
 		"node": ">=20"
 	},
 	"dependencies": {
-		"@echecs/fen": "^2.1.0",
 		"@ktarmyshov/assert": "^0.1.9",
 		"es-toolkit": "^1.45.1",
 		"type-fest": "^5.5.0"