react-chess-puzzle-kit 1.0.0

package/dist/features/analysis/core/renderProps.d.ts

@@ -0,0 +1,39 @@
+import type { ReactNode } from 'react';
+import { EngineEvaluation } from 'react-chess-core';
+import { AnalysisHistoryRow, SolutionMoveDisplay } from './AnalysisPosition';
+import { AnalysisBoardModel } from './useAnalysisBoardModel';
+export type AnalysisControls = {
+    visible: boolean;
+    openAnalysis: () => void;
+};
+export type EngineEvaluationRenderProps = {
+    fen: string;
+    evaluation: EngineEvaluation;
+    theme: 'light' | 'dark';
+};
+export type AnalysisSidebarRenderProps = {
+    /** Main-line moves (legacy; prefer historyRows). */
+    moves: SolutionMoveDisplay[];
+    historyRows: AnalysisHistoryRow[];
+    isHistoryRowSelected: (row: AnalysisHistoryRow) => boolean;
+    onSelectHistoryRow: (row: AnalysisHistoryRow) => void;
+    ply: number;
+    maxPly: number;
+    onSelectPly: (ply: number) => void;
+    theme: 'light' | 'dark';
+    /** Host-rendered engine UI from `renderEngineEvaluation`. */
+    engineEvaluationPanel: ReactNode | null;
+};
+export type AnalysisContainerRenderProps = {
+    theme: 'light' | 'dark';
+    onClose: () => void;
+    children: ReactNode;
+    /** Used by {@link DefaultAnalysisContainer} for overlay dismiss (ignored by most hosts). */
+    onBackdropMouseDown?: () => void;
+};
+/** Place board + sidebar inside the analysis shell (host or default grid). */
+export type AnalysisMainRenderProps = {
+    model: AnalysisBoardModel;
+    board: ReactNode;
+    sidebar: ReactNode;
+};

package/dist/features/analysis/core/useAnalysisBoardModel.d.ts

@@ -0,0 +1,36 @@
+import { AnalysisHistoryRow, SolutionMoveDisplay } from './AnalysisPosition';
+import { PuzzleAnalysisContext } from './analysisContext';
+import { AnalysisEngineOptions, EngineEvaluation } from 'react-chess-core';
+export type UseAnalysisBoardModelArgs = {
+    analysisContext: PuzzleAnalysisContext;
+    onClose: () => void;
+    theme: 'light' | 'dark';
+    /** Chessboard pixel width (host-controlled). */
+    boardWidth: number;
+    engine?: AnalysisEngineOptions;
+};
+export type AnalysisBoardModel = {
+    theme: 'light' | 'dark';
+    boardWidth: number;
+    analysisContext: PuzzleAnalysisContext;
+    fen: string;
+    ply: number;
+    maxPly: number;
+    historyRows: AnalysisHistoryRow[];
+    solutionSans: SolutionMoveDisplay[];
+    boardOrientation: 'white' | 'black';
+    engineEvaluation: EngineEvaluation;
+    engineEnabled: boolean;
+    lastMove: {
+        from: string;
+        to: string;
+    } | null;
+    checkSquare: string | null;
+    onSelectPly: (ply: number) => void;
+    onSelectHistoryRow: (row: AnalysisHistoryRow) => void;
+    isHistoryRowSelected: (row: AnalysisHistoryRow) => boolean;
+    onPieceDrop: (sourceSquare: string, targetSquare: string, piece: string) => boolean;
+    onBackdropMouseDown: () => void;
+    onClose: () => void;
+};
+export declare const useAnalysisBoardModel: ({ analysisContext, onClose, theme, boardWidth, engine, }: UseAnalysisBoardModelArgs) => AnalysisBoardModel;

package/dist/features/analysis/core/usePuzzleAnalysis.d.ts

@@ -0,0 +1,10 @@
+import { PuzzlePosition } from '../../position/Position';
+import { PuzzleResultStatus } from './analysisContext';
+import { PuzzleAnalysisContext } from './analysisContext';
+export declare const usePuzzleAnalysis: (position: PuzzlePosition | null, resultStatus: PuzzleResultStatus, puzzleNum: number) => {
+    canOpen: boolean;
+    isOpen: boolean;
+    snapshot: PuzzleAnalysisContext | null;
+    openAnalysis: () => void;
+    closeAnalysis: () => void;
+};

package/dist/features/analysis/defaults/AnalysisBoard.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { AnalysisBoardCoreProps } from '../core/AnalysisBoardCore';
+import { AnalysisLayoutConfig } from '../core/analysisLayoutConfig';
+import { AnalysisContainerRenderProps, AnalysisMainRenderProps, AnalysisSidebarRenderProps, EngineEvaluationRenderProps } from '../core/renderProps';
+export interface AnalysisBoardProps extends Omit<AnalysisBoardCoreProps, 'renderContainer' | 'renderMain' | 'renderSidebar' | 'renderEngineEvaluation' | 'boardWidth'> {
+    layout?: AnalysisLayoutConfig;
+    renderContainer?: (props: AnalysisContainerRenderProps) => React.ReactNode;
+    renderMain?: (props: AnalysisMainRenderProps) => React.ReactNode;
+    renderSidebar?: (props: AnalysisSidebarRenderProps) => React.ReactNode;
+    renderEngineEvaluation?: (props: EngineEvaluationRenderProps) => React.ReactNode;
+}
+/**
+ * Full analysis UI with library defaults: modal shell, grid layout, sidebar, engine panel.
+ * For host-owned UI only, use {@link AnalysisBoardCore} and pass all render props.
+ */
+export declare const AnalysisBoard: ({ layout, renderContainer, renderMain, renderSidebar, renderEngineEvaluation, engine, ...modelArgs }: AnalysisBoardProps) => React.JSX.Element;

package/dist/features/analysis/defaults/AnalysisBoardLayout.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { AnalysisLayoutConfig } from '../core/analysisLayoutConfig';
+import { AnalysisBoardModel } from '../core/useAnalysisBoardModel';
+export type AnalysisBoardLayoutProps = {
+    layout: AnalysisLayoutConfig;
+    model: AnalysisBoardModel;
+    board: React.ReactNode;
+    sidebar: React.ReactNode;
+};
+/**
+ * Optional grid helper: board column + sidebar column.
+ * Hosts may use this in `renderMain` or supply their own layout.
+ */
+export declare const AnalysisBoardLayout: ({ layout, model, board, sidebar, }: AnalysisBoardLayoutProps) => React.JSX.Element;

package/dist/features/analysis/defaults/DefaultAnalysisContainer.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { AnalysisContainerRenderProps } from '../core/renderProps';
+/** Default full-screen modal shell for analysis (library preset UI). */
+export declare const DefaultAnalysisContainer: ({ theme, onClose, onBackdropMouseDown, children, }: AnalysisContainerRenderProps) => React.JSX.Element;

package/dist/features/analysis/defaults/DefaultAnalysisSidebar.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { AnalysisSidebarRenderProps } from '../core/renderProps';
+export declare const DefaultAnalysisSidebar: ({ historyRows, isHistoryRowSelected, onSelectHistoryRow, ply, maxPly, onSelectPly, theme, engineEvaluationPanel, }: AnalysisSidebarRenderProps) => React.JSX.Element;

package/dist/features/analysis/defaults/analysisLayout.d.ts

@@ -0,0 +1,3 @@
+import { AnalysisLayoutConfig } from '../core/analysisLayoutConfig';
+/** Library default grid; hosts should pass their own {@link AnalysisLayoutConfig}. */
+export declare const DEFAULT_ANALYSIS_LAYOUT: AnalysisLayoutConfig;

package/dist/features/analysis/defaults/analysisModalStyles.d.ts

@@ -0,0 +1,7 @@
+import { CSSProperties } from 'react';
+export type AnalysisModalStyles = {
+    panel: CSSProperties;
+    title: CSSProperties;
+    closeButton: CSSProperties;
+};
+export declare const getAnalysisModalStyles: (theme: "light" | "dark") => AnalysisModalStyles;

