scrabble-solver 2.8.8 → 2.8.9

package/packages/solver/src/fillPattern.test.ts

@@ -0,0 +1,107 @@
+import { Trie } from '@kamilmielnik/trie';
+import { literaki } from '@scrabble-solver/configs';
+import { dictionaries } from '@scrabble-solver/dictionaries';
+import { Board, Cell, FinalPattern, 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];
+
+describe('fillPattern', () => {
+  let trie: Trie | undefined;
+
+  beforeAll(() => {
+    return dictionaries.get(locale).then((loadedTrie) => {
+      trie = loadedTrie;
+    });
+  });
+
+  it('fills patterns', () => {
+    const pattern = new VerticalPattern(board, [
+      new Cell({ x: 0, y: 0 }),
+      new Cell({ x: 0, y: 1, tile: new Tile({ character: 'd', isBlank: false }) }),
+      new Cell({ x: 0, y: 2 }),
+    ]);
+    const tiles = [
+      new Tile({ character: 'o', isBlank: false }),
+      new Tile({ character: 'a', isBlank: false }),
+      new Tile({ character: 'd', isBlank: false }),
+    ];
+    const filledPatterns = fillPattern(trie!, config, pattern, tiles);
+
+    expect(filledPatterns.length).toBe(1);
+  });
+
+  it('fills patterns with blanks', () => {
+    const pattern = new VerticalPattern(board, [board.rows[0][1], board.rows[1][1], board.rows[2][1]]);
+    const tiles = [new Tile({ character: ' ', isBlank: true }), new Tile({ character: 'ó', isBlank: false })];
+    const filledPatterns = fillPattern(trie!, config, pattern, tiles);
+
+    expect(filledPatterns.map(String)).toEqual([
+      'toć',
+      'tog',
+      'toi',
+      'tok',
+      'tom',
+      'ton',
+      'toń',
+      'top',
+      'tor',
+      'tos',
+      'toy',
+      'toż',
+    ]);
+  });
+
+  it('does not modify filled patterns', () => {
+    const pattern = new FinalPattern(
+      new VerticalPattern(board, [
+        new Cell({ x: 0, y: 0, isEmpty: false, tile: new Tile({ character: 'o', isBlank: false }) }),
+        new Cell({ x: 0, y: 1, isEmpty: false, tile: new Tile({ character: 'k', isBlank: false }) }),
+        new Cell({ x: 0, y: 2, isEmpty: false, tile: new Tile({ character: 'o', isBlank: false }) }),
+      ]),
+    );
+    const tiles = [new Tile({ character: 'ń', isBlank: false })];
+    const filledPatterns = fillPattern(trie!, config, pattern, tiles);
+
+    expect(filledPatterns.length).toBe(1);
+    expect(filledPatterns[0]).toEqual(pattern);
+  });
+
+  it('does not accept non-placeable filled patterns', () => {
+    const pattern = new VerticalPattern(board, [
+      new Cell({ x: 0, y: 0, isEmpty: false, tile: new Tile({ character: 'd', isBlank: false }) }),
+      new Cell({ x: 0, y: 1, isEmpty: false, tile: new Tile({ character: 'd', isBlank: false }) }),
+      new Cell({ x: 0, y: 2, isEmpty: false, tile: new Tile({ character: 'd', isBlank: false }) }),
+    ]);
+    const tiles = [new Tile({ character: 'ń', isBlank: false })];
+    const filledPatterns = fillPattern(trie!, config, pattern, tiles);
+
+    expect(filledPatterns.length).toBe(0);
+  });
+});
+
+describe('fillPatternRecursive', () => {
+  let trie: Trie | undefined;
+
+  beforeAll(() => {
+    return dictionaries.get(locale).then((loadedTrie) => {
+      trie = loadedTrie;
+    });
+  });
+
+  it('checks collisions', () => {
+    const pattern = new VerticalPattern(board, [
+      new Cell({ x: 2, y: 0, isEmpty: true, tile: new Tile({ character: 'k', isBlank: false }) }),
+      new Cell({ x: 2, y: 1, isEmpty: true, tile: new Tile({ character: 'o', isBlank: false }) }),
+      new Cell({ x: 2, y: 2, isEmpty: true, tile: new Tile({ character: 't', isBlank: false }) }),
+    ]);
+    const results: Pattern[] = [];
+    const tiles = [new Tile({ character: 'ń', isBlank: false })];
+    fillPatternRecursive(results, trie!, config, pattern, pattern.toString(), tiles);
+
+    expect(results.length).toBe(0);
+  });
+});

