@alepot55/chessboardjs 1.1.0 → 2.0.3

package/chessboard.move.js

@@ -0,0 +1,56 @@
+import Piece from "./chessboard.piece.js";
+import Square from "./chessboard.square.js";
+
+class Move {
+
+    constructor(from, to, promotion = null, check = false) {
+        this.piece = from.getPiece();
+        this.from = from;
+        this.to = to;
+        this.promotion = promotion;
+
+        if (check) this.check();
+    }
+
+    hasPromotion() {
+        return this.promotion !== null;
+    }
+
+    setPromotion(promotion) {
+        this.promotion = promotion;
+    }
+
+    check() {
+        if (this.piece === null) {
+            console.log(this);
+            throw new Error("Invalid move: piece is null");
+        }
+        if (!(this.piece instanceof Piece)) {
+            throw new Error("Invalid move: piece is not an instance of Piece");
+        }
+        if (['q', 'r', 'b', 'n', null].indexOf(this.promotion) === -1) {
+            throw new Error("Invalid move: promotion is not valid");
+        }
+        if (!(this.from instanceof Square)) {
+            throw new Error("Invalid move: from is not an instance of Square");
+        }
+        if (!(this.to instanceof Square)) {
+            throw new Error("Invalid move: to is not an instance of Square");
+        }
+        if (!this.to) {
+            throw new Error("Invalid move: to is null or undefined");
+        }
+        if (!this.from) {
+            throw new Error("Invalid move: from is null or undefined");
+        }
+    }
+
+    isLegal(game) {
+        let destinations = game.moves({ square: this.from.id, verbose: true }).map(move => move.to);
+        return destinations.indexOf(this.to.id) !== -1;
+    }
+
+
+}
+
+export default Move;

package/chessboard.piece.js

@@ -0,0 +1,115 @@
+class Piece {
+    constructor(color, type, src, opacity = 1) {
+        this.color = color;
+        this.type = type;
+        this.id = this.getId();
+        this.src = src;
+        this.element = this.createElement(src, opacity);
+
+        this.check();
+    }
+
+    getId() { return this.type + this.color }
+
+    createElement(opacity) {
+        let element = document.createElement("img");
+        element.classList.add("piece");
+        element.id = this.id;
+        element.src = this.src;
+        element.style.opacity = opacity;
+        return element;
+    }
+
+    visible() { this.element.style.opacity = 1 }
+
+    invisible() { this.element.style.opacity = 0 }
+
+    fadeIn(duration, speed, transition_f) {
+        let start = performance.now();
+        let opacity = 0;
+        let piece = this;
+        let fade = function () {
+            let elapsed = performance.now() - start;
+            opacity = transition_f(elapsed, duration, speed);
+            piece.element.style.opacity = opacity;
+            if (elapsed < duration) {
+                requestAnimationFrame(fade);
+            } else {
+                piece.element.style.opacity = 1;
+            }
+        }
+        fade();
+    }
+
+    fadeOut(duration, speed, transition_f) {
+        let start = performance.now();
+        let opacity = 1;
+        let piece = this;
+        let fade = function () {
+            let elapsed = performance.now() - start;
+            opacity = 1 - transition_f(elapsed, duration, speed);
+            piece.element.style.opacity = opacity;
+            if (elapsed < duration) {
+                requestAnimationFrame(fade);
+            } else {
+                piece.element.style.opacity = 0;
+            }
+        }
+    }
+
+    setDrag(f) {
+        this.element.ondragstart = () => false;
+        this.element.onmousedown = f;
+    }
+
+    destroy() {
+        this.element.remove();
+    }
+
+    translate(to, duration, transition_f, speed, callback = null) {
+
+        let sourceRect = this.element.getBoundingClientRect();
+        let targetRect = to.getBoundingClientRect();
+        let x_start = sourceRect.left + sourceRect.width / 2;
+        let y_start = sourceRect.top + sourceRect.height / 2;
+        let x_end = targetRect.left + targetRect.width / 2;
+        let y_end = targetRect.top + targetRect.height / 2;
+        let dx = x_end - x_start;
+        let dy = y_end - y_start;
+
+        let keyframes = [
+            { transform: 'translate(0, 0)' },
+            { transform: `translate(${dx}px, ${dy}px)` }
+        ];
+
+        if (this.element.animate) {
+            let animation = this.element.animate(keyframes, {
+                duration: duration,
+                easing: 'ease',
+                fill: 'none'
+            });
+
+            animation.onfinish = () => {
+                if (callback) callback();
+                this.element.style = '';
+            };
+        } else {
+            this.element.style.transition = `transform ${duration}ms ease`;
+            this.element.style.transform = `translate(${dx}px, ${dy}px)`;
+            if (callback) callback();
+            this.element.style = '';
+        }
+    }
+
+    check() {
+        if (['p', 'r', 'n', 'b', 'q', 'k'].indexOf(this.type) === -1) {
+            throw new Error("Invalid piece type");
+        }
+
+        if (['w', 'b'].indexOf(this.color) === -1) {
+            throw new Error("Invalid piece color");
+        }
+    }
+}
+
+export default Piece;

