@scrabble-solver/types 2.15.11 → 2.15.13

package/build/Board.d.ts

@@ -1,4 +1,4 @@
-import { BoardJson } from './BoardJson';
+import { type BoardJson } from './BoardJson';
 import { Cell } from './Cell';
 export declare class Board {
     static create: (width: number, height: number) => Board;

package/build/Board.js

@@ -70,20 +70,9 @@ class Board {
         }, 0);
     }
     getWords() {
-        const columns = [];
-        for (let x = 0; x < this.columnsCount; ++x) {
-            const column = [];
-            for (let y = 0; y < this.rowsCount; ++y) {
-                column.push(this.rows[y][x]);
-            }
-            columns.push(column);
-        }
-        const columnsBoard = new Board({ rows: columns });
-        const lines = this.toString().split('\n').concat(columnsBoard.toString().split('\n'));
-        const words = lines
-            .flatMap((line) => line.replaceAll(/\s+/g, constants_1.EMPTY_CELL).split(' '))
-            .filter((word) => word.length > 1);
-        return words;
+        const horizontalWords = getHorizontalWords(this.rows);
+        const verticalWords = getHorizontalWords(transpose(this.rows));
+        return [...horizontalWords, ...verticalWords];
     }
     isEmpty() {
         return this.rows.every((row) => row.every(({ isEmpty }) => isEmpty));
@@ -113,3 +102,40 @@ Board.fromJson = (json) => {
         rows: json.map((row) => row.map(Cell_1.Cell.fromJson)),
     });
 };
