@alepot55/chessboardjs 2.2.1 → 2.3.3

package/src/services/PieceService.js

@@ -0,0 +1,303 @@
+/**
+ * Service for managing chess pieces and their operations
+ * @module services/PieceService
+ * @since 2.0.0
+ */
+
+import Piece from '../components/Piece.js';
+import { PieceError, ValidationError } from '../errors/ChessboardError.js';
+import { ERROR_MESSAGES } from '../errors/messages.js';
+import { PIECE_TYPES, PIECE_COLORS } from '../constants/positions.js';
+
+/**
+ * Service responsible for piece management and operations
+ * @class
+ */
+export class PieceService {
+    /**
+     * Creates a new PieceService instance
+     * @param {ChessboardConfig} config - Board configuration
+     */
+    constructor(config) {
+        this.config = config;
+    }
+
+    /**
+     * Gets the path to a piece asset
+     * @param {string} piece - Piece identifier (e.g., 'wK', 'bP')
+     * @returns {string} Path to piece asset
+     * @throws {ValidationError} When piecesPath configuration is invalid
+     */
+    getPiecePath(piece) {
+        const { piecesPath } = this.config;
+
+        if (typeof piecesPath === 'string') {
+            return `${piecesPath}/${piece}.svg`;
+        } else if (typeof piecesPath === 'object' && piecesPath !== null) {
+            return piecesPath[piece];
+        } else if (typeof piecesPath === 'function') {
+            return piecesPath(piece);
+        } else {
+            throw new ValidationError(ERROR_MESSAGES.invalid_piecesPath, 'piecesPath', piecesPath);
+        }
+    }
+
+    /**
+     * Converts various piece formats to a Piece instance
+     * @param {string|Piece} piece - Piece in various formats
+     * @returns {Piece} Piece instance
+     * @throws {PieceError} When piece format is invalid
+     */
+    convertPiece(piece) {
+        if (piece instanceof Piece) {
+            return piece;
+        }
+
+        if (typeof piece === 'string' && piece.length === 2) {
+            const [first, second] = piece.split('');
+            let type, color;
+
+            // Check format: [type][color] (e.g., 'pw')
+            if (PIECE_TYPES.includes(first.toLowerCase()) && PIECE_COLORS.includes(second)) {
+                type = first.toLowerCase();
+                color = second;
+            }
+            // Check format: [color][type] (e.g., 'wP')
+            else if (PIECE_COLORS.includes(first) && PIECE_TYPES.includes(second.toLowerCase())) {
+                color = first;
+                type = second.toLowerCase();
+            } else {
+                throw new PieceError(ERROR_MESSAGES.invalid_piece + piece, piece);
+            }
+
+            const piecePath = this.getPiecePath(type + color);
+            return new Piece(color, type, piecePath);
+        }
+
+        throw new PieceError(ERROR_MESSAGES.invalid_piece + piece, piece);
+    }
+
+    /**
+     * Adds a piece to a square with optional fade-in animation
+     * @param {Square} square - Target square
+     * @param {Piece} piece - Piece to add
+     * @param {boolean} [fade=true] - Whether to fade in the piece
+     * @param {Function} dragFunction - Function to handle drag events
+     * @param {Function} [callback] - Callback when animation completes
+     */
+    addPieceOnSquare(square, piece, fade = true, dragFunction, callback) {
+        console.debug(`[PieceService] addPieceOnSquare: ${piece.id} to ${square.id}`);
+        square.putPiece(piece);
+
+        if (dragFunction) {
+            piece.setDrag(dragFunction(square, piece));
+        }
+
+        if (fade && this.config.fadeTime > 0) {
+            piece.fadeIn(
+                this.config.fadeTime,
+                this.config.fadeAnimation,
+                this._getTransitionTimingFunction(),
+                callback
+            );
+        } else {
+            if (callback) callback();
+        }
+
+        piece.visible();
+    }
+
+    /**
+     * Removes a piece from a square with optional fade-out animation
+     * @param {Square} square - Source square
+     * @param {boolean} [fade=true] - Whether to fade out the piece
+     * @param {Function} [callback] - Callback when animation completes
+     * @returns {Piece} The removed piece
+     * @throws {PieceError} When square has no piece to remove
+     */
+    removePieceFromSquare(square, fade = true, callback) {
+        console.debug(`[PieceService] removePieceFromSquare: ${square.id}`);
+        square.check();
+
+        const piece = square.piece;
+        if (!piece) {
+            if (callback) callback();
+            throw new PieceError(ERROR_MESSAGES.square_no_piece, null, square.getId());
+        }
+
+        if (fade && this.config.fadeTime > 0) {
+            piece.fadeOut(
+                this.config.fadeTime,
+                this.config.fadeAnimation,
+                this._getTransitionTimingFunction(),
+                callback
+            );
+        } else {
+            if (callback) callback();
+        }
+
+        square.removePiece();
+        return piece;
+    }
+
+    /**
+     * Moves a piece to a new position with animation
+     * @param {Piece} piece - Piece to move
+     * @param {Square} targetSquare - Target square
+     * @param {number} duration - Animation duration
+     * @param {Function} [callback] - Callback function when animation completes
+     */
+    movePiece(piece, targetSquare, duration, callback) {
+        console.debug(`[PieceService] movePiece: ${piece.id} to ${targetSquare.id}`);
+        if (!piece) {
+            console.warn('PieceService.movePiece: piece is null, skipping animation');
+            if (callback) callback();
+            return;
+        }
+
+        piece.translate(
+            targetSquare,
+            duration,
+            this._getTransitionTimingFunction(),
+            this.config.moveAnimation,
+            callback
+        );
+    }
+
+    /**
+     * Handles piece translation with optional capture
+     * @param {Move} move - Move object containing from/to squares and piece
+     * @param {boolean} removeTarget - Whether to remove piece from target square
+     * @param {boolean} animate - Whether to animate the move
+     * @param {Function} [dragFunction] - Function to create drag handlers
+     * @param {Function} [callback] - Callback function when complete
+     */
+    translatePiece(move, removeTarget, animate, dragFunction = null, callback = null) {
+        console.debug(`[PieceService] translatePiece: ${move.piece.id} from ${move.from.id} to ${move.to.id}`);
+        if (!move.piece) {
+            console.warn('PieceService.translatePiece: move.piece is null, skipping translation');
+            if (callback) callback();
+            return;
+        }
+
+        if (removeTarget) {
+            // Deselect the captured piece before removing it
+            move.to.deselect();
+            this.removePieceFromSquare(move.to, false);
+        }
+
+        const changeSquareCallback = () => {
+            // Check if piece still exists and is on the source square
+            if (move.from.piece === move.piece) {
+                move.from.removePiece(true); // Preserve the piece when moving
+            }
+
+            // Only put piece if destination square doesn't already have it
+            if (move.to.piece !== move.piece) {
+                move.to.putPiece(move.piece);
+
+                // Re-attach drag handler if provided
+                if (dragFunction && this.config.draggable && move.piece.element) {
+                    move.piece.setDrag(dragFunction(move.to, move.piece));
+                }
+            }
+
+            if (callback) callback();
+        };
+
+        // Check if piece is currently being dragged
+        const isDragging = move.piece.element.classList.contains('dragging');
+
+        if (isDragging) {
+            // If piece is being dragged, don't animate - just move it immediately
+            // The piece is already visually in the correct position from the drag
+            changeSquareCallback();
+        } else {
+            // Normal animation
+            const duration = animate ? this.config.moveTime : 0;
+            this.movePiece(move.piece, move.to, duration, changeSquareCallback);
+        }
+    }
+
+    /**
+     * Snaps a piece back to its original position
+     * @param {Square} square - Square containing the piece
+     * @param {boolean} [animate=true] - Whether to animate the snapback
+     */
+    snapbackPiece(square, animate = true) {
+        if (!square || !square.piece) {
+            return;
+        }
+        const piece = square.piece;
+        const duration = animate ? this.config.snapbackTime : 0;
+        console.debug(`[PieceService] snapbackPiece: ${piece.id} on ${square.id}`);
+        piece.translate(
+            square,
+            duration,
+            this._getTransitionTimingFunction(),
+            this.config.snapbackAnimation
+        );
+    }
+
+    /**
+     * Centers a piece in its square with animation (after successful drop)
+     * @param {Square} square - Square containing the piece to center
+     * @param {boolean} animate - Whether to animate the centering
+     */
+    centerPiece(square, animate = true) {
+        if (!square || !square.piece) {
+            return;
+        }
+        const piece = square.piece;
+        const duration = animate ? this.config.dropCenterTime : 0;
+        console.debug(`[PieceService] centerPiece: ${piece.id} on ${square.id}`);
+        piece.translate(
+            square,
+            duration,
+            this._getTransitionTimingFunction(),
+            this.config.dropCenterAnimation,
+            () => {
+                // After animation, reset all drag-related styles
+                if (!piece.element) return;
+                piece.element.style.position = '';
+                piece.element.style.left = '';
+                piece.element.style.top = '';
+                piece.element.style.transform = '';
+                piece.element.style.zIndex = '';
+            }
+        );
+    }
+
+    /**
+     * Gets the transition timing function for animations
+     * @private
+     * @returns {Function} Timing function
+     */
+    _getTransitionTimingFunction() {
+        return (elapsed, duration, type = 'ease') => {
+            const x = elapsed / duration;
+
+            switch (type) {
+                case 'linear':
+                    return x;
+                case 'ease':
+                    return (x ** 2) * (3 - 2 * x);
+                case 'ease-in':
+                    return x ** 2;
+                case 'ease-out':
+                    return -1 * (x - 1) ** 2 + 1;
+                case 'ease-in-out':
+                    return (x < 0.5) ? 2 * x ** 2 : 4 * x - 2 * x ** 2 - 1;
+                default:
+                    return x;
+            }
+        };
+    }
+
+    /**
+     * Cleans up resources
+     */
+    destroy() {
+        // Cleanup any cached pieces or references
+    }
+}

package/src/services/PositionService.js

@@ -0,0 +1,237 @@
+/**
+ * Service for managing chess positions and FEN conversion
+ * @module services/PositionService
+ * @since 2.0.0
+ */
+
+import { Chess, validateFen } from '../utils/chess.js';
+import { STANDARD_POSITIONS, DEFAULT_STARTING_POSITION, BOARD_LETTERS } from '../constants/positions.js';
+import { ValidationError } from '../errors/ChessboardError.js';
+import { ERROR_MESSAGES } from '../errors/messages.js';
+
+/**
+ * Service responsible for position management and FEN operations
+ * @class
+ */
+export class PositionService {
+    /**
+     * Creates a new PositionService instance
+     * @param {ChessboardConfig} config - Board configuration
+     */
+    constructor(config) {
+        this.config = config;
+        this.game = null;
+    }
+
+    /**
+     * Converts various position formats to FEN string
+     * @param {string|Object} position - Position in various formats
+     * @returns {string} FEN string representation
+     * @throws {ValidationError} When position format is invalid
+     */
+    convertFen(position) {
+        if (typeof position === 'string') {
+            return this._convertStringPosition(position);
+        } else if (typeof position === 'object' && position !== null) {
+            return this._convertObjectPosition(position);
+        } else {
+            throw new ValidationError(ERROR_MESSAGES.invalid_position + position, 'position', position);
+        }
+    }
+
+    /**
+     * Converts string position to FEN
+     * @private
+     * @param {string} position - String position
+     * @returns {string} FEN string
+     */
+    _convertStringPosition(position) {
+        if (position === 'start') {
+            return DEFAULT_STARTING_POSITION;
+        }
+        
+        if (this.validateFen(position)) {
+            return position;
+        }
+        
+        if (STANDARD_POSITIONS[position]) {
+            return STANDARD_POSITIONS[position];
+        }
+        
+        throw new ValidationError(ERROR_MESSAGES.invalid_position + position, 'position', position);
+    }
+
+    /**
+     * Converts object position to FEN
+     * @private
+     * @param {Object} position - Object with square->piece mapping
+     * @returns {string} FEN string
+     */
+    _convertObjectPosition(position) {
+        const parts = [];
+        
+        for (let row = 0; row < 8; row++) {
+            const rowParts = [];
+            let empty = 0;
+            
+            for (let col = 0; col < 8; col++) {
+                const square = this._getSquareID(row, col);
+                const piece = position[square];
+                
+                if (piece) {
+                    if (empty > 0) {
+                        rowParts.push(empty);
+                        empty = 0;
+                    }
+                    // Convert piece notation: white pieces become uppercase, black remain lowercase
+                    const fenPiece = piece[1] === 'w' ? piece[0].toUpperCase() : piece[0].toLowerCase();
+                    rowParts.push(fenPiece);
+                } else {
+                    empty++;
+                }
+            }
+            
+            if (empty > 0) {
+                rowParts.push(empty);
+            }
+            
+            parts.push(rowParts.join(''));
+        }
+        
+        return parts.join('/') + ' w KQkq - 0 1';
+    }
+
+    /**
+     * Sets up the game with the given position
+     * @param {string|Object} position - Position to set
+     * @param {Object} [options] - Additional options for game setup
+     */
+    setGame(position, options = {}) {
+        const fen = this.convertFen(position);
+        
+        if (this.game) {
+            this.game.load(fen, options);
+        } else {
+            this.game = new Chess(fen);
+        }
+    }
+
+    /**
+     * Gets the current game instance
+     * @returns {Chess} Current chess.js game instance
+     */
+    getGame() {
+        return this.game;
+    }
+
+    /**
+     * Validates a FEN string
+     * @param {string} fen - FEN string to validate
+     * @returns {boolean} True if valid, false otherwise
+     */
+    validateFen(fen) {
+        return validateFen(fen);
+    }
+
+    /**
+     * Gets piece information for a specific square
+     * @param {string} squareId - Square identifier
+     * @returns {string|null} Piece ID or null if no piece
+     */
+    getGamePieceId(squareId) {
+        if (!this.game) return null;
+        const piece = this.game.get(squareId);
+        return piece ? piece.color + piece.type : null;
+    }
+
+    /**
+     * Checks if a specific piece is on a specific square
+     * @param {string} piece - Piece ID to check
+     * @param {string} square - Square to check
+     * @returns {boolean} True if piece is on square
+     */
+    isPiece(piece, square) {
+        return this.getGamePieceId(square) === piece;
+    }
+
+    /**
+     * Converts board coordinates to square ID
+     * @private
+     * @param {number} row - Row index (0-7)
+     * @param {number} col - Column index (0-7)
+     * @returns {string} Square ID (e.g., 'e4')
+     */
+    _getSquareID(row, col) {
+        row = parseInt(row);
+        col = parseInt(col);
+        
+        if (this.config.orientation === 'w') {
+            row = 8 - row;
+            col = col + 1;
+        } else {
+            row = row + 1;
+            col = 8 - col;
+        }
+        
+        const letter = BOARD_LETTERS[col - 1];
+        return letter + row;
+    }
+
+    /**
+     * Changes the turn in a FEN string
+     * @param {string} fen - Original FEN string
+     * @param {string} color - New turn color ('w' or 'b')
+     * @returns {string} Modified FEN string
+     */
+    changeFenTurn(fen, color) {
+        const parts = fen.split(' ');
+        parts[1] = color;
+        return parts.join(' ');
+    }
+
+    /**
+     * Gets the current position as an object
+     * @returns {Object} Position object with piece placements
+     */
+    getPosition() {
+        const position = {};
+        const game = this.getGame();
+        
+        // Convert chess.js board to position object
+        const squares = ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1',
+                        'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2',
+                        'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3',
+                        'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4',
+                        'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5',
+                        'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6',
+                        'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7',
+                        'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8'];
+        
+        for (const square of squares) {
+            const piece = game.get(square);
+            if (piece) {
+                position[square] = piece.type + piece.color;
+            }
+        }
+        
+        return position;
+    }
+
+    /**
+     * Toggles the turn in a FEN string
+     * @param {string} fen - Original FEN string
+     * @returns {string} Modified FEN string
+     */
+    changeFenColor(fen) {
+        const parts = fen.split(' ');
+        parts[1] = parts[1] === 'w' ? 'b' : 'w';
+        return parts.join(' ');
+    }
+
+    /**
+     * Cleans up resources
+     */
+    destroy() {
+        this.game = null;
+    }
+}