scrabble-solver 2.9.0 → 2.9.2

package/packages/scrabble-solver/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@scrabble-solver/scrabble-solver",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrabble-solver/scrabble-solver",
-      "version": "2.9.0",
+      "version": "2.9.2",
       "license": "CC BY-NC-ND 4.0",
       "dependencies": {
         "@kamilmielnik/trie": "^2.0.1",

package/packages/scrabble-solver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/scrabble-solver",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "Scrabble Solver 2 - App",
   "engines": {
     "node": ">=16"
@@ -11,8 +11,8 @@
   },
   "author": {
     "name": "Kamil Mielnik",
-    "email": "kamil.adam.mielnik@gmail.com",
-    "url": "https://kamilmielnik.com/"
+    "email": "kamil@kamilmielnik.com",
+    "url": "https://kamilmielnik.com"
   },
   "license": "CC BY-NC-ND 4.0",
   "bugs": {
@@ -31,13 +31,13 @@
     "@kamilmielnik/trie": "^2.0.1",
     "@popperjs/core": "^2.11.6",
     "@reduxjs/toolkit": "^1.8.6",
-    "@scrabble-solver/configs": "^2.9.0",
-    "@scrabble-solver/constants": "^2.9.0",
-    "@scrabble-solver/dictionaries": "^2.9.0",
-    "@scrabble-solver/logger": "^2.9.0",
-    "@scrabble-solver/solver": "^2.9.0",
-    "@scrabble-solver/types": "^2.9.0",
-    "@scrabble-solver/word-definitions": "^2.9.0",
+    "@scrabble-solver/configs": "^2.9.2",
+    "@scrabble-solver/constants": "^2.9.2",
+    "@scrabble-solver/dictionaries": "^2.9.2",
+    "@scrabble-solver/logger": "^2.9.2",
+    "@scrabble-solver/solver": "^2.9.2",
+    "@scrabble-solver/types": "^2.9.2",
+    "@scrabble-solver/word-definitions": "^2.9.2",
     "classnames": "^2.3.2",
     "next": "^12.3.1",
     "normalize.css": "^8.0.1",

package/packages/scrabble-solver/src/components/Board/BoardPure.tsx

@@ -44,13 +44,7 @@ const BoardPure: FunctionComponent<Props> = ({
   onKeyDown,
   onPaste,
 }) => (
-  <div
-    className={classNames(styles.board, className)}
-    ref={innerRef}
-    onChange={onChange}
-    onKeyDown={onKeyDown}
-    onPaste={onPaste}
-  >
+  <div className={classNames(styles.board, className)} ref={innerRef} onKeyDown={onKeyDown} onPaste={onPaste}>
     {rows.map((cells, y) => (
       <div className={styles.row} key={y}>
         {cells.map((cell, x) => (
@@ -62,6 +56,7 @@ const BoardPure: FunctionComponent<Props> = ({
             isCenter={center.x === x && center.y === y}
             key={x}
             size={cellSize}
+            onChange={onChange}
             onDirectionToggle={onDirectionToggle}
             onFocus={onFocus}
           />

package/packages/scrabble-solver/src/components/Board/components/Cell/Cell.module.scss

@@ -213,7 +213,7 @@ $icon-size: 16px;
 
 .flag,
 .star {
-  $size: 24px;
+  $size: 50%;
 
   width: $size;
   height: $size;

package/packages/scrabble-solver/src/components/Board/components/Cell/Cell.tsx

@@ -1,6 +1,6 @@
 import { EMPTY_CELL } from '@scrabble-solver/constants';
 import { Cell as CellModel } from '@scrabble-solver/types';
-import { FunctionComponent, RefObject, useCallback, useMemo } from 'react';
+import { ChangeEventHandler, FunctionComponent, RefObject, useCallback, useMemo } from 'react';
 import { useDispatch } from 'react-redux';
 
 import { getTileSizes } from 'lib';
@@ -23,6 +23,7 @@ interface Props {
   inputRef: RefObject<HTMLInputElement>;
   isCenter: boolean;
   size: number;
+  onChange: ChangeEventHandler<HTMLInputElement>;
   onDirectionToggle: () => void;
   onFocus: (x: number, y: number) => void;
 }
@@ -34,6 +35,7 @@ const Cell: FunctionComponent<Props> = ({
   inputRef,
   isCenter,
   size,
+  onChange,
   onDirectionToggle,
   onFocus,
 }) => {
@@ -88,6 +90,7 @@ const Cell: FunctionComponent<Props> = ({
       style={style}
       tile={tile}
       translate={translate}
+      onChange={onChange}
       onDirectionToggleClick={handleDirectionToggleClick}
       onFocus={handleFocus}
       onToggleBlankClick={handleToggleBlankClick}

package/packages/scrabble-solver/src/components/Board/components/Cell/CellPure.tsx

@@ -1,6 +1,14 @@
 import { Bonus, Cell, Tile as TileModel } from '@scrabble-solver/types';
 import classNames from 'classnames';
-import { CSSProperties, FocusEventHandler, FunctionComponent, memo, MouseEventHandler, RefObject } from 'react';
+import {
+  ChangeEventHandler,
+  CSSProperties,
+  FocusEventHandler,
+  FunctionComponent,
+  memo,
+  MouseEventHandler,
+  RefObject,
+} from 'react';
 
 import { ArrowDown, Flag, Star } from 'icons';
 import { Translate } from 'types';
@@ -25,6 +33,7 @@ interface Props {
   style?: CSSProperties;
   tile: TileModel;
   translate: Translate;
+  onChange: ChangeEventHandler<HTMLInputElement>;
   onDirectionToggleClick: MouseEventHandler<HTMLButtonElement>;
   onFocus: FocusEventHandler<HTMLInputElement>;
   onToggleBlankClick: MouseEventHandler<HTMLButtonElement>;
@@ -45,6 +54,7 @@ const CellPure: FunctionComponent<Props> = ({
   style,
   tile,
   translate,
+  onChange,
   onDirectionToggleClick,
   onFocus,
   onToggleBlankClick,
@@ -78,6 +88,7 @@ const CellPure: FunctionComponent<Props> = ({
       raised={!isEmpty}
       size={size}
       tabIndex={cell.x === 0 && cell.y === 0 ? undefined : -1}
+      onChange={onChange}
       onFocus={onFocus}
     />
 

package/packages/scrabble-solver/src/components/Dictionary/Dictionary.module.scss

@@ -53,6 +53,7 @@
 
 .definition {
   margin-bottom: var(--spacing--s);
+  white-space: pre-wrap;
 
   &:last-child {
     margin-bottom: 0;

package/packages/scrabble-solver/src/components/Dictionary/Dictionary.tsx

@@ -31,7 +31,7 @@ const Dictionary: FunctionComponent<Props> = ({ className }) => {
         </EmptyState>
       )}
 
-      {results.map(({ definitions, isAllowed, word }) => (
+      {results.map(({ definitions, exists, isAllowed, word }) => (
         <div
           className={classNames(styles.result, {
             [styles.isAllowed]: isAllowed === true,
@@ -51,7 +51,12 @@ const Dictionary: FunctionComponent<Props> = ({ className }) => {
 
               {isAllowed === true && (
                 <>
-                  {definitions.length === 0 && <div>{translate('dictionary.empty-state.no-definitions')}</div>}
+                  {definitions.length === 0 && (
+                    <>
+                      {exists && <div>{translate('dictionary.empty-state.no-definitions')}</div>}
+                      {!exists && <div>{translate('dictionary.empty-state.no-results')}</div>}
+                    </>
+                  )}
 
                   {definitions.length > 0 && (
                     <ul className={styles.definitions}>

package/packages/scrabble-solver/src/components/Splash/Splash.module.scss

@@ -1,6 +1,6 @@
 @import 'styles/animations';
 
-$loading-duration: 450ms;
+$loading-duration: 250ms;
 $loaded-duration: 100ms;
 $hiding-duration: 200ms;
 

package/packages/scrabble-solver/src/i18n/en.json

@@ -15,9 +15,9 @@
   "common.word": "Word",
   "common.words": "Words",
   "dictionary.empty-state.no-definitions": "Word exists in the dictionary but it does not have a definition.",
-  "dictionary.empty-state.no-results": "Unable to find word definition in dictionary.",
+  "dictionary.empty-state.no-results": "Unable to find word definition in the dictionary.",
   "dictionary.empty-state.not-allowed": "This word is not allowed.",
-  "dictionary.empty-state.uninitialized": "Dictionary definition of the last highlighted word will be shown here.",
+  "dictionary.empty-state.uninitialized": "Dictionary definition of the most recently highlighted word will be shown here.",
   "dictionary.input.placeholder": "Search dictionary...",
   "empty-state.error": "Error",
   "empty-state.info": "Info",

package/packages/scrabble-solver/src/pages/api/dictionary/[locale]/[word].ts

@@ -1,4 +1,5 @@
 import { scrabble } from '@scrabble-solver/configs';
+import { dictionaries } from '@scrabble-solver/dictionaries';
 import logger from '@scrabble-solver/logger';
 import { isLocale, Locale } from '@scrabble-solver/types';
 import { getWordDefinition } from '@scrabble-solver/word-definitions';
@@ -27,7 +28,8 @@ const dictionary = async (request: NextApiRequest, response: NextApiResponse): P
       },
     });
 
-    const results = await Promise.all(words.map((word) => getWordDefinition(locale, word)));
+    const trie = await dictionaries.get(locale);
+    const results = await Promise.all(words.map((word) => getWordDefinition(locale, word, trie.has(word))));
     response.status(200).send(results.map((result) => result.toJson()));
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Unknown error';

package/packages/scrabble-solver/src/pages/index.tsx

@@ -48,7 +48,8 @@ const Index: FunctionComponent<Props> = ({ version }) => {
     useMeasure<HTMLDivElement>();
   const config = useTypedSelector(selectConfig);
   const cellSize = getCellSize(config, contentWidth - resultsContainerWidth, contentHeight);
-  const isInitialized = contentWidth > 0 && boardHeight > 0 && resultsContainerWidth > 0;
+  const isInitializedInitial = contentWidth > 0 && boardHeight > 0 && resultsContainerWidth > 0;
+  const [isInitialized, setIsInitialized] = useState(isInitializedInitial);
   const resultsHeight = boardHeight - DICTIONARY_HEIGHT - (isTablet ? COMPONENTS_SPACING_MOBILE : COMPONENTS_SPACING);
 
   const handleClear = () => {
@@ -71,6 +72,10 @@ const Index: FunctionComponent<Props> = ({ version }) => {
 
   useEffectOnce(() => {
     dispatch(initialize());
+
+    setTimeout(() => {
+      setIsInitialized(true);
+    }, 100);
   });
 
   useEffect(() => {

package/packages/scrabble-solver/src/service-worker/dictionaries/constants.ts

@@ -1,3 +1,5 @@
 export const DICTIONARY_CACHE = 'dictionary-api-cache';
 
-export const DICTIONARY_CACHE_MAX_AGE = 30 * 24 * 60 * 60 * 1000;
+export const DAY = 24 * 60 * 60 * 1000;
+
+export const DICTIONARY_CACHE_MAX_AGE = 1 * DAY; // eslint-disable-line no-implicit-coercion

package/packages/solver/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrabble-solver/solver",
-      "version": "2.9.0",
+      "version": "2.9.2",
       "license": "CC-BY-NC-ND-4.0",
       "dependencies": {
         "@kamilmielnik/trie": "^2.0.1"

package/packages/solver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "Scrabble Solver 2 - Solver",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -10,8 +10,8 @@
   },
   "author": {
     "name": "Kamil Mielnik",
-    "email": "kamil.adam.mielnik@gmail.com",
-    "url": "https://kamilmielnik.com/"
+    "email": "kamil@kamilmielnik.com",
+    "url": "https://kamilmielnik.com"
   },
   "license": "CC-BY-NC-ND-4.0",
   "bugs": {
@@ -25,12 +25,12 @@
   },
   "dependencies": {
     "@kamilmielnik/trie": "^2.0.1",
-    "@scrabble-solver/types": "^2.9.0"
+    "@scrabble-solver/types": "^2.9.2"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.9.0",
-    "@scrabble-solver/constants": "^2.9.0",
-    "@scrabble-solver/dictionaries": "^2.9.0"
+    "@scrabble-solver/configs": "^2.9.2",
+    "@scrabble-solver/constants": "^2.9.2",
+    "@scrabble-solver/dictionaries": "^2.9.2"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }

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

@@ -1,10 +1,10 @@
 declare enum Locale {
+    DE_DE = "de-DE",
     EN_GB = "en-GB",
     EN_US = "en-US",
     ES_ES = "es-ES",
     FR_FR = "fr-FR",
-    PL_PL = "pl-PL",
-    DE_DE = "de-DE"
+    PL_PL = "pl-PL"
 }
 export declare const isLocale: (locale: unknown) => locale is Locale;
 export default Locale;

package/packages/types/build/Locale.js

@@ -4,12 +4,12 @@ exports.isLocale = void 0;
 // eslint-disable-next-line no-shadow
 var Locale;
 (function (Locale) {
+    Locale["DE_DE"] = "de-DE";
     Locale["EN_GB"] = "en-GB";
     Locale["EN_US"] = "en-US";
     Locale["ES_ES"] = "es-ES";
     Locale["FR_FR"] = "fr-FR";
     Locale["PL_PL"] = "pl-PL";
-    Locale["DE_DE"] = "de-DE";
 })(Locale || (Locale = {}));
 const locales = Object.values(Locale);
 const isLocale = (locale) => locales.includes(locale);

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

@@ -3,13 +3,16 @@ declare class WordDefinition {
     static fromJson(json: WordDefinitionJson | null): WordDefinition;
     static readonly Null: WordDefinition;
     readonly definitions: string[];
+    /**
+     * Does the word have an entry in a corresponding online dictionary?
+     */
+    readonly exists: boolean;
+    /**
+     * Can the word be legally used in the game?
+     */
     readonly isAllowed: boolean;
     readonly word: string;
-    constructor({ definitions, isAllowed, word }: {
-        definitions: string[];
-        isAllowed: boolean;
-        word: string;
-    });
+    constructor({ definitions, exists, isAllowed, word }: WordDefinitionJson);
     toJson(): WordDefinitionJson | null;
 }
 export default WordDefinition;

package/packages/types/build/WordDefinition.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class WordDefinition {
-    constructor({ definitions, isAllowed, word }) {
+    constructor({ definitions, exists, isAllowed, word }) {
         this.definitions = definitions;
+        this.exists = exists;
         this.isAllowed = isAllowed;
         this.word = word;
     }
@@ -12,6 +13,7 @@ class WordDefinition {
         }
         return new WordDefinition({
             definitions: json.definitions,
+            exists: json.exists,
             isAllowed: json.isAllowed,
             word: json.word,
         });
@@ -19,6 +21,7 @@ class WordDefinition {
     toJson() {
         return {
             definitions: this.definitions,
+            exists: this.exists,
             isAllowed: this.isAllowed,
             word: this.word,
         };
@@ -26,6 +29,7 @@ class WordDefinition {
 }
 WordDefinition.Null = Object.freeze({
     definitions: [],
+    exists: false,
     isAllowed: false,
     word: '',
     toJson: () => null,

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

@@ -1,5 +1,12 @@
 interface WordDefinitionJson {
     definitions: string[];
+    /**
+     * Does the word have an entry in a corresponding online dictionary?
+     */
+    exists: boolean;
+    /**
+     * Can the word be legally used in the game?
+     */
     isAllowed: boolean;
     word: string;
 }

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/types",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "Scrabble Solver 2 - Types",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -10,8 +10,8 @@
   },
   "author": {
     "name": "Kamil Mielnik",
-    "email": "kamil.adam.mielnik@gmail.com",
-    "url": "https://kamilmielnik.com/"
+    "email": "kamil@kamilmielnik.com",
+    "url": "https://kamilmielnik.com"
   },
   "license": "CC-BY-NC-ND-4.0",
   "bugs": {
@@ -24,7 +24,7 @@
     "clean:force": "npm run clean && rimraf package-lock.json"
   },
   "dependencies": {
-    "@scrabble-solver/constants": "^2.9.0"
+    "@scrabble-solver/constants": "^2.9.2"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }

package/packages/types/src/Locale.ts

@@ -1,11 +1,11 @@
 // eslint-disable-next-line no-shadow
 enum Locale {
+  DE_DE = 'de-DE',
   EN_GB = 'en-GB',
   EN_US = 'en-US',
   ES_ES = 'es-ES',
   FR_FR = 'fr-FR',
   PL_PL = 'pl-PL',
-  DE_DE = 'de-DE',
 }
 
 const locales = Object.values(Locale);

package/packages/types/src/WordDefinition.ts

@@ -8,6 +8,7 @@ class WordDefinition {
 
     return new WordDefinition({
       definitions: json.definitions,
+      exists: json.exists,
       isAllowed: json.isAllowed,
       word: json.word,
     });
@@ -15,6 +16,7 @@ class WordDefinition {
 
   public static readonly Null: WordDefinition = Object.freeze({
     definitions: [],
+    exists: false,
     isAllowed: false,
     word: '',
     toJson: () => null,
@@ -22,12 +24,21 @@ class WordDefinition {
 
   public readonly definitions: string[];
 
+  /**
+   * Does the word have an entry in a corresponding online dictionary?
+   */
+  public readonly exists: boolean;
+
+  /**
+   * Can the word be legally used in the game?
+   */
   public readonly isAllowed: boolean;
 
   public readonly word: string;
 
-  constructor({ definitions, isAllowed, word }: { definitions: string[]; isAllowed: boolean; word: string }) {
+  constructor({ definitions, exists, isAllowed, word }: WordDefinitionJson) {
     this.definitions = definitions;
+    this.exists = exists;
     this.isAllowed = isAllowed;
     this.word = word;
   }
@@ -35,6 +46,7 @@ class WordDefinition {
   public toJson(): WordDefinitionJson | null {
     return {
       definitions: this.definitions,
+      exists: this.exists,
       isAllowed: this.isAllowed,
       word: this.word,
     };

package/packages/types/src/WordDefinitionJson.ts

@@ -1,5 +1,12 @@
 interface WordDefinitionJson {
   definitions: string[];
+  /**
+   * Does the word have an entry in a corresponding online dictionary?
+   */
+  exists: boolean;
+  /**
+   * Can the word be legally used in the game?
+   */
   isAllowed: boolean;
   word: string;
 }

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

@@ -1,3 +1,3 @@
 import { Locale, WordDefinition } from '@scrabble-solver/types';
-declare const getWordDefinition: (locale: Locale, word: string) => Promise<WordDefinition>;
+declare const getWordDefinition: (locale: Locale, word: string, isAllowed: boolean) => Promise<WordDefinition>;
 export default getWordDefinition;

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

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@scrabble-solver/types");
 const crawl_1 = require("./crawl");
 const parse_1 = require("./parse");
-const getWordDefinition = async (locale, word) => {
+const getWordDefinition = async (locale, word, isAllowed) => {
     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 });
+    const { definitions, exists } = (0, parse_1.parse)(locale, html);
+    const wordDefinition = new types_1.WordDefinition({ definitions, exists, isAllowed, word });
     return wordDefinition;
 };
 exports.default = getWordDefinition;

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

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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, '"');
-const normalizeLineBreaks = (definition) => definition.replace(/[\r\n]/g, '');
+const normalizeLineBreaks = (definition) => definition.replace(/\r\n/g, '\n');
+const normalizeWhitespace = (definition) => definition.replace(/[ ]+/g, ' ');
 const normalizeQuotes = (definition) => definition.replace(/\."/g, '".');
 /**
  * `(1.2) definition` -> `definition`
@@ -26,6 +27,7 @@ const normalizers = [
     normalizeMarkers,
     normalizeQuotes,
     normalizeLineBreaks,
+    normalizeWhitespace,
     normalizeTrailingSymbols,
     normalizeLeadingSymbols,
     normalizeNonWords,

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

@@ -19,10 +19,10 @@ const parsePerLocale = {
     [types_1.Locale.PL_PL]: parsePolish_1.default,
 };
 const parse = (locale, html) => {
-    const { definitions, isAllowed } = parsePerLocale[locale](html);
+    const { definitions, exists } = parsePerLocale[locale](html);
     return {
         definitions: (0, lib_1.unique)(definitions.map(lib_1.normalizeDefinition).filter(Boolean)),
-        isAllowed,
+        exists,
     };
 };
 exports.default = parse;

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

@@ -1,18 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const cheerio_1 = __importDefault(require("cheerio"));
+const cheerio_1 = require("cheerio");
+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) => {
-    const $ = cheerio_1.default.load(html);
+    const $ = (0, cheerio_1.load)(html);
     $('strong.mw_t_bc').replaceWith(', ');
     $('.text-lowercase').remove();
     $('[id^=dictionary-entry]').find('.dtText > *:not(a)').remove();
     const $definitions = $('[id^=dictionary-entry]').find('.dtText, .cxl-ref');
     return {
-        definitions: Array.from($definitions).map((definition) => $(definition).text()),
-        isAllowed: $definitions.length > 0,
+        definitions: Array.from($definitions).map((definition) => $(definition).text().replace(/\n/g, '')),
+        exists: $('.spelling-suggestion-text').text().trim() !== DOES_NOT_EXIST_MESSAGE,
     };
 };
 exports.default = parseEnglish;

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

@@ -1,15 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const cheerio_1 = __importDefault(require("cheerio"));
+const cheerio_1 = require("cheerio");
 const parseFrench = (html) => {
-    const $ = cheerio_1.default.load(html);
+    const $ = (0, cheerio_1.load)(html);
     const $definitions = $('.tlf_cdefinition');
     return {
         definitions: Array.from($definitions).map((definition) => $(definition).text()),
-        isAllowed: $('#vitemselected span').length > 0,
+        exists: $('#vitemselected span').length > 0,
     };
 };
 exports.default = parseFrench;