scrabble-solver 2.18.10-alpha.0 → 2.18.10-alpha.2

package/packages/types/src/lib/getCells.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'bun:test';
+
+import { Board } from '../Board';
+import { Cell } from '../Cell';
+import { Tile } from '../Tile';
+
+import { getCells } from './getCells';
+
+describe('getCells', () => {
+  it('reads a word placed on an empty board', () => {
+    const board = Board.fromStringArray(['     ', '     ', '     ', '     ', '     ']);
+    const cells = getCells(board, {
+      blankIndices: [],
+      id: 0,
+      isHorizontal: true,
+      points: 0,
+      tiles: ['a', 'b', 'c'],
+      x: 1,
+      y: 2,
+    });
+
+    expect(cells.map(String).join('')).toBe('abc');
+    expect(cells.map(({ x, y }) => `${x},${y}`).join(' ')).toBe('1,2 2,2 3,2');
+    expect(cells.every((cell) => cell.isEmpty)).toBe(true);
+  });
+
+  it('reads a word played through existing board tiles', () => {
+    const board = Board.fromStringArray(['     ', '     ', ' a c ', '     ', '     ']);
+    const cells = getCells(board, { blankIndices: [], id: 0, isHorizontal: true, points: 0, tiles: ['b'], x: 1, y: 2 });
+
+    expect(cells.map(String).join('')).toBe('abc');
+    expect(cells.map((cell) => cell.isEmpty)).toEqual([false, true, false]);
+    expect(
+      cells
+        .filter((cell) => cell.isEmpty)
+        .map(String)
+        .join(''),
+    ).toBe('b');
+  });
+
+  it('reads a vertical word', () => {
+    const board = Board.fromStringArray(['     ', '  a  ', '     ', '     ', '     ']);
+    const cells = getCells(board, {
+      blankIndices: [],
+      id: 0,
+      isHorizontal: false,
+      points: 0,
+      tiles: ['b', 'c'],
+      x: 2,
+      y: 1,
+    });
+
+    expect(cells.map(String).join('')).toBe('abc');
+    expect(cells.map(({ x, y }) => `${x},${y}`).join(' ')).toBe('2,1 2,2 2,3');
+  });
+
+  it('marks placed blanks by their index among placed tiles', () => {
+    const board = Board.fromStringArray(['     ', '     ', ' a   ', '     ', '     ']);
+    const cells = getCells(board, {
+      blankIndices: [1],
+      id: 0,
+      isHorizontal: true,
+      points: 0,
+      tiles: ['b', 'c'],
+      x: 1,
+      y: 2,
+    });
+
+    expect(cells.map(String).join('')).toBe('abc');
+    expect(cells.map((cell) => cell.tile.isBlank)).toEqual([false, false, true]);
+  });
+
+  it('stops at the board edge', () => {
+    const board = Board.fromStringArray(['     ', '     ', '     ', '     ', '     ']);
+    const cells = getCells(board, {
+      blankIndices: [],
+      id: 0,
+      isHorizontal: true,
+      points: 0,
+      tiles: ['a', 'b', 'c'],
+      x: 3,
+      y: 2,
+    });
+
+    expect(cells.map(String).join('')).toBe('ab');
+    expect(cells.map(({ x, y }) => `${x},${y}`).join(' ')).toBe('3,2 4,2');
+  });
+
+  it('treats a candidate cell as empty', () => {
+    const board = Board.fromStringArray(['     ', '     ', '     ', '     ', '     ']);
+    board.updateCell(2, 2, () => new Cell({ isEmpty: true, tile: new Tile({ character: 'z' }), x: 2, y: 2 }));
+    const cells = getCells(board, {
+      blankIndices: [],
+      id: 0,
+      isHorizontal: true,
+      points: 0,
+      tiles: ['a', 'b', 'c'],
+      x: 1,
+      y: 2,
+    });
+
+    expect(cells.map(String).join('')).toBe('abc');
+    expect(cells.every((cell) => cell.isEmpty)).toBe(true);
+  });
+
+  it('treats a cell without a tile as empty, matching the solver', () => {
+    const board = Board.fromStringArray(['     ', '     ', '     ', '     ', '     ']);
+    board.updateCell(2, 2, () => new Cell({ isEmpty: false, tile: Tile.Null, x: 2, y: 2 }));
+    const cells = getCells(board, {
+      blankIndices: [],
+      id: 0,
+      isHorizontal: true,
+      points: 0,
+      tiles: ['a', 'b', 'c'],
+      x: 1,
+      y: 2,
+    });
+
+    expect(cells.map(String).join('')).toBe('abc');
+    expect(
+      cells
+        .filter((cell) => cell.isEmpty)
+        .map(String)
+        .join(''),
+    ).toBe('abc');
+  });
+});

