@scrabble-solver/solver 2.12.2 → 2.12.3

package/build/getPatternHash.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const getPatternHash = (pattern) => {
     return pattern.cells
+        .filter((cell) => cell.isEmpty)
         .map((cell) => {
         const blank = cell.tile.isBlank ? '!' : '';
         const tile = cell.tile.character + blank;
-        // eslint-disable-next-line prefer-template
-        return cell.x + ',' + cell.y + ',' + tile;
+        return [cell.x, cell.y, tile].join(',');
     })
         .join('-');
 };

package/build/solve.js

@@ -11,7 +11,9 @@ const getUniquePatterns_1 = __importDefault(require("./getUniquePatterns"));
 const solve = (trie, config, board, tiles) => {
     const patterns = (0, generatePatterns_1.default)(config, board);
     const filledPatterns = patterns.flatMap((pattern) => (0, fillPattern_1.default)(trie, config, pattern, tiles));
-    const validPatterns = filledPatterns.filter((pattern) => (0, areDigraphsValid_1.default)(config, pattern));
+    const validPatterns = config.twoCharacterTiles.length > 0
+        ? filledPatterns.filter((pattern) => (0, areDigraphsValid_1.default)(config, pattern))
+        : filledPatterns;
     const uniquePatterns = (0, getUniquePatterns_1.default)(validPatterns);
     const results = uniquePatterns.map((pattern, index) => ({
         cells: pattern.cells.map((cell) => cell.toJson()),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.12.2",
+  "version": "2.12.3",
   "description": "Scrabble Solver 2 - Solver",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -25,12 +25,12 @@
   },
   "dependencies": {
     "@kamilmielnik/trie": "^2.0.1",
-    "@scrabble-solver/types": "^2.12.2"
+    "@scrabble-solver/types": "^2.12.3"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.12.2",
-    "@scrabble-solver/constants": "^2.12.2",
-    "@scrabble-solver/dictionaries": "^2.12.2"
+    "@scrabble-solver/configs": "^2.12.3",
+    "@scrabble-solver/constants": "^2.12.3",
+    "@scrabble-solver/dictionaries": "^2.12.3"
   },
-  "gitHead": "22ec8b756bf1f50d94028c8e69ccc269c23e5759"
+  "gitHead": "5400e276feee01557044e4e758b11e86b83fb085"
 }

package/src/fillPattern.test.ts

@@ -1,13 +1,13 @@
 import { Trie } from '@kamilmielnik/trie';
-import { literaki } from '@scrabble-solver/configs';
+import { getConfig } from '@scrabble-solver/configs';
 import { dictionaries } from '@scrabble-solver/dictionaries';
-import { Board, Cell, FinalPattern, Locale, Pattern, Tile, VerticalPattern } from '@scrabble-solver/types';
+import { Board, Cell, FinalPattern, Game, Locale, Pattern, Tile, VerticalPattern } from '@scrabble-solver/types';
 
 import fillPattern, { fillPatternRecursive } from './fillPattern';
 
 const board = Board.fromStringArray([' t ', 'do ', '   ']);
 const locale = Locale.PL_PL;
-const config = literaki[locale];
+const config = getConfig(Game.Literaki, locale);
 
 describe('fillPattern', () => {
   let trie: Trie | undefined;

package/src/generatePatterns.test.ts

@@ -0,0 +1,13 @@
+import { getConfig } from '@scrabble-solver/configs';
+import { Board, Game, Locale } from '@scrabble-solver/types';
+
+import generatePatterns from './generatePatterns';
+
+describe('generatePatterns', () => {
+  it('Generates all patterns for an empty board', () => {
+    const config = getConfig(Game.Scrabble, Locale.EN_US);
+    const board = Board.create(config.boardWidth, config.boardHeight);
+
+    expect(generatePatterns(config, board).length).toEqual(54);
+  });
+});

package/src/getPatternHash.ts

@@ -2,11 +2,11 @@ import { Pattern } from '@scrabble-solver/types';
 
 const getPatternHash = (pattern: Pattern): string => {
   return pattern.cells
+    .filter((cell) => cell.isEmpty)
     .map((cell) => {
       const blank = cell.tile.isBlank ? '!' : '';
       const tile = cell.tile.character + blank;
-      // eslint-disable-next-line prefer-template
-      return cell.x + ',' + cell.y + ',' + tile;
+      return [cell.x, cell.y, tile].join(',');
     })
     .join('-');
 };

package/src/getPatternScore.test.ts

@@ -1,9 +1,10 @@
-import { literaki } from '@scrabble-solver/configs';
-import { Board, Cell, HorizontalPattern, Locale, Pattern, Tile, VerticalPattern } from '@scrabble-solver/types';
+import { getConfig } from '@scrabble-solver/configs';
+import { Board, Cell, Game, HorizontalPattern, Locale, Pattern, Tile, VerticalPattern } from '@scrabble-solver/types';
 
 import getPatternScore from './getPatternScore';
 
-const config = literaki[Locale.PL_PL];
+const locale = Locale.PL_PL;
+const config = getConfig(Game.Literaki, locale);
 const board = Board.fromStringArray([
   ' kasom         ',
   '     i         ',

package/src/solve.test.ts

@@ -1,7 +1,9 @@
+/* eslint-disable max-lines */
+
 import { Trie } from '@kamilmielnik/trie';
-import { literaki, scrabble } from '@scrabble-solver/configs';
+import { getConfig } from '@scrabble-solver/configs';
 import { dictionaries } from '@scrabble-solver/dictionaries';
-import { Board, Locale, Result, Tile } from '@scrabble-solver/types';
+import { Board, Game, Locale, Result, Tile } from '@scrabble-solver/types';
 
 import solve from './solve';
 
@@ -16,9 +18,9 @@ const getBestResult = ([firstResult, ...results]: Result[]): Result => {
   );
 };
 
-describe('solve - PL', () => {
+describe('solve - pl-PL', () => {
   const locale = Locale.PL_PL;
-  const config = literaki[locale];
+  const config = getConfig(Game.Literaki, locale);
   let trie: Trie | undefined;
 
   beforeAll(() => {
@@ -99,11 +101,34 @@ describe('solve - PL', () => {
     expect(bestResult.word).toBe('zmartwychwstałą');
     expect(bestResult.points).toBe(1157);
   });
+
+  it('does not duplicate results', () => {
+    const board = Board.fromStringArray([
+      '             a ',
+      '              a',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+    ]);
+    const tiles = generateTiles(['d']);
+    const results = solve(trie!, config, board, tiles);
+    expect(results.length).toBe(4);
+  });
 });
 
-describe('solve - ES', () => {
+describe('solve - es-ES', () => {
   const locale = Locale.ES_ES;
-  const config = scrabble[locale];
+  const config = getConfig(Game.Scrabble, locale);
   let trie: Trie | undefined;
 
   beforeAll(() => {
@@ -161,3 +186,40 @@ describe('solve - ES', () => {
     expect(words).not.toContain('chocho');
   });
 });
+
+describe('solve - en-GB', () => {
+  const locale = Locale.EN_GB;
+  const config = getConfig(Game.Scrabble, locale);
+  let trie: Trie | undefined;
+
+  beforeAll(() => {
+    return dictionaries.get(locale).then((loadedTrie) => {
+      trie = loadedTrie;
+    });
+  });
+
+  it('no', () => {
+    const board = Board.fromStringArray([
+      '               ',
+      '             ko',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+    ]);
+    const tiles = generateTiles(['n']);
+    const results = solve(trie!, config, board, tiles).map(Result.fromJson);
+    expect(results.some((result) => result.word === 'no')).toBe(true);
+    expect(results.some((result) => result.word === 'on')).toBe(true);
+    expect(results.length).toBe(2);
+  });
+});

package/src/solve.ts

@@ -10,7 +10,10 @@ import getUniquePatterns from './getUniquePatterns';
 const solve = (trie: Trie, config: Config, board: Board, tiles: Tile[]): ResultJson[] => {
   const patterns = generatePatterns(config, board);
   const filledPatterns = patterns.flatMap((pattern) => fillPattern(trie, config, pattern, tiles));
-  const validPatterns = filledPatterns.filter((pattern) => areDigraphsValid(config, pattern));
+  const validPatterns =
+    config.twoCharacterTiles.length > 0
+      ? filledPatterns.filter((pattern) => areDigraphsValid(config, pattern))
+      : filledPatterns;
   const uniquePatterns = getUniquePatterns(validPatterns);
   const results = uniquePatterns.map((pattern, index) => ({
     cells: pattern.cells.map((cell) => cell.toJson()),