@scrabble-solver/solver 2.8.8 → 2.8.10

package/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/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/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/src/generateStartIndices.test.ts

@@ -0,0 +1,19 @@
+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('returns empty array when no cells given', () => {
+    const cells: Cell[] = [];
+    expect(generateStartIndices(cells).length).toBe(0);
+  });
+
+  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/src/generateStartIndices.ts

@@ -0,0 +1,19 @@
+import { Cell } from '@scrabble-solver/types';
+
+const generateStartIndices = (cells: Cell[]): number[] => {
+  if (cells.length === 0) {
+    return [];
+  }
+
+  const startIndices: number[] = [0];
+
+  for (let startIndex = 1; startIndex < cells.length - 1; ++startIndex) {
+    if (!cells[startIndex - 1].hasTile()) {
+      startIndices.push(startIndex);
+    }
+  }
+
+  return startIndices;
+};
+
+export default generateStartIndices;

package/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/src/generateVectors.ts

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

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

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

package/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,8 +69,8 @@ describe('Solver - PL', () => {
       '               ',
     ]);
     const tiles = generateTiles(['a', 'a', 'ą', 'r', 't', 'w', 'z']);
-    const results = solver!.solve(board, tiles);
-    const bestResult = getBestResult(results);
+    const results = solve(trie!, config, board, tiles);
+    const bestResult = getBestResult(results.map((result) => Result.fromJson(result)));
     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 bestResult = getBestResult(results);
+    const results = solve(trie!, config, board, tiles);
+    const bestResult = getBestResult(results.map((result) => Result.fromJson(result)));
     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,8 +131,8 @@ describe('Solver - ES', () => {
       '               ',
     ]);
     const tiles = generateTiles(['ll', 'a', 'n', 'a']);
-    const results = solver!.solve(board, tiles);
-    const bestResult = getBestResult(results);
+    const results = solve(trie!, config, board, tiles);
+    const bestResult = getBestResult(results.map((result) => Result.fromJson(result)));
     expect(results.length).toBe(24);
     expect(bestResult.points).toBe(22);
   });

package/src/solve.ts

@@ -0,0 +1,23 @@
+import { Trie } from '@kamilmielnik/trie';
+import { Board, Config, ResultJson, Tile } from '@scrabble-solver/types';
+
+import fillPattern from './fillPattern';
+import generatePatterns from './generatePatterns';
+import getPatternScore from './getPatternScore';
+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 results = uniquePatterns.map((pattern, index) => ({
+    cells: pattern.cells.map((cell) => cell.toJson()),
+    collisions: pattern.getCollisions().map((collision) => collision.cells.map((cell) => cell.toJson())),
+    id: index,
+    points: getPatternScore(config, pattern),
+  }));
+
+  return results;
+};
+
+export default solve;

package/build/PatternsFiller.d.ts

@@ -1,12 +0,0 @@
-import { Trie } from '@kamilmielnik/trie';
-import { Config, Pattern, Tile } from '@scrabble-solver/types';
-declare class PatternsFiller {
-    private readonly trie;
-    private readonly config;
-    constructor(config: Config, trie: Trie);
-    fill(pattern: Pattern, tiles: Tile[]): Pattern[];
-    fillPattern(pattern: Pattern, word: string, tiles: Tile[], onPatternFound: (newPattern: Pattern) => void): void;
-    canAddPattern(pattern: Pattern, word: string): boolean;
-    generateBlankTilesPermutations(tiles: Tile[]): Tile[][];
-}
-export default PatternsFiller;

package/build/PatternsFiller.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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;
-    }
-    fill(pattern, tiles) {
-        const patterns = [];
-        if (pattern.getEmptyCellsCount() > tiles.length) {
-            return [];
-        }
-        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;
-    }
-    fillPattern(pattern, word, tiles, onPatternFound) {
-        const indexOfFirstCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
-        if (indexOfFirstCellWithoutTile === -1) {
-            if (this.canAddPattern(pattern, word)) {
-                onPatternFound(pattern.clone());
-            }
-        }
-        else {
-            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(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)) {
-                    tiles.splice(index, 1);
-                    this.fillPattern(pattern, newWord, tiles, onPatternFound);
-                    tiles.splice(index, 0, tile);
-                }
-                pattern.cells[indexOfFirstCellWithoutTile].tile = previousTile;
-            }
-        }
-    }
-    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];
-        }
-        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));
-        }, []);
-    }
-}
-exports.default = PatternsFiller;