+const 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;
+};
+const getHorizontalWords = (cells) => {
+    const words = [];
+    for (const row of cells) {
+        let currentWord = [];
+        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) => {
+    return word.map((cell) => cell.tile.character).join('');
+};

package/build/BoardJson.d.ts

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

package/build/Bonus.d.ts

@@ -1,7 +1,7 @@
-import { BONUS_CHARACTER, BONUS_WORD } from '@scrabble-solver/constants';
-import { BonusJson } from './BonusJson';
-import { BonusValue } from './BonusValue';
-import { Cell } from './Cell';
+import { type BONUS_CHARACTER, type BONUS_WORD } from '@scrabble-solver/constants';
+import { type BonusJson } from './BonusJson';
+import { type BonusValue } from './BonusValue';
+import { type Cell } from './Cell';
 import { type Config } from './Config';
 export declare abstract class Bonus {
     readonly multiplier: number;

package/build/Cell.d.ts

@@ -1,4 +1,4 @@
-import { CellJson } from './CellJson';
+import { type CellJson } from './CellJson';
 import { Tile } from './Tile';
 export declare class Cell {
     static fromJson: (json: CellJson) => Cell;

package/build/CellJson.d.ts

@@ -1,4 +1,4 @@
-import { TileJson } from './TileJson';
+import { type TileJson } from './TileJson';
 export interface CellJson {
     isEmpty: boolean;
     tile: TileJson | null;

package/build/CharacterBonus.d.ts

@@ -1,6 +1,6 @@
 import { Bonus } from './Bonus';
-import { BonusValue } from './BonusValue';
-import { Cell } from './Cell';
+import { type BonusValue } from './BonusValue';
+import { type Cell } from './Cell';
 import { type Config } from './Config';
 export declare class CharacterBonus extends Bonus {
     readonly type = "BONUS_CHARACTER";

package/build/Collision.d.ts

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

package/build/CollisionJson.d.ts

@@ -1,2 +1,2 @@
-import { CellJson } from './CellJson';
+import { type CellJson } from './CellJson';
 export type CollisionJson = CellJson[];

package/build/Config.d.ts

@@ -1,12 +1,12 @@
-import { Bingo } from './Bingo';
-import { Bonus } from './Bonus';
-import { BonusValue } from './BonusValue';
-import { Cell } from './Cell';
-import { ConfigJson } from './ConfigJson';
-import { Game } from './Game';
-import { Locale } from './Locale';
-import { Tile } from './Tile';
-import { TileConfig } from './TileConfig';
+import { type Bingo } from './Bingo';
+import { type Bonus } from './Bonus';
+import { type BonusValue } from './BonusValue';
+import { type Cell } from './Cell';
+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';
 export declare class Config {
     static fromJson: (json: ConfigJson) => Config;
     readonly bonuses: Bonus[];

package/build/ConfigJson.d.ts

@@ -1,8 +1,8 @@
-import { Bingo } from './Bingo';
-import { BonusJson } from './BonusJson';
-import { Game } from './Game';
-import { Locale } from './Locale';
-import { TileConfig } from './TileConfig';
+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;

package/build/Dictionary.d.ts

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

package/build/Pattern.d.ts

@@ -1,7 +1,7 @@
-import { Board } from './Board';
-import { Cell } from './Cell';
-import { Config } from './Config';
-import { PatternJson } from './PatternJson';
+import { type Board } from './Board';
+import { type Cell } from './Cell';
+import { type Config } from './Config';
+import { type PatternJson } from './PatternJson';
 export declare class Pattern {
     readonly board: Board;
     readonly cells: Cell[];

package/build/PatternJson.d.ts

@@ -1,4 +1,4 @@
-import { CellJson } from './CellJson';
+import { type CellJson } from './CellJson';
 export interface PatternJson {
     cells: CellJson[];
     collisions: PatternJson[];

package/build/Result.d.ts

@@ -1,6 +1,6 @@
 import { Cell } from './Cell';
-import { ResultJson } from './ResultJson';
-import { Tile } from './Tile';
+import { type ResultJson } from './ResultJson';
+import { type Tile } from './Tile';
 type Collision = Cell[];
 export declare class Result {
     static fromJson: (json: ResultJson) => Result;
@@ -25,5 +25,7 @@ export declare class Result {
         points: number;
     });
     toJson(): ResultJson;
+    isHorizontal(): boolean;
+    isVertical(): boolean;
 }
 export {};

package/build/Result.js

@@ -29,6 +29,12 @@ class Result {
             points: this.points,
         };
     }
+    isHorizontal() {
+        return this.cells[0].y === this.cells[1].y;
+    }
+    isVertical() {
+        return this.cells[0].x === this.cells[1].x;
+    }
 }
 exports.Result = Result;
 Result.fromJson = (json) => {

package/build/ResultJson.d.ts

@@ -1,5 +1,5 @@
-import { CellJson } from './CellJson';
-import { CollisionJson } from './CollisionJson';
+import { type CellJson } from './CellJson';
+import { type CollisionJson } from './CollisionJson';
 export interface ResultJson {
     cells: CellJson[];
     collisions: CollisionJson[];

package/build/Tile.d.ts

@@ -1,4 +1,4 @@
-import { TileJson } from './TileJson';
+import { type TileJson } from './TileJson';
 export declare class Tile {
     static fromJson: (json: TileJson | null) => Tile;
     static readonly Null: Tile;

package/build/WordBonus.d.ts

@@ -1,5 +1,5 @@
 import { Bonus } from './Bonus';
-import { BonusValue } from './BonusValue';
+import { type BonusValue } from './BonusValue';
 export declare class WordBonus extends Bonus {
     readonly type = "BONUS_WORD";
     get value(): BonusValue;

package/build/WordDefinition.d.ts

@@ -1,4 +1,4 @@
-import { WordDefinitionJson } from './WordDefinitionJson';
+import { type WordDefinitionJson } from './WordDefinitionJson';
 export declare class WordDefinition {
     static fromJson: (json: WordDefinitionJson | null) => WordDefinition;
     static readonly Null: WordDefinition;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/types",
-  "version": "2.15.11",
+  "version": "2.15.13",
   "description": "Scrabble Solver 2 - Types",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -23,7 +23,7 @@
     "clean": "rimraf build/"
   },
   "dependencies": {
-    "@scrabble-solver/constants": "^2.15.11"
+    "@scrabble-solver/constants": "^2.15.13"
   },
-  "gitHead": "4fa527098d5e67120adb7964777c044a09378332"
+  "gitHead": "fd3e02f7051acdb8cc6dd138a959679bc00f1ed6"
 }

package/src/Board.ts

@@ -1,6 +1,6 @@
 import { EMPTY_CELL } from '@scrabble-solver/constants';
 
-import { BoardJson } from './BoardJson';
+import { type BoardJson } from './BoardJson';
 import { Cell } from './Cell';
 import { Tile } from './Tile';
 
@@ -110,25 +110,9 @@ export class Board {
   }
 
   public getWords(): string[] {
-    const columns: Cell[][] = [];
-
-    for (let x = 0; x < this.columnsCount; ++x) {
-      const column: Cell[] = [];
-
-      for (let y = 0; y < this.rowsCount; ++y) {
-        column.push(this.rows[y][x]);
-      }
-
-      columns.push(column);
-    }
-
-    const columnsBoard = new Board({ rows: columns });
-    const lines = this.toString().split('\n').concat(columnsBoard.toString().split('\n'));
-    const words = lines
-      .flatMap((line) => line.replaceAll(/\s+/g, EMPTY_CELL).split(' '))
-      .filter((word) => word.length > 1);
-
-    return words;
+    const horizontalWords = getHorizontalWords(this.rows);
+    const verticalWords = getHorizontalWords(transpose(this.rows));
+    return [...horizontalWords, ...verticalWords];
   }
 
   public isEmpty(): boolean {
@@ -151,3 +135,48 @@ 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/src/BoardJson.ts

@@ -1,4 +1,4 @@
-import { CellJson, isCellJson } from './CellJson';
+import { type CellJson, isCellJson } from './CellJson';
 
 export type BoardJson = CellJson[][];
 

package/src/Bonus.ts

@@ -1,8 +1,8 @@
-import { BONUS_CHARACTER, BONUS_WORD } from '@scrabble-solver/constants';
+import { type BONUS_CHARACTER, type BONUS_WORD } from '@scrabble-solver/constants';
 
-import { BonusJson } from './BonusJson';
-import { BonusValue } from './BonusValue';
-import { Cell } from './Cell';
+import { type BonusJson } from './BonusJson';
+import { type BonusValue } from './BonusValue';
+import { type Cell } from './Cell';
 import { type Config } from './Config';
 
 export abstract class Bonus {

package/src/Cell.ts

@@ -1,4 +1,4 @@
-import { CellJson } from './CellJson';
+import { type CellJson } from './CellJson';
 import { Tile } from './Tile';
 
 export class Cell {

package/src/CellJson.ts

@@ -1,5 +1,5 @@
 import { isObject } from './isObject';
-import { isTileJson, TileJson } from './TileJson';
+import { isTileJson, type TileJson } from './TileJson';
 
 export interface CellJson {
   isEmpty: boolean;

package/src/CharacterBonus.ts

@@ -1,8 +1,8 @@
 import { BONUS_CHARACTER } from '@scrabble-solver/constants';
 
 import { Bonus } from './Bonus';
-import { BonusValue } from './BonusValue';
-import { Cell } from './Cell';
+import { type BonusValue } from './BonusValue';
+import { type Cell } from './Cell';
 import { type Config } from './Config';
 
 export class CharacterBonus extends Bonus {

package/src/Collision.ts

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

package/src/CollisionJson.ts

@@ -1,3 +1,3 @@
-import { CellJson } from './CellJson';
+import { type CellJson } from './CellJson';
 
 export type CollisionJson = CellJson[];

package/src/Config.ts

@@ -1,15 +1,15 @@
 import { BLANK, BONUS_CHARACTER, BONUS_WORD, NO_BONUS } from '@scrabble-solver/constants';
 
-import { Bingo } from './Bingo';
-import { Bonus } from './Bonus';
-import { BonusValue } from './BonusValue';
-import { Cell } from './Cell';
+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 { ConfigJson } from './ConfigJson';
-import { Game } from './Game';
-import { Locale } from './Locale';
-import { Tile } from './Tile';
-import { TileConfig } from './TileConfig';
+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 {

package/src/ConfigJson.ts

@@ -1,8 +1,8 @@
-import { Bingo } from './Bingo';
-import { BonusJson } from './BonusJson';
-import { Game } from './Game';
-import { Locale } from './Locale';
-import { TileConfig } from './TileConfig';
+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;

package/src/Dictionary.ts

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

package/src/Pattern.ts

@@ -1,7 +1,7 @@
-import { Board } from './Board';
-import { Cell } from './Cell';
-import { Config } from './Config';
-import { PatternJson } from './PatternJson';
+import { type Board } from './Board';
+import { type Cell } from './Cell';
+import { type Config } from './Config';
+import { type PatternJson } from './PatternJson';
 
 export class Pattern {
   public readonly board: Board;

package/src/PatternJson.ts

@@ -1,4 +1,4 @@
-import { CellJson } from './CellJson';
+import { type CellJson } from './CellJson';
 
 export interface PatternJson {
   cells: CellJson[];

package/src/Result.ts

@@ -1,8 +1,8 @@
 import { CONSONANTS, VOWELS } from '@scrabble-solver/constants';
 
 import { Cell } from './Cell';
-import { ResultJson } from './ResultJson';
-import { Tile } from './Tile';
+import { type ResultJson } from './ResultJson';
+import { type Tile } from './Tile';
 
 type Collision = Cell[];
 
@@ -80,6 +80,14 @@ export class Result {
       points: this.points,
     };
   }
+
+  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);

package/src/ResultJson.ts

@@ -1,5 +1,5 @@
-import { CellJson } from './CellJson';
-import { CollisionJson } from './CollisionJson';
+import { type CellJson } from './CellJson';
+import { type CollisionJson } from './CollisionJson';
 
 export interface ResultJson {
   cells: CellJson[];

package/src/Tile.ts

@@ -1,6 +1,6 @@
 import { EMPTY_CELL } from '@scrabble-solver/constants';
 
-import { TileJson } from './TileJson';
+import { type TileJson } from './TileJson';
 
 export class Tile {
   public static fromJson = (json: TileJson | null): Tile => {

package/src/WordBonus.ts

@@ -1,7 +1,7 @@
 import { BONUS_WORD } from '@scrabble-solver/constants';
 
 import { Bonus } from './Bonus';
-import { BonusValue } from './BonusValue';
+import { type BonusValue } from './BonusValue';
 
 export class WordBonus extends Bonus {
   public readonly type = BONUS_WORD;

package/src/WordDefinition.ts

@@ -1,4 +1,4 @@
-import { WordDefinitionJson } from './WordDefinitionJson';
+import { type WordDefinitionJson } from './WordDefinitionJson';
 
 export class WordDefinition {
   public static fromJson = (json: WordDefinitionJson | null): WordDefinition => {