@scrabble-solver/scrabble-solver 2.8.6 → 2.8.8

package/.next/server/pages/api/dictionary/[locale]/[word].js

@@ -110,30 +110,37 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(52954);
-/* harmony import */ var _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _scrabble_solver_word_definitions__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(98173);
-/* harmony import */ var _scrabble_solver_word_definitions__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_word_definitions__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var api__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(53888);
+/* harmony import */ var _scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27911);
+/* harmony import */ var _scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(52954);
+/* harmony import */ var _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(46452);
+/* harmony import */ var _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_types__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _scrabble_solver_word_definitions__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(98173);
+/* harmony import */ var _scrabble_solver_word_definitions__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_word_definitions__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var api__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(81025);
 
 
 
+
+
+const MAXIMUM_WORDS_COUNT = _scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0__.scrabble["en-US"].maximumCharactersCount;
 const dictionary = async (request, response)=>{
-    const meta = (0,api__WEBPACK_IMPORTED_MODULE_2__/* .getServerLoggingData */ .X8)(request);
+    const meta = (0,api__WEBPACK_IMPORTED_MODULE_4__/* .getServerLoggingData */ .X8)(request);
     try {
-        const { locale , word  } = parseRequest(request);
-        _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_0___default().info("dictionary - request", {
+        const { locale , words  } = parseRequest(request);
+        _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_1___default().info("dictionary - request", {
             meta,
             payload: {
                 locale,
-                word
+                words
             }
         });
-        const result = await (0,_scrabble_solver_word_definitions__WEBPACK_IMPORTED_MODULE_1__.getWordDefinition)(locale, word);
-        response.status(200).send(result.toJson());
+        const results = await Promise.all(words.map((word)=>(0,_scrabble_solver_word_definitions__WEBPACK_IMPORTED_MODULE_3__.getWordDefinition)(locale, word)));
+        response.status(200).send(results.map((result)=>result.toJson()));
     } catch (error) {
         const message = error instanceof Error ? error.message : "Unknown error";
-        _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_0___default().error("dictionary - error", {
+        _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_1___default().error("dictionary - error", {
             error,
             meta
         });
@@ -141,15 +148,24 @@ const dictionary = async (request, response)=>{
             error: "Server error",
             message
         });
+        throw error;
     }
 };
 const parseRequest = (request)=>{
     const { locale , word  } = request.query;
-    (0,api__WEBPACK_IMPORTED_MODULE_2__/* .validateLocale */ .Qb)(locale);
-    (0,api__WEBPACK_IMPORTED_MODULE_2__/* .validateWord */ .yd)(word);
+    if (!(0,_scrabble_solver_types__WEBPACK_IMPORTED_MODULE_2__.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,
-        word: word
+        locale,
+        words
     };
 };
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (dictionary);
@@ -669,7 +685,7 @@ exports["default"] = parseSpanish;
 var __webpack_require__ = require("../../../../webpack-api-runtime.js");
 __webpack_require__.C(exports);
 var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
-var __webpack_exports__ = __webpack_require__.X(0, [50,865,907], () => (__webpack_exec__(15548)));
+var __webpack_exports__ = __webpack_require__.X(0, [50,865,939,911], () => (__webpack_exec__(15548)));
 module.exports = __webpack_exports__;
 
 })();

package/.next/server/pages/api/dictionary/[locale]/[word].js.nft.json

@@ -1 +1 @@
-{"version":1,"files":["../../../../webpack-api-runtime.js","../../../../chunks/50.js","../../../../chunks/865.js","../../../../chunks/907.js","../../../../../package.json"]}
+{"version":1,"files":["../../../../webpack-api-runtime.js","../../../../chunks/50.js","../../../../chunks/865.js","../../../../chunks/939.js","../../../../chunks/911.js","../../../../../package.json"]}

package/.next/server/pages/api/solve.js

@@ -500,25 +500,329 @@ Object.defineProperty(exports, "MemoryCache", ({ enumerable: true, get: function
 
 /***/ }),
 
-/***/ 38104:
+/***/ 207:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
+// ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-/* harmony import */ var _scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27911);
-/* harmony import */ var _scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _scrabble_solver_constants__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(38436);
-/* harmony import */ var _scrabble_solver_dictionaries__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(89044);
-/* harmony import */ var _scrabble_solver_dictionaries__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_dictionaries__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(52954);
-/* harmony import */ var _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var _scrabble_solver_solver__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(40368);
-/* harmony import */ var _scrabble_solver_solver__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_solver__WEBPACK_IMPORTED_MODULE_4__);
-/* harmony import */ var _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(46452);
-/* harmony import */ var _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5__);
-/* harmony import */ var api__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(53888);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (/* binding */ api_solve)
+});
+
+// EXTERNAL MODULE: ../configs/build/index.js
+var build = __webpack_require__(27911);
+// EXTERNAL MODULE: ../constants/build/index.js
+var constants_build = __webpack_require__(38436);
+// EXTERNAL MODULE: ../dictionaries/build/index.js
+var dictionaries_build = __webpack_require__(89044);
+// EXTERNAL MODULE: ../logger/build/index.js
+var logger_build = __webpack_require__(52954);
+var logger_build_default = /*#__PURE__*/__webpack_require__.n(logger_build);
+// EXTERNAL MODULE: ../solver/build/index.js
+var solver_build = __webpack_require__(40368);
+var solver_build_default = /*#__PURE__*/__webpack_require__.n(solver_build);
+// EXTERNAL MODULE: ../types/build/index.js
+var types_build = __webpack_require__(46452);
+// EXTERNAL MODULE: ./src/api/index.ts + 4 modules
+var api = __webpack_require__(81025);
+;// CONCATENATED MODULE: ./src/lib/canUseDom.ts
+const canUseDom = Boolean( false && 0);
+/* harmony default export */ const lib_canUseDom = ((/* unused pure expression or super */ null && (canUseDom)));
+
+;// CONCATENATED MODULE: ./src/lib/detectLocale.ts
+
+const detectLocale = ()=>{
+    if (window.navigator.languages.includes("pl") || window.navigator.languages.includes("pl-PL")) {
+        return Locale.PL_PL;
+    }
+    if (window.navigator.languages.includes("en-GB")) {
+        return Locale.EN_GB;
+    }
+    if (window.navigator.languages.includes("fr-FR")) {
+        return Locale.FR_FR;
+    }
+    return Locale.EN_US;
+};
+/* harmony default export */ const lib_detectLocale = ((/* unused pure expression or super */ null && (detectLocale)));
+
+;// CONCATENATED MODULE: ./src/parameters/index.ts
+const GITHUB_PROJECT_URL = "https://github.com/kamilmielnik/scrabble-solver";
+const TRANSITION_DURATION = 100;
+const TRANSITION_DURATION_LONG = 250;
+const COLOR_BLUE = "#c7d8f9";
+const COLOR_GREEN = "#bae3ba";
+const COLOR_RED = "#f7c2aa";
+const COLOR_YELLOW = "#efe3ae";
+const COMPONENTS_SPACING = 40;
+const COMPONENTS_SPACING_MOBILE = 20;
+const parameters_BOARD_CELL_BORDER_WIDTH = 1;
+const parameters_BOARD_TILE_FONT_SIZE_MIN = 14;
+const parameters_BOARD_TILE_FONT_SIZE_POINTS_MIN = 10;
+const parameters_BOARD_TILE_SIZE_MAX = 64;
+const parameters_BOARD_TILE_SIZE_MIN = 32;
+const DICTIONARY_HEIGHT = 220;
+const TILE_SIZE = 80;
+const PLAIN_TILES_COLOR_DEFAULT = (/* unused pure expression or super */ null && (COLOR_GREEN));
+const PLAIN_TILES_PADDING_HORIZONTAL = 0;
+const PLAIN_TILES_PADDING_VERTICAL = 0;
+const PLAIN_TILES_POINTS_COLORS = {
+    1: COLOR_YELLOW,
+    2: COLOR_GREEN,
+    3: COLOR_BLUE,
+    4: COLOR_RED,
+    5: COLOR_RED,
+    6: COLOR_RED,
+    7: COLOR_RED,
+    8: COLOR_RED,
+    9: COLOR_RED,
+    10: COLOR_RED
+};
+const PLAIN_TILES_TILE_MARGIN = 6;
+const PLAIN_TILES_TILE_MAX_ROTATE = 0;
+const PLAIN_TILES_TILE_MAX_SCATTER = 0;
+const PLAIN_TILES_TILE_SIZE = 80;
+const PLAIN_TILES_VERSION_TILE_COLOR = (/* unused pure expression or super */ null && (COLOR_GREEN));
+const PLAIN_TILES_VERSION_TILE_SIZE = (/* unused pure expression or super */ null && (TILE_SIZE));
+const REMAINING_TILES_TILE_SIZE = 50;
+const RESULTS_HEADER_HEIGHT = 35;
+const RESULTS_ITEM_HEIGHT = 34;
+const RESULTS_INPUT_HEIGHT = 43;
+
+;// CONCATENATED MODULE: ./src/lib/getCellSize.ts
+
+const getCellSize = (config, width, height)=>{
+    const maxWidth = (width - BOARD_CELL_BORDER_WIDTH) / config.boardWidth - BOARD_CELL_BORDER_WIDTH;
+    const maxHeight = (height - BOARD_CELL_BORDER_WIDTH) / config.boardHeight - BOARD_CELL_BORDER_WIDTH;
+    const cellSize = Math.min(maxWidth, maxHeight);
+    return Math.floor(Math.min(Math.max(cellSize, BOARD_TILE_SIZE_MIN), BOARD_TILE_SIZE_MAX));
+};
+/* harmony default export */ const lib_getCellSize = ((/* unused pure expression or super */ null && (getCellSize)));
+
+;// CONCATENATED MODULE: ./src/lib/getRemainingTiles.ts
+
+
+const getRemainingTiles = (config, board, characters)=>{
+    const nonEmptyCells = board.rows.flat().filter((cell)=>!cell.isEmpty);
+    const letterCells = nonEmptyCells.filter((cell)=>!cell.tile.isBlank);
+    const remainingTiles = Object.fromEntries(config.tiles.map((tile)=>[
+            tile.character,
+            {
+                ...tile,
+                usedCount: 0
+            }
+        ]));
+    const blank = {
+        character: BLANK,
+        count: config.blanksCount,
+        score: config.blankScore,
+        usedCount: nonEmptyCells.filter((cell)=>cell.tile.isBlank).length + characters.filter((character)=>character === BLANK).length
+    };
+    const letters = [
+        ...letterCells.map((cell)=>cell.tile.character),
+        ...characters.filter((letter)=>letter !== BLANK), 
+    ];
+    const unknownLetters = letters.filter((letter)=>typeof remainingTiles[letter] === "undefined");
+    for (const letter of unknownLetters){
+        remainingTiles[letter] = {
+            character: letter,
+            count: 0,
+            score: 0,
+            usedCount: 0
+        };
+    }
+    for (const letter1 of letters){
+        ++remainingTiles[letter1].usedCount;
+    }
+    return [
+        ...Object.values(remainingTiles).sort(createKeyComparator("character")),
+        blank
+    ];
+};
+/* harmony default export */ const lib_getRemainingTiles = ((/* unused pure expression or super */ null && (getRemainingTiles)));
+
+;// CONCATENATED MODULE: ./src/lib/getRemainingTilesGroups.ts
+
+
+
+const getRemainingTilesGroups = (remainingTiles)=>{
+    const consonants = remainingTiles.filter(({ character  })=>CONSONANTS.includes(character));
+    const vowels = remainingTiles.filter(({ character  })=>VOWELS.includes(character));
+    const twoCharacterTiles = remainingTiles.filter(({ character  })=>character.length === 2);
+    const blanks = remainingTiles.filter(({ character  })=>character === BLANK);
+    const groups = [
+        {
+            remainingCount: getRemainingTilesCount(vowels),
+            tiles: vowels,
+            translationKey: "common.vowels",
+            totalCount: getTotalRemainingTilesCount(vowels)
+        },
+        {
+            remainingCount: getRemainingTilesCount(consonants),
+            tiles: consonants,
+            translationKey: "common.consonants",
+            totalCount: getTotalRemainingTilesCount(consonants)
+        },
+        {
+            remainingCount: getRemainingTilesCount(twoCharacterTiles),
+            tiles: twoCharacterTiles,
+            translationKey: "common.two-letter-tiles",
+            totalCount: getTotalRemainingTilesCount(twoCharacterTiles)
+        },
+        {
+            remainingCount: getRemainingTilesCount(blanks),
+            tiles: blanks,
+            translationKey: "common.blanks",
+            totalCount: getTotalRemainingTilesCount(blanks)
+        }, 
+    ];
+    return groups.filter(({ totalCount  })=>totalCount > 0);
+};
+/* harmony default export */ const lib_getRemainingTilesGroups = ((/* unused pure expression or super */ null && (getRemainingTilesGroups)));
+
+;// CONCATENATED MODULE: ./src/lib/getTileSizes.ts
+
+const getTileSizes = (tileSize)=>({
+        pointsFontSize: Math.max(Math.round(tileSize * 0.25), BOARD_TILE_FONT_SIZE_POINTS_MIN),
+        tileFontSize: Math.max(Math.round(tileSize * 0.6), BOARD_TILE_FONT_SIZE_MIN),
+        tileSize
+    });
+/* harmony default export */ const lib_getTileSizes = ((/* unused pure expression or super */ null && (getTileSizes)));
+
+;// CONCATENATED MODULE: ./src/lib/isStringArray.ts
+const isStringArray = (value)=>{
+    return Array.isArray(value) && value.every((item)=>typeof item === "string");
+};
+/* harmony default export */ const lib_isStringArray = (isStringArray);
+
+;// CONCATENATED MODULE: ./src/types/index.ts
+var types_SortDirection;
+(function(SortDirection) {
+    SortDirection["Ascending"] = "ascending";
+    SortDirection["Descending"] = "descending";
+})(types_SortDirection || (types_SortDirection = {}));
+var ResultColumn;
+(function(ResultColumn) {
+    ResultColumn["BlanksCount"] = "blanks-count";
+    ResultColumn["ConsonantsCount"] = "consonants-count";
+    ResultColumn["Points"] = "points";
+    ResultColumn["TilesCount"] = "tiles-count";
+    ResultColumn["VowelsCount"] = "vowels-count";
+    ResultColumn["Word"] = "word";
+    ResultColumn["WordsCount"] = "words-count";
+})(ResultColumn || (ResultColumn = {}));
+
+;// CONCATENATED MODULE: ./src/lib/numberComparator.ts
+const numberComparator = (a, b)=>a - b;
+/* harmony default export */ const lib_numberComparator = (numberComparator);
+
+;// CONCATENATED MODULE: ./src/lib/stringComparator.ts
+const stringComparator = (a, b)=>a.localeCompare(b);
+/* harmony default export */ const lib_stringComparator = (stringComparator);
+
+;// CONCATENATED MODULE: ./src/lib/createKeyComparator.ts
+
+
+const createKeyComparator_createKeyComparator = (key)=>{
+    return (a, b)=>{
+        const aValue = a[key];
+        const bValue = b[key];
+        if (typeof aValue === "string" && typeof bValue === "string") {
+            return lib_stringComparator(aValue, bValue);
+        }
+        if (typeof aValue === "number" && typeof bValue === "number") {
+            return lib_numberComparator(aValue, bValue);
+        }
+        return 0;
+    };
+};
+/* harmony default export */ const lib_createKeyComparator = (createKeyComparator_createKeyComparator);
+
+;// CONCATENATED MODULE: ./src/lib/sortResults.ts
+
+
+
+const comparators = {
+    [ResultColumn.BlanksCount]: lib_createKeyComparator("blanksCount"),
+    [ResultColumn.ConsonantsCount]: lib_createKeyComparator("consonantsCount"),
+    [ResultColumn.Points]: lib_createKeyComparator("points"),
+    [ResultColumn.TilesCount]: lib_createKeyComparator("tilesCount"),
+    [ResultColumn.VowelsCount]: lib_createKeyComparator("vowelsCount"),
+    [ResultColumn.Word]: lib_createKeyComparator("word"),
+    [ResultColumn.WordsCount]: lib_createKeyComparator("wordsCount")
+};
+const sortResults = (results, column, sortDirection)=>{
+    if (typeof results === "undefined") {
+        return results;
+    }
+    const comparator = comparators[column];
+    const finalComparator = sortDirection === SortDirection.Descending ? reverseComparator(comparator) : comparator;
+    return [
+        ...results
+    ].sort(finalComparator);
+};
+/* harmony default export */ const lib_sortResults = ((/* unused pure expression or super */ null && (sortResults)));
+
+;// CONCATENATED MODULE: ./src/lib/zipCharactersAndTiles.ts
+
+const zipCharactersAndTiles = (characters, tiles)=>{
+    let remainingTiles = [
+        ...tiles
+    ];
+    return characters.map((character)=>{
+        const index = remainingTiles.findIndex((tile)=>character === BLANK ? tile.isBlank : character === tile.character);
+        if (index >= 0) {
+            const tile = remainingTiles[index];
+            remainingTiles = [
+                ...remainingTiles.slice(0, index),
+                ...remainingTiles.slice(index + 1)
+            ];
+            return {
+                character,
+                tile
+            };
+        }
+        return {
+            character,
+            tile: null
+        };
+    });
+};
+/* harmony default export */ const lib_zipCharactersAndTiles = ((/* unused pure expression or super */ null && (zipCharactersAndTiles)));
+
+;// CONCATENATED MODULE: ./src/lib/index.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// CONCATENATED MODULE: ./src/pages/api/solve.ts
+
 
 
 
@@ -527,10 +831,10 @@ __webpack_require__.r(__webpack_exports__);
 
 
 const solve = async (request, response)=>{
-    const meta = (0,api__WEBPACK_IMPORTED_MODULE_6__/* .getServerLoggingData */ .X8)(request);
+    const meta = (0,api/* getServerLoggingData */.X8)(request);
     try {
         const { board , characters , config , locale  } = parseRequest(request);
-        _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3___default().info("solve - request", {
+        logger_build_default().info("solve - request", {
             meta,
             payload: {
                 board: board.toString(),
@@ -541,23 +845,17 @@ const solve = async (request, response)=>{
                 locale
             }
         });
-        validateRequest({
-            board,
-            characters,
-            config,
-            locale
-        });
-        const trie = await _scrabble_solver_dictionaries__WEBPACK_IMPORTED_MODULE_2__.dictionaries.get(locale);
-        const tiles = characters.map((character)=>new _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5__.Tile({
+        const trie = await dictionaries_build.dictionaries.get(locale);
+        const tiles = characters.map((character)=>new types_build.Tile({
                 character,
-                isBlank: character === _scrabble_solver_constants__WEBPACK_IMPORTED_MODULE_1__.BLANK
+                isBlank: character === constants_build.BLANK
             }));
-        const solver = new (_scrabble_solver_solver__WEBPACK_IMPORTED_MODULE_4___default())(config, trie);
+        const solver = new (solver_build_default())(config, trie);
         const results = solver.solve(board, tiles);
         response.status(200).send(results.map((result)=>result.toJson()));
     } catch (error) {
         const message = error instanceof Error ? error.message : "Unknown error";
-        _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3___default().error("solve - error", {
+        logger_build_default().error("solve - error", {
             error,
             meta
         });
@@ -565,30 +863,43 @@ const solve = async (request, response)=>{
             error: "Server error",
             message
         });
+        throw error;
     }
 };
 const parseRequest = (request)=>{
-    const { board , characters , configId , locale  } = request.body;
-    (0,api__WEBPACK_IMPORTED_MODULE_6__/* .validateConfigId */ .Qm)(configId);
-    (0,api__WEBPACK_IMPORTED_MODULE_6__/* .validateLocale */ .Qb)(locale);
-    const config = (0,_scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0__.getLocaleConfig)(configId, locale);
-    (0,api__WEBPACK_IMPORTED_MODULE_6__/* .validateBoard */ .U4)(board, config);
-    (0,api__WEBPACK_IMPORTED_MODULE_6__/* .validateCharacters */ .EN)(characters, config);
+    const { board: boardJson , characters , configId , locale  } = request.body;
+    if (!(0,types_build.isLocale)(locale)) {
+        throw new Error('Invalid "locale" parameter');
+    }
+    if (!(0,build.isConfigId)(configId)) {
+        throw new Error('Invalid "configId" parameter');
+    }
+    const config = (0,build.getLocaleConfig)(configId, locale);
+    if (!(0,types_build.isBoardJson)(boardJson) || !(0,api/* isBoardValid */.p2)(boardJson, config)) {
+        throw new Error('Invalid "board" parameter');
+    }
+    if (!lib_isStringArray(characters) || characters.length === 0) {
+        throw new Error('Invalid "characters" parameter');
+    }
+    for (const character of characters){
+        if (!config.hasCharacter(character) && character !== constants_build.BLANK) {
+            throw new Error('Invalid "characters" parameter');
+        }
+    }
+    const board = types_build.Board.fromJson(boardJson);
+    const blankTilesCount = characters.filter((character)=>character === constants_build.BLANK).length;
+    const blanksCount = board.getBlanksCount() + blankTilesCount;
+    if (blanksCount > config.blanksCount) {
+        throw new Error("Too many blank tiles passed");
+    }
     return {
-        board: _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5__.Board.fromJson(board),
+        board,
         characters,
         config,
         locale
     };
 };
-const validateRequest = ({ board , characters , config  })=>{
-    const blankTilesCount = characters.filter((character)=>character === _scrabble_solver_constants__WEBPACK_IMPORTED_MODULE_1__.BLANK).length;
-    const blanksCount = board.getBlanksCount() + blankTilesCount;
-    if (blanksCount > config.numberOfBlanks) {
-        throw new Error(`Too many blank tiles passed (board: ${board.getBlanksCount()}, tiles: ${blankTilesCount})`);
-    }
-};
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (solve);
+/* harmony default export */ const api_solve = (solve);
 
 
 /***/ }),
@@ -607,7 +918,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);
@@ -687,25 +998,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));
     }
@@ -766,7 +1077,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) {
@@ -796,7 +1107,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const types_1 = __webpack_require__(46452);
-const uniqBy_1 = __importDefault(__webpack_require__(50285));
+const getUniquePatterns_1 = __importDefault(__webpack_require__(55555));
 const PatternsFiller_1 = __importDefault(__webpack_require__(6700));
 const PatternsGenerator_1 = __importDefault(__webpack_require__(34196));
 const ScoresCalculator_1 = __importDefault(__webpack_require__(19368));
@@ -809,11 +1120,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;
@@ -822,6 +1133,38 @@ class Solver {
 exports["default"] = Solver;
 
 
+/***/ }),
+
+/***/ 55555:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+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;
+
+
 /***/ }),
 
 /***/ 40368:
@@ -1265,7 +1608,7 @@ Object.defineProperty(exports, "getTxtWordList", ({ enumerable: true, get: funct
 var __webpack_require__ = require("../../webpack-api-runtime.js");
 __webpack_require__.C(exports);
 var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
-var __webpack_exports__ = __webpack_require__.X(0, [50,206,907], () => (__webpack_exec__(38104)));
+var __webpack_exports__ = __webpack_require__.X(0, [50,429,939,911], () => (__webpack_exec__(207)));
 module.exports = __webpack_exports__;
 
 })();

package/.next/server/pages/api/solve.js.nft.json

@@ -1 +1 @@
-{"version":1,"files":["../../webpack-api-runtime.js","../../chunks/50.js","../../chunks/206.js","../../chunks/907.js","../../../package.json"]}
+{"version":1,"files":["../../webpack-api-runtime.js","../../chunks/50.js","../../chunks/429.js","../../chunks/939.js","../../chunks/911.js","../../../package.json"]}