package/packages/types/src/lib/getCells.ts

@@ -0,0 +1,31 @@
+import { type Board } from '../Board';
+import { type Cell } from '../Cell';
+import { type ResultJson } from '../ResultJson';
+
+import { getPlacedCell } from './getPlacedCell';
+
+export function getCells(board: Board, json: ResultJson): Cell[] {
+  const stepX = json.isHorizontal ? 1 : 0;
+  const stepY = json.isHorizontal ? 0 : 1;
+  const cells: Cell[] = [];
+  let placedIndex = 0;
+  let { x, y } = json;
+
+  while (y < board.rowsCount && x < board.columnsCount) {
+    const boardCell = board.rows[y][x];
+
+    if (boardCell.isFilled()) {
+      cells.push(boardCell.clone());
+    } else if (placedIndex < json.tiles.length) {
+      cells.push(getPlacedCell(json, placedIndex, x, y));
+      placedIndex += 1;
+    } else {
+      break;
+    }
+
+    x += stepX;
+    y += stepY;
+  }
+
+  return cells;
+}

package/packages/types/src/lib/getCollidingWords.ts

@@ -0,0 +1,25 @@
+import { type Board } from '../Board';
+import { type BoardWord } from '../BoardWord';
+import { type Direction } from '../Direction';
+
+import { getWordThrough } from './getWordThrough';
+
+export function getCollidingWords(board: Board, word: BoardWord): BoardWord[] {
+  const isHorizontal = word.direction === 'horizontal';
+  const collidingDirection: Direction = isHorizontal ? 'vertical' : 'horizontal';
+  const collidingWords: BoardWord[] = [];
+  let { x, y } = word;
+
+  while (x < board.columnsCount && y < board.rowsCount && !board.rows[y][x].isEmpty) {
+    const collidingWord = getWordThrough(board, x, y, collidingDirection);
+
+    if (collidingWord) {
+      collidingWords.push(collidingWord);
+    }
+
+    x += isHorizontal ? 1 : 0;
+    y += isHorizontal ? 0 : 1;
+  }
+
+  return collidingWords;
+}

package/packages/types/src/lib/getCollision.ts

@@ -0,0 +1,38 @@
+import { type Board } from '../Board';
+import { type Cell } from '../Cell';
+
+export function getCollision(placed: Cell, board: Board, isHorizontal: boolean): Cell[] {
+  const stepX = isHorizontal ? 0 : 1;
+  const stepY = isHorizontal ? 1 : 0;
+  let x = placed.x - stepX;
+  let y = placed.y - stepY;
+
+  while (x >= 0 && y >= 0 && board.rows[y][x].isFilled()) {
+    x -= stepX;
+    y -= stepY;
+  }
+
+  x += stepX;
+  y += stepY;
+
+  const collision: Cell[] = [];
+
+  while (y < board.rowsCount && x < board.columnsCount) {
+    if (x === placed.x && y === placed.y) {
+      collision.push(placed);
+    } else {
+      const boardCell = board.rows[y][x];
+
+      if (!boardCell.isFilled()) {
+        break;
+      }
+
+      collision.push(boardCell.clone());
+    }
+
+    x += stepX;
+    y += stepY;
+  }
+
+  return collision;
+}

package/packages/types/src/lib/getCollisions.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'bun:test';
+
+import { Board } from '../Board';
+import { Cell } from '../Cell';
+import { Tile } from '../Tile';
+
+import { getCells } from './getCells';
+import { getCollisions } from './getCollisions';
+
+describe('getCollisions', () => {
+  it('reads the perpendicular word crossing a placed tile', () => {
+    const board = Board.fromStringArray(['     ', '  a  ', '   d ', '  c  ', '     ']);
+    const cells = getCells(board, { blankIndices: [], id: 0, isHorizontal: true, points: 0, tiles: ['b'], x: 2, y: 2 });
+    const collisions = getCollisions(board, cells, true);
+
+    expect(collisions.map((collision) => collision.map(String).join(''))).toEqual(['abc']);
+    expect(collisions[0].map(({ x, y }) => `${x},${y}`).join(' ')).toBe('2,1 2,2 2,3');
+  });
+
+  it('reads a horizontal collision crossing a vertical word', () => {
+    const board = Board.fromStringArray(['     ', ' a c ', '     ', '     ', '     ']);
+    const cells = getCells(board, {
+      blankIndices: [],
+      id: 0,
+      isHorizontal: false,
+      points: 0,
+      tiles: ['b', 'd'],
+      x: 2,
+      y: 1,
+    });
+    const collisions = getCollisions(board, cells, false);
+
+    expect(cells.map(String).join('')).toBe('bd');
+    expect(collisions.map((collision) => collision.map(String).join(''))).toEqual(['abc']);
+  });
+
+  it('reads one collision per placed tile', () => {
+    const board = Board.fromStringArray(['  a a', '     ', '     ', '     ', '     ']);
+    const cells = getCells(board, {
+      blankIndices: [],
+      id: 0,
+      isHorizontal: true,
+      points: 0,
+      tiles: ['b', 'c', 'b'],
+      x: 2,
+      y: 1,
+    });
+
+    expect(getCollisions(board, cells, true).map((collision) => collision.map(String).join(''))).toEqual(['ab', 'ab']);
+  });
+
+  it('ignores placed tiles without a perpendicular neighbour', () => {
+    const board = Board.fromStringArray(['     ', '     ', '     ', '     ', '     ']);
+    const cells = getCells(board, {
+      blankIndices: [],
+      id: 0,
+      isHorizontal: true,
+      points: 0,
+      tiles: ['a', 'b'],
+      x: 1,
+      y: 2,
+    });
+
+    expect(getCollisions(board, cells, true)).toEqual([]);
+  });
+
+  it('does not cross a candidate cell', () => {
+    const board = Board.fromStringArray(['     ', '     ', '     ', '     ', '     ']);
+    board.updateCell(2, 1, () => new Cell({ isEmpty: true, tile: new Tile({ character: 'z' }), x: 2, y: 1 }));
+    const cells = getCells(board, {
+      blankIndices: [],
+      id: 0,
+      isHorizontal: true,
+      points: 0,
+      tiles: ['a', 'b', 'c'],
+      x: 1,
+      y: 2,
+    });
+
+    expect(getCollisions(board, cells, true)).toEqual([]);
+  });
+});

package/packages/types/src/lib/getCollisions.ts

@@ -0,0 +1,22 @@
+import { type Board } from '../Board';
+import { type Cell } from '../Cell';
+
+import { getCollision } from './getCollision';
+
+export function getCollisions(board: Board, cells: Cell[], isHorizontal: boolean): Cell[][] {
+  const collisions: Cell[][] = [];
+
+  for (const cell of cells) {
+    if (cell.isFilled()) {
+      continue;
+    }
+
+    const collision = getCollision(cell, board, isHorizontal);
+
+    if (collision.length > 1) {
+      collisions.push(collision);
+    }
+  }
+
+  return collisions;
+}

package/packages/types/src/lib/getPlacedCell.ts