package/chessboard.square.js

@@ -0,0 +1,184 @@
+import Piece from "./chessboard.piece.js";
+
+class Square {
+
+    constructor(row, col) {
+        this.row = row;
+        this.col = col;
+        this.id = this.getId();
+        this.element = this.createElement();
+        this.piece = null;
+    }
+
+    getPiece() {
+        return this.piece;
+    }
+
+    opposite() {
+        this.row = 9 - this.row;
+        this.col = 9 - this.col;
+        this.id = this.getId();
+        this.element = this.resetElement();
+    }
+
+    isWhite() {
+        return (this.row + this.col) % 2 === 0;
+    }
+
+    getId() {
+        let letters = 'abcdefgh';
+        let letter = letters[this.col - 1];
+        return letter + this.row;
+    }
+
+    resetElement() {
+        this.element.id = this.id;
+        this.element.className = '';
+        this.element.classList.add('square');
+        this.element.classList.add(this.isWhite() ? 'whiteSquare' : 'blackSquare');
+    }
+
+    createElement() {
+        let element = document.createElement('div');
+        element.id = this.id;
+        element.classList.add('square');
+        element.classList.add(this.isWhite() ? 'whiteSquare' : 'blackSquare');
+        return element;
+    }
+
+    getElement() {
+        return this.element;
+    }
+
+    getBoundingClientRect() {
+        return this.element.getBoundingClientRect();
+    }
+
+    removePiece() {
+        this.element.removeChild(this.piece.element);
+        const piece = this.piece;
+        this.piece = null;
+        return piece;
+    }
+
+    addEventListener(event, callback) {
+        this.element.addEventListener(event, callback);
+    }
+
+    putPiece(piece) {
+        this.piece = piece;
+        this.element.appendChild(piece.element);
+    }
+
+    putHint(catchable) {
+        if (this.element.querySelector('.hint')) {
+            return;
+        }
+        let hint = document.createElement("div");
+        hint.classList.add('hint');
+        this.element.appendChild(hint);
+        if (catchable) {
+            hint.classList.add('catchable');
+        }
+    }
+
+    removeHint() {
+        let hint = this.element.querySelector('.hint');
+        if (hint) {
+            this.element.removeChild(hint);
+        }
+    }
+
+    select() {
+        this.element.classList.add(this.isWhite() ? 'selectedSquareWhite' : 'selectedSquareBlack');
+    }
+
+    deselect() {
+        this.element.classList.remove('selectedSquareWhite');
+        this.element.classList.remove('selectedSquareBlack');
+    }
+
+    moved() {
+        this.element.classList.add(this.isWhite() ? 'movedSquareWhite' : 'movedSquareBlack');
+    }
+
+    unmoved() {
+        this.element.classList.remove('movedSquareWhite');
+        this.element.classList.remove('movedSquareBlack');
+    }
+
+    highlight() {
+        this.element.classList.add('highlighted');
+    }
+
+    dehighlight() {
+        this.element.classList.remove('highlighted');
+    }
+
+    putCover(callback) {
+        let cover = document.createElement("div");
+        cover.classList.add('square');
+        cover.classList.add('cover');
+        this.element.appendChild(cover);
+        cover.addEventListener('click', (e) => {
+            e.stopPropagation();
+            callback();
+        });
+    }
+
+    removeCover() {
+        let cover = this.element.querySelector('.cover');
+        if (cover) {
+            this.element.removeChild(cover);
+        }
+    }
+
+    putPromotion(src, callback) {
+        let choice = document.createElement("div");
+        choice.classList.add('square');
+        choice.classList.add('choice');
+        this.element.appendChild(choice);
+        let img = document.createElement("img");
+        img.classList.add("piece");
+        img.classList.add("choicable");
+        img.src = src;
+        choice.appendChild(img);
+        choice.addEventListener('click', (e) => {
+            e.stopPropagation();
+            callback();
+        });
+
+    }
+
+    removePromotion() {
+        let choice = this.element.querySelector('.choice');
+        if (choice) {
+            choice.removeChild(choice.firstChild);
+            this.element.removeChild(choice);
+        }
+    }
+
+    destroy() {
+        this.element.remove();
+    }
+
+    hasPiece() {
+        return this.piece !== null;
+    }
+
+    getColor() {
+        return this.piece.getColor();
+    }
+
+    check() {
+        if (this.row < 1 || this.row > 8) {
+            throw new Error("Invalid square: row is out of bounds");
+        }
+        if (this.col < 1 || this.col > 8) {
+            throw new Error("Invalid square: col is out of bounds");
+        }
+        
+    }
+}
+
+export default Square;

package/jest.config.js

@@ -0,0 +1,7 @@
+export default {
+    testEnvironment: 'jsdom',
+    transform: {
+        "^.+\\.js$": "babel-jest"
+    }
+    // ...existing config...
+};

package/package.json

@@ -1,13 +1,13 @@
 {
   "dependencies": {
-    "chess.js": "^1.0.0-beta.8"
+    "chess.js": "^1.0.0"
   },
   "name": "@alepot55/chessboardjs",
-  "version": "1.1.0",
+  "version": "2.0.3",
   "main": "chessboard.js",
   "type": "module",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest"
   },
   "author": "alepot55",
   "license": "ISC",
