scrabble-solver 2.16.7 → 2.18.0

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

@@ -8,25 +8,21 @@ export { Cell } from './Cell';
 export { CellJson, isCellJson } from './CellJson';
 export { CharacterBonus } from './CharacterBonus';
 export { Collision } from './Collision';
-export { CollisionJson } from './CollisionJson';
 export { Config } from './Config';
 export { ConfigJson } from './ConfigJson';
 export { Dictionary } from './Dictionary';
-export { FinalPattern } from './FinalPattern';
+export { Direction } from './Direction';
 export { Game, isGame } from './Game';
-export { HorizontalPattern } from './HorizontalPattern';
 export { isError } from './isError';
 export { isObject } from './isObject';
 export { isLocale, Locale } from './Locale';
-export { Pattern } from './Pattern';
-export { PatternJson } from './PatternJson';
 export { Result } from './Result';
 export { ResultJson } from './ResultJson';
 export { ShowCoordinates } from './ShowCoordinates';
+export { TextDirection } from './TextDirection';
 export { Tile } from './Tile';
 export { TileConfig } from './TileConfig';
 export { isTileJson, TileJson } from './TileJson';
-export { VerticalPattern } from './VerticalPattern';
 export { WordBonus } from './WordBonus';
 export { WordDefinition } from './WordDefinition';
 export { WordDefinitionJson } from './WordDefinitionJson';

package/packages/types/build/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WordDefinition = exports.WordBonus = exports.VerticalPattern = exports.isTileJson = exports.Tile = exports.Result = exports.Pattern = exports.Locale = exports.isLocale = exports.isObject = exports.isError = exports.HorizontalPattern = exports.isGame = exports.Game = exports.FinalPattern = exports.Config = exports.CharacterBonus = exports.isCellJson = exports.Cell = exports.Bonus = exports.isBoardJson = exports.Board = exports.isScoreBingo = exports.isMultiplierBingo = exports.isBingo = void 0;
+exports.WordDefinition = exports.WordBonus = exports.isTileJson = exports.Tile = exports.Result = exports.Locale = exports.isLocale = exports.isObject = exports.isError = exports.isGame = exports.Game = exports.Config = exports.CharacterBonus = exports.isCellJson = exports.Cell = exports.Bonus = exports.isBoardJson = exports.Board = exports.isScoreBingo = exports.isMultiplierBingo = exports.isBingo = void 0;
 var Bingo_1 = require("./Bingo");
 Object.defineProperty(exports, "isBingo", { enumerable: true, get: function () { return Bingo_1.isBingo; } });
 Object.defineProperty(exports, "isMultiplierBingo", { enumerable: true, get: function () { return Bingo_1.isMultiplierBingo; } });
@@ -19,13 +19,9 @@ var CharacterBonus_1 = require("./CharacterBonus");
 Object.defineProperty(exports, "CharacterBonus", { enumerable: true, get: function () { return CharacterBonus_1.CharacterBonus; } });
 var Config_1 = require("./Config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return Config_1.Config; } });
-var FinalPattern_1 = require("./FinalPattern");
-Object.defineProperty(exports, "FinalPattern", { enumerable: true, get: function () { return FinalPattern_1.FinalPattern; } });
 var Game_1 = require("./Game");
 Object.defineProperty(exports, "Game", { enumerable: true, get: function () { return Game_1.Game; } });
 Object.defineProperty(exports, "isGame", { enumerable: true, get: function () { return Game_1.isGame; } });
-var HorizontalPattern_1 = require("./HorizontalPattern");
-Object.defineProperty(exports, "HorizontalPattern", { enumerable: true, get: function () { return HorizontalPattern_1.HorizontalPattern; } });
 var isError_1 = require("./isError");
 Object.defineProperty(exports, "isError", { enumerable: true, get: function () { return isError_1.isError; } });
 var isObject_1 = require("./isObject");
@@ -33,16 +29,12 @@ Object.defineProperty(exports, "isObject", { enumerable: true, get: function ()
 var Locale_1 = require("./Locale");
 Object.defineProperty(exports, "isLocale", { enumerable: true, get: function () { return Locale_1.isLocale; } });
 Object.defineProperty(exports, "Locale", { enumerable: true, get: function () { return Locale_1.Locale; } });
-var Pattern_1 = require("./Pattern");
-Object.defineProperty(exports, "Pattern", { enumerable: true, get: function () { return Pattern_1.Pattern; } });
 var Result_1 = require("./Result");
 Object.defineProperty(exports, "Result", { enumerable: true, get: function () { return Result_1.Result; } });
 var Tile_1 = require("./Tile");
 Object.defineProperty(exports, "Tile", { enumerable: true, get: function () { return Tile_1.Tile; } });
 var TileJson_1 = require("./TileJson");
 Object.defineProperty(exports, "isTileJson", { enumerable: true, get: function () { return TileJson_1.isTileJson; } });
-var VerticalPattern_1 = require("./VerticalPattern");
-Object.defineProperty(exports, "VerticalPattern", { enumerable: true, get: function () { return VerticalPattern_1.VerticalPattern; } });
 var WordBonus_1 = require("./WordBonus");
 Object.defineProperty(exports, "WordBonus", { enumerable: true, get: function () { return WordBonus_1.WordBonus; } });
 var WordDefinition_1 = require("./WordDefinition");

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

@@ -0,0 +1,5 @@
+import { type Board } from './Board';
+import { Cell } from './Cell';
+import { type ResultJson } from './ResultJson';
+export declare function readCells(json: ResultJson, board: Board): Cell[];
+export declare function readCollisions(cells: Cell[], board: Board, isHorizontal: boolean): Cell[][];

package/packages/types/build/readResultCells.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCells = readCells;
+exports.readCollisions = readCollisions;
+const Cell_1 = require("./Cell");
+const Tile_1 = require("./Tile");
+function readCells(json, board) {
+    const stepX = json.isHorizontal ? 1 : 0;
+    const stepY = json.isHorizontal ? 0 : 1;
+    const cells = [];
+    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;
+}
+function readCollisions(cells, board, isHorizontal) {
+    const collisions = [];
+    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, placedIndex, x, y) {
+    const character = json.tiles[placedIndex];
+    const isBlank = json.blankIndices.includes(placedIndex);
+    return new Cell_1.Cell({ isEmpty: true, tile: new Tile_1.Tile({ character, isBlank }), x, y });
+}
+function readCollision(placed, board, isHorizontal) {
+    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 = [];
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/types",
-  "version": "2.16.7",
+  "version": "2.18.0",
   "description": "Scrabble Solver 2 - Types",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -20,10 +20,11 @@
   "homepage": "https://scrabble-solver.org",
   "scripts": {
     "build": "tsc --project .",
-    "clean": "rimraf build/"
+    "clean": "rimraf build/",
+    "test": "bun test src"
   },
   "dependencies": {
-    "@scrabble-solver/constants": "^2.16.7"
+    "@scrabble-solver/constants": "^2.18.0"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }

package/packages/types/src/Cell.ts

@@ -47,6 +47,10 @@ export class Cell {
     return this.isEmpty && this.hasTile();
   }
 
+  public isFilled(): boolean {
+    return !this.isEmpty && this.hasTile();
+  }
+
   public toJson(): CellJson {
     return {
       isEmpty: this.isEmpty,

package/packages/types/src/Direction.ts

@@ -0,0 +1 @@
+export type Direction = 'horizontal' | 'vertical';

package/packages/types/src/Result.ts

@@ -1,17 +1,21 @@
 import { CONSONANTS, VOWELS } from '@scrabble-solver/constants';
 
-import { Cell } from './Cell';
+import { type Board } from './Board';
+import { type Cell } from './Cell';
+import { readCells, readCollisions } from './readResultCells';
 import { type ResultJson } from './ResultJson';
 import { type Tile } from './Tile';
 
 type Collision = Cell[];
 
 export class Result {
-  public static fromJson = (json: ResultJson): Result => {
+  public static fromJson = (json: ResultJson, board: Board): Result => {
+    const cells = readCells(json, board);
+
     return new Result({
+      cells,
+      collisions: readCollisions(cells, board, json.isHorizontal),
       id: json.id,
-      cells: json.cells.map(Cell.fromJson),
-      collisions: json.collisions.map((collision) => collision.map(Cell.fromJson)),
       points: json.points,
     });
   };
@@ -73,11 +77,16 @@ export class Result {
   }
 
   public toJson(): ResultJson {
+    const placed = this.cells.filter((cell) => cell.isEmpty);
+
     return {
-      cells: this.cells.map((cell) => cell.toJson()),
+      blankIndices: placed.flatMap((cell, index) => (cell.tile.isBlank ? [index] : [])),
       id: this.id,
-      collisions: this.collisions.map((collision) => collision.map((cell) => cell.toJson())),
+      isHorizontal: this.isHorizontal(),
       points: this.points,
+      tiles: placed.map((cell) => cell.tile.character),
+      x: this.cells[0].x,
+      y: this.cells[0].y,
     };
   }
 

package/packages/types/src/ResultJson.ts

@@ -1,9 +1,9 @@
-import { type CellJson } from './CellJson';
-import { type CollisionJson } from './CollisionJson';
-
 export interface ResultJson {
-  cells: CellJson[];
-  collisions: CollisionJson[];
+  blankIndices: number[];
   id: number;
+  isHorizontal: boolean;
   points: number;
+  tiles: string[];
+  x: number;
+  y: number;
 }

package/packages/types/src/ShowCoordinates.ts

@@ -1,6 +1,5 @@
 /**
  * 'original' means columns have letters and rows have numbers
  * 'alternative' means columns have numbers and rows have letters
- * 'hidden' means coordinates won't be shown
  */
-export type ShowCoordinates = 'original' | 'alternative' | 'hidden';
+export type ShowCoordinates = 'original' | 'alternative';

package/packages/types/src/TextDirection.ts

@@ -0,0 +1 @@
+export type TextDirection = 'ltr' | 'rtl';

package/packages/types/src/index.ts

@@ -8,25 +8,21 @@ export { Cell } from './Cell';
 export { CellJson, isCellJson } from './CellJson';
 export { CharacterBonus } from './CharacterBonus';
 export { Collision } from './Collision';
-export { CollisionJson } from './CollisionJson';
 export { Config } from './Config';
 export { ConfigJson } from './ConfigJson';
 export { Dictionary } from './Dictionary';
-export { FinalPattern } from './FinalPattern';
+export { Direction } from './Direction';
 export { Game, isGame } from './Game';
-export { HorizontalPattern } from './HorizontalPattern';
 export { isError } from './isError';
 export { isObject } from './isObject';
 export { isLocale, Locale } from './Locale';
-export { Pattern } from './Pattern';
-export { PatternJson } from './PatternJson';
 export { Result } from './Result';
 export { ResultJson } from './ResultJson';
 export { ShowCoordinates } from './ShowCoordinates';
+export { TextDirection } from './TextDirection';
 export { Tile } from './Tile';
 export { TileConfig } from './TileConfig';
 export { isTileJson, TileJson } from './TileJson';
-export { VerticalPattern } from './VerticalPattern';
 export { WordBonus } from './WordBonus';
 export { WordDefinition } from './WordDefinition';
 export { WordDefinitionJson } from './WordDefinitionJson';

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

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

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

package/packages/word-definitions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/word-definitions",
-  "version": "2.16.7",
+  "version": "2.18.0",
   "description": "Scrabble Solver 2 - Word definitions",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -24,7 +24,7 @@
     "test": "bun test --timeout 180000 src"
   },
   "dependencies": {
-    "@scrabble-solver/types": "^2.16.7",
+    "@scrabble-solver/types": "^2.18.0",
     "cheerio": "^1.2.0",
     "follow-redirects": "^1.16.0",
     "striptags": "^3.2.0"

package/packages/word-lists/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/word-lists",
-  "version": "2.16.7",
+  "version": "2.18.0",
   "description": "Scrabble Solver 2 - Word lists",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -23,7 +23,7 @@
     "clean": "rimraf build/"
   },
   "dependencies": {
-    "@scrabble-solver/types": "^2.16.7",
+    "@scrabble-solver/types": "^2.18.0",
     "cheerio": "^1.2.0",
     "follow-redirects": "^1.16.0",
     "transliteration": "^2.6.1",