@scrabble-solver/solver 2.12.1 → 2.12.3

package/README.md

@@ -2,4 +2,4 @@
 
 ![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen.svg)
 
-The brains of the Scrabble-Solver.
+The brains of Scrabble Solver.

package/build/areDigraphsValid.d.ts

@@ -0,0 +1,3 @@
+import { Config, Pattern } from '@scrabble-solver/types';
+declare const areDigraphsValid: (config: Config, pattern: Pattern) => boolean;
+export default areDigraphsValid;

package/build/areDigraphsValid.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const areDigraphsValid = (config, pattern) => {
+    const { twoCharacterTiles } = config;
+    const { cells } = pattern;
+    for (let index = 0; index < cells.length - 1; ++index) {
+        const current = cells[index];
+        const next = cells[index + 1];
+        const digraphCandidate = current.tile.character + next.tile.character;
+        if (twoCharacterTiles.includes(digraphCandidate)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.default = areDigraphsValid;

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/index.d.ts

@@ -1,3 +1,4 @@
+export { default as areDigraphsValid } from './areDigraphsValid';
 export { default as fillPattern } from './fillPattern';
 export { default as generateEndIndices } from './generateEndIndices';
 export { default as generateHorizontalPatterns } from './generateHorizontalPatterns';

package/build/index.js

@@ -3,7 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.solve = exports.getUniquePatterns = exports.getPatternScore = exports.getPatternHash = exports.getCellsScore = exports.generateVerticalPatterns = exports.generateVectors = exports.generateStartIndices = exports.generatePatterns = exports.generatePattern = exports.generateHorizontalPatterns = exports.generateEndIndices = exports.fillPattern = void 0;
+exports.solve = exports.getUniquePatterns = exports.getPatternScore = exports.getPatternHash = exports.getCellsScore = exports.generateVerticalPatterns = exports.generateVectors = exports.generateStartIndices = exports.generatePatterns = exports.generatePattern = exports.generateHorizontalPatterns = exports.generateEndIndices = exports.fillPattern = exports.areDigraphsValid = void 0;
+var areDigraphsValid_1 = require("./areDigraphsValid");
+Object.defineProperty(exports, "areDigraphsValid", { enumerable: true, get: function () { return __importDefault(areDigraphsValid_1).default; } });
 var fillPattern_1 = require("./fillPattern");
 Object.defineProperty(exports, "fillPattern", { enumerable: true, get: function () { return __importDefault(fillPattern_1).default; } });
 var generateEndIndices_1 = require("./generateEndIndices");

package/build/solve.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const areDigraphsValid_1 = __importDefault(require("./areDigraphsValid"));
 const fillPattern_1 = __importDefault(require("./fillPattern"));
 const generatePatterns_1 = __importDefault(require("./generatePatterns"));
 const getPatternScore_1 = __importDefault(require("./getPatternScore"));
@@ -10,7 +11,10 @@ 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 uniquePatterns = (0, getUniquePatterns_1.default)(filledPatterns);
+    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()),
         collisions: pattern.getCollisions().map((collision) => collision.cells.map((cell) => cell.toJson())),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.12.1",
+  "version": "2.12.3",
   "description": "Scrabble Solver 2 - Solver",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -17,7 +17,7 @@
   "bugs": {
     "url": "https://github.com/kamilmielnik/scrabble-solver/issues"
   },
-  "homepage": "https://github.com/kamilmielnik/scrabble-solver#readme",
+  "homepage": "https://scrabble-solver.org",
   "scripts": {
     "build": "tsc --project .",
     "clean": "rimraf build/ node_modules/",
@@ -25,12 +25,12 @@
   },
   "dependencies": {
     "@kamilmielnik/trie": "^2.0.1",
-    "@scrabble-solver/types": "^2.12.1"
+    "@scrabble-solver/types": "^2.12.3"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.12.1",
-    "@scrabble-solver/constants": "^2.12.1",
-    "@scrabble-solver/dictionaries": "^2.12.1"
+    "@scrabble-solver/configs": "^2.12.3",
+    "@scrabble-solver/constants": "^2.12.3",
+    "@scrabble-solver/dictionaries": "^2.12.3"
   },
-  "gitHead": "4f9a96d05558a90c90c5614c4929ce636f696f11"
+  "gitHead": "5400e276feee01557044e4e758b11e86b83fb085"
 }

package/src/areDigraphsValid.ts

@@ -0,0 +1,20 @@
+import { Config, Pattern } from '@scrabble-solver/types';
+
+const areDigraphsValid = (config: Config, pattern: Pattern): boolean => {
+  const { twoCharacterTiles } = config;
+  const { cells } = pattern;
+
+  for (let index = 0; index < cells.length - 1; ++index) {
+    const current = cells[index];
+    const next = cells[index + 1];
+    const digraphCandidate = current.tile.character + next.tile.character;
+
+    if (twoCharacterTiles.includes(digraphCandidate)) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+export default areDigraphsValid;

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         ',
@@ -57,4 +58,13 @@ describe('getPatternScore', () => {
 
     expect(getPatternScore(config, pattern)).toBe(2);
   });
+
+  it('gives 0 score for unknown characters', () => {
+    const pattern = new HorizontalPattern(board, [
+      new Cell({ x: 13, y: 14, tile: new Tile({ character: '?', isBlank: false }), isEmpty: true }),
+      new Cell({ x: 12, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
+    ]);
+
+    expect(getPatternScore(config, pattern)).toBe(2);
+  });
 });

package/src/index.ts

@@ -1,3 +1,4 @@
+export { default as areDigraphsValid } from './areDigraphsValid';
 export { default as fillPattern } from './fillPattern';
 export { default as generateEndIndices } from './generateEndIndices';
 export { default as generateHorizontalPatterns } from './generateHorizontalPatterns';

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(() => {
@@ -47,7 +49,7 @@ describe('solve - PL', () => {
     ]);
     const tiles = generateTiles(['l', 'i', 'n', 'o']);
     const results = solve(trie!, config, board, tiles);
-    expect(results.length).toBe(61);
+    expect(results.length).toBe(60);
   });
 
   it('zmartwychwstałą x9', () => {
@@ -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(() => {
@@ -136,4 +161,65 @@ describe('solve - ES', () => {
     expect(results.length).toBe(24);
     expect(bestResult.points).toBe(22);
   });
+
+  it('chooho - does not use C + H to imitate CH', () => {
+    const board = Board.fromStringArray([
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+      '               ',
+    ]);
+    const tiles = generateTiles(['ch', 'o', 'o', 'c', 'h']);
+    const results = solve(trie!, config, board, tiles);
+    const words = results.map((result) => result.cells.map((cell) => cell.tile?.character).join(''));
+    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

@@ -1,6 +1,7 @@
 import { Trie } from '@kamilmielnik/trie';
 import { Board, Config, ResultJson, Tile } from '@scrabble-solver/types';
 
+import areDigraphsValid from './areDigraphsValid';
 import fillPattern from './fillPattern';
 import generatePatterns from './generatePatterns';
 import getPatternScore from './getPatternScore';
@@ -9,7 +10,11 @@ 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 uniquePatterns = getUniquePatterns(filledPatterns);
+  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()),
     collisions: pattern.getCollisions().map((collision) => collision.cells.map((cell) => cell.toJson())),