@@ -23,5 +23,12 @@
   "bugs": {
     "url": "https://github.com/alepot55/ChessBoard/issues"
   },
-  "homepage": "https://github.com/alepot55/ChessBoard#readme"
+  "homepage": "https://github.com/alepot55/ChessBoard#readme",
+  "devDependencies": {
+    "@babel/core": "^7.26.8",
+    "@babel/preset-env": "^7.26.8",
+    "babel-jest": "^29.7.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0"
+  }
 }

package/test/chessboard.test.js

@@ -0,0 +1,128 @@
+import Chessboard from '../chessboard.js';
+
+describe('Chessboard User Functions', () => {
+    let chessboard;
+    let config = { id_div: 'board', size: 400, position: 'start', orientation: 'w' };
+
+    beforeEach(() => {
+        document.body.innerHTML = '<div id="board"></div>';
+        chessboard = new Chessboard(config);
+    });
+
+    test('turn() should return the current turn', () => {
+        expect(chessboard.turn()).toBe('w');
+    });
+
+    test('getOrientation() should return the current orientation', () => {
+        expect(chessboard.getOrientation()).toBe('w');
+    });
+
+    test('fen() should return the current FEN string', () => {
+        expect(chessboard.fen()).toBe('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1');
+    });
+
+    test('lastMove() should return the last move made', () => {
+        chessboard.move('e2e4');
+        expect(chessboard.lastMove().san).toBe('e4');
+    });
+
+    test('history() should return the history of moves', () => {
+        chessboard.move('e2e4');
+        chessboard.move('e7e5');
+        expect(chessboard.history().length).toBe(2);
+    });
+
+    test('get() should return the piece on the given square', () => {
+        expect(chessboard.get('e2')).toBe('pw');
+    });
+
+    test('position() should set the board to the given position', () => {
+        chessboard.position('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1');
+        expect(chessboard.fen()).toBe('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1');
+    });
+
+    test('flip() should flip the board orientation', () => {
+        chessboard.flip();
+        expect(chessboard.getOrientation()).toBe('b');
+    });
+
+    test('build() should rebuild the board', () => {
+        chessboard.build();
+        expect(chessboard.fen()).toBe('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1');
+    });
+
+    test('clear() should clear the board', () => {
+        chessboard.clear();
+        expect(chessboard.fen()).toBe('8/8/8/8/8/8/8/8 w - - 0 1');
+    });
+
+    test('insert() should insert a piece on the given square', () => {
+        chessboard.insert('e4', 'qw');
+        expect(chessboard.get('e4')).toBe('qw');
+    });
+
+    test('isGameOver() should return the game over status', () => {
+        chessboard.position('default');
+        chessboard.move('e2e4');
+        chessboard.move('e7e5');
+        chessboard.move('d1h5');
+        chessboard.move('b8c6');
+        chessboard.move('f1c4');
+        chessboard.move('g8f6');
+        chessboard.move('h5f7');
+        expect(chessboard.isGameOver()).toBe('w');
+    });
+
+    test('orientation() should set the board orientation', () => {
+        chessboard.orientation('b');
+        expect(chessboard.getOrientation()).toBe('b');
+    });
+
+    test('resize() should resize the board', () => {
+        chessboard.resize(500);
+        expect(document.documentElement.style.getPropertyValue('--dimBoard')).toBe('500px');
+    });
+
+    test('destroy() should destroy the board', () => {
+        chessboard.destroy();
+        expect(chessboard.board).toBeNull();
+    });
+
+    test('remove() should remove a piece from the given square', () => {
+        chessboard.remove('e2');
+        expect(chessboard.get('e2')).toBeNull();
+    });
+
+    test('piece() should return the piece on the given square', () => {
+        expect(chessboard.piece('e2')).toBe('pw');
+    });
+
+    test('highlight() should highlight the given square', () => {
+        chessboard.highlight('e2');
+        expect(chessboard.squares['e2'].element.classList.contains('highlighted')).toBe(true);
+    });
+
+    test('dehighlight() should dehighlight the given square', () => {
+        chessboard.highlight('e2');
+        chessboard.dehighlight('e2');
+        expect(chessboard.squares['e2'].element.classList.contains('highlighted')).toBe(false);
+    });
+
+    test('playerTurn() should return true if it is the player turn', () => {
+        expect(chessboard.playerTurn()).toBe(true);
+    });
+
+    test('isWhiteOriented() should return true if the board is oriented for white', () => {
+        expect(chessboard.isWhiteOriented()).toBe(true);
+    });
+
+    test('getSquareID() should return the correct square ID', () => {
+        expect(chessboard.getSquareID(0, 0)).toBe('a8');
+        expect(chessboard.getSquareID(7, 7)).toBe('h1');
+    });
+
+    test('removeSquares() should remove all squares from the board', () => {
+        chessboard.removeSquares();
+        expect(Object.keys(chessboard.squares).length).toBe(0);
+    });
+});