@scrabble-solver/solver 2.8.8 → 2.8.9

package/build/fillPattern.d.ts

@@ -0,0 +1,5 @@
+import { Trie } from '@kamilmielnik/trie';
+import { Config, Pattern, Tile } from '@scrabble-solver/types';
+declare const fillPattern: (trie: Trie, config: Config, pattern: Pattern, tiles: Tile[]) => Pattern[];
+export declare const fillPatternRecursive: (results: Pattern[], trie: Trie, config: Config, pattern: Pattern, word: string, tiles: Tile[]) => void;
+export default fillPattern;

package/build/fillPattern.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fillPatternRecursive = void 0;
+const constants_1 = require("@scrabble-solver/constants");
+const types_1 = require("@scrabble-solver/types");
+const fillPattern = (trie, config, pattern, tiles) => {
+    if (pattern.getEmptyCellsCount() > tiles.length) {
+        return [];
+    }
+    const results = [];
+    (0, exports.fillPatternRecursive)(results, trie, config, pattern, pattern.toString(), tiles);
+    return results;
+};
+const fillPatternRecursive = (
+/** gets mutated when this function is called */
+results, trie, config, pattern, word, tiles) => {
+    const indexOfFirstCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
+    if (indexOfFirstCellWithoutTile === -1) {
+        if (trie.has(word) && pattern.getCollisions().every((collision) => trie.has(collision.toString()))) {
+            results.push(new types_1.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(constants_1.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 types_1.FinalPattern(pattern.clone()));
+                }
+            }
+            else if (trie.hasPrefix(newWordPrefix)) {
+                tiles.splice(index, 1);
+                (0, exports.fillPatternRecursive)(results, trie, config, pattern, newWord, tiles);
+                tiles.splice(index, 0, tile);
+            }
+        }
+        pattern.cells[indexOfFirstCellWithoutTile].tile = previousTile;
+    }
+};
+exports.fillPatternRecursive = fillPatternRecursive;
+exports.default = fillPattern;

package/build/generateEndIndices.d.ts

@@ -0,0 +1,3 @@
+import { Cell } from '@scrabble-solver/types';
+declare const generateEndIndices: (cells: Cell[], startIndex: number) => number[];
+export default generateEndIndices;

package/build/generateEndIndices.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const 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 = generateEndIndices;

package/build/generateHorizontalPatterns.d.ts

@@ -0,0 +1,3 @@
+import { Board, Config, Pattern } from '@scrabble-solver/types';
+declare const generateHorizontalPatterns: (config: Config, board: Board) => Pattern[];
+export default generateHorizontalPatterns;

package/build/generateHorizontalPatterns.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@scrabble-solver/types");
+const generatePattern_1 = __importDefault(require("./generatePattern"));
+const generateVectors_1 = __importDefault(require("./generateVectors"));
+const generateHorizontalPatterns = (config, board) => {
+    const getNthVector = (index) => board.getRow(index);
+    const vectorsCount = config.boardHeight;
+    const horizontalVectors = (0, generateVectors_1.default)({ getNthVector, vectorsCount });
+    const horizontalPatterns = horizontalVectors.flatMap((cells) => {
+        return (0, generatePattern_1.default)({ board, config, PatternModel: types_1.HorizontalPattern, cells });
+    });
+    return horizontalPatterns;
+};
+exports.default = generateHorizontalPatterns;

package/build/generatePattern.d.ts

@@ -0,0 +1,8 @@
+import { Board, Cell, Config, Pattern } from '@scrabble-solver/types';
+declare const generatePattern: <P extends Pattern>({ board, cells, config, PatternModel, }: {
+    board: Board;
+    cells: Cell[];
+    config: Config;
+    PatternModel: new (board: Board, cells: Cell[]) => P;
+}) => P[];
+export default generatePattern;

