scrabble-solver 2.8.8 → 2.8.9

package/packages/scrabble-solver/src/state/sagas.ts

@@ -3,7 +3,7 @@ import { Result } from '@scrabble-solver/types';
 import { call, delay, put, select, takeEvery, takeLatest } from 'redux-saga/effects';
 
 import { memoize } from 'lib';
-import { findWordDefinitions, solve, visit } from 'sdk';
+import { findWordDefinitions, solve, verify, visit } from 'sdk';
 
 import { initialize, reset } from './actions';
 import {
@@ -23,6 +23,7 @@ import {
   resultsSlice,
   settingsSlice,
   solveSlice,
+  verifySlice,
 } from './slices';
 
 const SUBMIT_DELAY = 150;
@@ -43,7 +44,8 @@ export function* rootSaga(): AnyGenerator {
   yield takeLatest(dictionarySlice.actions.submit.type, onDictionarySubmit);
   yield takeLatest(initialize.type, onInitialize);
   yield takeLatest(reset.type, onReset);
-  yield takeLatest(solveSlice.actions.submit.type, onSubmit);
+  yield takeLatest(solveSlice.actions.submit.type, onSolve);
+  yield takeLatest(verifySlice.actions.submit.type, onVerify);
 }
 
 function* onCellValueChange({ payload }: PayloadAction<{ value: string; x: number; y: number }>): AnyGenerator {
@@ -52,6 +54,8 @@ function* onCellValueChange({ payload }: PayloadAction<{ value: string; x: numbe
   if (isFiltered) {
     yield put(cellFilterSlice.actions.toggle(payload));
   }
+
+  yield put(verifySlice.actions.submit());
 }
 
 function* onApplyResult({ payload: result }: PayloadAction<Result>): AnyGenerator {
@@ -60,11 +64,13 @@ function* onApplyResult({ payload: result }: PayloadAction<Result>): AnyGenerato
   yield put(cellFilterSlice.actions.reset());
   yield put(rackSlice.actions.removeTiles(result.tiles));
   yield put(rackSlice.actions.groupTiles(autoGroupTiles));
+  yield put(verifySlice.actions.submit());
 }
 
 function* onConfigIdChange(): AnyGenerator {
   yield put(resultsSlice.actions.reset());
   yield put(solveSlice.actions.submit());
+  yield put(verifySlice.actions.submit());
   yield* ensureProperTilesCount();
 }
 
@@ -95,12 +101,14 @@ function* onReset(): AnyGenerator {
   yield put(dictionarySlice.actions.reset());
   yield put(rackSlice.actions.reset());
   yield put(resultsSlice.actions.reset());
+  yield put(verifySlice.actions.submit());
 }
 
 function* onLocaleChange(): AnyGenerator {
-  yield put(solveSlice.actions.submit());
-  yield put(resultsSlice.actions.changeResultCandidate(null));
   yield put(dictionarySlice.actions.reset());
+  yield put(resultsSlice.actions.changeResultCandidate(null));
+  yield put(solveSlice.actions.submit());
+  yield put(verifySlice.actions.submit());
 }
 
 function* onResultCandidateChange({ payload: result }: PayloadAction<Result | null>): AnyGenerator {
@@ -110,7 +118,7 @@ function* onResultCandidateChange({ payload: result }: PayloadAction<Result | nu
   }
 }
 
-function* onSubmit(): AnyGenerator {
+function* onSolve(): AnyGenerator {
   const board = yield select(selectBoard);
   const { config } = yield select(selectConfig);
   const locale = yield select(selectLocale);
@@ -129,14 +137,33 @@ function* onSubmit(): AnyGenerator {
       configId: config.id,
       locale,
     });
-    yield put(solveSlice.actions.submitSuccess({ board, characters }));
     yield put(resultsSlice.actions.changeResults(results.map(Result.fromJson)));
+    yield put(solveSlice.actions.submitSuccess({ board, characters }));
   } catch (error) {
     yield put(resultsSlice.actions.changeResults([]));
     yield put(solveSlice.actions.submitFailure());
   }
 }
 
+function* onVerify(): AnyGenerator {
+  yield delay(SUBMIT_DELAY);
+
+  const board = yield select(selectBoard);
+  const { config } = yield select(selectConfig);
+  const locale = yield select(selectLocale);
+
+  try {
+    const { invalidWords, validWords } = yield call(verify, {
+      board: board.toJson(),
+      configId: config.id,
+      locale,
+    });
+    yield put(verifySlice.actions.submitSuccess({ board, invalidWords, validWords }));
+  } catch (error) {
+    yield put(verifySlice.actions.submitFailure());
+  }
+}
+
 function* ensureProperTilesCount(): AnyGenerator {
   const { config } = yield select(selectConfig);
   const characters = yield select(selectCharacters);

package/packages/scrabble-solver/src/state/selectors.ts

@@ -30,6 +30,8 @@ const selectSettingsRoot = (state: RootState): RootState['settings'] => state.se
 
 const selectSolveRoot = (state: RootState): RootState['solve'] => state.solve;
 
+const selectVerifyRoot = (state: RootState): RootState['verify'] => state.verify;
+
 export const selectDictionary = selectDictionaryRoot;
 
 export const selectAutoGroupTiles = createSelector([selectSettingsRoot], (settings) => settings.autoGroupTiles);
@@ -183,3 +185,9 @@ export const selectHasOverusedTiles = createSelector([selectRemainingTiles], (re
 });
 
 export const selectRemainingTilesGroups = createSelector([selectRemainingTiles], getRemainingTilesGroups);
+
+export const selectVerify = selectVerifyRoot;
+
+export const selectHasInvalidWords = createSelector([selectVerify], ({ invalidWords }) => {
+  return invalidWords.length > 0;
+});

package/packages/scrabble-solver/src/state/slices/index.ts

@@ -12,3 +12,5 @@ export { default as settingsInitialState } from './settingsInitialState';
 export { default as settingsSlice } from './settingsSlice';
 export { default as solveInitialState } from './solveInitialState';
 export { default as solveSlice } from './solveSlice';
+export { default as verifyInitialState } from './verifyInitialState';
+export { default as verifySlice } from './verifySlice';

package/packages/scrabble-solver/src/state/slices/verifyInitialState.ts

@@ -0,0 +1,12 @@
+import boardInitialState from './boardInitialState';
+
+const verifyInitialState = {
+  isLoading: false,
+  lastSolvedParameters: {
+    board: boardInitialState,
+  },
+  invalidWords: [] as string[],
+  validWords: [] as string[],
+};
+
+export default verifyInitialState;

package/packages/scrabble-solver/src/state/slices/verifySlice.ts

@@ -0,0 +1,31 @@
+import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+import { Board } from '@scrabble-solver/types';
+
+import verifyInitialState from './verifyInitialState';
+
+interface VerifyParameters {
+  board: Board;
+  invalidWords: string[];
+  validWords: string[];
+}
+
+const verifySlice = createSlice({
+  initialState: verifyInitialState,
+  name: 'verify',
+  reducers: {
+    submit: (state) => {
+      return { ...state, isLoading: true };
+    },
+
+    submitFailure: (state) => {
+      return { ...state, isLoading: false };
+    },
+
+    submitSuccess: (state, action: PayloadAction<VerifyParameters>) => {
+      const { board, invalidWords, validWords } = action.payload;
+      return { ...state, isLoading: false, lastSolvedParameters: { board }, invalidWords, validWords };
+    },
+  },
+});
+
+export default verifySlice;

package/packages/scrabble-solver/src/styles/variables.scss

@@ -26,7 +26,8 @@ $easeOutSine: cubic-bezier(0.61, 1, 0.88, 1);
   --color--background: #f4f4f4;
   --color--background--secondary: #111;
   --color--background--overlay: rgba(255, 255, 255, 0.65);
-  --color--error: rgba(255, 0, 0, 0.75);
+  --color--error: #fc3d3d;
+  --color--success: #00a900;
   --color--focus: #{rgba(#268fff, 0.5)};
   --color--foreground: black;
   --color--foreground--secondary: #444;

package/packages/scrabble-solver/src/types/index.ts

@@ -80,7 +80,10 @@ export type TranslationKey =
   | 'settings.autoGroupTiles.right'
   | 'settings.autoGroupTiles.null'
   | 'settings.game'
-  | 'settings.language';
+  | 'settings.language'
+  | 'words'
+  | 'words.invalid'
+  | 'words.valid';
 
 export type Translate = (key: TranslationKey) => string;
 

package/packages/solver/build/fillPattern.d.ts

@@ -0,0 +1,5 @@
+import { Trie } from '@kamilmielnik/trie';
+import { Config, Pattern, Tile } from '@scrabble-solver/types';
+declare const fillPattern: (trie: Trie, config: Config, pattern: Pattern, tiles: Tile[]) => Pattern[];
+export declare const fillPatternRecursive: (results: Pattern[], trie: Trie, config: Config, pattern: Pattern, word: string, tiles: Tile[]) => void;
+export default fillPattern;

package/packages/solver/build/fillPattern.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fillPatternRecursive = void 0;
+const constants_1 = require("@scrabble-solver/constants");
+const types_1 = require("@scrabble-solver/types");
+const fillPattern = (trie, config, pattern, tiles) => {
+    if (pattern.getEmptyCellsCount() > tiles.length) {
+        return [];
+    }
+    const results = [];
+    (0, exports.fillPatternRecursive)(results, trie, config, pattern, pattern.toString(), tiles);
+    return results;
+};
+const fillPatternRecursive = (
+/** gets mutated when this function is called */
+results, trie, config, pattern, word, tiles) => {
+    const indexOfFirstCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
+    if (indexOfFirstCellWithoutTile === -1) {
+        if (trie.has(word) && pattern.getCollisions().every((collision) => trie.has(collision.toString()))) {
+            results.push(new types_1.FinalPattern(pattern.clone()));
+        }
+        return;
+    }
+    for (let index = 0; index < tiles.length; ++index) {
+        const tile = tiles[index];
+        const previousTile = pattern.cells[indexOfFirstCellWithoutTile].tile;
+        pattern.cells[indexOfFirstCellWithoutTile].tile = tile;
+        const indexOfNextCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
+        const indexOfFirstEmptyLetter = word.indexOf(constants_1.EMPTY_CELL);
+        const prefix = word.substring(0, indexOfFirstEmptyLetter);
+        const suffix = word.substring(indexOfFirstEmptyLetter + 1);
+        const characters = tile.isBlank ? config.alphabet : [tile.character];
+        for (const character of characters) {
+            const newWordPrefix = prefix + character;
+            const newWord = newWordPrefix + suffix;
+            tile.character = character;
+            if (indexOfNextCellWithoutTile === -1) {
+                if (trie.has(newWord) && pattern.getCollisions().every((collision) => trie.has(collision.toString()))) {
+                    results.push(new types_1.FinalPattern(pattern.clone()));
+                }
+            }
+            else if (trie.hasPrefix(newWordPrefix)) {
+                tiles.splice(index, 1);
+                (0, exports.fillPatternRecursive)(results, trie, config, pattern, newWord, tiles);
+                tiles.splice(index, 0, tile);
+            }
+        }
+        pattern.cells[indexOfFirstCellWithoutTile].tile = previousTile;
+    }
+};
+exports.fillPatternRecursive = fillPatternRecursive;
+exports.default = fillPattern;

package/packages/solver/build/generateEndIndices.d.ts

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

package/packages/solver/build/generateEndIndices.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateEndIndices = (cells, startIndex) => {
+    return Array(cells.length - startIndex - 1)
+        .fill(0)
+        .map((_, endIndex) => endIndex + startIndex + 1)
+        .filter((endIndex) => endIndex >= cells.length - 1 || !cells[endIndex + 1].hasTile());
+};
+exports.default = generateEndIndices;

package/packages/solver/build/generateHorizontalPatterns.d.ts

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

package/packages/solver/build/generateHorizontalPatterns.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@scrabble-solver/types");
+const generatePattern_1 = __importDefault(require("./generatePattern"));
+const generateVectors_1 = __importDefault(require("./generateVectors"));
+const generateHorizontalPatterns = (config, board) => {
+    const getNthVector = (index) => board.getRow(index);
+    const vectorsCount = config.boardHeight;
+    const horizontalVectors = (0, generateVectors_1.default)({ getNthVector, vectorsCount });
+    const horizontalPatterns = horizontalVectors.flatMap((cells) => {
+        return (0, generatePattern_1.default)({ board, config, PatternModel: types_1.HorizontalPattern, cells });
+    });
+    return horizontalPatterns;
+};
+exports.default = generateHorizontalPatterns;

package/packages/solver/build/generatePattern.d.ts

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

package/packages/solver/build/generatePattern.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateEndIndices_1 = __importDefault(require("./generateEndIndices"));
+const generateStartIndices_1 = __importDefault(require("./generateStartIndices"));
+const generatePattern = ({ board, cells, config, PatternModel, }) => {
+    const startIndices = (0, generateStartIndices_1.default)(cells);
+    return startIndices.flatMap((startIndex) => {
+        const endIndices = (0, generateEndIndices_1.default)(cells, startIndex);
+        const patterns = [];
+        for (const endIndex of endIndices) {
+            const pattern = new PatternModel(board, cells.slice(startIndex, endIndex + 1));
+            if (pattern.canBePlaced(config)) {
+                patterns.push(pattern);
+            }
+        }
+        return patterns;
+    });
+};
+exports.default = generatePattern;

package/packages/solver/build/generatePatterns.d.ts

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

package/packages/solver/build/generatePatterns.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateHorizontalPatterns_1 = __importDefault(require("./generateHorizontalPatterns"));
+const generateVerticalPatterns_1 = __importDefault(require("./generateVerticalPatterns"));
+const generatePatterns = (config, board) => {
+    const horizontalPatterns = (0, generateHorizontalPatterns_1.default)(config, board);
+    const verticalPatterns = (0, generateVerticalPatterns_1.default)(config, board);
+    return horizontalPatterns.concat(verticalPatterns);
+};
+exports.default = generatePatterns;

package/packages/solver/build/generateStartIndices.d.ts

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

package/packages/solver/build/generateStartIndices.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateStartIndices = (cells) => {
+    return Array(cells.length - 1)
+        .fill(0)
+        .map((_, startIndex) => startIndex)
+        .filter((startIndex) => startIndex === 0 || !cells[startIndex - 1].hasTile());
+};
+exports.default = generateStartIndices;

package/packages/solver/build/generateVectors.d.ts

@@ -0,0 +1,6 @@
+import { Cell } from '@scrabble-solver/types';
+declare const generateVectors: ({ getNthVector, vectorsCount, }: {
+    getNthVector: (index: number) => Cell[];
+    vectorsCount: number;
+}) => Cell[][];
+export default generateVectors;

package/packages/solver/build/generateVectors.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateVectors = ({ getNthVector, vectorsCount, }) => {
+    return Array(vectorsCount)
+        .fill(0)
+        .map((_, index) => getNthVector(index));
+};
+exports.default = generateVectors;

package/packages/solver/build/generateVerticalPatterns.d.ts

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

package/packages/solver/build/generateVerticalPatterns.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@scrabble-solver/types");
+const generatePattern_1 = __importDefault(require("./generatePattern"));
+const generateVectors_1 = __importDefault(require("./generateVectors"));
+const generateVerticalPatterns = (config, board) => {
+    const getNthVector = (index) => board.getColumn(index);
+    const vectorsCount = config.boardWidth;
+    const verticalVectors = (0, generateVectors_1.default)({ getNthVector, vectorsCount });
+    const verticalPatterns = verticalVectors.flatMap((cells) => {
+        return (0, generatePattern_1.default)({ board, config, PatternModel: types_1.VerticalPattern, cells });
+    });
+    return verticalPatterns;
+};
+exports.default = generateVerticalPatterns;

package/packages/solver/build/getCellsScore.d.ts

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

package/packages/solver/build/getCellsScore.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("@scrabble-solver/constants");
+const getCellsScore = (config, cells) => {
+    const total = cells.reduce(({ multiplier, score }, cell) => {
+        const bonus = config.getCellBonus(cell);
+        const { characterMultiplier, wordMultiplier } = bonus && bonus.canApply(config, cell) ? bonus.value : constants_1.NO_BONUS;
+        const characterScore = cell.tile.isBlank ? config.blankScore : config.pointsMap[cell.tile.character];
+        return {
+            multiplier: multiplier * wordMultiplier,
+            score: score + characterScore * characterMultiplier,
+        };
+    }, { multiplier: 1, score: 0 });
+    return total.score * total.multiplier;
+};
+exports.default = getCellsScore;

package/packages/solver/build/getPatternHash.d.ts

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

package/packages/solver/build/getPatternHash.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getPatternHash = (pattern) => {
+    return pattern.cells
+        .map((cell) => {
+        const blank = cell.tile.isBlank ? '!' : '';
+        const tile = cell.tile.character + blank;
+        // eslint-disable-next-line prefer-template
+        return cell.x + ',' + cell.y + ',' + tile;
+    })
+        .join('-');
+};
+exports.default = getPatternHash;

package/packages/solver/build/getPatternScore.d.ts

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

package/packages/solver/build/getPatternScore.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getCellsScore_1 = __importDefault(require("./getCellsScore"));
+const getPatternScore = (config, pattern) => {
+    const areAllTilesUsed = pattern.getEmptyCellsCount() === config.maximumCharactersCount;
+    const bonusScore = areAllTilesUsed ? config.allTilesBonusScore : 0;
+    const score = pattern
+        .getCollisions()
+        .reduce((sum, collision) => sum + (0, getCellsScore_1.default)(config, collision.cells), (0, getCellsScore_1.default)(config, pattern.cells));
+    return score + bonusScore;
+};
+exports.default = getPatternScore;

package/packages/solver/build/getUniquePatterns.js

@@ -1,20 +1,14 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const getPatternHash = (pattern) => {
-    return pattern.cells
-        .map((cell) => {
-        const blank = cell.tile.isBlank ? '!' : '';
-        const tile = cell.tile.character + blank;
-        // eslint-disable-next-line prefer-template
-        return cell.x + ',' + cell.y + ',' + tile;
-    })
-        .join('-');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+const getPatternHash_1 = __importDefault(require("./getPatternHash"));
 const getUniquePatterns = (patterns) => {
     const hashes = new Set();
     const uniquePatterns = [];
     for (const pattern of patterns) {
-        const hash = getPatternHash(pattern);
+        const hash = (0, getPatternHash_1.default)(pattern);
         if (!hashes.has(hash)) {
             hashes.add(hash);
             uniquePatterns.push(pattern);

package/packages/solver/build/index.d.ts

@@ -1 +1 @@
-export { default } from './Solver';
+export { default as solve } from './solve';

package/packages/solver/build/index.js

@@ -3,6 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
-var Solver_1 = require("./Solver");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(Solver_1).default; } });
+exports.solve = void 0;
+var solve_1 = require("./solve");
+Object.defineProperty(exports, "solve", { enumerable: true, get: function () { return __importDefault(solve_1).default; } });

package/packages/solver/build/solve.d.ts

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

package/packages/solver/build/solve.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@scrabble-solver/types");
+const fillPattern_1 = __importDefault(require("./fillPattern"));
+const generatePatterns_1 = __importDefault(require("./generatePatterns"));
+const getPatternScore_1 = __importDefault(require("./getPatternScore"));
+const getUniquePatterns_1 = __importDefault(require("./getUniquePatterns"));
+const solve = (trie, config, board, tiles) => {
+    const patterns = (0, generatePatterns_1.default)(config, board);
+    const filledPatterns = patterns.flatMap((pattern) => (0, fillPattern_1.default)(trie, config, pattern, tiles));
+    const uniquePatterns = (0, getUniquePatterns_1.default)(filledPatterns);
+    const results = uniquePatterns.map((pattern, index) => new types_1.Result({
+        cells: pattern.cells,
+        collisions: pattern.getCollisions().map((collision) => collision.cells),
+        id: index,
+        points: (0, getPatternScore_1.default)(config, pattern),
+    }));
+    return results;
+};
+exports.default = solve;

package/packages/solver/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.8",
+  "version": "2.8.9",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrabble-solver/solver",
-      "version": "2.8.8",
+      "version": "2.8.9",
       "license": "CC-BY-NC-ND-4.0",
       "dependencies": {
         "@kamilmielnik/trie": "^2.0.0"

package/packages/solver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.8",
+  "version": "2.8.9",
   "description": "Scrabble Solver 2 - Solver",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -25,12 +25,12 @@
   },
   "dependencies": {
     "@kamilmielnik/trie": "^2.0.0",
-    "@scrabble-solver/types": "^2.8.8"
+    "@scrabble-solver/types": "^2.8.9"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.8.8",
-    "@scrabble-solver/constants": "^2.8.8",
-    "@scrabble-solver/dictionaries": "^2.8.8"
+    "@scrabble-solver/configs": "^2.8.9",
+    "@scrabble-solver/constants": "^2.8.9",
+    "@scrabble-solver/dictionaries": "^2.8.9"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }