scrabble-solver 2.8.7 → 2.8.9

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);

package/packages/solver/src/solve.ts

@@ -0,0 +1,25 @@
+import { Trie } from '@kamilmielnik/trie';
+import { Board, Config, Result, 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[]): Result[] => {
+  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) =>
+      new Result({
+        cells: pattern.cells,
+        collisions: pattern.getCollisions().map((collision) => collision.cells),
+        id: index,
+        points: getPatternScore(config, pattern),
+      }),
+  );
+  return results;
+};
+
+export default solve;

package/packages/types/build/Board.d.ts

@@ -22,6 +22,7 @@ declare class Board {
     getColumn(index: number): Cell[];
     getRow(index: number): Cell[];
     getTilesCount(): number;
+    getWords(): string[];
     isEmpty(): boolean;
     toJson(): BoardJson;
     toString(): string;

package/packages/types/build/Board.js

@@ -79,6 +79,22 @@ class Board {
             return count + row.reduce((rowCount, cell) => (cell.hasTile() ? rowCount + 1 : rowCount), 0);
         }, 0);
     }
+    getWords() {
+        const columns = [];
+        for (let x = 0; x < this.columnsCount; ++x) {
+            const column = [];
+            for (let y = 0; y < this.rowsCount; ++y) {
+                column.push(this.rows[y][x]);
+            }
+            columns.push(column);
+        }
+        const columnsBoard = new Board({ rows: columns });
+        const lines = this.toString().split('\n').concat(columnsBoard.toString().split('\n'));
+        const words = lines
+            .flatMap((line) => line.replaceAll(/\s+/g, constants_1.EMPTY_CELL).split(' '))
+            .filter((word) => word.length > 1);
+        return words;
+    }
     isEmpty() {
         return this.rows.every((row) => row.every(({ isEmpty }) => isEmpty));
     }
