scrabble-solver 2.18.8 → 2.18.10-alpha.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/packages/word-definitions/README.md

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

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

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

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

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

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

@@ -1,13 +0,0 @@
-"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;