scrabble-solver 2.18.1 → 2.18.3

package/packages/types/build/lib/isSameBoardWord.d.ts

@@ -0,0 +1,2 @@
+import { type BoardWord } from '../BoardWord';
+export declare function isSameBoardWord(a: BoardWord, b: BoardWord): boolean;

package/packages/types/build/lib/isSameBoardWord.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameBoardWord = isSameBoardWord;
+function isSameBoardWord(a, b) {
+    return a.direction === b.direction && a.x === b.x && a.y === b.y;
+}

package/packages/types/build/lib/toBoardWord.d.ts

@@ -0,0 +1,4 @@
+import { type BoardWord } from '../BoardWord';
+import { type Cell } from '../Cell';
+import { type Direction } from '../Direction';
+export declare function toBoardWord(cells: Cell[], direction: Direction): BoardWord;

package/packages/types/build/lib/toBoardWord.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBoardWord = toBoardWord;
+function toBoardWord(cells, direction) {
+    return {
+        direction,
+        word: cells.map((cell) => cell.tile.character).join(''),
+        x: cells[0].x,
+        y: cells[0].y,
+    };
+}

package/packages/types/build/lib/transpose.d.ts

@@ -0,0 +1 @@
+export declare function transpose<T>(array: T[][]): T[][];

