@alepot55/chessboardjs 2.2.2 → 2.3.0

package/config/.babelrc

@@ -1,4 +0,0 @@
-
-{
-  "presets": ["@babel/preset-env"]
-}

package/config/jest.config.js

@@ -1,15 +0,0 @@
-export default {
-    testEnvironment: 'jsdom',
-    rootDir: '../',
-    testMatch: [
-        '<rootDir>/tests/unit/**/*.test.js',
-        '<rootDir>/tests/integration/**/*.test.js'
-    ],
-    collectCoverageFrom: [
-        '<rootDir>/src/**/*.js',
-        '!<rootDir>/src/**/*.test.js'
-    ],
-    transform: {
-        "^.+\\.js$": ["babel-jest", { "presets": [["@babel/preset-env", { "targets": { "node": "current" } }]] }]
-    }
-};

package/config/rollup.config.js

@@ -1,36 +0,0 @@
-import resolve from '@rollup/plugin-node-resolve';
-import replace from '@rollup/plugin-replace';
-
-export default {
-  input: 'src/index.js', // nuovo entry point
-  output: [
-    {
-      file: 'dist/chessboard.esm.js', // ES modules
-      format: 'esm'
-    },
-    {
-      file: 'dist/chessboard.cjs.js', // CommonJS
-      format: 'cjs'
-    },
-    {
-      file: 'dist/chessboard.umd.js', // UMD
-      format: 'umd',
-      name: 'Chessboard'
-    },
-    {
-      file: 'dist/chessboard.iife.js', // IIFE per browser
-      format: 'iife',
-      name: 'ChessboardLib',
-      footer: 'var Chessboard = ChessboardLib.default; if (typeof window !== "undefined") { window.Chessboard = Chessboard; Object.keys(ChessboardLib).forEach(key => { if (key !== "default") Chessboard[key] = ChessboardLib[key]; }); }'
-    }
-  ],
-  plugins: [
-    replace({
-      'process.env.NODE_ENV': JSON.stringify('production'),
-      'process.env.BUILD_NUMBER': JSON.stringify(''),
-      'process.env.BUILD_DATE': JSON.stringify(''),
-      preventAssignment: true
-    }),
-    resolve()
-  ]
-};

package/jest.config.js

@@ -1,2 +0,0 @@
-// Re-export the configuration from the config directory
-export { default } from './config/jest.config.js';

package/rollup.config.js

@@ -1,2 +0,0 @@
-// Re-export the configuration from the config directory
-export { default } from './config/rollup.config.js';

package/tests/unit/chessboard-config-animations.test.js

