scrabble-solver 2.8.2 → 2.8.4

package/packages/solver/build/PatternsGenerator.js

@@ -1,95 +1,66 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var types_1 = require("@scrabble-solver/types");
-var PatternsGenerator = /** @class */ (function () {
-    function PatternsGenerator(config) {
+const types_1 = require("@scrabble-solver/types");
+class PatternsGenerator {
+    constructor(config) {
         this.config = config;
     }
-    PatternsGenerator.prototype.generate = function (board) {
-        return __spreadArray(__spreadArray([], __read(this.generateHorizontal(board)), false), __read(this.generateVertical(board)), false);
-    };
-    PatternsGenerator.prototype.generateHorizontal = function (board) {
+    generate(board) {
+        return [...this.generateHorizontal(board), ...this.generateVertical(board)];
+    }
+    generateHorizontal(board) {
         return this.generatePatterns({
-            board: board,
-            getNthVector: function (index) { return board.getRow(index); },
+            board,
+            getNthVector: (index) => board.getRow(index),
             numberOfVectors: this.config.boardHeight,
             PatternModel: types_1.HorizontalPattern,
         });
-    };
-    PatternsGenerator.prototype.generateVertical = function (board) {
+    }
+    generateVertical(board) {
         return this.generatePatterns({
-            board: board,
-            getNthVector: function (index) { return board.getColumn(index); },
+            board,
+            getNthVector: (index) => board.getColumn(index),
             numberOfVectors: this.config.boardWidth,
             PatternModel: types_1.VerticalPattern,
         });
-    };
-    PatternsGenerator.prototype.generatePatterns = function (_a) {
-        var _this = this;
-        var board = _a.board, getNthVector = _a.getNthVector, numberOfVectors = _a.numberOfVectors, PatternModel = _a.PatternModel;
-        return this.generateVectors({ getNthVector: getNthVector, numberOfVectors: numberOfVectors }).reduce(function (patterns, cells) {
-            return patterns.concat(_this.generateCellsPatterns({ board: board, PatternModel: PatternModel, cells: cells }));
+    }
+    generatePatterns({ board, getNthVector, numberOfVectors, PatternModel, }) {
+        return this.generateVectors({ getNthVector, numberOfVectors }).reduce((patterns, cells) => {
+            return patterns.concat(this.generateCellsPatterns({ board, PatternModel, cells }));
         }, []);
-    };
-    PatternsGenerator.prototype.generateVectors = function (_a) {
-        var getNthVector = _a.getNthVector, numberOfVectors = _a.numberOfVectors;
+    }
+    generateVectors({ getNthVector, numberOfVectors, }) {
         return Array(numberOfVectors)
             .fill(0)
-            .map(function (_, index) { return getNthVector(index); });
-    };
-    PatternsGenerator.prototype.generateCellsPatterns = function (_a) {
-        var _this = this;
-        var board = _a.board, cells = _a.cells, PatternModel = _a.PatternModel;
-        return this.generateStartIndices(cells).reduce(function (patterns, startIndex) {
-            return patterns.concat(_this.generateEndIndices(cells, startIndex).reduce(function (placeablePatterns, endIndex) {
-                var pattern = new PatternModel({
-                    board: board,
+            .map((_, index) => getNthVector(index));
+    }
+    generateCellsPatterns({ board, cells, PatternModel, }) {
+        return this.generateStartIndices(cells).flatMap((startIndex) => {
+            const endIndices = this.generateEndIndices(cells, startIndex);
+            const patterns = [];
+            for (const endIndex of endIndices) {
+                const pattern = new PatternModel({
+                    board,
                     cells: cells.slice(startIndex, endIndex + 1),
                 });
-                if (pattern.canBePlaced(_this.config)) {
-                    placeablePatterns.push(pattern);
+                if (pattern.canBePlaced(this.config)) {
+                    patterns.push(pattern);
                 }
-                return placeablePatterns;
-            }, []));
-        }, []);
-    };
-    PatternsGenerator.prototype.generateStartIndices = function (cells) {
+            }
+            return patterns;
+        });
+    }
+    generateStartIndices(cells) {
         return Array(cells.length - 1)
             .fill(0)
-            .map(function (_, startIndex) { return startIndex; })
-            .filter(function (startIndex) { return startIndex === 0 || !cells[startIndex - 1].hasTile(); });
-    };
-    PatternsGenerator.prototype.generateEndIndices = function (cells, startIndex) {
+            .map((_, startIndex) => startIndex)
+            .filter((startIndex) => startIndex === 0 || !cells[startIndex - 1].hasTile());
+    }
+    generateEndIndices(cells, startIndex) {
         return Array(cells.length - startIndex - 1)
             .fill(0)
-            .map(function (_, endIndex) { return endIndex + startIndex + 1; })
-            .filter(function (endIndex) { return endIndex >= cells.length - 1 || !cells[endIndex + 1].hasTile(); });
-    };
-    return PatternsGenerator;
-}());
+            .map((_, endIndex) => endIndex + startIndex + 1)
+            .filter((endIndex) => endIndex >= cells.length - 1 || !cells[endIndex + 1].hasTile());
+    }
+}
 exports.default = PatternsGenerator;

package/packages/solver/build/ScoresCalculator.js

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("@scrabble-solver/constants");
-var ScoresCalculator = /** @class */ (function () {
-    function ScoresCalculator(config) {
-        var _this = this;
-        this.reduceCellScore = function (_a, cell) {
-            var multiplier = _a.multiplier, score = _a.score;
-            var bonus = _this.config.getCellBonus(cell);
-            var _b = bonus && bonus.canApply(_this.config, cell) ? bonus.value : constants_1.NO_BONUS, characterMultiplier = _b.characterMultiplier, wordMultiplier = _b.wordMultiplier;
-            var characterScore = cell.tile.isBlank ? _this.config.blankScore : _this.config.pointsMap[cell.tile.character];
+const constants_1 = require("@scrabble-solver/constants");
+class ScoresCalculator {
+    constructor(config) {
+        this.reduceCellScore = ({ multiplier, score }, cell) => {
+            const bonus = this.config.getCellBonus(cell);
+            const { characterMultiplier, wordMultiplier } = bonus && bonus.canApply(this.config, cell) ? bonus.value : constants_1.NO_BONUS;
+            const characterScore = cell.tile.isBlank ? this.config.blankScore : this.config.pointsMap[cell.tile.character];
             return {
                 multiplier: multiplier * wordMultiplier,
                 score: score + characterScore * characterMultiplier,
@@ -16,26 +14,24 @@ var ScoresCalculator = /** @class */ (function () {
         };
         this.config = config;
     }
-    ScoresCalculator.prototype.calculate = function (pattern) {
+    calculate(pattern) {
         return this.calculatePatternScoreWithCollisions(pattern) + this.calculateBonusScore(pattern);
-    };
-    ScoresCalculator.prototype.calculateBonusScore = function (pattern) {
-        var areAllTilesUsed = pattern.getNumberOfEmptyCells() === this.config.maximumNumberOfCharacters;
+    }
+    calculateBonusScore(pattern) {
+        const areAllTilesUsed = pattern.getNumberOfEmptyCells() === this.config.maximumNumberOfCharacters;
         return areAllTilesUsed ? this.config.allTilesBonusScore : 0;
-    };
-    ScoresCalculator.prototype.calculatePatternScoreWithCollisions = function (pattern) {
-        var _this = this;
+    }
+    calculatePatternScoreWithCollisions(pattern) {
         return pattern
             .getCollisions()
-            .reduce(function (patternsScore, collisionPattern) { return patternsScore + _this.calculatePatternScore(collisionPattern); }, this.calculatePatternScore(pattern));
-    };
-    ScoresCalculator.prototype.calculatePatternScore = function (pattern) {
-        var _a = pattern.cells.reduce(this.reduceCellScore, {
+            .reduce((patternsScore, collisionPattern) => patternsScore + this.calculatePatternScore(collisionPattern), this.calculatePatternScore(pattern));
+    }
+    calculatePatternScore(pattern) {
+        const { multiplier, score } = pattern.cells.reduce(this.reduceCellScore, {
             multiplier: 1,
             score: 0,
-        }), multiplier = _a.multiplier, score = _a.score;
+        });
         return score * multiplier;
-    };
-    return ScoresCalculator;
-}());
+    }
+}
 exports.default = ScoresCalculator;

package/packages/solver/build/Solver.js

@@ -3,33 +3,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var types_1 = require("@scrabble-solver/types");
-var uniqBy_1 = __importDefault(require("lodash/uniqBy"));
-var PatternsFiller_1 = __importDefault(require("./PatternsFiller"));
-var PatternsGenerator_1 = __importDefault(require("./PatternsGenerator"));
-var ScoresCalculator_1 = __importDefault(require("./ScoresCalculator"));
-var Solver = /** @class */ (function () {
-    function Solver(config, trie) {
+const types_1 = require("@scrabble-solver/types");
+const uniqBy_1 = __importDefault(require("lodash/uniqBy"));
+const PatternsFiller_1 = __importDefault(require("./PatternsFiller"));
+const PatternsGenerator_1 = __importDefault(require("./PatternsGenerator"));
+const ScoresCalculator_1 = __importDefault(require("./ScoresCalculator"));
+class Solver {
+    constructor(config, trie) {
         this.patternsFiller = new PatternsFiller_1.default(config, trie);
         this.patternsGenerator = new PatternsGenerator_1.default(config);
         this.scoresCalculator = new ScoresCalculator_1.default(config);
     }
-    Solver.prototype.solve = function (board, tiles) {
-        var _this = this;
-        var patterns = this.patternsGenerator
-            .generate(board)
-            .reduce(function (filledPatterns, pattern) { return filledPatterns.concat(_this.patternsFiller.fill(pattern, tiles)); }, []);
-        var uniquePatterns = (0, uniqBy_1.default)(patterns, function (pattern) { return JSON.stringify(pattern.toJson()); });
-        var results = uniquePatterns.map(function (pattern, index) {
-            return new types_1.Result({
-                cells: pattern.cells,
-                id: index,
-                numberOfCollisions: pattern.getCollisions().length,
-                points: _this.scoresCalculator.calculate(pattern),
-            });
-        });
+    solve(board, tiles) {
+        const patterns = this.patternsGenerator.generate(board);
+        const filledPatterns = patterns.flatMap((pattern) => this.patternsFiller.fill(pattern, tiles));
+        const uniquePatterns = (0, uniqBy_1.default)(filledPatterns, (pattern) => JSON.stringify(pattern.toJson()));
+        const results = uniquePatterns.map((pattern, index) => new types_1.Result({
+            cells: pattern.cells,
+            id: index,
+            numberOfCollisions: pattern.getCollisions().length,
+            points: this.scoresCalculator.calculate(pattern),
+        }));
         return results;
-    };
-    return Solver;
-}());
+    }
+}
 exports.default = Solver;

package/packages/solver/package-lock.json

@@ -1,33 +1,33 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrabble-solver/solver",
-      "version": "2.8.2",
+      "version": "2.8.4",
       "license": "CC-BY-NC-ND-4.0",
       "dependencies": {
-        "@kamilmielnik/trie": "^1.0.3",
+        "@kamilmielnik/trie": "^2.0.0",
         "lodash": "^4.17.21"
       },
       "devDependencies": {
-        "@types/lodash": "^4.14.185"
+        "@types/lodash": "^4.14.186"
       }
     },
     "node_modules/@kamilmielnik/trie": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-1.0.3.tgz",
-      "integrity": "sha512-xIGglzz91BwfudrsNoxX0nRlfUrGu7Y9QxJ5RnrapLGZAer02CiVayBP00gndpkP3xjmueI9l49xb4W3JgcLXA==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-2.0.0.tgz",
+      "integrity": "sha512-YWTYtrV97bQ5hRifG1FImP47PI400a56O8+oQClQOtDjY3tioxab4sOgFHckiDdswciN1RwngCZ9Kv3phJfSuA==",
       "engines": {
-        "node": ">=10"
+        "node": ">=16"
       }
     },
     "node_modules/@types/lodash": {
-      "version": "4.14.185",
-      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.185.tgz",
-      "integrity": "sha512-evMDG1bC4rgQg4ku9tKpuMh5iBNEwNa3tf9zRHdP1qlv+1WUg44xat4IxCE14gIpZRGUUWAx2VhItCZc25NfMA==",
+      "version": "4.14.186",
+      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.186.tgz",
+      "integrity": "sha512-eHcVlLXP0c2FlMPm56ITode2AgLMSa6aJ05JTTbYbI+7EMkCEE5qk2E41d5g2lCVTqRe0GnnRFurmlCsDODrPw==",
       "dev": true
     },
     "node_modules/lodash": {
@@ -38,14 +38,14 @@
   },
   "dependencies": {
     "@kamilmielnik/trie": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-1.0.3.tgz",
-      "integrity": "sha512-xIGglzz91BwfudrsNoxX0nRlfUrGu7Y9QxJ5RnrapLGZAer02CiVayBP00gndpkP3xjmueI9l49xb4W3JgcLXA=="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-2.0.0.tgz",
+      "integrity": "sha512-YWTYtrV97bQ5hRifG1FImP47PI400a56O8+oQClQOtDjY3tioxab4sOgFHckiDdswciN1RwngCZ9Kv3phJfSuA=="
     },
     "@types/lodash": {
-      "version": "4.14.185",
-      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.185.tgz",
-      "integrity": "sha512-evMDG1bC4rgQg4ku9tKpuMh5iBNEwNa3tf9zRHdP1qlv+1WUg44xat4IxCE14gIpZRGUUWAx2VhItCZc25NfMA==",
+      "version": "4.14.186",
+      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.186.tgz",
+      "integrity": "sha512-eHcVlLXP0c2FlMPm56ITode2AgLMSa6aJ05JTTbYbI+7EMkCEE5qk2E41d5g2lCVTqRe0GnnRFurmlCsDODrPw==",
       "dev": true
     },
     "lodash": {

package/packages/solver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "description": "Scrabble Solver 2 - Solver",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -24,15 +24,15 @@
     "clean:force": "npm run clean && rimraf package-lock.json"
   },
   "dependencies": {
-    "@kamilmielnik/trie": "^1.0.3",
-    "@scrabble-solver/types": "^2.8.2",
+    "@kamilmielnik/trie": "^2.0.0",
+    "@scrabble-solver/types": "^2.8.4",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.8.2",
-    "@scrabble-solver/constants": "^2.8.2",
-    "@scrabble-solver/dictionaries": "^2.8.2",
-    "@types/lodash": "^4.14.185"
+    "@scrabble-solver/configs": "^2.8.4",
+    "@scrabble-solver/constants": "^2.8.4",
+    "@scrabble-solver/dictionaries": "^2.8.4",
+    "@types/lodash": "^4.14.186"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }

package/packages/solver/src/PatternsFiller.ts

@@ -24,7 +24,7 @@ class PatternsFiller {
 
     for (let index = 0; index < tilesPermutations.length; ++index) {
       const tilesPermutation = tilesPermutations[index];
-      this.fillPattern(pattern, String(pattern), tilesPermutation, onPatternFound);
+      this.fillPattern(pattern, pattern.toString(), tilesPermutation, onPatternFound);
     }
 
     return patterns;
@@ -45,7 +45,6 @@ class PatternsFiller {
     } else {
       for (let index = 0; index < tiles.length; ++index) {
         const tile = tiles[index];
-        const remainingTiles = tiles.slice(0, index).concat(tiles.slice(index + 1));
         const previousTile = pattern.cells[indexOfFirstCellWithoutTile].tile;
         pattern.cells[indexOfFirstCellWithoutTile].tile = tile;
         const indexOfNextCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
@@ -57,7 +56,9 @@ class PatternsFiller {
             onPatternFound(pattern.clone());
           }
         } else if (this.trie.hasPrefix(newWordPrefix)) {
-          this.fillPattern(pattern, newWord, remainingTiles, onPatternFound);
+          tiles.splice(index, 1);
+          this.fillPattern(pattern, newWord, tiles, onPatternFound);
+          tiles.splice(index, 0, tile);
         }
         pattern.cells[indexOfFirstCellWithoutTile].tile = previousTile;
       }
@@ -65,13 +66,7 @@ class PatternsFiller {
   }
 
   public canAddPattern(pattern: Pattern, word: string): boolean {
-    return (
-      this.trie.has(word) &&
-      pattern
-        .getCollisions()
-        .map(String)
-        .every((collision) => this.trie.has(collision))
-    );
+    return this.trie.has(word) && pattern.getCollisions().every((collision) => this.trie.has(collision.toString()));
   }
 
   public generateBlankTilesPermutations(tiles: Tile[]): Tile[][] {

package/packages/solver/src/PatternsGenerator.ts

@@ -66,22 +66,23 @@ class PatternsGenerator {
     cells: Cell[];
     PatternModel: new (parameters: { board: Board; cells: Cell[] }) => P;
   }): P[] {
-    return this.generateStartIndices(cells).reduce<P[]>(
-      (patterns, startIndex) =>
-        patterns.concat(
-          this.generateEndIndices(cells, startIndex).reduce<P[]>((placeablePatterns, endIndex) => {
-            const pattern = new PatternModel({
-              board,
-              cells: cells.slice(startIndex, endIndex + 1),
-            });
-            if (pattern.canBePlaced(this.config)) {
-              placeablePatterns.push(pattern);
-            }
-            return placeablePatterns;
-          }, []),
-        ),
-      [],
-    );
+    return this.generateStartIndices(cells).flatMap((startIndex) => {
+      const endIndices = this.generateEndIndices(cells, startIndex);
+      const patterns: P[] = [];
+
+      for (const endIndex of endIndices) {
+        const pattern = new PatternModel({
+          board,
+          cells: cells.slice(startIndex, endIndex + 1),
+        });
+
+        if (pattern.canBePlaced(this.config)) {
+          patterns.push(pattern);
+        }
+      }
+
+      return patterns;
+    });
   }
 
   public generateStartIndices(cells: Cell[]): number[] {

package/packages/solver/src/Solver.ts

@@ -1,5 +1,5 @@
 import { Trie } from '@kamilmielnik/trie';
-import { Board, Config, Pattern, Result, Tile } from '@scrabble-solver/types';
+import { Board, Config, Result, Tile } from '@scrabble-solver/types';
 import uniqBy from 'lodash/uniqBy';
 
 import PatternsFiller from './PatternsFiller';
@@ -20,13 +20,9 @@ class Solver {
   }
 
   public solve(board: Board, tiles: Tile[]): Result[] {
-    const patterns = this.patternsGenerator
-      .generate(board)
-      .reduce<Pattern[]>(
-        (filledPatterns, pattern) => filledPatterns.concat(this.patternsFiller.fill(pattern, tiles)),
-        [],
-      );
-    const uniquePatterns = uniqBy(patterns, (pattern) => JSON.stringify(pattern.toJson()));
+    const patterns = this.patternsGenerator.generate(board);
+    const filledPatterns = patterns.flatMap((pattern) => this.patternsFiller.fill(pattern, tiles));
+    const uniquePatterns = uniqBy(filledPatterns, (pattern) => JSON.stringify(pattern.toJson()));
     const results = uniquePatterns.map(
       (pattern, index) =>
         new Result({

package/packages/types/build/Board.js

@@ -3,113 +3,96 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("@scrabble-solver/constants");
-var Cell_1 = __importDefault(require("./Cell"));
-var Tile_1 = __importDefault(require("./Tile"));
-var Board = /** @class */ (function () {
-    function Board(_a) {
-        var rows = _a.rows;
+const constants_1 = require("@scrabble-solver/constants");
+const Cell_1 = __importDefault(require("./Cell"));
+const Tile_1 = __importDefault(require("./Tile"));
+class Board {
+    constructor({ rows }) {
         this.rows = rows;
         this.numberOfColumns = rows[0].length;
         this.numberOfRows = rows.length;
     }
-    Board.create = function (width, height) {
+    static create(width, height) {
         return Board.fromStringArray(Array(height).fill(Array(width).fill(' ').join('')));
-    };
-    Board.fromJson = function (json) {
+    }
+    static fromJson(json) {
         return new Board({
-            rows: json.map(function (row) { return row.map(Cell_1.default.fromJson); }),
+            rows: json.map((row) => row.map(Cell_1.default.fromJson)),
         });
-    };
-    Board.fromStringArray = function (stringArray) {
+    }
+    static fromStringArray(stringArray) {
         return new Board({
-            rows: stringArray.map(function (row, y) {
-                return row.split('').map(function (character, x) {
-                    return new Cell_1.default({
-                        isEmpty: !character || character === constants_1.EMPTY_CELL,
-                        tile: character === constants_1.EMPTY_CELL ? Tile_1.default.Null : new Tile_1.default({ character: character }),
-                        x: x,
-                        y: y,
-                    });
-                });
-            }),
+            rows: stringArray.map((row, y) => row.split('').map((character, x) => new Cell_1.default({
+                isEmpty: !character || character === constants_1.EMPTY_CELL,
+                tile: character === constants_1.EMPTY_CELL ? Tile_1.default.Null : new Tile_1.default({ character }),
+                x,
+                y,
+            }))),
         });
-    };
-    Object.defineProperty(Board.prototype, "center", {
-        get: function () {
-            var x = Math.floor(this.numberOfColumns / 2);
-            var y = Math.floor(this.numberOfRows / 2);
-            return this.rows[y][x];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Board.prototype.clone = function () {
-        var rows = this.rows.map(function (row) { return row.map(function (cell) { return cell.clone(); }); });
-        return new Board({ rows: rows });
-    };
-    Board.prototype.collides = function (cell) {
+    }
+    get center() {
+        const x = Math.floor(this.numberOfColumns / 2);
+        const y = Math.floor(this.numberOfRows / 2);
+        return this.rows[y][x];
+    }
+    clone() {
+        const rows = this.rows.map((row) => row.map((cell) => cell.clone()));
+        return new Board({ rows });
+    }
+    collides(cell) {
         return this.collidesUp(cell) || this.collidesDown(cell) || this.collidesLeft(cell) || this.collidesRight(cell);
-    };
-    Board.prototype.collidesDown = function (_a) {
-        var x = _a.x, y = _a.y;
+    }
+    collidesDown({ x, y }) {
         return y < this.numberOfRows - 1 && !this.rows[y + 1][x].isEmpty;
-    };
-    Board.prototype.collidesLeft = function (_a) {
-        var x = _a.x, y = _a.y;
+    }
+    collidesLeft({ x, y }) {
         return x > 0 && !this.rows[y][x - 1].isEmpty;
-    };
-    Board.prototype.collidesRight = function (_a) {
-        var x = _a.x, y = _a.y;
+    }
+    collidesRight({ x, y }) {
         return x < this.numberOfColumns - 1 && !this.rows[y][x + 1].isEmpty;
-    };
-    Board.prototype.collidesUp = function (_a) {
-        var x = _a.x, y = _a.y;
+    }
+    collidesUp({ x, y }) {
         return y > 0 && !this.rows[y - 1][x].isEmpty;
-    };
-    Board.prototype.equals = function (other) {
+    }
+    equals(other) {
         return (this.numberOfColumns === other.numberOfColumns &&
             this.numberOfRows === other.numberOfRows &&
-            this.rows.every(function (row, rowIndex) {
-                return row.every(function (cell, cellIndex) {
+            this.rows.every((row, rowIndex) => {
+                return row.every((cell, cellIndex) => {
                     return cell.equals(other.rows[rowIndex][cellIndex]);
                 });
             }));
-    };
-    Board.prototype.getBlanksCount = function () {
-        return this.rows.reduce(function (count, row) {
-            return count + row.reduce(function (rowCount, cell) { return (cell.tile.isBlank ? rowCount + 1 : rowCount); }, 0);
+    }
+    getBlanksCount() {
+        return this.rows.reduce((count, row) => {
+            return count + row.reduce((rowCount, cell) => (cell.tile.isBlank ? rowCount + 1 : rowCount), 0);
         }, 0);
-    };
-    Board.prototype.getColumn = function (index) {
-        return this.rows.map(function (row) { return row[index]; });
-    };
-    Board.prototype.getRow = function (index) {
+    }
+    getColumn(index) {
+        return this.rows.map((row) => row[index]);
+    }
+    getRow(index) {
         return this.rows[index];
-    };
-    Board.prototype.getTilesCount = function () {
-        return this.rows.reduce(function (count, row) {
-            return count + row.reduce(function (rowCount, cell) { return (cell.hasTile() ? rowCount + 1 : rowCount); }, 0);
+    }
+    getTilesCount() {
+        return this.rows.reduce((count, row) => {
+            return count + row.reduce((rowCount, cell) => (cell.hasTile() ? rowCount + 1 : rowCount), 0);
         }, 0);
-    };
-    Board.prototype.isEmpty = function () {
-        return this.rows.every(function (row) { return row.every(function (_a) {
-            var isEmpty = _a.isEmpty;
-            return isEmpty;
-        }); });
-    };
-    Board.prototype.toJson = function () {
-        return this.rows.map(function (row) { return row.map(function (cell) { return cell.toJson(); }); });
-    };
-    Board.prototype.toString = function () {
-        return this.rows.map(function (row) { return row.map(String); }).join('\n');
-    };
-    Board.prototype.updateCell = function (x, y, updateCell) {
+    }
+    isEmpty() {
+        return this.rows.every((row) => row.every(({ isEmpty }) => isEmpty));
+    }
+    toJson() {
+        return this.rows.map((row) => row.map((cell) => cell.toJson()));
+    }
+    toString() {
+        return this.rows.map((row) => row.map(String)).join('\n');
+    }
+    updateCell(x, y, updateCell) {
         this.rows[y][x] = updateCell(this.rows[y][x]);
-    };
-    Board.prototype.updateRow = function (y, updateRow) {
+    }
+    updateRow(y, updateRow) {
         this.rows[y] = updateRow(this.rows[y]);
-    };
-    return Board;
-}());
+    }
+}
 exports.default = Board;