package/dist/features/analysis/defaults/analysisSidebarColors.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Move-list colors for the analysis board sidebar.
+ * Tweak values here when iterating on history row striping.
+ */
+export declare const analysisSidebarColors: {
+    /** Selected move row */
+    readonly activeMove: {
+        readonly light: "rgba(119, 177, 212, 1)";
+        readonly dark: "rgba(90, 159, 190, 1)";
+    };
+    /** Start row */
+    readonly start: {
+        readonly light: "#e8e8e8";
+        readonly dark: "#262626";
+    };
+    /** Alternating main-line rows (index 0 = darker, 1 = lighter). */
+    readonly mainStripe: readonly [{
+        readonly light: "#c9c9c9";
+        readonly dark: "#1c1c1c";
+    }, {
+        readonly light: "#f2f2f2";
+        readonly dark: "#383838";
+    }];
+    /** Alternating user-variation rows (index 0 = slightly tinted, 1 = lighter). */
+    readonly variationStripe: readonly [{
+        readonly light: "#eef5fb";
+        readonly dark: "#2c3540";
+    }, {
+        readonly light: "#f7fbfe";
+        readonly dark: "#343f4c";
+    }];
+    /** Text on variation rows (light backgrounds need dark type). */
+    readonly variationText: {
+        readonly light: "rgba(0, 0, 0, 0.87)";
+        readonly dark: "rgba(0, 0, 0, 0.87)";
+    };
+};

package/dist/features/analysis/defaults/analysisSidebarRowStyle.d.ts

@@ -0,0 +1,8 @@
+import { AnalysisHistoryRow } from '../core/AnalysisPosition';
+export type SidebarRowBandCounters = {
+    main: number;
+    variation: number;
+};
+export declare const createSidebarRowBandCounters: () => SidebarRowBandCounters;
+/** Background for one analysis history row; mutates `bands` while iterating rows in order. */
+export declare const getSidebarRowBackground: (theme: "light" | "dark", row: AnalysisHistoryRow, bands: SidebarRowBandCounters) => string;

package/dist/features/analysis/defaults/index.d.ts

@@ -0,0 +1,8 @@
+export * from './analysisModalStyles';
+export * from './analysisSidebarColors';
+export * from './analysisSidebarRowStyle';
+export * from './analysisLayout';
+export * from './AnalysisBoard';
+export * from './AnalysisBoardLayout';
+export * from './DefaultAnalysisContainer';
+export * from './DefaultAnalysisSidebar';

package/dist/features/analysis/index.d.ts

@@ -0,0 +1,3 @@
+export { buildAnalysisContext, emptyAnalysisContext, isAnalysisAvailable, } from './analysisContext';
+export type { PuzzleAnalysisContext, PuzzleResultStatus } from './analysisContext';
+export { usePuzzleAnalysis } from './usePuzzleAnalysis';

package/dist/features/analysis/renderProps.d.ts

@@ -0,0 +1,39 @@
+import type { ReactNode } from 'react';
+import { EngineEvaluation } from '../engine/types';
+import { AnalysisHistoryRow, SolutionMoveDisplay } from './AnalysisPosition';
+import { AnalysisBoardModel } from './useAnalysisBoardModel';
+export type AnalysisControls = {
+    visible: boolean;
+    openAnalysis: () => void;
+};
+export type EngineEvaluationRenderProps = {
+    fen: string;
+    evaluation: EngineEvaluation;
+    theme: 'light' | 'dark';
+};
+export type AnalysisSidebarRenderProps = {
+    /** Main-line moves (legacy; prefer historyRows). */
+    moves: SolutionMoveDisplay[];
+    historyRows: AnalysisHistoryRow[];
+    isHistoryRowSelected: (row: AnalysisHistoryRow) => boolean;
+    onSelectHistoryRow: (row: AnalysisHistoryRow) => void;
+    ply: number;
+    maxPly: number;
+    onSelectPly: (ply: number) => void;
+    theme: 'light' | 'dark';
+    /** Host-rendered engine UI from `renderEngineEvaluation`. */
+    engineEvaluationPanel: ReactNode | null;
+};
+export type AnalysisContainerRenderProps = {
+    theme: 'light' | 'dark';
+    onClose: () => void;
+    children: ReactNode;
+    /** Used by {@link DefaultAnalysisContainer} for overlay dismiss (ignored by most hosts). */
+    onBackdropMouseDown?: () => void;
+};
+/** Place board + sidebar inside the analysis shell (host or default grid). */
+export type AnalysisMainRenderProps = {
+    model: AnalysisBoardModel;
+    board: ReactNode;
+    sidebar: ReactNode;
+};

