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

package/packages/types/src/CharacterBonus.ts

@@ -0,0 +1,29 @@
+import { BONUS_CHARACTER } from '@scrabble-solver/constants';
+
+import { Bonus } from './Bonus';
+import { type BonusValue } from './BonusValue';
+import { type Cell } from './Cell';
+import { type Config } from './Config';
+
+export class CharacterBonus extends Bonus {
+  public readonly type = BONUS_CHARACTER;
+
+  public canApply(config: Config, cell: Cell): boolean {
+    return super.canApply(config, cell) && this.matchesCellTileScore(config, cell);
+  }
+
+  public matchesCellTileScore(config: Config, cell: Cell): boolean {
+    if (typeof this.score === 'undefined') {
+      return true;
+    }
+
+    return this.score === config.pointsMap[cell.tile.character];
+  }
+
+  public get value(): BonusValue {
+    return {
+      characterMultiplier: this.multiplier,
+      wordMultiplier: 1,
+    };
+  }
+}

package/packages/types/src/Collision.ts

@@ -0,0 +1,3 @@
+import { type Cell } from './Cell';
+
+export type Collision = Cell[];

package/packages/types/src/Config.ts

@@ -0,0 +1,152 @@
+import { BLANK, BONUS_CHARACTER, BONUS_WORD, NO_BONUS } from '@scrabble-solver/constants';
+
+import { type Bingo } from './Bingo';
+import { type Bonus } from './Bonus';
+import { type BonusValue } from './BonusValue';
+import { type Cell } from './Cell';
+import { CharacterBonus } from './CharacterBonus';
+import { type ConfigJson } from './ConfigJson';
+import { type Game } from './Game';
+import { type Locale } from './Locale';
+import { type Tile } from './Tile';
+import { type TileConfig } from './TileConfig';
+import { WordBonus } from './WordBonus';
+
+export class Config {
+  public static fromJson = (json: ConfigJson): Config => {
+    return new Config(json);
+  };
+
+  public readonly bonuses: Bonus[];
+
+  public readonly config: ConfigJson;
+
+  public readonly pointsMap: Record<string, number>;
+
+  constructor(config: ConfigJson) {
+    this.bonuses = getBonuses(config);
+    this.config = config;
+    this.pointsMap = getPointsMap(this.config);
+  }
+
+  public get alphabet(): string[] {
+    return getAlphabet(this.config);
+  }
+
+  public get bingo(): Bingo {
+    return this.config.bingo;
+  }
+
+  public get blankScore(): number {
+    return this.config.blankScore;
+  }
+
+  public get blanksCount(): number {
+    return this.config.blanksCount;
+  }
+
+  public get boardHeight(): number {
+    return this.config.boardHeight;
+  }
+
+  public get boardWidth(): number {
+    return this.config.boardWidth;
+  }
+
+  public get game(): Game {
+    return this.config.game;
+  }
+
+  public get locale(): Locale {
+    return this.config.locale;
+  }
+
+  public get twoCharacterTiles(): string[] {
+    return this.config.tiles.filter((tile) => tile.character.length === 2).map((tile) => tile.character);
+  }
+
+  public getCellBonus(cell: Cell): Bonus | undefined {
+    return this.bonuses.find((bonus) => bonus.matchesCellCoordinates(cell));
+  }
+
+  public getCellBonusValue(cell: Cell): BonusValue {
+    return this.getCellBonus(cell)?.value || NO_BONUS;
+  }
+
+  public getCharacterPoints(character: string | null): number | undefined {
+    if (character === null) {
+      return undefined;
+    }
+
+    if (character === BLANK) {
+      return this.blankScore;
+    }
+
+    return this.pointsMap[character];
+  }
+
+  public getTwoCharacterTileByPrefix(character: string): string | undefined {
+    if (character.length !== 1) {
+      return undefined;
+    }
+
+    return this.twoCharacterTiles.find((characters) => characters.startsWith(character.toLocaleLowerCase()));
+  }
+
+  public getTilePoints(tile: Tile | null): number | undefined {
+    if (tile === null) {
+      return undefined;
+    }
+
+    return tile.isBlank ? this.blankScore : this.getCharacterPoints(tile.character);
+  }
+
+  public hasCharacter(character: string): boolean {
+    return character in this.pointsMap;
+  }
+
+  public isTwoCharacterTilePrefix(character: string): boolean {
+    return typeof this.getTwoCharacterTileByPrefix(character) !== 'undefined';
+  }
+
+  public get rackSize(): number {
+    return this.config.rackSize;
+  }
+
+  public get supportsRemainingTiles(): boolean {
+    return this.tiles.every((tile) => typeof tile.count === 'number');
+  }
+
+  public get tiles(): TileConfig[] {
+    return this.config.tiles;
+  }
+
+  public toJson(): ConfigJson {
+    return this.config;
+  }
+}
+
+const getBonuses = (config: ConfigJson): Bonus[] => {
+  return config.bonuses.map((bonus) => {
+    if (bonus.type === BONUS_CHARACTER) {
+      return new CharacterBonus(bonus);
+    }
+
+    if (bonus.type === BONUS_WORD) {
+      return new WordBonus(bonus);
+    }
+
+    throw new Error(`Unsupported Bonus type: "${bonus.type}"`);
+  });
+};
+
+const getAlphabet = (config: ConfigJson): string[] => config.tiles.map(({ character }) => character);
+
+const getPointsMap = (config: ConfigJson): Record<string, number> =>
+  config.tiles.reduce(
+    (pointsMap, { character, score }) => ({
+      ...pointsMap,
+      [character]: score,
+    }),
+    {},
+  );

