scrabble-solver 2.16.7 → 2.17.0

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

@@ -1,204 +0,0 @@
-/* eslint-disable max-lines */
-
-import { getConfig } from '@scrabble-solver/configs';
-import {
-  type Bingo,
-  Board,
-  Cell,
-  Config,
-  Game,
-  HorizontalPattern,
-  Locale,
-  Pattern,
-  Tile,
-  VerticalPattern,
-} from '@scrabble-solver/types';
-
-import { getPatternScore } from './getPatternScore';
-
-describe('getPatternScore', () => {
-  describe('Literaki - PL_PL', () => {
-    const config = getConfig(Game.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  ',
-    ]);
-
-    it('gives proper score without collisions (źaaaaaaź)', () => {
-      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 (źaaaaaaź)', () => {
-      const pattern = new HorizontalPattern(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(133);
-    });
-
-    it('gives proper score with collisions (lino)', () => {
-      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);
-    });
-
-    it('gives 0 score for unknown characters', () => {
-      const pattern = new HorizontalPattern(board, [
-        new Cell({
-          x: 13,
-          y: 14,
-          tile: new Tile({ character: '?', isBlank: false }),
-          isEmpty: true,
-        }),
-        new Cell({ x: 12, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
-      ]);
-
-      expect(getPatternScore(config, pattern)).toBe(2);
-    });
-
-    it('gives 50 points bonus for bingo', () => {
-      const pattern = new HorizontalPattern(board, [
-        new Cell({ x: 6, y: 14, tile: new Tile({ character: 'p' }), isEmpty: true }),
-        new Cell({ x: 7, y: 14, tile: new Tile({ character: 'o' }), isEmpty: true }),
-        new Cell({ x: 8, y: 14, tile: new Tile({ character: 'r' }), isEmpty: true }),
-        new Cell({ x: 9, y: 14, tile: new Tile({ character: 'o' }), isEmpty: true }),
-        new Cell({ x: 10, y: 14, tile: new Tile({ character: 'w' }), isEmpty: true }),
-        new Cell({
-          x: 11,
-          y: 14,
-          tile: new Tile({ character: 'a', isBlank: true }),
-          isEmpty: true,
-        }),
-        new Cell({ x: 11, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
-        new Cell({ x: 13, y: 14, tile: new Tile({ character: 'e' }), isEmpty: true }),
-      ]);
-
-      expect(getPatternScore(config, pattern)).toBe(59);
-    });
-  });
-
-  describe('Letter League - EN_US', () => {
-    const config = getConfig(Game.LetterLeague, Locale.EN_US);
-
-    it('gives double multiplier bonus for bingo without collisions', () => {
-      const board = Board.create(config.boardWidth, config.boardHeight);
-      const pattern = new HorizontalPattern(board, [
-        new Cell({ x: 13, y: 6, tile: new Tile({ character: 'r' }), isEmpty: true }),
-        new Cell({ x: 13, y: 7, tile: new Tile({ character: 'o' }), isEmpty: true }),
-        new Cell({ x: 13, y: 8, tile: new Tile({ character: 'm' }), isEmpty: true }),
-        new Cell({ x: 13, y: 9, tile: new Tile({ character: 'a' }), isEmpty: true }),
-        new Cell({ x: 13, y: 10, tile: new Tile({ character: 'i' }), isEmpty: true }),
-        new Cell({ x: 13, y: 11, tile: new Tile({ character: 'n' }), isEmpty: true }),
-        new Cell({ x: 13, y: 12, tile: new Tile({ character: 'e' }), isEmpty: true }),
-      ]);
-
-      expect(getPatternScore(config, pattern)).toBe(18);
-    });
-
-    it('gives double multiplier bonus for bingo with collisions', () => {
-      const board = Board.fromStringArray([
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '           on              ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-        '                           ',
-      ]);
-
-      const pattern = new VerticalPattern(board, [
-        new Cell({ x: 13, y: 6, tile: new Tile({ character: 'r' }), isEmpty: true }),
-        new Cell({ x: 13, y: 7, tile: new Tile({ character: 'o' }), isEmpty: true }),
-        new Cell({ x: 13, y: 8, tile: new Tile({ character: 'm' }), isEmpty: true }),
-        new Cell({ x: 13, y: 9, tile: new Tile({ character: 'a' }), isEmpty: true }),
-        new Cell({ x: 13, y: 10, tile: new Tile({ character: 'i' }), isEmpty: true }),
-        new Cell({ x: 13, y: 11, tile: new Tile({ character: 'n' }), isEmpty: true }),
-        new Cell({ x: 13, y: 12, tile: new Tile({ character: 'e' }), isEmpty: true }),
-      ]);
-
-      expect(getPatternScore(config, pattern)).toBe(21);
-    });
-  });
-
-  describe('invalid bingo config', () => {
-    const baseConfig = getConfig(Game.LetterLeague, Locale.EN_US);
-    const config = Config.fromJson({ ...baseConfig.config, bingo: {} as unknown as Bingo });
-
-    it('ignores the bingo bonus when the config is neither a score nor a multiplier bingo', () => {
-      const board = Board.create(config.boardWidth, config.boardHeight);
-      const pattern = new HorizontalPattern(board, [
-        new Cell({ x: 13, y: 6, tile: new Tile({ character: 'r' }), isEmpty: true }),
-        new Cell({ x: 13, y: 7, tile: new Tile({ character: 'o' }), isEmpty: true }),
-        new Cell({ x: 13, y: 8, tile: new Tile({ character: 'm' }), isEmpty: true }),
-        new Cell({ x: 13, y: 9, tile: new Tile({ character: 'a' }), isEmpty: true }),
-        new Cell({ x: 13, y: 10, tile: new Tile({ character: 'i' }), isEmpty: true }),
-        new Cell({ x: 13, y: 11, tile: new Tile({ character: 'n' }), isEmpty: true }),
-        new Cell({ x: 13, y: 12, tile: new Tile({ character: 'e' }), isEmpty: true }),
-      ]);
-
-      expect(getPatternScore(config, pattern)).toBe(9);
-    });
-  });
-});

package/packages/solver/src/getPatternScore.ts

@@ -1,23 +0,0 @@
-import { type Config, isMultiplierBingo, isScoreBingo, type Pattern } from '@scrabble-solver/types';
-
-import { getCellsScore } from './getCellsScore';
-
-export const getPatternScore = (config: Config, pattern: Pattern) => {
-  const areAllTilesUsed = pattern.getEmptyCellsCount() === config.rackSize;
-  const baseScore = getCellsScore(config, pattern.cells);
-  const collisionsScore = pattern
-    .getCollisions()
-    .reduce((sum, collision) => sum + getCellsScore(config, collision.cells), 0);
-
-  if (areAllTilesUsed) {
-    if (isScoreBingo(config.bingo)) {
-      return baseScore + collisionsScore + config.bingo.score;
-    }
-
-    if (isMultiplierBingo(config.bingo)) {
-      return baseScore * config.bingo.multiplier + collisionsScore;
-    }
-  }
-
-  return baseScore + collisionsScore;
-};

package/packages/solver/src/getUniquePatterns.ts

@@ -1,19 +0,0 @@
-import { type Pattern } from '@scrabble-solver/types';
-
-import { getPatternHash } from './getPatternHash';
-
-export const getUniquePatterns = (patterns: Pattern[]): Pattern[] => {
-  const hashes = new Set<string>();
-  const uniquePatterns: Pattern[] = [];
-
-  for (const pattern of patterns) {
-    const hash = getPatternHash(pattern);
-
-    if (!hashes.has(hash)) {
-      hashes.add(hash);
-      uniquePatterns.push(pattern);
-    }
-  }
-
-  return uniquePatterns;
-};

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

@@ -1,2 +0,0 @@
-import { type CellJson } from './CellJson';
-export type CollisionJson = CellJson[];

package/packages/types/build/CollisionJson.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/packages/types/build/FinalPattern.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FinalPattern = void 0;
-const Pattern_1 = require("./Pattern");
-class FinalPattern extends Pattern_1.Pattern {
-    constructor(pattern) {
-        super(pattern.board, pattern.cells);
-        this.collisions = pattern.getCollisions();
-    }
-    getCollisions() {
-        return this.collisions;
-    }
-}
-exports.FinalPattern = FinalPattern;

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

@@ -1,5 +0,0 @@
-import { Pattern } from './Pattern';
-export declare class HorizontalPattern extends Pattern {
-    clone(): Pattern;
-    getCollisions(): Pattern[];
-}

package/packages/types/build/HorizontalPattern.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HorizontalPattern = void 0;
-const Pattern_1 = require("./Pattern");
-class HorizontalPattern extends Pattern_1.Pattern {
-    clone() {
-        return new HorizontalPattern(this.board, this.cells.map((cell) => cell.clone()));
-    }
-    getCollisions() {
-        const collisions = [];
-        this.cells
-            .filter((cell) => cell.isEmpty && (this.board.collidesUp(cell) || this.board.collidesDown(cell)))
-            .forEach((cell) => {
-            const column = this.board.getColumn(cell.x);
-            let y = cell.y - 1;
-            while (y >= 0 && column[y].hasTile()) {
-                --y;
-            }
-            const previousCells = column.slice(y + 1, cell.y);
-            y = cell.y + 1;
-            while (y < column.length && column[y].hasTile()) {
-                ++y;
-            }
-            const nextCells = column.slice(cell.y + 1, y);
-            const cells = [...previousCells, cell, ...nextCells];
-            if (cells.length > 1) {
-                const pattern = new Pattern_1.Pattern(this.board, cells);
-                collisions.push(pattern);
-            }
-        });
-        return collisions;
-    }
-}
-exports.HorizontalPattern = HorizontalPattern;

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

@@ -1,20 +0,0 @@
-import { type Board } from './Board';
-import { type Cell } from './Cell';
-import { type Config } from './Config';
-import { type PatternJson } from './PatternJson';
-export declare class Pattern {
-    readonly board: Board;
-    readonly cells: Cell[];
-    constructor(board: Board, cells: Cell[]);
-    canBePlaced(config: Config): boolean;
-    clone(): Pattern;
-    collides(): boolean;
-    getIndexOfFirstCellWithoutTile(): number;
-    getEmptyCellsCount(): number;
-    goesThroughBoardCenter(): boolean;
-    hasAtLeast1EmptyCell(): boolean;
-    hasAtLeast1NonEmptyCell(): boolean;
-    getCollisions(): Pattern[];
-    toJson(): PatternJson;
-    toString(): string;
-}

package/packages/types/build/Pattern.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pattern = void 0;
-class Pattern {
-    constructor(board, cells) {
-        this.board = board;
-        this.cells = cells;
-    }
-    canBePlaced(config) {
-        const emptyCellsCount = this.getEmptyCellsCount();
-        const isUsedCellsCountInRange = emptyCellsCount >= 1 && emptyCellsCount <= config.rackSize;
-        return (isUsedCellsCountInRange &&
-            (this.hasAtLeast1NonEmptyCell() || this.collides() || (this.goesThroughBoardCenter() && this.board.isEmpty())));
-    }
-    clone() {
-        return new Pattern(this.board, this.cells.map((cell) => cell.clone()));
-    }
-    collides() {
-        return this.cells.some((cell) => cell.isEmpty && this.board.collides(cell));
-    }
-    getIndexOfFirstCellWithoutTile() {
-        return this.cells.findIndex((cell) => !cell.hasTile());
-    }
-    getEmptyCellsCount() {
-        return this.cells.filter((cell) => cell.isEmpty).length;
-    }
-    goesThroughBoardCenter() {
-        return this.cells.some((cell) => cell.x === this.board.center.x && cell.y === this.board.center.y && cell.isEmpty);
-    }
-    hasAtLeast1EmptyCell() {
-        return this.cells.some((cell) => cell.isEmpty);
-    }
-    hasAtLeast1NonEmptyCell() {
-        return this.cells.some((cell) => !cell.isEmpty);
-    }
-    getCollisions() {
-        return [];
-    }
-    toJson() {
-        return {
-            cells: this.cells.map((cell) => cell.toJson()),
-            collisions: this.getCollisions().map((collision) => collision.toJson()),
-            word: this.toString(),
-        };
-    }
-    toString() {
-        return this.cells.reduce((result, cell) => result + cell.toString(), '');
-    }
-}
-exports.Pattern = Pattern;

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

@@ -1,6 +0,0 @@
-import { type CellJson } from './CellJson';
-export interface PatternJson {
-    cells: CellJson[];
-    collisions: PatternJson[];
-    word: string;
-}

package/packages/types/build/PatternJson.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,5 +0,0 @@
-import { Pattern } from './Pattern';
-export declare class VerticalPattern extends Pattern {
-    clone(): Pattern;
-    getCollisions(): Pattern[];
-}

package/packages/types/build/VerticalPattern.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VerticalPattern = void 0;
-const Pattern_1 = require("./Pattern");
-class VerticalPattern extends Pattern_1.Pattern {
-    clone() {
-        return new VerticalPattern(this.board, this.cells.map((cell) => cell.clone()));
-    }
-    getCollisions() {
-        const collisions = [];
-        this.cells
-            .filter((cell) => cell.isEmpty && (this.board.collidesLeft(cell) || this.board.collidesRight(cell)))
-            .forEach((cell) => {
-            const row = this.board.getRow(cell.y);
-            let x = cell.x - 1;
-            while (x >= 0 && row[x].hasTile()) {
-                --x;
-            }
-            const previousCells = row.slice(x + 1, cell.x);
-            x = cell.x + 1;
-            while (x < row.length && row[x].hasTile()) {
-                ++x;
-            }
-            const nextCells = row.slice(cell.x + 1, x);
-            const cells = [...previousCells, cell, ...nextCells];
-            if (cells.length > 1) {
-                const pattern = new Pattern_1.Pattern(this.board, cells);
-                collisions.push(pattern);
-            }
-        });
-        return collisions;
-    }
-}
-exports.VerticalPattern = VerticalPattern;

package/packages/types/src/CollisionJson.ts

@@ -1,3 +0,0 @@
-import { type CellJson } from './CellJson';
-
-export type CollisionJson = CellJson[];

package/packages/types/src/FinalPattern.ts

@@ -1,14 +0,0 @@
-import { Pattern } from './Pattern';
-
-export class FinalPattern extends Pattern {
-  private readonly collisions: Pattern[];
-
-  constructor(pattern: Pattern) {
-    super(pattern.board, pattern.cells);
-    this.collisions = pattern.getCollisions();
-  }
-
-  public getCollisions(): Pattern[] {
-    return this.collisions;
-  }
-}

package/packages/types/src/HorizontalPattern.ts

@@ -1,37 +0,0 @@
-import { Pattern } from './Pattern';
-
-export class HorizontalPattern extends Pattern {
-  public clone(): Pattern {
-    return new HorizontalPattern(
-      this.board,
-      this.cells.map((cell) => cell.clone()),
-    );
-  }
-
-  public getCollisions(): Pattern[] {
-    const collisions: Pattern[] = [];
-
-    this.cells
-      .filter((cell) => cell.isEmpty && (this.board.collidesUp(cell) || this.board.collidesDown(cell)))
-      .forEach((cell) => {
-        const column = this.board.getColumn(cell.x);
-        let y = cell.y - 1;
-        while (y >= 0 && column[y].hasTile()) {
-          --y;
-        }
-        const previousCells = column.slice(y + 1, cell.y);
-        y = cell.y + 1;
-        while (y < column.length && column[y].hasTile()) {
-          ++y;
-        }
-        const nextCells = column.slice(cell.y + 1, y);
-        const cells = [...previousCells, cell, ...nextCells];
-        if (cells.length > 1) {
-          const pattern = new Pattern(this.board, cells);
-          collisions.push(pattern);
-        }
-      });
-
-    return collisions;
-  }
-}

package/packages/types/src/Pattern.ts

@@ -1,71 +0,0 @@
-import { type Board } from './Board';
-import { type Cell } from './Cell';
-import { type Config } from './Config';
-import { type PatternJson } from './PatternJson';
-
-export class Pattern {
-  public readonly board: Board;
-
-  public readonly cells: Cell[];
-
-  constructor(board: Board, cells: Cell[]) {
-    this.board = board;
-    this.cells = cells;
-  }
-
-  public canBePlaced(config: Config): boolean {
-    const emptyCellsCount = this.getEmptyCellsCount();
-    const isUsedCellsCountInRange = emptyCellsCount >= 1 && emptyCellsCount <= config.rackSize;
-    return (
-      isUsedCellsCountInRange &&
-      (this.hasAtLeast1NonEmptyCell() || this.collides() || (this.goesThroughBoardCenter() && this.board.isEmpty()))
-    );
-  }
-
-  public clone(): Pattern {
-    return new Pattern(
-      this.board,
-      this.cells.map((cell) => cell.clone()),
-    );
-  }
-
-  public collides(): boolean {
-    return this.cells.some((cell) => cell.isEmpty && this.board.collides(cell));
-  }
-
-  public getIndexOfFirstCellWithoutTile(): number {
-    return this.cells.findIndex((cell) => !cell.hasTile());
-  }
-
-  public getEmptyCellsCount(): number {
-    return this.cells.filter((cell) => cell.isEmpty).length;
-  }
-
-  public goesThroughBoardCenter(): boolean {
-    return this.cells.some((cell) => cell.x === this.board.center.x && cell.y === this.board.center.y && cell.isEmpty);
-  }
-
-  public hasAtLeast1EmptyCell(): boolean {
-    return this.cells.some((cell) => cell.isEmpty);
-  }
-
-  public hasAtLeast1NonEmptyCell(): boolean {
-    return this.cells.some((cell) => !cell.isEmpty);
-  }
-
-  public getCollisions(): Pattern[] {
-    return [];
-  }
-
-  public toJson(): PatternJson {
-    return {
-      cells: this.cells.map((cell) => cell.toJson()),
-      collisions: this.getCollisions().map((collision) => collision.toJson()),
-      word: this.toString(),
-    };
-  }
-
-  public toString(): string {
-    return this.cells.reduce((result, cell) => result + cell.toString(), '');
-  }
-}

package/packages/types/src/PatternJson.ts

@@ -1,7 +0,0 @@
-import { type CellJson } from './CellJson';
-
-export interface PatternJson {
-  cells: CellJson[];
-  collisions: PatternJson[];
-  word: string;
-}

package/packages/types/src/VerticalPattern.ts

@@ -1,37 +0,0 @@
-import { Pattern } from './Pattern';
-
-export class VerticalPattern extends Pattern {
-  public clone(): Pattern {
-    return new VerticalPattern(
-      this.board,
-      this.cells.map((cell) => cell.clone()),
-    );
-  }
-
-  public getCollisions(): Pattern[] {
-    const collisions: Pattern[] = [];
-
-    this.cells
-      .filter((cell) => cell.isEmpty && (this.board.collidesLeft(cell) || this.board.collidesRight(cell)))
-      .forEach((cell) => {
-        const row = this.board.getRow(cell.y);
-        let x = cell.x - 1;
-        while (x >= 0 && row[x].hasTile()) {
-          --x;
-        }
-        const previousCells = row.slice(x + 1, cell.x);
-        x = cell.x + 1;
-        while (x < row.length && row[x].hasTile()) {
-          ++x;
-        }
-        const nextCells = row.slice(cell.x + 1, x);
-        const cells = [...previousCells, cell, ...nextCells];
-        if (cells.length > 1) {
-          const pattern = new Pattern(this.board, cells);
-          collisions.push(pattern);
-        }
-      });
-
-    return collisions;
-  }
-}