react-chess-replay-trainer 0.0.2 → 0.0.4

package/README.md

@@ -1,44 +1,46 @@
-# react-chess-replay-trainer
-
-A React component for replaying a chess game move-by-move and drilling it.
-
-- **Browse** freely through the game (first / prev / next / last / jump) without
-  recording anything, so you can pick the part of the game you want to study.
-- **Train White / Train Black / Train Both** start a drill at the current ply:
-  you guess each move, and every mistake is reported via `onMiss` so the host can
-  (for example) enroll the missed position into a spaced-repetition deck.
-  - With **Train White** or **Train Black** you only guess that side's moves; the
-    opponent's reply is played automatically after each correct guess, and the
-    board is rotated so the trained side is on the bottom.
-  - With **Train Both** you drill every ply for both colors.
-- **Analyze** opens the built-in analysis board (`AnalysisBoard` from
-  `react-chess-core`) at the current position.
-
-Depends on `react-chess-core` (board, engine, analysis board), `react-chessboard`,
-and `chess.js`.
-
-## Usage
-
-```tsx
-import { ReplayTrainer } from 'react-chess-replay-trainer';
-
-<ReplayTrainer
-  gameId={gameId}
-  startFen={fenWhereUserWasBrowsing}
-  fetchGame={fetchGame}
-  onMiss={(miss) => enrollMissedPosition(miss)}
-  onExit={() => setTraining(null)}
-  theme="dark"
-  engine={{ depth: 18, multiPv: 3 }}
-/>;
-```
-
-For a custom shell, use `useReplayTrainer` with `AnalysisBoard` from the same package:
-
-```tsx
-import {
-  useReplayTrainer,
-  buildReplayAnalysisContext,
-  AnalysisBoard,
-} from 'react-chess-replay-trainer';
-```
+# react-chess-replay-trainer
+
+A React component for replaying a chess game move-by-move and drilling it.
+
+- **Browse** freely through the game (first / prev / next / last / jump) without
+  recording anything, so you can pick the part of the game you want to study.
+- **Train White / Train Black / Train Both** start a drill at the current ply:
+  you guess each move, and every mistake is reported via `onMiss` so the host can
+  (for example) enroll the missed position into a spaced-repetition deck.
+  - With **Train White** or **Train Black** you only guess that side's moves; the
+    opponent's reply is played automatically after each correct guess, and the
+    board is rotated so the trained side is on the bottom.
+  - With **Train Both** you drill every ply for both colors.
+- **Analyze** opens the built-in analysis board (`AnalysisBoard` from
+  `react-chess-core`) at the current position.
+
+Depends on `react-chess-core` (board, engine, analysis board), `react-chessboard`,
+and `chess.js`.
+
+Used in production at [endchess.com](https://endchess.com).
+
+## Usage
+
+```tsx
+import { ReplayTrainer } from 'react-chess-replay-trainer';
+
+<ReplayTrainer
+  gameId={gameId}
+  startFen={fenWhereUserWasBrowsing}
+  fetchGame={fetchGame}
+  onMiss={(miss) => enrollMissedPosition(miss)}
+  onExit={() => setTraining(null)}
+  theme="dark"
+  engine={{ depth: 18, multiPv: 3 }}
+/>;
+```
+
+For a custom shell, use `useReplayTrainer` with `AnalysisBoard` from the same package:
+
+```tsx
+import {
+  useReplayTrainer,
+  buildReplayAnalysisContext,
+  AnalysisBoard,
+} from 'react-chess-replay-trainer';
+```

package/dist/features/replay/hooks/useReplayTrainer.d.ts

@@ -28,6 +28,10 @@ export interface ReplayTrainerState {
     /** Revealed/expected move at the current ply (set after a miss or reveal). */
     expectedSan: string | null;
     expectedUci: string | null;
+    /** Destination square of the last correct guess (green check overlay). */
+    correctMoveSquare: string | null;
+    /** FEN shown on the board (includes a pending correct-move ply). */
+    displayFen: string;
     canPrev: boolean;
     canNext: boolean;
     goFirst: () => void;

package/dist/index.esm.js

@@ -1,6 +1,6 @@
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { useState, useRef, useEffect, useMemo, useCallback } from 'react';
-import { createExpectedMoveDropHandler, ThemeProvider, ChessboardDnDProvider, HighlightChessboard, PlyNavigation, AnalysisErrorBoundary, AnalysisBoard } from 'react-chess-core';
+import { useCorrectMoveFeedback, createExpectedMoveDropHandler, fenAfterUci, ThemeProvider, ChessboardDnDProvider, HighlightChessboard, PlyNavigation, AnalysisErrorBoundary, AnalysisBoard } from 'react-chess-core';
 export { AnalysisBoard, AnalysisBoardCore, AnalysisErrorBoundary, DEFAULT_ANALYSIS_LAYOUT, DefaultPlyNavigation, PlyNavigation, MISS_MOVE_ANIMATION_MS as REPLAY_MISS_MOVE_ANIMATION_MS, MISS_REFUTATION_MAX_WAIT_MS as REPLAY_MISS_REFUTATION_MAX_WAIT_MS, MISS_REFUTATION_PAUSE_MS as REPLAY_MISS_REFUTATION_PAUSE_MS, MISS_WRONG_PAUSE_MS as REPLAY_MISS_WRONG_PAUSE_MS, REFUTATION_EVAL_GAP_CP as REPLAY_REFUTATION_EVAL_GAP_CP, REFUTATION_EVAL_GAP_PAWNS as REPLAY_REFUTATION_EVAL_GAP_PAWNS, defaultRenderPlyNavigation, fenAfterUci, getMissDisplay as getReplayMissDisplay, refutationEvalGapCp, refutationFromEvaluation, refutationEngineOptions as replayRefutationEngineOptions, uciFromDrop, useMissBoard as useReplayMissBoard, useMissSequence as useReplayMissSequence, useMissRefutation as useReplayRefutation } from 'react-chess-core';
 import { Chess } from 'chess.js';
 
@@ -78,6 +78,8 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
     const [expectedSan, setExpectedSan] = useState(null);
     const [autoplayActive, setAutoplayActive] = useState(false);
     const [expectedUci, setExpectedUci] = useState(null);
+    const [feedbackFen, setFeedbackFen] = useState(null);
+    const { correctMoveSquare, showCorrectMove, clearCorrectMoveFeedback, isShowingCorrectMove, } = useCorrectMoveFeedback();
     const fetchGameRef = useRef(fetchGame);
     fetchGameRef.current = fetchGame;
     const onMissRef = useRef(onMiss);
@@ -88,6 +90,8 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
     const completedFiredRef = useRef(false);
     const modeRef = useRef('browse');
     const trainColorRef = useRef('both');
+    const showingCorrectMoveRef = useRef(false);
+    showingCorrectMoveRef.current = isShowingCorrectMove;
     useEffect(() => {
         let cancelled = false;
         setLoading(true);
@@ -131,6 +135,7 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
     const movesUci = useMemo(() => { var _a; return (_a = game === null || game === void 0 ? void 0 : game.movesUci) !== null && _a !== void 0 ? _a : []; }, [game]);
     const totalPly = movesUci.length;
     const fen = useMemo(() => fenAtPly(movesUci, plyIndex), [movesUci, plyIndex]);
+    const displayFen = feedbackFen !== null && feedbackFen !== void 0 ? feedbackFen : fen;
     const complete = plyIndex >= totalPly && totalPly > 0;
     const sideToMove$1 = sideToMove(fen);
     const isUserTurn = isTrainSideToMove(trainColor, sideToMove$1);
@@ -140,7 +145,9 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
         setFeedback(null);
         setExpectedSan(null);
         setExpectedUci(null);
-    }, []);
+        setFeedbackFen(null);
+        clearCorrectMoveFeedback();
+    }, [clearCorrectMoveFeedback]);
     const stopAutoplay = useCallback(() => {
         setAutoplayActive(false);
     }, []);
