cm-chessboard 4.0.4 → 4.0.8

package/test/TestPiecesAnimation.js

@@ -5,32 +5,29 @@
  */
 
 import {describe, it, assert} from "../node_modules/teevi/src/teevi.js"
-import {ChessboardPiecesAnimation} from "../src/cm-chessboard/ChessboardPiecesAnimation.js"
-import {ChessboardState} from "../src/cm-chessboard/ChessboardState.js"
-import {ViewMock} from "./mocks/ViewMock.js"
-
-const cfa = new ChessboardPiecesAnimation(new ViewMock())
+import {State} from "../src/cm-chessboard/core/State.js"
+import {PositionsAnimation} from "../src/cm-chessboard/core/PositionAnimationsQueue.js"
 
 describe("TestPiecesAnimation", () => {
     it("should calculate square distances", () => {
-        assert.equals(cfa.squareDistance(0, 0), 0)
-        assert.equals(cfa.squareDistance(0, 1), 1)
-        assert.equals(cfa.squareDistance(0, 7), 7)
-        assert.equals(cfa.squareDistance(0, 8), 1)
-        assert.equals(cfa.squareDistance(10, 20), 2)
-        assert.equals(cfa.squareDistance(0, 63), 7)
-        assert.equals(cfa.squareDistance(8, 24), 2)
-        assert.equals(cfa.squareDistance(14, 24), 6)
+        assert.equals(PositionsAnimation.squareDistance(0, 0), 0)
+        assert.equals(PositionsAnimation.squareDistance(0, 1), 1)
+        assert.equals(PositionsAnimation.squareDistance(0, 7), 7)
+        assert.equals(PositionsAnimation.squareDistance(0, 8), 1)
+        assert.equals(PositionsAnimation.squareDistance(10, 20), 2)
+        assert.equals(PositionsAnimation.squareDistance(0, 63), 7)
+        assert.equals(PositionsAnimation.squareDistance(8, 24), 2)
+        assert.equals(PositionsAnimation.squareDistance(14, 24), 6)
     })
 
     it("should seek changes", () => {
-        const state1 = new ChessboardState()
+        const state1 = new State()
         state1.setPosition("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR")
-        const state2 = new ChessboardState()
+        const state2 = new State()
         state2.setPosition("rn2k1r1/ppp1pp1p/3p2p1/5bn1/P7/2N2B2/1PPPPP2/2BNK1RR")
         const previousBoard1 = state1.position.squares
         const newBoard1 = state2.position.squares
-        const changes = cfa.seekChanges(previousBoard1, newBoard1)
+        const changes = PositionsAnimation.seekChanges(previousBoard1, newBoard1)
 
         assert.equals(changes[0].type,0 )
         assert.equals(changes[0].piece, "wn")

package/test/TestPosition.js

@@ -5,7 +5,7 @@
  */
 
 import {describe, it, assert} from "../node_modules/teevi/src/teevi.js"
-import {Position} from "../src/cm-chessboard/Position.js"
+import {Position} from "../src/cm-chessboard/core/Position.js"
 
 describe("TestPosition", () => {
     it("should convert square to index", () => {

package/src/cm-chessboard/ChessboardPiecesAnimation.js

@@ -1,142 +0,0 @@
-/**
- * Author and copyright: Stefan Haack (https://shaack.com)
- * Repository: https://github.com/shaack/cm-chessboard
- * License: MIT, see file 'LICENSE'
- */
-import {Position} from "./Position.js"
-
-const CHANGE_TYPE = {
-    move: 0,
-    appear: 1,
-    disappear: 2
-}
-
-export class ChessboardPiecesAnimation {
-
-    constructor(view, fromSquares, toSquares, duration, callback) {
-        this.view = view
-        if (fromSquares && toSquares) {
-            this.animatedElements = this.createAnimation(fromSquares, toSquares)
-            this.duration = duration
-            this.callback = callback
-            this.frameHandle = requestAnimationFrame(this.animationStep.bind(this))
-        }
-    }
-
-    seekChanges(fromSquares, toSquares) {
-        const appearedList = [], disappearedList = [], changes = []
-        for (let i = 0; i < 64; i++) {
-            const previousSquare = fromSquares[i]
-            const newSquare = toSquares[i]
-            if (newSquare !== previousSquare) {
-                if (newSquare) {
-                    appearedList.push({piece: newSquare, index: i})
-                }
-                if (previousSquare) {
-                    disappearedList.push({piece: previousSquare, index: i})
-                }
-            }
-        }
-        appearedList.forEach((appeared) => {
-            let shortestDistance = 8
-            let foundMoved = undefined
-            disappearedList.forEach((disappeared) => {
-                if (appeared.piece === disappeared.piece) {
-                    const moveDistance = this.squareDistance(appeared.index, disappeared.index)
-                    if (moveDistance < shortestDistance) {
-                        foundMoved = disappeared
-                        shortestDistance = moveDistance
-                    }
-                }
-            })
-            if (foundMoved) {
-                disappearedList.splice(disappearedList.indexOf(foundMoved), 1) // remove from disappearedList, because it is moved now
-                changes.push({
-                    type: CHANGE_TYPE.move,
-                    piece: appeared.piece,
-                    atIndex: foundMoved.index,
-                    toIndex: appeared.index
-                })
-            } else {
-                changes.push({type: CHANGE_TYPE.appear, piece: appeared.piece, atIndex: appeared.index})
-            }
-        })
-        disappearedList.forEach((disappeared) => {
-            changes.push({type: CHANGE_TYPE.disappear, piece: disappeared.piece, atIndex: disappeared.index})
-        })
-        return changes
-    }
-
-    createAnimation(fromSquares, toSquares) {
-        const changes = this.seekChanges(fromSquares, toSquares)
-        const animatedElements = []
-        changes.forEach((change) => {
-            const animatedItem = {
-                type: change.type
-            }
-            switch (change.type) {
-                case CHANGE_TYPE.move:
-                    animatedItem.element = this.view.getPiece(Position.indexToSquare(change.atIndex))
-                    animatedItem.atPoint = this.view.indexToPoint(change.atIndex)
-                    animatedItem.toPoint = this.view.indexToPoint(change.toIndex)
-                    break
-                case CHANGE_TYPE.appear:
-                    animatedItem.element = this.view.drawPiece(Position.indexToSquare(change.atIndex), change.piece)
-                    animatedItem.element.style.opacity = 0
-                    break
-                case CHANGE_TYPE.disappear:
-                    animatedItem.element = this.view.getPiece(Position.indexToSquare(change.atIndex))
-                    break
-            }
-            animatedElements.push(animatedItem)
-        })
-        return animatedElements
-    }
-
-    animationStep(time) {
-        if (!this.startTime) {
-            this.startTime = time
-        }
-        const timeDiff = time - this.startTime
-        if (timeDiff <= this.duration) {
-            this.frameHandle = requestAnimationFrame(this.animationStep.bind(this))
-        } else {
-            cancelAnimationFrame(this.frameHandle)
-            this.callback()
-            return
-        }
-        const t = Math.min(1, timeDiff / this.duration)
-        const progress = t < .5 ? 2 * t * t : -1 + (4 - 2 * t) * t // easeInOut
-        this.animatedElements.forEach((animatedItem) => {
-            if (animatedItem.element) {
-                switch (animatedItem.type) {
-                    case CHANGE_TYPE.move:
-                        animatedItem.element.transform.baseVal.removeItem(0)
-                        const transform = (this.view.svg.createSVGTransform())
-                        transform.setTranslate(
-                            animatedItem.atPoint.x + (animatedItem.toPoint.x - animatedItem.atPoint.x) * progress,
-                            animatedItem.atPoint.y + (animatedItem.toPoint.y - animatedItem.atPoint.y) * progress)
-                        animatedItem.element.transform.baseVal.appendItem(transform)
-                        break
-                    case CHANGE_TYPE.appear:
-                        animatedItem.element.style.opacity = progress
-                        break
-                    case CHANGE_TYPE.disappear:
-                        animatedItem.element.style.opacity = 1 - progress
-                        break
-                }
-            } else {
-                console.warn("animatedItem has no element", animatedItem)
-            }
-        })
-    }
-
-    squareDistance(index1, index2) {
-        const file1 = index1 % 8
-        const rank1 = Math.floor(index1 / 8)
-        const file2 = index2 % 8
-        const rank2 = Math.floor(index2 / 8)
-        return Math.max(Math.abs(rank2 - rank1), Math.abs(file2 - file1))
-    }
-
-}

package/src/cm-chessboard/Observed.js

@@ -1,40 +0,0 @@
-/**
- * Author and copyright: Stefan Haack (https://shaack.com)
- * Repository: https://github.com/shaack/cm-chessboard
- * License: MIT, see file 'LICENSE'
- */
-
-export function Observed(target) {
-    const self = this
-    this.target = target
-    this.observers = []
-    this.target.addObserver = (callback, propertyName = undefined) => {
-        self.observers.push({callback: callback, property: propertyName})
-        // console.log(this.observers)
-    }
-    this.target.destruct = () => {
-        self.observers = []
-    }
-    this.proxy = new Proxy(this.target, {
-        set(target, property, value) {
-            const oldValue = target[property]
-            target[property] = value
-            // console.log("set", "property", property, "value", value)
-            for (const observer of self.observers) {
-                clearTimeout(observer.callbackDebounce)
-                observer.callbackDebounce = setTimeout(() => {
-                    if (!observer.property || observer.property === property) {
-                        observer.callback({
-                            target: target,
-                            property: property,
-                            value: value,
-                            oldValue: oldValue
-                        })
-                    }
-                })
-            }
-            return true
-        }
-    })
-    return this.proxy
-}