package/packages/solver/src/fillPattern.ts

@@ -0,0 +1,70 @@
+/* eslint-disable max-params, max-statements */
+import { Trie } from '@kamilmielnik/trie';
+import { EMPTY_CELL } from '@scrabble-solver/constants';
+import { Config, FinalPattern, Pattern, Tile } from '@scrabble-solver/types';
+
+const fillPattern = (trie: Trie, config: Config, pattern: Pattern, tiles: Tile[]): Pattern[] => {
+  if (pattern.getEmptyCellsCount() > tiles.length) {
+    return [];
+  }
+
+  const results: Pattern[] = [];
+
+  fillPatternRecursive(results, trie, config, pattern, pattern.toString(), tiles);
+
+  return results;
+};
+
+export const fillPatternRecursive = (
+  /** gets mutated when this function is called */
+  results: Pattern[],
+  trie: Trie,
+  config: Config,
+  pattern: Pattern,
+  word: string,
+  tiles: Tile[],
+): void => {
+  const indexOfFirstCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
+
+  if (indexOfFirstCellWithoutTile === -1) {
+    if (trie.has(word) && pattern.getCollisions().every((collision) => trie.has(collision.toString()))) {
+      results.push(new FinalPattern(pattern.clone()));
+    }
+
+    return;
+  }
+
+  for (let index = 0; index < tiles.length; ++index) {
+    const tile = tiles[index];
+    const previousTile = pattern.cells[indexOfFirstCellWithoutTile].tile;
+
+    pattern.cells[indexOfFirstCellWithoutTile].tile = tile;
+
+    const indexOfNextCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
+    const indexOfFirstEmptyLetter = word.indexOf(EMPTY_CELL);
+    const prefix = word.substring(0, indexOfFirstEmptyLetter);
+    const suffix = word.substring(indexOfFirstEmptyLetter + 1);
+    const characters = tile.isBlank ? config.alphabet : [tile.character];
+
+    for (const character of characters) {
+      const newWordPrefix = prefix + character;
+      const newWord = newWordPrefix + suffix;
+
+      tile.character = character;
+
+      if (indexOfNextCellWithoutTile === -1) {
+        if (trie.has(newWord) && pattern.getCollisions().every((collision) => trie.has(collision.toString()))) {
+          results.push(new FinalPattern(pattern.clone()));
+        }
+      } else if (trie.hasPrefix(newWordPrefix)) {
+        tiles.splice(index, 1);
+        fillPatternRecursive(results, trie, config, pattern, newWord, tiles);
+        tiles.splice(index, 0, tile);
+      }
+    }
+
+    pattern.cells[indexOfFirstCellWithoutTile].tile = previousTile;
+  }
+};
+
+export default fillPattern;

package/packages/solver/src/generateEndIndices.test.ts

@@ -0,0 +1,18 @@
+import { Cell } from '@scrabble-solver/types';
+
+import generateEndIndices from './generateEndIndices';
+
+describe('generateEndIndices', () => {
+  const emptyCell: Cell = { hasTile: () => false } as Cell;
+  const filledCell: Cell = { hasTile: () => true } as Cell;
+
+  it('finds indices where a new word can end - XXOOOX', () => {
+    const cells = [filledCell, filledCell, emptyCell, emptyCell, emptyCell, filledCell];
+    expect(generateEndIndices(cells, 3)).toEqual([5]);
+  });
+
+  it('finds indices where a new word can end - XXOOOXO', () => {
+    const cells = [filledCell, filledCell, emptyCell, emptyCell, emptyCell, filledCell, emptyCell];
+    expect(generateEndIndices(cells, 3)).toEqual([5, 6]);
+  });
+});

package/packages/solver/src/generateEndIndices.ts

@@ -0,0 +1,10 @@
+import { Cell } from '@scrabble-solver/types';
+
+const generateEndIndices = (cells: Cell[], startIndex: number): number[] => {
+  return Array(cells.length - startIndex - 1)
+    .fill(0)
+    .map((_, endIndex) => endIndex + startIndex + 1)
+    .filter((endIndex) => endIndex >= cells.length - 1 || !cells[endIndex + 1].hasTile());
+};
+
+export default generateEndIndices;

package/packages/solver/src/generateHorizontalPatterns.test.ts