@@ -0,0 +1,9 @@
+import { Cell } from '../Cell';
+import { type ResultJson } from '../ResultJson';
+import { Tile } from '../Tile';
+
+export function getPlacedCell(json: ResultJson, placedIndex: number, x: number, y: number): Cell {
+  const character = json.tiles[placedIndex];
+  const isBlank = json.blankIndices.includes(placedIndex);
+  return new Cell({ isEmpty: true, tile: new Tile({ character, isBlank }), x, y });
+}

package/packages/types/src/lib/getWordThrough.ts

@@ -0,0 +1,30 @@
+import { type Board } from '../Board';
+import { type BoardWord } from '../BoardWord';
+import { type Cell } from '../Cell';
+import { type Direction } from '../Direction';
+
+import { toBoardWord } from './toBoardWord';
+
+export function getWordThrough(board: Board, x: number, y: number, direction: Direction): BoardWord | undefined {
+  const stepX = direction === 'horizontal' ? 1 : 0;
+  const stepY = direction === 'horizontal' ? 0 : 1;
+  let startX = x;
+  let startY = y;
+
+  while (startX - stepX >= 0 && startY - stepY >= 0 && !board.rows[startY - stepY][startX - stepX].isEmpty) {
+    startX -= stepX;
+    startY -= stepY;
+  }
+
+  const cells: Cell[] = [];
+  let cellX = startX;
+  let cellY = startY;
+
+  while (cellX < board.columnsCount && cellY < board.rowsCount && !board.rows[cellY][cellX].isEmpty) {
+    cells.push(board.rows[cellY][cellX]);
+    cellX += stepX;
+    cellY += stepY;
+  }
+
+  return cells.length > 1 ? toBoardWord(cells, direction) : undefined;
+}

package/packages/types/src/lib/getWordsInRows.ts

@@ -0,0 +1,34 @@
+import { type BoardWord } from '../BoardWord';
+import { type Cell } from '../Cell';
+import { type Direction } from '../Direction';
+
+import { toBoardWord } from './toBoardWord';
+
+/**
+ * Cells in transposed rows keep their original coordinates,
+ * so the first cell of a run is the word's start in both directions.
+ */
+export function getWordsInRows(cells: Cell[][], direction: Direction): BoardWord[] {
+  const words: BoardWord[] = [];
+
+  for (const row of cells) {
+    let currentWord: Cell[] = [];
+
+    for (const cell of row) {
+      if (!cell.isEmpty) {
+        currentWord.push(cell);
+      } else if (currentWord.length > 0) {
+        if (currentWord.length > 1) {
+          words.push(toBoardWord(currentWord, direction));
+        }
+        currentWord = [];
+      }
+    }
+
+    if (currentWord.length > 1) {
+      words.push(toBoardWord(currentWord, direction));
+    }
+  }
+
+  return words;
+}

package/packages/types/src/lib/index.ts

@@ -0,0 +1,5 @@
+export * from './getBoardWords';
+export * from './getCells';
+export * from './getCollidingWords';
+export * from './getCollisions';
+export * from './isSameBoardWord';

package/packages/types/src/lib/isSameBoardWord.ts

@@ -0,0 +1,5 @@
+import { type BoardWord } from '../BoardWord';
+
+export function isSameBoardWord(a: BoardWord, b: BoardWord): boolean {
+  return a.direction === b.direction && a.x === b.x && a.y === b.y;
+}

package/packages/types/src/lib/toBoardWord.ts

@@ -0,0 +1,12 @@
+import { type BoardWord } from '../BoardWord';
+import { type Cell } from '../Cell';
+import { type Direction } from '../Direction';
+
+export function toBoardWord(cells: Cell[], direction: Direction): BoardWord {
+  return {
+    direction,
+    word: cells.map((cell) => cell.tile.character).join(''),
+    x: cells[0].x,
+    y: cells[0].y,
+  };
+}

package/packages/types/src/lib/transpose.ts

