@alepot55/chessboardjs 2.3.6 → 2.3.8

package/src/services/PieceService.js

@@ -1,5 +1,5 @@
 /**
- * Service for managing chess pieces and their operations
+ * PieceService - Handles chess piece management and operations
  * @module services/PieceService
  * @since 2.0.0
  */
@@ -11,11 +11,11 @@ import { PIECE_TYPES, PIECE_COLORS } from '../constants/positions.js';
 
 /**
  * Service responsible for piece management and operations
- * @class
+ * @class PieceService
  */
 export class PieceService {
     /**
-     * Creates a new PieceService instance
+     * Create a new PieceService instance
      * @param {ChessboardConfig} config - Board configuration
      */
     constructor(config) {
@@ -23,14 +23,13 @@ export class PieceService {
     }
 
     /**
-     * Gets the path to a piece asset
+     * Get 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) {
@@ -43,7 +42,7 @@ export class PieceService {
     }
 
     /**
-     * Converts various piece formats to a Piece instance
+     * Convert 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
@@ -52,54 +51,41 @@ export class PieceService {
         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())) {
+            } 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 (oggetto)
-     * @param {Piece} piece - Piece to add (oggetto)
+     * Add 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) {
-        if (!square || !piece) throw new Error('addPieceOnSquare richiede oggetti Square e Piece');
-        console.debug(`[PieceService] addPieceOnSquare: ${piece.id} to ${square.id}`);
+        if (!square || !piece) throw new Error('addPieceOnSquare requires Square and Piece objects');
         square.putPiece(piece);
-
-        // Imposta sempre il drag (touch e mouse)
         if (dragFunction) {
             piece.setDrag(dragFunction(square, piece));
         }
-        // Forza il drag touch se manca (debug/robustezza)
         if (!piece.element.ontouchstart) {
             piece.element.ontouchstart = dragFunction ? dragFunction(square, piece) : () => { };
-            console.debug(`[PieceService] Forzato ontouchstart su ${piece.id}`);
         }
-
         if (fade && this.config.fadeTime > 0) {
             piece.fadeIn(
                 this.config.fadeTime,
@@ -110,28 +96,24 @@ export class PieceService {
         } else {
             if (callback) callback();
         }
-
         piece.visible();
     }
 
     /**
-     * Rimuove un pezzo da una casella
-     * @param {Square} square - Oggetto Square
+     * Remove a piece from a square
+     * @param {Square} square - Square object
      * @param {boolean} [fade=true]
      * @param {Function} [callback]
-     * @returns {Piece} Il pezzo rimosso
+     * @returns {Piece} The removed piece
      */
     removePieceFromSquare(square, fade = true, callback) {
-        if (!square) throw new Error('removePieceFromSquare richiede oggetto Square');
-        console.debug(`[PieceService] removePieceFromSquare: ${square.id}`);
+        if (!square) throw new Error('removePieceFromSquare requires a Square object');
         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,
@@ -142,26 +124,22 @@ export class PieceService {
         } else {
             if (callback) callback();
         }
-
         square.removePiece();
         return piece;
     }
 
     /**
-     * Moves a piece to a new position with animation
+     * Move 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 || !piece.element) {
-            console.warn(`[PieceService] movePiece: piece or element is null, skipping animation`);
             if (callback) callback();
             return;
         }
-
         piece.translate(
             targetSquare,
             duration,
@@ -172,7 +150,7 @@ export class PieceService {
     }
 
     /**
-     * Handles piece translation with optional capture
+     * Handle 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
@@ -180,54 +158,37 @@ export class PieceService {
      * @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
+                move.from.removePiece(true);
             }
-
-            // 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 && 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
+     * Snap a piece back to its original position
      * @param {Square} square - Square containing the piece
      * @param {boolean} [animate=true] - Whether to animate the snapback
      */
@@ -237,7 +198,6 @@ export class PieceService {
         }
         const piece = square.piece;
         const duration = animate ? this.config.snapbackTime : 0;
-        console.debug(`[PieceService] snapbackPiece: ${piece.id} on ${square.id}`);
         piece.translate(
             square,
             duration,
@@ -247,7 +207,7 @@ export class PieceService {
     }
 
     /**
-     * Centers a piece in its square with animation (after successful drop)
+     * Center 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
      */
@@ -257,14 +217,12 @@ export class PieceService {
         }
         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 = '';
@@ -276,14 +234,13 @@ export class PieceService {
     }
 
     /**
-     * Gets the transition timing function for animations
+     * Get 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;
@@ -302,7 +259,7 @@ export class PieceService {
     }
 
     /**
-     * Cleans up resources
+     * Clean up resources
      */
     destroy() {
         // Cleanup any cached pieces or references

package/src/services/PositionService.js

@@ -1,5 +1,5 @@
 /**
- * Service for managing chess positions and FEN conversion
+ * PositionService - Handles chess position management and FEN conversion
  * @module services/PositionService
  * @since 2.0.0
  */
@@ -11,11 +11,11 @@ import { ERROR_MESSAGES } from '../errors/messages.js';
 
 /**
  * Service responsible for position management and FEN operations
- * @class
+ * @class PositionService
  */
 export class PositionService {
     /**
-     * Creates a new PositionService instance
+     * Create a new PositionService instance
      * @param {ChessboardConfig} config - Board configuration
      */
     constructor(config) {
@@ -24,7 +24,7 @@ export class PositionService {
     }
 
     /**
-     * Converts various position formats to FEN string
+     * Convert 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
@@ -40,7 +40,7 @@ export class PositionService {
     }
 
     /**
-     * Converts string position to FEN
+     * Convert string position to FEN
      * @private
      * @param {string} position - String position
      * @returns {string} FEN string
@@ -49,35 +49,29 @@ export class PositionService {
         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
+     * Convert 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);
@@ -90,25 +84,21 @@ export class PositionService {
                     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
+     * Set 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 {
@@ -117,7 +107,7 @@ export class PositionService {
     }
 
     /**
-     * Gets the current game instance
+     * Get the current game instance
      * @returns {Chess} Current chess.js game instance
      */
     getGame() {
@@ -125,7 +115,7 @@ export class PositionService {
     }
 
     /**
-     * Validates a FEN string
+     * Validate a FEN string
      * @param {string} fen - FEN string to validate
      * @returns {boolean} True if valid, false otherwise
      */
@@ -134,7 +124,7 @@ export class PositionService {
     }
 
     /**
-     * Gets piece information for a specific square
+     * Get piece information for a specific square
      * @param {string} squareId - Square identifier
      * @returns {string|null} Piece ID or null if no piece
      */
@@ -145,7 +135,7 @@ export class PositionService {
     }
 
     /**
-     * Checks if a specific piece is on a specific square
+     * Check 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
@@ -155,7 +145,7 @@ export class PositionService {
     }
 
     /**
-     * Converts board coordinates to square ID
+     * Convert board coordinates to square ID
      * @private
      * @param {number} row - Row index (0-7)
      * @param {number} col - Column index (0-7)
@@ -164,7 +154,6 @@ export class PositionService {
     _getSquareID(row, col) {
         row = parseInt(row);
         col = parseInt(col);
-        
         if (this.config.orientation === 'w') {
             row = 8 - row;
             col = col + 1;
@@ -172,13 +161,12 @@ export class PositionService {
             row = row + 1;
             col = 8 - col;
         }
-        
         const letter = BOARD_LETTERS[col - 1];
         return letter + row;
     }
 
     /**
-     * Changes the turn in a FEN string
+     * Change 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
@@ -190,35 +178,33 @@ export class PositionService {
     }
 
     /**
-     * Gets the current position as an object
+     * Get 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'];
-        
+        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
+     * Toggle the turn in a FEN string
      * @param {string} fen - Original FEN string
      * @returns {string} Modified FEN string
      */
@@ -229,7 +215,7 @@ export class PositionService {
     }
 
     /**
-     * Cleans up resources
+     * Clean up resources
      */
     destroy() {
         this.game = null;