scrabble-solver 2.8.2 → 2.8.3

package/packages/types/build/Bonus.js

@@ -1,20 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var Bonus = /** @class */ (function () {
-    function Bonus(_a) {
-        var multiplier = _a.multiplier, score = _a.score, x = _a.x, y = _a.y;
+class Bonus {
+    constructor({ multiplier, score, x, y }) {
         this.multiplier = multiplier;
         this.score = score;
         this.x = x;
         this.y = y;
     }
-    Bonus.prototype.canApply = function (_config, cell) {
+    canApply(_config, cell) {
         return cell.isEmpty && this.matchesCellCoordinates(cell);
-    };
-    Bonus.prototype.matchesCellCoordinates = function (cell) {
+    }
+    matchesCellCoordinates(cell) {
         return this.x === cell.x && this.y === cell.y;
-    };
-    Bonus.prototype.toJson = function () {
+    }
+    toJson() {
         return {
             multiplier: this.multiplier,
             score: this.score,
@@ -22,17 +21,12 @@ var Bonus = /** @class */ (function () {
             x: this.x,
             y: this.y,
         };
-    };
-    Object.defineProperty(Bonus.prototype, "value", {
-        get: function () {
-            return {
-                characterMultiplier: 1,
-                wordMultiplier: 1,
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Bonus;
-}());
+    }
+    get value() {
+        return {
+            characterMultiplier: 1,
+            wordMultiplier: 1,
+        };
+    }
+}
 exports.default = Bonus;

package/packages/types/build/Cell.js

@@ -3,17 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var Tile_1 = __importDefault(require("./Tile"));
-var Cell = /** @class */ (function () {
+const Tile_1 = __importDefault(require("./Tile"));
+class Cell {
     // eslint-disable-next-line no-undef
-    function Cell(_a) {
-        var _b = _a.isEmpty, isEmpty = _b === void 0 ? true : _b, _c = _a.tile, tile = _c === void 0 ? Tile_1.default.Null : _c, x = _a.x, y = _a.y;
+    constructor({ isEmpty = true, tile = Tile_1.default.Null, x, y }) {
         this.isEmpty = isEmpty;
         this.tile = tile;
         this.x = x;
         this.y = y;
     }
-    Cell.fromJson = function (json) {
+    static fromJson(json) {
         if (!json) {
             return Cell.Null;
         }
@@ -23,47 +22,46 @@ var Cell = /** @class */ (function () {
             x: json.x,
             y: json.y,
         });
-    };
-    Cell.prototype.clone = function () {
+    }
+    clone() {
         return new Cell({
             isEmpty: this.isEmpty,
             tile: this.tile.clone(),
             x: this.x,
             y: this.y,
         });
-    };
-    Cell.prototype.equals = function (other) {
+    }
+    equals(other) {
         return this.x === other.x && this.y === other.y && this.isEmpty === other.isEmpty && this.tile.equals(other.tile);
-    };
-    Cell.prototype.hasTile = function () {
+    }
+    hasTile() {
         return this.tile !== Tile_1.default.Null;
-    };
-    Cell.prototype.isCandidate = function () {
+    }
+    isCandidate() {
         return this.isEmpty && this.hasTile();
-    };
-    Cell.prototype.toJson = function () {
+    }
+    toJson() {
         return {
             isEmpty: this.isEmpty,
             tile: this.tile.toJson(),
             x: this.x,
             y: this.y,
         };
-    };
-    Cell.prototype.toString = function () {
+    }
+    toString() {
         return String(this.tile);
-    };
-    Cell.Null = Object.freeze({
-        isEmpty: true,
-        tile: Tile_1.default.Null,
-        x: 0,
-        y: 0,
-        clone: function () { return Cell.Null; },
-        equals: function (other) { return other === Cell.Null; },
-        hasTile: function () { return false; },
-        isCandidate: function () { return false; },
-        toString: function () { return ''; },
-        toJson: function () { return null; },
-    });
-    return Cell;
-}());
+    }
+}
+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/CharacterBonus.js

@@ -1,51 +1,29 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("@scrabble-solver/constants");
-var Bonus_1 = __importDefault(require("./Bonus"));
-var CharacterBonus = /** @class */ (function (_super) {
-    __extends(CharacterBonus, _super);
-    function CharacterBonus() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.type = constants_1.BONUS_CHARACTER;
-        return _this;
+const constants_1 = require("@scrabble-solver/constants");
+const Bonus_1 = __importDefault(require("./Bonus"));
+class CharacterBonus extends Bonus_1.default {
+    constructor() {
+        super(...arguments);
+        this.type = constants_1.BONUS_CHARACTER;
     }
-    CharacterBonus.prototype.canApply = function (config, cell) {
-        return _super.prototype.canApply.call(this, config, cell) && this.matchesCellTileScore(config, cell);
-    };
-    CharacterBonus.prototype.matchesCellTileScore = function (config, cell) {
+    canApply(config, cell) {
+        return super.canApply(config, cell) && this.matchesCellTileScore(config, cell);
+    }
+    matchesCellTileScore(config, cell) {
         if (typeof this.score === 'undefined') {
             return true;
         }
         return this.score === config.pointsMap[cell.tile.character];
-    };
-    Object.defineProperty(CharacterBonus.prototype, "value", {
-        get: function () {
-            return {
-                characterMultiplier: this.multiplier,
-                wordMultiplier: 1,
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return CharacterBonus;
-}(Bonus_1.default));
+    }
+    get value() {
+        return {
+            characterMultiplier: this.multiplier,
+            wordMultiplier: 1,
+        };
+    }
+}
 exports.default = CharacterBonus;

package/packages/types/build/Config.js

@@ -1,81 +1,45 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("@scrabble-solver/constants");
-var CharacterBonus_1 = __importDefault(require("./CharacterBonus"));
-var WordBonus_1 = __importDefault(require("./WordBonus"));
-var Config = /** @class */ (function () {
-    function Config(config) {
+const constants_1 = require("@scrabble-solver/constants");
+const CharacterBonus_1 = __importDefault(require("./CharacterBonus"));
+const WordBonus_1 = __importDefault(require("./WordBonus"));
+class Config {
+    constructor(config) {
         this.bonuses = getBonuses(config);
         this.config = config;
         this.pointsMap = getPointsMap(this.config);
     }
-    Config.fromJson = function (json) {
+    static fromJson(json) {
         return new Config(json);
-    };
-    Object.defineProperty(Config.prototype, "allTilesBonusScore", {
-        get: function () {
-            return this.config.allTilesBonusScore;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Config.prototype, "alphabet", {
-        get: function () {
-            return getAlphabet(this.config);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Config.prototype, "blankScore", {
-        get: function () {
-            return this.config.blankScore;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Config.prototype, "boardHeight", {
-        get: function () {
-            return this.config.boardHeight;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Config.prototype, "boardWidth", {
-        get: function () {
-            return this.config.boardWidth;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Config.prototype, "twoCharacterTiles", {
-        get: function () {
-            return this.config.tiles.filter(function (tile) { return tile.character.length === 2; }).map(function (tile) { return tile.character; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Config.prototype.getCellBonus = function (cell) {
-        return this.bonuses.find(function (bonus) { return bonus.matchesCellCoordinates(cell); });
-    };
-    Config.prototype.getCellBonusValue = function (cell) {
-        var _a;
-        return ((_a = this.getCellBonus(cell)) === null || _a === void 0 ? void 0 : _a.value) || constants_1.NO_BONUS;
-    };
-    Config.prototype.getCharacterPoints = function (character) {
+    }
+    get allTilesBonusScore() {
+        return this.config.allTilesBonusScore;
+    }
+    get alphabet() {
+        return getAlphabet(this.config);
+    }
+    get blankScore() {
+        return this.config.blankScore;
+    }
+    get boardHeight() {
+        return this.config.boardHeight;
+    }
+    get boardWidth() {
+        return this.config.boardWidth;
+    }
+    get twoCharacterTiles() {
+        return this.config.tiles.filter((tile) => tile.character.length === 2).map((tile) => tile.character);
+    }
+    getCellBonus(cell) {
+        return this.bonuses.find((bonus) => bonus.matchesCellCoordinates(cell));
+    }
+    getCellBonusValue(cell) {
+        return this.getCellBonus(cell)?.value || constants_1.NO_BONUS;
+    }
+    getCharacterPoints(character) {
         if (character === null) {
             return undefined;
         }
@@ -83,71 +47,52 @@ var Config = /** @class */ (function () {
             return this.blankScore;
         }
         return this.pointsMap[character];
-    };
-    Config.prototype.getTwoCharacterTileByPrefix = function (character) {
+    }
+    getTwoCharacterTileByPrefix(character) {
         if (character.length !== 1) {
             return undefined;
         }
-        return this.twoCharacterTiles.find(function (characters) { return characters.startsWith(character); });
-    };
-    Config.prototype.getTilePoints = function (tile) {
+        return this.twoCharacterTiles.find((characters) => characters.startsWith(character));
+    }
+    getTilePoints(tile) {
         if (tile === null) {
             return undefined;
         }
         return tile.isBlank ? this.blankScore : this.getCharacterPoints(tile.character);
-    };
-    Config.prototype.hasCharacter = function (character) {
+    }
+    hasCharacter(character) {
         return this.alphabet.includes(character);
-    };
-    Config.prototype.isTwoCharacterTilePrefix = function (character) {
+    }
+    isTwoCharacterTilePrefix(character) {
         return typeof this.getTwoCharacterTileByPrefix(character) !== 'undefined';
-    };
-    Object.defineProperty(Config.prototype, "maximumNumberOfCharacters", {
-        get: function () {
-            return this.config.maximumNumberOfCharacters;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Config.prototype, "numberOfBlanks", {
-        get: function () {
-            return this.config.numberOfBlanks;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Config.prototype, "tiles", {
-        get: function () {
-            return this.config.tiles;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Config.prototype.toJson = function () {
+    }
+    get maximumNumberOfCharacters() {
+        return this.config.maximumNumberOfCharacters;
+    }
+    get numberOfBlanks() {
+        return this.config.numberOfBlanks;
+    }
+    get tiles() {
+        return this.config.tiles;
+    }
+    toJson() {
         return this.config;
-    };
-    return Config;
-}());
-var getBonuses = function (config) {
-    return config.bonuses.map(function (bonus) {
+    }
+}
+const getBonuses = (config) => {
+    return config.bonuses.map((bonus) => {
         if (bonus.type === constants_1.BONUS_CHARACTER) {
             return new CharacterBonus_1.default(bonus);
         }
         if (bonus.type === constants_1.BONUS_WORD) {
             return new WordBonus_1.default(bonus);
         }
-        throw new Error("Unsupported Bonus type: \"".concat(bonus.type, "\""));
+        throw new Error(`Unsupported Bonus type: "${bonus.type}"`);
     });
 };
-var getAlphabet = function (config) { return config.tiles.map(function (_a) {
-    var character = _a.character;
-    return character;
-}); };
-var getPointsMap = function (config) {
-    return config.tiles.reduce(function (pointsMap, _a) {
-        var _b;
-        var character = _a.character, score = _a.score;
-        return (__assign(__assign({}, pointsMap), (_b = {}, _b[character] = score, _b)));
-    }, {});
-};
+const getAlphabet = (config) => config.tiles.map(({ character }) => character);
+const getPointsMap = (config) => config.tiles.reduce((pointsMap, { character, score }) => ({
+    ...pointsMap,
+    [character]: score,
+}), {});
 exports.default = Config;

package/packages/types/build/HorizontalPattern.js

@@ -1,85 +1,39 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var Pattern_1 = __importDefault(require("./Pattern"));
-var HorizontalPattern = /** @class */ (function (_super) {
-    __extends(HorizontalPattern, _super);
-    function HorizontalPattern() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    HorizontalPattern.prototype.clone = function () {
+const Pattern_1 = __importDefault(require("./Pattern"));
+class HorizontalPattern extends Pattern_1.default {
+    clone() {
         return new HorizontalPattern({
             board: this.board,
-            cells: this.cells.map(function (cell) { return cell.clone(); }),
+            cells: this.cells.map((cell) => cell.clone()),
         });
-    };
-    HorizontalPattern.prototype.getCollisions = function () {
-        var _this = this;
-        var collisions = [];
+    }
+    getCollisions() {
+        const collisions = [];
         this.cells
-            .filter(function (cell) { return cell.isEmpty && (_this.board.collidesUp(cell) || _this.board.collidesDown(cell)); })
-            .forEach(function (cell) {
-            var column = _this.board.getColumn(cell.x);
-            var y = cell.y - 1;
+            .filter((cell) => cell.isEmpty && (this.board.collidesUp(cell) || this.board.collidesDown(cell)))
+            .forEach((cell) => {
+            const column = this.board.getColumn(cell.x);
+            let y = cell.y - 1;
             while (y >= 0 && column[y].hasTile()) {
                 --y;
             }
-            var previousCells = column.slice(y + 1, cell.y);
+            const previousCells = column.slice(y + 1, cell.y);
             y = cell.y + 1;
             while (y < column.length && column[y].hasTile()) {
                 ++y;
             }
-            var nextCells = column.slice(cell.y + 1, y);
-            var cells = __spreadArray(__spreadArray(__spreadArray([], __read(previousCells), false), [cell], false), __read(nextCells), false);
+            const nextCells = column.slice(cell.y + 1, y);
+            const cells = [...previousCells, cell, ...nextCells];
             if (cells.length > 1) {
-                var pattern = new Pattern_1.default({ board: _this.board, cells: cells });
+                const pattern = new Pattern_1.default({ board: this.board, cells });
                 collisions.push(pattern);
             }
         });
         return collisions;
-    };
-    return HorizontalPattern;
-}(Pattern_1.default));
+    }
+}
 exports.default = HorizontalPattern;

package/packages/types/build/Pattern.js

@@ -1,56 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var Pattern = /** @class */ (function () {
-    function Pattern(_a) {
-        var board = _a.board, cells = _a.cells;
+class Pattern {
+    constructor({ board, cells }) {
         this.board = board;
         this.cells = cells;
     }
-    Pattern.prototype.canBePlaced = function (config) {
-        var numberOfEmptyCells = this.getNumberOfEmptyCells();
-        var isNumberOfUsedCellsInRange = numberOfEmptyCells >= 1 && numberOfEmptyCells <= config.maximumNumberOfCharacters;
+    canBePlaced(config) {
+        const numberOfEmptyCells = this.getNumberOfEmptyCells();
+        const isNumberOfUsedCellsInRange = numberOfEmptyCells >= 1 && numberOfEmptyCells <= config.maximumNumberOfCharacters;
         return (isNumberOfUsedCellsInRange &&
             (this.hasAtLeast1NonEmptyCell() || this.collides() || (this.goesThroughBoardCenter() && this.board.isEmpty())));
-    };
-    Pattern.prototype.clone = function () {
+    }
+    clone() {
         return new Pattern({
             board: this.board,
-            cells: this.cells.map(function (cell) { return cell.clone(); }),
+            cells: this.cells.map((cell) => cell.clone()),
         });
-    };
-    Pattern.prototype.collides = function () {
-        var _this = this;
-        return this.cells.some(function (cell) { return cell.isEmpty && _this.board.collides(cell); });
-    };
-    Pattern.prototype.getIndexOfFirstCellWithoutTile = function () {
-        return this.cells.findIndex(function (cell) { return !cell.hasTile(); });
-    };
-    Pattern.prototype.getNumberOfEmptyCells = function () {
-        return this.cells.filter(function (cell) { return cell.isEmpty; }).length;
-    };
-    Pattern.prototype.goesThroughBoardCenter = function () {
-        var _this = this;
-        return this.cells.some(function (cell) { return cell.x === _this.board.center.x && cell.y === _this.board.center.y && cell.isEmpty; });
-    };
-    Pattern.prototype.hasAtLeast1EmptyCell = function () {
-        return this.cells.some(function (cell) { return cell.isEmpty; });
-    };
-    Pattern.prototype.hasAtLeast1NonEmptyCell = function () {
-        return this.cells.some(function (cell) { return !cell.isEmpty; });
-    };
-    Pattern.prototype.getCollisions = function () {
+    }
+    collides() {
+        return this.cells.some((cell) => cell.isEmpty && this.board.collides(cell));
+    }
+    getIndexOfFirstCellWithoutTile() {
+        return this.cells.findIndex((cell) => !cell.hasTile());
+    }
+    getNumberOfEmptyCells() {
+        return this.cells.filter((cell) => cell.isEmpty).length;
+    }
+    goesThroughBoardCenter() {
+        return this.cells.some((cell) => cell.x === this.board.center.x && cell.y === this.board.center.y && cell.isEmpty);
+    }
+    hasAtLeast1EmptyCell() {
+        return this.cells.some((cell) => cell.isEmpty);
+    }
+    hasAtLeast1NonEmptyCell() {
+        return this.cells.some((cell) => !cell.isEmpty);
+    }
+    getCollisions() {
         return [];
-    };
-    Pattern.prototype.toJson = function () {
+    }
+    toJson() {
         return {
-            cells: this.cells.map(function (cell) { return cell.toJson(); }),
-            collisions: this.getCollisions().map(function (collision) { return collision.toJson(); }),
+            cells: this.cells.map((cell) => cell.toJson()),
+            collisions: this.getCollisions().map((collision) => collision.toJson()),
             word: this.toString(),
         };
-    };
-    Pattern.prototype.toString = function () {
+    }
+    toString() {
         return this.cells.map(String).join('');
-    };
-    return Pattern;
-}());
+    }
+}
 exports.default = Pattern;