@scrabble-solver/scrabble-solver 2.15.11 → 2.15.12

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 = 0, 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,

package/src/state/types.ts

@@ -1,21 +1,19 @@
-import {
-  boardSlice,
-  cellFilterSlice,
-  dictionarySlice,
-  rackSlice,
-  resultsSlice,
-  settingsSlice,
-  solveSlice,
-  verifySlice,
-} from './slices';
+import type { BoardState } from './board';
+import type { CellFiltersState } from './cellFilters';
+import type { DictionaryState } from './dictionary';
+import type { RackState } from './rack';
+import type { ResultsState } from './results';
+import type { SettingsState } from './settings';
+import type { SolveState } from './solve';
+import type { VerifyState } from './verify';
 
 export type RootState = {
-  board: ReturnType<typeof boardSlice.reducer>;
-  cellFilter: ReturnType<typeof cellFilterSlice.reducer>;
-  dictionary: ReturnType<typeof dictionarySlice.reducer>;
-  rack: ReturnType<typeof rackSlice.reducer>;
-  results: ReturnType<typeof resultsSlice.reducer>;
-  settings: ReturnType<typeof settingsSlice.reducer>;
-  solve: ReturnType<typeof solveSlice.reducer>;
-  verify: ReturnType<typeof verifySlice.reducer>;
+  board: BoardState;
+  cellFilters: CellFiltersState;
+  dictionary: DictionaryState;
+  rack: RackState;
+  results: ResultsState;
+  settings: SettingsState;
+  solve: SolveState;
+  verify: VerifyState;
 };

package/src/state/useTranslate.ts

@@ -1,8 +1,8 @@
 import { useCallback } from 'react';
 
-import { Translate } from 'types';
+import type { Translate } from 'types';
 
-import { selectLocale, selectTranslations } from './selectors';
+import { selectLocale, selectTranslations } from './settings';
 import { useTypedSelector } from './useTypedSelector';
 
 export const useTranslate = (): Translate => {

package/src/state/useTypedSelector.ts

@@ -1,5 +1,5 @@
-import { TypedUseSelectorHook, useSelector } from 'react-redux';
+import { type TypedUseSelectorHook, useSelector } from 'react-redux';
 
-import { RootState } from './types';
+import type { RootState } from './types';
 
 export const useTypedSelector: TypedUseSelectorHook<RootState> = useSelector;

package/src/state/verify/index.ts

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

package/src/state/verify/initialState.ts

@@ -0,0 +1,12 @@
+import { boardInitialState } from '../board';
+
+import type { VerifyState } from './types';
+
+export const verifyInitialState: VerifyState = {
+  isLoading: false,
+  lastSolvedParameters: {
+    board: boardInitialState,
+  },
+  invalidWords: [],
+  validWords: [],
+};

package/src/state/verify/selectors.ts

@@ -0,0 +1,9 @@
+import { createSelector } from '@reduxjs/toolkit';
+
+import type { RootState } from '../types';
+
+export const selectVerify = (state: RootState) => state.verify;
+
+export const selectInvalidWords = createSelector([selectVerify], (verify) => verify.invalidWords);
+
+export const selectValidWords = createSelector([selectVerify], (verify) => verify.validWords);

package/src/state/{slices/verifySlice.ts → verify/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 { verifyInitialState } from './verifyInitialState';
+import { verifyInitialState } from './initialState';
 
 interface VerifyParameters {
   board: Board;

package/src/state/verify/types.ts

@@ -0,0 +1,10 @@
+import type { BoardState } from '../board';
+
+export interface VerifyState {
+  isLoading: boolean;
+  lastSolvedParameters: {
+    board: BoardState;
+  };
+  invalidWords: string[];
+  validWords: string[];
+}

package/src/styles/global.scss

@@ -45,3 +45,8 @@ h4 {
   -webkit-margin-after: 0;
   margin: 0;
 }
+
+/* https://github.com/vercel/next.js/discussions/13387#discussioncomment-5694715 */
+nextjs-portal {
+  display: none;
+}