package/dist/features/analysis/useAnalysisBoardModel.d.ts

@@ -0,0 +1,33 @@
+import { AnalysisHistoryRow, SolutionMoveDisplay } from './AnalysisPosition';
+import { PuzzleAnalysisContext } from './analysisContext';
+import { AnalysisEngineOptions, EngineEvaluation } from '../engine';
+export type UseAnalysisBoardModelArgs = {
+    analysisContext: PuzzleAnalysisContext;
+    onClose: () => void;
+    theme: 'light' | 'dark';
+    engine?: AnalysisEngineOptions;
+};
+export type AnalysisBoardModel = {
+    theme: 'light' | 'dark';
+    analysisContext: PuzzleAnalysisContext;
+    fen: string;
+    ply: number;
+    maxPly: number;
+    historyRows: AnalysisHistoryRow[];
+    solutionSans: SolutionMoveDisplay[];
+    boardOrientation: 'white' | 'black';
+    engineEvaluation: EngineEvaluation;
+    engineEnabled: boolean;
+    lastMove: {
+        from: string;
+        to: string;
+    } | null;
+    checkSquare: string | null;
+    onSelectPly: (ply: number) => void;
+    onSelectHistoryRow: (row: AnalysisHistoryRow) => void;
+    isHistoryRowSelected: (row: AnalysisHistoryRow) => boolean;
+    onPieceDrop: (sourceSquare: string, targetSquare: string, piece: string) => boolean;
+    onBackdropMouseDown: () => void;
+    onClose: () => void;
+};
+export declare const useAnalysisBoardModel: ({ analysisContext, onClose, theme, engine, }: UseAnalysisBoardModelArgs) => AnalysisBoardModel;

package/dist/features/analysis/usePuzzleAnalysis.d.ts

@@ -0,0 +1,10 @@
+import type { AnalysisContext } from 'react-chess-core';
+import { PuzzlePosition } from '../position/Position';
+import { PuzzleResultStatus } from './analysisContext';
+export declare const usePuzzleAnalysis: (position: PuzzlePosition | null, resultStatus: PuzzleResultStatus, puzzleNum: number) => {
+    canOpen: boolean;
+    isOpen: boolean;
+    snapshot: AnalysisContext | null;
+    openAnalysis: () => void;
+    closeAnalysis: () => void;
+};

package/dist/features/board/BlankPuzzleBoard.d.ts

@@ -0,0 +1,5 @@
+export interface BlankPuzzleBoardProps {
+    boardWidth: number;
+}
+/** Placeholder board that preserves puzzle layout while the next position loads. */
+export declare const BlankPuzzleBoard: ({ boardWidth }: BlankPuzzleBoardProps) => import("react").JSX.Element;

package/dist/features/board/HighlightChessboard.d.ts

@@ -0,0 +1,2 @@
+export { HighlightChessboard } from 'react-chess-core';
+export type { HighlightChessboardProps } from 'react-chess-core';

package/dist/features/board/LineBoard.d.ts

@@ -0,0 +1,15 @@
+import type { LineTrainSide } from './LineBoardWithControls';
+export interface LineBoardProps {
+    fen: string;
+    orientation: 'white' | 'black';
+    trainSide: LineTrainSide;
+    draggable: boolean;
+    onPieceDrop: (source: string, target: string, piece: string) => boolean;
+    boardWidth: number;
+}
+/**
+ * Board view for line drilling: a plain themed board that only lets the trainer
+ * side's pieces be dragged. Move validation and sequencing live in
+ * {@link LineBoardWithControls}.
+ */
+export declare const LineBoard: ({ fen, orientation, trainSide, draggable, onPieceDrop, boardWidth, }: LineBoardProps) => import("react").JSX.Element;

package/dist/features/board/LineBoardWithControls.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+export type LineTrainSide = 'w' | 'b';
+/** A line to drill: a start position plus the moves to walk, from one side. */
+export interface LineSpec {
+    startFen: string;
+    movesUci: string[];
+    /** Optional SAN parallel to {@link movesUci} for nicer feedback labels. */
+    movesSan?: string[];
+    /** The side the user plays; the other side is auto-played. */
+    trainSide: LineTrainSide;
+}
+export interface LineMoveResult {
+    /** Index into {@link LineSpec.movesUci}. */
+    index: number;
+    isCorrect: boolean;
+}
+export interface LineMoveFeedback extends LineMoveResult {
+    expectedSan: string;
+}
+/** State handed to the controls renderer on every render. */
+export interface LineControlsRenderProps {
+    trainSide: LineTrainSide;
+    /** 1-based number of the move currently in focus. */
+    moveNumber: number;
+    total: number;
+    finished: boolean;
+    isUserTurn: boolean;
+    feedback: LineMoveFeedback | null;
+}
+export interface LineBoardWithControlsProps {
+    theme: 'light' | 'dark';
+    line: LineSpec;
+    /** Called once when the whole line has been walked. */
+    onComplete: (perMove: LineMoveResult[]) => void;
+    /** Optional per-move callback as each user move is graded. */
+    onMove?: (feedback: LineMoveFeedback) => void;
+    /** Omit to use {@link defaultRenderLineControls}. */
+    renderControls?: (props: LineControlsRenderProps) => React.ReactNode;
+    boardWidth?: number;
+    /** Delay before auto-playing each opponent move (ms). */
+    opponentMoveDelayMs?: number;
+}
+/**
+ * Guided line-drill board: walks a known move sequence, auto-playing the
+ * opponent and grading each of the trainer's moves against the line. Mirrors
+ * {@link PuzzleBoardWithControls} but for opening/line repetition rather than
+ * tactical puzzles. Mount one instance per drill (key it by line) so its
+ * internal state resets between lines.
+ */
+export declare const LineBoardWithControls: ({ theme, line, onComplete, onMove, renderControls, boardWidth, opponentMoveDelayMs, }: LineBoardWithControlsProps) => React.JSX.Element;

package/dist/features/board/PuzzleBoard.d.ts

@@ -0,0 +1,10 @@
+import { PuzzlePosition } from '../position/Position';
+export interface PuzzleBoardProps {
+    position: PuzzlePosition;
+    onFeedback: (feedbackData: any) => void;
+    incInteractionNum: () => void;
+    boardWidth: number;
+    /** After a wrong guess, play the correct move instead of allowing retries. */
+    revealAnswerOnIncorrect?: boolean;
+}
+export declare const PuzzleBoard: ({ position, onFeedback, incInteractionNum, boardWidth, revealAnswerOnIncorrect, }: PuzzleBoardProps) => import("react").JSX.Element;

package/dist/features/board/PuzzleBoardWithControls.d.ts

