scrabble-solver 2.8.5 → 2.8.7

package/packages/scrabble-solver/src/pages/api/dictionary/[locale]/[word].ts

@@ -1,45 +1,69 @@
+import { scrabble } from '@scrabble-solver/configs';
 import logger from '@scrabble-solver/logger';
-import { Locale } from '@scrabble-solver/types';
+import { isLocale, Locale } from '@scrabble-solver/types';
 import { getWordDefinition } from '@scrabble-solver/word-definitions';
 import { NextApiRequest, NextApiResponse } from 'next';
 
-import { getServerLoggingData, validateLocale, validateWord } from 'api';
+import { getServerLoggingData } from 'api';
 
 interface RequestData {
   locale: Locale;
-  word: string;
+  words: string[];
 }
 
+const MAXIMUM_WORDS_COUNT = scrabble['en-US'].maximumCharactersCount;
+
 const dictionary = async (request: NextApiRequest, response: NextApiResponse): Promise<void> => {
   const meta = getServerLoggingData(request);
 
   try {
-    const { locale, word } = parseRequest(request);
+    const { locale, words } = parseRequest(request);
+
     logger.info('dictionary - request', {
       meta,
       payload: {
         locale,
-        word,
+        words,
       },
     });
-    const result = await getWordDefinition(locale, word);
-    response.status(200).send(result.toJson());
+
+    const results = await Promise.all(words.map((word) => getWordDefinition(locale, word)));
+    response.status(200).send(results.map((result) => result.toJson()));
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Unknown error';
     logger.error('dictionary - error', { error, meta });
     response.status(500).send({ error: 'Server error', message });
+    throw error;
   }
 };
 
 const parseRequest = (request: NextApiRequest): RequestData => {
   const { locale, word } = request.query;
 
-  validateLocale(locale);
-  validateWord(word);
+  if (!isLocale(locale)) {
+    throw new Error('Invalid "locale" parameter');
+  }
+
+  if (typeof word !== 'string' || word.length === 0) {
+    throw new Error('Invalid "word" parameter');
+  }
+
+  const words = Array.from(
+    new Set(
+      word
+        .split(',')
+        .map((part) => part.trim())
+        .filter(Boolean),
+    ),
+  );
+
+  if (words.length > MAXIMUM_WORDS_COUNT) {
+    throw new Error('Invalid "word" parameter');
+  }
 
   return {
-    locale: locale as Locale,
-    word: word as string,
+    locale,
+    words,
   };
 };
 

package/packages/scrabble-solver/src/pages/api/solve.ts

@@ -1,12 +1,13 @@
-import { getLocaleConfig } from '@scrabble-solver/configs';
+import { getLocaleConfig, isConfigId } from '@scrabble-solver/configs';
 import { BLANK } from '@scrabble-solver/constants';
 import { dictionaries } from '@scrabble-solver/dictionaries';
 import logger from '@scrabble-solver/logger';
 import Solver from '@scrabble-solver/solver';
-import { Board, Config, Locale, Tile } from '@scrabble-solver/types';
+import { Board, Config, isBoardJson, isLocale, Locale, Tile } from '@scrabble-solver/types';
 import { NextApiRequest, NextApiResponse } from 'next';
 
-import { getServerLoggingData, validateBoard, validateCharacters, validateConfigId, validateLocale } from 'api';
+import { getServerLoggingData, isBoardValid } from 'api';
+import { isStringArray } from 'lib';
 
 interface RequestData {
   board: Board;
@@ -20,6 +21,7 @@ const solve = async (request: NextApiRequest, response: NextApiResponse): Promis
 
   try {
     const { board, characters, config, locale } = parseRequest(request);
+
     logger.info('solve - request', {
       meta,
       payload: {
@@ -31,7 +33,7 @@ const solve = async (request: NextApiRequest, response: NextApiResponse): Promis
         locale,
       },
     });
-    validateRequest({ board, characters, config, locale });
+
     const trie = await dictionaries.get(locale);
     const tiles = characters.map((character) => new Tile({ character, isBlank: character === BLANK }));
     const solver = new Solver(config, trie);
@@ -41,33 +43,51 @@ const solve = async (request: NextApiRequest, response: NextApiResponse): Promis
     const message = error instanceof Error ? error.message : 'Unknown error';
     logger.error('solve - error', { error, meta });
     response.status(500).send({ error: 'Server error', message });
+    throw error;
   }
 };
 
 const parseRequest = (request: NextApiRequest): RequestData => {
-  const { board, characters, configId, locale } = request.body;
+  const { board: boardJson, characters, configId, locale } = request.body;
+
+  if (!isLocale(locale)) {
+    throw new Error('Invalid "locale" parameter');
+  }
+
+  if (!isConfigId(configId)) {
+    throw new Error('Invalid "configId" parameter');
+  }
 
-  validateConfigId(configId);
-  validateLocale(locale);
   const config = getLocaleConfig(configId, locale);
-  validateBoard(board, config);
-  validateCharacters(characters, config);
 
-  return {
-    board: Board.fromJson(board),
-    characters,
-    config,
-    locale,
-  };
-};
+  if (!isBoardJson(boardJson) || !isBoardValid(boardJson, config)) {
+    throw new Error('Invalid "board" parameter');
+  }
+
+  if (!isStringArray(characters) || characters.length === 0) {
+    throw new Error('Invalid "characters" parameter');
+  }
 
-const validateRequest = ({ board, characters, config }: RequestData): void => {
+  for (const character of characters) {
+    if (!config.hasCharacter(character) && character !== BLANK) {
+      throw new Error('Invalid "characters" parameter');
+    }
+  }
+
+  const board = Board.fromJson(boardJson);
   const blankTilesCount = characters.filter((character) => character === BLANK).length;
   const blanksCount = board.getBlanksCount() + blankTilesCount;
 
-  if (blanksCount > config.numberOfBlanks) {
-    throw new Error(`Too many blank tiles passed (board: ${board.getBlanksCount()}, tiles: ${blankTilesCount})`);
+  if (blanksCount > config.blanksCount) {
+    throw new Error('Too many blank tiles passed');
   }
+
+  return {
+    board,
+    characters,
+    config,
+    locale,
+  };
 };
 
 export default solve;

package/packages/scrabble-solver/src/pages/api/visit.ts

@@ -13,6 +13,7 @@ const visit = async (request: NextApiRequest, response: NextApiResponse): Promis
     const message = error instanceof Error ? error.message : 'Unknown error';
     logger.error('visit - error', { error, meta });
     response.status(500).send({ error: 'Server error', message });
+    throw error;
   }
 };
 

package/packages/scrabble-solver/src/pages/index.module.scss

@@ -25,11 +25,15 @@
   padding: var(--spacing--l);
 }
 
