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

package/packages/scrabble-solver/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/packages/scrabble-solver/src/state/settings/selectors.ts

@@ -0,0 +1,78 @@
+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 { LOCALE_FEATURES } from '@/i18n/constants';
+import { englishTranslations } from '@/i18n/i18n';
+
+import { selectLoadedTranslations } 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 selectHighlightUnreachableCells = createSelector(
+  [selectSettings],
+  (settings) => settings.highlightUnreachableCells,
+);
+
+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, selectLoadedTranslations],
+  (locale, translations) => translations[locale] ?? englishTranslations,
+);
+
+export const selectRemoveCellFilters = createSelector([selectSettings], (settings) => settings.removeCellFilters);

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

@@ -0,0 +1,54 @@
+import { type PayloadAction, createSlice } from '@reduxjs/toolkit';
+import { type Game, type Locale, type ShowCoordinates } from '@scrabble-solver/types';
+
+import type { AutoGroupTiles, InputMode, RemoveCellFilters } from '@/types';
+
+import { settingsInitialState } from './initialState';
+
+export const settingsSlice = createSlice({
+  initialState: settingsInitialState,
+  name: 'settings',
+  reducers: {
+    changeAutoGroupTiles: (state, action: PayloadAction<AutoGroupTiles>) => {
+      const autoGroupTiles = action.payload;
+      return { ...state, autoGroupTiles };
+    },
+
+    changeGame: (state, action: PayloadAction<Game>) => {
+      const game = action.payload;
+      return { ...state, game };
+    },
+
+    changeHighlightUnreachableCells: (state, action: PayloadAction<boolean>) => {
+      const highlightUnreachableCells = action.payload;
+      return { ...state, highlightUnreachableCells };
+    },
+
+    changeInputMode: (state, action: PayloadAction<InputMode>) => {
+      const inputMode = action.payload;
+      return { ...state, inputMode };
+    },
+
+    changeLocale: (state, action: PayloadAction<Locale>) => {
+      const locale = action.payload;
+      return { ...state, locale };
+    },
+
+    changeShowCoordinates: (state, action: PayloadAction<ShowCoordinates>) => {
+      const showCoordinates = action.payload;
+      return { ...state, showCoordinates };
+    },
+
+    changeRemoveCellFilters: (state, action: PayloadAction<RemoveCellFilters>) => {
+      const removeCellFilters = action.payload;
+      return { ...state, removeCellFilters };
+    },
+
+    init: (state, action: PayloadAction<Partial<typeof settingsInitialState>>) => {
+      const settings = { ...state, ...action.payload };
+      const keys = Object.keys(settings) as (keyof typeof settingsInitialState)[];
+      const hasDiff = keys.some((key) => settings[key] !== state[key]);
+      return hasDiff ? settings : state;
+    },
+  },
+});

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

@@ -0,0 +1,13 @@
+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;
+  highlightUnreachableCells: boolean;
+  inputMode: InputMode;
+  locale: Locale;
+  showCoordinates: ShowCoordinates;
+  removeCellFilters: RemoveCellFilters;
+}

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

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

package/packages/scrabble-solver/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/packages/scrabble-solver/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/packages/scrabble-solver/src/state/solve/slice.ts

@@ -0,0 +1,33 @@
+import { type PayloadAction, createSlice } from '@reduxjs/toolkit';
+import { type Board } from '@scrabble-solver/types';
+
+import { solveInitialState } from './initialState';
+
+interface SolveParameters {
+  board: Board;
+  characters: string[];
+}
+
+export const solveSlice = createSlice({
+  initialState: solveInitialState,
+  name: 'solve',
+  reducers: {
+    reset: () => solveInitialState,
+
+    submit: (state) => {
+      const error = solveInitialState.error;
+      return { ...state, error, isLoading: true };
+    },
+
+    submitFailure: (state, action: PayloadAction<unknown>) => {
+      const error = action.payload;
+      return { ...state, error, isLoading: false };
+    },
+
+    submitSuccess: (state, action: PayloadAction<SolveParameters>) => {
+      const error = solveInitialState.error;
+      const lastSolvedParameters = action.payload;
+      return { ...state, error, isLoading: false, lastSolvedParameters };
+    },
+  },
+});

