@scrabble-solver/scrabble-solver 2.8.8 → 2.8.10

package/src/i18n/de.json

@@ -49,5 +49,8 @@
   "settings.autoGroupTiles.right": "Rechte Seite",
   "settings.autoGroupTiles.null": "Nicht gruppieren",
   "settings.game": "Spiel",
-  "settings.language": "Sprache"
+  "settings.language": "Sprache",
+  "words": "Gebildete Wörter",
+  "words.invalid": "Falsch",
+  "words.valid": "Korrekt"
 }

package/src/i18n/en.json

@@ -49,5 +49,8 @@
   "settings.autoGroupTiles.right": "On the right",
   "settings.autoGroupTiles.null": "Do not group",
   "settings.game": "Game",
-  "settings.language": "Language"
+  "settings.language": "Language",
+  "words": "Created words",
+  "words.invalid": "Invalid",
+  "words.valid": "Valid"
 }

package/src/i18n/es.json

@@ -49,5 +49,8 @@
   "settings.autoGroupTiles.right": "A la derecha",
   "settings.autoGroupTiles.null": "No agrupar",
   "settings.game": "Juego",
-  "settings.language": "Idioma"
+  "settings.language": "Idioma",
+  "words": "Palabras creadas",
+  "words.invalid": "Incorrecto",
+  "words.valid": "Correcto"
 }

package/src/i18n/fr.json

@@ -49,5 +49,8 @@
   "settings.autoGroupTiles.right": "Vers la gauche",
   "settings.autoGroupTiles.null": "Ne pas grouper",
   "settings.game": "Jeu",
-  "settings.language": "Langue"
+  "settings.language": "Langue",
+  "words": "Mots créés",
+  "words.invalid": "Incorrect",
+  "words.valid": "Corriger"
 }

package/src/i18n/pl.json

@@ -49,5 +49,8 @@
   "settings.autoGroupTiles.right": "Po prawej",
   "settings.autoGroupTiles.null": "Nie grupuj",
   "settings.game": "Gra",
-  "settings.language": "Język"
+  "settings.language": "Język",
+  "words": "Utworzone słowa",
+  "words.invalid": "Niepoprawne",
+  "words.valid": "Poprawne"
 }

package/src/icons/BookHalf.svg

@@ -0,0 +1,4 @@
+<!-- https://icons.getbootstrap.com/icons/book-half/ -->
+<svg viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
+  <path d="M8.5 2.687c.654-.689 1.782-.886 3.112-.752 1.234.124 2.503.523 3.388.893v9.923c-.918-.35-2.107-.692-3.287-.81-1.094-.111-2.278-.039-3.213.492V2.687zM8 1.783C7.015.936 5.587.81 4.287.94c-1.514.153-3.042.672-3.994 1.105A.5.5 0 0 0 0 2.5v11a.5.5 0 0 0 .707.455c.882-.4 2.303-.881 3.68-1.02 1.409-.142 2.59.087 3.223.877a.5.5 0 0 0 .78 0c.633-.79 1.814-1.019 3.222-.877 1.378.139 2.8.62 3.681 1.02A.5.5 0 0 0 16 13.5v-11a.5.5 0 0 0-.293-.455c-.952-.433-2.48-.952-3.994-1.105C10.413.809 8.985.936 8 1.783z" fill="currentColor" />
+</svg>

package/src/icons/Check.svg

@@ -0,0 +1,4 @@
+<!-- https://icons.getbootstrap.com/icons/check/ -->
+<svg viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
+  <path d="M10.97 4.97a.75.75 0 0 1 1.07 1.05l-3.99 4.99a.75.75 0 0 1-1.08.02L4.324 8.384a.75.75 0 1 1 1.06-1.06l2.094 2.093 3.473-4.425a.267.267 0 0 1 .02-.022z" fill="currentColor" />
+</svg>

package/src/icons/Cross.svg

