scrabble-solver 2.18.10-alpha.1 → 2.18.10-alpha.2

package/packages/scrabble-solver/src/state/results/lib.ts

@@ -0,0 +1,86 @@
+import { type Result, type ShowCoordinates } from '@scrabble-solver/types';
+
+import { createCoordinatesComparator } from '@/lib/createCoordinatesComparator';
+import { createKeyComparator } from '@/lib/createKeyComparator';
+import { createRegExp } from '@/lib/createRegExp';
+import { createSortComparator } from '@/lib/createSortComparator';
+import { getCoordinates as getPointCoordinates } from '@/lib/getCoordinates';
+import { type CellFilter, type ComparatorFactory, type GroupedResults, type Sort, ResultColumnId } from '@/types';
+
+export const getCoordinates = (result: Result, showCoordinates: ShowCoordinates): string => {
+  const firstCell = result.cells[0];
+  return getPointCoordinates({ isHorizontal: result.isHorizontal(), x: firstCell.x, y: firstCell.y }, showCoordinates);
+};
+
+export const groupResults = (
+  results: Result[] | undefined,
+  query: string,
+  cellFilters: CellFilter[],
+): GroupedResults | undefined => {
+  if (typeof results === 'undefined') {
+    return undefined;
+  }
+
+  const regExp = createRegExp(query);
+
+  const { matching, other } = results.reduce<GroupedResults>(
+    (groupedResults, result) => {
+      const matchesQuery = () => Boolean(result.word.match(regExp));
+
+      if (resultMatchesCellFilter(result, cellFilters) && matchesQuery()) {
+        groupedResults.matching.push(result);
+      } else {
+        groupedResults.other.push(result);
+      }
+
+      return groupedResults;
+    },
+    { matching: [], other: [] },
+  );
+
+  return { matching, other };
+};
+
+export const resultMatchesCellFilter = (result: Result, cellFilters: CellFilter[]): boolean => {
+  const excludeFilters = cellFilters.filter((filter) => filter.type === 'exclude');
+  const matchesExcludeFilters = excludeFilters.every(({ x, y }) => {
+    return result.cells.every((cell) => cell.x !== x || cell.y !== y);
+  });
+
+  if (!matchesExcludeFilters) {
+    return false;
+  }
+
+  const includeFilter = cellFilters.filter((filter) => filter.type === 'include');
+  const matchesIncludeFilters = includeFilter.every(({ x, y }) => {
+    return result.cells.some((cell) => cell.x === x && cell.y === y);
+  });
+
+  return matchesExcludeFilters && matchesIncludeFilters;
+};
+
+const comparators: Record<ResultColumnId, ComparatorFactory<Result>> = {
+  [ResultColumnId.BlanksCount]: (locale: string) => createKeyComparator('blanksCount', locale),
+  [ResultColumnId.ConsonantsCount]: (locale: string) => createKeyComparator('consonantsCount', locale),
+  [ResultColumnId.Coordinates]: (locale: string, showCoordinates: ShowCoordinates) => {
+    return createCoordinatesComparator({ getItemCoordinates: getCoordinates, locale, showCoordinates });
+  },
+  [ResultColumnId.Points]: (locale: string) => createKeyComparator('points', locale),
+  [ResultColumnId.TilesCount]: (locale: string) => createKeyComparator('tilesCount', locale),
+  [ResultColumnId.VowelsCount]: (locale: string) => createKeyComparator('vowelsCount', locale),
+  [ResultColumnId.Word]: (locale: string) => createKeyComparator('word', locale),
+  [ResultColumnId.WordsCount]: (locale: string) => createKeyComparator('wordsCount', locale),
+};
+
+export const sortResults = (
+  results: Result[] | undefined,
+  sort: Sort,
+  locale: string,
+  showCoordinates: ShowCoordinates,
+): Result[] | undefined => {
+  if (typeof results === 'undefined') {
+    return undefined;
+  }
+
+  return [...results].sort(createSortComparator({ comparators, locale, showCoordinates, sort }));
+};

package/packages/scrabble-solver/src/state/results/selectors.ts

@@ -0,0 +1,83 @@
+import { createSelector } from '@reduxjs/toolkit';
+
+import { createRegExp } from '@/lib/createRegExp';
+
+import { selectCellFilters } from '../cellFilters';
+import { selectLocale, selectShowCoordinates } from '../settings';
+import type { RootState } from '../types';
+
+import { getCoordinates, groupResults, resultMatchesCellFilter, sortResults } from './lib';
+
+const selectResultIndex = (_: unknown, index: number): number => index;
+
+export const selectResults = (state: RootState) => state.results;
+
+export const selectResultCandidate = createSelector([selectResults], (results) => results.candidate);
+
+export const selectResultsQuery = createSelector([selectResults], (results) => results.query);
+
+export const selectResultsResults = createSelector([selectResults], (results) => results.results);
+
+export const selectResultsSort = createSelector([selectResults], (results) => results.sort);
+
+export const selectResultCandidateCells = createSelector(
+  [selectResultCandidate],
+  (resultCandidate) => resultCandidate?.cells ?? [],
+);
+
+export const selectResultCandidateTiles = createSelector(
+  [selectResultCandidate],
+  (resultCandidate) => resultCandidate?.tiles ?? [],
+);
+
+const selectSortedResults = createSelector(
+  [selectResultsResults, selectResultsSort, selectLocale, selectShowCoordinates],
+  sortResults,
+);
+
+const selectGroupedSortedResults = createSelector(
+  [selectSortedResults, selectResultsQuery, selectCellFilters],
+  groupResults,
+);
+
+export const selectProcessedResults = createSelector([selectGroupedSortedResults], (results) => {
+  return results ? [...results.matching, ...results.other] : undefined;
+});
+
+export const selectResultCandidateIndex = createSelector(
+  [selectProcessedResults, selectResultCandidate],
+  (results, candidate) => {
+    const index = results && candidate ? results.findIndex((result) => result.id === candidate.id) : -1;
+    return index === -1 ? undefined : index;
+  },
+);
+
+export const selectIsResultMatching = createSelector(
+  [selectProcessedResults, selectResultsQuery, selectCellFilters, selectResultIndex],
+  (results, query, cellFilters, index) => {
+    if (!results) {
+      return false;
+    }
+
+    const result = results[index];
+    const regExp = createRegExp(query);
+
+    if (!regExp.test(result.word)) {
+      return false;
+    }
+
+    return resultMatchesCellFilter(result, cellFilters);
+  },
+);
+
+export const selectResultCoordinates = createSelector(
+  [selectProcessedResults, selectShowCoordinates, selectResultIndex],
+  (results, showCoordinates, index) => {
+    if (!results) {
+      return '';
+    }
+
+    const result = results[index];
+    return getCoordinates(result, showCoordinates);
+  },
+);

package/packages/scrabble-solver/src/state/results/slice.ts

@@ -0,0 +1,43 @@
+import { type PayloadAction, createSlice } from '@reduxjs/toolkit';
+import { type Result } from '@scrabble-solver/types';
+
+import { getNextSort } from '@/lib/getNextSort';
+import { type ResultColumnId } from '@/types';
+
+import { resultsInitialState } from './initialState';
+
+export const resultsSlice = createSlice({
+  initialState: resultsInitialState,
+  name: 'results',
+  reducers: {
+    applyResult: (_state, _action: PayloadAction<Result>) => {
+      return resultsInitialState;
+    },
+
+    changeQuery: (state, action: PayloadAction<string>) => {
+      const newQuery = action.payload;
+      return { ...state, query: newQuery };
+    },
+
+    changeResultCandidate: (state, action: PayloadAction<Result | null>) => {
+      const candidate = action.payload;
+      return candidate === state.candidate ? state : { ...state, candidate };
+    },
+
+    changeResults: (state, action: PayloadAction<Result[]>) => {
+      const newResults = action.payload;
+      return {
+        ...state,
+        candidate: resultsInitialState.candidate,
+        query: resultsInitialState.query,
+        results: newResults,
+      };
+    },
+
+    sort: (state, action: PayloadAction<ResultColumnId>) => {
+      return { ...state, sort: getNextSort(state.sort, action.payload) };
+    },
+
+    reset: () => resultsInitialState,
+  },
+});

package/packages/scrabble-solver/src/state/results/types.ts

@@ -0,0 +1,10 @@
+import { type Result } from '@scrabble-solver/types';
+
+import type { Sort } from '@/types';
+
+export interface ResultsState {
+  candidate: Result | null;
+  query: string;
+  results: Result[] | undefined;
+  sort: Sort;
+}

package/packages/scrabble-solver/src/state/sagas.ts

