@scrabble-solver/scrabble-solver 2.15.10 → 2.15.12

package/src/state/sagas.ts

@@ -3,9 +3,9 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 
-import { PayloadAction } from '@reduxjs/toolkit';
+import { type PayloadAction } from '@reduxjs/toolkit';
 import { hasConfig, languages } from '@scrabble-solver/configs';
-import { Board, Locale, Result } from '@scrabble-solver/types';
+import { Board, type Locale, type Result } from '@scrabble-solver/types';
 import { call, delay, put, select, takeEvery, takeLatest } from 'redux-saga/effects';
 
 import { LOCALE_FEATURES } from 'i18n';
@@ -13,27 +13,21 @@ import { memoize } from 'lib';
 import { findWordDefinitions, solve, verify, visit } from 'sdk';
 
 import { initialize, reset } from './actions';
+import { boardSlice, selectBoard } from './board';
+import { cellFiltersSlice, selectCellFilter } from './cellFilters';
+import { dictionarySlice, selectDictionary } from './dictionary';
+import { rackSlice, selectCharacters, selectRack } from './rack';
+import { resultsSlice } from './results';
 import {
-  selectBoard,
-  selectCellFilter,
-  selectCharacters,
   selectConfig,
-  selectDictionary,
   selectGame,
   selectLocale,
   selectLocaleAutoGroupTiles,
-  selectRack,
-} from './selectors';
-import {
-  boardSlice,
-  cellFilterSlice,
-  dictionarySlice,
-  rackSlice,
-  resultsSlice,
+  selectRemoveCellFilters,
   settingsSlice,
-  solveSlice,
-  verifySlice,
-} from './slices';
+} from './settings';
+import { solveSlice } from './solve';
+import { verifySlice } from './verify';
 
 const SUBMIT_DELAY = 150;
 
@@ -62,7 +56,7 @@ function* onCellValueChange({ payload }: PayloadAction<{ value: string; x: numbe
   const filter = yield select((state) => selectCellFilter(state, payload));
 
   if (filter) {
-    yield put(cellFilterSlice.actions.cancel(payload));
+    yield put(cellFiltersSlice.actions.cancel(payload));
   }
 
   yield put(resultsSlice.actions.changeResultCandidate(null));
@@ -75,8 +69,13 @@ function* onRackValueChange(): AnyGenerator {
 
 function* onApplyResult({ payload: result }: PayloadAction<Result>): AnyGenerator {
   const autoGroupTiles = yield select(selectLocaleAutoGroupTiles);
+  const removeCellFilters = yield select(selectRemoveCellFilters);
   yield put(boardSlice.actions.applyResult(result));
-  yield put(cellFilterSlice.actions.reset());
+  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());
@@ -92,8 +91,8 @@ function* onGameChange(): AnyGenerator {
   }
 
   yield put(resultsSlice.actions.reset());
+  yield* resetRack();
   yield put(verifySlice.actions.submit());
-  yield* ensureProperTilesCount();
 }
 
 function* onDictionarySubmit(): AnyGenerator {
@@ -126,7 +125,7 @@ function* onInitialize(): AnyGenerator {
   yield call(visit);
 
   if (!board.isEmpty()) {
-    yield* ensureProperTilesCount();
+    yield* resetRack();
     yield put(verifySlice.actions.submit());
   }
 }
@@ -135,7 +134,7 @@ function* onReset(): AnyGenerator {
   const config = yield select(selectConfig);
 
   yield put(boardSlice.actions.init(Board.create(config.boardWidth, config.boardHeight)));
-  yield put(cellFilterSlice.actions.reset());
+  yield put(cellFiltersSlice.actions.reset());
   yield put(dictionarySlice.actions.reset());
   yield put(rackSlice.actions.reset());
   yield put(resultsSlice.actions.reset());
@@ -223,7 +222,7 @@ function* onVerify(): AnyGenerator {
   }
 }
 
-function* ensureProperTilesCount(): AnyGenerator {
+function* resetRack(): AnyGenerator {
   const { config } = yield select(selectConfig);
   const rack = yield select(selectRack);
 

package/src/state/selectors.ts

@@ -1,255 +1,35 @@
-/* eslint-disable max-lines */
-
 import { createSelector } from '@reduxjs/toolkit';
-import { getConfig } from '@scrabble-solver/configs';
-import { BLANK } from '@scrabble-solver/constants';
-import { Cell, Config, isError, Tile } from '@scrabble-solver/types';
-
-import { i18n, LOCALE_FEATURES } from 'i18n';
-import {
-  createRegExp,
-  findCell,
-  getRemainingTiles,
-  getRemainingTilesGroups,
-  groupResults,
-  resultMatchesCellFilter,
-  sortGroupedResults,
-  unorderedArraysEqual,
-} from 'lib';
-import { Point, ResultColumnId, Translations } from 'types';
-
-import { RootState } from './types';
-
-const selectCell = (_: unknown, cell: Cell): Cell => cell;
-
-const selectPoint = (_: unknown, point: Point): Point => point;
-
-const selectResultIndex = (_: unknown, index: number): number => index;
-
-const selectCharacter = (_: unknown, character: string | null): string | null => character;
-
-const selectTile = (_: unknown, tile: Tile | null): Tile | null => tile;
-
-const selectBoardRoot = (state: RootState): RootState['board'] => state.board;
-
-const selectDictionaryRoot = (state: RootState): RootState['dictionary'] => state.dictionary;
-
-const selectCellFilterRoot = (state: RootState): RootState['cellFilter'] => state.cellFilter;
-
-const selectRackRoot = (state: RootState): RootState['rack'] => state.rack;
-
-const selectResultsRoot = (state: RootState): RootState['results'] => state.results;
-
-const selectSettingsRoot = (state: RootState): RootState['settings'] => state.settings;
-
-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 selectLocale = createSelector([selectSettingsRoot], (settings) => settings.locale);
-
-export const selectAutoGroupTiles = createSelector([selectSettingsRoot], (settings) => settings.autoGroupTiles);
-
-export const selectLocaleAutoGroupTiles = createSelector([selectLocale, selectSettingsRoot], (locale, settings) => {
-  if (LOCALE_FEATURES[locale].direction === 'ltr' || settings.autoGroupTiles === null) {
-    return settings.autoGroupTiles;
-  }
-
-  return settings.autoGroupTiles === 'left' ? 'right' : 'left';
-});
-
-export const selectBoard = selectBoardRoot;
-
-export const selectInputMode = createSelector([selectSettingsRoot], (settings) => settings.inputMode);
-
-export const selectShowCoordinates = createSelector([selectSettingsRoot], (settings) => settings.showCoordinates);
-
-export const selectGame = createSelector([selectSettingsRoot], (settings) => settings.game);
-
-export const selectConfig = createSelector([selectGame, selectLocale], getConfig);
-
-export const selectFilteredCells = selectCellFilterRoot;
-
-export const selectCellFilter = createSelector([selectFilteredCells, selectPoint], (cellFilter, { x, y }) => {
-  return cellFilter.find((cell) => cell.x === x && cell.y === y);
-});
-
-export const selectCellIsValid = createSelector([selectConfig, selectCell], (config, cell) => {
-  if (!cell.hasTile()) {
-    return true;
-  }
-
-  return config.tiles.some((tile) => tile.character === cell.tile.character);
-});
-
-export const selectResultsRaw = createSelector([selectResultsRoot], (results) => results.results);
-
-export const selectResultsQuery = createSelector([selectResultsRoot], (results) => results.query);
-
-export const selectResultsSort = createSelector([selectResultsRoot], (results) => results.sort);
-
-export const selectGroupedResults = createSelector(
-  [selectResultsRaw, selectResultsQuery, selectFilteredCells],
-  groupResults,
-);
-
-export const selectGroupedSortedResults = createSelector(
-  [selectGroupedResults, selectResultsSort, selectLocale, selectShowCoordinates],
-  sortGroupedResults,
-);
-
-export const selectResults = createSelector([selectGroupedSortedResults], (groupedResults) => {
-  return groupedResults ? [...groupedResults.matching, ...groupedResults.other] : groupedResults;
-});
 
-export const selectIsResultMatching = createSelector(
-  [selectResults, selectResultsQuery, selectFilteredCells, selectResultIndex],
-  (results, query, cellFilter, index) => {
-    if (!results) {
-      return false;
-    }
+import { unorderedArraysEqual } from 'lib';
 
-    const result = results[index];
-    const regExp = createRegExp(query);
+import { selectBoard } from './board';
+import { getRemainingTiles } from './lib';
+import { selectCharacters } from './rack';
+import { selectConfig, selectLocale } from './settings';
+import { selectLastSolvedParameters } from './solve';
 
-    if (!regExp.test(result.word)) {
-      return false;
-    }
-
-    return resultMatchesCellFilter(result, cellFilter);
-  },
-);
-
-export const selectResultCandidate = createSelector([selectResultsRoot], (results) => results.candidate);
-
-export const selectResultCandidateCells = createSelector(
-  [selectResultCandidate],
-  (resultCandidate): Cell[] => resultCandidate?.cells || [],
-);
-
-export const selectResultCandidateTiles = createSelector(
-  [selectResultCandidate],
-  (resultCandidate): Tile[] => resultCandidate?.tiles || [],
-);
-
-export const selectRowsWithCandidate = createSelector([selectBoardRoot, selectResultCandidateCells], (board, cells) => {
-  return board.rows.map((row: Cell[], y: number) => row.map((cell: Cell, x: number) => findCell(cells, x, y) || cell));
-});
-
-export const selectCellBonus = createSelector([selectConfig, selectCell], (config: Config, cell: Cell) => {
-  return config.getCellBonus(cell);
-});
-
-export const selectCharacterPoints = createSelector(
-  [selectConfig, selectCharacter],
-  (config: Config, character: string | null) => {
-    return config.getCharacterPoints(character);
-  },
-);
-
-export const selectCharacterIsValid = createSelector(
-  [selectConfig, selectCharacter],
-  (config: Config, character: string | null) => {
-    if (character === null || character === BLANK) {
-      return true;
-    }
-
-    return config.tiles.some((tile) => tile.character === character);
+const selectHasBoardChanged = createSelector(
+  [selectLastSolvedParameters, selectBoard],
+  (lastSolvedParameters, board) => {
+    return !lastSolvedParameters.board.equals(board);
   },
 );
 
-export const selectTilePoints = createSelector([selectConfig, selectTile], (config: Config, tile: Tile | null) => {
-  return config.getTilePoints(tile);
-});
-
-export const selectTranslations = createSelector([selectLocale], (locale) => i18n[locale]);
-
-export const selectTranslation = createSelector(
-  [selectTranslations, selectLocale, (_: unknown, id: keyof Translations) => id],
-  (translations, locale, id): string => {
-    const translation = translations[id];
-
-    if (typeof translation === 'undefined') {
-      throw new Error(`Untranslated key "${id}" in locale "${locale}"`);
-    }
-
-    return translation;
-  },
-);
-
-export const selectRack = selectRackRoot;
-
-export const selectCharacters = createSelector(selectRackRoot, (rack) => rack.filter((tile) => tile !== null));
-
-export const selectLastSolvedParameters = createSelector([selectSolveRoot], (solve) => solve.lastSolvedParameters);
-
-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(
+const selectHaveCharactersChanged = createSelector(
   [selectLastSolvedParameters, selectCharacters, selectLocale],
   (lastSolvedParameters, characters, locale) => {
     return !unorderedArraysEqual(lastSolvedParameters.characters, characters, locale);
   },
 );
 
-export const selectHasBoardChanged = createSelector(
-  [selectLastSolvedParameters, selectBoardRoot],
-  (lastSolvedParameters, board) => !lastSolvedParameters.board.equals(board),
-);
-
 export const selectAreResultsOutdated = createSelector(
   [selectHasBoardChanged, selectHaveCharactersChanged],
-  (hasBoardChanged, haveCharactersChanged) => hasBoardChanged || haveCharactersChanged,
+  (hasBoardChanged, haveCharactersChanged) => {
+    return hasBoardChanged || haveCharactersChanged;
+  },
 );
 
 export const selectRemainingTiles = createSelector(
-  [selectConfig, selectBoardRoot, selectCharacters, selectLocale],
+  [selectConfig, selectBoard, selectCharacters, selectLocale],
   getRemainingTiles,
 );
-
-export const selectHasOverusedTiles = createSelector([selectRemainingTiles], (remainingTiles) => {
-  return remainingTiles.some(({ count, usedCount }) => usedCount > count);
-});
-
-export const selectRemainingTilesGroups = createSelector([selectRemainingTiles], getRemainingTilesGroups);
-
-export const selectVerify = selectVerifyRoot;
-
-export const selectHasInvalidWords = createSelector([selectVerify], ({ invalidWords }) => {
-  return invalidWords.length > 0;
-});
-
-export const selectColumns = createSelector([selectLocale, selectShowCoordinates], (locale, showCoordinates) => {
-  const { consonants, vowels } = LOCALE_FEATURES[locale];
-  const columns: ResultColumnId[] = [
-    ResultColumnId.Word,
-    ResultColumnId.TilesCount,
-    ResultColumnId.BlanksCount,
-    ResultColumnId.WordsCount,
-    ResultColumnId.Points,
-  ];
-
-  if (showCoordinates !== 'hidden') {
-    columns.push(ResultColumnId.Coordinates);
-  }
-
-  if (vowels) {
-    columns.push(ResultColumnId.VowelsCount);
-  }
-
-  if (consonants) {
-    columns.push(ResultColumnId.ConsonantsCount);
-  }
-
-  return columns;
-});

package/src/state/settings/index.ts

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

package/src/state/{slices/settingsInitialState.ts → settings/initialState.ts}

@@ -1,17 +1,9 @@
-import { Game, Locale, ShowCoordinates } from '@scrabble-solver/types';
-
-import { guessLocale } from 'lib';
-import { AutoGroupTiles, InputMode } from 'types';
+import { Game } from '@scrabble-solver/types';
 
 import { localStorage } from '../localStorage';
 
-export interface SettingsState {
-  autoGroupTiles: AutoGroupTiles;
-  game: Game;
-  inputMode: InputMode;
-  locale: Locale;
-  showCoordinates: ShowCoordinates;
-}
+import { guessLocale } from './lib';
+import type { SettingsState } from './types';
 
 const localStorageAutoGroupTiles = localStorage.getAutoGroupTiles();
 const isTouchScreen = typeof globalThis.matchMedia !== 'undefined' && globalThis.matchMedia('(hover: none)').matches;
@@ -22,4 +14,5 @@ export const settingsInitialState: SettingsState = {
   inputMode: localStorage.getInputMode() ?? (isTouchScreen ? 'touchscreen' : 'keyboard'),
   locale: localStorage.getLocale() ?? guessLocale(),
   showCoordinates: localStorage.getShowCoordinates() ?? 'hidden',
+  removeCellFilters: localStorage.getRemoveCellFilters() ?? 'always',
 };

package/src/state/settings/lib.ts

@@ -0,0 +1,42 @@
+import { Locale } from '@scrabble-solver/types';
+
+export const guessLocale = (): Locale => {
+  if (!globalThis.navigator) {
+    return Locale.EN_US;
+  }
+
+  const languages = globalThis.navigator.languages;
+
+  if (languages.includes('pl') || languages.includes('pl-PL')) {
+    return Locale.PL_PL;
+  }
+
+  if (languages.includes('en-GB')) {
+    return Locale.EN_GB;
+  }
+
+  if (languages.includes('fa') || languages.includes('fa-IR')) {
+    return Locale.FA_IR;
+  }
+
+  if (languages.includes('fr-FR')) {
+    return Locale.FR_FR;
+  }
+
+  if (languages.includes('ro') || languages.includes('ro-RO')) {
+    return Locale.RO_RO;
+  }
+
+  const locales = Object.values(Locale);
+  const exactMatch = locales.find((locale) => globalThis.navigator.language === String(locale));
+
+  if (exactMatch) {
+    return exactMatch;
+  }
+
+  const partialMatch = locales.find((locale) => {
+    return globalThis.navigator.language === locale.substring(0, 2);
+  });
+
+  return partialMatch ?? Locale.EN_US;
+};

package/src/state/settings/selectors.ts

@@ -0,0 +1,69 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { getConfig } from '@scrabble-solver/configs';
+import { BLANK } from '@scrabble-solver/constants';
+import { type Cell, type Tile } from '@scrabble-solver/types';
+
+import { i18n, LOCALE_FEATURES } from 'i18n';
+
+import type { RootState } from '../types';
+
+const selectCell = (_: unknown, cell: Cell): Cell => cell;
+
+const selectCharacter = (_: unknown, character: string | null): string | null => character;
+
+const selectTile = (_: unknown, tile: Tile | null): Tile | null => tile;
+
+export const selectSettings = (state: RootState) => state.settings;
+
+export const selectAutoGroupTiles = createSelector([selectSettings], (settings) => settings.autoGroupTiles);
+
+export const selectGame = createSelector([selectSettings], (settings) => settings.game);
+
+export const selectInputMode = createSelector([selectSettings], (settings) => settings.inputMode);
+
+export const selectLocale = createSelector([selectSettings], (settings) => settings.locale);
+
+export const selectLocaleAutoGroupTiles = createSelector([selectLocale, selectSettings], (locale, settings) => {
+  if (LOCALE_FEATURES[locale].direction === 'ltr' || settings.autoGroupTiles === null) {
+    return settings.autoGroupTiles;
+  }
+
+  return settings.autoGroupTiles === 'left' ? 'right' : 'left';
+});
+
+export const selectShowCoordinates = createSelector([selectSettings], (settings) => settings.showCoordinates);
+
+export const selectConfig = createSelector([selectGame, selectLocale], getConfig);
+
+export const selectCharacterPoints = createSelector([selectConfig, selectCharacter], (config, character) => {
+  return config.getCharacterPoints(character);
+});
+
+export const selectCharacterIsValid = createSelector([selectConfig, selectCharacter], (config, character) => {
+  if (character === null || character === BLANK) {
+    return true;
+  }
+
+  return config.tiles.some((tile) => tile.character === character);
+});
+
+export const selectCellBonus = createSelector([selectConfig, selectCell], (config, cell) => {
+  return config.getCellBonus(cell);
+});
+
+export const selectTilePoints = createSelector([selectConfig, selectTile], (config, tile) => {
+  return config.getTilePoints(tile);
+});
+
+export const selectCellIsValid = createSelector([selectConfig, selectCell], (config, cell) => {
+  if (!cell.hasTile()) {
+    return true;
+  }
+
+  return config.tiles.some((tile) => tile.character === cell.tile.character);
+});
+
+export const selectTranslations = createSelector([selectLocale], (locale) => i18n[locale]);
+
+export const selectRemoveCellFilters = createSelector([selectSettings], (settings) => settings.removeCellFilters);
+

package/src/state/{slices/settingsSlice.ts → settings/slice.ts}

@@ -1,9 +1,9 @@
-import { createSlice, PayloadAction } from '@reduxjs/toolkit';
-import { Game, Locale, ShowCoordinates } from '@scrabble-solver/types';
+import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
+import { type Game, type Locale, type ShowCoordinates } from '@scrabble-solver/types';
 
-import { AutoGroupTiles, InputMode } from 'types';
+import type { AutoGroupTiles, InputMode, RemoveCellFilters } from 'types';
 
-import { settingsInitialState } from './settingsInitialState';
+import { settingsInitialState } from './initialState';
 
 export const settingsSlice = createSlice({
   initialState: settingsInitialState,
@@ -34,6 +34,11 @@ export const settingsSlice = createSlice({
       return { ...state, showCoordinates };
     },
 
+    changeRemoveCellFilters: (state, action: PayloadAction<RemoveCellFilters>) => {
+      const removeCellFilters = action.payload;
+      return { ...state, removeCellFilters };
+    },
+
     init: (state, action: PayloadAction<Partial<Pick<typeof settingsInitialState, 'game' | 'locale'>>>) => {
       return { ...state, ...action.payload };
     },

package/src/state/settings/types.ts

@@ -0,0 +1,12 @@
+import { type Game, type Locale, type ShowCoordinates } from '@scrabble-solver/types';
+
+import type { AutoGroupTiles, InputMode, RemoveCellFilters } from 'types';
+
+export interface SettingsState {
+  autoGroupTiles: AutoGroupTiles;
+  game: Game;
+  inputMode: InputMode;
+  locale: Locale;
+  showCoordinates: ShowCoordinates;
+  removeCellFilters: RemoveCellFilters;
+}

package/src/state/solve/index.ts

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

package/src/state/solve/initialState.ts

@@ -0,0 +1,12 @@
+import { boardInitialState } from '../board';
+
+import type { SolveState } from './types';
+
+export const solveInitialState: SolveState = {
+  error: undefined,
+  isLoading: false,
+  lastSolvedParameters: {
+    board: boardInitialState,
+    characters: [],
+  },
+};

package/src/state/solve/selectors.ts

@@ -0,0 +1,14 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { isError } from '@scrabble-solver/types';
+
+import type { RootState } from '../types';
+
+export const selectSolve = (state: RootState) => state.solve;
+
+export const selectSolveError = createSelector([selectSolve], (solve) => {
+  return isError(solve.error) ? solve.error : undefined;
+});
+
+export const selectSolveIsLoading = createSelector([selectSolve], (solve) => solve.isLoading);
+
+export const selectLastSolvedParameters = createSelector([selectSolve], (solve) => solve.lastSolvedParameters);

package/src/state/{slices/solveSlice.ts → solve/slice.ts}

@@ -1,7 +1,7 @@
-import { createSlice, PayloadAction } from '@reduxjs/toolkit';
-import { Board } from '@scrabble-solver/types';
+import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
+import { type Board } from '@scrabble-solver/types';
 
-import { solveInitialState } from './solveInitialState';
+import { solveInitialState } from './initialState';
 
 interface SolveParameters {
   board: Board;

package/src/state/solve/types.ts

@@ -0,0 +1,10 @@
+import { type Board } from '@scrabble-solver/types';
+
+export interface SolveState {
+  error: unknown;
+  isLoading: boolean;
+  lastSolvedParameters: {
+    board: Board;
+    characters: string[];
+  };
+}

package/src/state/store.ts

@@ -1,24 +1,22 @@
 import { configureStore } from '@reduxjs/toolkit';
 import reduxSaga from 'redux-saga';
 
+import { boardSlice } from './board';
+import { cellFiltersSlice } from './cellFilters';
+import { dictionarySlice } from './dictionary';
+import { rackSlice } from './rack';
+import { resultsSlice } from './results';
 import { rootSaga } from './sagas';
-import {
-  boardSlice,
-  cellFilterSlice,
-  dictionarySlice,
-  rackSlice,
-  resultsSlice,
-  settingsSlice,
-  solveSlice,
-  verifySlice,
-} from './slices';
+import { settingsSlice } from './settings';
+import { solveSlice } from './solve';
+import { verifySlice } from './verify';
 
 const sagaMiddleware = reduxSaga();
 
 export const store = configureStore({
   reducer: {
     board: boardSlice.reducer,
-    cellFilter: cellFilterSlice.reducer,
+    cellFilters: cellFiltersSlice.reducer,
     dictionary: dictionarySlice.reducer,
     rack: rackSlice.reducer,
     results: resultsSlice.reducer,