@@ -86,7 +102,7 @@ class Board {
         return this.rows.map((row) => row.map((cell) => cell.toJson()));
     }
     toString() {
-        return this.rows.map((row) => row.map(String)).join('\n');
+        return this.rows.map((row) => row.map(String).join('')).join('\n');
     }
     updateCell(x, y, updateCell) {
         this.rows[y][x] = updateCell(this.rows[y][x]);

package/packages/types/build/Config.js

@@ -64,7 +64,7 @@ class Config {
         return tile.isBlank ? this.blankScore : this.getCharacterPoints(tile.character);
     }
     hasCharacter(character) {
-        return this.alphabet.includes(character);
+        return character in this.pointsMap;
     }
     isTwoCharacterTilePrefix(character) {
         return typeof this.getTwoCharacterTileByPrefix(character) !== 'undefined';

package/packages/types/build/FinalPattern.d.ts

@@ -0,0 +1,7 @@
+import Pattern from './Pattern';
+declare class FinalPattern extends Pattern {
+    private readonly collisions;
+    constructor(pattern: Pattern);
+    getCollisions(): Pattern[];
+}
+export default FinalPattern;

package/packages/types/build/FinalPattern.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Pattern_1 = __importDefault(require("./Pattern"));
+class FinalPattern extends Pattern_1.default {
+    constructor(pattern) {
+        super(pattern.board, pattern.cells);
+        this.collisions = pattern.getCollisions();
+    }
+    getCollisions() {
+        return this.collisions;
+    }
+}
+exports.default = FinalPattern;

package/packages/types/build/HorizontalPattern.js

@@ -6,10 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Pattern_1 = __importDefault(require("./Pattern"));
 class HorizontalPattern extends Pattern_1.default {
     clone() {
-        return new HorizontalPattern({
-            board: this.board,
-            cells: this.cells.map((cell) => cell.clone()),
-        });
+        return new HorizontalPattern(this.board, this.cells.map((cell) => cell.clone()));
     }
     getCollisions() {
         const collisions = [];
@@ -29,7 +26,7 @@ class HorizontalPattern extends Pattern_1.default {
             const nextCells = column.slice(cell.y + 1, y);
             const cells = [...previousCells, cell, ...nextCells];
             if (cells.length > 1) {
-                const pattern = new Pattern_1.default({ board: this.board, cells });
+                const pattern = new Pattern_1.default(this.board, cells);
                 collisions.push(pattern);
             }
         });

package/packages/types/build/Pattern.d.ts

@@ -5,10 +5,7 @@ import PatternJson from './PatternJson';
 declare class Pattern {
     readonly board: Board;
     readonly cells: Cell[];
-    constructor({ board, cells }: {
-        board: Board;
-        cells: Cell[];
-    });
+    constructor(board: Board, cells: Cell[]);
     canBePlaced(config: Config): boolean;
     clone(): Pattern;
     collides(): boolean;

package/packages/types/build/Pattern.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class Pattern {
-    constructor({ board, cells }) {
+    constructor(board, cells) {
         this.board = board;
         this.cells = cells;
     }
@@ -12,10 +12,7 @@ class Pattern {
             (this.hasAtLeast1NonEmptyCell() || this.collides() || (this.goesThroughBoardCenter() && this.board.isEmpty())));
     }
     clone() {
-        return new Pattern({
-            board: this.board,
-            cells: this.cells.map((cell) => cell.clone()),
-        });
+        return new Pattern(this.board, this.cells.map((cell) => cell.clone()));
     }
     collides() {
         return this.cells.some((cell) => cell.isEmpty && this.board.collides(cell));

package/packages/types/build/Result.js

@@ -50,11 +50,9 @@ const getNonBlanks = (tiles) => tiles.filter(({ isBlank }) => !isBlank);
 const getPointsRatio = (tiles, points) => points / tiles.length;
 const getTiles = (cells) => cells.filter(({ isEmpty }) => isEmpty).map(({ tile }) => tile);
 const getTilesCharacters = (tiles) => getNonBlankCharacters(tiles).sort(charactersComparator).join('');
-const getWord = (cells) => cells.map(String).join('');
-const getWords = (cells, collisions) => [
-    getWord(cells),
-    ...collisions.map((collision) => collision.map(String).join('')),
-];
+// eslint-disable-next-line prefer-template
+const getWord = (cells) => cells.reduce((word, cell) => word + cell.toString(), '');
+const getWords = (cells, collisions) => [cells, ...collisions].map(getWord);
 const isConsonant = ({ character, isBlank }) => constants_1.CONSONANTS.includes(character) && !isBlank;
 const isVowel = ({ character, isBlank }) => constants_1.VOWELS.includes(character) && !isBlank;
 exports.default = Result;

package/packages/types/build/Tile.d.ts

@@ -2,8 +2,8 @@ import TileJson from './TileJson';
 declare class Tile {
     static fromJson(json: TileJson | null): Tile;
     static readonly Null: Tile;
-    readonly character: string;
-    readonly isBlank: boolean;
+    character: string;
+    isBlank: boolean;
     constructor({ character, isBlank }: {
         character: string;
         isBlank?: boolean;

package/packages/types/build/VerticalPattern.js

@@ -6,10 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Pattern_1 = __importDefault(require("./Pattern"));
 class VerticalPattern extends Pattern_1.default {
     clone() {
-        return new VerticalPattern({
-            board: this.board,
-            cells: this.cells.map((cell) => cell.clone()),
-        });
+        return new VerticalPattern(this.board, this.cells.map((cell) => cell.clone()));
     }
     getCollisions() {
         const collisions = [];
@@ -29,7 +26,7 @@ class VerticalPattern extends Pattern_1.default {
             const nextCells = row.slice(cell.x + 1, x);
             const cells = [...previousCells, cell, ...nextCells];
             if (cells.length > 1) {
-                const pattern = new Pattern_1.default({ board: this.board, cells });
+                const pattern = new Pattern_1.default(this.board, cells);
                 collisions.push(pattern);
             }
         });

package/packages/types/build/index.d.ts

@@ -10,6 +10,7 @@ export { default as Collision } from './Collision';
 export { default as CollisionJson } from './CollisionJson';
 export { default as Config } from './Config';
 export { default as ConfigJson } from './ConfigJson';
+export { default as FinalPattern } from './FinalPattern';
 export { default as HorizontalPattern } from './HorizontalPattern';
 export { default as isObject } from './isObject';
 export { default as Locale, isLocale } from './Locale';

package/packages/types/build/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WordDefinition = exports.WordBonus = exports.VerticalPattern = exports.isTileJson = exports.Tile = exports.Result = exports.Pattern = exports.isLocale = exports.Locale = exports.isObject = exports.HorizontalPattern = exports.Config = exports.CharacterBonus = exports.isCellJson = exports.Cell = exports.Bonus = exports.isBoardJson = exports.Board = void 0;
+exports.WordDefinition = exports.WordBonus = exports.VerticalPattern = exports.isTileJson = exports.Tile = exports.Result = exports.Pattern = exports.isLocale = exports.Locale = exports.isObject = exports.HorizontalPattern = exports.FinalPattern = exports.Config = exports.CharacterBonus = exports.isCellJson = exports.Cell = exports.Bonus = exports.isBoardJson = exports.Board = void 0;
 var Board_1 = require("./Board");
 Object.defineProperty(exports, "Board", { enumerable: true, get: function () { return __importDefault(Board_1).default; } });
 var BoardJson_1 = require("./BoardJson");
@@ -18,6 +18,8 @@ var CharacterBonus_1 = require("./CharacterBonus");
 Object.defineProperty(exports, "CharacterBonus", { enumerable: true, get: function () { return __importDefault(CharacterBonus_1).default; } });
 var Config_1 = require("./Config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return __importDefault(Config_1).default; } });
+var FinalPattern_1 = require("./FinalPattern");
+Object.defineProperty(exports, "FinalPattern", { enumerable: true, get: function () { return __importDefault(FinalPattern_1).default; } });
 var HorizontalPattern_1 = require("./HorizontalPattern");
 Object.defineProperty(exports, "HorizontalPattern", { enumerable: true, get: function () { return __importDefault(HorizontalPattern_1).default; } });
 var isObject_1 = require("./isObject");

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/types",
-  "version": "2.8.7",
+  "version": "2.8.9",
   "description": "Scrabble Solver 2 - Types",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -24,7 +24,7 @@
     "clean:force": "npm run clean && rimraf package-lock.json"
   },
   "dependencies": {
-    "@scrabble-solver/constants": "^2.8.7"
+    "@scrabble-solver/constants": "^2.8.9"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }