@scrabble-solver/solver 2.8.2 → 2.8.4

package/build/PatternsFiller.js

@@ -1,104 +1,70 @@
 "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 constants_1 = require("@scrabble-solver/constants");
-var types_1 = require("@scrabble-solver/types");
-var PatternsFiller = /** @class */ (function () {
-    function PatternsFiller(config, trie) {
+const constants_1 = require("@scrabble-solver/constants");
+const types_1 = require("@scrabble-solver/types");
+class PatternsFiller {
+    constructor(config, trie) {
         this.config = config;
         this.trie = trie;
     }
-    PatternsFiller.prototype.fill = function (pattern, tiles) {
-        var patterns = [];
+    fill(pattern, tiles) {
+        const patterns = [];
         if (pattern.getNumberOfEmptyCells() > tiles.length) {
             return [];
         }
-        var onPatternFound = function (newPattern) { return patterns.push(newPattern); };
-        var tilesPermutations = this.generateBlankTilesPermutations(tiles);
-        for (var index = 0; index < tilesPermutations.length; ++index) {
-            var tilesPermutation = tilesPermutations[index];
-            this.fillPattern(pattern, String(pattern), tilesPermutation, onPatternFound);
+        const onPatternFound = (newPattern) => patterns.push(newPattern);
+        const tilesPermutations = this.generateBlankTilesPermutations(tiles);
+        for (let index = 0; index < tilesPermutations.length; ++index) {
+            const tilesPermutation = tilesPermutations[index];
+            this.fillPattern(pattern, pattern.toString(), tilesPermutation, onPatternFound);
         }
         return patterns;
-    };
-    PatternsFiller.prototype.fillPattern = function (pattern, word, tiles, onPatternFound) {
-        var indexOfFirstCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
+    }
+    fillPattern(pattern, word, tiles, onPatternFound) {
+        const indexOfFirstCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
         if (indexOfFirstCellWithoutTile === -1) {
             if (this.canAddPattern(pattern, word)) {
                 onPatternFound(pattern.clone());
             }
         }
         else {
-            for (var index = 0; index < tiles.length; ++index) {
-                var tile = tiles[index];
-                var remainingTiles = tiles.slice(0, index).concat(tiles.slice(index + 1));
-                var previousTile = pattern.cells[indexOfFirstCellWithoutTile].tile;
+            for (let index = 0; index < tiles.length; ++index) {
+                const tile = tiles[index];
+                const previousTile = pattern.cells[indexOfFirstCellWithoutTile].tile;
                 pattern.cells[indexOfFirstCellWithoutTile].tile = tile;
-                var indexOfNextCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
-                var indexOfFirstEmptyLetter = word.indexOf(constants_1.EMPTY_CELL);
-                var newWordPrefix = word.substring(0, indexOfFirstEmptyLetter) + tile.character;
-                var newWord = newWordPrefix + word.substring(indexOfFirstEmptyLetter + 1);
+                const indexOfNextCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
+                const indexOfFirstEmptyLetter = word.indexOf(constants_1.EMPTY_CELL);
+                const newWordPrefix = word.substring(0, indexOfFirstEmptyLetter) + tile.character;
+                const newWord = newWordPrefix + word.substring(indexOfFirstEmptyLetter + 1);
                 if (indexOfNextCellWithoutTile === -1) {
                     if (this.canAddPattern(pattern, newWord)) {
                         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;
             }
         }
-    };
-    PatternsFiller.prototype.canAddPattern = function (pattern, word) {
-        var _this = this;
-        return (this.trie.has(word) &&
-            pattern
-                .getCollisions()
-                .map(String)
-                .every(function (collision) { return _this.trie.has(collision); }));
-    };
-    PatternsFiller.prototype.generateBlankTilesPermutations = function (tiles) {
-        var _this = this;
-        var alphabet = this.config.alphabet;
-        var firstBlankIndex = tiles.findIndex(function (_a) {
-            var character = _a.character, isBlank = _a.isBlank;
-            return isBlank && !alphabet.includes(character);
-        });
+    }
+    canAddPattern(pattern, word) {
+        return this.trie.has(word) && pattern.getCollisions().every((collision) => this.trie.has(collision.toString()));
+    }
+    generateBlankTilesPermutations(tiles) {
+        const { alphabet } = this.config;
+        const firstBlankIndex = tiles.findIndex(({ character, isBlank }) => isBlank && !alphabet.includes(character));
         if (firstBlankIndex === -1) {
             return [tiles];
         }
-        var remainingTiles = tiles.slice(0, firstBlankIndex).concat(tiles.slice(firstBlankIndex + 1));
-        return this.config.alphabet.reduce(function (permutations, character) {
-            var newTile = new types_1.Tile({ character: character, isBlank: true });
-            var newTiles = __spreadArray(__spreadArray([], __read(remainingTiles), false), [newTile], false);
-            return permutations.concat(_this.generateBlankTilesPermutations(newTiles));
+        const remainingTiles = tiles.slice(0, firstBlankIndex).concat(tiles.slice(firstBlankIndex + 1));
+        return this.config.alphabet.reduce((permutations, character) => {
+            const newTile = new types_1.Tile({ character, isBlank: true });
+            const newTiles = [...remainingTiles, newTile];
+            return permutations.concat(this.generateBlankTilesPermutations(newTiles));
         }, []);
-    };
-    return PatternsFiller;
-}());
+    }
+}
 exports.default = PatternsFiller;

package/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/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/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/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": "bf360562a79572dd4640ac7cd7f26199f1ba6899"
+  "gitHead": "3b0c4c9d7987e456f34f7e2918931b0024b8a393"
 }

package/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/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/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({