@scrabble-solver/types 2.8.6 → 2.8.8

package/build/Board.d.ts

@@ -4,9 +4,9 @@ declare class Board {
     static create(width: number, height: number): Board;
     static fromJson(json: BoardJson): Board;
     static fromStringArray(stringArray: string[]): Board;
+    readonly columnsCount: number;
     readonly rows: Cell[][];
-    readonly numberOfColumns: number;
-    readonly numberOfRows: number;
+    readonly rowsCount: number;
     constructor({ rows }: {
         rows: Cell[][];
     });

package/build/Board.js

@@ -9,8 +9,8 @@ const Tile_1 = __importDefault(require("./Tile"));
 class Board {
     constructor({ rows }) {
         this.rows = rows;
-        this.numberOfColumns = rows[0].length;
-        this.numberOfRows = rows.length;
+        this.columnsCount = rows[0].length;
+        this.rowsCount = rows.length;
     }
     static create(width, height) {
         return Board.fromStringArray(Array(height).fill(Array(width).fill(' ').join('')));
@@ -31,8 +31,8 @@ class Board {
         });
     }
     get center() {
-        const x = Math.floor(this.numberOfColumns / 2);
-        const y = Math.floor(this.numberOfRows / 2);
+        const x = Math.floor(this.columnsCount / 2);
+        const y = Math.floor(this.rowsCount / 2);
         return this.rows[y][x];
     }
     clone() {
@@ -43,20 +43,20 @@ class Board {
         return this.collidesUp(cell) || this.collidesDown(cell) || this.collidesLeft(cell) || this.collidesRight(cell);
     }
     collidesDown({ x, y }) {
-        return y < this.numberOfRows - 1 && !this.rows[y + 1][x].isEmpty;
+        return y < this.rowsCount - 1 && !this.rows[y + 1][x].isEmpty;
     }
     collidesLeft({ x, y }) {
         return x > 0 && !this.rows[y][x - 1].isEmpty;
     }
     collidesRight({ x, y }) {
-        return x < this.numberOfColumns - 1 && !this.rows[y][x + 1].isEmpty;
+        return x < this.columnsCount - 1 && !this.rows[y][x + 1].isEmpty;
     }
     collidesUp({ x, y }) {
         return y > 0 && !this.rows[y - 1][x].isEmpty;
     }
     equals(other) {
-        return (this.numberOfColumns === other.numberOfColumns &&
-            this.numberOfRows === other.numberOfRows &&
+        return (this.columnsCount === other.columnsCount &&
+            this.rowsCount === other.rowsCount &&
             this.rows.every((row, rowIndex) => {
                 return row.every((cell, cellIndex) => {
                     return cell.equals(other.rows[rowIndex][cellIndex]);

package/build/BoardJson.d.ts

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

package/build/BoardJson.js

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

package/build/Cell.d.ts

@@ -1,8 +1,7 @@
 import CellJson from './CellJson';
 import Tile from './Tile';
 declare class Cell {
-    static fromJson(json: CellJson | null): Cell;
-    static readonly Null: Cell;
+    static fromJson(json: CellJson): Cell;
     readonly isEmpty: boolean;
     tile: Tile;
     readonly x: number;
@@ -17,7 +16,7 @@ declare class Cell {
     equals(other: Cell): boolean;
     hasTile(): boolean;
     isCandidate(): boolean;
-    toJson(): CellJson | null;
+    toJson(): CellJson;
     toString(): string;
 }
 export default Cell;

package/build/Cell.js

@@ -13,9 +13,6 @@ class Cell {
         this.y = y;
     }
     static fromJson(json) {
-        if (!json) {
-            return Cell.Null;
-        }
         return new Cell({
             isEmpty: json.isEmpty,
             tile: Tile_1.default.fromJson(json.tile),
@@ -52,16 +49,4 @@ class Cell {
         return this.tile.toString();
     }
 }
-Cell.Null = Object.freeze({
-    isEmpty: true,
-    tile: Tile_1.default.Null,
-    x: 0,
-    y: 0,
-    clone: () => Cell.Null,
-    equals: (other) => other === Cell.Null,
-    hasTile: () => false,
-    isCandidate: () => false,
-    toString: () => '',
-    toJson: () => null,
-});
 exports.default = Cell;

package/build/CellJson.d.ts

@@ -5,4 +5,5 @@ interface CellJson {
     x: number;
     y: number;
 }
+export declare const isCellJson: (value: unknown) => value is CellJson;
 export default CellJson;

package/build/CellJson.js

@@ -1,2 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCellJson = void 0;
+const isObject_1 = __importDefault(require("./isObject"));
+const TileJson_1 = require("./TileJson");
+const isCellJson = (value) => {
+    return ((0, isObject_1.default)(value) &&
+        typeof value.isEmpty === 'boolean' &&
+        ((0, TileJson_1.isTileJson)(value.tile) || value.tile === null) &&
+        typeof value.x === 'number' &&
+        typeof value.y === 'number');
+};
+exports.isCellJson = isCellJson;

package/build/Collision.d.ts

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

package/build/Collision.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/CollisionJson.d.ts

@@ -0,0 +1,3 @@
+import CellJson from './CellJson';
+declare type CollisionJson = CellJson[];
+export default CollisionJson;

package/build/CollisionJson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/Config.d.ts

@@ -13,6 +13,7 @@ declare class Config {
     get allTilesBonusScore(): number;
     get alphabet(): string[];
     get blankScore(): number;
+    get blanksCount(): number;
     get boardHeight(): number;
     get boardWidth(): number;
     get twoCharacterTiles(): string[];
@@ -23,8 +24,7 @@ declare class Config {
     getTilePoints(tile: Tile | null): number | undefined;
     hasCharacter(character: string): boolean;
     isTwoCharacterTilePrefix(character: string): boolean;
-    get maximumNumberOfCharacters(): number;
-    get numberOfBlanks(): number;
+    get maximumCharactersCount(): number;
     get tiles(): TileConfig[];
     toJson(): ConfigJson;
 }

package/build/Config.js

@@ -24,6 +24,9 @@ class Config {
     get blankScore() {
         return this.config.blankScore;
     }
+    get blanksCount() {
+        return this.config.blanksCount;
+    }
     get boardHeight() {
         return this.config.boardHeight;
     }
@@ -66,11 +69,8 @@ class Config {
     isTwoCharacterTilePrefix(character) {
         return typeof this.getTwoCharacterTileByPrefix(character) !== 'undefined';
     }
-    get maximumNumberOfCharacters() {
-        return this.config.maximumNumberOfCharacters;
-    }
-    get numberOfBlanks() {
-        return this.config.numberOfBlanks;
+    get maximumCharactersCount() {
+        return this.config.maximumCharactersCount;
     }
     get tiles() {
         return this.config.tiles;

package/build/ConfigJson.d.ts

@@ -3,13 +3,13 @@ import TileConfig from './TileConfig';
 interface ConfigJson {
     allTilesBonusScore: number;
     blankScore: number;
+    blanksCount: number;
     boardHeight: number;
     boardWidth: number;
     bonuses: BonusJson[];
     id: string;
-    maximumNumberOfCharacters: number;
+    maximumCharactersCount: number;
     name: string;
-    numberOfBlanks: number;
     tiles: TileConfig[];
 }
 export default ConfigJson;

package/build/Locale.d.ts

@@ -6,4 +6,5 @@ declare enum Locale {
     PL_PL = "pl-PL",
     DE_DE = "de-DE"
 }
+export declare const isLocale: (locale: unknown) => locale is Locale;
 export default Locale;

package/build/Locale.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocale = void 0;
 // eslint-disable-next-line no-shadow
 var Locale;
 (function (Locale) {
@@ -10,4 +11,7 @@ var Locale;
     Locale["PL_PL"] = "pl-PL";
     Locale["DE_DE"] = "de-DE";
 })(Locale || (Locale = {}));
+const locales = Object.values(Locale);
+const isLocale = (locale) => locales.includes(locale);
+exports.isLocale = isLocale;
 exports.default = Locale;

package/build/Pattern.d.ts

@@ -13,7 +13,7 @@ declare class Pattern {
     clone(): Pattern;
     collides(): boolean;
     getIndexOfFirstCellWithoutTile(): number;
-    getNumberOfEmptyCells(): number;
+    getEmptyCellsCount(): number;
     goesThroughBoardCenter(): boolean;
     hasAtLeast1EmptyCell(): boolean;
     hasAtLeast1NonEmptyCell(): boolean;

package/build/Pattern.js

@@ -6,9 +6,9 @@ class Pattern {
         this.cells = cells;
     }
     canBePlaced(config) {
-        const numberOfEmptyCells = this.getNumberOfEmptyCells();
-        const isNumberOfUsedCellsInRange = numberOfEmptyCells >= 1 && numberOfEmptyCells <= config.maximumNumberOfCharacters;
-        return (isNumberOfUsedCellsInRange &&
+        const emptyCellsCount = this.getEmptyCellsCount();
+        const isUsedCellsCountInRange = emptyCellsCount >= 1 && emptyCellsCount <= config.maximumCharactersCount;
+        return (isUsedCellsCountInRange &&
             (this.hasAtLeast1NonEmptyCell() || this.collides() || (this.goesThroughBoardCenter() && this.board.isEmpty())));
     }
     clone() {
@@ -23,7 +23,7 @@ class Pattern {
     getIndexOfFirstCellWithoutTile() {
         return this.cells.findIndex((cell) => !cell.hasTile());
     }
-    getNumberOfEmptyCells() {
+    getEmptyCellsCount() {
         return this.cells.filter((cell) => cell.isEmpty).length;
     }
     goesThroughBoardCenter() {

package/build/PatternJson.d.ts

@@ -1,6 +1,6 @@
 import CellJson from './CellJson';
 interface PatternJson {
-    cells: (CellJson | null)[];
+    cells: CellJson[];
     collisions: PatternJson[];
     word: string;
 }

package/build/Result.d.ts

@@ -1,26 +1,28 @@
 import Cell from './Cell';
 import ResultJson from './ResultJson';
 import Tile from './Tile';
+declare type Collision = Cell[];
 declare class Result {
     static fromJson(json: ResultJson): Result;
+    readonly blanksCount: number;
     readonly cells: Cell[];
+    readonly collisions: Collision[];
+    readonly consonantsCount: number;
     readonly id: number;
     readonly length: number;
-    readonly numberOfBlanks: number;
-    readonly numberOfCollisions: number;
-    readonly numberOfConsonants: number;
-    readonly numberOfTiles: number;
-    readonly numberOfVowels: number;
-    readonly numberOfWords: number;
     readonly points: number;
     readonly pointsRatio: number;
     readonly tiles: Tile[];
     readonly tilesCharacters: string;
+    readonly tilesCount: number;
+    readonly vowelsCount: number;
     readonly word: string;
-    constructor({ cells, id, numberOfCollisions, points, }: {
+    readonly words: string[];
+    readonly wordsCount: number;
+    constructor({ cells, id, collisions, points, }: {
         cells: Cell[];
         id: number;
-        numberOfCollisions: number;
+        collisions: Collision[];
         points: number;
     });
     toJson(): ResultJson;

package/build/Result.js

@@ -6,28 +6,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const constants_1 = require("@scrabble-solver/constants");
 const Cell_1 = __importDefault(require("./Cell"));
 class Result {
-    constructor({ cells, id, numberOfCollisions, points, }) {
+    constructor({ cells, id, collisions, points, }) {
         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.numberOfCollisions = numberOfCollisions;
-        this.numberOfConsonants = getConsonants(tiles).length;
-        this.numberOfBlanks = getBlanks(tiles).length;
-        this.numberOfTiles = tiles.length;
-        this.numberOfVowels = getVowels(tiles).length;
-        this.numberOfWords = 1 + this.numberOfCollisions;
         this.points = points;
         this.pointsRatio = getPointsRatio(tiles, points);
         this.tiles = tiles;
         this.tilesCharacters = getTilesCharacters(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;
     }
     static fromJson(json) {
         return new Result({
-            cells: json.cells.map(Cell_1.default.fromJson),
             id: json.id,
-            numberOfCollisions: json.numberOfCollisions,
+            cells: json.cells.map(Cell_1.default.fromJson),
+            collisions: json.collisions.map((collision) => collision.map(Cell_1.default.fromJson)),
             points: json.points,
         });
     }
@@ -35,7 +36,7 @@ class Result {
         return {
             cells: this.cells.map((cell) => cell.toJson()),
             id: this.id,
-            numberOfCollisions: this.numberOfCollisions,
+            collisions: this.collisions.map((collision) => collision.map((cell) => cell.toJson())),
             points: this.points,
         };
     }
@@ -50,6 +51,10 @@ const getPointsRatio = (tiles, points) => points / tiles.length;
 const getTiles = (cells) => cells.filter(({ isEmpty }) => isEmpty).map(({ tile }) => tile);
 const getTilesCharacters = (tiles) => getNonBlankCharacters(tiles).sort(charactersComparator).join('');
 const getWord = (cells) => cells.map(String).join('');
+const getWords = (cells, collisions) => [
+    getWord(cells),
+    ...collisions.map((collision) => collision.map(String).join('')),
+];
 const isConsonant = ({ character, isBlank }) => constants_1.CONSONANTS.includes(character) && !isBlank;
 const isVowel = ({ character, isBlank }) => constants_1.VOWELS.includes(character) && !isBlank;
 exports.default = Result;

package/build/ResultJson.d.ts

@@ -1,8 +1,9 @@
 import CellJson from './CellJson';
+import CollisionJson from './CollisionJson';
 interface ResultJson {
-    cells: (CellJson | null)[];
+    cells: CellJson[];
+    collisions: CollisionJson[];
     id: number;
-    numberOfCollisions: number;
     points: number;
 }
 export default ResultJson;

package/build/TileJson.d.ts

@@ -2,4 +2,5 @@ interface TileJson {
     character: string;
     isBlank: boolean;
 }
+export declare const isTileJson: (value: unknown) => value is TileJson;
 export default TileJson;

package/build/TileJson.js

@@ -1,2 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTileJson = void 0;
+const isObject_1 = __importDefault(require("./isObject"));
+const isTileJson = (value) => {
+    return (0, isObject_1.default)(value) && typeof value.character === 'string' && typeof value.isBlank === 'boolean';
+};
+exports.isTileJson = isTileJson;

package/build/index.d.ts

@@ -1,22 +1,25 @@
 export { default as Board } from './Board';
-export { default as BoardJson } from './BoardJson';
+export { default as BoardJson, isBoardJson } from './BoardJson';
 export { default as Bonus } from './Bonus';
 export { default as BonusJson } from './BonusJson';
 export { default as BonusValue } from './BonusValue';
 export { default as Cell } from './Cell';
-export { default as CellJson } from './CellJson';
+export { default as CellJson, isCellJson } from './CellJson';
 export { default as CharacterBonus } from './CharacterBonus';
+export { default as Collision } from './Collision';
+export { default as CollisionJson } from './CollisionJson';
 export { default as Config } from './Config';
 export { default as ConfigJson } from './ConfigJson';
 export { default as HorizontalPattern } from './HorizontalPattern';
-export { default as Locale } from './Locale';
+export { default as isObject } from './isObject';
+export { default as Locale, isLocale } from './Locale';
 export { default as Pattern } from './Pattern';
 export { default as PatternJson } from './PatternJson';
 export { default as Result } from './Result';
 export { default as ResultJson } from './ResultJson';
 export { default as Tile } from './Tile';
 export { default as TileConfig } from './TileConfig';
-export { default as TileJson } from './TileJson';
+export { default as TileJson, isTileJson } from './TileJson';
 export { default as VerticalPattern } from './VerticalPattern';
 export { default as WordBonus } from './WordBonus';
 export { default as WordDefinition } from './WordDefinition';

package/build/index.js

@@ -3,27 +3,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WordDefinition = exports.WordBonus = exports.VerticalPattern = exports.Tile = exports.Result = exports.Pattern = exports.Locale = exports.HorizontalPattern = exports.Config = exports.CharacterBonus = exports.Cell = exports.Bonus = exports.Board = void 0;
+exports.WordDefinition = exports.WordBonus = exports.VerticalPattern = exports.isTileJson = exports.Tile = exports.Result = exports.Pattern = exports.isLocale = exports.Locale = exports.isObject = exports.HorizontalPattern = exports.Config = exports.CharacterBonus = exports.isCellJson = exports.Cell = exports.Bonus = exports.isBoardJson = exports.Board = void 0;
 var Board_1 = require("./Board");
 Object.defineProperty(exports, "Board", { enumerable: true, get: function () { return __importDefault(Board_1).default; } });
+var BoardJson_1 = require("./BoardJson");
+Object.defineProperty(exports, "isBoardJson", { enumerable: true, get: function () { return BoardJson_1.isBoardJson; } });
 var Bonus_1 = require("./Bonus");
 Object.defineProperty(exports, "Bonus", { enumerable: true, get: function () { return __importDefault(Bonus_1).default; } });
 var Cell_1 = require("./Cell");
 Object.defineProperty(exports, "Cell", { enumerable: true, get: function () { return __importDefault(Cell_1).default; } });
+var CellJson_1 = require("./CellJson");
+Object.defineProperty(exports, "isCellJson", { enumerable: true, get: function () { return CellJson_1.isCellJson; } });
 var CharacterBonus_1 = require("./CharacterBonus");
 Object.defineProperty(exports, "CharacterBonus", { enumerable: true, get: function () { return __importDefault(CharacterBonus_1).default; } });
 var Config_1 = require("./Config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return __importDefault(Config_1).default; } });
 var HorizontalPattern_1 = require("./HorizontalPattern");
 Object.defineProperty(exports, "HorizontalPattern", { enumerable: true, get: function () { return __importDefault(HorizontalPattern_1).default; } });
+var isObject_1 = require("./isObject");
+Object.defineProperty(exports, "isObject", { enumerable: true, get: function () { return __importDefault(isObject_1).default; } });
 var Locale_1 = require("./Locale");
 Object.defineProperty(exports, "Locale", { enumerable: true, get: function () { return __importDefault(Locale_1).default; } });
+Object.defineProperty(exports, "isLocale", { enumerable: true, get: function () { return Locale_1.isLocale; } });
 var Pattern_1 = require("./Pattern");
 Object.defineProperty(exports, "Pattern", { enumerable: true, get: function () { return __importDefault(Pattern_1).default; } });
 var Result_1 = require("./Result");
 Object.defineProperty(exports, "Result", { enumerable: true, get: function () { return __importDefault(Result_1).default; } });
 var Tile_1 = require("./Tile");
 Object.defineProperty(exports, "Tile", { enumerable: true, get: function () { return __importDefault(Tile_1).default; } });
+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 __importDefault(VerticalPattern_1).default; } });
 var WordBonus_1 = require("./WordBonus");

package/build/isObject.d.ts

@@ -0,0 +1,2 @@
+declare const isObject: (value: unknown) => value is Record<string, unknown>;
+export default isObject;

package/build/isObject.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isObject = (value) => {
+    return typeof value === 'object' && value !== null;
+};
+exports.default = isObject;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/types",
-  "version": "2.8.6",
+  "version": "2.8.8",
   "description": "Scrabble Solver 2 - Types",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -24,7 +24,7 @@
     "clean:force": "npm run clean && rimraf package-lock.json"
   },
   "dependencies": {
-    "@scrabble-solver/constants": "^2.8.6"
+    "@scrabble-solver/constants": "^2.8.8"
   },
-  "gitHead": "ec130aa77ac64b91ab82e79f130eb69ac561fffa"
+  "gitHead": "e6ced6e98204e49ba69750242643bda52a453635"
 }

package/src/Board.ts

@@ -31,21 +31,21 @@ class Board {
     });
   }
 
-  public readonly rows: Cell[][];
+  public readonly columnsCount: number;
 
-  public readonly numberOfColumns: number;
+  public readonly rows: Cell[][];
 
-  public readonly numberOfRows: number;
+  public readonly rowsCount: number;
 
   constructor({ rows }: { rows: Cell[][] }) {
     this.rows = rows;
-    this.numberOfColumns = rows[0].length;
-    this.numberOfRows = rows.length;
+    this.columnsCount = rows[0].length;
+    this.rowsCount = rows.length;
   }
 
   public get center(): Cell {
-    const x = Math.floor(this.numberOfColumns / 2);
-    const y = Math.floor(this.numberOfRows / 2);
+    const x = Math.floor(this.columnsCount / 2);
+    const y = Math.floor(this.rowsCount / 2);
     return this.rows[y][x];
   }
 
@@ -59,7 +59,7 @@ class Board {
   }
 
   public collidesDown({ x, y }: Cell): boolean {
-    return y < this.numberOfRows - 1 && !this.rows[y + 1][x].isEmpty;
+    return y < this.rowsCount - 1 && !this.rows[y + 1][x].isEmpty;
   }
 
   public collidesLeft({ x, y }: Cell): boolean {
@@ -67,7 +67,7 @@ class Board {
   }
 
   public collidesRight({ x, y }: Cell): boolean {
-    return x < this.numberOfColumns - 1 && !this.rows[y][x + 1].isEmpty;
+    return x < this.columnsCount - 1 && !this.rows[y][x + 1].isEmpty;
   }
 
   public collidesUp({ x, y }: Cell): boolean {
@@ -76,8 +76,8 @@ class Board {
 
   public equals(other: Board): boolean {
     return (
-      this.numberOfColumns === other.numberOfColumns &&
-      this.numberOfRows === other.numberOfRows &&
+      this.columnsCount === other.columnsCount &&
+      this.rowsCount === other.rowsCount &&
       this.rows.every((row, rowIndex) => {
         return row.every((cell, cellIndex) => {
           return cell.equals(other.rows[rowIndex][cellIndex]);

package/src/BoardJson.ts

@@ -1,5 +1,25 @@
-import CellJson from './CellJson';
+import CellJson, { isCellJson } from './CellJson';
 
-type BoardJson = (CellJson | null)[][];
+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;
+};
 
 export default BoardJson;

package/src/Cell.ts

@@ -2,11 +2,7 @@ import CellJson from './CellJson';
 import Tile from './Tile';
 
 class Cell {
-  public static fromJson(json: CellJson | null): Cell {
-    if (!json) {
-      return Cell.Null;
-    }
-
+  public static fromJson(json: CellJson): Cell {
     return new Cell({
       isEmpty: json.isEmpty,
       tile: Tile.fromJson(json.tile),
@@ -15,19 +11,6 @@ class Cell {
     });
   }
 
-  public static readonly Null: Cell = Object.freeze({
-    isEmpty: true,
-    tile: Tile.Null,
-    x: 0,
-    y: 0,
-    clone: () => Cell.Null,
-    equals: (other: Cell) => other === Cell.Null,
-    hasTile: () => false,
-    isCandidate: () => false,
-    toString: () => '',
-    toJson: () => null,
-  });
-
   public readonly isEmpty: boolean;
 
   public tile: Tile;
@@ -65,7 +48,7 @@ class Cell {
     return this.isEmpty && this.hasTile();
   }
 
-  public toJson(): CellJson | null {
+  public toJson(): CellJson {
     return {
       isEmpty: this.isEmpty,
       tile: this.tile.toJson(),

package/src/CellJson.ts

@@ -1,4 +1,5 @@
-import TileJson from './TileJson';
+import isObject from './isObject';
+import TileJson, { isTileJson } from './TileJson';
 
 interface CellJson {
   isEmpty: boolean;
@@ -7,4 +8,14 @@ interface CellJson {
   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'
+  );
+};
+
 export default CellJson;

package/src/Collision.ts

@@ -0,0 +1,5 @@
+import Cell from './Cell';
+
+type Collision = Cell[];
+
+export default Collision;

package/src/CollisionJson.ts

@@ -0,0 +1,5 @@
+import CellJson from './CellJson';
+
+type CollisionJson = CellJson[];
+
+export default CollisionJson;

package/src/Config.ts

@@ -38,6 +38,10 @@ class Config {
     return this.config.blankScore;
   }
 
+  public get blanksCount(): number {
+    return this.config.blanksCount;
+  }
+
   public get boardHeight(): number {
     return this.config.boardHeight;
   }
@@ -94,12 +98,8 @@ class Config {
     return typeof this.getTwoCharacterTileByPrefix(character) !== 'undefined';
   }
 
-  public get maximumNumberOfCharacters(): number {
-    return this.config.maximumNumberOfCharacters;
-  }
-
-  public get numberOfBlanks(): number {
-    return this.config.numberOfBlanks;
+  public get maximumCharactersCount(): number {
+    return this.config.maximumCharactersCount;
   }
 
   public get tiles(): TileConfig[] {

package/src/ConfigJson.ts

@@ -4,13 +4,13 @@ import TileConfig from './TileConfig';
 interface ConfigJson {
   allTilesBonusScore: number;
   blankScore: number;
+  blanksCount: number;
   boardHeight: number;
   boardWidth: number;
   bonuses: BonusJson[];
   id: string;
-  maximumNumberOfCharacters: number;
+  maximumCharactersCount: number;
   name: string;
-  numberOfBlanks: number;
   tiles: TileConfig[];
 }
 

package/src/Locale.ts

@@ -8,4 +8,8 @@ enum Locale {
   DE_DE = 'de-DE',
 }
 
+const locales = Object.values(Locale);
+
+export const isLocale = (locale: unknown): locale is Locale => locales.includes(locale as Locale);
+
 export default Locale;

package/src/Pattern.ts

@@ -14,11 +14,10 @@ class Pattern {
   }
 
   public canBePlaced(config: Config): boolean {
-    const numberOfEmptyCells = this.getNumberOfEmptyCells();
-    const isNumberOfUsedCellsInRange =
-      numberOfEmptyCells >= 1 && numberOfEmptyCells <= config.maximumNumberOfCharacters;
+    const emptyCellsCount = this.getEmptyCellsCount();
+    const isUsedCellsCountInRange = emptyCellsCount >= 1 && emptyCellsCount <= config.maximumCharactersCount;
     return (
-      isNumberOfUsedCellsInRange &&
+      isUsedCellsCountInRange &&
       (this.hasAtLeast1NonEmptyCell() || this.collides() || (this.goesThroughBoardCenter() && this.board.isEmpty()))
     );
   }
@@ -38,7 +37,7 @@ class Pattern {
     return this.cells.findIndex((cell) => !cell.hasTile());
   }
 
-  public getNumberOfEmptyCells(): number {
+  public getEmptyCellsCount(): number {
     return this.cells.filter((cell) => cell.isEmpty).length;
   }
 

package/src/PatternJson.ts

@@ -1,7 +1,7 @@
 import CellJson from './CellJson';
 
 interface PatternJson {
-  cells: (CellJson | null)[];
+  cells: CellJson[];
   collisions: PatternJson[];
   word: string;
 }

package/src/Result.ts

@@ -4,33 +4,29 @@ import Cell from './Cell';
 import ResultJson from './ResultJson';
 import Tile from './Tile';
 
+type Collision = Cell[];
+
 class Result {
   public static fromJson(json: ResultJson): Result {
     return new Result({
-      cells: json.cells.map(Cell.fromJson),
       id: json.id,
-      numberOfCollisions: json.numberOfCollisions,
+      cells: json.cells.map(Cell.fromJson),
+      collisions: json.collisions.map((collision) => collision.map(Cell.fromJson)),
       points: json.points,
     });
   }
 
-  public readonly cells: Cell[];
-
-  public readonly id: number;
-
-  public readonly length: number;
-
-  public readonly numberOfBlanks: number;
+  public readonly blanksCount: number;
 
-  public readonly numberOfCollisions: number;
+  public readonly cells: Cell[];
 
-  public readonly numberOfConsonants: number;
+  public readonly collisions: Collision[];
 
-  public readonly numberOfTiles: number;
+  public readonly consonantsCount: number;
 
-  public readonly numberOfVowels: number;
+  public readonly id: number;
 
-  public readonly numberOfWords: number;
+  public readonly length: number;
 
   public readonly points: number;
 
@@ -40,41 +36,50 @@ class Result {
 
   public readonly tilesCharacters: string;
 
+  public readonly tilesCount: number;
+
+  public readonly vowelsCount: number;
+
   public readonly word: string;
 
+  public readonly words: string[];
+
+  public readonly wordsCount: number;
+
   constructor({
     cells,
     id,
-    numberOfCollisions,
+    collisions,
     points,
   }: {
     cells: Cell[];
     id: number;
-    numberOfCollisions: 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.numberOfCollisions = numberOfCollisions;
-    this.numberOfConsonants = getConsonants(tiles).length;
-    this.numberOfBlanks = getBlanks(tiles).length;
-    this.numberOfTiles = tiles.length;
-    this.numberOfVowels = getVowels(tiles).length;
-    this.numberOfWords = 1 + this.numberOfCollisions;
     this.points = points;
     this.pointsRatio = getPointsRatio(tiles, points);
     this.tiles = tiles;
     this.tilesCharacters = getTilesCharacters(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 {
     return {
       cells: this.cells.map((cell) => cell.toJson()),
       id: this.id,
-      numberOfCollisions: this.numberOfCollisions,
+      collisions: this.collisions.map((collision) => collision.map((cell) => cell.toJson())),
       points: this.points,
     };
   }
@@ -100,6 +105,11 @@ const getTilesCharacters = (tiles: Tile[]): string => getNonBlankCharacters(tile
 
 const getWord = (cells: Cell[]): string => cells.map(String).join('');
 
+const getWords = (cells: Cell[], collisions: Collision[]): string[] => [
+  getWord(cells),
+  ...collisions.map((collision) => collision.map(String).join('')),
+];
+
 const isConsonant = ({ character, isBlank }: Tile): boolean => CONSONANTS.includes(character) && !isBlank;
 
 const isVowel = ({ character, isBlank }: Tile): boolean => VOWELS.includes(character) && !isBlank;

package/src/ResultJson.ts

@@ -1,9 +1,10 @@
 import CellJson from './CellJson';
+import CollisionJson from './CollisionJson';
 
 interface ResultJson {
-  cells: (CellJson | null)[];
+  cells: CellJson[];
+  collisions: CollisionJson[];
   id: number;
-  numberOfCollisions: number;
   points: number;
 }
 

package/src/TileJson.ts

@@ -1,6 +1,12 @@
+import isObject from './isObject';
+
 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';
+};
+
 export default TileJson;

package/src/index.ts

@@ -1,22 +1,25 @@
 export { default as Board } from './Board';
-export { default as BoardJson } from './BoardJson';
+export { default as BoardJson, isBoardJson } from './BoardJson';
 export { default as Bonus } from './Bonus';
 export { default as BonusJson } from './BonusJson';
 export { default as BonusValue } from './BonusValue';
 export { default as Cell } from './Cell';
-export { default as CellJson } from './CellJson';
+export { default as CellJson, isCellJson } from './CellJson';
 export { default as CharacterBonus } from './CharacterBonus';
+export { default as Collision } from './Collision';
+export { default as CollisionJson } from './CollisionJson';
 export { default as Config } from './Config';
 export { default as ConfigJson } from './ConfigJson';
 export { default as HorizontalPattern } from './HorizontalPattern';
-export { default as Locale } from './Locale';
+export { default as isObject } from './isObject';
+export { default as Locale, isLocale } from './Locale';
 export { default as Pattern } from './Pattern';
 export { default as PatternJson } from './PatternJson';
 export { default as Result } from './Result';
 export { default as ResultJson } from './ResultJson';
 export { default as Tile } from './Tile';
 export { default as TileConfig } from './TileConfig';
-export { default as TileJson } from './TileJson';
+export { default as TileJson, isTileJson } from './TileJson';
 export { default as VerticalPattern } from './VerticalPattern';
 export { default as WordBonus } from './WordBonus';
 export { default as WordDefinition } from './WordDefinition';

package/src/isObject.ts

@@ -0,0 +1,5 @@
+const isObject = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === 'object' && value !== null;
+};
+
+export default isObject;