scrabble-solver 2.18.9 → 2.18.10-alpha.0

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

@@ -1,86 +0,0 @@
-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, ResultColumnId, type Sort } 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

@@ -1,83 +0,0 @@
-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

@@ -1,43 +0,0 @@
-import { createSlice, type PayloadAction } 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

@@ -1,10 +0,0 @@
-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

@@ -1,395 +0,0 @@
-/* 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 { Board, Locale, type Result } 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 {
-  selectConfig,
-  selectGame,
-  selectLocale,
-  selectLocaleAutoGroupTiles,
-  selectRemoveCellFilters,
-  settingsInitialState,
-  settingsSlice,
-  type SettingsState,
-} 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

@@ -1,52 +0,0 @@
-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

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

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

@@ -1,16 +0,0 @@
-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',
-};