@@ -0,0 +1,395 @@
+/* eslint-disable max-lines */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
+import { type PayloadAction } from '@reduxjs/toolkit';
+import { hasConfig, languages } from '@scrabble-solver/configs';
+import { type Result, Board, Locale } from '@scrabble-solver/types';
+import { call, delay, put, select, spawn, takeEvery, takeLatest } from 'redux-saga/effects';
+
+import { LOCALE_FEATURES } from '@/i18n/constants';
+import { loadTranslations } from '@/i18n/i18n';
+import { memoize } from '@/lib/memoize';
+import { waitForFirstIntent, waitForIdleOrFirstIntent } from '@/lib/waitForIdleOrFirstIntent';
+import { findWordDefinitions, solve, verify, visit } from '@/sdk';
+import { prefetchDictionary } from '@/solver-worker';
+import { type VerifiedWord } from '@/types';
+
+import { initialize, reset } from './actions';
+import { appSlice, selectVersion } from './app';
+import { boardSlice, selectBoard } from './board';
+import { cellFiltersSlice, selectCellFilter } from './cellFilters';
+import { dictionarySlice, selectDictionary } from './dictionary';
+import { hoveredWordSlice } from './hoveredWord';
+import { i18nSlice, selectLoadedTranslations } from './i18n';
+import { localStorage } from './localStorage';
+import { rackSlice, selectCharacters, selectRack } from './rack';
+import { resultsSlice } from './results';
+import {
+  type SettingsState,
+  selectConfig,
+  selectGame,
+  selectLocale,
+  selectLocaleAutoGroupTiles,
+  selectRemoveCellFilters,
+  settingsInitialState,
+  settingsSlice,
+} from './settings';
+import { guessLocale } from './settings/lib';
+import { solveSlice } from './solve';
+import { verifySlice } from './verify';
+
+const SUBMIT_DELAY = 150;
+
+const memoizedFindWordDefinitions = memoize(findWordDefinitions);
+
+// Can't conveniently type generators for sagas yet,
+// see: https://github.com/microsoft/TypeScript/issues/43632
+type AnyGenerator = Generator<any, any, any>;
+
+export function* rootSaga(): AnyGenerator {
+  yield takeEvery(boardSlice.actions.changeCellValue.type, onCellValueChange);
+  yield takeEvery([rackSlice.actions.changeCharacter.type, rackSlice.actions.changeCharacters.type], onRackValueChange);
+  yield takeEvery(resultsSlice.actions.applyResult.type, onApplyResult);
+  yield takeLatest(resultsSlice.actions.changeResultCandidate.type, onResultCandidateChange);
+  yield takeLatest([hoveredWordSlice.actions.set.type, hoveredWordSlice.actions.clear.type], onHoveredWordChange);
+  yield takeEvery(settingsSlice.actions.changeGame.type, onGameChange);
+  yield takeEvery(settingsSlice.actions.changeLocale.type, onLocaleChange);
+  yield takeLatest(dictionarySlice.actions.submit.type, onDictionarySubmit);
+  yield takeLatest(initialize.type, onInitialize);
+  yield takeLatest(reset.type, onReset);
+  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 {
+  const filter = yield select((state) => selectCellFilter(state, payload));
+
+  if (filter) {
+    yield put(cellFiltersSlice.actions.cancel(payload));
+  }
+
+  yield put(resultsSlice.actions.changeResultCandidate(null));
+  yield put(hoveredWordSlice.actions.clear());
+  yield put(verifySlice.actions.submit());
+}
+
+function* onRackValueChange(): AnyGenerator {
+  yield put(resultsSlice.actions.changeResultCandidate(null));
+}
+
+function* onApplyResult({ payload: result }: PayloadAction<Result>): AnyGenerator {
+  const autoGroupTiles = yield select(selectLocaleAutoGroupTiles);
+  const removeCellFilters = yield select(selectRemoveCellFilters);
+  yield put(boardSlice.actions.applyResult(result));
+  if (removeCellFilters === 'never') {
+    yield put(cellFiltersSlice.actions.removeCells(result.cells));
+  } else {
+    yield put(cellFiltersSlice.actions.reset());
+  }
+  yield put(rackSlice.actions.removeTiles(result.tiles));
+  yield put(rackSlice.actions.groupTiles(autoGroupTiles));
+  yield put(verifySlice.actions.submit());
+}
+
+function* onGameChange(): AnyGenerator {
+  const characters = yield select(selectCharacters);
+
+  if (characters.length > 0) {
+    yield put(solveSlice.actions.submit());
+  } else {
+    yield put(resultsSlice.actions.reset());
+  }
+
+  yield put(resultsSlice.actions.reset());
+  yield put(hoveredWordSlice.actions.clear());
+  yield* resetRack();
+  yield put(verifySlice.actions.submit());
+}
+
+function* onDictionarySubmit(): AnyGenerator {
+  const { input: word } = yield select(selectDictionary);
+  const locale = yield select(selectLocale);
+
+  if (!memoizedFindWordDefinitions.hasCache(locale, word)) {
+    yield delay(SUBMIT_DELAY);
+  }
+
+  try {
+    const wordDefinitions = yield call(memoizedFindWordDefinitions, locale, word);
+    const { input: currentWord } = yield select(selectDictionary);
+
+    if (word === currentWord) {
+      yield put(dictionarySlice.actions.submitSuccess(wordDefinitions));
+    }
+  } catch (error) {
+    const { input: currentWord } = yield select(selectDictionary);
+
+    if (word === currentWord) {
+      yield put(dictionarySlice.actions.submitFailure(error));
+    }
+  }
+}
+
+function* onInitialize({ payload }: PayloadAction<{ version: string }>): AnyGenerator {
+  try {
+    yield* hydratePersistedState(payload.version);
+    // oxlint-disable-next-line no-empty
+  } catch {
+  } finally {
+    yield put(appSlice.actions.hydrated());
+  }
+
+  const board = yield select(selectBoard);
+  const locale = yield select(selectLocale);
+
+  yield spawn(prefetchDictionaryOnFirstIntent);
+  yield spawn(loadLocaleTranslations, locale);
+  yield spawn(preloadTranslationsWhenIdle);
+  yield spawn(visitWhenIdle);
+
+  if (!board.isEmpty()) {
+    yield* resetRack();
+    yield put(verifySlice.actions.submit());
+  }
+}
+
+function* hydratePersistedState(version: string): AnyGenerator {
+  const isTouchScreen = globalThis.matchMedia?.('(hover: none)').matches ?? false;
+  const settings: Pick<SettingsState, 'game' | 'inputMode' | 'locale'> & Partial<SettingsState> = {
+    game: settingsInitialState.game,
+    inputMode: isTouchScreen ? ('touchscreen' as const) : ('keyboard' as const),
+    locale: guessLocale(),
+    ...localStorage.getSettings(),
+  };
+
+  if (!hasConfig(settings.game, settings.locale)) {
+    const localeDefault = Object.values(languages).find((config) => config.locale === settings.locale);
+    settings.game = localeDefault?.game ?? settingsInitialState.game;
+    settings.locale = localeDefault?.locale ?? guessLocale();
+  }
+
+  yield put(settingsSlice.actions.init(settings));
+  yield* hydratePersistedTranslations(settings.locale, version);
+
+  const config = yield select(selectConfig);
+  const currentBoard: Board = yield select(selectBoard);
+  const board = localStorage.getBoard();
+
+  if (board) {
+    yield put(boardSlice.actions.init(board));
+  } else if (currentBoard.rows.length !== config.boardHeight || currentBoard.rows[0].length !== config.boardWidth) {
+    yield put(boardSlice.actions.init(Board.create(config.boardWidth, config.boardHeight)));
+  }
+
+  const currentRack = yield select(selectRack);
+  const rack = localStorage.getRack();
+
+  if (rack) {
+    yield put(rackSlice.actions.init(rack));
+  } else if (currentRack.length !== config.rackSize) {
+    yield put(rackSlice.actions.init(Array(config.rackSize).fill(null)));
+  }
+}
+
+// Applied synchronously so the first post-hydration paint is already translated
+function* hydratePersistedTranslations(locale: Locale, version: string): AnyGenerator {
+  const translations = localStorage.getTranslations(locale, version);
+
+  if (translations) {
+    yield put(i18nSlice.actions.loaded({ locale, translations }));
+  }
+}
+
+function* visitWhenIdle(): AnyGenerator {
+  yield call(waitForIdleOrFirstIntent);
+  const locale = yield select(selectLocale);
+  const game = yield select(selectGame);
+
+  try {
+    yield call(visit, { game, locale, referrer: document.referrer, url: location.href });
+    // oxlint-disable-next-line no-empty
+  } catch {}
+}
+
+function* prefetchDictionaryOnFirstIntent(): AnyGenerator {
+  yield call(waitForFirstIntent);
+  const locale = yield select(selectLocale);
+  yield call(prefetchDictionary, locale);
+}
+
+function* loadLocaleTranslations(locale: Locale): AnyGenerator {
+  const loaded = yield select(selectLoadedTranslations);
+
+  if (loaded[locale]) {
+    return;
+  }
+
+  const translations = yield call(loadTranslations, locale);
+  yield put(i18nSlice.actions.loaded({ locale, translations }));
+
+  const activeLocale = yield select(selectLocale);
+
+  if (locale === activeLocale) {
+    const version = yield select(selectVersion);
+    localStorage.setTranslations(locale, version, translations);
+  }
+}
+
+// The cache makes the next boot's first paint translated without waiting for a chunk download
+function* persistTranslationsCache(locale: Locale): AnyGenerator {
+  const loaded = yield select(selectLoadedTranslations);
+  const version = yield select(selectVersion);
+
+  if (loaded[locale]) {
+    localStorage.setTranslations(locale, version, loaded[locale]);
+  }
+}
+
+function* preloadTranslationsWhenIdle(): AnyGenerator {
+  yield call(waitForIdleOrFirstIntent);
+
+  for (const locale of Object.values(Locale)) {
+    yield spawn(loadLocaleTranslations, locale);
+  }
+}
+
+function* onReset(): AnyGenerator {
+  const config = yield select(selectConfig);
+
+  yield put(boardSlice.actions.init(Board.create(config.boardWidth, config.boardHeight)));
+  yield put(cellFiltersSlice.actions.reset());
+  yield put(dictionarySlice.actions.reset());
+  yield put(hoveredWordSlice.actions.clear());
+  yield put(rackSlice.actions.reset());
+  yield put(resultsSlice.actions.reset());
+  yield put(solveSlice.actions.reset());
+  yield put(verifySlice.actions.submit());
+}
+
+function* onLocaleChange({ payload: locale }: PayloadAction<Locale>): AnyGenerator {
+  yield spawn(loadLocaleTranslations, locale);
+  yield spawn(prefetchDictionary, locale);
+  yield* persistTranslationsCache(locale);
+
+  const game = yield select(selectGame);
+
+  if (!hasConfig(game, locale)) {
+    const defaultConfig = Object.values(languages).find((config) => config.locale === locale);
+
+    if (defaultConfig) {
+      yield put(settingsSlice.actions.changeGame(defaultConfig.game));
+    }
+  }
+
+  const characters = yield select(selectCharacters);
+
+  if (characters.length > 0) {
+    yield put(solveSlice.actions.submit());
+  } else {
+    yield put(resultsSlice.actions.reset());
+  }
+
+  yield put(dictionarySlice.actions.reset());
+  yield put(hoveredWordSlice.actions.clear());
+  yield put(resultsSlice.actions.changeResultCandidate(null));
+  yield put(verifySlice.actions.submit());
+}
+
+function* onResultCandidateChange({ payload: result }: PayloadAction<Result | null>): AnyGenerator {
+  if (!result) {
+    return;
+  }
+
+  yield put(hoveredWordSlice.actions.clear());
+  yield* searchDictionary(result.words);
+}
+
+function* onHoveredWordChange({ payload: word }: PayloadAction<VerifiedWord | undefined>): AnyGenerator {
+  if (!word) {
+    return;
+  }
+
+  yield put(resultsSlice.actions.changeResultCandidate(null));
+
+  const board: Board = yield select(selectBoard);
+  const collidingWords = board.getCollidingWords(word);
+
+  yield* searchDictionary([word.word, ...collidingWords.map((collidingWord) => collidingWord.word)]);
+}
+
+function* searchDictionary(words: string[]): AnyGenerator {
+  const locale: Locale = yield select(selectLocale);
+  const uniqueWords = Array.from(new Set(words));
+  const input = uniqueWords.join(LOCALE_FEATURES[locale].separator);
+
+  if (!memoizedFindWordDefinitions.hasCache(locale, input)) {
+    yield delay(SUBMIT_DELAY);
+  }
+
+  yield put(dictionarySlice.actions.changeInput(input));
+  yield put(dictionarySlice.actions.submit());
+}
+
+function* onSolve(): AnyGenerator {
+  const board = yield select(selectBoard);
+  const { config } = yield select(selectConfig);
+  const locale = yield select(selectLocale);
+  const characters = yield select(selectCharacters);
+
+  if (characters.length === 0) {
+    yield put(solveSlice.actions.submitSuccess({ board, characters }));
+    yield put(resultsSlice.actions.changeResults([]));
+    return;
+  }
+
+  try {
+    const results = yield call(solve, {
+      board: board.toJson(),
+      characters,
+      game: config.game,
+      locale,
+    });
+    yield put(resultsSlice.actions.changeResults(results));
+    yield put(solveSlice.actions.submitSuccess({ board, characters }));
+  } catch (error) {
+    yield put(resultsSlice.actions.changeResults([]));
+    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(),
+      game: config.game,
+      locale,
+    });
+    yield put(verifySlice.actions.submitSuccess({ board, invalidWords, validWords }));
+  } catch (_error) {
+    yield put(verifySlice.actions.submitFailure());
+  }
+}
+
+function* resetRack(): AnyGenerator {
+  const { config } = yield select(selectConfig);
+  const rack = yield select(selectRack);
+
+  if (config.rackSize > rack.length) {
+    const differenceCount = Math.abs(config.rackSize - rack.length);
+    yield put(rackSlice.actions.init([...rack, ...Array(differenceCount).fill(null)]));
+  } else if (config.rackSize < rack.length) {
+    const nonNulls = rack.filter(Boolean).slice(0, config.rackSize);
+    const differenceCount = Math.abs(config.rackSize - nonNulls.length);
+    const autoGroupTiles = yield select(selectLocaleAutoGroupTiles);
+    yield put(rackSlice.actions.init([...nonNulls, ...Array(differenceCount).fill(null)]));
+    yield put(rackSlice.actions.groupTiles(autoGroupTiles));
+  }
+}