@@ -0,0 +1,51 @@
+import React from 'react';
+import { PuzzleResultStatus } from '../analysis';
+import { AnalysisContainerRenderProps, AnalysisControls, AnalysisEngineOptions, AnalysisLayoutConfig, AnalysisMainRenderProps, AnalysisSidebarRenderProps, EngineEvaluationRenderProps } from 'react-chess-core';
+import { type PuzzleControlState } from './defaults/DefaultPuzzleControls';
+export type { PuzzleMoveRecord } from '../position/moveHistory';
+export type { AnalysisContainerRenderProps, AnalysisControls, AnalysisLayoutConfig, AnalysisMainRenderProps, AnalysisSidebarRenderProps, EngineEvaluationRenderProps, } from 'react-chess-core';
+export type { PuzzleAnalysisContext, PuzzleResultStatus } from '../analysis';
+export { DEFAULT_ANALYSIS_LAYOUT } from 'react-chess-core';
+export { DEFAULT_PUZZLE_BOARD_WIDTH } from './puzzleBoardLayout';
+export { DefaultPuzzleControls, defaultRenderControls, } from './defaults/DefaultPuzzleControls';
+export type { PuzzleControlState, PuzzleControlsRenderProps, } from './defaults/DefaultPuzzleControls';
+export interface PuzzleBoardWithControlsProps {
+    theme: 'light' | 'dark';
+    apiProxy: {
+        onFetch: () => Promise<{
+            fen: string;
+            moves: string[];
+        }>;
+        /** Called when {@link onFetch} rejects (e.g. network / server down). */
+        onFetchError?: (error: unknown) => void;
+        onFeedback: (feedbackData: {
+            index: number;
+            guess?: {
+                sourceSquare: string;
+                targetSquare: string;
+                piece: string;
+            };
+            hintRequested?: boolean;
+            solutionShown?: boolean;
+            isCorrect?: boolean;
+            isFinished?: boolean;
+        }) => void;
+    };
+    /** Omit to use {@link defaultRenderControls} / {@link DefaultPuzzleControls}. */
+    renderControls?: (showHint: () => void, showSolution: () => void, nextPuzzle: () => void, resultStatus: PuzzleResultStatus, analysis: AnalysisControls, controlState: PuzzleControlState) => React.ReactNode;
+    renderAnalysisSidebar?: (props: AnalysisSidebarRenderProps) => React.ReactNode;
+    renderAnalysisContainer?: (props: AnalysisContainerRenderProps) => React.ReactNode;
+    renderEngineEvaluation?: (props: EngineEvaluationRenderProps) => React.ReactNode;
+    /** Pixel width of the live puzzle board (separate from analysis). */
+    puzzleBoardWidth?: number;
+    /** Board + sidebar grid sizes when analysis is open. */
+    analysisLayout?: AnalysisLayoutConfig;
+    /** Custom board/sidebar placement (overrides {@link analysisLayout} grid). */
+    renderAnalysisMain?: (props: AnalysisMainRenderProps) => React.ReactNode;
+    engine?: AnalysisEngineOptions;
+    /** After a clean solve (no wrong move, hint, or solution reveal), load the next card. */
+    autoAdvanceOnComplete?: boolean;
+    /** After a wrong guess, play the correct move and wait for the user to advance. */
+    revealAnswerOnIncorrect?: boolean;
+}
+export declare const PuzzleBoardWithControls: ({ theme, apiProxy, renderControls, renderAnalysisSidebar, renderAnalysisContainer, renderEngineEvaluation, puzzleBoardWidth, analysisLayout, renderAnalysisMain, engine, autoAdvanceOnComplete, revealAnswerOnIncorrect, }: PuzzleBoardWithControlsProps) => React.JSX.Element;

package/dist/features/board/PuzzlePlaySurface.d.ts

@@ -0,0 +1,25 @@
+import { PuzzlePosition } from '../position/Position';
+export interface PuzzlePlaySurfaceProps {
+    position: PuzzlePosition | null;
+    onFeedback: (feedbackData: {
+        index: number;
+        guess?: {
+            sourceSquare: string;
+            targetSquare: string;
+            piece: string;
+        };
+        hintRequested?: boolean;
+        solutionShown?: boolean;
+        isCorrect?: boolean;
+        isFinished?: boolean;
+    }) => void;
+    incInteractionNum: () => void;
+    boardWidth: number;
+    /** After a wrong guess, play the correct move instead of allowing retries. */
+    revealAnswerOnIncorrect?: boolean;
+}
+/**
+ * Single mounted board for puzzle play. Shows an empty board while the next
+ * position loads so the layout and controls do not flicker between cards.
+ */
+export declare const PuzzlePlaySurface: ({ position, onFeedback, incInteractionNum, boardWidth, revealAnswerOnIncorrect, }: PuzzlePlaySurfaceProps) => import("react").JSX.Element;