@@ -0,0 +1,31 @@
+import { EMPTY_CELL } from '@scrabble-solver/constants';
+import { Board, Config } from '@scrabble-solver/types';
+
+import generateHorizontalPatterns from './generateHorizontalPatterns';
+
+const board = Board.fromStringArray([' t ', 'do ', '   ']);
+
+const config = {
+  boardHeight: 3,
+  boardWidth: 3,
+  maximumCharactersCount: 7,
+} as Config;
+
+describe('generateHorizontalPatterns', () => {
+  it('generates some horizontal patterns', () => {
+    expect(generateHorizontalPatterns(config, board).length).toBeGreaterThan(0);
+  });
+
+  it('generates proper horizontal patterns', () => {
+    const horizontal = generateHorizontalPatterns(config, board);
+    expect(horizontal.map(({ cells }) => cells.map(String))).toEqual([
+      [EMPTY_CELL, 't'],
+      [EMPTY_CELL, 't', EMPTY_CELL],
+      ['t', EMPTY_CELL],
+      ['d', 'o', EMPTY_CELL],
+      [EMPTY_CELL, EMPTY_CELL],
+      [EMPTY_CELL, EMPTY_CELL, EMPTY_CELL],
+      [EMPTY_CELL, EMPTY_CELL],
+    ]);
+  });
+});

package/packages/solver/src/generateHorizontalPatterns.ts

@@ -0,0 +1,17 @@
+import { Board, Config, HorizontalPattern, Pattern } from '@scrabble-solver/types';
+
+import generatePattern from './generatePattern';
+import generateVectors from './generateVectors';
+
+const generateHorizontalPatterns = (config: Config, board: Board): Pattern[] => {
+  const getNthVector = (index: number) => board.getRow(index);
+  const vectorsCount = config.boardHeight;
+  const horizontalVectors = generateVectors({ getNthVector, vectorsCount });
+  const horizontalPatterns = horizontalVectors.flatMap((cells) => {
+    return generatePattern({ board, config, PatternModel: HorizontalPattern, cells });
+  });
+
+  return horizontalPatterns;
+};
+
+export default generateHorizontalPatterns;

package/packages/solver/src/generatePattern.ts

@@ -0,0 +1,35 @@
+import { Board, Cell, Config, Pattern } from '@scrabble-solver/types';
+
+import generateEndIndices from './generateEndIndices';
+import generateStartIndices from './generateStartIndices';
+
+const generatePattern = <P extends Pattern>({
+  board,
+  cells,
+  config,
+  PatternModel,
+}: {
+  board: Board;
+  cells: Cell[];
+  config: Config;
+  PatternModel: new (board: Board, cells: Cell[]) => P;
+}): P[] => {
+  const startIndices = generateStartIndices(cells);
+
+  return startIndices.flatMap((startIndex) => {
+    const endIndices = generateEndIndices(cells, startIndex);
+    const patterns: P[] = [];
+
+    for (const endIndex of endIndices) {
+      const pattern = new PatternModel(board, cells.slice(startIndex, endIndex + 1));
+
+      if (pattern.canBePlaced(config)) {
+        patterns.push(pattern);
+      }
+    }
+
+    return patterns;
+  });
+};
+
+export default generatePattern;

package/packages/solver/src/generatePatterns.ts

@@ -0,0 +1,13 @@
+import { Board, Config, Pattern } from '@scrabble-solver/types';
+
+import generateHorizontalPatterns from './generateHorizontalPatterns';
+import generateVerticalPatterns from './generateVerticalPatterns';
+
+const generatePatterns = (config: Config, board: Board): Pattern[] => {
+  const horizontalPatterns = generateHorizontalPatterns(config, board);
+  const verticalPatterns = generateVerticalPatterns(config, board);
+
+  return horizontalPatterns.concat(verticalPatterns);
+};
+
+export default generatePatterns;

package/packages/solver/src/generateStartIndices.test.ts

@@ -0,0 +1,14 @@
+import { Cell } from '@scrabble-solver/types';
+
+import generateStartIndices from './generateStartIndices';
+
+describe('generateStartIndices', () => {
+  const emptyCell: Cell = { hasTile: () => false } as Cell;
+  const filledCell: Cell = { hasTile: () => true } as Cell;
+
+  it('finds indices where a new word can start', () => {
+    const cells = [filledCell, filledCell, emptyCell, emptyCell, emptyCell, filledCell];
+    const startIndices = generateStartIndices(cells);
+    expect(startIndices).toEqual([0, 3, 4]);
+  });
+});

