@scrabble-solver/scrabble-solver 2.15.11 → 2.15.13

package/src/state/board/selectors.ts

@@ -0,0 +1,3 @@
+import type { RootState } from '../types';
+
+export const selectBoard = (state: RootState) => state.board;

package/src/state/{slices/boardSlice.ts → board/slice.ts}

@@ -1,10 +1,11 @@
-import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
 import { games } from '@scrabble-solver/configs';
 import { EMPTY_CELL } from '@scrabble-solver/constants';
-import { Board, Cell, Result, Tile } from '@scrabble-solver/types';
+import { Board, Cell, type Result, Tile } from '@scrabble-solver/types';
 
-import { boardInitialState } from './boardInitialState';
-import { settingsSlice } from './settingsSlice';
+import { settingsSlice } from '../settings';
+
+import { boardInitialState } from './initialState';
 
 export const boardSlice = createSlice({
   initialState: boardInitialState,

package/src/state/board/types.ts

@@ -0,0 +1,3 @@
+import { type Board } from '@scrabble-solver/types';
+
+export type BoardState = Board;

package/src/state/cellFilters/index.ts

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

package/src/state/cellFilters/initialState.ts

@@ -0,0 +1,3 @@
+import type { CellFiltersState } from './types';
+
+export const cellFiltersInitialState: CellFiltersState = [];

package/src/state/cellFilters/lib.ts

@@ -0,0 +1,8 @@
+import type { CellFilterType } from 'types';
+
+export const toggleCellFilterState = (type: CellFilterType): CellFilterType | null => {
+  const chain: (CellFilterType | null)[] = ['include', 'exclude', null];
+  const index = chain.indexOf(type);
+  const nextIndex = (index + 1) % chain.length;
+  return chain[nextIndex];
+};

package/src/state/cellFilters/selectors.ts

@@ -0,0 +1,13 @@
+import { createSelector } from '@reduxjs/toolkit';
+
+import type { Point } from 'types';
+
+import type { RootState } from '../types';
+
+const selectPoint = (_: unknown, point: Point): Point => point;
+
+export const selectCellFilters = (state: RootState) => state.cellFilters;
+
+export const selectCellFilter = createSelector([selectCellFilters, selectPoint], (cellFilters, point) => {
+  return cellFilters.find((cell) => cell.x === point.x && cell.y === point.y);
+});

package/src/state/{slices/cellFilterSlice.ts → cellFilters/slice.ts}

@@ -1,12 +1,14 @@
-import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
+import type { Cell } from '@scrabble-solver/types';
 
-import { CellFilterType, Point } from 'types';
+import type { Point } from 'types';
 
-import { cellFilterInitialState } from './cellFilterInitialState';
+import { cellFiltersInitialState } from './initialState';
+import { toggleCellFilterState } from './lib';
 
-export const cellFilterSlice = createSlice({
-  initialState: cellFilterInitialState,
-  name: 'cellFilter',
+export const cellFiltersSlice = createSlice({
+  initialState: cellFiltersInitialState,
+  name: 'cellFilters',
   reducers: {
     toggle: (state, action: PayloadAction<Point>) => {
       const { x, y } = action.payload;
@@ -37,13 +39,12 @@ export const cellFilterSlice = createSlice({
       return state.filter((point) => point.x !== x || point.y !== y);
     },
 
-    reset: () => cellFilterInitialState,
+    removeCells: (state, action: PayloadAction<Cell[]>) => {
+      const cellsToRemove = action.payload;
+      return state.filter((entry) =>
+        cellsToRemove.every((cell) => cell.x !== entry.x || cell.y !== entry.y));
+    },
+
+    reset: () => cellFiltersInitialState,
   },
 });
-
-const toggleCellFilterState = (type: CellFilterType): CellFilterType | null => {
-  const chain: (CellFilterType | null)[] = ['include', 'exclude', null];
-  const index = chain.indexOf(type);
-  const nextIndex = (index + 1) % chain.length;
-  return chain[nextIndex];
-};

package/src/state/cellFilters/types.ts

@@ -0,0 +1,3 @@
+import type { CellFilter } from 'types';
+
+export type CellFiltersState = CellFilter[];

package/src/state/dictionary/index.ts

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

package/src/state/dictionary/initialState.ts

@@ -0,0 +1,8 @@
+import { type DictionaryState } from './types';
+
+export const dictionaryInitialState: DictionaryState = {
+  error: undefined,
+  input: '',
+  isLoading: false,
+  results: [],
+};

package/src/state/dictionary/selectors.ts

@@ -0,0 +1,16 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { isError } from '@scrabble-solver/types';
+
+import type { RootState } from '../types';
+
+export const selectDictionary = (state: RootState) => state.dictionary;
+
+export const selectDictionaryInput = createSelector([selectDictionary], (dictionary) => dictionary.input);
+
+export const selectDictionaryResults = createSelector([selectDictionary], (dictionary) => dictionary.results);
+
+export const selectDictionaryIsLoading = createSelector([selectDictionary], (dictionary) => dictionary.isLoading);
+
+export const selectDictionaryError = createSelector([selectDictionary], (dictionary) => {
+  return isError(dictionary.error) ? dictionary.error : undefined;
+});

package/src/state/{slices/dictionarySlice.ts → dictionary/slice.ts}

@@ -1,7 +1,7 @@
-import { createSlice, PayloadAction } from '@reduxjs/toolkit';
-import { WordDefinition } from '@scrabble-solver/types';
+import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
+import { type WordDefinition } from '@scrabble-solver/types';
 
-import { dictionaryInitialState } from './dictionaryInitialState';
+import { dictionaryInitialState } from './initialState';
 
 export const dictionarySlice = createSlice({
   initialState: dictionaryInitialState,

package/src/state/dictionary/types.ts

@@ -0,0 +1,8 @@
+import { type WordDefinition } from '@scrabble-solver/types';
+
+export interface DictionaryState {
+  error: unknown;
+  input: string;
+  isLoading: boolean;
+  results: WordDefinition[];
+}

package/src/state/index.ts

@@ -1,7 +1,14 @@
 export * from './actions';
-export { localStorage } from './localStorage';
+export * from './board';
+export * from './cellFilters';
+export * from './dictionary';
+export * from './localStorage';
+export * from './rack';
+export * from './results';
 export * from './selectors';
-export * from './slices';
-export { store } from './store';
-export { useTranslate } from './useTranslate';
-export { useTypedSelector } from './useTypedSelector';
+export * from './settings';
+export * from './solve';
+export * from './store';
+export * from './useTranslate';
+export * from './useTypedSelector';
+export * from './verify';

package/src/{lib/getRemainingTiles.ts → state/lib.ts}

@@ -1,9 +1,8 @@
 import { BLANK } from '@scrabble-solver/constants';
-import { Board, Config } from '@scrabble-solver/types';
+import { type Board, type Config } from '@scrabble-solver/types';
 
-import { RemainingTile } from 'types';
-
-import { createKeyComparator } from './createKeyComparator';
+import { createKeyComparator } from 'lib';
+import { type RemainingTile } from 'types';
 
 export const getRemainingTiles = (
   config: Config,

package/src/state/localStorage.ts

@@ -1,12 +1,13 @@
-import { Board, BoardJson, Game, Locale, ShowCoordinates } from '@scrabble-solver/types';
+import { Board, type BoardJson, type Game, type Locale, type ShowCoordinates } from '@scrabble-solver/types';
 import store2 from 'store2';
 
-import { AutoGroupTiles, InputMode, Rack } from 'types';
+import type { AutoGroupTiles, InputMode, Rack, RemoveCellFilters } from 'types';
 
 const AUTO_GROUP_TILES = 'auto-group-tiles';
 const BOARD = 'board';
 const GAME_ID = 'config-id';
 const INPUT_MODE = 'input-mode';
+const REMOVE_CELL_FILTERS = 'remove-cell-filters';
 const LOCALE = 'locale';
 const RACK = 'rack';
 const SHOW_COORDINATES = 'show-coordinates';
@@ -71,4 +72,12 @@ export const localStorage = {
   setShowCoordinates(showCoordinates: ShowCoordinates | undefined): void {
     store.set(SHOW_COORDINATES, showCoordinates, true);
   },
+
+  getRemoveCellFilters(): RemoveCellFilters | undefined {
+    return store.get(REMOVE_CELL_FILTERS) as RemoveCellFilters | undefined;
+  },
+
+  setRemoveCellFilters(removeCellFilters: RemoveCellFilters | undefined): void {
+    store.set(REMOVE_CELL_FILTERS, removeCellFilters, true);
+  },
 };

package/src/state/rack/index.ts

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

package/src/state/rack/initialState.ts

@@ -0,0 +1,12 @@
+import { getConfig } from '@scrabble-solver/configs';
+
+import { localStorage } from '../localStorage';
+import { settingsInitialState } from '../settings';
+
+import type { RackState } from './types';
+
+const defaultConfig = getConfig(settingsInitialState.game, settingsInitialState.locale);
+
+export const rackDefaultState: RackState = Array(defaultConfig.rackSize).fill(null);
+
+export const rackInitialState: RackState = localStorage.getRack() ?? rackDefaultState;

package/src/state/rack/selectors.ts

@@ -0,0 +1,7 @@
+import { createSelector } from '@reduxjs/toolkit';
+
+import { type RootState } from '../types';
+
+export const selectRack = (state: RootState) => state.rack;
+
+export const selectCharacters = createSelector(selectRack, (rack) => rack.filter((tile) => tile !== null));

package/src/state/{slices/rackSlice.ts → rack/slice.ts}

@@ -1,10 +1,10 @@
-import { createSlice, PayloadAction } from '@reduxjs/toolkit';
-import { Tile } from '@scrabble-solver/types';
+import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
+import { type Tile } from '@scrabble-solver/types';
 
 import { arrayEquals, createNullMovingComparator, inverseDirection, zipCharactersAndTiles } from 'lib';
-import { AutoGroupTiles, Rack } from 'types';
+import { type AutoGroupTiles, type Rack } from 'types';
 
-import { rackInitialState, rackDefaultState } from './rackInitialState';
+import { rackDefaultState, rackInitialState } from './initialState';
 
 export const rackSlice = createSlice({
   initialState: rackInitialState,

package/src/state/rack/types.ts

@@ -0,0 +1,3 @@
+import { type Rack } from 'types';
+
+export type RackState = Rack;

package/src/state/results/index.ts

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

package/src/state/results/initialState.ts

@@ -0,0 +1,13 @@
+import { ResultColumnId, SortDirection } from 'types';
+
+import type { ResultsState } from './types';
+
+export const resultsInitialState: ResultsState = {
+  candidate: null,
+  query: '',
+  results: undefined,
+  sort: {
+    column: ResultColumnId.Points,
+    direction: SortDirection.Descending,
+  },
+};

package/src/state/results/lib.ts

@@ -0,0 +1,96 @@
+import { type Result, type ShowCoordinates } from '@scrabble-solver/types';
+
+import { createKeyComparator, createRegExp, createStringComparator, getCoordinate, reverseComparator } from 'lib';
+import { type CellFilter, type Comparator, type GroupedResults, ResultColumnId, type Sort, SortDirection } from 'types';
+
+export const getCoordinates = (result: Result, showCoordinates: ShowCoordinates): string => {
+  if (showCoordinates === 'hidden') {
+    return '';
+  }
+
+  const firstCell = result.cells[0];
+  const x = getCoordinate(firstCell.x, showCoordinates === 'original' ? 'letter' : 'number');
+  const y = getCoordinate(firstCell.y, showCoordinates === 'original' ? 'number' : 'letter');
+
+  return result.isHorizontal() ? `${y}${x}` : `${x}${y}`;
+};
+
+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, (locale: string, showCoordinates: ShowCoordinates) => Comparator<Result>> = {
+  [ResultColumnId.BlanksCount]: (locale: string) => createKeyComparator('blanksCount', locale),
+  [ResultColumnId.ConsonantsCount]: (locale: string) => createKeyComparator('consonantsCount', locale),
+  [ResultColumnId.Coordinates]: (locale: string, showCoordinates: ShowCoordinates) => (a, b) => {
+    const stringComparator = createStringComparator(locale);
+    const aValue = getCoordinates(a, showCoordinates);
+    const bValue = getCoordinates(b, showCoordinates);
+    return stringComparator(aValue, bValue);
+  },
+  [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;
+  }
+
+  const createComparator = comparators[sort.column];
+  const comparator = createComparator(locale, showCoordinates);
+  const finalComparator = sort.direction === SortDirection.Descending ? reverseComparator(comparator) : comparator;
+  const sortedResults = [...results].sort(finalComparator);
+  return sortedResults;
+};

package/src/state/results/selectors.ts

@@ -0,0 +1,75 @@
+import { createSelector } from '@reduxjs/toolkit';
+
+import { createRegExp } from 'lib';
+
+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);
+
+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 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/src/state/{slices/resultsSlice.ts → results/slice.ts}

@@ -1,9 +1,9 @@
-import { createSlice, PayloadAction } from '@reduxjs/toolkit';
-import { Result } from '@scrabble-solver/types';
+import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
+import { type Result } from '@scrabble-solver/types';
 
-import { ResultColumnId, SortDirection } from 'types';
+import { type ResultColumnId, SortDirection } from 'types';
 
-import { resultsInitialState } from './resultsInitialState';
+import { resultsInitialState } from './initialState';
 
 const toggleDirection = (direction: SortDirection): SortDirection => {
   return direction === SortDirection.Ascending ? SortDirection.Descending : SortDirection.Ascending;

package/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/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);