package/dist/features/board/boardSquareHighlightColors.d.ts

@@ -0,0 +1 @@
+export { boardSquareHighlightColors } from 'react-chess-core';

package/dist/features/board/chessboardTheme.d.ts

@@ -0,0 +1,2 @@
+export { ChessboardThemeContext, ThemeProvider, getStylesForTheme, useChessboardTheme, useTheme, } from 'react-chess-core';
+export type { ThemeProviderProps } from 'react-chess-core';

package/dist/features/board/defaults/DefaultLineControls.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { LineControlsRenderProps } from '../LineBoardWithControls';
+/** Library default line-drill status controls (unstyled). */
+export declare const DefaultLineControls: ({ moveNumber, total, finished, isUserTurn, feedback, }: LineControlsRenderProps) => React.JSX.Element;
+export declare const defaultRenderLineControls: (props: LineControlsRenderProps) => React.JSX.Element;

package/dist/features/board/defaults/DefaultPuzzleControls.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { PuzzleResultStatus } from '../../analysis';
+import { AnalysisControls } from 'react-chess-core';
+export type PuzzleControlState = {
+    canShowHint: boolean;
+    canShowSolution: boolean;
+};
+export type PuzzleControlsRenderProps = {
+    showHint: () => void;
+    showSolution: () => void;
+    nextPuzzle: () => void;
+    resultStatus: PuzzleResultStatus;
+    analysis: AnalysisControls;
+    controlState: PuzzleControlState;
+};
+/** Library default hint / next / analysis / result controls (unstyled buttons). */
+export declare const DefaultPuzzleControls: ({ showHint, showSolution, nextPuzzle, resultStatus, analysis, controlState, }: PuzzleControlsRenderProps) => React.JSX.Element;
+export declare const defaultRenderControls: (showHint: () => void, showSolution: () => void, nextPuzzle: () => void, resultStatus: PuzzleResultStatus, analysis: AnalysisControls, controlState: PuzzleControlState) => React.JSX.Element;

package/dist/features/board/defaults/index.d.ts

@@ -0,0 +1 @@
+export * from './DefaultPuzzleControls';

package/dist/features/board/puzzleBoardLayout.d.ts

@@ -0,0 +1,8 @@
+import { CSSProperties } from 'react';
+/** Default pixel width for the live puzzle board (analysis uses {@link DEFAULT_ANALYSIS_LAYOUT}). */
+export declare const DEFAULT_PUZZLE_BOARD_WIDTH = 480;
+/** Minimum height reserved below the board so controls do not shift when status changes. */
+export declare const PUZZLE_CONTROLS_MIN_HEIGHT = 96;
+export declare const puzzlePlayColumnStyle: (boardWidth: number) => CSSProperties;
+export declare const puzzleBoardSlotStyle: () => CSSProperties;
+export declare const puzzleControlsSlotStyle: () => CSSProperties;

package/dist/features/engine/EngineEvaluationPanel.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { type EngineEvaluation } from 'react-chess-core';
+export interface EngineEvaluationPanelProps {
+    fen: string;
+    evaluation: EngineEvaluation;
+    theme: 'light' | 'dark';
+}
+export declare const EngineEvaluationPanel: ({ fen, evaluation, theme, }: EngineEvaluationPanelProps) => React.JSX.Element;

package/dist/features/engine/StockfishBrowserEngine.d.ts

@@ -0,0 +1 @@
+export { StockfishBrowserEngine } from 'react-chess-core';

package/dist/features/engine/formatEvaluation.d.ts

@@ -0,0 +1 @@
+export { formatEvaluation, formatPvPreview, normalizeEvalForWhite, uciPvToSan, } from 'react-chess-core';

package/dist/features/engine/index.d.ts

@@ -0,0 +1 @@
+export { EngineEvaluationPanel, type EngineEvaluationPanelProps, } from './EngineEvaluationPanel';

package/dist/features/engine/isAnalyzableFen.d.ts

@@ -0,0 +1 @@
+export { isAnalyzableFen } from 'react-chess-core';

package/dist/features/engine/parseUciInfo.d.ts