package/build/generatePattern.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateEndIndices_1 = __importDefault(require("./generateEndIndices"));
+const generateStartIndices_1 = __importDefault(require("./generateStartIndices"));
+const generatePattern = ({ board, cells, config, PatternModel, }) => {
+    const startIndices = (0, generateStartIndices_1.default)(cells);
+    return startIndices.flatMap((startIndex) => {
+        const endIndices = (0, generateEndIndices_1.default)(cells, startIndex);
+        const patterns = [];
+        for (const endIndex of endIndices) {
+            const pattern = new PatternModel(board, cells.slice(startIndex, endIndex + 1));
+            if (pattern.canBePlaced(config)) {
+                patterns.push(pattern);
+            }
+        }
+        return patterns;
+    });
+};
+exports.default = generatePattern;

package/build/generatePatterns.d.ts

@@ -0,0 +1,3 @@
+import { Board, Config, Pattern } from '@scrabble-solver/types';
+declare const generatePatterns: (config: Config, board: Board) => Pattern[];
+export default generatePatterns;

package/build/generatePatterns.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateHorizontalPatterns_1 = __importDefault(require("./generateHorizontalPatterns"));
+const generateVerticalPatterns_1 = __importDefault(require("./generateVerticalPatterns"));
+const generatePatterns = (config, board) => {
+    const horizontalPatterns = (0, generateHorizontalPatterns_1.default)(config, board);
+    const verticalPatterns = (0, generateVerticalPatterns_1.default)(config, board);
+    return horizontalPatterns.concat(verticalPatterns);
+};
+exports.default = generatePatterns;

package/build/generateStartIndices.d.ts

@@ -0,0 +1,3 @@
+import { Cell } from '@scrabble-solver/types';
+declare const generateStartIndices: (cells: Cell[]) => number[];
+export default generateStartIndices;

package/build/generateStartIndices.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateStartIndices = (cells) => {
+    return Array(cells.length - 1)
+        .fill(0)
+        .map((_, startIndex) => startIndex)
+        .filter((startIndex) => startIndex === 0 || !cells[startIndex - 1].hasTile());
+};
+exports.default = generateStartIndices;

package/build/generateVectors.d.ts

@@ -0,0 +1,6 @@
+import { Cell } from '@scrabble-solver/types';
+declare const generateVectors: ({ getNthVector, vectorsCount, }: {
+    getNthVector: (index: number) => Cell[];
+    vectorsCount: number;
+}) => Cell[][];
+export default generateVectors;

package/build/generateVectors.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateVectors = ({ getNthVector, vectorsCount, }) => {
+    return Array(vectorsCount)
+        .fill(0)
+        .map((_, index) => getNthVector(index));
+};
+exports.default = generateVectors;

package/build/generateVerticalPatterns.d.ts

@@ -0,0 +1,3 @@
+import { Board, Config, Pattern } from '@scrabble-solver/types';
+declare const generateVerticalPatterns: (config: Config, board: Board) => Pattern[];
+export default generateVerticalPatterns;

package/build/generateVerticalPatterns.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@scrabble-solver/types");
+const generatePattern_1 = __importDefault(require("./generatePattern"));
+const generateVectors_1 = __importDefault(require("./generateVectors"));
+const generateVerticalPatterns = (config, board) => {
+    const getNthVector = (index) => board.getColumn(index);
+    const vectorsCount = config.boardWidth;
+    const verticalVectors = (0, generateVectors_1.default)({ getNthVector, vectorsCount });
+    const verticalPatterns = verticalVectors.flatMap((cells) => {
+        return (0, generatePattern_1.default)({ board, config, PatternModel: types_1.VerticalPattern, cells });
+    });
+    return verticalPatterns;
+};
+exports.default = generateVerticalPatterns;

package/build/getCellsScore.d.ts

@@ -0,0 +1,3 @@
+import { Cell, Config } from '@scrabble-solver/types';
+declare const getCellsScore: (config: Config, cells: Cell[]) => number;
+export default getCellsScore;