-.logoContainer {
+.navLogo {
   display: flex;
   flex: 1;
 }
 
+.logoContainer {
+  display: flex;
+}
+
 .logo {
   height: 60px;
   user-select: none;
@@ -127,13 +131,3 @@
 .submitInput {
   display: none;
 }
-
-.version {
-  position: fixed;
-  bottom: var(--spacing--m);
-  left: 0;
-  right: 0;
-  font-size: var(--font--size--xs);
-  color: var(--color--background);
-  text-align: center;
-}

package/packages/scrabble-solver/src/pages/index.tsx

@@ -74,8 +74,10 @@ const Index: FunctionComponent<Props> = ({ version }) => {
     <>
       <div className={classNames(styles.index, { [styles.initialized]: isInitialized })}>
         <div className={styles.nav}>
-          <div className={styles.logoContainer}>
-            <Logo className={styles.logo} />
+          <div className={styles.navLogo}>
+            <a className={styles.logoContainer} href="/" title={version}>
+              <Logo className={styles.logo} />
+            </a>
           </div>
 
           <NavButtons
@@ -114,8 +116,6 @@ const Index: FunctionComponent<Props> = ({ version }) => {
           <Rack className={styles.rack} />
           <input className={styles.submitInput} tabIndex={-1} type="submit" />
         </form>
-
-        <span className={styles.version}>v{version}</span>
       </div>
 
       <Settings isOpen={showSettings} onClose={() => setShowSettings(false)} />
@@ -138,7 +138,7 @@ const readVersion = async (): Promise<string> => {
   const packageJsonFilepath = path.resolve(process.cwd(), 'package.json');
   const data = await fs.promises.readFile(packageJsonFilepath, 'utf-8');
   const packageJson = JSON.parse(data);
-  return packageJson.version;
+  return `v${packageJson.version}`;
 };
 
 export default Index;

package/packages/scrabble-solver/src/sdk/{findWordDefinition.ts → findWordDefinitions.ts}

@@ -1,9 +1,9 @@
 import { Locale, WordDefinition } from '@scrabble-solver/types';
 
-const findWordDefinition = async (locale: Locale, word: string): Promise<WordDefinition> => {
+const findWordDefinitions = async (locale: Locale, word: string): Promise<WordDefinition[]> => {
   const url = `/api/dictionary/${locale}/${word}`;
   const json = await fetch(url).then((response) => response.json());
-  return WordDefinition.fromJson(json);
+  return json.map(WordDefinition.fromJson);
 };
 
-export default findWordDefinition;
+export default findWordDefinitions;

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

@@ -1,3 +1,3 @@
-export { default as findWordDefinition } from './findWordDefinition';
+export { default as findWordDefinitions } from './findWordDefinitions';
 export { default as solve } from './solve';
 export { default as visit } from './visit';

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 { findWordDefinition, solve, visit } from 'sdk';
+import { findWordDefinitions, solve, visit } from 'sdk';
 
 import { initialize, reset } from './actions';
 import {
@@ -18,7 +18,7 @@ import { boardSlice, dictionarySlice, rackSlice, resultsSlice, settingsSlice, so
 
 const SUBMIT_DELAY = 150;
 
-const memoizedFindWordDefinition = memoize(findWordDefinition);
+const memoizedFindWordDefinitions = memoize(findWordDefinitions);
 
 // Can't conveniently type generators for sagas yet,
 // see: https://github.com/microsoft/TypeScript/issues/43632
@@ -53,13 +53,13 @@ function* onDictionarySubmit(): AnyGenerator {
   const { input: word } = yield select(selectDictionary);
   const locale = yield select(selectLocale);
 
-  if (!memoizedFindWordDefinition.hasCache(locale, word)) {
+  if (!memoizedFindWordDefinitions.hasCache(locale, word)) {
     yield delay(SUBMIT_DELAY);
   }
 
   try {
-    const wordDefinition = yield call(memoizedFindWordDefinition, locale, word);
-    yield put(dictionarySlice.actions.submitSuccess(wordDefinition));
+    const wordDefinitions = yield call(memoizedFindWordDefinitions, locale, word);
+    yield put(dictionarySlice.actions.submitSuccess(wordDefinitions));
   } catch (error) {
     yield put(dictionarySlice.actions.submitFailure());
   }
@@ -85,7 +85,7 @@ function* onLocaleChange(): AnyGenerator {
 
 function* onResultCandidateChange({ payload: result }: PayloadAction<Result | null>): AnyGenerator {
   if (result) {
-    yield put(dictionarySlice.actions.changeInput(result.word));
+    yield put(dictionarySlice.actions.changeInput(result.words.join(', ')));
     yield put(dictionarySlice.actions.submit());
   }
 }
@@ -121,12 +121,12 @@ function* ensureProperTilesCount(): AnyGenerator {
   const { config } = yield select(selectConfig);
   const characters = yield select(selectCharacters);
 
-  if (config.maximumNumberOfCharacters > characters.length) {
-    const differenceCount = Math.abs(config.maximumNumberOfCharacters - characters.length);
+  if (config.maximumCharactersCount > characters.length) {
+    const differenceCount = Math.abs(config.maximumCharactersCount - characters.length);
     yield put(rackSlice.actions.init([...characters, ...Array(differenceCount).fill(null)]));
-  } else if (config.maximumNumberOfCharacters < characters.length) {
-    const nonNulls = characters.filter(Boolean).slice(0, config.maximumNumberOfCharacters);
-    const differenceCount = Math.abs(config.maximumNumberOfCharacters - nonNulls.length);
+  } else if (config.maximumCharactersCount < characters.length) {
+    const nonNulls = characters.filter(Boolean).slice(0, config.maximumCharactersCount);
+    const differenceCount = Math.abs(config.maximumCharactersCount - nonNulls.length);
     const autoGroupTiles = yield select(selectAutoGroupTiles);
     yield put(rackSlice.actions.init([...nonNulls, ...Array(differenceCount).fill(null)]));
     yield put(rackSlice.actions.groupTiles(autoGroupTiles));

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

@@ -59,8 +59,12 @@ export const selectSortedFilteredResults = createSelector(
     }
 
     return results.filter((result) => {
-      const regExp = new RegExp(query, 'gi');
-      return regExp.test(result.word);
+      try {
+        const regExp = new RegExp(query, 'gi');
+        return regExp.test(result.word);
+      } catch {
+        return false;
+      }
     });
   },
 );

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

@@ -1,9 +1,9 @@
+import { WordDefinition } from '@scrabble-solver/types';
+
 const dictionaryInitialState = {
-  definitions: [] as string[],
   input: '',
-  isAllowed: null as boolean | null,
   isLoading: false,
-  word: undefined as string | undefined,
+  results: [] as WordDefinition[],
 };
 
 export default dictionaryInitialState;

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

@@ -16,30 +16,24 @@ const dictionarySlice = createSlice({
     submit: (state) => {
       return {
         ...state,
-        definitions: dictionaryInitialState.definitions,
-        isAllowed: dictionaryInitialState.isAllowed,
         isLoading: true,
-        word: dictionaryInitialState.word,
+        results: dictionaryInitialState.results,
       };
     },
 
     submitFailure: (state) => {
       return {
         ...state,
-        definitions: dictionaryInitialState.definitions,
-        isAllowed: false,
         isLoading: false,
-        word: state.input,
+        results: dictionaryInitialState.results,
       };
     },
 
-    submitSuccess: (state, action: PayloadAction<WordDefinition>) => {
+    submitSuccess: (state, action: PayloadAction<WordDefinition[]>) => {
       return {
         ...state,
-        definitions: action.payload.definitions,
-        isAllowed: action.payload.isAllowed,
         isLoading: false,
-        word: action.payload.word,
+        results: action.payload,
       };
     },
   },

package/packages/solver/build/PatternsFiller.js

@@ -9,7 +9,7 @@ class PatternsFiller {
     }
     fill(pattern, tiles) {
         const patterns = [];
-        if (pattern.getNumberOfEmptyCells() > tiles.length) {
+        if (pattern.getEmptyCellsCount() > tiles.length) {
             return [];
         }
         const onPatternFound = (newPattern) => patterns.push(newPattern);

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

@@ -5,18 +5,18 @@ declare class PatternsGenerator {
     generate(board: Board): Pattern[];
     generateHorizontal(board: Board): HorizontalPattern[];
     generateVertical(board: Board): VerticalPattern[];
-    generatePatterns<P extends Pattern>({ board, getNthVector, numberOfVectors, PatternModel, }: {
+    generatePatterns<P extends Pattern>({ board, getNthVector, vectorsCount, PatternModel, }: {
         board: Board;
         getNthVector: (index: number) => Cell[];
-        numberOfVectors: number;
         PatternModel: new (parameters: {
             board: Board;
             cells: Cell[];
         }) => P;
+        vectorsCount: number;
     }): P[];
-    generateVectors({ getNthVector, numberOfVectors, }: {
+    generateVectors({ getNthVector, vectorsCount, }: {
         getNthVector: (index: number) => Cell[];
-        numberOfVectors: number;
+        vectorsCount: number;
     }): Cell[][];
     generateCellsPatterns<P extends Pattern>({ board, cells, PatternModel, }: {
         board: Board;

package/packages/solver/build/PatternsGenerator.js

@@ -12,25 +12,25 @@ class PatternsGenerator {
         return this.generatePatterns({
             board,
             getNthVector: (index) => board.getRow(index),
-            numberOfVectors: this.config.boardHeight,
             PatternModel: types_1.HorizontalPattern,
+            vectorsCount: this.config.boardHeight,
         });
     }
     generateVertical(board) {
         return this.generatePatterns({
             board,
             getNthVector: (index) => board.getColumn(index),
-            numberOfVectors: this.config.boardWidth,
             PatternModel: types_1.VerticalPattern,
+            vectorsCount: this.config.boardWidth,
         });
     }
-    generatePatterns({ board, getNthVector, numberOfVectors, PatternModel, }) {
-        return this.generateVectors({ getNthVector, numberOfVectors }).reduce((patterns, cells) => {
+    generatePatterns({ board, getNthVector, vectorsCount, PatternModel, }) {
+        return this.generateVectors({ getNthVector, vectorsCount }).reduce((patterns, cells) => {
             return patterns.concat(this.generateCellsPatterns({ board, PatternModel, cells }));
         }, []);
     }
-    generateVectors({ getNthVector, numberOfVectors, }) {
-        return Array(numberOfVectors)
+    generateVectors({ getNthVector, vectorsCount, }) {
+        return Array(vectorsCount)
             .fill(0)
             .map((_, index) => getNthVector(index));
     }

package/packages/solver/build/ScoresCalculator.js

@@ -18,7 +18,7 @@ class ScoresCalculator {
         return this.calculatePatternScoreWithCollisions(pattern) + this.calculateBonusScore(pattern);
     }
     calculateBonusScore(pattern) {
-        const areAllTilesUsed = pattern.getNumberOfEmptyCells() === this.config.maximumNumberOfCharacters;
+        const areAllTilesUsed = pattern.getEmptyCellsCount() === this.config.maximumCharactersCount;
         return areAllTilesUsed ? this.config.allTilesBonusScore : 0;
     }
     calculatePatternScoreWithCollisions(pattern) {

package/packages/solver/build/Solver.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@scrabble-solver/types");
-const uniqBy_1 = __importDefault(require("lodash/uniqBy"));
+const getUniquePatterns_1 = __importDefault(require("./getUniquePatterns"));
 const PatternsFiller_1 = __importDefault(require("./PatternsFiller"));
 const PatternsGenerator_1 = __importDefault(require("./PatternsGenerator"));
 const ScoresCalculator_1 = __importDefault(require("./ScoresCalculator"));
@@ -17,11 +17,11 @@ class Solver {
     solve(board, tiles) {
         const patterns = this.patternsGenerator.generate(board);
         const filledPatterns = patterns.flatMap((pattern) => this.patternsFiller.fill(pattern, tiles));
-        const uniquePatterns = (0, uniqBy_1.default)(filledPatterns, (pattern) => JSON.stringify(pattern.toJson()));
+        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,
-            numberOfCollisions: pattern.getCollisions().length,
             points: this.scoresCalculator.calculate(pattern),
         }));
         return results;

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

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

package/packages/solver/build/getUniquePatterns.js

@@ -0,0 +1,25 @@
+"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('-');
+};
+const getUniquePatterns = (patterns) => {
+    const hashes = new Set();
+    const uniquePatterns = [];
+    for (const pattern of patterns) {
+        const hash = getPatternHash(pattern);
+        if (!hashes.has(hash)) {
+            hashes.add(hash);
+            uniquePatterns.push(pattern);
+        }
+    }
+    return uniquePatterns;
+};
+exports.default = getUniquePatterns;

package/packages/solver/package-lock.json

@@ -1,19 +1,15 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.5",
+  "version": "2.8.7",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrabble-solver/solver",
-      "version": "2.8.5",
+      "version": "2.8.7",
       "license": "CC-BY-NC-ND-4.0",
       "dependencies": {
-        "@kamilmielnik/trie": "^2.0.0",
-        "lodash": "^4.17.21"
-      },
-      "devDependencies": {
-        "@types/lodash": "^4.14.186"
+        "@kamilmielnik/trie": "^2.0.0"
       }
     },
     "node_modules/@kamilmielnik/trie": {
@@ -23,17 +19,6 @@
       "engines": {
         "node": ">=16"
       }
-    },
-    "node_modules/@types/lodash": {
-      "version": "4.14.186",
-      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.186.tgz",
-      "integrity": "sha512-eHcVlLXP0c2FlMPm56ITode2AgLMSa6aJ05JTTbYbI+7EMkCEE5qk2E41d5g2lCVTqRe0GnnRFurmlCsDODrPw==",
-      "dev": true
-    },
-    "node_modules/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
     }
   },
   "dependencies": {
@@ -41,17 +26,6 @@
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-2.0.0.tgz",
       "integrity": "sha512-YWTYtrV97bQ5hRifG1FImP47PI400a56O8+oQClQOtDjY3tioxab4sOgFHckiDdswciN1RwngCZ9Kv3phJfSuA=="
-    },
-    "@types/lodash": {
-      "version": "4.14.186",
-      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.186.tgz",
-      "integrity": "sha512-eHcVlLXP0c2FlMPm56ITode2AgLMSa6aJ05JTTbYbI+7EMkCEE5qk2E41d5g2lCVTqRe0GnnRFurmlCsDODrPw==",
-      "dev": true
-    },
-    "lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
     }
   }
 }

package/packages/solver/package.json

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

package/packages/solver/src/PatternsFiller.ts

@@ -15,7 +15,7 @@ class PatternsFiller {
   public fill(pattern: Pattern, tiles: Tile[]): Pattern[] {
     const patterns: Pattern[] = [];
 
-    if (pattern.getNumberOfEmptyCells() > tiles.length) {
+    if (pattern.getEmptyCellsCount() > tiles.length) {
       return [];
     }
 

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

@@ -8,7 +8,7 @@ const board = Board.fromStringArray([' t ', 'do ', '   ']);
 const patternsGenerator = new PatternsGenerator({
   boardHeight: 3,
   boardWidth: 3,
-  maximumNumberOfCharacters: 7,
+  maximumCharactersCount: 7,
 } as Config);
 
 describe('PatternsGenerator', () => {
@@ -45,7 +45,7 @@ describe('PatternsGenerator', () => {
   it('generates vectors', () => {
     const vectors = patternsGenerator.generateVectors({
       getNthVector: () => [],
-      numberOfVectors: 3,
+      vectorsCount: 3,
     });
     expect(vectors.length).toBe(3);
     expect(vectors).toEqual([[], [], []]);