@scrabble-solver/solver 2.8.7 → 2.8.9

package/build/Solver.d.ts

@@ -1,10 +0,0 @@
-import { Trie } from '@kamilmielnik/trie';
-import { Board, Config, Result, Tile } from '@scrabble-solver/types';
-declare class Solver {
-    private readonly patternsFiller;
-    private readonly patternsGenerator;
-    private readonly scoresCalculator;
-    constructor(config: Config, trie: Trie);
-    solve(board: Board, tiles: Tile[]): Result[];
-}
-export default Solver;

package/build/Solver.js

@@ -1,30 +0,0 @@
-"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 getUniquePatterns_1 = __importDefault(require("./getUniquePatterns"));
-const PatternsFiller_1 = __importDefault(require("./PatternsFiller"));
-const PatternsGenerator_1 = __importDefault(require("./PatternsGenerator"));
-const ScoresCalculator_1 = __importDefault(require("./ScoresCalculator"));
-class Solver {
-    constructor(config, trie) {
-        this.patternsFiller = new PatternsFiller_1.default(config, trie);
-        this.patternsGenerator = new PatternsGenerator_1.default(config);
-        this.scoresCalculator = new ScoresCalculator_1.default(config);
-    }
-    solve(board, tiles) {
-        const patterns = this.patternsGenerator.generate(board);
-        const filledPatterns = patterns.flatMap((pattern) => this.patternsFiller.fill(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: this.scoresCalculator.calculate(pattern),
-        }));
-        return results;
-    }
-}
-exports.default = Solver;

package/src/PatternsFiller.test.ts

@@ -1,92 +0,0 @@
-import { literaki } from '@scrabble-solver/configs';
-import { dictionaries } from '@scrabble-solver/dictionaries';
-import { Board, Cell, Locale, Tile, VerticalPattern } from '@scrabble-solver/types';
-
-import PatternsFiller from './PatternsFiller';
-
-describe('PatternsFiller', () => {
-  const board = Board.fromStringArray([' t ', 'do ', '   ']);
-  const locale = Locale.PL_PL;
-  const config = literaki[locale];
-  let patternsFiller: PatternsFiller | undefined;
-
-  beforeAll(() => {
-    return dictionaries.get(locale).then((trie) => {
-      patternsFiller = new PatternsFiller(config, trie);
-    });
-  });
-
-  it('does not affect non-blank tiles', () => {
-    const permutations = patternsFiller!.generateBlankTilesPermutations([
-      new Tile({ character: 'a', isBlank: false }),
-      new Tile({ character: 'b', isBlank: false }),
-      new Tile({ character: 'c', isBlank: false }),
-    ]);
-    expect(permutations.length).toBe(1);
-    expect(permutations[0].map(String).join('')).toEqual('abc');
-  });
-
-  it('replaces blank tiles', () => {
-    const permutations = patternsFiller!.generateBlankTilesPermutations([
-      new Tile({ character: 'a', isBlank: false }),
-      new Tile({ character: 'a', isBlank: false }),
-      new Tile({ character: '', isBlank: true }),
-    ]);
-    expect(permutations.length).toBe(config.alphabet.length);
-    expect(permutations[0][2].toJson()).toEqual({
-      character: config.alphabet[0],
-      isBlank: true,
-    });
-    expect(permutations[permutations.length - 1][2].toJson()).toEqual({
-      character: config.alphabet[config.alphabet.length - 1],
-      isBlank: true,
-    });
-  });
-
-  it('fills patterns', () => {
-    const pattern = new VerticalPattern({
-      board,
-      cells: [
-        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 = patternsFiller!.fill(pattern, tiles);
-    expect(filledPatterns.length).toBe(1);
-  });
-
-  it('does not modify filled patterns', () => {
-    const pattern = new VerticalPattern({
-      board,
-      cells: [
-        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 = patternsFiller!.fill(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,
-      cells: [
-        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 = patternsFiller!.fill(pattern, tiles);
-    expect(filledPatterns.length).toBe(0);
-  });
-});

package/src/PatternsFiller.ts

@@ -1,91 +0,0 @@
-import { Trie } from '@kamilmielnik/trie';
-import { EMPTY_CELL } from '@scrabble-solver/constants';
-import { Config, Pattern, Tile } from '@scrabble-solver/types';
-
-class PatternsFiller {
-  private readonly trie: Trie;
-
-  private readonly config: Config;
-
-  constructor(config: Config, trie: Trie) {
-    this.config = config;
-    this.trie = trie;
-  }
-
-  public fill(pattern: Pattern, tiles: Tile[]): Pattern[] {
-    const patterns: Pattern[] = [];
-
-    if (pattern.getEmptyCellsCount() > tiles.length) {
-      return [];
-    }
-
-    const onPatternFound = (newPattern: Pattern) => 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;
-  }
-
-  public fillPattern(
-    pattern: Pattern,
-    word: string,
-    tiles: Tile[],
-    onPatternFound: (newPattern: Pattern) => void,
-  ): void {
-    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(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;
-      }
-    }
-  }
-
-  public canAddPattern(pattern: Pattern, word: string): boolean {
-    return this.trie.has(word) && pattern.getCollisions().every((collision) => this.trie.has(collision.toString()));
-  }
-
-  public generateBlankTilesPermutations(tiles: Tile[]): Tile[][] {
-    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<Tile[][]>((permutations, character) => {
-      const newTile = new Tile({ character, isBlank: true });
-      const newTiles = [...remainingTiles, newTile];
-
-      return permutations.concat(this.generateBlankTilesPermutations(newTiles));
-    }, []);
-  }
-}
-
-export default PatternsFiller;

package/src/PatternsGenerator.test.ts

@@ -1,89 +0,0 @@
-import { EMPTY_CELL } from '@scrabble-solver/constants';
-import { Board, Cell, Config } from '@scrabble-solver/types';
-
-import PatternsGenerator from './PatternsGenerator';
-
-const board = Board.fromStringArray([' t ', 'do ', '   ']);
-
-const patternsGenerator = new PatternsGenerator({
-  boardHeight: 3,
-  boardWidth: 3,
-  maximumCharactersCount: 7,
-} as Config);
-
-describe('PatternsGenerator', () => {
-  const emptyCell: Cell = { hasTile: () => false } as Cell;
-  const filledCell: Cell = { hasTile: () => true } as Cell;
-
-  it('generates start indices', () => {
-    const cells = [filledCell, filledCell, emptyCell, emptyCell, emptyCell, filledCell];
-    const startIndices = patternsGenerator.generateStartIndices(cells);
-    expect(startIndices).toEqual([0, 3, 4]);
-  });
-
-  it('generates end indices', () => {
-    const tests = [
-      {
-        input: patternsGenerator.generateEndIndices(
-          [filledCell, filledCell, emptyCell, emptyCell, emptyCell, filledCell],
-          3,
-        ),
-        output: [5],
-      },
-      {
-        input: patternsGenerator.generateEndIndices(
-          [filledCell, filledCell, emptyCell, emptyCell, emptyCell, filledCell, emptyCell],
-          3,
-        ),
-        output: [5, 6],
-      },
-    ];
-
-    tests.forEach(({ input, output }) => expect(input).toEqual(output));
-  });
-
-  it('generates vectors', () => {
-    const vectors = patternsGenerator.generateVectors({
-      getNthVector: () => [],
-      vectorsCount: 3,
-    });
-    expect(vectors.length).toBe(3);
-    expect(vectors).toEqual([[], [], []]);
-  });
-
-  it('generates some vertical patterns', () => {
-    const vertical = patternsGenerator.generateVertical(board);
-    expect(vertical.length).toBeGreaterThan(0);
-  });
-
-  it('generates proper vertical patterns', () => {
-    const vertical = patternsGenerator.generateVertical(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],
-    ]);
-  });
-
-  it('generates some horizontal patterns', () => {
-    const horizontal = patternsGenerator.generateHorizontal(board);
-    expect(horizontal.length).toBeGreaterThan(0);
-  });
-
-  it('generates proper horizontal patterns', () => {
-    const horizontal = patternsGenerator.generateHorizontal(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/PatternsGenerator.ts

@@ -1,103 +0,0 @@
-import { Board, Cell, Config, HorizontalPattern, Pattern, VerticalPattern } from '@scrabble-solver/types';
-
-class PatternsGenerator {
-  private readonly config: Config;
-
-  constructor(config: Config) {
-    this.config = config;
-  }
-
-  public generate(board: Board): Pattern[] {
-    return [...this.generateHorizontal(board), ...this.generateVertical(board)];
-  }
-
-  public generateHorizontal(board: Board): HorizontalPattern[] {
-    return this.generatePatterns({
-      board,
-      getNthVector: (index) => board.getRow(index),
-      PatternModel: HorizontalPattern,
-      vectorsCount: this.config.boardHeight,
-    });
-  }
-
-  public generateVertical(board: Board): VerticalPattern[] {
-    return this.generatePatterns({
-      board,
-      getNthVector: (index) => board.getColumn(index),
-      PatternModel: VerticalPattern,
-      vectorsCount: this.config.boardWidth,
-    });
-  }
-
-  public 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[] {
-    return this.generateVectors({ getNthVector, vectorsCount }).reduce<P[]>((patterns, cells) => {
-      return patterns.concat(this.generateCellsPatterns<P>({ board, PatternModel, cells }));
-    }, []);
-  }
-
-  public generateVectors({
-    getNthVector,
-    vectorsCount,
-  }: {
-    getNthVector: (index: number) => Cell[];
-    vectorsCount: number;
-  }): Cell[][] {
-    return Array(vectorsCount)
-      .fill(0)
-      .map((_, index) => getNthVector(index));
-  }
-
-  public generateCellsPatterns<P extends Pattern>({
-    board,
-    cells,
-    PatternModel,
-  }: {
-    board: Board;
-    cells: Cell[];
-    PatternModel: new (parameters: { board: Board; cells: Cell[] }) => P;
-  }): P[] {
-    return this.generateStartIndices(cells).flatMap((startIndex) => {
-      const endIndices = this.generateEndIndices(cells, startIndex);
-      const patterns: P[] = [];
-
-      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;
-    });
-  }
-
-  public generateStartIndices(cells: Cell[]): number[] {
-    return Array(cells.length - 1)
-      .fill(0)
-      .map((_, startIndex) => startIndex)
-      .filter((startIndex) => startIndex === 0 || !cells[startIndex - 1].hasTile());
-  }
-
-  public 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 PatternsGenerator;

package/src/ScoresCalculator.test.ts

@@ -1,70 +0,0 @@
-import { literaki } from '@scrabble-solver/configs';
-import { Board, Cell, HorizontalPattern, Locale, Pattern, Tile, VerticalPattern } from '@scrabble-solver/types';
-
-import ScoresCalculator from './ScoresCalculator';
-
-const config = literaki[Locale.PL_PL];
-const scoresCalculator = new ScoresCalculator(config);
-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('ScoresCalculator', () => {
-  it('gives proper score without collisions', () => {
-    const pattern = new Pattern({
-      board,
-      cells: [
-        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 }),
-      ],
-    });
-    const score = scoresCalculator.calculate(pattern);
-    expect(score).toBe(128);
-  });
-
-  it('gives proper score with collisions', () => {
-    const pattern = new VerticalPattern({
-      board,
-      cells: [
-        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 }),
-      ],
-    });
-    const score = scoresCalculator.calculate(pattern);
-    expect(score).toBe(44);
-  });
-
-  it('gives proper score for blank', () => {
-    const pattern = new HorizontalPattern({
-      board,
-      cells: [
-        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 }),
-      ],
-    });
-    const score = scoresCalculator.calculate(pattern);
-    expect(score).toBe(2);
-  });
-});

package/src/ScoresCalculator.ts

@@ -1,52 +0,0 @@
-import { NO_BONUS } from '@scrabble-solver/constants';
-import { Cell, Config, Pattern } from '@scrabble-solver/types';
-
-class ScoresCalculator {
-  private readonly config: Config;
-
-  constructor(config: Config) {
-    this.config = config;
-  }
-
-  public calculate(pattern: Pattern): number {
-    return this.calculatePatternScoreWithCollisions(pattern) + this.calculateBonusScore(pattern);
-  }
-
-  public calculateBonusScore(pattern: Pattern): number {
-    const areAllTilesUsed = pattern.getEmptyCellsCount() === this.config.maximumCharactersCount;
-    return areAllTilesUsed ? this.config.allTilesBonusScore : 0;
-  }
-
-  public calculatePatternScoreWithCollisions(pattern: Pattern): number {
-    return pattern
-      .getCollisions()
-      .reduce(
-        (patternsScore, collisionPattern) => patternsScore + this.calculatePatternScore(collisionPattern),
-        this.calculatePatternScore(pattern),
-      );
-  }
-
-  public calculatePatternScore(pattern: Pattern): number {
-    const { multiplier, score } = pattern.cells.reduce(this.reduceCellScore, {
-      multiplier: 1,
-      score: 0,
-    });
-    return score * multiplier;
-  }
-
-  public reduceCellScore = (
-    { multiplier, score }: { multiplier: number; score: number },
-    cell: Cell,
-  ): { multiplier: number; score: number } => {
-    const bonus = this.config.getCellBonus(cell);
-    const { characterMultiplier, wordMultiplier } = bonus && bonus.canApply(this.config, cell) ? bonus.value : NO_BONUS;
-    const characterScore = cell.tile.isBlank ? this.config.blankScore : this.config.pointsMap[cell.tile.character];
-
-    return {
-      multiplier: multiplier * wordMultiplier,
-      score: score + characterScore * characterMultiplier,
-    };
-  };
-}
-
-export default ScoresCalculator;

package/src/Solver.ts

@@ -1,39 +0,0 @@
-import { Trie } from '@kamilmielnik/trie';
-import { Board, Config, Result, Tile } from '@scrabble-solver/types';
-
-import getUniquePatterns from './getUniquePatterns';
-import PatternsFiller from './PatternsFiller';
-import PatternsGenerator from './PatternsGenerator';
-import ScoresCalculator from './ScoresCalculator';
-
-class Solver {
-  private readonly patternsFiller: PatternsFiller;
-
-  private readonly patternsGenerator: PatternsGenerator;
-
-  private readonly scoresCalculator: ScoresCalculator;
-
-  constructor(config: Config, trie: Trie) {
-    this.patternsFiller = new PatternsFiller(config, trie);
-    this.patternsGenerator = new PatternsGenerator(config);
-    this.scoresCalculator = new ScoresCalculator(config);
-  }
-
-  public solve(board: Board, tiles: Tile[]): Result[] {
-    const patterns = this.patternsGenerator.generate(board);
-    const filledPatterns = patterns.flatMap((pattern) => this.patternsFiller.fill(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: this.scoresCalculator.calculate(pattern),
-        }),
-    );
-    return results;
-  }
-}
-
-export default Solver;