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

package/packages/types/src/CharacterBonus.ts

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

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

package/packages/types/src/Config.ts

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

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

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

package/packages/types/src/Direction.ts

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

package/packages/types/src/Game.ts

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

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

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

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

package/packages/types/src/ShowCoordinates.ts

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

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

package/packages/types/src/Tile.ts

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

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

package/packages/types/src/TileJson.ts

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

package/packages/types/src/WordBonus.ts

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

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

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

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

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