package/packages/scrabble-solver/src/state/selectors.ts

@@ -0,0 +1,52 @@
+import { createSelector } from '@reduxjs/toolkit';
+
+import { unorderedArraysEqual } from '@/lib/unorderedArraysEqual';
+
+import { selectBoard } from './board';
+import { selectHoveredWord } from './hoveredWord';
+import { getRemainingTiles } from './lib';
+import { selectCharacters } from './rack';
+import { selectResultsResults } from './results';
+import { selectConfig, selectLocale } from './settings';
+import { selectLastSolvedParameters, selectSolveError } from './solve';
+import { selectLastVerifiedBoard } from './verify';
+
+const selectHasBoardChanged = createSelector(
+  [selectLastSolvedParameters, selectBoard],
+  (lastSolvedParameters, board) => {
+    return !lastSolvedParameters.board.equals(board);
+  },
+);
+
+const selectHaveCharactersChanged = createSelector(
+  [selectLastSolvedParameters, selectCharacters, selectLocale],
+  (lastSolvedParameters, characters, locale) => {
+    return !unorderedArraysEqual(lastSolvedParameters.characters, characters, locale);
+  },
+);
+
+export const selectAreResultsOutdated = createSelector(
+  [selectHasBoardChanged, selectHaveCharactersChanged],
+  (hasBoardChanged, haveCharactersChanged) => {
+    return hasBoardChanged || haveCharactersChanged;
+  },
+);
+
+export const selectUpToDateResults = createSelector(
+  [selectResultsResults, selectAreResultsOutdated, selectSolveError],
+  (results, areResultsOutdated, solveError) => {
+    return results && !areResultsOutdated && !solveError ? results : null;
+  },
+);
+
+export const selectUpToDateHoveredWord = createSelector(
+  [selectHoveredWord, selectLastVerifiedBoard, selectBoard],
+  (hoveredWord, lastVerifiedBoard, board) => {
+    return hoveredWord && lastVerifiedBoard.equals(board) ? hoveredWord : null;
+  },
+);
+
+export const selectRemainingTiles = createSelector(
+  [selectConfig, selectBoard, selectCharacters, selectLocale],
+  getRemainingTiles,
+);

package/packages/scrabble-solver/src/state/settings/index.ts

@@ -0,0 +1,4 @@
+export * from './initialState';
+export * from './selectors';
+export * from './slice';
+export * from './types';

package/packages/scrabble-solver/src/state/settings/initialState.ts

@@ -0,0 +1,16 @@
+import { Game, Locale } from '@scrabble-solver/types';
+
+import type { SettingsState } from './types';
+
+/**
+ * Deterministic defaults shared by the server render and the client's hydration render.
+ */
+export const settingsInitialState: SettingsState = {
+  autoGroupTiles: null,
+  game: Game.Scrabble,
+  highlightUnreachableCells: false,
+  inputMode: 'keyboard',
+  locale: Locale.EN_US,
+  removeCellFilters: 'always',
+  showCoordinates: 'original',
+};