package/packages/scrabble-solver/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/packages/scrabble-solver/src/state/store.ts

@@ -0,0 +1,38 @@
+import { configureStore } from '@reduxjs/toolkit';
+import reduxSaga from 'redux-saga';
+
+import { appSlice } from './app';
+import { boardSlice } from './board';
+import { cellFiltersSlice } from './cellFilters';
+import { dictionarySlice } from './dictionary';
+import { hoveredTileSlice } from './hoveredTile';
+import { hoveredWordSlice } from './hoveredWord';
+import { i18nSlice } from './i18n';
+import { rackSlice } from './rack';
+import { resultsSlice } from './results';
+import { rootSaga } from './sagas';
+import { settingsSlice } from './settings';
+import { solveSlice } from './solve';
+import { verifySlice } from './verify';
+
+const sagaMiddleware = reduxSaga();
+
+export const store = configureStore({
+  reducer: {
+    app: appSlice.reducer,
+    board: boardSlice.reducer,
+    cellFilters: cellFiltersSlice.reducer,
+    dictionary: dictionarySlice.reducer,
+    hoveredTile: hoveredTileSlice.reducer,
+    hoveredWord: hoveredWordSlice.reducer,
+    i18n: i18nSlice.reducer,
+    rack: rackSlice.reducer,
+    results: resultsSlice.reducer,
+    settings: settingsSlice.reducer,
+    solve: solveSlice.reducer,
+    verify: verifySlice.reducer,
+  },
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware({ serializableCheck: false }).concat([sagaMiddleware]),
+});
+
+sagaMiddleware.run(rootSaga);

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

@@ -0,0 +1,27 @@
+import type { AppState } from './app';
+import type { BoardState } from './board';
+import type { CellFiltersState } from './cellFilters';
+import type { DictionaryState } from './dictionary';
+import type { HoveredTileState } from './hoveredTile';
+import type { HoveredWordState } from './hoveredWord';
+import type { I18nState } from './i18n';
+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 = {
+  app: AppState;
+  board: BoardState;
+  cellFilters: CellFiltersState;
+  dictionary: DictionaryState;
+  hoveredTile: HoveredTileState;
+  hoveredWord: HoveredWordState;
+  i18n: I18nState;
+  rack: RackState;
+  results: ResultsState;
+  settings: SettingsState;
+  solve: SolveState;
+  verify: VerifyState;
+};

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

@@ -0,0 +1,32 @@
+import { useCallback } from 'react';
+
+import type { Translate } from '@/types';
+
+import { selectLocale, selectTranslations } from './settings';
+import { useTypedSelector } from './useTypedSelector';
+
+export const useTranslate = (): Translate => {
+  const translations = useTypedSelector(selectTranslations);
+  const locale = useTypedSelector(selectLocale);
+  const translate: Translate = useCallback(
+    (id, replacements) => {
+      const translation = translations[id];
+
+      if (typeof translation === 'undefined') {
+        throw new Error(`Untranslated key "${id}" in locale "${locale}"`);
+      }
+
+      if (!replacements) {
+        return translation;
+      }
+
+      return Object.entries(replacements).reduce(
+        (result, [key, value]) => result.replaceAll(`{{${key}}}`, value),
+        translation,
+      );
+    },
+    [translations, locale],
+  );
+
+  return translate;
+};

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

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

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

@@ -0,0 +1,6 @@
+import { type Store } from '@reduxjs/toolkit';
+import { useStore } from 'react-redux';
+
+import type { RootState } from './types';
+
+export const useTypedStore = (): Store<RootState> => useStore<RootState>();

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

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

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

@@ -0,0 +1,19 @@
+import { SortDirection, WordColumnId } from '@/types';
+
+import { boardInitialState } from '../board';
+
+import type { VerifyState } from './types';
+
+export const verifyInitialState: VerifyState = {
+  isLoading: false,
+  lastSolvedParameters: {
+    board: boardInitialState,
+  },
+  invalidWords: [],
+  query: '',
+  sort: {
+    column: WordColumnId.Word,
+    direction: SortDirection.Ascending,
+  },
+  validWords: [],
+};

package/packages/scrabble-solver/src/state/verify/lib.test.ts

@@ -0,0 +1,55 @@
+import { type VerifiedWord, SortDirection, WordColumnId } from '../../types';
+
+import { getWordCoordinates, sortWords } from './lib';
+
+describe('getWordCoordinates', () => {
+  it('locates a horizontal word by its start cell', () => {
+    expect(getWordCoordinates(createWord({ x: 3, y: 3 }), 'original')).toBe('4D');
+  });
+
+  it('locates a vertical word by its start cell', () => {
+    expect(getWordCoordinates(createWord({ direction: 'vertical', x: 3, y: 3 }), 'original')).toBe('D4');
+  });
+});
+
+describe('sortWords', () => {
+  const cat = createWord({ word: 'cat', x: 3, y: 3 });
+  const zvq = createWord({ isValid: false, word: 'zvq', x: 3, y: 5 });
+
+  it('sorts by word', () => {
+    const sort = { column: WordColumnId.Word, direction: SortDirection.Ascending };
+
+    expect(sortWords([zvq, cat], sort, 'en-US', 'original')).toEqual([cat, zvq]);
+  });
+
+  it('sorts by coordinates', () => {
+    const sort = { column: WordColumnId.Coordinates, direction: SortDirection.Ascending };
+
+    expect(sortWords([zvq, cat], sort, 'en-US', 'original')).toEqual([cat, zvq]);
+  });
+
+  it('sorts invalid words first by validity', () => {
+    const sort = { column: WordColumnId.Validity, direction: SortDirection.Ascending };
+
+    expect(sortWords([cat, zvq], sort, 'en-US', 'original')).toEqual([zvq, cat]);
+  });
+
+  it('reverses the order when sorting descending', () => {
+    const sort = { column: WordColumnId.Word, direction: SortDirection.Descending };
+
+    expect(sortWords([cat, zvq], sort, 'en-US', 'original')).toEqual([zvq, cat]);
+  });
+
+  it('does not modify the input', () => {
+    const sort = { column: WordColumnId.Word, direction: SortDirection.Ascending };
+    const words = [zvq, cat];
+
+    sortWords(words, sort, 'en-US', 'original');
+
+    expect(words).toEqual([zvq, cat]);
+  });
+});
+
+function createWord(overrides: Partial<VerifiedWord>): VerifiedWord {
+  return { direction: 'horizontal', isValid: true, word: 'cat', x: 0, y: 0, ...overrides };
+}

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

@@ -0,0 +1,49 @@
+import { type BoardWord, 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 } from '@/lib/getCoordinates';
+import { numberComparator } from '@/lib/numberComparator';
+import { type ComparatorFactory, type GroupedWords, type Sort, type VerifiedWord, WordColumnId } from '@/types';
+
+export const getWordCoordinates = (word: BoardWord, showCoordinates: ShowCoordinates): string => {
+  return getCoordinates({ isHorizontal: word.direction === 'horizontal', x: word.x, y: word.y }, showCoordinates);
+};
+
+export const groupWords = (words: VerifiedWord[], query: string): GroupedWords => {
+  const regExp = createRegExp(query);
+
+  return words.reduce<GroupedWords>(
+    (groupedWords, word) => {
+      if (word.word.match(regExp)) {
+        groupedWords.matching.push(word);
+      } else {
+        groupedWords.other.push(word);
+      }
+
+      return groupedWords;
+    },
+    { matching: [], other: [] },
+  );
+};
+
+const comparators: Record<WordColumnId, ComparatorFactory<VerifiedWord>> = {
+  [WordColumnId.Coordinates]: (locale: string, showCoordinates: ShowCoordinates) => {
+    return createCoordinatesComparator({ getItemCoordinates: getWordCoordinates, locale, showCoordinates });
+  },
+  [WordColumnId.Validity]: () => (a, b) => {
+    return numberComparator(Number(a.isValid), Number(b.isValid));
+  },
+  [WordColumnId.Word]: (locale: string) => createKeyComparator('word', locale),
+};
+
+export const sortWords = (
+  words: VerifiedWord[],
+  sort: Sort<WordColumnId>,
+  locale: string,
+  showCoordinates: ShowCoordinates,
+): VerifiedWord[] => {
+  return [...words].sort(createSortComparator({ comparators, locale, showCoordinates, sort }));
+};

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

