scrabble-solver 2.18.0 → 2.18.2

package/packages/types/src/readResultCells.test.ts

@@ -1,140 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-
-import { Board } from './Board';
-import { Cell } from './Cell';
-import { readCells, readCollisions } from './readResultCells';
-import { type ResultJson } from './ResultJson';
-import { Tile } from './Tile';
-
-describe('readCells', () => {
-  it('reads a word placed on an empty board', () => {
-    const board = createBoard();
-    const cells = readCells(createResultJson({ tiles: ['a', 'b', 'c'], x: 1, y: 2 }), board);
-
-    expect(toWord(cells)).toBe('abc');
-    expect(toCoordinates(cells)).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 = createBoard(['     ', '     ', ' a c ', '     ', '     ']);
-    const cells = readCells(createResultJson({ tiles: ['b'], x: 1, y: 2 }), board);
-
-    expect(toWord(cells)).toBe('abc');
-    expect(cells.map((cell) => cell.isEmpty)).toEqual([false, true, false]);
-    expect(toWord(placedCells(cells))).toBe('b');
-  });
-
-  it('reads a vertical word', () => {
-    const board = createBoard(['     ', '  a  ', '     ', '     ', '     ']);
-    const cells = readCells(createResultJson({ isHorizontal: false, tiles: ['b', 'c'], x: 2, y: 1 }), board);
-
-    expect(toWord(cells)).toBe('abc');
-    expect(toCoordinates(cells)).toBe('2,1 2,2 2,3');
-  });
-
-  it('marks placed blanks by their index among placed tiles', () => {
-    const board = createBoard(['     ', '     ', ' a   ', '     ', '     ']);
-    const cells = readCells(createResultJson({ blankIndices: [1], tiles: ['b', 'c'], x: 1, y: 2 }), board);
-
-    expect(toWord(cells)).toBe('abc');
-    expect(cells.map((cell) => cell.tile.isBlank)).toEqual([false, false, true]);
-  });
-
-  it('stops at the board edge', () => {
-    const board = createBoard();
-    const cells = readCells(createResultJson({ tiles: ['a', 'b', 'c'], x: 3, y: 2 }), board);
-
-    expect(toWord(cells)).toBe('ab');
-    expect(toCoordinates(cells)).toBe('3,2 4,2');
-  });
-
-  it('treats a candidate cell as empty', () => {
-    const board = createBoard();
-    board.updateCell(2, 2, () => new Cell({ isEmpty: true, tile: new Tile({ character: 'z' }), x: 2, y: 2 }));
-    const cells = readCells(createResultJson({ tiles: ['a', 'b', 'c'], x: 1, y: 2 }), board);
-
-    expect(toWord(cells)).toBe('abc');
-    expect(cells.every((cell) => cell.isEmpty)).toBe(true);
-  });
-
-  it('treats a cell without a tile as empty, matching the solver', () => {
-    const board = createBoard();
-    board.updateCell(2, 2, () => new Cell({ isEmpty: false, tile: Tile.Null, x: 2, y: 2 }));
-    const cells = readCells(createResultJson({ tiles: ['a', 'b', 'c'], x: 1, y: 2 }), board);
-
-    expect(toWord(cells)).toBe('abc');
-    expect(toWord(placedCells(cells))).toBe('abc');
-  });
-});
-
-describe('readCollisions', () => {
-  it('reads the perpendicular word crossing a placed tile', () => {
-    const board = createBoard(['     ', '  a  ', '   d ', '  c  ', '     ']);
-    const cells = readCells(createResultJson({ tiles: ['b'], x: 2, y: 2 }), board);
-    const collisions = readCollisions(cells, board, true);
-
-    expect(collisions.map(toWord)).toEqual(['abc']);
-    expect(toCoordinates(collisions[0])).toBe('2,1 2,2 2,3');
-  });
-
-  it('reads a horizontal collision crossing a vertical word', () => {
-    const board = createBoard(['     ', ' a c ', '     ', '     ', '     ']);
-    const cells = readCells(createResultJson({ isHorizontal: false, tiles: ['b', 'd'], x: 2, y: 1 }), board);
-    const collisions = readCollisions(cells, board, false);
-
-    expect(toWord(cells)).toBe('bd');
-    expect(collisions.map(toWord)).toEqual(['abc']);
-  });
-
-  it('reads one collision per placed tile', () => {
-    const board = createBoard(['  a a', '     ', '     ', '     ', '     ']);
-    const cells = readCells(createResultJson({ tiles: ['b', 'c', 'b'], x: 2, y: 1 }), board);
-
-    expect(readCollisions(cells, board, true).map(toWord)).toEqual(['ab', 'ab']);
-  });
-
-  it('ignores placed tiles without a perpendicular neighbour', () => {
-    const board = createBoard();
-    const cells = readCells(createResultJson({ tiles: ['a', 'b'], x: 1, y: 2 }), board);
-
-    expect(readCollisions(cells, board, true)).toEqual([]);
-  });
-
-  it('does not cross a candidate cell', () => {
-    const board = createBoard();
-    board.updateCell(2, 1, () => new Cell({ isEmpty: true, tile: new Tile({ character: 'z' }), x: 2, y: 1 }));
-    const cells = readCells(createResultJson({ tiles: ['a', 'b', 'c'], x: 1, y: 2 }), board);
-
-    expect(readCollisions(cells, board, true)).toEqual([]);
-  });
-});
-
-function createBoard(rows: string[] = ['     ', '     ', '     ', '     ', '     ']): Board {
-  return Board.fromStringArray(rows);
-}
-
-function createResultJson(json: Partial<ResultJson> = {}): ResultJson {
-  return {
-    blankIndices: [],
-    id: 0,
-    isHorizontal: true,
-    points: 0,
-    tiles: [],
-    x: 0,
-    y: 0,
-    ...json,
-  };
-}
-
-function placedCells(cells: Cell[]): Cell[] {
-  return cells.filter((cell) => cell.isEmpty);
-}
-
-function toWord(cells: Cell[]): string {
-  return cells.map(String).join('');
-}
-
-function toCoordinates(cells: Cell[]): string {
-  return cells.map(({ x, y }) => `${x},${y}`).join(' ');
-}

package/packages/types/src/readResultCells.ts

@@ -1,90 +0,0 @@
-import { type Board } from './Board';
-import { Cell } from './Cell';
-import { type ResultJson } from './ResultJson';
-import { Tile } from './Tile';
-
-export function readCells(json: ResultJson, board: Board): 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(readPlacedCell(json, placedIndex, x, y));
-      placedIndex += 1;
-    } else {
-      break;
-    }
-
-    x += stepX;
-    y += stepY;
-  }
-
-  return cells;
-}
-
-export function readCollisions(cells: Cell[], board: Board, isHorizontal: boolean): Cell[][] {
-  const collisions: Cell[][] = [];
-
-  for (const cell of cells) {
-    if (cell.isFilled()) {
-      continue;
-    }
-
-    const collision = readCollision(cell, board, isHorizontal);
-
-    if (collision.length > 1) {
-      collisions.push(collision);
-    }
-  }
-
-  return collisions;
-}
-
-function readPlacedCell(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 });
-}
-
-function readCollision(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;
-}