scrabble-solver 2.8.2 → 2.8.4

package/packages/types/build/Result.js

@@ -3,12 +3,11 @@ 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 Cell_1 = __importDefault(require("./Cell"));
-var Result = /** @class */ (function () {
-    function Result(_a) {
-        var cells = _a.cells, id = _a.id, numberOfCollisions = _a.numberOfCollisions, points = _a.points;
-        var tiles = getTiles(cells);
+const constants_1 = require("@scrabble-solver/constants");
+const Cell_1 = __importDefault(require("./Cell"));
+class Result {
+    constructor({ cells, id, numberOfCollisions, points, }) {
+        const tiles = getTiles(cells);
         this.cells = cells;
         this.id = id;
         this.length = cells.length;
@@ -24,55 +23,33 @@ var Result = /** @class */ (function () {
         this.tilesCharacters = getTilesCharacters(tiles);
         this.word = getWord(cells);
     }
-    Result.fromJson = function (json) {
+    static fromJson(json) {
         return new Result({
             cells: json.cells.map(Cell_1.default.fromJson),
             id: json.id,
             numberOfCollisions: json.numberOfCollisions,
             points: json.points,
         });
-    };
-    Result.prototype.toJson = function () {
+    }
+    toJson() {
         return {
-            cells: this.cells.map(function (cell) { return cell.toJson(); }),
+            cells: this.cells.map((cell) => cell.toJson()),
             id: this.id,
             numberOfCollisions: this.numberOfCollisions,
             points: this.points,
         };
-    };
-    return Result;
-}());
-var charactersComparator = function (a, b) { return a.localeCompare(b); };
-var getBlanks = function (tiles) { return tiles.filter(function (_a) {
-    var isBlank = _a.isBlank;
-    return isBlank;
-}); };
-var getConsonants = function (tiles) { return tiles.filter(isConsonant); };
-var getVowels = function (tiles) { return tiles.filter(isVowel); };
-var getNonBlankCharacters = function (tiles) { return getNonBlanks(tiles).map(function (_a) {
-    var character = _a.character;
-    return character;
-}); };
-var getNonBlanks = function (tiles) { return tiles.filter(function (_a) {
-    var isBlank = _a.isBlank;
-    return !isBlank;
-}); };
-var getPointsRatio = function (tiles, points) { return points / tiles.length; };
-var getTiles = function (cells) { return cells.filter(function (_a) {
-    var isEmpty = _a.isEmpty;
-    return isEmpty;
-}).map(function (_a) {
-    var tile = _a.tile;
-    return tile;
-}); };
-var getTilesCharacters = function (tiles) { return getNonBlankCharacters(tiles).sort(charactersComparator).join(''); };
-var getWord = function (cells) { return cells.map(String).join(''); };
-var isConsonant = function (_a) {
-    var character = _a.character, isBlank = _a.isBlank;
-    return constants_1.CONSONANTS.includes(character) && !isBlank;
-};
-var isVowel = function (_a) {
-    var character = _a.character, isBlank = _a.isBlank;
-    return constants_1.VOWELS.includes(character) && !isBlank;
-};
+    }
+}
+const charactersComparator = (a, b) => a.localeCompare(b);
+const getBlanks = (tiles) => tiles.filter(({ isBlank }) => isBlank);
+const getConsonants = (tiles) => tiles.filter(isConsonant);
+const getVowels = (tiles) => tiles.filter(isVowel);
+const getNonBlankCharacters = (tiles) => getNonBlanks(tiles).map(({ character }) => character);
+const getNonBlanks = (tiles) => tiles.filter(({ isBlank }) => !isBlank);
+const getPointsRatio = (tiles, points) => points / tiles.length;
+const getTiles = (cells) => cells.filter(({ isEmpty }) => isEmpty).map(({ tile }) => tile);
+const getTilesCharacters = (tiles) => getNonBlankCharacters(tiles).sort(charactersComparator).join('');
+const getWord = (cells) => cells.map(String).join('');
+const isConsonant = ({ character, isBlank }) => constants_1.CONSONANTS.includes(character) && !isBlank;
+const isVowel = ({ character, isBlank }) => constants_1.VOWELS.includes(character) && !isBlank;
 exports.default = Result;

package/packages/types/build/Tile.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("@scrabble-solver/constants");
-var Tile = /** @class */ (function () {
-    function Tile(_a) {
-        var character = _a.character, _b = _a.isBlank, isBlank = _b === void 0 ? false : _b;
+const constants_1 = require("@scrabble-solver/constants");
+class Tile {
+    constructor({ character, isBlank = false }) {
         this.character = character;
         this.isBlank = isBlank;
     }
-    Tile.fromJson = function (json) {
+    static fromJson(json) {
         if (!json) {
             return Tile.Null;
         }
@@ -15,33 +14,32 @@ var Tile = /** @class */ (function () {
             character: json.character,
             isBlank: json.isBlank,
         });
-    };
-    Tile.prototype.clone = function () {
+    }
+    clone() {
         return new Tile({
             character: this.character,
             isBlank: this.isBlank,
         });
-    };
-    Tile.prototype.equals = function (other) {
+    }
+    equals(other) {
         return this.character === other.character && this.isBlank === other.isBlank;
-    };
-    Tile.prototype.toJson = function () {
+    }
+    toJson() {
         return {
             character: this.character,
             isBlank: this.isBlank,
         };
-    };
-    Tile.prototype.toString = function () {
+    }
+    toString() {
         return this.character;
-    };
-    Tile.Null = Object.freeze({
-        character: constants_1.EMPTY_CELL,
-        isBlank: false,
-        clone: function () { return Tile.Null; },
-        equals: function (other) { return other === Tile.Null; },
-        toJson: function () { return null; },
-        toString: function () { return constants_1.EMPTY_CELL; },
-    });
-    return Tile;
-}());
+    }
+}
+Tile.Null = Object.freeze({
+    character: constants_1.EMPTY_CELL,
+    isBlank: false,
+    clone: () => Tile.Null,
+    equals: (other) => other === Tile.Null,
+    toJson: () => null,
+    toString: () => constants_1.EMPTY_CELL,
+});
 exports.default = Tile;

package/packages/types/build/VerticalPattern.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 VerticalPattern = /** @class */ (function (_super) {
-    __extends(VerticalPattern, _super);
-    function VerticalPattern() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    VerticalPattern.prototype.clone = function () {
+const Pattern_1 = __importDefault(require("./Pattern"));
+class VerticalPattern extends Pattern_1.default {
+    clone() {
         return new VerticalPattern({
             board: this.board,
-            cells: this.cells.map(function (cell) { return cell.clone(); }),
+            cells: this.cells.map((cell) => cell.clone()),
         });
-    };
-    VerticalPattern.prototype.getCollisions = function () {
-        var _this = this;
-        var collisions = [];
+    }
+    getCollisions() {
+        const collisions = [];
         this.cells
-            .filter(function (cell) { return cell.isEmpty && (_this.board.collidesLeft(cell) || _this.board.collidesRight(cell)); })
-            .forEach(function (cell) {
-            var row = _this.board.getRow(cell.y);
-            var x = cell.x - 1;
+            .filter((cell) => cell.isEmpty && (this.board.collidesLeft(cell) || this.board.collidesRight(cell)))
+            .forEach((cell) => {
+            const row = this.board.getRow(cell.y);
+            let x = cell.x - 1;
             while (x >= 0 && row[x].hasTile()) {
                 --x;
             }
-            var previousCells = row.slice(x + 1, cell.x);
+            const previousCells = row.slice(x + 1, cell.x);
             x = cell.x + 1;
             while (x < row.length && row[x].hasTile()) {
                 ++x;
             }
-            var nextCells = row.slice(cell.x + 1, x);
-            var cells = __spreadArray(__spreadArray(__spreadArray([], __read(previousCells), false), [cell], false), __read(nextCells), false);
+            const nextCells = row.slice(cell.x + 1, x);
+            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 VerticalPattern;
-}(Pattern_1.default));
+    }
+}
 exports.default = VerticalPattern;

package/packages/types/build/WordBonus.js

@@ -1,42 +1,20 @@
 "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 WordBonus = /** @class */ (function (_super) {
-    __extends(WordBonus, _super);
-    function WordBonus() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.type = constants_1.BONUS_WORD;
-        return _this;
+const constants_1 = require("@scrabble-solver/constants");
+const Bonus_1 = __importDefault(require("./Bonus"));
+class WordBonus extends Bonus_1.default {
+    constructor() {
+        super(...arguments);
+        this.type = constants_1.BONUS_WORD;
     }
-    Object.defineProperty(WordBonus.prototype, "value", {
-        get: function () {
-            return {
-                characterMultiplier: 1,
-                wordMultiplier: this.multiplier,
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return WordBonus;
-}(Bonus_1.default));
+    get value() {
+        return {
+            characterMultiplier: 1,
+            wordMultiplier: this.multiplier,
+        };
+    }
+}
 exports.default = WordBonus;

package/packages/types/build/WordDefinition.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var WordDefinition = /** @class */ (function () {
-    function WordDefinition(_a) {
-        var definitions = _a.definitions, isAllowed = _a.isAllowed, word = _a.word;
+class WordDefinition {
+    constructor({ definitions, isAllowed, word }) {
         this.definitions = definitions;
         this.isAllowed = isAllowed;
         this.word = word;
     }
-    WordDefinition.fromJson = function (json) {
+    static fromJson(json) {
         if (!json) {
             return WordDefinition.Null;
         }
@@ -16,20 +15,19 @@ var WordDefinition = /** @class */ (function () {
             isAllowed: json.isAllowed,
             word: json.word,
         });
-    };
-    WordDefinition.prototype.toJson = function () {
+    }
+    toJson() {
         return {
             definitions: this.definitions,
             isAllowed: this.isAllowed,
             word: this.word,
         };
-    };
-    WordDefinition.Null = Object.freeze({
-        definitions: [],
-        isAllowed: false,
-        word: '',
-        toJson: function () { return null; },
-    });
-    return WordDefinition;
-}());
+    }
+}
+WordDefinition.Null = Object.freeze({
+    definitions: [],
+    isAllowed: false,
+    word: '',
+    toJson: () => null,
+});
 exports.default = WordDefinition;

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/types",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "description": "Scrabble Solver 2 - Types",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -24,7 +24,7 @@
     "clean:force": "npm run clean && rimraf package-lock.json"
   },
   "dependencies": {
-    "@scrabble-solver/constants": "^2.8.2"
+    "@scrabble-solver/constants": "^2.8.4"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }

package/packages/types/src/Cell.ts

@@ -75,7 +75,7 @@ class Cell {
   }
 
   public toString(): string {
-    return String(this.tile);
+    return this.tile.toString();
   }
 }
 

package/packages/types/src/Pattern.ts

@@ -67,7 +67,7 @@ class Pattern {
   }
 
   public toString(): string {
-    return this.cells.map(String).join('');
+    return this.cells.reduce((result, cell) => result + cell.toString(), '');
   }
 }
 

package/packages/word-definitions/build/crawl/crawl.js

@@ -2,23 +2,22 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-var types_1 = require("@scrabble-solver/types");
-var crawlEnglish_1 = __importDefault(require("./crawlEnglish"));
-var crawlFrench_1 = __importDefault(require("./crawlFrench"));
-var crawlGerman_1 = __importDefault(require("./crawlGerman"));
-var crawlPolish_1 = __importDefault(require("./crawlPolish"));
-var crawlSpanish_1 = __importDefault(require("./crawlSpanish"));
-var crawlPerLocale = (_a = {},
-    _a[types_1.Locale.DE_DE] = crawlGerman_1.default,
-    _a[types_1.Locale.EN_GB] = crawlEnglish_1.default,
-    _a[types_1.Locale.EN_US] = crawlEnglish_1.default,
-    _a[types_1.Locale.ES_ES] = crawlSpanish_1.default,
-    _a[types_1.Locale.FR_FR] = crawlFrench_1.default,
-    _a[types_1.Locale.PL_PL] = crawlPolish_1.default,
-    _a);
-var crawl = function (locale, word) {
+const types_1 = require("@scrabble-solver/types");
+const crawlEnglish_1 = __importDefault(require("./crawlEnglish"));
+const crawlFrench_1 = __importDefault(require("./crawlFrench"));
+const crawlGerman_1 = __importDefault(require("./crawlGerman"));
+const crawlPolish_1 = __importDefault(require("./crawlPolish"));
+const crawlSpanish_1 = __importDefault(require("./crawlSpanish"));
+const crawlPerLocale = {
+    [types_1.Locale.DE_DE]: crawlGerman_1.default,
+    [types_1.Locale.EN_GB]: crawlEnglish_1.default,
+    [types_1.Locale.EN_US]: crawlEnglish_1.default,
+    [types_1.Locale.ES_ES]: crawlSpanish_1.default,
+    [types_1.Locale.FR_FR]: crawlFrench_1.default,
+    [types_1.Locale.PL_PL]: crawlPolish_1.default,
+};
+const crawl = (locale, word) => {
     return crawlPerLocale[locale](word);
 };
 exports.default = crawl;

package/packages/word-definitions/build/crawl/crawlEnglish.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var lib_1 = require("../lib");
-var crawlEnglish = function (word) {
+const lib_1 = require("../lib");
+const crawlEnglish = (word) => {
     return (0, lib_1.request)({
         protocol: 'https',
         hostname: 'www.merriam-webster.com',
-        path: "/dictionary/".concat(encodeURIComponent(word)),
+        path: `/dictionary/${encodeURIComponent(word)}`,
     });
 };
 exports.default = crawlEnglish;

package/packages/word-definitions/build/crawl/crawlFrench.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var lib_1 = require("../lib");
-var crawlFrench = function (word) {
+const lib_1 = require("../lib");
+const crawlFrench = (word) => {
     return (0, lib_1.request)({
         protocol: 'https',
         hostname: 'www.cnrtl.fr',
-        path: "/definition/".concat(encodeURIComponent(word)),
+        path: `/definition/${encodeURIComponent(word)}`,
     });
 };
 exports.default = crawlFrench;

package/packages/word-definitions/build/crawl/crawlGerman.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var lib_1 = require("../lib");
-var crawlGerman = function (word) {
+const lib_1 = require("../lib");
+const crawlGerman = (word) => {
     return (0, lib_1.request)({
         protocol: 'https',
         hostname: 'www.dwds.de',
-        path: "?q=".concat(encodeURIComponent(word), "&from=wb"),
+        path: `?q=${encodeURIComponent(word)}&from=wb`,
     });
 };
 exports.default = crawlGerman;

package/packages/word-definitions/build/crawl/crawlPolish.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var lib_1 = require("../lib");
-var crawlPolish = function (word) {
+const lib_1 = require("../lib");
+const crawlPolish = (word) => {
     return (0, lib_1.request)({
         protocol: 'https',
         hostname: 'sjp.pl',
-        path: "/".concat(encodeURIComponent(word)),
+        path: `/${encodeURIComponent(word)}`,
     });
 };
 exports.default = crawlPolish;

package/packages/word-definitions/build/crawl/crawlSpanish.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var lib_1 = require("../lib");
-var crawlSpanish = function (word) {
+const lib_1 = require("../lib");
+const crawlSpanish = (word) => {
     return (0, lib_1.request)({
         protocol: 'https',
         hostname: 'www.diccionarios.com',
-        path: "/diccionario/espanol/".concat(encodeURIComponent(word)),
+        path: `/diccionario/espanol/${encodeURIComponent(word)}`,
     });
 };
 exports.default = crawlSpanish;

package/packages/word-definitions/build/getWordDefinition.js

@@ -1,55 +1,12 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var types_1 = require("@scrabble-solver/types");
-var crawl_1 = require("./crawl");
-var parse_1 = require("./parse");
-var getWordDefinition = function (locale, word) { return __awaiter(void 0, void 0, void 0, function () {
-    var html, _a, definitions, isAllowed, wordDefinition;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0: return [4 /*yield*/, (0, crawl_1.crawl)(locale, word)];
-            case 1:
-                html = _b.sent();
-                _a = (0, parse_1.parse)(locale, html), definitions = _a.definitions, isAllowed = _a.isAllowed;
-                wordDefinition = new types_1.WordDefinition({ definitions: definitions, isAllowed: isAllowed, word: word });
-                return [2 /*return*/, wordDefinition];
-        }
-    });
-}); };
+const types_1 = require("@scrabble-solver/types");
+const crawl_1 = require("./crawl");
+const parse_1 = require("./parse");
+const getWordDefinition = async (locale, word) => {
+    const html = await (0, crawl_1.crawl)(locale, word);
+    const { definitions, isAllowed } = (0, parse_1.parse)(locale, html);
+    const wordDefinition = new types_1.WordDefinition({ definitions, isAllowed, word });
+    return wordDefinition;
+};
 exports.default = getWordDefinition;