package/packages/types/build/lib/transpose.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transpose = transpose;
+function transpose(array) {
+    const rows = array.length;
+    const cols = array[0].length;
+    const transposed = 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/build/type-guards/index.d.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/build/type-guards/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTileJson = exports.isScoreBingo = exports.isObject = exports.isMultiplierBingo = exports.isLocale = exports.isGame = exports.isError = exports.isCellJson = exports.isBoardJson = exports.isBingo = void 0;
+var isBingo_1 = require("./isBingo");
+Object.defineProperty(exports, "isBingo", { enumerable: true, get: function () { return isBingo_1.isBingo; } });
+var isBoardJson_1 = require("./isBoardJson");
+Object.defineProperty(exports, "isBoardJson", { enumerable: true, get: function () { return isBoardJson_1.isBoardJson; } });
+var isCellJson_1 = require("./isCellJson");
+Object.defineProperty(exports, "isCellJson", { enumerable: true, get: function () { return isCellJson_1.isCellJson; } });
+var isError_1 = require("./isError");
+Object.defineProperty(exports, "isError", { enumerable: true, get: function () { return isError_1.isError; } });
+var isGame_1 = require("./isGame");
+Object.defineProperty(exports, "isGame", { enumerable: true, get: function () { return isGame_1.isGame; } });
+var isLocale_1 = require("./isLocale");
+Object.defineProperty(exports, "isLocale", { enumerable: true, get: function () { return isLocale_1.isLocale; } });
+var isMultiplierBingo_1 = require("./isMultiplierBingo");
+Object.defineProperty(exports, "isMultiplierBingo", { enumerable: true, get: function () { return isMultiplierBingo_1.isMultiplierBingo; } });
+var isObject_1 = require("./isObject");
+Object.defineProperty(exports, "isObject", { enumerable: true, get: function () { return isObject_1.isObject; } });
+var isScoreBingo_1 = require("./isScoreBingo");
+Object.defineProperty(exports, "isScoreBingo", { enumerable: true, get: function () { return isScoreBingo_1.isScoreBingo; } });
+var isTileJson_1 = require("./isTileJson");
+Object.defineProperty(exports, "isTileJson", { enumerable: true, get: function () { return isTileJson_1.isTileJson; } });

package/packages/types/build/type-guards/isBingo.d.ts

@@ -0,0 +1,2 @@
+import { type Bingo } from '../Bingo';
+export declare const isBingo: (value: unknown) => value is Bingo;

package/packages/types/build/type-guards/isBingo.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBingo = void 0;
+const isMultiplierBingo_1 = require("./isMultiplierBingo");
+const isScoreBingo_1 = require("./isScoreBingo");
+const isBingo = (value) => {
+    return (0, isScoreBingo_1.isScoreBingo)(value) || (0, isMultiplierBingo_1.isMultiplierBingo)(value);
+};
+exports.isBingo = isBingo;

package/packages/types/build/type-guards/isBoardJson.d.ts

@@ -0,0 +1,2 @@
+import { type BoardJson } from '../BoardJson';
+export declare const isBoardJson: (value: unknown) => value is BoardJson;

package/packages/types/build/type-guards/isBoardJson.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBoardJson = void 0;
+const isCellJson_1 = require("./isCellJson");
+const isBoardJson = (value) => {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    for (const row of value) {
+        if (!Array.isArray(row)) {
+            return false;
+        }
+        for (const cell of row) {
+            if (!(0, isCellJson_1.isCellJson)(cell)) {
+                return false;
+            }
+        }
+    }
+    return true;
+};
+exports.isBoardJson = isBoardJson;

package/packages/types/build/type-guards/isCellJson.d.ts

@@ -0,0 +1,2 @@
+import { type CellJson } from '../CellJson';
+export declare const isCellJson: (value: unknown) => value is CellJson;

package/packages/types/build/type-guards/isCellJson.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCellJson = void 0;
+const isObject_1 = require("./isObject");
+const isTileJson_1 = require("./isTileJson");
+const isCellJson = (value) => {
+    return ((0, isObject_1.isObject)(value) &&
+        typeof value.isEmpty === 'boolean' &&
+        ((0, isTileJson_1.isTileJson)(value.tile) || value.tile === null) &&
+        typeof value.x === 'number' &&
+        typeof value.y === 'number');
+};
+exports.isCellJson = isCellJson;

package/packages/types/build/type-guards/isGame.d.ts

@@ -0,0 +1,2 @@
+import { Game } from '../Game';
+export declare const isGame: (locale: unknown) => locale is Game;

package/packages/types/build/type-guards/isGame.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGame = void 0;
+const Game_1 = require("../Game");
+const games = Object.values(Game_1.Game);
+const isGame = (locale) => games.includes(locale);
+exports.isGame = isGame;

package/packages/types/build/type-guards/isLocale.d.ts

@@ -0,0 +1,2 @@
+import { Locale } from '../Locale';
+export declare const isLocale: (locale: unknown) => locale is Locale;

package/packages/types/build/type-guards/isLocale.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocale = void 0;
+const Locale_1 = require("../Locale");
+const locales = Object.values(Locale_1.Locale);
+const isLocale = (locale) => locales.includes(locale);
+exports.isLocale = isLocale;

package/packages/types/build/type-guards/isMultiplierBingo.d.ts

@@ -0,0 +1,2 @@
+import { type MultiplierBingo } from '../Bingo';
+export declare const isMultiplierBingo: (value: unknown) => value is MultiplierBingo;

package/packages/types/build/type-guards/isMultiplierBingo.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMultiplierBingo = void 0;
+const isObject_1 = require("./isObject");
+const isMultiplierBingo = (value) => {
+    return (0, isObject_1.isObject)(value) && 'multiplier' in value && typeof value.multiplier === 'number';
+};
+exports.isMultiplierBingo = isMultiplierBingo;

package/packages/types/build/type-guards/isScoreBingo.d.ts

@@ -0,0 +1,2 @@
+import { type ScoreBingo } from '../Bingo';
+export declare const isScoreBingo: (value: unknown) => value is ScoreBingo;

package/packages/types/build/type-guards/isScoreBingo.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScoreBingo = void 0;
+const isObject_1 = require("./isObject");
+const isScoreBingo = (value) => {
+    return (0, isObject_1.isObject)(value) && 'score' in value && typeof value.score === 'number';
+};
+exports.isScoreBingo = isScoreBingo;

package/packages/types/build/type-guards/isTileJson.d.ts

@@ -0,0 +1,2 @@
+import { type TileJson } from '../TileJson';
+export declare const isTileJson: (value: unknown) => value is TileJson;

package/packages/types/build/type-guards/isTileJson.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTileJson = void 0;
+const isObject_1 = require("./isObject");
+const isTileJson = (value) => {
+    return (0, isObject_1.isObject)(value) && typeof value.character === 'string' && typeof value.isBlank === 'boolean';
+};
+exports.isTileJson = isTileJson;

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/types",
-  "version": "2.18.1",
+  "version": "2.18.3",
   "description": "Domain model for Scrabble Solver: Board, Cell, Tile, Result, Config, Locale, and their JSON wire shapes.",
   "keywords": [
     "scrabble",
@@ -31,7 +31,7 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@scrabble-solver/constants": "^2.18.1"
+    "@scrabble-solver/constants": "^2.18.3"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }

package/packages/types/src/Bingo.ts

@@ -1,19 +1,5 @@
-import { isObject } from './isObject';
-
 export type MultiplierBingo = { multiplier: number };
 
 export type ScoreBingo = { score: number };
 
 export type Bingo = MultiplierBingo | ScoreBingo;
-
-export const isBingo = (value: unknown): value is Bingo => {
-  return isScoreBingo(value) || isMultiplierBingo(value);
-};
-
-export const isScoreBingo = (value: unknown): value is ScoreBingo => {
-  return isObject(value) && 'score' in value && typeof value.score === 'number';
-};
-
-export const isMultiplierBingo = (value: unknown): value is MultiplierBingo => {
-  return isObject(value) && 'multiplier' in value && typeof value.multiplier === 'number';
-};

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

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'bun:test';
+
+import { Board } from './Board';
+import { Cell } from './Cell';
+import { Tile } from './Tile';
+
+describe('Board.getWords', () => {
+  it('returns no words for an empty board', () => {
+    const board = Board.fromStringArray(['     ', '     ', '     ', '     ', '     ']);
+
+    expect(board.getWords()).toEqual([]);
+  });
+
+  it('locates a horizontal word', () => {
+    const board = Board.fromStringArray(['     ', ' cat ', '     ', '     ', '     ']);
+
+    expect(board.getWords()).toEqual([{ direction: 'horizontal', word: 'cat', x: 1, y: 1 }]);
+  });
+
+  it('locates a vertical word', () => {
+    const board = Board.fromStringArray(['     ', '  c  ', '  a  ', '  t  ', '     ']);
+
+    expect(board.getWords()).toEqual([{ direction: 'vertical', word: 'cat', x: 2, y: 1 }]);
+  });
+
+  it('locates crossing words in both directions', () => {
+    const board = Board.fromStringArray(['     ', ' cat ', ' o   ', ' d   ', '     ']);
+
+    expect(board.getWords()).toEqual([
+      { direction: 'horizontal', word: 'cat', x: 1, y: 1 },
+      { direction: 'vertical', word: 'cod', x: 1, y: 1 },
+    ]);
+  });
+
+  it('distinguishes the same word at different positions', () => {
+    const board = Board.fromStringArray(['cat  ', '     ', '  cat', '     ', '     ']);
+
+    expect(board.getWords()).toEqual([
+      { direction: 'horizontal', word: 'cat', x: 0, y: 0 },
+      { direction: 'horizontal', word: 'cat', x: 2, y: 2 },
+    ]);
+  });
+
+  it('skips single-tile runs', () => {
+    const board = Board.fromStringArray(['     ', ' a   ', '     ', '   to', '     ']);
+
+    expect(board.getWords()).toEqual([{ direction: 'horizontal', word: 'to', x: 3, y: 3 }]);
+  });
+
+  it('locates a word with a digraph tile occupying a single cell', () => {
+    const board = Board.fromStringArray(['   ', '  e', '   ']);
+    board.updateCell(1, 1, () => new Cell({ isEmpty: false, tile: new Tile({ character: 'ch' }), x: 1, y: 1 }));
+
+    expect(board.getWords()).toEqual([{ direction: 'horizontal', word: 'che', x: 1, y: 1 }]);
+  });
+});
+
+describe('Board.getCollidingWords', () => {
+  const board = Board.fromStringArray(['     ', ' cat ', ' o  o', ' dot ', '     ']);
+
+  it('finds the words crossing each cell of a horizontal word', () => {
+    expect(board.getCollidingWords({ direction: 'horizontal', word: 'cat', x: 1, y: 1 })).toEqual([
+      { direction: 'vertical', word: 'cod', x: 1, y: 1 },
+    ]);
+  });
+
+  it('finds the words crossing each cell of a vertical word', () => {
+    expect(board.getCollidingWords({ direction: 'vertical', word: 'cod', x: 1, y: 1 })).toEqual([
+      { direction: 'horizontal', word: 'cat', x: 1, y: 1 },
+      { direction: 'horizontal', word: 'dot', x: 1, y: 3 },
+    ]);
+  });
+
+  it('finds a crossing word entered away from its start', () => {
+    expect(board.getCollidingWords({ direction: 'horizontal', word: 'dot', x: 1, y: 3 })).toEqual([
+      { direction: 'vertical', word: 'cod', x: 1, y: 1 },
+    ]);
+  });
+
+  it('returns no words for a word without crossings', () => {
+    const lonely = Board.fromStringArray(['     ', ' cat ', '     ', '     ', '     ']);
+
+    expect(lonely.getCollidingWords({ direction: 'horizontal', word: 'cat', x: 1, y: 1 })).toEqual([]);
+  });
+});

package/packages/types/src/Board.ts

@@ -1,7 +1,9 @@
 import { EMPTY_CELL } from '@scrabble-solver/constants';
 
 import { type BoardJson } from './BoardJson';
+import { type BoardWord } from './BoardWord';
 import { Cell } from './Cell';
+import { getBoardWords, getCollidingWords } from './lib';
 import { Tile } from './Tile';
 
 export class Board {
@@ -95,6 +97,10 @@ export class Board {
     }, 0);
   }
 
+  public getCollidingWords(word: BoardWord): BoardWord[] {
+    return getCollidingWords(this, word);
+  }
+
   public getColumn(index: number): Cell[] {
     return this.rows.map((row) => row[index]);
   }
@@ -109,10 +115,8 @@ export class Board {
     }, 0);
   }
 
-  public getWords(): string[] {
-    const horizontalWords = getHorizontalWords(this.rows);
-    const verticalWords = getHorizontalWords(transpose(this.rows));
-    return [...horizontalWords, ...verticalWords];
+  public getWords(): BoardWord[] {
+    return getBoardWords(this);
   }
 
   public isEmpty(): boolean {
@@ -135,48 +139,3 @@ export class Board {
     this.rows[y] = updateRow(this.rows[y]);
   }
 }
-
-const 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;
-};
-
-const getHorizontalWords = (cells: Cell[][]): string[] => {
-  const words: string[] = [];
-
-  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(wordToString(currentWord));
-        }
-        currentWord = [];
-      }
-    }
-
-    if (currentWord.length > 1) {
-      words.push(wordToString(currentWord));
-    }
-  }
-
-  return words;
-};
-
-const wordToString = (word: Cell[]): string => {
-  return word.map((cell) => cell.tile.character).join('');
-};

package/packages/types/src/BoardJson.ts

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