@@ -220,12 +227,21 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
         expectedUci: movesUci[plyIndex],
         enabled: modeRef.current === 'train' &&
             !complete &&
+            !showingCorrectMoveRef.current &&
             isTrainSideToMove(trainColorRef.current, sideToMove$1),
-        onCorrect: () => {
+        onCorrect: (uci) => {
             setFeedback('correct');
             setExpectedSan(null);
             setExpectedUci(null);
-            setPlyIndex((p) => p + 1);
+            const nextFen = fenAfterUci(fen, uci);
+            if (nextFen) {
+                setFeedbackFen(nextFen);
+            }
+            showCorrectMove(uci.slice(2, 4), () => {
+                setFeedbackFen(null);
+                setFeedback(null);
+                setPlyIndex((p) => p + 1);
+            });
         },
         onIncorrect: () => {
             var _a, _b;
@@ -238,7 +254,7 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
             setExpectedUci(expectedUci);
             recordMiss(plyIndex);
         },
-    })(source, target, piece), [complete, movesUci, plyIndex, fen, game, recordMiss, sideToMove$1]);
+    })(source, target, piece), [complete, fen, movesUci, plyIndex, game, recordMiss, sideToMove$1, showCorrectMove]);
     useEffect(() => {
         var _a;
         if (mode === 'train' && complete && !completedFiredRef.current) {
@@ -267,12 +283,15 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
         if (mode !== 'train' || complete || trainColor === 'both' || isUserTurn) {
             return;
         }
+        if (isShowingCorrectMove) {
+            return;
+        }
         const id = setTimeout(() => {
             setPlyIndex((p) => (p < totalPly ? p + 1 : p));
             clearTransient();
         }, OPPONENT_MOVE_DELAY_MS);
         return () => clearTimeout(id);
-    }, [mode, complete, trainColor, isUserTurn, plyIndex, totalPly, clearTransient]);
+    }, [mode, complete, trainColor, isUserTurn, plyIndex, totalPly, clearTransient, isShowingCorrectMove]);
     return {
         game,
         loading,
@@ -288,6 +307,8 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
         feedback,
         expectedSan,
         expectedUci,
+        correctMoveSquare,
+        displayFen,
         canPrev: plyIndex > 0,
         canNext: plyIndex < totalPly,
         goFirst,
@@ -437,7 +458,7 @@ const ReplayTrainer = ({ gameId, fetchGame, startFen, onMiss, onComplete, onExit
         ]
         : [];
     const draggable = training && !state.complete;
-    return (jsxs(ThemeProvider, { theme: theme, boardTheme: boardTheme, children: [jsxs("div", { style: mainContainerStyle(boardWidth, colors), children: [jsxs("div", { style: headerStyle, children: [jsxs("span", { style: playerNameStyle, children: [((_b = game.white) !== null && _b !== void 0 ? _b : 'White'), " vs ", ((_c = game.black) !== null && _c !== void 0 ? _c : 'Black')] }), game.result && jsx("span", { style: subtleTextStyle(colors), children: game.result })] }), jsx(ChessboardDnDProvider, { children: jsx(HighlightChessboard, { boardWidth: boardWidth, checkSquare: "", hintSquare: null, incorrectMoveSquare: null, position: state.fen, boardOrientation: boardOrientation, arePiecesDraggable: draggable, isDraggablePiece: ({ piece }) => {
+    return (jsxs(ThemeProvider, { theme: theme, boardTheme: boardTheme, children: [jsxs("div", { style: mainContainerStyle(boardWidth, colors), children: [jsxs("div", { style: headerStyle, children: [jsxs("span", { style: playerNameStyle, children: [((_b = game.white) !== null && _b !== void 0 ? _b : 'White'), " vs ", ((_c = game.black) !== null && _c !== void 0 ? _c : 'Black')] }), game.result && jsx("span", { style: subtleTextStyle(colors), children: game.result })] }), jsx(ChessboardDnDProvider, { children: jsx(HighlightChessboard, { boardWidth: boardWidth, checkSquare: "", hintSquare: null, incorrectMoveSquare: null, correctMoveSquare: state.correctMoveSquare, position: state.displayFen, boardOrientation: boardOrientation, arePiecesDraggable: draggable && !state.correctMoveSquare, isDraggablePiece: ({ piece }) => {
                                 if (state.trainColor === 'white')
                                     return piece[0] === 'w';
                                 if (state.trainColor === 'black')

package/dist/index.js

@@ -79,6 +79,8 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
     const [expectedSan, setExpectedSan] = react.useState(null);
     const [autoplayActive, setAutoplayActive] = react.useState(false);
     const [expectedUci, setExpectedUci] = react.useState(null);
+    const [feedbackFen, setFeedbackFen] = react.useState(null);
+    const { correctMoveSquare, showCorrectMove, clearCorrectMoveFeedback, isShowingCorrectMove, } = reactChessCore.useCorrectMoveFeedback();
     const fetchGameRef = react.useRef(fetchGame);
     fetchGameRef.current = fetchGame;
     const onMissRef = react.useRef(onMiss);
@@ -89,6 +91,8 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
     const completedFiredRef = react.useRef(false);
     const modeRef = react.useRef('browse');
     const trainColorRef = react.useRef('both');
+    const showingCorrectMoveRef = react.useRef(false);
+    showingCorrectMoveRef.current = isShowingCorrectMove;
     react.useEffect(() => {
         let cancelled = false;
         setLoading(true);
@@ -132,6 +136,7 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
     const movesUci = react.useMemo(() => { var _a; return (_a = game === null || game === void 0 ? void 0 : game.movesUci) !== null && _a !== void 0 ? _a : []; }, [game]);
     const totalPly = movesUci.length;
     const fen = react.useMemo(() => fenAtPly(movesUci, plyIndex), [movesUci, plyIndex]);
+    const displayFen = feedbackFen !== null && feedbackFen !== void 0 ? feedbackFen : fen;
     const complete = plyIndex >= totalPly && totalPly > 0;
     const sideToMove$1 = sideToMove(fen);
     const isUserTurn = isTrainSideToMove(trainColor, sideToMove$1);
@@ -141,7 +146,9 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
         setFeedback(null);
         setExpectedSan(null);
         setExpectedUci(null);
-    }, []);
+        setFeedbackFen(null);
+        clearCorrectMoveFeedback();
+    }, [clearCorrectMoveFeedback]);
     const stopAutoplay = react.useCallback(() => {
         setAutoplayActive(false);
     }, []);
@@ -221,12 +228,21 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
         expectedUci: movesUci[plyIndex],
         enabled: modeRef.current === 'train' &&
             !complete &&
+            !showingCorrectMoveRef.current &&
             isTrainSideToMove(trainColorRef.current, sideToMove$1),
-        onCorrect: () => {
+        onCorrect: (uci) => {
             setFeedback('correct');
             setExpectedSan(null);
             setExpectedUci(null);
-            setPlyIndex((p) => p + 1);
+            const nextFen = reactChessCore.fenAfterUci(fen, uci);
+            if (nextFen) {
+                setFeedbackFen(nextFen);
+            }
+            showCorrectMove(uci.slice(2, 4), () => {
+                setFeedbackFen(null);
+                setFeedback(null);
+                setPlyIndex((p) => p + 1);
+            });
         },
         onIncorrect: () => {
             var _a, _b;
@@ -239,7 +255,7 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
             setExpectedUci(expectedUci);
             recordMiss(plyIndex);
         },
-    })(source, target, piece), [complete, movesUci, plyIndex, fen, game, recordMiss, sideToMove$1]);
+    })(source, target, piece), [complete, fen, movesUci, plyIndex, game, recordMiss, sideToMove$1, showCorrectMove]);
     react.useEffect(() => {
         var _a;
         if (mode === 'train' && complete && !completedFiredRef.current) {
@@ -268,12 +284,15 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
         if (mode !== 'train' || complete || trainColor === 'both' || isUserTurn) {
             return;
         }
+        if (isShowingCorrectMove) {
+            return;
+        }
         const id = setTimeout(() => {
             setPlyIndex((p) => (p < totalPly ? p + 1 : p));
             clearTransient();
         }, OPPONENT_MOVE_DELAY_MS);
         return () => clearTimeout(id);
-    }, [mode, complete, trainColor, isUserTurn, plyIndex, totalPly, clearTransient]);
+    }, [mode, complete, trainColor, isUserTurn, plyIndex, totalPly, clearTransient, isShowingCorrectMove]);
     return {
         game,
         loading,
@@ -289,6 +308,8 @@ function useReplayTrainer({ gameId, startFen, fetchGame, onMiss, onComplete, })
         feedback,
         expectedSan,
         expectedUci,
+        correctMoveSquare,
+        displayFen,
         canPrev: plyIndex > 0,
         canNext: plyIndex < totalPly,
         goFirst,
@@ -438,7 +459,7 @@ const ReplayTrainer = ({ gameId, fetchGame, startFen, onMiss, onComplete, onExit
         ]
         : [];
     const draggable = training && !state.complete;
-    return (jsxRuntime.jsxs(reactChessCore.ThemeProvider, { theme: theme, boardTheme: boardTheme, children: [jsxRuntime.jsxs("div", { style: mainContainerStyle(boardWidth, colors), children: [jsxRuntime.jsxs("div", { style: headerStyle, children: [jsxRuntime.jsxs("span", { style: playerNameStyle, children: [((_b = game.white) !== null && _b !== void 0 ? _b : 'White'), " vs ", ((_c = game.black) !== null && _c !== void 0 ? _c : 'Black')] }), game.result && jsxRuntime.jsx("span", { style: subtleTextStyle(colors), children: game.result })] }), jsxRuntime.jsx(reactChessCore.ChessboardDnDProvider, { children: jsxRuntime.jsx(reactChessCore.HighlightChessboard, { boardWidth: boardWidth, checkSquare: "", hintSquare: null, incorrectMoveSquare: null, position: state.fen, boardOrientation: boardOrientation, arePiecesDraggable: draggable, isDraggablePiece: ({ piece }) => {
+    return (jsxRuntime.jsxs(reactChessCore.ThemeProvider, { theme: theme, boardTheme: boardTheme, children: [jsxRuntime.jsxs("div", { style: mainContainerStyle(boardWidth, colors), children: [jsxRuntime.jsxs("div", { style: headerStyle, children: [jsxRuntime.jsxs("span", { style: playerNameStyle, children: [((_b = game.white) !== null && _b !== void 0 ? _b : 'White'), " vs ", ((_c = game.black) !== null && _c !== void 0 ? _c : 'Black')] }), game.result && jsxRuntime.jsx("span", { style: subtleTextStyle(colors), children: game.result })] }), jsxRuntime.jsx(reactChessCore.ChessboardDnDProvider, { children: jsxRuntime.jsx(reactChessCore.HighlightChessboard, { boardWidth: boardWidth, checkSquare: "", hintSquare: null, incorrectMoveSquare: null, correctMoveSquare: state.correctMoveSquare, position: state.displayFen, boardOrientation: boardOrientation, arePiecesDraggable: draggable && !state.correctMoveSquare, isDraggablePiece: ({ piece }) => {
                                 if (state.trainColor === 'white')
                                     return piece[0] === 'w';
                                 if (state.trainColor === 'black')

package/package.json

@@ -1,56 +1,56 @@
-{
-  "name": "react-chess-replay-trainer",
-  "version": "0.0.2",
-  "description": "React component for browsing a chess game and drilling its moves, reporting misses (uses react-chess-core for board and analysis)",
-  "license": "MIT",
-  "author": "Robert Blackwell",
-  "main": "dist/index.js",
-  "module": "dist/index.esm.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "rollup -c",
-    "prepublishOnly": "npm run build",
-    "storybook": "storybook dev -p 6008",
-    "build-storybook": "storybook build"
-  },
-  "dependencies": {
-    "rollup": "^4.22.2",
-    "rollup-plugin-peer-deps-external": "^2.2.4",
-    "typescript": "^5.6.2"
-  },
-  "peerDependencies": {
-    "chess.js": "^1.0.0-beta.8",
-    "react": "^18.3.1",
-    "react-chess-core": "^0.1.1",
-    "react-chessboard": "^4.7.1"
-  },
-  "devDependencies": {
-    "@chromatic-com/storybook": "^1.9.0",
-    "@rollup/plugin-commonjs": "^26.0.1",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-typescript": "^12.3.0",
-    "@storybook/addon-essentials": "^8.2.9",
-    "@storybook/addon-interactions": "^8.2.9",
-    "@storybook/addon-links": "^8.2.9",
-    "@storybook/addon-onboarding": "^8.2.9",
-    "@storybook/blocks": "^8.2.9",
-    "@storybook/preset-typescript": "^3.0.0",
-    "@storybook/react": "^8.2.9",
-    "@storybook/react-vite": "^8.2.9",
-    "@storybook/test": "^8.2.9",
-    "@types/react": "^18.3.12",
-    "@types/react-dom": "^18.3.1",
-    "@vitejs/plugin-react": "^4.3.1",
-    "chess.js": "^1.0.0-beta.8",
-    "react": "^18.3.1",
-    "react-chess-core": "^0.1.1",
-    "react-chessboard": "^4.7.1",
-    "react-dom": "^18.3.1",
-    "storybook": "^8.2.9",
-    "tslib": "^2.8.1",
-    "vite-tsconfig-paths": "^5.0.1"
-  }
-}
+{
+  "name": "react-chess-replay-trainer",
+  "version": "0.0.4",
+  "description": "React component for browsing a chess game and drilling its moves, reporting misses (uses react-chess-core for board and analysis)",
+  "license": "MIT",
+  "author": "Robert Blackwell",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rollup -c",
+    "prepublishOnly": "npm run build",
+    "storybook": "storybook dev -p 6008",
+    "build-storybook": "storybook build"
+  },
+  "dependencies": {
+    "rollup": "^4.22.2",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "typescript": "^5.6.2"
+  },
+  "peerDependencies": {
+    "chess.js": "^1.0.0-beta.8",
+    "react": "^18.3.1",
+    "react-chess-core": "^0.1.1",
+    "react-chessboard": "^4.7.1"
+  },
+  "devDependencies": {
+    "@chromatic-com/storybook": "^1.9.0",
+    "@rollup/plugin-commonjs": "^26.0.1",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@storybook/addon-essentials": "^8.2.9",
+    "@storybook/addon-interactions": "^8.2.9",
+    "@storybook/addon-links": "^8.2.9",
+    "@storybook/addon-onboarding": "^8.2.9",
+    "@storybook/blocks": "^8.2.9",
+    "@storybook/preset-typescript": "^3.0.0",
+    "@storybook/react": "^8.2.9",
+    "@storybook/react-vite": "^8.2.9",
+    "@storybook/test": "^8.2.9",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.1",
+    "chess.js": "^1.0.0-beta.8",
+    "react": "^18.3.1",
+    "react-chess-core": "^0.1.1",
+    "react-chessboard": "^4.7.1",
+    "react-dom": "^18.3.1",
+    "storybook": "^8.2.9",
+    "tslib": "^2.8.1",
+    "vite-tsconfig-paths": "^5.0.1"
+  }
+}

package/dist/features/replay/miss/replayMissDisplay.d.ts

@@ -1,16 +0,0 @@
-export type MissSequencePhase = 'wrong' | 'refutation' | 'answer' | 'retry';
-export type MissSequenceState = {
-    setupFen: string;
-    attemptedUci: string;
-    phase: MissSequencePhase;
-};
-export type ReplayMissDisplay = {
-    fen: string | null;
-    arrows: [string, string, string][];
-    animating: boolean;
-};
-export declare const REPLAY_MISS_WRONG_PAUSE_MS = 450;
-export declare const REPLAY_MISS_REFUTATION_PAUSE_MS = 900;
-export declare const REPLAY_MISS_REFUTATION_MAX_WAIT_MS = 4000;
-export declare const REPLAY_MISS_MOVE_ANIMATION_MS = 220;
-export declare function getReplayMissDisplay(sequence: MissSequenceState | null, expectedUci: string | null, refutationUci: string | null, answerArrowColor: string): ReplayMissDisplay;

package/dist/features/replay/miss/useReplayMissBoard.d.ts

@@ -1,28 +0,0 @@
-import type { AnalysisEngineOptions } from 'react-chess-core';
-type ReplayMissFeedback = 'correct' | 'incorrect' | null;
-export declare function useReplayMissBoard({ feedback, expectedUci, positionFen, answerArrowColor, autoShowWrongMoves, engineOptions, }: {
-    feedback: ReplayMissFeedback;
-    expectedUci: string | null;
-    positionFen: string;
-    answerArrowColor: string;
-    autoShowWrongMoves?: boolean;
-    engineOptions?: AnalysisEngineOptions;
-}): {
-    missSequence: {
-        sequence: import("./replayMissDisplay").MissSequenceState | null;
-        refutation: import("..").ReplayRefutationResult;
-        display: import("./replayMissDisplay").ReplayMissDisplay;
-        startSequence: (setupFen: string, attemptedUci: string) => void;
-        clearSequence: () => void;
-    };
-    refutation: import("..").ReplayRefutationResult;
-    customArrows: [string, string, string][];
-    boardPosition: string;
-    boardAnimating: boolean;
-    wrapDropHandler: (onDrop: (source: string, target: string, piece: string) => boolean, { enabled, dropFen, expectedMoveUci, }: {
-        enabled: boolean;
-        dropFen?: string;
-        expectedMoveUci?: string | null;
-    }) => (source: string, target: string, piece: string) => boolean;
-};
-export {};

package/dist/features/replay/miss/useReplayMissSequence.d.ts

@@ -1,10 +0,0 @@
-import type { AnalysisEngineOptions } from 'react-chess-core';
-import { type MissSequencePhase, type MissSequenceState, type ReplayMissDisplay } from './replayMissDisplay';
-export type { MissSequencePhase, ReplayMissDisplay };
-export declare function useReplayMissSequence(feedback: 'correct' | 'incorrect' | null, expectedUci: string | null, engineOptions: AnalysisEngineOptions, answerArrowColor: string, autoShowWrongMoves: boolean): {
-    sequence: MissSequenceState | null;
-    refutation: import("..").ReplayRefutationResult;
-    display: ReplayMissDisplay;
-    startSequence: (setupFen: string, attemptedUci: string) => void;
-    clearSequence: () => void;
-};

package/dist/features/replay/miss/useReplayRefutation.d.ts

@@ -1,3 +0,0 @@
-import { type AnalysisEngineOptions } from 'react-chess-core';
-import { type ReplayRefutationResult } from '../refutation/replayRefutation';
-export declare function useReplayRefutation(setupFen: string | null, attemptedUci: string | null, expectedUci: string | null, enabled: boolean, engineOptions: AnalysisEngineOptions): ReplayRefutationResult;

package/dist/features/replay/refutation/replayRefutation.d.ts

@@ -1,19 +0,0 @@
-import { type AnalysisEngineOptions, type EngineEvaluation, type EngineLine } from 'react-chess-core';
-/** Minimum eval loss (pawns) from the wrong move before showing a refutation. */
-export declare const REPLAY_REFUTATION_EVAL_GAP_PAWNS = 0.5;
-export declare const REPLAY_REFUTATION_EVAL_GAP_CP: number;
-export type ReplayRefutationResult = {
-    fenAfterWrong: string | null;
-    refutationUci: string | null;
-    refutationSan: string | null;
-    refutationLine: string | null;
-    loading: boolean;
-    error: string | null;
-};
-export declare const replayRefutationEngineOptions: AnalysisEngineOptions;
-export declare function fenAfterUci(fen: string, uci: string): string | null;
-/** Centipawn score from side to move, comparable across sibling positions. */
-export declare function lineEvalCpForGap(line: EngineLine | undefined): number | null;
-/** How much better the opponent's eval is after the wrong move vs the correct one. */
-export declare function refutationEvalGapCp(evalAfterWrong: EngineEvaluation, evalAfterCorrect: EngineEvaluation): number | null;
-export declare function refutationFromEvaluation(fenAfterWrong: string, evaluation: EngineEvaluation, evalGapCp: number | null, evalGapApplies: boolean, evalGapLoading: boolean): Omit<ReplayRefutationResult, 'fenAfterWrong'>;