package/packages/solver/src/generateStartIndices.ts

@@ -0,0 +1,10 @@
+import { Cell } from '@scrabble-solver/types';
+
+const generateStartIndices = (cells: Cell[]): number[] => {
+  return Array(cells.length - 1)
+    .fill(0)
+    .map((_, startIndex) => startIndex)
+    .filter((startIndex) => startIndex === 0 || !cells[startIndex - 1].hasTile());
+};
+
+export default generateStartIndices;

package/packages/solver/src/generateVectors.test.ts

@@ -0,0 +1,12 @@
+import generateVectors from './generateVectors';
+
+describe('generateVectors', () => {
+  it('generates given number of vectors', () => {
+    const vectors = generateVectors({
+      getNthVector: () => [],
+      vectorsCount: 3,
+    });
+    expect(vectors.length).toBe(3);
+    expect(vectors).toEqual([[], [], []]);
+  });
+});

package/packages/solver/src/generateVectors.ts

@@ -0,0 +1,15 @@
+import { Cell } from '@scrabble-solver/types';
+
+const generateVectors = ({
+  getNthVector,
+  vectorsCount,
+}: {
+  getNthVector: (index: number) => Cell[];
+  vectorsCount: number;
+}): Cell[][] => {
+  return Array(vectorsCount)
+    .fill(0)
+    .map((_, index) => getNthVector(index));
+};
+
+export default generateVectors;

package/packages/solver/src/generateVerticalPatterns.test.ts

@@ -0,0 +1,32 @@
+import { EMPTY_CELL } from '@scrabble-solver/constants';
+import { Board, Config } from '@scrabble-solver/types';
+
+import generateVerticalPatterns from './generateVerticalPatterns';
+
+const board = Board.fromStringArray([' t ', 'do ', '   ']);
+
+const config = {
+  boardHeight: 3,
+  boardWidth: 3,
+  maximumCharactersCount: 7,
+} as Config;
+
+describe('generateVerticalPatterns', () => {
+  it('generates some vertical patterns', () => {
+    expect(generateVerticalPatterns(config, board).length).toBeGreaterThan(0);
+  });
+
+  it('generates proper vertical patterns', () => {
+    const vertical = generateVerticalPatterns(config, board);
+
+    expect(vertical.map(({ cells }) => cells.map(String))).toEqual([
+      [EMPTY_CELL, 'd'],
+      [EMPTY_CELL, 'd', EMPTY_CELL],
+      ['d', EMPTY_CELL],
+      ['t', 'o', EMPTY_CELL],
+      [EMPTY_CELL, EMPTY_CELL],
+      [EMPTY_CELL, EMPTY_CELL, EMPTY_CELL],
+      [EMPTY_CELL, EMPTY_CELL],
+    ]);
+  });
+});

package/packages/solver/src/generateVerticalPatterns.ts

@@ -0,0 +1,17 @@
+import { Board, Config, Pattern, VerticalPattern } from '@scrabble-solver/types';
+
+import generatePattern from './generatePattern';
+import generateVectors from './generateVectors';
+
+const generateVerticalPatterns = (config: Config, board: Board): Pattern[] => {
+  const getNthVector = (index: number) => board.getColumn(index);
+  const vectorsCount = config.boardWidth;
+  const verticalVectors = generateVectors({ getNthVector, vectorsCount });
+  const verticalPatterns = verticalVectors.flatMap((cells) => {
+    return generatePattern({ board, config, PatternModel: VerticalPattern, cells });
+  });
+
+  return verticalPatterns;
+};
+
+export default generateVerticalPatterns;

package/packages/solver/src/getCellsScore.ts

@@ -0,0 +1,22 @@
+import { NO_BONUS } from '@scrabble-solver/constants';
+import { Cell, Config } from '@scrabble-solver/types';
+
+const getCellsScore = (config: Config, cells: Cell[]): number => {
+  const total = cells.reduce(
+    ({ multiplier, score }, cell: Cell): { multiplier: number; score: number } => {
+      const bonus = config.getCellBonus(cell);
+      const { characterMultiplier, wordMultiplier } = bonus && bonus.canApply(config, cell) ? bonus.value : NO_BONUS;
+      const characterScore = cell.tile.isBlank ? config.blankScore : config.pointsMap[cell.tile.character];
+
+      return {
+        multiplier: multiplier * wordMultiplier,
+        score: score + characterScore * characterMultiplier,
+      };
+    },
+    { multiplier: 1, score: 0 },
+  );
+
+  return total.score * total.multiplier;
+};
+
+export default getCellsScore;