@@ -0,0 +1,46 @@
+import { createSelector } from '@reduxjs/toolkit';
+
+import { createRegExp } from '@/lib/createRegExp';
+
+import { selectLocale, selectShowCoordinates } from '../settings';
+import type { RootState } from '../types';
+
+import { getWordCoordinates, groupWords, sortWords } from './lib';
+
+const selectWordIndex = (_: unknown, index: number): number => index;
+
+export const selectVerify = (state: RootState) => state.verify;
+
+export const selectLastVerifiedBoard = createSelector([selectVerify], (verify) => verify.lastSolvedParameters.board);
+
+export const selectInvalidWords = createSelector([selectVerify], (verify) => verify.invalidWords);
+
+export const selectValidWords = createSelector([selectVerify], (verify) => verify.validWords);
+
+export const selectWordsQuery = createSelector([selectVerify], (verify) => verify.query);
+
+export const selectWordsSort = createSelector([selectVerify], (verify) => verify.sort);
+
+export const selectCreatedWords = createSelector([selectInvalidWords, selectValidWords], (invalidWords, validWords) => {
+  return [...invalidWords, ...validWords];
+});
+
+const selectSortedWords = createSelector(
+  [selectCreatedWords, selectWordsSort, selectLocale, selectShowCoordinates],
+  sortWords,
+);
+
+export const selectProcessedWords = createSelector([selectSortedWords, selectWordsQuery], (words, query) => {
+  const { matching, other } = groupWords(words, query);
+  return [...matching, ...other];
+});
+
+export const selectIsWordMatching = createSelector(
+  [selectProcessedWords, selectWordsQuery, selectWordIndex],
+  (words, query, index) => createRegExp(query).test(words[index].word),
+);
+
+export const selectWordCoordinates = createSelector(
+  [selectProcessedWords, selectShowCoordinates, selectWordIndex],
+  (words, showCoordinates, index) => getWordCoordinates(words[index], showCoordinates),
+);

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

@@ -0,0 +1,40 @@
+import { type PayloadAction, createSlice } from '@reduxjs/toolkit';
+import { type Board } from '@scrabble-solver/types';
+
+import { getNextSort } from '@/lib/getNextSort';
+import { type VerifiedWord, type WordColumnId } from '@/types';
+
+import { verifyInitialState } from './initialState';
+
+interface VerifyParameters {
+  board: Board;
+  invalidWords: VerifiedWord[];
+  validWords: VerifiedWord[];
+}
+
+export const verifySlice = createSlice({
+  initialState: verifyInitialState,
+  name: 'verify',
+  reducers: {
+    submit: (state) => {
+      return { ...state, isLoading: true };
+    },
+
+    changeQuery: (state, action: PayloadAction<string>) => {
+      return { ...state, query: action.payload };
+    },
+
+    submitFailure: (state) => {
+      return { ...state, isLoading: false };
+    },
+
+    sort: (state, action: PayloadAction<WordColumnId>) => {
+      return { ...state, sort: getNextSort(state.sort, action.payload) };
+    },
+
+    submitSuccess: (state, action: PayloadAction<VerifyParameters>) => {
+      const { board, invalidWords, validWords } = action.payload;
+      return { ...state, isLoading: false, lastSolvedParameters: { board }, invalidWords, validWords };
+    },
+  },
+});

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

@@ -0,0 +1,14 @@
+import type { Sort, VerifiedWord, WordColumnId } from '@/types';
+
+import type { BoardState } from '../board';
+
+export interface VerifyState {
+  isLoading: boolean;
+  lastSolvedParameters: {
+    board: BoardState;
+  };
+  invalidWords: VerifiedWord[];
+  query: string;
+  sort: Sort<WordColumnId>;
+  validWords: VerifiedWord[];
+}