@scrabble-solver/solver 2.8.3 → 2.8.5

package/build/PatternsFiller.js

@@ -16,7 +16,7 @@ class PatternsFiller {
         const tilesPermutations = this.generateBlankTilesPermutations(tiles);
         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;
     }
@@ -51,11 +51,7 @@ class PatternsFiller {
         }
     }
     canAddPattern(pattern, word) {
-        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()));
     }
     generateBlankTilesPermutations(tiles) {
         const { alphabet } = this.config;

package/build/PatternsGenerator.js

@@ -35,16 +35,20 @@ class PatternsGenerator {
             .map((_, index) => getNthVector(index));
     }
     generateCellsPatterns({ board, cells, PatternModel, }) {
-        return this.generateStartIndices(cells).reduce((patterns, startIndex) => patterns.concat(this.generateEndIndices(cells, startIndex).reduce((placeablePatterns, endIndex) => {
-            const pattern = new PatternModel({
-                board,
-                cells: cells.slice(startIndex, endIndex + 1),
-            });
-            if (pattern.canBePlaced(this.config)) {
-                placeablePatterns.push(pattern);
+        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)) {
+                    patterns.push(pattern);
+                }
             }
-            return placeablePatterns;
-        }, [])), []);
+            return patterns;
+        });
     }
     generateStartIndices(cells) {
         return Array(cells.length - 1)

package/build/Solver.js

@@ -15,10 +15,9 @@ class Solver {
         this.scoresCalculator = new ScoresCalculator_1.default(config);
     }
     solve(board, tiles) {
-        const patterns = this.patternsGenerator
-            .generate(board)
-            .reduce((filledPatterns, pattern) => filledPatterns.concat(this.patternsFiller.fill(pattern, tiles)), []);
-        const uniquePatterns = (0, uniqBy_1.default)(patterns, (pattern) => JSON.stringify(pattern.toJson()));
+        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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.3",
+  "version": "2.8.5",
   "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.3",
+    "@kamilmielnik/trie": "^2.0.0",
+    "@scrabble-solver/types": "^2.8.5",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.8.3",
-    "@scrabble-solver/constants": "^2.8.3",
-    "@scrabble-solver/dictionaries": "^2.8.3",
-    "@types/lodash": "^4.14.185"
+    "@scrabble-solver/configs": "^2.8.5",
+    "@scrabble-solver/constants": "^2.8.5",
+    "@scrabble-solver/dictionaries": "^2.8.5",
+    "@types/lodash": "^4.14.186"
   },
-  "gitHead": "116f214733e7ad071044f556bcf67e867da3d9ca"
+  "gitHead": "79ba3664458e7dc8d805599a3cf3cd1faba86309"
 }

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;
@@ -66,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({