package/packages/types/src/ConfigJson.ts

@@ -0,0 +1,19 @@
+import { type Bingo } from './Bingo';
+import { type BonusJson } from './BonusJson';
+import { type Game } from './Game';
+import { type Locale } from './Locale';
+import { type TileConfig } from './TileConfig';
+
+export interface ConfigJson {
+  bingo: Bingo;
+  blankScore: number;
+  blanksCount: number;
+  boardHeight: number;
+  boardWidth: number;
+  bonuses: BonusJson[];
+  game: Game;
+  locale: Locale;
+  name: string;
+  rackSize: number;
+  tiles: TileConfig[];
+}

package/packages/types/src/Dictionary.ts

@@ -0,0 +1,7 @@
+import { type Locale } from './Locale';
+
+export interface Dictionary {
+  description: string;
+  locale: Locale;
+  name: string;
+}

package/packages/types/src/Direction.ts

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

package/packages/types/src/Game.ts

@@ -0,0 +1,11 @@
+export enum Game {
+  Crossplay = 'crossplay',
+  Kelimelik = 'kelimelik',
+  LetterLeague = 'letter-league',
+  Literaki = 'literaki',
+  Scrabble = 'scrabble',
+  ScrabbleDuel = 'scrabble-duel',
+  SuperScrabble = 'super-scrabble',
+  Wordfeud = 'wordfeud',
+  Wyrazy = 'wyrazy',
+}

package/packages/types/src/Locale.ts

@@ -0,0 +1,16 @@
+/**
+ * Locales are defined using IETF language tags
+ * @see https://en.wikipedia.org/wiki/IETF_language_tag
+ * @see https://en.wikipedia.org/wiki/ISO_3166-1
+ */
+export enum Locale {
+  DE_DE = 'de-DE',
+  EN_GB = 'en-GB',
+  EN_US = 'en-US',
+  ES_ES = 'es-ES',
+  FA_IR = 'fa-IR',
+  FR_FR = 'fr-FR',
+  PL_PL = 'pl-PL',
+  RO_RO = 'ro-RO',
+  TR_TR = 'tr-TR',
+}

package/packages/types/src/Result.ts

