@scrabble-solver/solver 2.15.10 → 2.15.12

package/build/areDigraphsValid.d.ts

@@ -1,2 +1,2 @@
-import { Config, Pattern } from '@scrabble-solver/types';
+import { type Config, type Pattern } from '@scrabble-solver/types';
 export declare const areDigraphsValid: (config: Config, pattern: Pattern) => boolean;

package/build/fillPattern.d.ts

@@ -1,5 +1,5 @@
-import { Trie } from '@kamilmielnik/trie';
-import { Config, Pattern, Tile } from '@scrabble-solver/types';
+import { type Trie } from '@kamilmielnik/trie';
+import { type Config, type Pattern, type Tile } from '@scrabble-solver/types';
 export declare const fillPattern: (trie: Trie, config: Config, pattern: Pattern, tiles: Tile[]) => Pattern[];
 export declare const fillPatternRecursive: (
 /** gets mutated when this function is called */

package/build/generateEndIndices.d.ts

@@ -1,2 +1,2 @@
-import { Cell } from '@scrabble-solver/types';
+import { type Cell } from '@scrabble-solver/types';
 export declare const generateEndIndices: (cells: Cell[], startIndex: number) => number[];

package/build/generateHorizontalPatterns.d.ts

@@ -1,2 +1,2 @@
-import { Board, Config, Pattern } from '@scrabble-solver/types';
+import { type Board, type Config, type Pattern } from '@scrabble-solver/types';
 export declare const generateHorizontalPatterns: (config: Config, board: Board) => Pattern[];

package/build/generatePattern.d.ts

@@ -1,4 +1,4 @@
-import { Board, Cell, Config, Pattern } from '@scrabble-solver/types';
+import { type Board, type Cell, type Config, type Pattern } from '@scrabble-solver/types';
 export declare const generatePattern: <P extends Pattern>({ board, cells, config, PatternModel, }: {
     board: Board;
     cells: Cell[];

package/build/generatePatterns.d.ts

@@ -1,2 +1,2 @@
-import { Board, Config, Pattern } from '@scrabble-solver/types';
+import { type Board, type Config, type Pattern } from '@scrabble-solver/types';
 export declare const generatePatterns: (config: Config, board: Board) => Pattern[];

package/build/generateStartIndices.d.ts

@@ -1,2 +1,2 @@
-import { Cell } from '@scrabble-solver/types';
+import { type Cell } from '@scrabble-solver/types';
 export declare const generateStartIndices: (cells: Cell[]) => number[];

package/build/generateVectors.d.ts

@@ -1,4 +1,4 @@
-import { Cell } from '@scrabble-solver/types';
+import { type Cell } from '@scrabble-solver/types';
 interface Parameters {
     getNthVector: (index: number) => Cell[];
     vectorsCount: number;

package/build/generateVerticalPatterns.d.ts

@@ -1,2 +1,2 @@
-import { Board, Config, Pattern } from '@scrabble-solver/types';
+import { type Board, type Config, type Pattern } from '@scrabble-solver/types';
 export declare const generateVerticalPatterns: (config: Config, board: Board) => Pattern[];

package/build/getCellsScore.d.ts

@@ -1,2 +1,2 @@
-import { Cell, Config } from '@scrabble-solver/types';
+import { type Cell, type Config } from '@scrabble-solver/types';
 export declare const getCellsScore: (config: Config, cells: Cell[]) => number;

package/build/getPatternHash.d.ts

@@ -1,2 +1,2 @@
-import { Pattern } from '@scrabble-solver/types';
+import { type Pattern } from '@scrabble-solver/types';
 export declare const getPatternHash: (pattern: Pattern) => string;

package/build/getPatternScore.d.ts

@@ -1,2 +1,2 @@
-import { Config, Pattern } from '@scrabble-solver/types';
+import { type Config, type Pattern } from '@scrabble-solver/types';
 export declare const getPatternScore: (config: Config, pattern: Pattern) => number;

package/build/getPatternScore.js

@@ -1,13 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPatternScore = void 0;
+const types_1 = require("@scrabble-solver/types");
 const getCellsScore_1 = require("./getCellsScore");
 const getPatternScore = (config, pattern) => {
     const areAllTilesUsed = pattern.getEmptyCellsCount() === config.rackSize;
-    const bonusScore = areAllTilesUsed ? config.bingoScore : 0;
-    const score = pattern
+    const baseScore = (0, getCellsScore_1.getCellsScore)(config, pattern.cells);
+    const collisionsScore = pattern
         .getCollisions()
-        .reduce((sum, collision) => sum + (0, getCellsScore_1.getCellsScore)(config, collision.cells), (0, getCellsScore_1.getCellsScore)(config, pattern.cells));
-    return score + bonusScore;
+        .reduce((sum, collision) => sum + (0, getCellsScore_1.getCellsScore)(config, collision.cells), 0);
+    if (areAllTilesUsed) {
+        if ((0, types_1.isScoreBingo)(config.bingo)) {
+            return baseScore + collisionsScore + config.bingo.score;
+        }
+        if ((0, types_1.isMultiplierBingo)(config.bingo)) {
+            return baseScore * config.bingo.multiplier + collisionsScore;
+        }
+    }
+    return baseScore + collisionsScore;
 };
 exports.getPatternScore = getPatternScore;

package/build/getUniquePatterns.d.ts

@@ -1,2 +1,2 @@
-import { Pattern } from '@scrabble-solver/types';
+import { type Pattern } from '@scrabble-solver/types';
 export declare const getUniquePatterns: (patterns: Pattern[]) => Pattern[];

package/build/solve.d.ts

@@ -1,3 +1,3 @@
-import { Trie } from '@kamilmielnik/trie';
-import { Board, Config, ResultJson, Tile } from '@scrabble-solver/types';
+import { type Trie } from '@kamilmielnik/trie';
+import { type Board, type Config, type ResultJson, type Tile } from '@scrabble-solver/types';
 export declare const solve: (trie: Trie, config: Config, board: Board, tiles: Tile[]) => ResultJson[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.15.10",
+  "version": "2.15.12",
   "description": "Scrabble Solver 2 - Solver",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -24,12 +24,12 @@
   },
   "dependencies": {
     "@kamilmielnik/trie": "^4.0.0",
-    "@scrabble-solver/types": "^2.15.10"
+    "@scrabble-solver/types": "^2.15.12"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.15.10",
-    "@scrabble-solver/constants": "^2.15.10",
-    "@scrabble-solver/dictionaries": "^2.15.10"
+    "@scrabble-solver/configs": "^2.15.12",
+    "@scrabble-solver/constants": "^2.15.12",
+    "@scrabble-solver/dictionaries": "^2.15.12"
   },
-  "gitHead": "dab5a817c1bde1a3ebf8e8907215adf12af5cb27"
+  "gitHead": "1eeef2b2975e63b195885dd2636c53624d300c6b"
 }

package/src/areDigraphsValid.ts

@@ -1,4 +1,4 @@
-import { Config, Pattern } from '@scrabble-solver/types';
+import { type Config, type Pattern } from '@scrabble-solver/types';
 
 export const areDigraphsValid = (config: Config, pattern: Pattern): boolean => {
   const { twoCharacterTiles } = config;

package/src/fillPattern.test.ts

@@ -1,7 +1,7 @@
-import { Trie } from '@kamilmielnik/trie';
+import { type Trie } from '@kamilmielnik/trie';
 import { getConfig } from '@scrabble-solver/configs';
 import { dictionaries } from '@scrabble-solver/dictionaries';
-import { Board, Cell, FinalPattern, Game, Locale, Pattern, Tile, VerticalPattern } from '@scrabble-solver/types';
+import { Board, Cell, FinalPattern, Game, Locale, type Pattern, Tile, VerticalPattern } from '@scrabble-solver/types';
 
 import { fillPattern, fillPatternRecursive } from './fillPattern';
 

package/src/fillPattern.ts

@@ -1,7 +1,7 @@
 /* eslint-disable max-params, max-statements */
-import { Trie } from '@kamilmielnik/trie';
+import { type Trie } from '@kamilmielnik/trie';
 import { EMPTY_CELL } from '@scrabble-solver/constants';
-import { Config, FinalPattern, Pattern, Tile } from '@scrabble-solver/types';
+import { type Config, FinalPattern, type Pattern, type Tile } from '@scrabble-solver/types';
 
 export const fillPattern = (trie: Trie, config: Config, pattern: Pattern, tiles: Tile[]): Pattern[] => {
   if (pattern.getEmptyCellsCount() > tiles.length) {

package/src/generateEndIndices.test.ts

@@ -1,4 +1,4 @@
-import { Cell } from '@scrabble-solver/types';
+import { type Cell } from '@scrabble-solver/types';
 
 import { generateEndIndices } from './generateEndIndices';
 

package/src/generateEndIndices.ts

@@ -1,4 +1,4 @@
-import { Cell } from '@scrabble-solver/types';
+import { type Cell } from '@scrabble-solver/types';
 
 export const generateEndIndices = (cells: Cell[], startIndex: number): number[] => {
   if (cells.length === 0) {

package/src/generateHorizontalPatterns.test.ts

@@ -1,5 +1,5 @@
 import { EMPTY_CELL } from '@scrabble-solver/constants';
-import { Board, Config } from '@scrabble-solver/types';
+import { Board, type Config } from '@scrabble-solver/types';
 
 import { generateHorizontalPatterns } from './generateHorizontalPatterns';
 

package/src/generateHorizontalPatterns.ts

@@ -1,4 +1,4 @@
-import { Board, Config, HorizontalPattern, Pattern } from '@scrabble-solver/types';
+import { type Board, type Config, HorizontalPattern, type Pattern } from '@scrabble-solver/types';
 
 import { generatePattern } from './generatePattern';
 import { generateVectors } from './generateVectors';

package/src/generatePattern.ts

@@ -1,4 +1,4 @@
-import { Board, Cell, Config, Pattern } from '@scrabble-solver/types';
+import { type Board, type Cell, type Config, type Pattern } from '@scrabble-solver/types';
 
 import { generateEndIndices } from './generateEndIndices';
 import { generateStartIndices } from './generateStartIndices';

package/src/generatePatterns.ts

@@ -1,4 +1,4 @@
-import { Board, Config, Pattern } from '@scrabble-solver/types';
+import { type Board, type Config, type Pattern } from '@scrabble-solver/types';
 
 import { generateHorizontalPatterns } from './generateHorizontalPatterns';
 import { generateVerticalPatterns } from './generateVerticalPatterns';

package/src/generateStartIndices.test.ts

@@ -1,4 +1,4 @@
-import { Cell } from '@scrabble-solver/types';
+import { type Cell } from '@scrabble-solver/types';
 
 import { generateStartIndices } from './generateStartIndices';
 

package/src/generateStartIndices.ts

@@ -1,4 +1,4 @@
-import { Cell } from '@scrabble-solver/types';
+import { type Cell } from '@scrabble-solver/types';
 
 export const generateStartIndices = (cells: Cell[]): number[] => {
   if (cells.length === 0) {

package/src/generateVectors.ts

@@ -1,4 +1,4 @@
-import { Cell } from '@scrabble-solver/types';
+import { type Cell } from '@scrabble-solver/types';
 
 interface Parameters {
   getNthVector: (index: number) => Cell[];

package/src/generateVerticalPatterns.test.ts

@@ -1,5 +1,5 @@
 import { EMPTY_CELL } from '@scrabble-solver/constants';
-import { Board, Config } from '@scrabble-solver/types';
+import { Board, type Config } from '@scrabble-solver/types';
 
 import { generateVerticalPatterns } from './generateVerticalPatterns';
 

package/src/generateVerticalPatterns.ts

@@ -1,4 +1,4 @@
-import { Board, Config, Pattern, VerticalPattern } from '@scrabble-solver/types';
+import { type Board, type Config, type Pattern, VerticalPattern } from '@scrabble-solver/types';
 
 import { generatePattern } from './generatePattern';
 import { generateVectors } from './generateVectors';

package/src/getCellsScore.ts

@@ -1,5 +1,5 @@
 import { NO_BONUS } from '@scrabble-solver/constants';
-import { Cell, Config } from '@scrabble-solver/types';
+import { type Cell, type Config } from '@scrabble-solver/types';
 
 export const getCellsScore = (config: Config, cells: Cell[]): number => {
   const total = cells.reduce(

package/src/getPatternHash.ts

@@ -1,4 +1,4 @@
-import { Pattern } from '@scrabble-solver/types';
+import { type Pattern } from '@scrabble-solver/types';
 
 export const getPatternHash = (pattern: Pattern): string => {
   return pattern.cells

package/src/getPatternScore.test.ts

@@ -3,68 +3,154 @@ import { Board, Cell, Game, HorizontalPattern, Locale, Pattern, Tile, VerticalPa
 
 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  ',
-]);
-
 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/src/getPatternScore.ts

@@ -1,13 +1,23 @@
-import { Config, Pattern } from '@scrabble-solver/types';
+import { type Config, isMultiplierBingo, isScoreBingo, type Pattern } from '@scrabble-solver/types';
 
 import { getCellsScore } from './getCellsScore';
 
 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;
+    }
+  }
+
+  return baseScore + collisionsScore;
 };

package/src/getUniquePatterns.ts

@@ -1,4 +1,4 @@
-import { Pattern } from '@scrabble-solver/types';
+import { type Pattern } from '@scrabble-solver/types';
 
 import { getPatternHash } from './getPatternHash';
 

package/src/solve.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines */
 
-import { Trie } from '@kamilmielnik/trie';
+import { type Trie } from '@kamilmielnik/trie';
 import { getConfig } from '@scrabble-solver/configs';
 import { dictionaries } from '@scrabble-solver/dictionaries';
 import { Board, Game, Locale, Result, Tile } from '@scrabble-solver/types';

package/src/solve.ts

@@ -1,5 +1,5 @@
-import { Trie } from '@kamilmielnik/trie';
-import { Board, Config, ResultJson, Tile } from '@scrabble-solver/types';
+import { type Trie } from '@kamilmielnik/trie';
+import { type Board, type Config, type ResultJson, type Tile } from '@scrabble-solver/types';
 
 import { areDigraphsValid } from './areDigraphsValid';
 import { fillPattern } from './fillPattern';