scrabble-solver 2.8.6 → 2.8.8

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.6",
+  "version": "2.8.8",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrabble-solver/solver",
-      "version": "2.8.6",
+      "version": "2.8.8",
       "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.6",
+  "version": "2.8.8",
   "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.6",
-    "lodash": "^4.17.21"
+    "@scrabble-solver/types": "^2.8.8"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.8.6",
-    "@scrabble-solver/constants": "^2.8.6",
-    "@scrabble-solver/dictionaries": "^2.8.6",
-    "@types/lodash": "^4.14.186"
+    "@scrabble-solver/configs": "^2.8.8",
+    "@scrabble-solver/constants": "^2.8.8",
+    "@scrabble-solver/dictionaries": "^2.8.8"
   },
   "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([[], [], []]);

package/packages/solver/src/PatternsGenerator.ts

@@ -15,8 +15,8 @@ class PatternsGenerator {
     return this.generatePatterns({
       board,
       getNthVector: (index) => board.getRow(index),
-      numberOfVectors: this.config.boardHeight,
       PatternModel: HorizontalPattern,
+      vectorsCount: this.config.boardHeight,
     });
   }
 
@@ -24,35 +24,35 @@ class PatternsGenerator {
     return this.generatePatterns({
       board,
       getNthVector: (index) => board.getColumn(index),
-      numberOfVectors: this.config.boardWidth,
       PatternModel: VerticalPattern,
+      vectorsCount: this.config.boardWidth,
     });
   }
 
   public generatePatterns<P extends Pattern>({
     board,
     getNthVector,
-    numberOfVectors,
+    vectorsCount,
     PatternModel,
   }: {
     board: Board;
     getNthVector: (index: number) => Cell[];
-    numberOfVectors: number;
     PatternModel: new (parameters: { board: Board; cells: Cell[] }) => P;
+    vectorsCount: number;
   }): P[] {
-    return this.generateVectors({ getNthVector, numberOfVectors }).reduce<P[]>((patterns, cells) => {
+    return this.generateVectors({ getNthVector, vectorsCount }).reduce<P[]>((patterns, cells) => {
       return patterns.concat(this.generateCellsPatterns<P>({ board, PatternModel, cells }));
     }, []);
   }
 
   public generateVectors({
     getNthVector,
-    numberOfVectors,
+    vectorsCount,
   }: {
     getNthVector: (index: number) => Cell[];
-    numberOfVectors: number;
+    vectorsCount: number;
   }): Cell[][] {
-    return Array(numberOfVectors)
+    return Array(vectorsCount)
       .fill(0)
       .map((_, index) => getNthVector(index));
   }

package/packages/solver/src/ScoresCalculator.ts

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

package/packages/solver/src/Solver.ts

@@ -1,7 +1,7 @@
 import { Trie } from '@kamilmielnik/trie';
 import { Board, Config, Result, Tile } from '@scrabble-solver/types';
-import uniqBy from 'lodash/uniqBy';
 
+import getUniquePatterns from './getUniquePatterns';
 import PatternsFiller from './PatternsFiller';
 import PatternsGenerator from './PatternsGenerator';
 import ScoresCalculator from './ScoresCalculator';
@@ -22,13 +22,13 @@ class Solver {
   public solve(board: Board, tiles: Tile[]): Result[] {
     const patterns = this.patternsGenerator.generate(board);
     const filledPatterns = patterns.flatMap((pattern) => this.patternsFiller.fill(pattern, tiles));
-    const uniquePatterns = uniqBy(filledPatterns, (pattern) => JSON.stringify(pattern.toJson()));
+    const uniquePatterns = getUniquePatterns(filledPatterns);
     const results = uniquePatterns.map(
       (pattern, index) =>
         new Result({
           cells: pattern.cells,
+          collisions: pattern.getCollisions().map((collision) => collision.cells),
           id: index,
-          numberOfCollisions: pattern.getCollisions().length,
           points: this.scoresCalculator.calculate(pattern),
         }),
     );

package/packages/solver/src/getUniquePatterns.ts

@@ -0,0 +1,30 @@
+import { Pattern } from '@scrabble-solver/types';
+
+const getPatternHash = (pattern: Pattern): string => {
+  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: Pattern[]): Pattern[] => {
+  const hashes = new Set<string>();
+  const uniquePatterns: Pattern[] = [];
+
+  for (const pattern of patterns) {
+    const hash = getPatternHash(pattern);
+
+    if (!hashes.has(hash)) {
+      hashes.add(hash);
+      uniquePatterns.push(pattern);
+    }
+  }
+
+  return uniquePatterns;
+};
+
+export default getUniquePatterns;

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

@@ -4,9 +4,9 @@ declare class Board {
     static create(width: number, height: number): Board;
     static fromJson(json: BoardJson): Board;
     static fromStringArray(stringArray: string[]): Board;
+    readonly columnsCount: number;
     readonly rows: Cell[][];
-    readonly numberOfColumns: number;
-    readonly numberOfRows: number;
+    readonly rowsCount: number;
     constructor({ rows }: {
         rows: Cell[][];
     });

package/packages/types/build/Board.js

@@ -9,8 +9,8 @@ const Tile_1 = __importDefault(require("./Tile"));
 class Board {
     constructor({ rows }) {
         this.rows = rows;
-        this.numberOfColumns = rows[0].length;
-        this.numberOfRows = rows.length;
+        this.columnsCount = rows[0].length;
+        this.rowsCount = rows.length;
     }
     static create(width, height) {
         return Board.fromStringArray(Array(height).fill(Array(width).fill(' ').join('')));
@@ -31,8 +31,8 @@ class Board {
         });
     }
     get center() {
-        const x = Math.floor(this.numberOfColumns / 2);
-        const y = Math.floor(this.numberOfRows / 2);
+        const x = Math.floor(this.columnsCount / 2);
+        const y = Math.floor(this.rowsCount / 2);
         return this.rows[y][x];
     }
     clone() {
@@ -43,20 +43,20 @@ class Board {
         return this.collidesUp(cell) || this.collidesDown(cell) || this.collidesLeft(cell) || this.collidesRight(cell);
     }
     collidesDown({ x, y }) {
-        return y < this.numberOfRows - 1 && !this.rows[y + 1][x].isEmpty;
+        return y < this.rowsCount - 1 && !this.rows[y + 1][x].isEmpty;
     }
     collidesLeft({ x, y }) {
         return x > 0 && !this.rows[y][x - 1].isEmpty;
     }
     collidesRight({ x, y }) {
-        return x < this.numberOfColumns - 1 && !this.rows[y][x + 1].isEmpty;
+        return x < this.columnsCount - 1 && !this.rows[y][x + 1].isEmpty;
     }
     collidesUp({ x, y }) {
         return y > 0 && !this.rows[y - 1][x].isEmpty;
     }
     equals(other) {
-        return (this.numberOfColumns === other.numberOfColumns &&
-            this.numberOfRows === other.numberOfRows &&
+        return (this.columnsCount === other.columnsCount &&
+            this.rowsCount === other.rowsCount &&
             this.rows.every((row, rowIndex) => {
                 return row.every((cell, cellIndex) => {
                     return cell.equals(other.rows[rowIndex][cellIndex]);

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

@@ -1,3 +1,4 @@
 import CellJson from './CellJson';
-declare type BoardJson = (CellJson | null)[][];
+declare type BoardJson = CellJson[][];
+export declare const isBoardJson: (value: unknown) => value is BoardJson;
 export default BoardJson;

package/packages/types/build/BoardJson.js

@@ -1,2 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBoardJson = void 0;
+const CellJson_1 = require("./CellJson");
+const isBoardJson = (value) => {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    for (const row of value) {
+        if (!Array.isArray(value)) {
+            return false;
+        }
+        for (const cell of row) {
+            if (!(0, CellJson_1.isCellJson)(cell)) {
+                return false;
+            }
+        }
+    }
+    return true;
+};
+exports.isBoardJson = isBoardJson;

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

@@ -1,8 +1,7 @@
 import CellJson from './CellJson';
 import Tile from './Tile';
 declare class Cell {
-    static fromJson(json: CellJson | null): Cell;
-    static readonly Null: Cell;
+    static fromJson(json: CellJson): Cell;
     readonly isEmpty: boolean;
     tile: Tile;
     readonly x: number;
@@ -17,7 +16,7 @@ declare class Cell {
     equals(other: Cell): boolean;
     hasTile(): boolean;
     isCandidate(): boolean;
-    toJson(): CellJson | null;
+    toJson(): CellJson;
     toString(): string;
 }
 export default Cell;

package/packages/types/build/Cell.js

@@ -13,9 +13,6 @@ class Cell {
         this.y = y;
     }
     static fromJson(json) {
-        if (!json) {
-            return Cell.Null;
-        }
         return new Cell({
             isEmpty: json.isEmpty,
             tile: Tile_1.default.fromJson(json.tile),
@@ -52,16 +49,4 @@ class Cell {
         return this.tile.toString();
     }
 }
-Cell.Null = Object.freeze({
-    isEmpty: true,
-    tile: Tile_1.default.Null,
-    x: 0,
-    y: 0,
-    clone: () => Cell.Null,
-    equals: (other) => other === Cell.Null,
-    hasTile: () => false,
-    isCandidate: () => false,
-    toString: () => '',
-    toJson: () => null,
-});
 exports.default = Cell;

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

@@ -5,4 +5,5 @@ interface CellJson {
     x: number;
     y: number;
 }
+export declare const isCellJson: (value: unknown) => value is CellJson;
 export default CellJson;

package/packages/types/build/CellJson.js

@@ -1,2 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCellJson = void 0;
+const isObject_1 = __importDefault(require("./isObject"));
+const TileJson_1 = require("./TileJson");
+const isCellJson = (value) => {
+    return ((0, isObject_1.default)(value) &&
+        typeof value.isEmpty === 'boolean' &&
+        ((0, TileJson_1.isTileJson)(value.tile) || value.tile === null) &&
+        typeof value.x === 'number' &&
+        typeof value.y === 'number');
+};
+exports.isCellJson = isCellJson;

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

@@ -0,0 +1,3 @@
+import Cell from './Cell';
+declare type Collision = Cell[];
+export default Collision;

package/packages/types/build/Collision.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,3 @@
+import CellJson from './CellJson';
+declare type CollisionJson = CellJson[];
+export default CollisionJson;

package/packages/types/build/CollisionJson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -13,6 +13,7 @@ declare class Config {
     get allTilesBonusScore(): number;
     get alphabet(): string[];
     get blankScore(): number;
+    get blanksCount(): number;
     get boardHeight(): number;
     get boardWidth(): number;
     get twoCharacterTiles(): string[];
@@ -23,8 +24,7 @@ declare class Config {
     getTilePoints(tile: Tile | null): number | undefined;
     hasCharacter(character: string): boolean;
     isTwoCharacterTilePrefix(character: string): boolean;
-    get maximumNumberOfCharacters(): number;
-    get numberOfBlanks(): number;
+    get maximumCharactersCount(): number;
     get tiles(): TileConfig[];
     toJson(): ConfigJson;
 }

package/packages/types/build/Config.js

@@ -24,6 +24,9 @@ class Config {
     get blankScore() {
         return this.config.blankScore;
     }
+    get blanksCount() {
+        return this.config.blanksCount;
+    }
     get boardHeight() {
         return this.config.boardHeight;
     }
@@ -66,11 +69,8 @@ class Config {
     isTwoCharacterTilePrefix(character) {
         return typeof this.getTwoCharacterTileByPrefix(character) !== 'undefined';
     }
-    get maximumNumberOfCharacters() {
-        return this.config.maximumNumberOfCharacters;
-    }
-    get numberOfBlanks() {
-        return this.config.numberOfBlanks;
+    get maximumCharactersCount() {
+        return this.config.maximumCharactersCount;
     }
     get tiles() {
         return this.config.tiles;

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

@@ -3,13 +3,13 @@ import TileConfig from './TileConfig';
 interface ConfigJson {
     allTilesBonusScore: number;
     blankScore: number;
+    blanksCount: number;
     boardHeight: number;
     boardWidth: number;
     bonuses: BonusJson[];
     id: string;
-    maximumNumberOfCharacters: number;
+    maximumCharactersCount: number;
     name: string;
-    numberOfBlanks: number;
     tiles: TileConfig[];
 }
 export default ConfigJson;

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

@@ -6,4 +6,5 @@ declare enum Locale {
     PL_PL = "pl-PL",
     DE_DE = "de-DE"
 }
+export declare const isLocale: (locale: unknown) => locale is Locale;
 export default Locale;

package/packages/types/build/Locale.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocale = void 0;
 // eslint-disable-next-line no-shadow
 var Locale;
 (function (Locale) {
@@ -10,4 +11,7 @@ var Locale;
     Locale["PL_PL"] = "pl-PL";
     Locale["DE_DE"] = "de-DE";
 })(Locale || (Locale = {}));
+const locales = Object.values(Locale);
+const isLocale = (locale) => locales.includes(locale);
+exports.isLocale = isLocale;
 exports.default = Locale;

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

@@ -13,7 +13,7 @@ declare class Pattern {
     clone(): Pattern;
     collides(): boolean;
     getIndexOfFirstCellWithoutTile(): number;
-    getNumberOfEmptyCells(): number;
+    getEmptyCellsCount(): number;
     goesThroughBoardCenter(): boolean;
     hasAtLeast1EmptyCell(): boolean;
     hasAtLeast1NonEmptyCell(): boolean;

package/packages/types/build/Pattern.js

@@ -6,9 +6,9 @@ class Pattern {
         this.cells = cells;
     }
     canBePlaced(config) {
-        const numberOfEmptyCells = this.getNumberOfEmptyCells();
-        const isNumberOfUsedCellsInRange = numberOfEmptyCells >= 1 && numberOfEmptyCells <= config.maximumNumberOfCharacters;
-        return (isNumberOfUsedCellsInRange &&
+        const emptyCellsCount = this.getEmptyCellsCount();
+        const isUsedCellsCountInRange = emptyCellsCount >= 1 && emptyCellsCount <= config.maximumCharactersCount;
+        return (isUsedCellsCountInRange &&
             (this.hasAtLeast1NonEmptyCell() || this.collides() || (this.goesThroughBoardCenter() && this.board.isEmpty())));
     }
     clone() {
@@ -23,7 +23,7 @@ class Pattern {
     getIndexOfFirstCellWithoutTile() {
         return this.cells.findIndex((cell) => !cell.hasTile());
     }
-    getNumberOfEmptyCells() {
+    getEmptyCellsCount() {
         return this.cells.filter((cell) => cell.isEmpty).length;
     }
     goesThroughBoardCenter() {