package/packages/types/src/BoardWord.ts

@@ -0,0 +1,8 @@
+import { type Direction } from './Direction';
+
+export interface BoardWord {
+  direction: Direction;
+  word: string;
+  x: number;
+  y: number;
+}

package/packages/types/src/CellJson.ts

@@ -1,5 +1,4 @@
-import { isObject } from './isObject';
-import { isTileJson, type TileJson } from './TileJson';
+import { type TileJson } from './TileJson';
 
 export interface CellJson {
   isEmpty: boolean;
@@ -7,13 +6,3 @@ export interface CellJson {
   x: number;
   y: number;
 }
-
-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/Game.ts

@@ -6,8 +6,5 @@ export enum Game {
   Scrabble = 'scrabble',
   ScrabbleDuel = 'scrabble-duel',
   SuperScrabble = 'super-scrabble',
+  Wyrazy = 'wyrazy',
 }
-
-const games = Object.values(Game);
-
-export const isGame = (locale: unknown): locale is Game => games.includes(locale as Game);

package/packages/types/src/Locale.ts

@@ -14,7 +14,3 @@ export enum Locale {
   RO_RO = 'ro-RO',
   TR_TR = 'tr-TR',
 }
-
-const locales = Object.values(Locale);
-
-export const isLocale = (locale: unknown): locale is Locale => locales.includes(locale as Locale);

package/packages/types/src/Result.ts

@@ -2,7 +2,7 @@ import { CONSONANTS, VOWELS } from '@scrabble-solver/constants';
 
 import { type Board } from './Board';
 import { type Cell } from './Cell';
-import { readCells, readCollisions } from './readResultCells';
+import { getCells, getCollisions } from './lib';
 import { type ResultJson } from './ResultJson';
 import { type Tile } from './Tile';
 
@@ -10,11 +10,11 @@ type Collision = Cell[];
 
 export class Result {
   public static fromJson = (json: ResultJson, board: Board): Result => {
-    const cells = readCells(json, board);
+    const cells = getCells(board, json);
 
     return new Result({
       cells,
-      collisions: readCollisions(cells, board, json.isHorizontal),
+      collisions: getCollisions(board, cells, json.isHorizontal),
       id: json.id,
       points: json.points,
     });

package/packages/types/src/TileJson.ts

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

package/packages/types/src/index.ts

@@ -1,28 +1,40 @@
-export { Bingo, isBingo, isMultiplierBingo, isScoreBingo } from './Bingo';
+export { Bingo } from './Bingo';
 export { Board } from './Board';
-export { BoardJson, isBoardJson } from './BoardJson';
+export { BoardJson } from './BoardJson';
+export { BoardWord } from './BoardWord';
 export { Bonus } from './Bonus';
 export { BonusJson } from './BonusJson';
 export { BonusValue } from './BonusValue';
 export { Cell } from './Cell';
-export { CellJson, isCellJson } from './CellJson';
+export { CellJson } from './CellJson';
 export { CharacterBonus } from './CharacterBonus';
 export { Collision } from './Collision';
 export { Config } from './Config';
 export { ConfigJson } from './ConfigJson';
 export { Dictionary } from './Dictionary';
 export { Direction } from './Direction';
-export { Game, isGame } from './Game';
-export { isError } from './isError';
-export { isObject } from './isObject';
-export { isLocale, Locale } from './Locale';
+export { Game } from './Game';
+export { isSameBoardWord } from './lib';
+export { Locale } from './Locale';
 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 { TileJson } from './TileJson';
+export {
+  isBingo,
+  isBoardJson,
+  isCellJson,
+  isError,
+  isGame,
+  isLocale,
+  isMultiplierBingo,
+  isObject,
+  isScoreBingo,
+  isTileJson,
+} from './type-guards';
 export { WordBonus } from './WordBonus';
 export { WordDefinition } from './WordDefinition';
 export { WordDefinitionJson } from './WordDefinitionJson';

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

@@ -0,0 +1,11 @@
+import { type Board } from '../Board';
+import { type BoardWord } from '../BoardWord';
+
+import { getWordsInRows } from './getWordsInRows';
+import { transpose } from './transpose';
+
+export function getBoardWords(board: Board): BoardWord[] {
+  const horizontalWords = getWordsInRows(board.rows, 'horizontal');
+  const verticalWords = getWordsInRows(transpose(board.rows), 'vertical');
+  return [...horizontalWords, ...verticalWords];
+}