@@ -0,0 +1 @@
+export { parseUciInfoLine } from 'react-chess-core';

package/dist/features/engine/stockfishUrls.d.ts

@@ -0,0 +1 @@
+export { resolveStockfishScriptUrl, resolveStockfishWasmUrl, resolveStockfishWorkerUrl, } from 'react-chess-core';

package/dist/features/engine/types.d.ts

@@ -0,0 +1 @@
+export * from 'react-chess-core';

package/dist/features/engine/useAnalysisEngine.d.ts

@@ -0,0 +1 @@
+export { useAnalysisEngine } from 'react-chess-core';

package/dist/features/position/Position.d.ts

@@ -0,0 +1,67 @@
+import { Traversable } from './Traversable';
+import { Chess } from 'chess.js';
+import { PuzzleMoveRecord } from './moveHistory';
+/** Apply a UCI move (e.g. `e7e8q`) without throwing. */
+export declare function applyUciMove(chess: Chess, uci: string): boolean;
+export declare abstract class Position implements Traversable {
+    protected chess: Chess;
+    protected moves: string[];
+    protected i: number;
+    constructor();
+    getIndex(): number;
+    next(): boolean;
+    prev(): boolean;
+    isFinished(): boolean;
+    /** True when a correct guess at the current index completes the puzzle. */
+    isCompletedByCorrectGuess(): boolean;
+    fen(): string;
+    getCheckSquare(): string;
+}
+export declare function getCheckSquareFromChess(chess: Chess): string;
+/** Side to move for the final (user) ply in a puzzle line. */
+export declare function playerColorForSolution(initialFen: string, moves: string[]): 'white' | 'black';
+export declare class PuzzlePosition extends Position {
+    protected isCorrect: boolean;
+    protected guessedMove: string;
+    protected isHintWanted: boolean;
+    protected solutionRevealed: boolean;
+    protected playerColor: string;
+    protected readonly initialFen: string;
+    protected moveHistory: PuzzleMoveRecord[];
+    private usedAlternativeCheckmate;
+    constructor(initialFEN: string, moves: string[]);
+    next(): boolean;
+    getInitialFen(): string;
+    getSolutionMoves(): string[];
+    getMoveHistory(): PuzzleMoveRecord[];
+    recordHint(): void;
+    recordSolutionShown(): void;
+    setSolutionRevealed(revealed: boolean): void;
+    isSolutionRevealed(): boolean;
+    /** Reset the board to replay an already-revealed solution walkthrough. */
+    replaySolution(): void;
+    /** Chess-legal move from the current puzzle position (ignores solution line). */
+    isLegalMove(sourceSquare: string, targetSquare: string): boolean;
+    private buildCandidateUcis;
+    private tryMakeUciMove;
+    private isCheckmatingMove;
+    private applyCheckmateGuess;
+    tryGuess: (sourceSquare: string, targetSquare: string, piece: string) => {
+        accepted: boolean;
+        finished: boolean;
+    };
+    judgeGuess: (sourceSquare: string, targetSquare: string, piece: string) => boolean;
+    resetInteractions(): void;
+    /** Play the expected move at the current index and lock further input. */
+    revealCorrectMove(): boolean;
+    /** True when the last correct guess applied an alternative checkmate. */
+    isAlternativeCheckmate(): boolean;
+    wantsHint(wants: boolean): void;
+    getHintSquare(): string;
+    private hint;
+    getIncorrectMoveSquare(): string;
+    getPlayerColor(): string;
+}
+export declare class GamePosition extends Position {
+    constructor(PGN: string);
+}

package/dist/features/position/Position.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/position/Traversable.d.ts

@@ -0,0 +1,4 @@
+export interface Traversable {
+    next(): boolean;
+    prev(): boolean;
+}

package/dist/features/position/moveHistory.d.ts

@@ -0,0 +1,7 @@
+export type PuzzleMoveRecord = {
+    ply: number;
+    uci: string;
+    san?: string;
+    actor: 'player' | 'opponent' | 'attempt';
+    isCorrect?: boolean;
+};