@@ -0,0 +1,15 @@
+export function transpose<T>(array: T[][]): T[][] {
+  const rows = array.length;
+  const cols = array[0].length;
+  const transposed: T[][] = Array(cols)
+    .fill(null)
+    .map(() => Array(rows));
+
+  for (let y = 0; y < rows; ++y) {
+    for (let x = 0; x < cols; ++x) {
+      transposed[x][y] = array[y][x];
+    }
+  }
+
+  return transposed;
+}

package/packages/types/src/type-guards/index.ts

@@ -0,0 +1,10 @@
+export { isBingo } from './isBingo';
+export { isBoardJson } from './isBoardJson';
+export { isCellJson } from './isCellJson';
+export { isError } from './isError';
+export { isGame } from './isGame';
+export { isLocale } from './isLocale';
+export { isMultiplierBingo } from './isMultiplierBingo';
+export { isObject } from './isObject';
+export { isScoreBingo } from './isScoreBingo';
+export { isTileJson } from './isTileJson';

package/packages/types/src/type-guards/isBingo.ts

@@ -0,0 +1,8 @@
+import { type Bingo } from '../Bingo';
+
+import { isMultiplierBingo } from './isMultiplierBingo';
+import { isScoreBingo } from './isScoreBingo';
+
+export const isBingo = (value: unknown): value is Bingo => {
+  return isScoreBingo(value) || isMultiplierBingo(value);
+};

package/packages/types/src/type-guards/isBoardJson.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'bun:test';
+
+import { isBoardJson } from './isBoardJson';
+
+describe('isBoardJson', () => {
+  const cell = { isEmpty: true, tile: null, x: 0, y: 0 };
+
+  it('accepts a board of cells', () => {
+    expect(
+      isBoardJson([
+        [cell, cell],
+        [cell, cell],
+      ]),
+    ).toBe(true);
+  });
+
+  it('accepts an empty board', () => {
+    expect(isBoardJson([])).toBe(true);
+  });
+
+  it('rejects a non-array', () => {
+    expect(isBoardJson({ rows: [] })).toBe(false);
+  });
+
+  it('rejects rows that are not arrays', () => {
+    expect(isBoardJson([1, 2, 3])).toBe(false);
+    expect(isBoardJson([[cell], 'row'])).toBe(false);
+  });
+
+  it('rejects rows holding something other than cells', () => {
+    expect(isBoardJson([[cell, { x: 1, y: 0 }]])).toBe(false);
+  });
+});

package/packages/types/src/type-guards/isBoardJson.ts