package/build/PatternsGenerator.d.ts

@@ -1,32 +0,0 @@
-import { Board, Cell, Config, HorizontalPattern, Pattern, VerticalPattern } from '@scrabble-solver/types';
-declare class PatternsGenerator {
-    private readonly config;
-    constructor(config: Config);
-    generate(board: Board): Pattern[];
-    generateHorizontal(board: Board): HorizontalPattern[];
-    generateVertical(board: Board): VerticalPattern[];
-    generatePatterns<P extends Pattern>({ board, getNthVector, vectorsCount, PatternModel, }: {
-        board: Board;
-        getNthVector: (index: number) => Cell[];
-        PatternModel: new (parameters: {
-            board: Board;
-            cells: Cell[];
-        }) => P;
-        vectorsCount: number;
-    }): P[];
-    generateVectors({ getNthVector, vectorsCount, }: {
-        getNthVector: (index: number) => Cell[];
-        vectorsCount: number;
-    }): Cell[][];
-    generateCellsPatterns<P extends Pattern>({ board, cells, PatternModel, }: {
-        board: Board;
-        cells: Cell[];
-        PatternModel: new (parameters: {
-            board: Board;
-            cells: Cell[];
-        }) => P;
-    }): P[];
-    generateStartIndices(cells: Cell[]): number[];
-    generateEndIndices(cells: Cell[], startIndex: number): number[];
-}
-export default PatternsGenerator;

package/build/PatternsGenerator.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("@scrabble-solver/types");
-class PatternsGenerator {
-    constructor(config) {
-        this.config = config;
-    }
-    generate(board) {
-        return [...this.generateHorizontal(board), ...this.generateVertical(board)];
-    }
-    generateHorizontal(board) {
-        return this.generatePatterns({
-            board,
-            getNthVector: (index) => board.getRow(index),
-            PatternModel: types_1.HorizontalPattern,
-            vectorsCount: this.config.boardHeight,
-        });
-    }
-    generateVertical(board) {
-        return this.generatePatterns({
-            board,
-            getNthVector: (index) => board.getColumn(index),
-            PatternModel: types_1.VerticalPattern,
-            vectorsCount: this.config.boardWidth,
-        });
-    }
-    generatePatterns({ board, getNthVector, vectorsCount, PatternModel, }) {
-        return this.generateVectors({ getNthVector, vectorsCount }).reduce((patterns, cells) => {
-            return patterns.concat(this.generateCellsPatterns({ board, PatternModel, cells }));
-        }, []);
-    }
-    generateVectors({ getNthVector, vectorsCount, }) {
-        return Array(vectorsCount)
-            .fill(0)
-            .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)) {
-                    patterns.push(pattern);
-                }
-            }
-            return patterns;
-        });
-    }
-    generateStartIndices(cells) {
-        return Array(cells.length - 1)
-            .fill(0)
-            .map((_, startIndex) => startIndex)
-            .filter((startIndex) => startIndex === 0 || !cells[startIndex - 1].hasTile());
-    }
-    generateEndIndices(cells, startIndex) {
-        return Array(cells.length - startIndex - 1)
-            .fill(0)
-            .map((_, endIndex) => endIndex + startIndex + 1)
-            .filter((endIndex) => endIndex >= cells.length - 1 || !cells[endIndex + 1].hasTile());
-    }
-}
-exports.default = PatternsGenerator;

package/build/ScoresCalculator.d.ts

@@ -1,17 +0,0 @@
-import { Cell, Config, Pattern } from '@scrabble-solver/types';
-declare class ScoresCalculator {
-    private readonly config;
-    constructor(config: Config);
-    calculate(pattern: Pattern): number;
-    calculateBonusScore(pattern: Pattern): number;
-    calculatePatternScoreWithCollisions(pattern: Pattern): number;
-    calculatePatternScore(pattern: Pattern): number;
-    reduceCellScore: ({ multiplier, score }: {
-        multiplier: number;
-        score: number;
-    }, cell: Cell) => {
-        multiplier: number;
-        score: number;
-    };
-}
-export default ScoresCalculator;