scrabble-solver 2.15.9 → 2.15.11

package/packages/solver/src/generateVerticalPatterns.ts

@@ -1,16 +1,15 @@
 import { Board, Config, Pattern, VerticalPattern } from '@scrabble-solver/types';
 
-import generatePattern from './generatePattern';
-import generateVectors from './generateVectors';
+import { generatePattern } from './generatePattern';
+import { generateVectors } from './generateVectors';
 
-const generateVerticalPatterns = (config: Config, board: Board): Pattern[] => {
+export const generateVerticalPatterns = (config: Config, board: Board): Pattern[] => {
   const getNthVector = (index: number) => board.getColumn(index);
-  const verticalVectors = generateVectors({ getNthVector, vectorsCount: config.boardSize });
+  const vectorsCount = config.boardWidth;
+  const verticalVectors = generateVectors({ getNthVector, vectorsCount });
   const verticalPatterns = verticalVectors.flatMap((cells) => {
     return generatePattern({ board, config, PatternModel: VerticalPattern, cells });
   });
 
   return verticalPatterns;
 };
-
-export default generateVerticalPatterns;

package/packages/solver/src/getCellsScore.ts

@@ -1,7 +1,7 @@
 import { NO_BONUS } from '@scrabble-solver/constants';
 import { Cell, Config } from '@scrabble-solver/types';
 
-const getCellsScore = (config: Config, cells: Cell[]): number => {
+export const getCellsScore = (config: Config, cells: Cell[]): number => {
   const total = cells.reduce(
     ({ multiplier, score }, cell: Cell): { multiplier: number; score: number } => {
       const bonus = config.getCellBonus(cell);
@@ -19,5 +19,3 @@ const getCellsScore = (config: Config, cells: Cell[]): number => {
 
   return total.score * total.multiplier;
 };
-
-export default getCellsScore;

package/packages/solver/src/getPatternHash.test.ts

@@ -1,6 +1,6 @@
 import { Board, Cell, Pattern, Tile } from '@scrabble-solver/types';
 
-import getPatternHash from './getPatternHash';
+import { getPatternHash } from './getPatternHash';
 
 describe('getPatternHash', () => {
   const board = Board.fromStringArray([' t ', 'do ', '   ']);

package/packages/solver/src/getPatternHash.ts

@@ -1,6 +1,6 @@
 import { Pattern } from '@scrabble-solver/types';
 
-const getPatternHash = (pattern: Pattern): string => {
+export const getPatternHash = (pattern: Pattern): string => {
   return pattern.cells
     .filter((cell) => cell.isEmpty)
     .map((cell) => {
@@ -10,5 +10,3 @@ const getPatternHash = (pattern: Pattern): string => {
     })
     .join('-');
 };
-
-export default getPatternHash;

package/packages/solver/src/getPatternScore.test.ts

@@ -1,70 +1,156 @@
 import { getConfig } from '@scrabble-solver/configs';
 import { Board, Cell, Game, HorizontalPattern, Locale, Pattern, Tile, VerticalPattern } from '@scrabble-solver/types';
 
-import getPatternScore from './getPatternScore';
-
-const locale = Locale.PL_PL;
-const config = getConfig(Game.Literaki, locale);
-const board = Board.fromStringArray([
-  ' kasom         ',
-  '     i         ',
-  '     napiją    ',
-  '  w  i         ',
-  ' krabim        ',
-  '  z            ',
-  '  ę  eh        ',
-  'f s srać       ',
-  'i z t       s  ',
-  'knebel      e  ',
-  'a  ew     warcz',
-  'ł  żyło  wody  ',
-  'o     pecyj chu',
-  '            y  ',
-  '            t  ',
-]);
+import { getPatternScore } from './getPatternScore';
 
 describe('getPatternScore', () => {
-  it('gives proper score without collisions', () => {
-    const pattern = new Pattern(board, [
-      new Cell({ x: 0, y: 0, tile: new Tile({ character: 'ź' }), isEmpty: true }),
-      new Cell({ x: 1, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-      new Cell({ x: 2, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-      new Cell({ x: 3, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-      new Cell({ x: 4, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-      new Cell({ x: 5, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-      new Cell({ x: 6, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-      new Cell({ x: 7, y: 0, tile: new Tile({ character: 'ź' }), isEmpty: false }),
+  describe('Literaki - PL_PL', () => {
+    const config = getConfig(Game.Literaki, Locale.PL_PL);
+    const board = Board.fromStringArray([
+      ' kasom         ',
+      '     i         ',
+      '     napiją    ',
+      '  w  i         ',
+      ' krabim        ',
+      '  z            ',
+      '  ę  eh        ',
+      'f s srać       ',
+      'i z t       s  ',
+      'knebel      e  ',
+      'a  ew     warcz',
+      'ł  żyło  wody  ',
+      'o     pecyj chu',
+      '            y  ',
+      '            t  ',
     ]);
 
-    expect(getPatternScore(config, pattern)).toBe(128);
-  });
+    it('gives proper score without collisions (źaaaaaaź)', () => {
+      const pattern = new Pattern(board, [
+        new Cell({ x: 0, y: 0, tile: new Tile({ character: 'ź' }), isEmpty: true }),
+        new Cell({ x: 1, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 2, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 3, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 4, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 5, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 6, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 7, y: 0, tile: new Tile({ character: 'ź' }), isEmpty: false }),
+      ]);
 
-  it('gives proper score with collisions', () => {
-    const pattern = new VerticalPattern(board, [
-      new Cell({ x: 2, y: 11, tile: new Tile({ character: 'l' }), isEmpty: true }),
-      new Cell({ x: 2, y: 12, tile: new Tile({ character: 'i' }), isEmpty: true }),
-      new Cell({ x: 2, y: 13, tile: new Tile({ character: 'n' }), isEmpty: true }),
-      new Cell({ x: 2, y: 14, tile: new Tile({ character: 'o' }), isEmpty: true }),
-    ]);
+      expect(getPatternScore(config, pattern)).toBe(128);
+    });
 
-    expect(getPatternScore(config, pattern)).toBe(44);
-  });
+    it('gives proper score with collisions (źaaaaaaź)', () => {
+      const pattern = new HorizontalPattern(board, [
+        new Cell({ x: 0, y: 0, tile: new Tile({ character: 'ź' }), isEmpty: true }),
+        new Cell({ x: 1, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 2, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 3, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 4, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 5, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 6, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 7, y: 0, tile: new Tile({ character: 'ź' }), isEmpty: false }),
+      ]);
 
-  it('gives proper score for blank', () => {
-    const pattern = new HorizontalPattern(board, [
-      new Cell({ x: 13, y: 14, tile: new Tile({ character: 'o', isBlank: true }), isEmpty: true }),
-      new Cell({ x: 12, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
-    ]);
+      expect(getPatternScore(config, pattern)).toBe(133);
+    });
+
+    it('gives proper score with collisions (lino)', () => {
+      const pattern = new VerticalPattern(board, [
+        new Cell({ x: 2, y: 11, tile: new Tile({ character: 'l' }), isEmpty: true }),
+        new Cell({ x: 2, y: 12, tile: new Tile({ character: 'i' }), isEmpty: true }),
+        new Cell({ x: 2, y: 13, tile: new Tile({ character: 'n' }), isEmpty: true }),
+        new Cell({ x: 2, y: 14, tile: new Tile({ character: 'o' }), isEmpty: true }),
+      ]);
+
+      expect(getPatternScore(config, pattern)).toBe(44);
+    });
+
+    it('gives proper score for blank', () => {
+      const pattern = new HorizontalPattern(board, [
+        new Cell({ x: 13, y: 14, tile: new Tile({ character: 'o', isBlank: true }), isEmpty: true }),
+        new Cell({ x: 12, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
+      ]);
+
+      expect(getPatternScore(config, pattern)).toBe(2);
+    });
 
-    expect(getPatternScore(config, pattern)).toBe(2);
+    it('gives 0 score for unknown characters', () => {
+      const pattern = new HorizontalPattern(board, [
+        new Cell({ x: 13, y: 14, tile: new Tile({ character: '?', isBlank: false }), isEmpty: true }),
+        new Cell({ x: 12, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
+      ]);
+
+      expect(getPatternScore(config, pattern)).toBe(2);
+    });
+
+    it('gives 50 points bonus for bingo', () => {
+      const pattern = new HorizontalPattern(board, [
+        new Cell({ x: 6, y: 14, tile: new Tile({ character: 'p' }), isEmpty: true }),
+        new Cell({ x: 7, y: 14, tile: new Tile({ character: 'o' }), isEmpty: true }),
+        new Cell({ x: 8, y: 14, tile: new Tile({ character: 'r' }), isEmpty: true }),
+        new Cell({ x: 9, y: 14, tile: new Tile({ character: 'o' }), isEmpty: true }),
+        new Cell({ x: 10, y: 14, tile: new Tile({ character: 'w' }), isEmpty: true }),
+        new Cell({ x: 11, y: 14, tile: new Tile({ character: 'a', isBlank: true }), isEmpty: true }),
+        new Cell({ x: 11, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
+        new Cell({ x: 13, y: 14, tile: new Tile({ character: 'e' }), isEmpty: true }),
+      ]);
+
+      expect(getPatternScore(config, pattern)).toBe(59);
+    });
   });
 
-  it('gives 0 score for unknown characters', () => {
-    const pattern = new HorizontalPattern(board, [
-      new Cell({ x: 13, y: 14, tile: new Tile({ character: '?', isBlank: false }), isEmpty: true }),
-      new Cell({ x: 12, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
-    ]);
+  describe('Letter League - EN_US', () => {
+    const config = getConfig(Game.LetterLeague, Locale.EN_US);
+
+    it('gives double multiplier bonus for bingo without collisions', () => {
+      const board = Board.create(config.boardWidth, config.boardHeight);
+      const pattern = new HorizontalPattern(board, [
+        new Cell({ x: 13, y: 6, tile: new Tile({ character: 'r' }), isEmpty: true }),
+        new Cell({ x: 13, y: 7, tile: new Tile({ character: 'o' }), isEmpty: true }),
+        new Cell({ x: 13, y: 8, tile: new Tile({ character: 'm' }), isEmpty: true }),
+        new Cell({ x: 13, y: 9, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 13, y: 10, tile: new Tile({ character: 'i' }), isEmpty: true }),
+        new Cell({ x: 13, y: 11, tile: new Tile({ character: 'n' }), isEmpty: true }),
+        new Cell({ x: 13, y: 12, tile: new Tile({ character: 'e' }), isEmpty: true }),
+      ]);
+
+      expect(getPatternScore(config, pattern)).toBe(18);
+    });
+
+    it('gives double multiplier bonus for bingo with collisions', () => {
+      const board = Board.fromStringArray([
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '           on              ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+      ]);
+
+      const pattern = new VerticalPattern(board, [
+        new Cell({ x: 13, y: 6, tile: new Tile({ character: 'r' }), isEmpty: true }),
+        new Cell({ x: 13, y: 7, tile: new Tile({ character: 'o' }), isEmpty: true }),
+        new Cell({ x: 13, y: 8, tile: new Tile({ character: 'm' }), isEmpty: true }),
+        new Cell({ x: 13, y: 9, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 13, y: 10, tile: new Tile({ character: 'i' }), isEmpty: true }),
+        new Cell({ x: 13, y: 11, tile: new Tile({ character: 'n' }), isEmpty: true }),
+        new Cell({ x: 13, y: 12, tile: new Tile({ character: 'e' }), isEmpty: true }),
+      ]);
 
-    expect(getPatternScore(config, pattern)).toBe(2);
+      expect(getPatternScore(config, pattern)).toBe(21);
+    });
   });
 });

package/packages/solver/src/getPatternScore.ts

@@ -1,15 +1,23 @@
-import { Config, Pattern } from '@scrabble-solver/types';
+import { Config, isMultiplierBingo, isScoreBingo, Pattern } from '@scrabble-solver/types';
 
-import getCellsScore from './getCellsScore';
+import { getCellsScore } from './getCellsScore';
 
-const getPatternScore = (config: Config, pattern: Pattern) => {
+export const getPatternScore = (config: Config, pattern: Pattern) => {
   const areAllTilesUsed = pattern.getEmptyCellsCount() === config.rackSize;
-  const bonusScore = areAllTilesUsed ? config.bingoScore : 0;
-  const score = pattern
+  const baseScore = getCellsScore(config, pattern.cells);
+  const collisionsScore = pattern
     .getCollisions()
-    .reduce((sum, collision) => sum + getCellsScore(config, collision.cells), getCellsScore(config, pattern.cells));
+    .reduce((sum, collision) => sum + getCellsScore(config, collision.cells), 0);
 
-  return score + bonusScore;
-};
+  if (areAllTilesUsed) {
+    if (isScoreBingo(config.bingo)) {
+      return baseScore + collisionsScore + config.bingo.score;
+    }
+
+    if (isMultiplierBingo(config.bingo)) {
+      return baseScore * config.bingo.multiplier + collisionsScore;
+    }
+  }
 
-export default getPatternScore;
+  return baseScore + collisionsScore;
+};

package/packages/solver/src/getUniquePatterns.ts

@@ -1,8 +1,8 @@
 import { Pattern } from '@scrabble-solver/types';
 
-import getPatternHash from './getPatternHash';
+import { getPatternHash } from './getPatternHash';
 
-const getUniquePatterns = (patterns: Pattern[]): Pattern[] => {
+export const getUniquePatterns = (patterns: Pattern[]): Pattern[] => {
   const hashes = new Set<string>();
   const uniquePatterns: Pattern[] = [];
 
@@ -17,5 +17,3 @@ const getUniquePatterns = (patterns: Pattern[]): Pattern[] => {
 
   return uniquePatterns;
 };
-
-export default getUniquePatterns;

package/packages/solver/src/index.ts

@@ -1,14 +1,14 @@
-export { default as areDigraphsValid } from './areDigraphsValid';
-export { default as fillPattern } from './fillPattern';
-export { default as generateEndIndices } from './generateEndIndices';
-export { default as generateHorizontalPatterns } from './generateHorizontalPatterns';
-export { default as generatePattern } from './generatePattern';
-export { default as generatePatterns } from './generatePatterns';
-export { default as generateStartIndices } from './generateStartIndices';
-export { default as generateVectors } from './generateVectors';
-export { default as generateVerticalPatterns } from './generateVerticalPatterns';
-export { default as getCellsScore } from './getCellsScore';
-export { default as getPatternHash } from './getPatternHash';
-export { default as getPatternScore } from './getPatternScore';
-export { default as getUniquePatterns } from './getUniquePatterns';
-export { default as solve } from './solve';
+export { areDigraphsValid } from './areDigraphsValid';
+export { fillPattern } from './fillPattern';
+export { generateEndIndices } from './generateEndIndices';
+export { generateHorizontalPatterns } from './generateHorizontalPatterns';
+export { generatePattern } from './generatePattern';
+export { generatePatterns } from './generatePatterns';
+export { generateStartIndices } from './generateStartIndices';
+export { generateVectors } from './generateVectors';
+export { generateVerticalPatterns } from './generateVerticalPatterns';
+export { getCellsScore } from './getCellsScore';
+export { getPatternHash } from './getPatternHash';
+export { getPatternScore } from './getPatternScore';
+export { getUniquePatterns } from './getUniquePatterns';
+export { solve } from './solve';

package/packages/solver/src/solve.test.ts

@@ -5,7 +5,7 @@ import { getConfig } from '@scrabble-solver/configs';
 import { dictionaries } from '@scrabble-solver/dictionaries';
 import { Board, Game, Locale, Result, Tile } from '@scrabble-solver/types';
 
-import solve from './solve';
+import { solve } from './solve';
 
 const generateTiles = (characters: string[]): Tile[] => {
   return characters.map((character) => new Tile({ character, isBlank: false }));

package/packages/solver/src/solve.ts

@@ -1,13 +1,13 @@
 import { Trie } from '@kamilmielnik/trie';
 import { Board, Config, ResultJson, Tile } from '@scrabble-solver/types';
 
-import areDigraphsValid from './areDigraphsValid';
-import fillPattern from './fillPattern';
-import generatePatterns from './generatePatterns';
-import getPatternScore from './getPatternScore';
-import getUniquePatterns from './getUniquePatterns';
+import { areDigraphsValid } from './areDigraphsValid';
+import { fillPattern } from './fillPattern';
+import { generatePatterns } from './generatePatterns';
+import { getPatternScore } from './getPatternScore';
+import { getUniquePatterns } from './getUniquePatterns';
 
-const solve = (trie: Trie, config: Config, board: Board, tiles: Tile[]): ResultJson[] => {
+export const solve = (trie: Trie, config: Config, board: Board, tiles: Tile[]): ResultJson[] => {
   const patterns = generatePatterns(config, board);
   const filledPatterns = patterns.flatMap((pattern) => fillPattern(trie, config, pattern, tiles));
   const validPatterns =
@@ -24,5 +24,3 @@ const solve = (trie: Trie, config: Config, board: Board, tiles: Tile[]): ResultJ
 
   return results;
 };
-
-export default solve;

package/packages/types/build/Bingo.d.ts

@@ -0,0 +1,10 @@
+export type MultiplierBingo = {
+    multiplier: number;
+};
+export type ScoreBingo = {
+    score: number;
+};
+export type Bingo = MultiplierBingo | ScoreBingo;
+export declare const isBingo: (value: unknown) => value is Bingo;
+export declare const isScoreBingo: (value: unknown) => value is ScoreBingo;
+export declare const isMultiplierBingo: (value: unknown) => value is MultiplierBingo;

package/packages/types/build/Bingo.js

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

package/packages/types/build/Board.d.ts

@@ -1,8 +1,8 @@
-import BoardJson from './BoardJson';
-import Cell from './Cell';
-declare class Board {
-    static create(size: number): Board;
-    static fromJson(json: BoardJson): Board;
+import { BoardJson } from './BoardJson';
+import { Cell } from './Cell';
+export 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[][];
@@ -29,4 +29,3 @@ declare class Board {
     updateCell(x: number, y: number, updateCell: (cell: Cell) => Cell): void;
     updateRow(y: number, updateRow: (cells: Cell[]) => Cell[]): void;
 }
-export default Board;

package/packages/types/build/Board.js

@@ -1,25 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Board = void 0;
 const constants_1 = require("@scrabble-solver/constants");
-const Cell_1 = __importDefault(require("./Cell"));
-const Tile_1 = __importDefault(require("./Tile"));
+const Cell_1 = require("./Cell");
+const Tile_1 = require("./Tile");
 class Board {
-    static create(size) {
-        return Board.fromStringArray(Array(size).fill(Array(size).fill(' ').join('')));
-    }
-    static fromJson(json) {
-        return new Board({
-            rows: json.map((row) => row.map(Cell_1.default.fromJson)),
-        });
-    }
     static fromStringArray(stringArray) {
         return new Board({
-            rows: stringArray.map((row, y) => row.split('').map((character, x) => new Cell_1.default({
+            rows: stringArray.map((row, y) => row.split('').map((character, x) => new Cell_1.Cell({
                 isEmpty: !character || character === constants_1.EMPTY_CELL,
-                tile: character === constants_1.EMPTY_CELL ? Tile_1.default.Null : new Tile_1.default({ character }),
+                tile: character === constants_1.EMPTY_CELL ? Tile_1.Tile.Null : new Tile_1.Tile({ character }),
                 x,
                 y,
             }))),
@@ -111,4 +101,15 @@ class Board {
         this.rows[y] = updateRow(this.rows[y]);
     }
 }
-exports.default = Board;
+exports.Board = Board;
+Board.create = (width, height) => {
+    const rows = Array(height);
+    const emptyRow = Array(width).fill(' ').join('');
+    const emptyRows = rows.fill(emptyRow);
+    return Board.fromStringArray(emptyRows);
+};
+Board.fromJson = (json) => {
+    return new Board({
+        rows: json.map((row) => row.map(Cell_1.Cell.fromJson)),
+    });
+};

package/packages/types/build/BoardJson.d.ts

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

package/packages/types/build/Bonus.d.ts

@@ -1,9 +1,9 @@
 import { BONUS_CHARACTER, BONUS_WORD } from '@scrabble-solver/constants';
-import BonusJson from './BonusJson';
-import BonusValue from './BonusValue';
-import Cell from './Cell';
-import type Config from './Config';
-declare abstract class Bonus {
+import { BonusJson } from './BonusJson';
+import { BonusValue } from './BonusValue';
+import { Cell } from './Cell';
+import { type Config } from './Config';
+export declare abstract class Bonus {
     readonly multiplier: number;
     readonly score: number | undefined;
     abstract readonly type: typeof BONUS_CHARACTER | typeof BONUS_WORD;
@@ -20,4 +20,3 @@ declare abstract class Bonus {
     toJson(): BonusJson;
     get value(): BonusValue;
 }
-export default Bonus;

package/packages/types/build/Bonus.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bonus = void 0;
 class Bonus {
     constructor({ multiplier, score, x, y }) {
         this.multiplier = multiplier;
@@ -29,4 +30,4 @@ class Bonus {
         };
     }
 }
-exports.default = Bonus;
+exports.Bonus = Bonus;

package/packages/types/build/BonusJson.d.ts

@@ -1,8 +1,7 @@
-interface BonusJson {
+export interface BonusJson {
     multiplier: number;
     score?: number;
     type: string;
     x: number;
     y: number;
 }
-export default BonusJson;

package/packages/types/build/BonusValue.d.ts

@@ -1,5 +1,4 @@
-interface BonusValue {
+export interface BonusValue {
     characterMultiplier: number;
     wordMultiplier: number;
 }
-export default BonusValue;

package/packages/types/build/Cell.d.ts

@@ -1,7 +1,7 @@
-import CellJson from './CellJson';
-import Tile from './Tile';
-declare class Cell {
-    static fromJson(json: CellJson): Cell;
+import { CellJson } from './CellJson';
+import { Tile } from './Tile';
+export declare class Cell {
+    static fromJson: (json: CellJson) => Cell;
     readonly isEmpty: boolean;
     tile: Tile;
     readonly x: number;
@@ -19,4 +19,3 @@ declare class Cell {
     toJson(): CellJson;
     toString(): string;
 }
-export default Cell;

package/packages/types/build/Cell.js

@@ -1,19 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const Tile_1 = __importDefault(require("./Tile"));
+exports.Cell = void 0;
+const Tile_1 = require("./Tile");
 class Cell {
-    static fromJson(json) {
-        return new Cell({
-            isEmpty: json.isEmpty,
-            tile: Tile_1.default.fromJson(json.tile),
-            x: json.x,
-            y: json.y,
-        });
-    }
-    constructor({ isEmpty = true, tile = Tile_1.default.Null, x, y }) {
+    constructor({ isEmpty = true, tile = Tile_1.Tile.Null, x, y }) {
         this.isEmpty = isEmpty;
         this.tile = tile;
         this.x = x;
@@ -31,7 +21,7 @@ class Cell {
         return this.x === other.x && this.y === other.y && this.isEmpty === other.isEmpty && this.tile.equals(other.tile);
     }
     hasTile() {
-        return this.tile !== Tile_1.default.Null;
+        return this.tile !== Tile_1.Tile.Null;
     }
     isCandidate() {
         return this.isEmpty && this.hasTile();
@@ -48,4 +38,12 @@ class Cell {
         return this.tile.toString();
     }
 }
-exports.default = Cell;
+exports.Cell = Cell;
+Cell.fromJson = (json) => {
+    return new Cell({
+        isEmpty: json.isEmpty,
+        tile: Tile_1.Tile.fromJson(json.tile),
+        x: json.x,
+        y: json.y,
+    });
+};

package/packages/types/build/CellJson.d.ts

@@ -1,9 +1,8 @@
-import TileJson from './TileJson';
-interface CellJson {
+import { TileJson } from './TileJson';
+export interface CellJson {
     isEmpty: boolean;
     tile: TileJson | null;
     x: number;
     y: number;
 }
 export declare const isCellJson: (value: unknown) => value is CellJson;
-export default CellJson;

package/packages/types/build/CellJson.js

@@ -1,13 +1,10 @@
 "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 isObject_1 = require("./isObject");
 const TileJson_1 = require("./TileJson");
 const isCellJson = (value) => {
-    return ((0, isObject_1.default)(value) &&
+    return ((0, isObject_1.isObject)(value) &&
         typeof value.isEmpty === 'boolean' &&
         ((0, TileJson_1.isTileJson)(value.tile) || value.tile === null) &&
         typeof value.x === 'number' &&