@scrabble-solver/scrabble-solver 2.15.10 → 2.15.12

package/src/service-worker/dictionaries/revalidateDictionary.ts

@@ -1,4 +1,4 @@
-import { Locale } from '@scrabble-solver/types';
+import { type Locale } from '@scrabble-solver/types';
 
 import { DICTIONARY_CACHE } from './constants';
 import { expirationManager } from './expirationManager';

package/src/service-worker/getTrie.ts

@@ -1,5 +1,5 @@
 import { Trie } from '@kamilmielnik/trie';
-import { Locale } from '@scrabble-solver/types';
+import { type Locale } from '@scrabble-solver/types';
 
 import { getDictionary } from './dictionaries';
 

package/src/service-worker/routeSolveRequests.ts

@@ -1,11 +1,11 @@
-import { Trie } from '@kamilmielnik/trie';
+import { type Trie } from '@kamilmielnik/trie';
 import { getConfig } from '@scrabble-solver/configs';
 import { BLANK } from '@scrabble-solver/constants';
 import { solve } from '@scrabble-solver/solver';
 import { Board, Tile } from '@scrabble-solver/types';
 import { registerRoute } from 'workbox-routing';
 
-import { SolveRequestPayload } from 'types';
+import { type SolveRequestPayload } from 'types';
 
 import { average } from './average';
 import { revalidateDictionary } from './dictionaries';

package/src/service-worker/routeVerifyRequests.ts

@@ -1,7 +1,7 @@
 import { Board } from '@scrabble-solver/types';
 import { registerRoute } from 'workbox-routing';
 
-import { VerifyRequestPayload } from 'types';
+import { type VerifyRequestPayload } from 'types';
 
 import { revalidateDictionary } from './dictionaries';
 import { getTrie } from './getTrie';

package/src/state/board/index.ts

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

package/src/state/{slices/boardInitialState.ts → board/initialState.ts}

@@ -2,17 +2,14 @@ import { getConfig } from '@scrabble-solver/configs';
 import { Board } from '@scrabble-solver/types';
 
 import { localStorage } from '../localStorage';
+import { settingsInitialState } from '../settings';
 
-import { settingsInitialState } from './settingsInitialState';
-
-export type BoardState = Board;
+import type { BoardState } from './types';
 
 const { game, locale } = settingsInitialState;
 const { boardHeight, boardWidth } = getConfig(game, locale);
 
-export const boardDefaultState = Board.create(boardWidth, boardHeight);
-
-export const boardInitialState: BoardState = localStorage.getBoard() || boardDefaultState;
+export const boardInitialState: BoardState = localStorage.getBoard() ?? Board.create(boardWidth, boardHeight);
 
 // const createOxyphenbutazone = () => {
 //   // Tiles: oypbaze

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;
+}