@@ -0,0 +1,23 @@
+import { type BoardJson } from '../BoardJson';
+
+import { isCellJson } from './isCellJson';
+
+export const isBoardJson = (value: unknown): value is BoardJson => {
+  if (!Array.isArray(value)) {
+    return false;
+  }
+
+  for (const row of value) {
+    if (!Array.isArray(row)) {
+      return false;
+    }
+
+    for (const cell of row) {
+      if (!isCellJson(cell)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+};

package/packages/types/src/type-guards/isCellJson.ts

@@ -0,0 +1,14 @@
+import { type CellJson } from '../CellJson';
+
+import { isObject } from './isObject';
+import { isTileJson } from './isTileJson';
+
+export const isCellJson = (value: unknown): value is CellJson => {
+  return (
+    isObject(value) &&
+    typeof value.isEmpty === 'boolean' &&
+    (isTileJson(value.tile) || value.tile === null) &&
+    typeof value.x === 'number' &&
+    typeof value.y === 'number'
+  );
+};

package/packages/types/src/type-guards/isError.ts

@@ -0,0 +1,9 @@
+import { isObject } from './isObject';
+
+export const isError = (value: unknown): value is Error => {
+  if (!isObject(value)) {
+    return false;
+  }
+
+  return typeof value.message === 'string';
+};

package/packages/types/src/type-guards/isGame.ts

@@ -0,0 +1,5 @@
+import { Game } from '../Game';
+
+const games = Object.values(Game);
+
+export const isGame = (locale: unknown): locale is Game => games.includes(locale as Game);

package/packages/types/src/type-guards/isLocale.ts

@@ -0,0 +1,5 @@
+import { Locale } from '../Locale';
+
+const locales = Object.values(Locale);
+
+export const isLocale = (locale: unknown): locale is Locale => locales.includes(locale as Locale);

package/packages/types/src/type-guards/isMultiplierBingo.ts

@@ -0,0 +1,7 @@
+import { type MultiplierBingo } from '../Bingo';
+
+import { isObject } from './isObject';
+
+export const isMultiplierBingo = (value: unknown): value is MultiplierBingo => {
+  return isObject(value) && 'multiplier' in value && typeof value.multiplier === 'number';
+};

package/packages/types/src/type-guards/isObject.ts

@@ -0,0 +1,3 @@
+export const isObject = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === 'object' && value !== null;
+};

package/packages/types/src/type-guards/isScoreBingo.ts

@@ -0,0 +1,7 @@
+import { type ScoreBingo } from '../Bingo';
+
+import { isObject } from './isObject';
+
+export const isScoreBingo = (value: unknown): value is ScoreBingo => {
+  return isObject(value) && 'score' in value && typeof value.score === 'number';
+};

package/packages/types/src/type-guards/isTileJson.ts

@@ -0,0 +1,7 @@
+import { type TileJson } from '../TileJson';
+
+import { isObject } from './isObject';
+
+export const isTileJson = (value: unknown): value is TileJson => {
+  return isObject(value) && typeof value.character === 'string' && typeof value.isBlank === 'boolean';
+};

package/packages/types/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+
+  "compilerOptions": {
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "exclude": ["node_modules", "**/*.test.ts"],
+  "include": ["./src", "index.ts"]
+}

package/packages/word-definitions/README.md

@@ -0,0 +1,3 @@
+# @scrabble-solver/word-definitions
+
+Fetches array of definitions of a given word in a given language.

package/packages/word-definitions/build/crawl.d.ts

@@ -0,0 +1,2 @@
+import { Locale } from '@scrabble-solver/types';
+export declare const crawl: (locale: Locale, word: string) => Promise<string>;

package/packages/word-definitions/build/crawl.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crawl = void 0;
+const types_1 = require("@scrabble-solver/types");
+const languages_1 = require("./languages");
+const crawlPerLocale = {
+    [types_1.Locale.DE_DE]: languages_1.german.crawl,
+    [types_1.Locale.EN_GB]: languages_1.english.crawl,
+    [types_1.Locale.EN_US]: languages_1.english.crawl,
+    [types_1.Locale.ES_ES]: languages_1.spanish.crawl,
+    [types_1.Locale.FA_IR]: languages_1.persian.crawl,
+    [types_1.Locale.FR_FR]: languages_1.french.crawl,
+    [types_1.Locale.PL_PL]: languages_1.polish.crawl,
+    [types_1.Locale.RO_RO]: languages_1.romanian.crawl,
+    [types_1.Locale.TR_TR]: languages_1.turkish.crawl,
+};
+const crawl = (locale, word) => {
+    return crawlPerLocale[locale](word);
+};
+exports.crawl = crawl;

package/packages/word-definitions/build/getWordDefinition.d.ts

@@ -0,0 +1,2 @@
+import { type Locale, WordDefinition } from '@scrabble-solver/types';
+export declare const getWordDefinition: (locale: Locale, word: string, isAllowed: boolean) => Promise<WordDefinition>;

package/packages/word-definitions/build/getWordDefinition.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWordDefinition = void 0;
+const types_1 = require("@scrabble-solver/types");
+const crawl_1 = require("./crawl");
+const parse_1 = require("./parse");
+const getWordDefinition = async (locale, word, isAllowed) => {
+    const html = await (0, crawl_1.crawl)(locale, word);
+    const { definitions, exists } = (0, parse_1.parse)(locale, html);
+    const wordDefinition = new types_1.WordDefinition({ definitions, exists, isAllowed, word });
+    return wordDefinition;
+};
+exports.getWordDefinition = getWordDefinition;