scrabble-solver 2.8.9 → 2.8.11

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

@@ -37,6 +37,7 @@ type AnyGenerator = Generator<any, any, any>;
 
 export function* rootSaga(): AnyGenerator {
   yield takeEvery(boardSlice.actions.changeCellValue.type, onCellValueChange);
+  yield takeEvery([rackSlice.actions.changeCharacter.type, rackSlice.actions.changeCharacters.type], onRackValueChange);
   yield takeEvery(resultsSlice.actions.applyResult.type, onApplyResult);
   yield takeEvery(resultsSlice.actions.changeResultCandidate.type, onResultCandidateChange);
   yield takeEvery(settingsSlice.actions.changeConfigId.type, onConfigIdChange);
@@ -55,9 +56,14 @@ function* onCellValueChange({ payload }: PayloadAction<{ value: string; x: numbe
     yield put(cellFilterSlice.actions.toggle(payload));
   }
 
+  yield put(resultsSlice.actions.changeResultCandidate(null));
   yield put(verifySlice.actions.submit());
 }
 
+function* onRackValueChange(): AnyGenerator {
+  yield put(resultsSlice.actions.changeResultCandidate(null));
+}
+
 function* onApplyResult({ payload: result }: PayloadAction<Result>): AnyGenerator {
   const autoGroupTiles = yield select(selectAutoGroupTiles);
   yield put(boardSlice.actions.applyResult(result));
@@ -86,7 +92,7 @@ function* onDictionarySubmit(): AnyGenerator {
     const wordDefinitions = yield call(memoizedFindWordDefinitions, locale, word);
     yield put(dictionarySlice.actions.submitSuccess(wordDefinitions));
   } catch (error) {
-    yield put(dictionarySlice.actions.submitFailure());
+    yield put(dictionarySlice.actions.submitFailure(error));
   }
 }
 
@@ -137,11 +143,11 @@ function* onSolve(): AnyGenerator {
       configId: config.id,
       locale,
     });
-    yield put(resultsSlice.actions.changeResults(results.map(Result.fromJson)));
+    yield put(resultsSlice.actions.changeResults(results));
     yield put(solveSlice.actions.submitSuccess({ board, characters }));
   } catch (error) {
     yield put(resultsSlice.actions.changeResults([]));
-    yield put(solveSlice.actions.submitFailure());
+    yield put(solveSlice.actions.submitFailure(error));
   }
 }
 

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

@@ -1,6 +1,6 @@
 import { createSelector } from '@reduxjs/toolkit';
 import { getLocaleConfig } from '@scrabble-solver/configs';
-import { Cell, Config, Result, Tile } from '@scrabble-solver/types';
+import { Cell, Config, isError, Result, Tile } from '@scrabble-solver/types';
 
 import i18n from 'i18n';
 import { findCell, getRemainingTiles, getRemainingTilesGroups, sortResults, unorderedArraysEqual } from 'lib';
@@ -34,6 +34,10 @@ const selectVerifyRoot = (state: RootState): RootState['verify'] => state.verify
 
 export const selectDictionary = selectDictionaryRoot;
 
+export const selectDictionaryError = createSelector([selectDictionaryRoot], (dictionary) => {
+  return isError(dictionary.error) ? dictionary.error : undefined;
+});
+
 export const selectAutoGroupTiles = createSelector([selectSettingsRoot], (settings) => settings.autoGroupTiles);
 
 export const selectLocale = createSelector([selectSettingsRoot], (settings) => settings.locale);
@@ -158,6 +162,10 @@ export const selectLastSolvedParameters = createSelector([selectSolveRoot], (sol
 
 export const selectIsLoading = createSelector([selectSolveRoot], (solve) => solve.isLoading);
 
+export const selectSolveError = createSelector([selectSolveRoot], (solve) => {
+  return isError(solve.error) ? solve.error : undefined;
+});
+
 export const selectHaveCharactersChanged = createSelector(
   [selectLastSolvedParameters, selectCharacters],
   (lastSolvedParameters, characters) => {

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

@@ -1,9 +1,17 @@
 import { WordDefinition } from '@scrabble-solver/types';
 
-const dictionaryInitialState = {
+interface DictionaryInitialState {
+  error: unknown | undefined;
+  input: string;
+  isLoading: boolean;
+  results: WordDefinition[];
+}
+
+const dictionaryInitialState: DictionaryInitialState = {
+  error: undefined,
   input: '',
   isLoading: false,
-  results: [] as WordDefinition[],
+  results: [],
 };
 
 export default dictionaryInitialState;

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

@@ -14,27 +14,21 @@ const dictionarySlice = createSlice({
     reset: () => dictionaryInitialState,
 
     submit: (state) => {
-      return {
-        ...state,
-        isLoading: true,
-        results: dictionaryInitialState.results,
-      };
+      const error = dictionaryInitialState.error;
+      const results = dictionaryInitialState.results;
+      return { ...state, error, isLoading: true, results };
     },
 
-    submitFailure: (state) => {
-      return {
-        ...state,
-        isLoading: false,
-        results: dictionaryInitialState.results,
-      };
+    submitFailure: (state, action: PayloadAction<unknown>) => {
+      const error = action.payload;
+      const results = dictionaryInitialState.results;
+      return { ...state, error, isLoading: false, results };
     },
 
     submitSuccess: (state, action: PayloadAction<WordDefinition[]>) => {
-      return {
-        ...state,
-        isLoading: false,
-        results: action.payload,
-      };
+      const error = dictionaryInitialState.error;
+      const results = action.payload;
+      return { ...state, error, isLoading: false, results };
     },
   },
 });

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

@@ -9,16 +9,18 @@ const rackSlice = createSlice({
   initialState: rackInitialState,
   name: 'rack',
   reducers: {
-    change: (_state, action: PayloadAction<(string | null)[]>) => {
-      const rack = action.payload;
-      return rack;
-    },
-
     changeCharacter: (state, action: PayloadAction<{ character: string | null; index: number }>) => {
       const { character, index } = action.payload;
       return [...state.slice(0, index), character, ...state.slice(index + 1)];
     },
 
+    changeCharacters: (state, action: PayloadAction<{ characters: (string | null)[]; index: number }>) => {
+      const { characters, index } = action.payload;
+      const expectedRackLength = state.length;
+      const rack = [...state.slice(0, index), ...characters, ...state.slice(index + characters.length)];
+      return rack.slice(0, expectedRackLength);
+    },
+
     groupTiles: (state, action: PayloadAction<'left' | 'right' | null>) => {
       const direction = action.payload;
 

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

@@ -1,10 +1,22 @@
+import { Board } from '@scrabble-solver/types';
+
 import boardInitialState from './boardInitialState';
 
-const solveInitialState = {
+interface SolveInitialState {
+  error: unknown | undefined;
+  isLoading: boolean;
+  lastSolvedParameters: {
+    board: Board;
+    characters: string[];
+  };
+}
+
+const solveInitialState: SolveInitialState = {
+  error: undefined,
   isLoading: false,
   lastSolvedParameters: {
     board: boardInitialState,
-    characters: [] as string[],
+    characters: [],
   },
 };
 

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

@@ -13,16 +13,19 @@ const solveSlice = createSlice({
   name: 'solve',
   reducers: {
     submit: (state) => {
-      return { ...state, isLoading: true };
+      const error = solveInitialState.error;
+      return { ...state, error, isLoading: true };
     },
 
-    submitFailure: (state) => {
-      return { ...state, isLoading: false };
+    submitFailure: (state, action: PayloadAction<unknown>) => {
+      const error = action.payload;
+      return { ...state, error, isLoading: false };
     },
 
     submitSuccess: (state, action: PayloadAction<SolveParameters>) => {
+      const error = solveInitialState.error;
       const lastSolvedParameters = action.payload;
-      return { ...state, isLoading: false, lastSolvedParameters };
+      return { ...state, error, isLoading: false, lastSolvedParameters };
     },
   },
 });

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

@@ -1,5 +1,7 @@
 export type Comparator<T> = (a: T, B: T) => number;
 
+export type Direction = 'horizontal' | 'vertical';
+
 export enum SortDirection {
   Ascending = 'ascending',
   Descending = 'descending',

package/packages/solver/build/generateEndIndices.js

@@ -1,9 +1,16 @@
 "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());
+    if (cells.length === 0) {
+        return [];
+    }
+    const endIndices = [];
+    for (let endIndex = startIndex + 1; endIndex < cells.length - 1; ++endIndex) {
+        if (!cells[endIndex + 1].hasTile()) {
+            endIndices.push(endIndex);
+        }
+    }
+    endIndices.push(cells.length - 1);
+    return endIndices;
 };
 exports.default = generateEndIndices;

package/packages/solver/build/generateStartIndices.js

@@ -1,9 +1,15 @@
 "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());
+    if (cells.length === 0) {
+        return [];
+    }
+    const startIndices = [0];
+    for (let startIndex = 1; startIndex < cells.length - 1; ++startIndex) {
+        if (!cells[startIndex - 1].hasTile()) {
+            startIndices.push(startIndex);
+        }
+    }
+    return startIndices;
 };
 exports.default = generateStartIndices;

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

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

package/packages/solver/build/generateVectors.js

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

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

@@ -1 +1,13 @@
+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';

package/packages/solver/build/index.js

@@ -3,6 +3,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.solve = void 0;
+exports.solve = exports.getUniquePatterns = exports.getPatternScore = exports.getPatternHash = exports.getCellsScore = exports.generateVerticalPatterns = exports.generateVectors = exports.generateStartIndices = exports.generatePatterns = exports.generatePattern = exports.generateHorizontalPatterns = exports.generateEndIndices = exports.fillPattern = void 0;
+var fillPattern_1 = require("./fillPattern");
+Object.defineProperty(exports, "fillPattern", { enumerable: true, get: function () { return __importDefault(fillPattern_1).default; } });
+var generateEndIndices_1 = require("./generateEndIndices");
+Object.defineProperty(exports, "generateEndIndices", { enumerable: true, get: function () { return __importDefault(generateEndIndices_1).default; } });
+var generateHorizontalPatterns_1 = require("./generateHorizontalPatterns");
+Object.defineProperty(exports, "generateHorizontalPatterns", { enumerable: true, get: function () { return __importDefault(generateHorizontalPatterns_1).default; } });
+var generatePattern_1 = require("./generatePattern");
+Object.defineProperty(exports, "generatePattern", { enumerable: true, get: function () { return __importDefault(generatePattern_1).default; } });
+var generatePatterns_1 = require("./generatePatterns");
+Object.defineProperty(exports, "generatePatterns", { enumerable: true, get: function () { return __importDefault(generatePatterns_1).default; } });
+var generateStartIndices_1 = require("./generateStartIndices");
+Object.defineProperty(exports, "generateStartIndices", { enumerable: true, get: function () { return __importDefault(generateStartIndices_1).default; } });
+var generateVectors_1 = require("./generateVectors");
+Object.defineProperty(exports, "generateVectors", { enumerable: true, get: function () { return __importDefault(generateVectors_1).default; } });
+var generateVerticalPatterns_1 = require("./generateVerticalPatterns");
+Object.defineProperty(exports, "generateVerticalPatterns", { enumerable: true, get: function () { return __importDefault(generateVerticalPatterns_1).default; } });
+var getCellsScore_1 = require("./getCellsScore");
+Object.defineProperty(exports, "getCellsScore", { enumerable: true, get: function () { return __importDefault(getCellsScore_1).default; } });
+var getPatternHash_1 = require("./getPatternHash");
+Object.defineProperty(exports, "getPatternHash", { enumerable: true, get: function () { return __importDefault(getPatternHash_1).default; } });
+var getPatternScore_1 = require("./getPatternScore");
+Object.defineProperty(exports, "getPatternScore", { enumerable: true, get: function () { return __importDefault(getPatternScore_1).default; } });
+var getUniquePatterns_1 = require("./getUniquePatterns");
+Object.defineProperty(exports, "getUniquePatterns", { enumerable: true, get: function () { return __importDefault(getUniquePatterns_1).default; } });
 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

@@ -1,4 +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[];
+import { Board, Config, ResultJson, Tile } from '@scrabble-solver/types';
+declare const solve: (trie: Trie, config: Config, board: Board, tiles: Tile[]) => ResultJson[];
 export default solve;

package/packages/solver/build/solve.js

@@ -3,7 +3,6 @@ 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"));
@@ -12,9 +11,9 @@ 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),
+    const results = uniquePatterns.map((pattern, index) => ({
+        cells: pattern.cells.map((cell) => cell.toJson()),
+        collisions: pattern.getCollisions().map((collision) => collision.cells.map((cell) => cell.toJson())),
         id: index,
         points: (0, getPatternScore_1.default)(config, pattern),
     }));

package/packages/solver/package-lock.json

@@ -1,21 +1,21 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.9",
+  "version": "2.8.11",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrabble-solver/solver",
-      "version": "2.8.9",
+      "version": "2.8.11",
       "license": "CC-BY-NC-ND-4.0",
       "dependencies": {
-        "@kamilmielnik/trie": "^2.0.0"
+        "@kamilmielnik/trie": "^2.0.1"
       }
     },
     "node_modules/@kamilmielnik/trie": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-2.0.0.tgz",
-      "integrity": "sha512-YWTYtrV97bQ5hRifG1FImP47PI400a56O8+oQClQOtDjY3tioxab4sOgFHckiDdswciN1RwngCZ9Kv3phJfSuA==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-2.0.1.tgz",
+      "integrity": "sha512-6Ulw5/xgFRadHsx0uVnpOxB2E2ZO2osnaakI26yS3RMlww580JiaQEfXUmQjXZcmOjcO+HrZ0CWjRDhoDYKHbg==",
       "engines": {
         "node": ">=16"
       }
@@ -23,9 +23,9 @@
   },
   "dependencies": {
     "@kamilmielnik/trie": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-2.0.0.tgz",
-      "integrity": "sha512-YWTYtrV97bQ5hRifG1FImP47PI400a56O8+oQClQOtDjY3tioxab4sOgFHckiDdswciN1RwngCZ9Kv3phJfSuA=="
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-2.0.1.tgz",
+      "integrity": "sha512-6Ulw5/xgFRadHsx0uVnpOxB2E2ZO2osnaakI26yS3RMlww580JiaQEfXUmQjXZcmOjcO+HrZ0CWjRDhoDYKHbg=="
     }
   }
 }

package/packages/solver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.9",
+  "version": "2.8.11",
   "description": "Scrabble Solver 2 - Solver",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -24,13 +24,13 @@
     "clean:force": "npm run clean && rimraf package-lock.json"
   },
   "dependencies": {
-    "@kamilmielnik/trie": "^2.0.0",
-    "@scrabble-solver/types": "^2.8.9"
+    "@kamilmielnik/trie": "^2.0.1",
+    "@scrabble-solver/types": "^2.8.11"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.8.9",
-    "@scrabble-solver/constants": "^2.8.9",
-    "@scrabble-solver/dictionaries": "^2.8.9"
+    "@scrabble-solver/configs": "^2.8.11",
+    "@scrabble-solver/constants": "^2.8.11",
+    "@scrabble-solver/dictionaries": "^2.8.11"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }

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

@@ -6,6 +6,11 @@ describe('generateEndIndices', () => {
   const emptyCell: Cell = { hasTile: () => false } as Cell;
   const filledCell: Cell = { hasTile: () => true } as Cell;
 
+  it('returns empty array when no cells given', () => {
+    const cells: Cell[] = [];
+    expect(generateEndIndices(cells, 0).length).toBe(0);
+  });
+
   it('finds indices where a new word can end - XXOOOX', () => {
     const cells = [filledCell, filledCell, emptyCell, emptyCell, emptyCell, filledCell];
     expect(generateEndIndices(cells, 3)).toEqual([5]);

package/packages/solver/src/generateEndIndices.ts

@@ -1,10 +1,21 @@
 import { Cell } from '@scrabble-solver/types';
 
 const generateEndIndices = (cells: Cell[], startIndex: number): number[] => {
-  return Array(cells.length - startIndex - 1)
-    .fill(0)
-    .map((_, endIndex) => endIndex + startIndex + 1)
-    .filter((endIndex) => endIndex >= cells.length - 1 || !cells[endIndex + 1].hasTile());
+  if (cells.length === 0) {
+    return [];
+  }
+
+  const endIndices: number[] = [];
+
+  for (let endIndex = startIndex + 1; endIndex < cells.length - 1; ++endIndex) {
+    if (!cells[endIndex + 1].hasTile()) {
+      endIndices.push(endIndex);
+    }
+  }
+
+  endIndices.push(cells.length - 1);
+
+  return endIndices;
 };
 
 export default generateEndIndices;

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

@@ -6,6 +6,11 @@ describe('generateStartIndices', () => {
   const emptyCell: Cell = { hasTile: () => false } as Cell;
   const filledCell: Cell = { hasTile: () => true } as Cell;
 
+  it('returns empty array when no cells given', () => {
+    const cells: Cell[] = [];
+    expect(generateStartIndices(cells).length).toBe(0);
+  });
+
   it('finds indices where a new word can start', () => {
     const cells = [filledCell, filledCell, emptyCell, emptyCell, emptyCell, filledCell];
     const startIndices = generateStartIndices(cells);

package/packages/solver/src/generateStartIndices.ts

@@ -1,10 +1,19 @@
 import { Cell } from '@scrabble-solver/types';
 
 const generateStartIndices = (cells: Cell[]): number[] => {
-  return Array(cells.length - 1)
-    .fill(0)
-    .map((_, startIndex) => startIndex)
-    .filter((startIndex) => startIndex === 0 || !cells[startIndex - 1].hasTile());
+  if (cells.length === 0) {
+    return [];
+  }
+
+  const startIndices: number[] = [0];
+
+  for (let startIndex = 1; startIndex < cells.length - 1; ++startIndex) {
+    if (!cells[startIndex - 1].hasTile()) {
+      startIndices.push(startIndex);
+    }
+  }
+
+  return startIndices;
 };
 
 export default generateStartIndices;

package/packages/solver/src/generateVectors.ts

@@ -1,15 +1,12 @@
 import { Cell } from '@scrabble-solver/types';
 
-const generateVectors = ({
-  getNthVector,
-  vectorsCount,
-}: {
+interface Parameters {
   getNthVector: (index: number) => Cell[];
   vectorsCount: number;
-}): Cell[][] => {
-  return Array(vectorsCount)
-    .fill(0)
-    .map((_, index) => getNthVector(index));
+}
+
+const generateVectors = ({ getNthVector, vectorsCount }: Parameters): Cell[][] => {
+  return Array.from({ length: vectorsCount }, (_, index) => getNthVector(index));
 };
 
 export default generateVectors;

package/packages/solver/src/index.ts

@@ -1 +1,13 @@
+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';

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

@@ -70,7 +70,7 @@ describe('solve - PL', () => {
     ]);
     const tiles = generateTiles(['a', 'a', 'ą', 'r', 't', 'w', 'z']);
     const results = solve(trie!, config, board, tiles);
-    const bestResult = getBestResult(results);
+    const bestResult = getBestResult(results.map((result) => Result.fromJson(result)));
     expect(bestResult.word).toBe('zmartwychwstałą');
     expect(bestResult.points).toBe(682);
   });
@@ -95,7 +95,7 @@ describe('solve - PL', () => {
     ]);
     const tiles = generateTiles(['ą', 'c', 'h', 't', 'w', 'w', 'z']);
     const results = solve(trie!, config, board, tiles);
-    const bestResult = getBestResult(results);
+    const bestResult = getBestResult(results.map((result) => Result.fromJson(result)));
     expect(bestResult.word).toBe('zmartwychwstałą');
     expect(bestResult.points).toBe(1157);
   });
@@ -132,7 +132,7 @@ describe('solve - ES', () => {
     ]);
     const tiles = generateTiles(['ll', 'a', 'n', 'a']);
     const results = solve(trie!, config, board, tiles);
-    const bestResult = getBestResult(results);
+    const bestResult = getBestResult(results.map((result) => Result.fromJson(result)));
     expect(results.length).toBe(24);
     expect(bestResult.points).toBe(22);
   });

package/packages/solver/src/solve.ts

@@ -1,24 +1,22 @@
 import { Trie } from '@kamilmielnik/trie';
-import { Board, Config, Result, Tile } from '@scrabble-solver/types';
+import { Board, Config, ResultJson, Tile } from '@scrabble-solver/types';
 
 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[]): Result[] => {
+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 uniquePatterns = getUniquePatterns(filledPatterns);
-  const results = uniquePatterns.map(
-    (pattern, index) =>
-      new Result({
-        cells: pattern.cells,
-        collisions: pattern.getCollisions().map((collision) => collision.cells),
-        id: index,
-        points: getPatternScore(config, pattern),
-      }),
-  );
+  const results = uniquePatterns.map((pattern, index) => ({
+    cells: pattern.cells.map((cell) => cell.toJson()),
+    collisions: pattern.getCollisions().map((collision) => collision.cells.map((cell) => cell.toJson())),
+    id: index,
+    points: getPatternScore(config, pattern),
+  }));
+
   return results;
 };
 

package/packages/types/build/Board.js

@@ -65,7 +65,7 @@ class Board {
     }
     getBlanksCount() {
         return this.rows.reduce((count, row) => {
-            return count + row.reduce((rowCount, cell) => (cell.tile.isBlank ? rowCount + 1 : rowCount), 0);
+            return count + row.reduce((rowCount, cell) => rowCount + (cell.tile.isBlank ? 1 : 0), 0);
         }, 0);
     }
     getColumn(index) {
@@ -76,7 +76,7 @@ class Board {
     }
     getTilesCount() {
         return this.rows.reduce((count, row) => {
-            return count + row.reduce((rowCount, cell) => (cell.hasTile() ? rowCount + 1 : rowCount), 0);
+            return count + row.reduce((rowCount, cell) => rowCount + (cell.hasTile() ? 1 : 0), 0);
         }, 0);
     }
     getWords() {

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

@@ -12,6 +12,7 @@ export { default as Config } from './Config';
 export { default as ConfigJson } from './ConfigJson';
 export { default as FinalPattern } from './FinalPattern';
 export { default as HorizontalPattern } from './HorizontalPattern';
+export { default as isError } from './isError';
 export { default as isObject } from './isObject';
 export { default as Locale, isLocale } from './Locale';
 export { default as Pattern } from './Pattern';