@@ -0,0 +1,118 @@
+import { CONSONANTS, VOWELS } from '@scrabble-solver/constants';
+
+import { type Board } from './Board';
+import { type Cell } from './Cell';
+import { getCells, getCollisions } from './lib';
+import { type ResultJson } from './ResultJson';
+import { type Tile } from './Tile';
+
+type Collision = Cell[];
+
+export class Result {
+  public static fromJson = (json: ResultJson, board: Board): Result => {
+    const cells = getCells(board, json);
+
+    return new Result({
+      cells,
+      collisions: getCollisions(board, cells, json.isHorizontal),
+      id: json.id,
+      points: json.points,
+    });
+  };
+
+  public readonly blanksCount: number;
+
+  public readonly cells: Cell[];
+
+  public readonly collisions: Collision[];
+
+  public readonly consonantsCount: number;
+
+  public readonly id: number;
+
+  public readonly length: number;
+
+  public readonly points: number;
+
+  public readonly pointsRatio: number;
+
+  public readonly tiles: Tile[];
+
+  public readonly tilesCount: number;
+
+  public readonly vowelsCount: number;
+
+  public readonly word: string;
+
+  public readonly words: string[];
+
+  public readonly wordsCount: number;
+
+  constructor({
+    cells,
+    id,
+    collisions,
+    points,
+  }: {
+    cells: Cell[];
+    id: number;
+    collisions: Collision[];
+    points: number;
+  }) {
+    const tiles = getTiles(cells);
+    this.blanksCount = getBlanks(tiles).length;
+    this.cells = cells;
+    this.collisions = collisions;
+    this.consonantsCount = getConsonants(tiles).length;
+    this.id = id;
+    this.length = cells.length;
+    this.points = points;
+    this.pointsRatio = getPointsRatio(tiles, points);
+    this.tiles = tiles;
+    this.tilesCount = tiles.length;
+    this.vowelsCount = getVowels(tiles).length;
+    this.word = getWord(cells);
+    this.words = getWords(cells, collisions);
+    this.wordsCount = 1 + this.collisions.length;
+  }
+
+  public toJson(): ResultJson {
+    const placed = this.cells.filter((cell) => cell.isEmpty);
+
+    return {
+      blankIndices: placed.flatMap((cell, index) => (cell.tile.isBlank ? [index] : [])),
+      id: this.id,
+      isHorizontal: this.isHorizontal(),
+      points: this.points,
+      tiles: placed.map((cell) => cell.tile.character),
+      x: this.cells[0].x,
+      y: this.cells[0].y,
+    };
+  }
+
+  public isHorizontal(): boolean {
+    return this.cells[0].y === this.cells[1].y;
+  }
+
+  public isVertical(): boolean {
+    return this.cells[0].x === this.cells[1].x;
+  }
+}
+
+const getBlanks = (tiles: Tile[]): Tile[] => tiles.filter(({ isBlank }) => isBlank);
+
+const getConsonants = (tiles: Tile[]): Tile[] => tiles.filter(isConsonant);
+
+const getVowels = (tiles: Tile[]): Tile[] => tiles.filter(isVowel);
+
+const getPointsRatio = (tiles: Tile[], points: number): number => points / tiles.length;
+
+const getTiles = (cells: Cell[]): Tile[] => cells.filter(({ isEmpty }) => isEmpty).map(({ tile }) => tile);
+
+const getWord = (cells: Cell[]): string => cells.reduce((word, cell) => word + cell.toString(), '');
+
+const getWords = (cells: Cell[], collisions: Collision[]): string[] => [cells, ...collisions].map(getWord);
+
+const isConsonant = ({ character, isBlank }: Tile): boolean => CONSONANTS.includes(character) && !isBlank;
+
+const isVowel = ({ character, isBlank }: Tile): boolean => VOWELS.includes(character) && !isBlank;

package/packages/types/src/ResultJson.ts

@@ -0,0 +1,9 @@
+export interface ResultJson {
+  blankIndices: number[];
+  id: number;
+  isHorizontal: boolean;
+  points: number;
+  tiles: string[];
+  x: number;
+  y: number;
+}

package/packages/types/src/ShowCoordinates.ts

@@ -0,0 +1,5 @@
+/**
+ * 'alternative' means columns have numbers and rows have letters
+ * 'original' means columns have letters and rows have numbers
+ */
+export type ShowCoordinates = 'alternative' | 'original';

package/packages/types/src/TextDirection.ts

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

package/packages/types/src/Tile.ts

@@ -0,0 +1,56 @@
+import { EMPTY_CELL } from '@scrabble-solver/constants';
+
+import { type TileJson } from './TileJson';
+
+export class Tile {
+  public static fromJson = (json: TileJson | null): Tile => {
+    if (!json) {
+      return Tile.Null;
+    }
+
+    return new Tile({
+      character: json.character,
+      isBlank: json.isBlank,
+    });
+  };
+
+  public static readonly Null: Tile = Object.freeze({
+    character: EMPTY_CELL,
+    isBlank: false,
+    clone: () => Tile.Null,
+    equals: (other: Tile) => other === Tile.Null,
+    toJson: () => null,
+    toString: () => EMPTY_CELL,
+  });
+
+  public character: string;
+
+  public isBlank: boolean;
+
+  constructor({ character, isBlank = false }: { character: string; isBlank?: boolean }) {
+    this.character = character;
+    this.isBlank = isBlank;
+  }
+
+  public clone(): Tile {
+    return new Tile({
+      character: this.character,
+      isBlank: this.isBlank,
+    });
+  }
+
+  public equals(other: Tile): boolean {
+    return this.character === other.character && this.isBlank === other.isBlank;
+  }
+
+  public toJson(): TileJson | null {
+    return {
+      character: this.character,
+      isBlank: this.isBlank,
+    };
+  }
+
+  public toString(): string {
+    return this.character;
+  }
+}

package/packages/types/src/TileConfig.ts

@@ -0,0 +1,5 @@
+export interface TileConfig {
+  character: string;
+  count?: number;
+  score: number;
+}

package/packages/types/src/TileJson.ts

@@ -0,0 +1,4 @@
+export interface TileJson {
+  character: string;
+  isBlank: boolean;
+}

package/packages/types/src/WordBonus.ts

@@ -0,0 +1,15 @@
+import { BONUS_WORD } from '@scrabble-solver/constants';
+
+import { Bonus } from './Bonus';
+import { type BonusValue } from './BonusValue';
+
+export class WordBonus extends Bonus {
+  public readonly type = BONUS_WORD;
+
+  public get value(): BonusValue {
+    return {
+      characterMultiplier: 1,
+      wordMultiplier: this.multiplier,
+    };
+  }
+}

package/packages/types/src/WordDefinition.ts

@@ -0,0 +1,54 @@
+import { type WordDefinitionJson } from './WordDefinitionJson';
+
+export class WordDefinition {
+  public static fromJson = (json: WordDefinitionJson | null): WordDefinition => {
+    if (!json) {
+      return WordDefinition.Null;
+    }
+
+    return new WordDefinition({
+      definitions: json.definitions,
+      exists: json.exists,
+      isAllowed: json.isAllowed,
+      word: json.word,
+    });
+  };
+
+  public static readonly Null: WordDefinition = Object.freeze({
+    definitions: [],
+    exists: false,
+    isAllowed: false,
+    word: '',
+    toJson: () => null,
+  });
+
+  public readonly definitions: string[];
+
+  /**
+   * Does the word have an entry in a corresponding online dictionary?
+   */
+  public readonly exists: boolean;
+
+  /**
+   * Can the word be legally used in the game?
+   */
+  public readonly isAllowed: boolean;
+
+  public readonly word: string;
+
+  constructor({ definitions, exists, isAllowed, word }: WordDefinitionJson) {
+    this.definitions = definitions;
+    this.exists = exists;
+    this.isAllowed = isAllowed;
+    this.word = word;
+  }
+
+  public toJson(): WordDefinitionJson | null {
+    return {
+      definitions: this.definitions,
+      exists: this.exists,
+      isAllowed: this.isAllowed,
+      word: this.word,
+    };
+  }
+}

package/packages/types/src/WordDefinitionJson.ts

@@ -0,0 +1,12 @@
+export interface WordDefinitionJson {
+  definitions: string[];
+  /**
+   * Does the word have an entry in a corresponding online dictionary?
+   */
+  exists: boolean;
+  /**
+   * Can the word be legally used in the game?
+   */
+  isAllowed: boolean;
+  word: string;
+}

package/packages/types/src/index.ts

@@ -0,0 +1,40 @@
+export { Bingo } from './Bingo';
+export { Board } from './Board';
+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 } 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 } 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 { 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];
+}