package/packages/solver/src/getPatternHash.test.ts

@@ -0,0 +1,17 @@
+import { Board, Cell, Pattern, Tile } from '@scrabble-solver/types';
+
+import getPatternHash from './getPatternHash';
+
+describe('getPatternHash', () => {
+  const board = Board.fromStringArray([' t ', 'do ', '   ']);
+
+  it('hashes blanks', () => {
+    const pattern = new Pattern(board, [
+      new Cell({ x: 0, y: 0, tile: new Tile({ character: 'a', isBlank: false }) }),
+      new Cell({ x: 0, y: 1, tile: new Tile({ character: 'b', isBlank: true }) }),
+      new Cell({ x: 0, y: 2, tile: new Tile({ character: 'c', isBlank: false }) }),
+    ]);
+
+    expect(getPatternHash(pattern)).toBe('0,0,a-0,1,b!-0,2,c');
+  });
+});

package/packages/solver/src/getPatternHash.ts

@@ -0,0 +1,14 @@
+import { Pattern } from '@scrabble-solver/types';
+
+const getPatternHash = (pattern: Pattern): string => {
+  return pattern.cells
+    .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;
+    })
+    .join('-');
+};
+
+export default getPatternHash;

package/packages/solver/src/getPatternScore.test.ts

@@ -0,0 +1,60 @@
+import { literaki } from '@scrabble-solver/configs';
+import { Board, Cell, HorizontalPattern, Locale, Pattern, Tile, VerticalPattern } from '@scrabble-solver/types';
+
+import getPatternScore from './getPatternScore';
+
+const config = literaki[Locale.PL_PL];
+const board = Board.fromStringArray([
+  ' kasom         ',
+  '     i         ',
+  '     napiją    ',
+  '  w  i         ',
+  ' krabim        ',
+  '  z            ',
+  '  ę  eh        ',
+  'f s srać       ',
+  'i z t       s  ',
+  'knebel      e  ',
+  'a  ew     warcz',
+  'ł  żyło  wody  ',
+  'o     pecyj chu',
+  '            y  ',
+  '            t  ',
+]);
+
+describe('getPatternScore', () => {
+  it('gives proper score without collisions', () => {
+    const pattern = new Pattern(board, [
+      new Cell({ x: 0, y: 0, tile: new Tile({ character: 'ź' }), isEmpty: true }),
+      new Cell({ x: 1, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+      new Cell({ x: 2, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+      new Cell({ x: 3, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+      new Cell({ x: 4, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+      new Cell({ x: 5, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+      new Cell({ x: 6, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+      new Cell({ x: 7, y: 0, tile: new Tile({ character: 'ź' }), isEmpty: false }),
+    ]);
+
+    expect(getPatternScore(config, pattern)).toBe(128);
+  });
+
+  it('gives proper score with collisions', () => {
+    const pattern = new VerticalPattern(board, [
+      new Cell({ x: 2, y: 11, tile: new Tile({ character: 'l' }), isEmpty: true }),
+      new Cell({ x: 2, y: 12, tile: new Tile({ character: 'i' }), isEmpty: true }),
+      new Cell({ x: 2, y: 13, tile: new Tile({ character: 'n' }), isEmpty: true }),
+      new Cell({ x: 2, y: 14, tile: new Tile({ character: 'o' }), isEmpty: true }),
+    ]);
+
+    expect(getPatternScore(config, pattern)).toBe(44);
+  });
+
+  it('gives proper score for blank', () => {
+    const pattern = new HorizontalPattern(board, [
+      new Cell({ x: 13, y: 14, tile: new Tile({ character: 'o', isBlank: true }), isEmpty: true }),
+      new Cell({ x: 12, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
+    ]);
+
+    expect(getPatternScore(config, pattern)).toBe(2);
+  });
+});

package/packages/solver/src/getPatternScore.ts

@@ -0,0 +1,15 @@
+import { Config, Pattern } from '@scrabble-solver/types';
+
+import getCellsScore from './getCellsScore';
+
+const getPatternScore = (config: Config, pattern: Pattern) => {
+  const areAllTilesUsed = pattern.getEmptyCellsCount() === config.maximumCharactersCount;
+  const bonusScore = areAllTilesUsed ? config.allTilesBonusScore : 0;
+  const score = pattern
+    .getCollisions()
+    .reduce((sum, collision) => sum + getCellsScore(config, collision.cells), getCellsScore(config, pattern.cells));
+
+  return score + bonusScore;
+};
+
+export default getPatternScore;

package/packages/solver/src/getUniquePatterns.ts

@@ -1,15 +1,6 @@
 import { Pattern } from '@scrabble-solver/types';
 
-const getPatternHash = (pattern: Pattern): string => {
-  return pattern.cells
-    .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;
-    })
-    .join('-');
-};
+import getPatternHash from './getPatternHash';
 
 const getUniquePatterns = (patterns: Pattern[]): Pattern[] => {
   const hashes = new Set<string>();

package/packages/solver/src/index.ts

@@ -1 +1 @@
-export { default } from './Solver';
+export { default as solve } from './solve';

package/packages/solver/src/{Solver.test.ts → solve.test.ts}

@@ -1,8 +1,9 @@
+import { Trie } from '@kamilmielnik/trie';
 import { literaki, scrabble } from '@scrabble-solver/configs';
 import { dictionaries } from '@scrabble-solver/dictionaries';
 import { Board, Locale, Result, Tile } from '@scrabble-solver/types';
 
-import Solver from './Solver';
+import solve from './solve';
 
 const generateTiles = (characters: string[]): Tile[] => {
   return characters.map((character) => new Tile({ character, isBlank: false }));
@@ -15,14 +16,14 @@ const getBestResult = ([firstResult, ...results]: Result[]): Result => {
   );
 };
 
-describe('Solver - PL', () => {
+describe('solve - PL', () => {
   const locale = Locale.PL_PL;
   const config = literaki[locale];
-  let solver: Solver | undefined;
+  let trie: Trie | undefined;
 
   beforeAll(() => {
-    return dictionaries.get(locale).then((trie) => {
-      solver = new Solver(config, trie);
+    return dictionaries.get(locale).then((loadedTrie) => {
+      trie = loadedTrie;
     });
   });
 
@@ -45,7 +46,7 @@ describe('Solver - PL', () => {
       '               ',
     ]);
     const tiles = generateTiles(['l', 'i', 'n', 'o']);
-    const results = solver!.solve(board, tiles);
+    const results = solve(trie!, config, board, tiles);
     expect(results.length).toBe(61);
   });
 
@@ -68,7 +69,7 @@ describe('Solver - PL', () => {
       '               ',
     ]);
     const tiles = generateTiles(['a', 'a', 'ą', 'r', 't', 'w', 'z']);
-    const results = solver!.solve(board, tiles);
+    const results = solve(trie!, config, board, tiles);
     const bestResult = getBestResult(results);
     expect(bestResult.word).toBe('zmartwychwstałą');
     expect(bestResult.points).toBe(682);
@@ -93,21 +94,21 @@ describe('Solver - PL', () => {
       'ar  ń    m     ',
     ]);
     const tiles = generateTiles(['ą', 'c', 'h', 't', 'w', 'w', 'z']);
-    const results = solver!.solve(board, tiles);
+    const results = solve(trie!, config, board, tiles);
     const bestResult = getBestResult(results);
     expect(bestResult.word).toBe('zmartwychwstałą');
     expect(bestResult.points).toBe(1157);
   });
 });
 
-describe('Solver - ES', () => {
+describe('solve - ES', () => {
   const locale = Locale.ES_ES;
   const config = scrabble[locale];
-  let solver: Solver | undefined;
+  let trie: Trie | undefined;
 
   beforeAll(() => {
-    return dictionaries.get(locale).then((trie) => {
-      solver = new Solver(config, trie);
+    return dictionaries.get(locale).then((loadedTrie) => {
+      trie = loadedTrie;
     });
   });
 
@@ -130,7 +131,7 @@ describe('Solver - ES', () => {
       '               ',
     ]);
     const tiles = generateTiles(['ll', 'a', 'n', 'a']);
-    const results = solver!.solve(board, tiles);
+    const results = solve(trie!, config, board, tiles);
     const bestResult = getBestResult(results);
     expect(results.length).toBe(24);
     expect(bestResult.points).toBe(22);