package/build/getCellsScore.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("@scrabble-solver/constants");
+const getCellsScore = (config, cells) => {
+    const total = cells.reduce(({ multiplier, score }, cell) => {
+        const bonus = config.getCellBonus(cell);
+        const { characterMultiplier, wordMultiplier } = bonus && bonus.canApply(config, cell) ? bonus.value : constants_1.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;
+};
+exports.default = getCellsScore;

package/build/getPatternHash.d.ts

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

package/build/getPatternHash.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getPatternHash = (pattern) => {
+    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('-');
+};
+exports.default = getPatternHash;

package/build/getPatternScore.d.ts

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

package/build/getPatternScore.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getCellsScore_1 = __importDefault(require("./getCellsScore"));
+const getPatternScore = (config, pattern) => {
+    const areAllTilesUsed = pattern.getEmptyCellsCount() === config.maximumCharactersCount;
+    const bonusScore = areAllTilesUsed ? config.allTilesBonusScore : 0;
+    const score = pattern
+        .getCollisions()
+        .reduce((sum, collision) => sum + (0, getCellsScore_1.default)(config, collision.cells), (0, getCellsScore_1.default)(config, pattern.cells));
+    return score + bonusScore;
+};
+exports.default = getPatternScore;

package/build/getUniquePatterns.js

@@ -1,20 +1,14 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const getPatternHash = (pattern) => {
-    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('-');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+const getPatternHash_1 = __importDefault(require("./getPatternHash"));
 const getUniquePatterns = (patterns) => {
     const hashes = new Set();
     const uniquePatterns = [];
     for (const pattern of patterns) {
-        const hash = getPatternHash(pattern);
+        const hash = (0, getPatternHash_1.default)(pattern);
         if (!hashes.has(hash)) {
             hashes.add(hash);
             uniquePatterns.push(pattern);

package/build/index.d.ts

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

package/build/index.js

@@ -3,6 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
-var Solver_1 = require("./Solver");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(Solver_1).default; } });
+exports.solve = void 0;
+var solve_1 = require("./solve");
+Object.defineProperty(exports, "solve", { enumerable: true, get: function () { return __importDefault(solve_1).default; } });

package/build/solve.d.ts

@@ -0,0 +1,4 @@
+import { Trie } from '@kamilmielnik/trie';
+import { Board, Config, Result, Tile } from '@scrabble-solver/types';
+declare const solve: (trie: Trie, config: Config, board: Board, tiles: Tile[]) => Result[];
+export default solve;

package/build/solve.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@scrabble-solver/types");
+const fillPattern_1 = __importDefault(require("./fillPattern"));
+const generatePatterns_1 = __importDefault(require("./generatePatterns"));
+const getPatternScore_1 = __importDefault(require("./getPatternScore"));
+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 results = uniquePatterns.map((pattern, index) => new types_1.Result({
+        cells: pattern.cells,
+        collisions: pattern.getCollisions().map((collision) => collision.cells),
+        id: index,
+        points: (0, getPatternScore_1.default)(config, pattern),
+    }));
+    return results;
+};
+exports.default = solve;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.8",
+  "version": "2.8.9",
   "description": "Scrabble Solver 2 - Solver",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -25,12 +25,12 @@
   },
   "dependencies": {
     "@kamilmielnik/trie": "^2.0.0",
-    "@scrabble-solver/types": "^2.8.8"
+    "@scrabble-solver/types": "^2.8.9"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.8.8",
-    "@scrabble-solver/constants": "^2.8.8",
-    "@scrabble-solver/dictionaries": "^2.8.8"
+    "@scrabble-solver/configs": "^2.8.9",
+    "@scrabble-solver/constants": "^2.8.9",
+    "@scrabble-solver/dictionaries": "^2.8.9"
   },
-  "gitHead": "e6ced6e98204e49ba69750242643bda52a453635"
+  "gitHead": "8557cc2c5214e6689a5c59373b228b28f5dd8ed4"
 }

package/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/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/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/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/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/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;