scrabble-solver 2.13.4 → 2.13.5-alpha.1

package/packages/word-definitions/build/languages/polish.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.crawl = void 0;
+const cheerio_1 = require("cheerio");
+const lib_1 = require("../lib");
+const crawl = (word) => {
+    return (0, lib_1.request)({
+        protocol: 'https',
+        hostname: 'sjp.pl',
+        path: `/${encodeURIComponent(word)}`,
+    });
+};
+exports.crawl = crawl;
+const parse = (html) => {
+    const $ = (0, cheerio_1.load)(html);
+    const $header = $($('h1')[0]);
+    const $isAllowed = $header.next();
+    const $definitions = $header.next().next().next().next();
+    return {
+        definitions: $definitions.text().trim().split(/\d+\./),
+        exists: $isAllowed.text().trim().indexOf('dopuszczalne w grach') >= 0,
+    };
+};
+exports.parse = parse;

package/packages/word-definitions/build/languages/romanian.d.ts

@@ -0,0 +1,3 @@
+import { ParsingResult } from '../types';
+export declare const crawl: (word: string) => Promise<string>;
+export declare const parse: (html: string) => ParsingResult;

package/packages/word-definitions/build/languages/romanian.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.crawl = void 0;
+const cheerio_1 = require("cheerio");
+const lib_1 = require("../lib");
+const crawl = (word) => {
+    return (0, lib_1.request)({
+        protocol: 'https',
+        hostname: 'dexonline.ro',
+        path: `/definitie/${encodeURIComponent(word)}`,
+    });
+};
+exports.crawl = crawl;
+const parse = (html) => {
+    const $ = (0, cheerio_1.load)(html);
+    const $activeTab = $('.tab-pane.show.active');
+    $('.type-example').remove();
+    const $definitions = $activeTab.find('li.type-meaning.depth-0 > .meaningContainer .def.html');
+    $definitions.find('.meaningTree').remove();
+    const definitions = Array.from($definitions).map((definition) => $(definition).text().replace(/\n/g, ''));
+    return {
+        definitions,
+        exists: definitions.length > 0,
+    };
+};
+exports.parse = parse;

package/packages/word-definitions/build/languages/spanish.d.ts

@@ -0,0 +1,3 @@
+import { ParsingResult } from '../types';
+export declare const crawl: (word: string) => Promise<string>;
+export declare const parse: (html: string) => ParsingResult;

package/packages/word-definitions/build/languages/spanish.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.crawl = void 0;
+const cheerio_1 = require("cheerio");
+const lib_1 = require("../lib");
+const crawl = (word) => {
+    return (0, lib_1.request)({
+        protocol: 'https',
+        hostname: 'www.diccionarios.com',
+        path: `/diccionario/espanol/${encodeURIComponent(word)}`,
+    });
+};
+exports.crawl = crawl;
+const parse = (html) => {
+    const $ = (0, cheerio_1.load)(html);
+    $('.verdBold14 + .gris11 + .gris13').remove();
+    $('br + .gris13').remove();
+    $('.grisItalic13 + .gris13').remove();
+    $('font[class^="verd"]').remove();
+    $('font.gris11').remove();
+    $('font[class^="grisBold"]').remove();
+    $('font[class^="grisItalic"]').remove();
+    Array.from($('.gris13')).forEach((element) => {
+        const children = $(element).find('.gris13');
+        if (children && children.length > 0) {
+            children.remove();
+        }
+    });
+    const definitions = Array.from($('.dcom-search-result .gris13'));
+    return {
+        definitions: definitions
+            .map((definition) => $(definition).text().trim())
+            .filter(Boolean)
+            .map((definition) => definition.replace(/\s+\.$/g, ''))
+            .map((definition) => (definition.endsWith('.') ? definition : `${definition}.`)),
+        exists: $('.wrapper > p > strong').text() !== 'No se ha encontrado la palabra exacta',
+    };
+};
+exports.parse = parse;

package/packages/word-definitions/build/lib/index.d.ts