@@ -1,4 +1,4 @@
-<!-- https://icons.getbootstrap.com/icons/x-square-fill/ -->
+<!-- https://icons.getbootstrap.com/icons/x/ -->
 <svg viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
-  <path d="M2 0a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V2a2 2 0 0 0-2-2H2zm3.354 4.646L8 7.293l2.646-2.647a.5.5 0 0 1 .708.708L8.707 8l2.647 2.646a.5.5 0 0 1-.708.708L8 8.707l-2.646 2.647a.5.5 0 0 1-.708-.708L7.293 8 4.646 5.354a.5.5 0 1 1 .708-.708z" fill="currentColor" />
+  <path d="M4.646 4.646a.5.5 0 0 1 .708 0L8 7.293l2.646-2.647a.5.5 0 0 1 .708.708L8.707 8l2.647 2.646a.5.5 0 0 1-.708.708L8 8.707l-2.646 2.647a.5.5 0 0 1-.708-.708L7.293 8 4.646 5.354a.5.5 0 0 1 0-.708z"  fill="currentColor" />
 </svg>

package/src/icons/CrossFill.svg

@@ -0,0 +1,4 @@
+<!-- https://icons.getbootstrap.com/icons/x-square-fill/ -->
+<svg viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
+  <path d="M2 0a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V2a2 2 0 0 0-2-2H2zm3.354 4.646L8 7.293l2.646-2.647a.5.5 0 0 1 .708.708L8.707 8l2.647 2.646a.5.5 0 0 1-.708.708L8 8.707l-2.646 2.647a.5.5 0 0 1-.708-.708L7.293 8 4.646 5.354a.5.5 0 1 1 .708-.708z" fill="currentColor" />
+</svg>

package/src/icons/index.ts

@@ -2,10 +2,13 @@ export { default as ArrowDown } from './ArrowDown.svg';
 export { default as ArrowLeft } from './ArrowLeft.svg';
 export { default as ArrowRight } from './ArrowRight.svg';
 export { default as ArrowUp } from './ArrowUp.svg';
+export { default as BookHalf } from './BookHalf.svg';
+export { default as Check } from './Check.svg';
 export { default as CheckboxChecked } from './CheckboxChecked.svg';
 export { default as CheckboxEmpty } from './CheckboxEmpty.svg';
 export { default as Cog } from './Cog.svg';
 export { default as Cross } from './Cross.svg';
+export { default as CrossFill } from './CrossFill.svg';
 export { default as DashCircleFill } from './DashCircleFill.svg';
 export { default as Eraser } from './Eraser.svg';
 export { default as Flag } from './Flag.svg';

package/src/lib/extractCharacters.ts

@@ -0,0 +1,26 @@
+import { BLANK } from '@scrabble-solver/constants';
+import { Config } from '@scrabble-solver/types';
+
+const extractCharacters = (config: Config, value: string): string[] => {
+  let index = 0;
+  const characters: string[] = [];
+
+  while (index < value.length) {
+    const character = value[index];
+    const nextCharacter = value[index + 1];
+    const twoCharacterTileCandidate = `${character}${nextCharacter}`;
+
+    if (config.twoCharacterTiles.includes(twoCharacterTileCandidate)) {
+      characters.push(twoCharacterTileCandidate);
+      ++index;
+    } else if (config.hasCharacter(character) || character === BLANK) {
+      characters.push(character);
+    }
+
+    ++index;
+  }
+
+  return characters;
+};
+
+export default extractCharacters;

package/src/lib/extractInputValue.ts

@@ -0,0 +1,17 @@
+const extractInputValue = (input: HTMLInputElement) => {
+  const value = input.value.toLocaleLowerCase();
+
+  if (input.selectionStart === null || input.selectionEnd === null) {
+    return value;
+  }
+
+  const index = Math.min(input.selectionStart, input.selectionEnd);
+
+  if (index > 0) {
+    return value.substring(index - 1, index);
+  }
+
+  return value;
+};
+
+export default extractInputValue;