@@ -1,106 +0,0 @@
-import { ChessboardConfig } from '../../src/core/ChessboardConfig.js';
-
-describe('ChessboardConfig Animation & Drag Properties', () => {
-    const baseConfig = { id: 'test-board' };
-
-    test('should handle boolean moveAnimation values', () => {
-        expect(() => {
-            new ChessboardConfig({ ...baseConfig, moveAnimation: true });
-        }).not.toThrow();
-        expect(() => {
-            new ChessboardConfig({ ...baseConfig, moveAnimation: false });
-        }).not.toThrow();
-        // Check resulting property
-        expect(new ChessboardConfig({ ...baseConfig, moveAnimation: true }).moveAnimation).toBe('ease');
-        expect(new ChessboardConfig({ ...baseConfig, moveAnimation: false }).moveAnimation).toBe(null);
-    });
-
-    test('should handle boolean snapbackAnimation values', () => {
-        expect(() => {
-            new ChessboardConfig({ ...baseConfig, snapbackAnimation: true });
-        }).not.toThrow();
-        expect(() => {
-            new ChessboardConfig({ ...baseConfig, snapbackAnimation: false });
-        }).not.toThrow();
-        expect(new ChessboardConfig({ ...baseConfig, snapbackAnimation: true }).snapbackAnimation).toBe('ease');
-        expect(new ChessboardConfig({ ...baseConfig, snapbackAnimation: false }).snapbackAnimation).toBe(null);
-    });
-
-    test('should handle boolean fadeAnimation values', () => {
-        expect(() => {
-            new ChessboardConfig({ ...baseConfig, fadeAnimation: true });
-        }).not.toThrow();
-        expect(() => {
-            new ChessboardConfig({ ...baseConfig, fadeAnimation: false });
-        }).not.toThrow();
-        expect(new ChessboardConfig({ ...baseConfig, fadeAnimation: true }).fadeAnimation).toBe('ease');
-        expect(new ChessboardConfig({ ...baseConfig, fadeAnimation: false }).fadeAnimation).toBe(null);
-    });
-
-    test('should handle string animation values', () => {
-        expect(() => {
-            new ChessboardConfig({
-                ...baseConfig,
-                moveAnimation: 'ease-in-out',
-                snapbackAnimation: 'linear',
-                fadeAnimation: 'ease'
-            });
-        }).not.toThrow();
-    });
-
-    test('should handle none animation values', () => {
-        expect(() => {
-            new ChessboardConfig({
-                ...baseConfig,
-                moveAnimation: 'none',
-                snapbackAnimation: 'none',
-                fadeAnimation: 'none'
-            });
-        }).not.toThrow();
-    });
-
-    test('should throw error for invalid animation values', () => {
-        expect(() => {
-            new ChessboardConfig({ ...baseConfig, moveAnimation: 'invalid-animation' });
-        }).toThrow('Invalid transition function');
-    });
-
-    // --- DRAGGABLE ---
-    test('should handle draggable true/false', () => {
-        expect(() => new ChessboardConfig({ ...baseConfig, draggable: true })).not.toThrow();
-        expect(() => new ChessboardConfig({ ...baseConfig, draggable: false })).not.toThrow();
-    });
-    test('should default draggable to true', () => {
-        const config = new ChessboardConfig(baseConfig);
-        expect(config.draggable).toBe(true);
-    });
-    test('should throw error for invalid draggable value', () => {
-        expect(() => new ChessboardConfig({ ...baseConfig, draggable: 'maybe' })).toThrow();
-    });
-
-    // --- DROP OFF BOARD ---
-    test('should accept valid dropOffBoard values', () => {
-        expect(() => new ChessboardConfig({ ...baseConfig, dropOffBoard: 'snapback' })).not.toThrow();
-        expect(() => new ChessboardConfig({ ...baseConfig, dropOffBoard: 'trash' })).not.toThrow();
-    });
-    test('should throw error for invalid dropOffBoard value', () => {
-        expect(() => new ChessboardConfig({ ...baseConfig, dropOffBoard: 'invalid' })).toThrow();
-    });
-
-    // --- ANIMATION STYLE ---
-    test('should accept valid animationStyle values', () => {
-        expect(() => new ChessboardConfig({ ...baseConfig, animationStyle: 'simultaneous' })).not.toThrow();
-        expect(() => new ChessboardConfig({ ...baseConfig, animationStyle: 'sequential' })).not.toThrow();
-    });
-    test('should throw error for invalid animationStyle value', () => {
-        expect(() => new ChessboardConfig({ ...baseConfig, animationStyle: 'crazy' })).toThrow();
-    });
-
-    // --- EDGE CASES ---
-    test('should throw error if id/id_div is missing', () => {
-        expect(() => new ChessboardConfig({})).toThrow();
-    });
-    test('should throw error for non-object config', () => {
-        expect(() => new ChessboardConfig('not-an-object')).toThrow();
-    });
-});

package/tests/unit/chessboard-robust.test.js

