scrabble-solver 2.16.6 → 2.17.0

package/packages/solver/build/getPatternHash.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPatternHash = void 0;
-const getPatternHash = (pattern) => {
-    return pattern.cells
-        .filter((cell) => cell.isEmpty)
-        .map((cell) => {
-        const blank = cell.tile.isBlank ? '!' : '';
-        const tile = cell.tile.character + blank;
-        return [cell.x, cell.y, tile].join(',');
-    })
-        .join('-');
-};
-exports.getPatternHash = getPatternHash;

package/packages/solver/build/getPatternScore.d.ts

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

package/packages/solver/build/getPatternScore.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPatternScore = void 0;
-const types_1 = require("@scrabble-solver/types");
-const getCellsScore_1 = require("./getCellsScore");
-const getPatternScore = (config, pattern) => {
-    const areAllTilesUsed = pattern.getEmptyCellsCount() === config.rackSize;
-    const baseScore = (0, getCellsScore_1.getCellsScore)(config, pattern.cells);
-    const collisionsScore = pattern
-        .getCollisions()
-        .reduce((sum, collision) => sum + (0, getCellsScore_1.getCellsScore)(config, collision.cells), 0);
-    if (areAllTilesUsed) {
-        if ((0, types_1.isScoreBingo)(config.bingo)) {
-            return baseScore + collisionsScore + config.bingo.score;
-        }
-        if ((0, types_1.isMultiplierBingo)(config.bingo)) {
-            return baseScore * config.bingo.multiplier + collisionsScore;
-        }
-    }
-    return baseScore + collisionsScore;
-};
-exports.getPatternScore = getPatternScore;

package/packages/solver/build/getUniquePatterns.d.ts

@@ -1,2 +0,0 @@
-import { type Pattern } from '@scrabble-solver/types';
-export declare const getUniquePatterns: (patterns: Pattern[]) => Pattern[];

package/packages/solver/build/getUniquePatterns.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUniquePatterns = void 0;
-const getPatternHash_1 = require("./getPatternHash");
-const getUniquePatterns = (patterns) => {
-    const hashes = new Set();
-    const uniquePatterns = [];
-    for (const pattern of patterns) {
-        const hash = (0, getPatternHash_1.getPatternHash)(pattern);
-        if (!hashes.has(hash)) {
-            hashes.add(hash);
-            uniquePatterns.push(pattern);
-        }
-    }
-    return uniquePatterns;
-};
-exports.getUniquePatterns = getUniquePatterns;

package/packages/solver/src/areDigraphsValid.ts

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

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

@@ -1,107 +0,0 @@
-import { type Trie } from '@kamilmielnik/trie';
-import { getConfig } from '@scrabble-solver/configs';
-import { dictionaries } from '@scrabble-solver/dictionaries';
-import { Board, Cell, FinalPattern, Game, Locale, type 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 = getConfig(Game.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

@@ -1,68 +0,0 @@
-/* eslint-disable max-params, max-statements */
-import { type Trie } from '@kamilmielnik/trie';
-import { EMPTY_CELL } from '@scrabble-solver/constants';
-import { type Config, FinalPattern, type Pattern, type Tile } from '@scrabble-solver/types';
-
-export 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;
-  }
-};

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

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

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

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

@@ -1,31 +0,0 @@
-import { EMPTY_CELL } from '@scrabble-solver/constants';
-import { Board, type Config } from '@scrabble-solver/types';
-
-import { generateHorizontalPatterns } from './generateHorizontalPatterns';
-
-const board = Board.fromStringArray([' t ', 'do ', '   ']);
-
-const config = {
-  boardHeight: 3,
-  boardWidth: 3,
-  rackSize: 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

@@ -1,15 +0,0 @@
-import { type Board, type Config, HorizontalPattern, type Pattern } from '@scrabble-solver/types';
-
-import { generatePattern } from './generatePattern';
-import { generateVectors } from './generateVectors';
-
-export 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;
-};

package/packages/solver/src/generatePattern.ts

@@ -1,33 +0,0 @@
-import { type Board, type Cell, type Config, type Pattern } from '@scrabble-solver/types';
-
-import { generateEndIndices } from './generateEndIndices';
-import { generateStartIndices } from './generateStartIndices';
-
-export 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;
-  });
-};

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

@@ -1,13 +0,0 @@
-import { getConfig } from '@scrabble-solver/configs';
-import { Board, Game, Locale } from '@scrabble-solver/types';
-
-import { generatePatterns } from './generatePatterns';
-
-describe('generatePatterns', () => {
-  it('Generates all patterns for an empty board', () => {
-    const config = getConfig(Game.Scrabble, Locale.EN_US);
-    const board = Board.create(config.boardWidth, config.boardHeight);
-
-    expect(generatePatterns(config, board).length).toEqual(54);
-  });
-});

package/packages/solver/src/generatePatterns.ts

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

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

@@ -1,19 +0,0 @@
-import { type 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/packages/solver/src/generateStartIndices.ts

@@ -1,17 +0,0 @@
-import { type Cell } from '@scrabble-solver/types';
-
-export 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;
-};

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

@@ -1,12 +0,0 @@
-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

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

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

@@ -1,32 +0,0 @@
-import { EMPTY_CELL } from '@scrabble-solver/constants';
-import { Board, type Config } from '@scrabble-solver/types';
-
-import { generateVerticalPatterns } from './generateVerticalPatterns';
-
-const board = Board.fromStringArray([' t ', 'do ', '   ']);
-
-const config = {
-  boardHeight: 3,
-  boardWidth: 3,
-  rackSize: 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

@@ -1,15 +0,0 @@
-import { type Board, type Config, type Pattern, VerticalPattern } from '@scrabble-solver/types';
-
-import { generatePattern } from './generatePattern';
-import { generateVectors } from './generateVectors';
-
-export 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;
-};

package/packages/solver/src/getCellsScore.ts

@@ -1,21 +0,0 @@
-import { NO_BONUS } from '@scrabble-solver/constants';
-import { type Cell, type Config } from '@scrabble-solver/types';
-
-export 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 = config.pointsMap[cell.tile.character] || 0;
-      const tileScore = cell.tile.isBlank ? config.blankScore : characterScore;
-
-      return {
-        multiplier: multiplier * wordMultiplier,
-        score: score + tileScore * characterMultiplier,
-      };
-    },
-    { multiplier: 1, score: 0 },
-  );
-
-  return total.score * total.multiplier;
-};

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

@@ -1,17 +0,0 @@
-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

@@ -1,12 +0,0 @@
-import { type Pattern } from '@scrabble-solver/types';
-
-export const getPatternHash = (pattern: Pattern): string => {
-  return pattern.cells
-    .filter((cell) => cell.isEmpty)
-    .map((cell) => {
-      const blank = cell.tile.isBlank ? '!' : '';
-      const tile = cell.tile.character + blank;
-      return [cell.x, cell.y, tile].join(',');
-    })
-    .join('-');
-};