package/src/lib/index.ts

@@ -6,6 +6,8 @@ export { default as createKeyboardNavigation } from './createKeyboardNavigation'
 export { default as createKeyComparator } from './createKeyComparator';
 export { default as createNullMovingComparator } from './createNullMovingComparator';
 export { default as detectLocale } from './detectLocale';
+export { default as extractCharacters } from './extractCharacters';
+export { default as extractInputValue } from './extractInputValue';
 export { default as findCell } from './findCell';
 export { default as getCellSize } from './getCellSize';
 export { default as getRemainingTiles } from './getRemainingTiles';

package/src/lib/isCtrl.ts

@@ -1,6 +1,6 @@
 import { KeyboardEvent } from 'react';
 
-const isCtrl = <T>(event: KeyboardEvent<T>): boolean => {
+const isCtrl = <T>(event: KeyboardEvent<T> | globalThis.KeyboardEvent): boolean => {
   return event.ctrlKey || event.metaKey;
 };
 

package/src/lib/memoize.ts

@@ -1,5 +1,5 @@
 interface AnyFunction {
-  (...parameters: any[]): any; // eslint-disable-line @typescript-eslint/no-explicit-any
+  (...parameters: any[]): any | Promise<any>; // eslint-disable-line @typescript-eslint/no-explicit-any
 }
 
 interface AnyCachedFunction<T extends AnyFunction> extends AnyFunction {
@@ -20,6 +20,14 @@ const memoize = <T extends AnyFunction>(fn: T): AnyCachedFunction<T> => {
     return cache.find((entry) => parametersEqual(entry.parameters, parameters))?.result;
   };
 
+  const removeCache = (parameters: Parameters<T>): void => {
+    const index = cache.findIndex((entry) => parametersEqual(entry.parameters, parameters));
+
+    if (index >= 0) {
+      cache.splice(index, 1);
+    }
+  };
+
   const writeCache = (parameters: Parameters<T>, result: ReturnType<T>): void => {
     cache.push({ parameters, result });
   };
@@ -33,6 +41,12 @@ const memoize = <T extends AnyFunction>(fn: T): AnyCachedFunction<T> => {
 
     const result = fn(...parameters);
 
+    if (result instanceof Promise) {
+      result.catch(() => {
+        removeCache(parameters);
+      });
+    }
+
     writeCache(parameters, result);
 
     return result;

package/src/pages/api/solve.ts

@@ -2,7 +2,7 @@ import { getLocaleConfig, isConfigId } from '@scrabble-solver/configs';
 import { BLANK } from '@scrabble-solver/constants';
 import { dictionaries } from '@scrabble-solver/dictionaries';
 import logger from '@scrabble-solver/logger';
-import Solver from '@scrabble-solver/solver';
+import { solve as solveScrabble } from '@scrabble-solver/solver';
 import { Board, Config, isBoardJson, isLocale, Locale, Tile } from '@scrabble-solver/types';
 import { NextApiRequest, NextApiResponse } from 'next';
 
@@ -36,9 +36,8 @@ const solve = async (request: NextApiRequest, response: NextApiResponse): Promis
 
     const trie = await dictionaries.get(locale);
     const tiles = characters.map((character) => new Tile({ character, isBlank: character === BLANK }));
-    const solver = new Solver(config, trie);
-    const results = solver.solve(board, tiles);
-    response.status(200).send(results.map((result) => result.toJson()));
+    const results = solveScrabble(trie, config, board, tiles);
+    response.status(200).send(results);
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Unknown error';
     logger.error('solve - error', { error, meta });

package/src/pages/api/verify.ts

@@ -0,0 +1,71 @@
+import { getLocaleConfig, isConfigId } from '@scrabble-solver/configs';
+import { dictionaries } from '@scrabble-solver/dictionaries';
+import logger from '@scrabble-solver/logger';
+import { Board, Config, isBoardJson, isLocale, Locale } from '@scrabble-solver/types';
+import { NextApiRequest, NextApiResponse } from 'next';
+
+import { getServerLoggingData, isBoardValid } from 'api';
+
+interface RequestData {
+  board: Board;
+  config: Config;
+  locale: Locale;
+}
+
+const verify = async (request: NextApiRequest, response: NextApiResponse): Promise<void> => {
+  const meta = getServerLoggingData(request);
+
+  try {
+    const { board, locale } = parseRequest(request);
+
+    logger.info('verify - request', {
+      meta,
+      payload: {
+        board: board.toString(),
+        boardBlanksCount: board.getBlanksCount(),
+        boardTilesCount: board.getTilesCount(),
+        configId: request.body.configId,
+        locale,
+      },
+    });
+
+    const trie = await dictionaries.get(locale);
+    const words = board.getWords().sort((a, b) => a.localeCompare(b));
+    const invalidWords = words.filter((word) => !trie.has(word));
+    const validWords = words.filter((word) => trie.has(word));
+    response.status(200).send({ invalidWords, validWords });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('verify - error', { error, meta });
+    response.status(500).send({ error: 'Server error', message });
+    throw error;
+  }
+};
+
+const parseRequest = (request: NextApiRequest): RequestData => {
+  const { board: boardJson, configId, locale } = request.body;
+
+  if (!isLocale(locale)) {
+    throw new Error('Invalid "locale" parameter');
+  }
+
+  if (!isConfigId(configId)) {
+    throw new Error('Invalid "configId" parameter');
+  }
+
+  const config = getLocaleConfig(configId, locale);
+
+  if (!isBoardJson(boardJson) || !isBoardValid(boardJson, config)) {
+    throw new Error('Invalid "board" parameter');
+  }
+
+  const board = Board.fromJson(boardJson);
+
+  return {
+    board,
+    config,
+    locale,
+  };
+};
+
+export default verify;

package/src/pages/index.tsx

@@ -19,6 +19,7 @@ import {
   Settings,
   Splash,
   Well,
+  Words,
 } from 'components';
 import { useIsTablet, useLocalStorage } from 'hooks';
 import { getCellSize } from 'lib';
@@ -39,6 +40,7 @@ const Index: FunctionComponent<Props> = ({ version }) => {
   const [showKeyMap, setShowKeyMap] = useState(false);
   const [showRemainingTiles, setShowRemainingTiles] = useState(false);
   const [showSettings, setShowSettings] = useState(false);
+  const [showWords, setShowWords] = useState(false);
   const [boardRef, { height: boardHeight }] = useMeasure<HTMLDivElement>();
   const [contentRef, { height: contentHeight, width: contentWidth }] = useMeasure<HTMLDivElement>();
   const [resultsContainerRef, { height: resultsContainerHeight, width: resultsContainerWidth }] =
@@ -85,6 +87,7 @@ const Index: FunctionComponent<Props> = ({ version }) => {
             onShowKeyMap={() => setShowKeyMap(true)}
             onShowRemainingTiles={() => setShowRemainingTiles(true)}
             onShowSettings={() => setShowSettings(true)}
+            onShowWords={() => setShowWords(true)}
           />
         </div>
 
@@ -122,6 +125,8 @@ const Index: FunctionComponent<Props> = ({ version }) => {
 
       <KeyMap isOpen={showKeyMap} onClose={() => setShowKeyMap(false)} />
 
+      <Words isOpen={showWords} onClose={() => setShowWords(false)} />
+
       <RemainingTiles isOpen={showRemainingTiles} onClose={() => setShowRemainingTiles(false)} />
 
       <Splash forceShow={!isInitialized} onAnimationEnd={handleSplashAnimationEnd} />

package/src/sdk/fetchJson.ts

@@ -0,0 +1,36 @@
+import { isError } from '@scrabble-solver/types';
+
+const fetchJson = async <T>(input: RequestInfo | URL, init?: RequestInit): Promise<T> => {
+  let response: Response;
+
+  try {
+    response = await fetch(input, {
+      ...init,
+      headers: {
+        'Content-Type': 'application/json',
+        ...init?.headers,
+      },
+    });
+  } catch (error) {
+    const message = isError(error) ? error.message : 'Unknown error';
+    throw new Error(`Network error: ${message}`);
+  }
+
+  if (response.ok) {
+    return response.json();
+  }
+
+  try {
+    const json = await response.json();
+
+    if (isError(json)) {
+      throw new Error(json.message);
+    }
+  } finally {
+    // do nothing
+  }
+
+  throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+};
+
+export default fetchJson;

package/src/sdk/findWordDefinitions.ts

@@ -1,8 +1,9 @@
-import { Locale, WordDefinition } from '@scrabble-solver/types';
+import { Locale, WordDefinition, WordDefinitionJson } from '@scrabble-solver/types';
+
+import fetchJson from './fetchJson';
 
 const findWordDefinitions = async (locale: Locale, word: string): Promise<WordDefinition[]> => {
-  const url = `/api/dictionary/${locale}/${word}`;
-  const json = await fetch(url).then((response) => response.json());
+  const json = await fetchJson<WordDefinitionJson[]>(`/api/dictionary/${locale}/${word}`);
   return json.map(WordDefinition.fromJson);
 };
 

package/src/sdk/index.ts

@@ -1,3 +1,4 @@
 export { default as findWordDefinitions } from './findWordDefinitions';
 export { default as solve } from './solve';
+export { default as verify } from './verify';
 export { default as visit } from './visit';

package/src/sdk/solve.ts

@@ -1,4 +1,6 @@
-import { BoardJson, Locale, ResultJson } from '@scrabble-solver/types';
+import { BoardJson, Locale, Result, ResultJson } from '@scrabble-solver/types';
+
+import fetchJson from './fetchJson';
 
 interface Payload {
   board: BoardJson;
@@ -7,14 +9,13 @@ interface Payload {
   locale: Locale;
 }
 
-const solve = ({ board, characters, configId, locale }: Payload): Promise<ResultJson[]> => {
-  return fetch('/api/solve', {
+const solve = async ({ board, characters, configId, locale }: Payload): Promise<Result[]> => {
+  const json = await fetchJson<ResultJson[]>('/api/solve', {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
     body: JSON.stringify({ board, characters, configId, locale }),
-  }).then((response) => response.json());
+  });
+
+  return json.map(Result.fromJson);
 };
 
 export default solve;

package/src/sdk/verify.ts

@@ -0,0 +1,23 @@
+import { BoardJson, Locale } from '@scrabble-solver/types';
+
+import fetchJson from './fetchJson';
+
+interface Payload {
+  board: BoardJson;
+  configId: string;
+  locale: Locale;
+}
+
+interface Response {
+  invalidWords: string[];
+  validWords: string[];
+}
+
+const verify = async ({ board, configId, locale }: Payload): Promise<Response> => {
+  return fetchJson<Response>('/api/verify', {
+    method: 'POST',
+    body: JSON.stringify({ board, configId, locale }),
+  });
+};
+
+export default verify;

package/src/state/rootReducer.ts

@@ -8,6 +8,7 @@ import {
   resultsSlice,
   settingsSlice,
   solveSlice,
+  verifySlice,
 } from './slices';
 
 const rootReducer = combineReducers({
@@ -18,6 +19,7 @@ const rootReducer = combineReducers({
   results: resultsSlice.reducer,
   settings: settingsSlice.reducer,
   solve: solveSlice.reducer,
+  verify: verifySlice.reducer,
 });
 
 export default rootReducer;

package/src/state/sagas.ts

@@ -3,7 +3,7 @@ import { Result } from '@scrabble-solver/types';
 import { call, delay, put, select, takeEvery, takeLatest } from 'redux-saga/effects';
 
 import { memoize } from 'lib';
-import { findWordDefinitions, solve, visit } from 'sdk';
+import { findWordDefinitions, solve, verify, visit } from 'sdk';
 
 import { initialize, reset } from './actions';
 import {
@@ -23,6 +23,7 @@ import {
   resultsSlice,
   settingsSlice,
   solveSlice,
+  verifySlice,
 } from './slices';
 
 const SUBMIT_DELAY = 150;
@@ -43,7 +44,8 @@ export function* rootSaga(): AnyGenerator {
   yield takeLatest(dictionarySlice.actions.submit.type, onDictionarySubmit);
   yield takeLatest(initialize.type, onInitialize);
   yield takeLatest(reset.type, onReset);
-  yield takeLatest(solveSlice.actions.submit.type, onSubmit);
+  yield takeLatest(solveSlice.actions.submit.type, onSolve);
+  yield takeLatest(verifySlice.actions.submit.type, onVerify);
 }
 
 function* onCellValueChange({ payload }: PayloadAction<{ value: string; x: number; y: number }>): AnyGenerator {
@@ -52,6 +54,8 @@ function* onCellValueChange({ payload }: PayloadAction<{ value: string; x: numbe
   if (isFiltered) {
     yield put(cellFilterSlice.actions.toggle(payload));
   }
+
+  yield put(verifySlice.actions.submit());
 }
 
 function* onApplyResult({ payload: result }: PayloadAction<Result>): AnyGenerator {
@@ -60,11 +64,13 @@ function* onApplyResult({ payload: result }: PayloadAction<Result>): AnyGenerato
   yield put(cellFilterSlice.actions.reset());
   yield put(rackSlice.actions.removeTiles(result.tiles));
   yield put(rackSlice.actions.groupTiles(autoGroupTiles));
+  yield put(verifySlice.actions.submit());
 }
 
 function* onConfigIdChange(): AnyGenerator {
   yield put(resultsSlice.actions.reset());
   yield put(solveSlice.actions.submit());
+  yield put(verifySlice.actions.submit());
   yield* ensureProperTilesCount();
 }
 
@@ -80,7 +86,7 @@ function* onDictionarySubmit(): AnyGenerator {
     const wordDefinitions = yield call(memoizedFindWordDefinitions, locale, word);
     yield put(dictionarySlice.actions.submitSuccess(wordDefinitions));
   } catch (error) {
-    yield put(dictionarySlice.actions.submitFailure());
+    yield put(dictionarySlice.actions.submitFailure(error));
   }
 }
 
@@ -95,12 +101,14 @@ function* onReset(): AnyGenerator {
   yield put(dictionarySlice.actions.reset());
   yield put(rackSlice.actions.reset());
   yield put(resultsSlice.actions.reset());
+  yield put(verifySlice.actions.submit());
 }
 
 function* onLocaleChange(): AnyGenerator {
-  yield put(solveSlice.actions.submit());
-  yield put(resultsSlice.actions.changeResultCandidate(null));
   yield put(dictionarySlice.actions.reset());
+  yield put(resultsSlice.actions.changeResultCandidate(null));
+  yield put(solveSlice.actions.submit());
+  yield put(verifySlice.actions.submit());
 }
 
 function* onResultCandidateChange({ payload: result }: PayloadAction<Result | null>): AnyGenerator {
@@ -110,7 +118,7 @@ function* onResultCandidateChange({ payload: result }: PayloadAction<Result | nu
   }
 }
 
-function* onSubmit(): AnyGenerator {
+function* onSolve(): AnyGenerator {
   const board = yield select(selectBoard);
   const { config } = yield select(selectConfig);
   const locale = yield select(selectLocale);
@@ -129,11 +137,30 @@ function* onSubmit(): AnyGenerator {
       configId: config.id,
       locale,
     });
+    yield put(resultsSlice.actions.changeResults(results));
     yield put(solveSlice.actions.submitSuccess({ board, characters }));
-    yield put(resultsSlice.actions.changeResults(results.map(Result.fromJson)));
   } catch (error) {
     yield put(resultsSlice.actions.changeResults([]));
-    yield put(solveSlice.actions.submitFailure());
+    yield put(solveSlice.actions.submitFailure(error));
+  }
+}
+
+function* onVerify(): AnyGenerator {
+  yield delay(SUBMIT_DELAY);
+
+  const board = yield select(selectBoard);
+  const { config } = yield select(selectConfig);
+  const locale = yield select(selectLocale);
+
+  try {
+    const { invalidWords, validWords } = yield call(verify, {
+      board: board.toJson(),
+      configId: config.id,
+      locale,
+    });
+    yield put(verifySlice.actions.submitSuccess({ board, invalidWords, validWords }));
+  } catch (error) {
+    yield put(verifySlice.actions.submitFailure());
   }
 }
 

package/src/state/selectors.ts

@@ -1,6 +1,6 @@
 import { createSelector } from '@reduxjs/toolkit';
 import { getLocaleConfig } from '@scrabble-solver/configs';
-import { Cell, Config, Result, Tile } from '@scrabble-solver/types';
+import { Cell, Config, isError, Result, Tile } from '@scrabble-solver/types';
 
 import i18n from 'i18n';
 import { findCell, getRemainingTiles, getRemainingTilesGroups, sortResults, unorderedArraysEqual } from 'lib';
@@ -30,8 +30,14 @@ const selectSettingsRoot = (state: RootState): RootState['settings'] => state.se
 
 const selectSolveRoot = (state: RootState): RootState['solve'] => state.solve;
 
+const selectVerifyRoot = (state: RootState): RootState['verify'] => state.verify;
+
 export const selectDictionary = selectDictionaryRoot;
 
+export const selectDictionaryError = createSelector([selectDictionaryRoot], (dictionary) => {
+  return isError(dictionary.error) ? dictionary.error : undefined;
+});
+
 export const selectAutoGroupTiles = createSelector([selectSettingsRoot], (settings) => settings.autoGroupTiles);
 
 export const selectLocale = createSelector([selectSettingsRoot], (settings) => settings.locale);
@@ -156,6 +162,10 @@ export const selectLastSolvedParameters = createSelector([selectSolveRoot], (sol
 
 export const selectIsLoading = createSelector([selectSolveRoot], (solve) => solve.isLoading);
 
+export const selectSolveError = createSelector([selectSolveRoot], (solve) => {
+  return isError(solve.error) ? solve.error : undefined;
+});
+
 export const selectHaveCharactersChanged = createSelector(
   [selectLastSolvedParameters, selectCharacters],
   (lastSolvedParameters, characters) => {
@@ -183,3 +193,9 @@ export const selectHasOverusedTiles = createSelector([selectRemainingTiles], (re
 });
 
 export const selectRemainingTilesGroups = createSelector([selectRemainingTiles], getRemainingTilesGroups);
+
+export const selectVerify = selectVerifyRoot;
+
+export const selectHasInvalidWords = createSelector([selectVerify], ({ invalidWords }) => {
+  return invalidWords.length > 0;
+});

package/src/state/slices/dictionaryInitialState.ts

@@ -1,9 +1,17 @@
 import { WordDefinition } from '@scrabble-solver/types';
 
-const dictionaryInitialState = {
+interface DictionaryInitialState {
+  error: unknown | undefined;
+  input: string;
+  isLoading: boolean;
+  results: WordDefinition[];
+}
+
+const dictionaryInitialState: DictionaryInitialState = {
+  error: undefined,
   input: '',
   isLoading: false,
-  results: [] as WordDefinition[],
+  results: [],
 };
 
 export default dictionaryInitialState;