@@ -1,163 +0,0 @@
-import Chessboard from '../../src/index.js';
-
-describe('Chessboard Robustness & Edge Cases', () => {
-    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);
-    });
-
-    describe('Piece Insertion', () => {
-        test('insert valid string piece', () => {
-            expect(() => chessboard.putPiece('wq', 'e4')).not.toThrow();
-            expect(chessboard.getPiece('e4')).toBe('wq');
-        });
-        test('insert valid object piece', () => {
-            expect(() => chessboard.putPiece({ type: 'q', color: 'w' }, 'd5')).not.toThrow();
-            expect(chessboard.getPiece('d5')).toBe('wq');
-        });
-        test('insert invalid string piece', () => {
-            expect(() => chessboard.putPiece('xx', 'e4')).toThrow();
-        });
-        test('insert invalid object piece', () => {
-            expect(() => chessboard.putPiece({ type: 'z', color: 'w' }, 'e4')).toThrow();
-        });
-        test('insert null/undefined piece', () => {
-            expect(() => chessboard.putPiece(null, 'e4')).toThrow();
-            expect(() => chessboard.putPiece(undefined, 'e4')).toThrow();
-        });
-        test('insert on invalid square', () => {
-            expect(() => chessboard.putPiece('wq', 'z9')).toThrow();
-        });
-        test('insert on already occupied square', () => {
-            chessboard.putPiece('wq', 'e4');
-            expect(() => chessboard.putPiece('bq', 'e4')).not.toThrow();
-            expect(chessboard.getPiece('e4')).toBe('bq');
-        });
-    });
-
-    describe('Piece Removal', () => {
-        test('remove from empty square', () => {
-            expect(chessboard.getPiece('e5')).toBeNull();
-            expect(() => chessboard.removePiece('e5')).not.toThrow();
-        });
-        test('remove from occupied square', () => {
-            chessboard.putPiece('wq', 'e4');
-            expect(() => chessboard.removePiece('e4')).not.toThrow();
-            expect(chessboard.getPiece('e4')).toBeNull();
-        });
-        test('remove from invalid square', () => {
-            expect(() => chessboard.removePiece('z9')).toThrow();
-        });
-    });
-
-    describe('FEN Handling', () => {
-        test('set valid FEN', () => {
-            const fen = '8/8/8/8/8/8/8/8 w - - 0 1';
-            expect(() => chessboard.setPosition(fen)).toThrow(); // ora deve lanciare
-        });
-        test('set invalid FEN', () => {
-            expect(() => chessboard.setPosition('invalid-fen')).toThrow();
-        });
-        test('set FEN with pawns on first/last rank', () => {
-            expect(() => chessboard.setPosition('8/8/8/8/8/8/8/P7 w - - 0 1')).toThrow();
-        });
-        test('set FEN with too many kings', () => {
-            expect(() => chessboard.setPosition('8/8/8/8/8/8/8/KK6 w - - 0 1')).toThrow();
-        });
-    });
-
-    describe('Game Over & Rules', () => {
-        test('checkmate detection', () => {
-            chessboard.setPosition('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1');
-            chessboard.movePiece('f2f3');
-            chessboard.movePiece('e7e5');
-            chessboard.movePiece('g2g4');
-            chessboard.movePiece('d8h4');
-            expect(chessboard.isGameOver()).toBe(true);
-        });
-        test('stalemate detection', () => {
-            chessboard.setPosition('7k/5Q2/6K1/8/8/8/8/8 b - - 0 1');
-            expect(chessboard.isGameOver()).toBe(true);
-        });
-        test('insufficient material', () => {
-            chessboard.setPosition('8/8/8/8/8/8/2k5/3K4 w - - 0 1');
-            expect(chessboard.isGameOver()).toBe(true);
-        });
-    });
-
-    describe('Undo/Redo & History', () => {
-        test('undo/redo after moves', async () => {
-            chessboard.movePiece('e2e4');
-            chessboard.movePiece('e7e5');
-            chessboard.undoMove();
-            expect(chessboard.getPiece('e5')).toBeNull();
-            chessboard.redoMove();
-            chessboard.forceSync();
-            await new Promise(r => setTimeout(r, 10));
-            expect(chessboard.getPiece('e5')).toBe('pb');
-        });
-        test('undo/redo after clear', () => {
-            chessboard.movePiece('e2e4');
-            chessboard.clear();
-            expect(() => chessboard.undoMove()).not.toThrow();
-        });
-    });
-
-    describe('Config & Animation', () => {
-        test('set invalid config', () => {
-            expect(() => new Chessboard({})).toThrow();
-        });
-        test('set extreme resize', () => {
-            expect(() => chessboard.resizeBoard(50)).not.toThrow();
-            expect(() => chessboard.resizeBoard(2000)).not.toThrow();
-        });
-        test('set invalid resize', () => {
-            expect(() => chessboard.resizeBoard(-1)).toThrow();
-        });
-        test('change animation at runtime', () => {
-            expect(() => chessboard.config.moveAnimation = 'linear').not.toThrow();
-        });
-    });
-
-    describe('Alias & Deprecated', () => {
-        test('alias insert', () => {
-            expect(() => chessboard.insert('e4', 'wq')).not.toThrow();
-            expect(chessboard.getPiece('e4')).toBe('wq');
-        });
-        test('alias get', async () => {
-            chessboard.forceSync();
-            await new Promise(r => setTimeout(r, 10));
-            expect(chessboard.get('e2')).toBe('pw');
-        });
-        test('alias piece', async () => {
-            chessboard.forceSync();
-            await new Promise(r => setTimeout(r, 10));
-            expect(chessboard.piece('e2')).toBe('pw');
-        });
-    });
-
-    describe('Drag & Drop', () => {
-        test('draggable false disables drag', () => {
-            chessboard = new Chessboard({ ...config, draggable: false });
-            expect(chessboard.config.draggable).toBe(false);
-        });
-        test('draggable true enables drag', () => {
-            chessboard = new Chessboard({ ...config, draggable: true });
-            expect(chessboard.config.draggable).toBe(true);
-        });
-    });
-
-    describe('Resize & Flip Edge Cases', () => {
-        test('multiple flips', () => {
-            chessboard.flipBoard();
-            chessboard.flipBoard();
-            expect(chessboard.getOrientation()).toBe('w');
-        });
-        test('resize to auto', () => {
-            expect(() => chessboard.resizeBoard('auto')).not.toThrow();
-        });
-    });
-}); 

package/tests/unit/chessboard.test.js

@@ -1,183 +0,0 @@
-import Chessboard from '../../src/index.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');
-    });
-
-    // lastMove() is not part of the new API, so this test is commented out or should be adapted
-    // test('lastMove() should return the last move made', () => {
-    //     chessboard.movePiece('e2e4');
-    //     expect(chessboard.lastMove().san).toBe('e4');
-    // });
-
-    test('getHistory() should return the history of moves', () => {
-        chessboard.movePiece('e2e4');
-        chessboard.movePiece('e7e5');
-        expect(chessboard.getHistory().length).toBe(2);
-    });
-
-    test('getPiece() should return the piece on the given square', () => {
-        expect(chessboard.getPiece('e2')).toBe('pw');
-    });
-
-    test('setPosition() should set the board to the given position', () => {
-        chessboard.setPosition('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('flipBoard() should flip the board orientation', () => {
-        chessboard.flipBoard();
-        expect(chessboard.getOrientation()).toBe('b');
-    });
-
-    test('rebuild() should rebuild the board', () => {
-        chessboard.rebuild();
-        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('putPiece() should insert a piece on the given square', () => {
-        chessboard.putPiece('qw', 'e4');
-        expect(chessboard.getPiece('e4')).toBe('qw');
-    });
-
-    // isGameOver() returns boolean, not 'w', so adapt the test
-    test('isGameOver() should return the game over status', () => {
-        chessboard.setPosition('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1');
-        chessboard.movePiece('e2e4');
-        chessboard.movePiece('e7e5');
-        chessboard.movePiece('d1h5');
-        chessboard.movePiece('b8c6');
-        chessboard.movePiece('f1c4');
-        chessboard.movePiece('g8f6');
-        chessboard.movePiece('h5f7');
-        expect(chessboard.isGameOver()).toBe(true);
-    });
-
-    test('setOrientation() should set the board orientation', () => {
-        chessboard.setOrientation('b');
-        expect(chessboard.getOrientation()).toBe('b');
-    });
-
-    test('resizeBoard() should resize the board', () => {
-        chessboard.resizeBoard(500);
-        expect(document.documentElement.style.getPropertyValue('--dimBoard')).toBe('500px');
-    });
-
-    test('destroy() should destroy the board', () => {
-        chessboard.destroy();
-        // Adapt this test to check for DOM cleanup or internal state
-        // For now, just check that calling destroy does not throw
-        expect(() => chessboard.destroy()).not.toThrow();
-    });
-
-    test('removePiece() should remove a piece from the given square', () => {
-        chessboard.removePiece('e2');
-        expect(chessboard.getPiece('e2')).toBeNull();
-    });
-
-    // piece() is deprecated, use getPiece()
-    test('getPiece() alias should return the piece on the given square', () => {
-        expect(chessboard.getPiece('e2')).toBe('pw');
-    });
-
-    // highlight/dehighlight tests depend on implementation details
-    // Here we check that the methods exist and can be called
-    test('highlight() should not throw for a valid square', () => {
-        expect(() => chessboard.highlight('e2')).not.toThrow();
-    });
-
-    test('dehighlight() should not throw for a valid square', () => {
-        expect(() => chessboard.dehighlight('e2')).not.toThrow();
-    });
-
-    // The following tests are for features not present in the new API or require internal access
-    // 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);
-    // });
-
-    // --- DRAG & ANIMATION TESTS ---
-    describe('Drag and Animation', () => {
-        test('should respect draggable: false', () => {
-            chessboard.destroy();
-            chessboard = new Chessboard({ ...config, draggable: false });
-            // Simulate drag attempt (mock event)
-            const dragStart = () => chessboard.config.draggable;
-            expect(dragStart()).toBe(false);
-        });
-
-        test('should allow drag when draggable: true', () => {
-            chessboard.destroy();
-            chessboard = new Chessboard({ ...config, draggable: true });
-            // Simulate drag attempt (mock event)
-            const dragStart = () => chessboard.config.draggable;
-            expect(dragStart()).toBe(true);
-        });
-
-        test('moveAnimation config should be respected', () => {
-            chessboard.destroy();
-            chessboard = new Chessboard({ ...config, moveAnimation: 'ease-in-out' });
-            expect(chessboard.config.moveAnimation).toBe('ease-in-out');
-        });
-
-        test('snapbackAnimation config should be respected', () => {
-            chessboard.destroy();
-            chessboard = new Chessboard({ ...config, snapbackAnimation: 'linear' });
-            expect(chessboard.config.snapbackAnimation).toBe('linear');
-        });
-
-        test('fadeAnimation config should be respected', () => {
-            chessboard.destroy();
-            chessboard = new Chessboard({ ...config, fadeAnimation: 'ease' });
-            expect(chessboard.config.fadeAnimation).toBe('ease');
-        });
-
-        test('should not animate if moveAnimation is false', () => {
-            chessboard.destroy();
-            chessboard = new Chessboard({ ...config, moveAnimation: false });
-            expect(chessboard.config.moveAnimation).toBe(null);
-        });
-
-        // NOTE: DOM animation/drag event simulation is limited in Jest/JSDOM
-        // These tests check config and method presence, not actual browser animation
-        test('should have highlight and dehighlight methods for drag/hover', () => {
-            expect(typeof chessboard.highlight).toBe('function');
-            expect(typeof chessboard.dehighlight).toBe('function');
-        });
-    });
-});