@@ -1,3 +1,3 @@
-export { default as normalizeDefinition } from './normalizeDefinition';
-export { default as request } from './request';
-export { default as unique } from './unique';
+export { normalizeDefinition } from './normalizeDefinition';
+export { request } from './request';
+export { unique } from './unique';

package/packages/word-definitions/build/lib/index.js

@@ -1,12 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unique = exports.request = exports.normalizeDefinition = void 0;
 var normalizeDefinition_1 = require("./normalizeDefinition");
-Object.defineProperty(exports, "normalizeDefinition", { enumerable: true, get: function () { return __importDefault(normalizeDefinition_1).default; } });
+Object.defineProperty(exports, "normalizeDefinition", { enumerable: true, get: function () { return normalizeDefinition_1.normalizeDefinition; } });
 var request_1 = require("./request");
-Object.defineProperty(exports, "request", { enumerable: true, get: function () { return __importDefault(request_1).default; } });
+Object.defineProperty(exports, "request", { enumerable: true, get: function () { return request_1.request; } });
 var unique_1 = require("./unique");
-Object.defineProperty(exports, "unique", { enumerable: true, get: function () { return __importDefault(unique_1).default; } });
+Object.defineProperty(exports, "unique", { enumerable: true, get: function () { return unique_1.unique; } });

package/packages/word-definitions/build/lib/normalizeDefinition.d.ts

@@ -1,2 +1 @@
-declare const normalizeDefinition: (definition: string) => string;
-export default normalizeDefinition;
+export declare const normalizeDefinition: (definition: string) => string;

package/packages/word-definitions/build/lib/normalizeDefinition.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDefinition = void 0;
 const striptags_1 = __importDefault(require("striptags"));
 const EMPHASIS_TAGS = ['a', 'b', 'em', 'internalXref'];
 const normalizeHtmlTags = (definition) => (0, striptags_1.default)((0, striptags_1.default)(definition, EMPHASIS_TAGS), undefined, '"');
@@ -40,6 +41,6 @@ const normalizers = [
 const normalizeDefinition = (definition) => {
     const normalized = normalizers.reduce((result, normalize) => normalize(result), definition);
     const hasChanged = normalized !== definition;
-    return hasChanged ? normalizeDefinition(normalized) : normalized;
+    return hasChanged ? (0, exports.normalizeDefinition)(normalized) : normalized;
 };
-exports.default = normalizeDefinition;
+exports.normalizeDefinition = normalizeDefinition;

package/packages/word-definitions/build/lib/request.d.ts

@@ -3,5 +3,5 @@ import { RequestOptions } from 'http';
 interface Options extends RequestOptions {
     protocol?: 'http' | 'https';
 }
-declare const request: ({ protocol, ...options }: Options) => Promise<string>;
-export default request;
+export declare const request: ({ protocol, ...options }: Options) => Promise<string>;
+export {};

package/packages/word-definitions/build/lib/request.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.request = void 0;
 const follow_redirects_1 = require("follow-redirects");
 const request = ({ protocol, ...options }) => {
     const agent = protocol === 'https' ? follow_redirects_1.https : follow_redirects_1.http;
@@ -23,4 +24,4 @@ const request = ({ protocol, ...options }) => {
             .on('error', reject);
     });
 };
-exports.default = request;
+exports.request = request;

package/packages/word-definitions/build/lib/unique.d.ts

@@ -1,2 +1 @@
-declare const unique: <T>(array: T[]) => T[];
-export default unique;
+export declare const unique: <T>(array: T[]) => T[];

package/packages/word-definitions/build/lib/unique.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = void 0;
 const unique = (array) => Array.from(new Set(array));
-exports.default = unique;
+exports.unique = unique;

package/packages/word-definitions/build/parse.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '@scrabble-solver/types';
+import { ParsingResult } from './types';
+export declare const parse: (locale: Locale, html: string) => ParsingResult;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const types_1 = require("@scrabble-solver/types");
+const languages_1 = require("./languages");
+const lib_1 = require("./lib");
+const parsePerLocale = {
+    [types_1.Locale.DE_DE]: languages_1.german.parse,
+    [types_1.Locale.EN_GB]: languages_1.english.parse,
+    [types_1.Locale.EN_US]: languages_1.english.parse,
+    [types_1.Locale.ES_ES]: languages_1.spanish.parse,
+    [types_1.Locale.FA_IR]: languages_1.persian.parse,
+    [types_1.Locale.FR_FR]: languages_1.french.parse,
+    [types_1.Locale.PL_PL]: languages_1.polish.parse,
+    [types_1.Locale.RO_RO]: languages_1.romanian.parse,
+};
+const parse = (locale, html) => {
+    const { definitions, exists } = parsePerLocale[locale](html);
+    return {
+        definitions: (0, lib_1.unique)(definitions.map(lib_1.normalizeDefinition).filter(Boolean)),
+        exists,
+    };
+};
+exports.parse = parse;

package/packages/word-definitions/build/types.d.ts

@@ -1,4 +1,4 @@
-export interface ParseResult {
+export interface ParsingResult {
     definitions: string[];
     exists: boolean;
 }

package/packages/word-definitions/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@scrabble-solver/word-definitions",
-  "version": "2.13.4",
+  "version": "2.13.5-alpha.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrabble-solver/word-definitions",
-      "version": "2.13.4",
+      "version": "2.13.5-alpha.1",
       "license": "CC-BY-NC-ND-4.0",
       "dependencies": {
         "cheerio": "^1.0.0-rc.12",

package/packages/word-definitions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/word-definitions",
-  "version": "2.13.4",
+  "version": "2.13.5-alpha.1",
   "description": "Scrabble Solver 2 - Word definitions",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -23,7 +23,7 @@
     "clean": "rimraf build/"
   },
   "dependencies": {
-    "@scrabble-solver/types": "^2.13.4",
+    "@scrabble-solver/types": "^2.13.5-alpha.1",
     "cheerio": "^1.0.0-rc.12",
     "follow-redirects": "^1.15.5",
     "striptags": "^3.2.0"

package/packages/word-definitions/src/crawl.ts

@@ -0,0 +1,18 @@
+import { Locale } from '@scrabble-solver/types';
+
+import { english, french, german, persian, polish, romanian, spanish } from './languages';
+
+const crawlPerLocale: Record<Locale, (word: string) => Promise<string>> = {
+  [Locale.DE_DE]: german.crawl,
+  [Locale.EN_GB]: english.crawl,
+  [Locale.EN_US]: english.crawl,
+  [Locale.ES_ES]: spanish.crawl,
+  [Locale.FA_IR]: persian.crawl,
+  [Locale.FR_FR]: french.crawl,
+  [Locale.PL_PL]: polish.crawl,
+  [Locale.RO_RO]: romanian.crawl,
+};
+
+export const crawl = (locale: Locale, word: string): Promise<string> => {
+  return crawlPerLocale[locale](word);
+};

package/packages/word-definitions/src/getWordDefinition.ts

@@ -3,11 +3,9 @@ import { Locale, WordDefinition } from '@scrabble-solver/types';
 import { crawl } from './crawl';
 import { parse } from './parse';
 
-const getWordDefinition = async (locale: Locale, word: string, isAllowed: boolean): Promise<WordDefinition> => {
+export const getWordDefinition = async (locale: Locale, word: string, isAllowed: boolean): Promise<WordDefinition> => {
   const html = await crawl(locale, word);
   const { definitions, exists } = parse(locale, html);
   const wordDefinition = new WordDefinition({ definitions, exists, isAllowed, word });
   return wordDefinition;
 };
-
-export default getWordDefinition;

package/packages/word-definitions/src/index.ts

@@ -1,5 +1,6 @@
-export { default as getWordDefinition } from './getWordDefinition';
+export { getWordDefinition } from './getWordDefinition';
 
 export * from './crawl';
+export * from './languages';
 export * from './lib';
 export * from './parse';

package/packages/word-definitions/src/{parse/parseEnglish.ts → languages/english.ts}

@@ -1,12 +1,21 @@
 import { load } from 'cheerio';
 
-import { ParseResult } from '../types';
+import { request } from '../lib';
+import { ParsingResult } from '../types';
 
 const DOES_NOT_EXIST_MESSAGE =
   // eslint-disable-next-line max-len
   "The word you've entered isn't in the dictionary. Click on a spelling suggestion below or try again using the search bar above.";
 
-const parseEnglish = (html: string): ParseResult => {
+export const crawl = (word: string): Promise<string> => {
+  return request({
+    protocol: 'https',
+    hostname: 'www.merriam-webster.com',
+    path: `/dictionary/${encodeURIComponent(word)}`,
+  });
+};
+
+export const parse = (html: string): ParsingResult => {
   const $ = load(html);
   $('strong.mw_t_bc').replaceWith(', ');
   $('.text-lowercase').remove();
@@ -19,5 +28,3 @@ const parseEnglish = (html: string): ParseResult => {
     exists: $('.spelling-suggestion-text').text().trim() !== DOES_NOT_EXIST_MESSAGE,
   };
 };
-
-export default parseEnglish;

package/packages/word-definitions/src/languages/french.ts

@@ -0,0 +1,22 @@
+import { load } from 'cheerio';
+
+import { request } from '../lib';
+import { ParsingResult } from '../types';
+
+export const crawl = (word: string): Promise<string> => {
+  return request({
+    protocol: 'https',
+    hostname: 'www.cnrtl.fr',
+    path: `/definition/${encodeURIComponent(word)}`,
+  });
+};
+
+export const parse = (html: string): ParsingResult => {
+  const $ = load(html);
+  const $definitions = $('.tlf_cdefinition');
+
+  return {
+    definitions: Array.from($definitions).map((definition) => $(definition).text()),
+    exists: $('#vitemselected span').length > 0,
+  };
+};

package/packages/word-definitions/src/{parse/parseGerman.ts → languages/german.ts}

@@ -1,12 +1,21 @@
 import { Cheerio, CheerioAPI, Element, load } from 'cheerio';
 
-import { ParseResult } from '../types';
+import { request } from '../lib';
+import { ParsingResult } from '../types';
+
+export const crawl = (word: string): Promise<string> => {
+  return request({
+    protocol: 'https',
+    hostname: 'www.dwds.de',
+    path: `/wb/${encodeURIComponent(word)}`,
+  });
+};
 
-const parseGerman = (html: string): ParseResult => {
+export const parse = (html: string): ParsingResult => {
   const $ = load(html);
 
   const definitions = [parseBedeutungsubersicht, parseBedeutungen, parseBedeutung].reduce<string[]>(
-    (results, parse) => (results.length === 0 ? parse($) : results),
+    (results, parseDefinition) => (results.length === 0 ? parseDefinition($) : results),
     [],
   );
   const exists = Array.from($('.label-danger')).every((label) => $(label).text() !== 'Hinweis');
@@ -76,5 +85,3 @@ const parseDefinitions = ($: CheerioAPI, $definitions: Cheerio<Element>) => {
       .replace(/^[0-9]+\.\s/g, ''),
   );
 };
-
-export default parseGerman;

package/packages/word-definitions/src/languages/index.ts

@@ -0,0 +1,7 @@
+export * as english from './english';
+export * as german from './german';
+export * as french from './french';
+export * as persian from './persian';
+export * as polish from './polish';
+export * as romanian from './romanian';
+export * as spanish from './spanish';

package/packages/word-definitions/src/{parse/parseFarsi.ts → languages/persian.ts}

@@ -1,10 +1,19 @@
 import { load } from 'cheerio';
 
-import { ParseResult } from '../types';
+import { request } from '../lib';
+import { ParsingResult } from '../types';
 
 const DOES_NOT_EXIST_MESSAGE = '404 Page Not Found';
 
-const parseFarsi = (html: string): ParseResult => {
+export const crawl = (word: string): Promise<string> => {
+  return request({
+    protocol: 'https',
+    hostname: 'www.vajehyab.com',
+    path: `/moein/${encodeURIComponent(word)}`,
+  });
+};
+
+export const parse = (html: string): ParsingResult => {
   const $ = load(html);
   const $definitions = $('[itemprop=articleBody]');
 
@@ -13,5 +22,3 @@ const parseFarsi = (html: string): ParseResult => {
     exists: $('#container h1').text() !== DOES_NOT_EXIST_MESSAGE,
   };
 };
-
-export default parseFarsi;

package/packages/word-definitions/src/{parse/parsePolish.ts → languages/polish.ts}

@@ -1,8 +1,17 @@
 import { load } from 'cheerio';
 
-import { ParseResult } from '../types';
+import { request } from '../lib';
+import { ParsingResult } from '../types';
 
-const parsePolish = (html: string): ParseResult => {
+export const crawl = (word: string): Promise<string> => {
+  return request({
+    protocol: 'https',
+    hostname: 'sjp.pl',
+    path: `/${encodeURIComponent(word)}`,
+  });
+};
+
+export const parse = (html: string): ParsingResult => {
   const $ = load(html);
   const $header = $($('h1')[0]);
   const $isAllowed = $header.next();
@@ -13,5 +22,3 @@ const parsePolish = (html: string): ParseResult => {
     exists: $isAllowed.text().trim().indexOf('dopuszczalne w grach') >= 0,
   };
 };
-
-export default parsePolish;

package/packages/word-definitions/src/{parse/parseRomanian.ts → languages/romanian.ts}

@@ -1,8 +1,17 @@
 import { load } from 'cheerio';
 
-import { ParseResult } from '../types';
+import { request } from '../lib';
+import { ParsingResult } from '../types';
 
-const parseRomanian = (html: string): ParseResult => {
+export const crawl = (word: string): Promise<string> => {
+  return request({
+    protocol: 'https',
+    hostname: 'dexonline.ro',
+    path: `/definitie/${encodeURIComponent(word)}`,
+  });
+};
+
+export const parse = (html: string): ParsingResult => {
   const $ = load(html);
 
   const $activeTab = $('.tab-pane.show.active');
@@ -16,5 +25,3 @@ const parseRomanian = (html: string): ParseResult => {
     exists: definitions.length > 0,
   };
 };
-
-export default parseRomanian;

package/packages/word-definitions/src/{parse/parseSpanish.ts → languages/spanish.ts}

@@ -1,8 +1,17 @@
 import { load } from 'cheerio';
 
-import { ParseResult } from '../types';
+import { request } from '../lib';
+import { ParsingResult } from '../types';
 
-const parseSpanish = (html: string): ParseResult => {
+export const crawl = (word: string): Promise<string> => {
+  return request({
+    protocol: 'https',
+    hostname: 'www.diccionarios.com',
+    path: `/diccionario/espanol/${encodeURIComponent(word)}`,
+  });
+};
+
+export const parse = (html: string): ParsingResult => {
   const $ = load(html);
   $('.verdBold14 + .gris11 + .gris13').remove();
   $('br + .gris13').remove();
@@ -31,5 +40,3 @@ const parseSpanish = (html: string): ParseResult => {
     exists: $('.wrapper > p > strong').text() !== 'No se ha encontrado la palabra exacta',
   };
 };
-
-export default parseSpanish;

package/packages/word-definitions/src/lib/index.ts

@@ -1,3 +1,3 @@
-export { default as normalizeDefinition } from './normalizeDefinition';
-export { default as request } from './request';
-export { default as unique } from './unique';
+export { normalizeDefinition } from './normalizeDefinition';
+export { request } from './request';
+export { unique } from './unique';

package/packages/word-definitions/src/lib/normalizeDefinition.ts

@@ -46,10 +46,8 @@ const normalizers: Normalize[] = [
   (definition) => definition.trim(),
 ];
 
-const normalizeDefinition = (definition: string): string => {
+export const normalizeDefinition = (definition: string): string => {
   const normalized = normalizers.reduce((result, normalize) => normalize(result), definition);
   const hasChanged = normalized !== definition;
   return hasChanged ? normalizeDefinition(normalized) : normalized;
 };
-
-export default normalizeDefinition;

package/packages/word-definitions/src/lib/request.ts

@@ -5,7 +5,7 @@ interface Options extends RequestOptions {
   protocol?: 'http' | 'https';
 }
 
-const request = ({ protocol, ...options }: Options): Promise<string> => {
+export const request = ({ protocol, ...options }: Options): Promise<string> => {
   const agent = protocol === 'https' ? https : http;
 
   return new Promise((resolve, reject) => {
@@ -27,5 +27,3 @@ const request = ({ protocol, ...options }: Options): Promise<string> => {
       .on('error', reject);
   });
 };
-
-export default request;

package/packages/word-definitions/src/lib/unique.ts

@@ -1,3 +1 @@
-const unique = <T>(array: T[]): T[] => Array.from(new Set(array));
-
-export default unique;
+export const unique = <T>(array: T[]): T[] => Array.from(new Set(array));

package/packages/word-definitions/src/{parse/parse.test.ts → parse.test.ts}

@@ -2,7 +2,7 @@ import { Locale } from '@scrabble-solver/types';
 import fs from 'fs';
 import path from 'path';
 
-import parse from './parse';
+import { parse } from './parse';
 
 export const readTestFile = (filepath: string): string => {
   const absoluteFilepath = path.resolve(__dirname, '__tests__', filepath);
@@ -26,11 +26,9 @@ const tests = [
 ];
 
 describe('parse', () => {
-  tests.forEach(({ locale, word }) => {
-    it(`${locale} - "${word}"`, () => {
-      const input = readTestFile(`input/${locale}.${word}.html`);
-      const expected = readTestFile(`expected/${locale}.${word}.json`);
-      expect(parse(locale, input)).toEqual(JSON.parse(expected));
-    });
+  it.each(tests)(`[$locale] "$word"`, ({ locale, word }) => {
+    const input = readTestFile(`input/${locale}.${word}.html`);
+    const expected = readTestFile(`expected/${locale}.${word}.json`);
+    expect(parse(locale, input)).toEqual(JSON.parse(expected));
   });
 });

package/packages/word-definitions/src/parse.ts

@@ -0,0 +1,25 @@
+import { Locale } from '@scrabble-solver/types';
+
+import { english, french, german, persian, polish, romanian, spanish } from './languages';
+import { normalizeDefinition, unique } from './lib';
+import { ParsingResult } from './types';
+
+const parsePerLocale: Record<Locale, (html: string) => ParsingResult> = {
+  [Locale.DE_DE]: german.parse,
+  [Locale.EN_GB]: english.parse,
+  [Locale.EN_US]: english.parse,
+  [Locale.ES_ES]: spanish.parse,
+  [Locale.FA_IR]: persian.parse,
+  [Locale.FR_FR]: french.parse,
+  [Locale.PL_PL]: polish.parse,
+  [Locale.RO_RO]: romanian.parse,
+};
+
+export const parse = (locale: Locale, html: string): ParsingResult => {
+  const { definitions, exists } = parsePerLocale[locale](html);
+
+  return {
+    definitions: unique(definitions.map(normalizeDefinition).filter(Boolean)),
+    exists,
+  };
+};

package/packages/word-definitions/src/types.ts

@@ -1,4 +1,4 @@
-export interface ParseResult {
+export interface ParsingResult {
   definitions: string[];
   exists: boolean;
 }

package/packages/word-lists/build/getWordList.d.ts

@@ -1,3 +1,2 @@
 import { Locale } from '@scrabble-solver/types';
-declare const getWordList: (locale: Locale) => Promise<string[]>;
-export default getWordList;
+export declare const getWordList: (locale: Locale) => Promise<string[]>;