@scrabble-solver/scrabble-solver 2.13.8 → 2.13.10

package/src/state/selectors.ts

@@ -12,7 +12,8 @@ import {
   getRemainingTiles,
   getRemainingTilesGroups,
   groupResults,
-  sortResults,
+  resultMatchesCellFilter,
+  sortGroupedResults,
   unorderedArraysEqual,
 } from 'lib';
 import { Point, Translations } from 'types';
@@ -75,8 +76,8 @@ export const selectConfig = createSelector([selectGame, selectLocale], getConfig
 
 export const selectFilteredCells = selectCellFilterRoot;
 
-export const selectCellIsFiltered = createSelector([selectFilteredCells, selectPoint], (cellFilter, { x, y }) => {
-  return cellFilter.some((cell) => cell.x === x && cell.y === y);
+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) => {
@@ -93,20 +94,23 @@ export const selectResultsQuery = createSelector([selectResultsRoot], (results)
 
 export const selectResultsSort = createSelector([selectResultsRoot], (results) => results.sort);
 
-export const selectSortedResults = createSelector([selectResultsRaw, selectResultsSort, selectLocale], sortResults);
-
 export const selectGroupedResults = createSelector(
-  [selectSortedResults, selectResultsQuery, selectFilteredCells],
+  [selectResultsRaw, selectResultsQuery, selectFilteredCells],
   groupResults,
 );
 
-export const selectResults = createSelector([selectGroupedResults], (groupedResults) => {
+export const selectGroupedSortedResults = createSelector(
+  [selectGroupedResults, selectResultsSort, selectLocale],
+  sortGroupedResults,
+);
+
+export const selectResults = createSelector([selectGroupedSortedResults], (groupedResults) => {
   return groupedResults ? [...groupedResults.matching, ...groupedResults.other] : groupedResults;
 });
 
 export const selectIsResultMatching = createSelector(
   [selectResults, selectResultsQuery, selectFilteredCells, selectResultIndex],
-  (results, query, filteredCells, index) => {
+  (results, query, cellFilter, index) => {
     if (!results) {
       return false;
     }
@@ -118,11 +122,7 @@ export const selectIsResultMatching = createSelector(
       return false;
     }
 
-    if (filteredCells) {
-      return filteredCells.every(({ x, y }) => result.cells.some((cell) => cell.x === x && cell.y === y));
-    }
-
-    return true;
+    return resultMatchesCellFilter(result, cellFilter);
   },
 );
 

package/src/state/slices/cellFilterInitialState.ts

@@ -1,6 +1,6 @@
-import { Point } from 'types';
+import { CellFilterEntry } from 'types';
 
-export type CellFilterState = Point[];
+export type CellFilterState = CellFilterEntry[];
 
 const cellFilterInitialState: CellFilterState = [];
 

package/src/state/slices/cellFilterSlice.ts

@@ -1,6 +1,6 @@
 import { createSlice, PayloadAction } from '@reduxjs/toolkit';
 
-import { Point } from 'types';
+import { CellFilterType, Point } from 'types';
 
 import cellFilterInitialState from './cellFilterInitialState';
 
@@ -10,17 +10,42 @@ const cellFilterSlice = createSlice({
   reducers: {
     toggle: (state, action: PayloadAction<Point>) => {
       const { x, y } = action.payload;
-      const has = state.some((point) => point.x === x && point.y === y);
+      const currentEntry = state.find((point) => point.x === x && point.y === y);
+      const has = Boolean(currentEntry);
+      const nextType = currentEntry ? toggleCellFilterState(currentEntry.type) : 'include';
 
-      if (has) {
+      if (nextType === null) {
         return state.filter((point) => point.x !== x || point.y !== y);
       }
 
-      return [...state, action.payload];
+      if (!has) {
+        return [...state, { ...action.payload, type: nextType }];
+      }
+
+      return state.map((entry) => {
+        if (entry.x === x && entry.y === y) {
+          return { ...entry, type: nextType };
+        }
+
+        return entry;
+      });
+    },
+
+    cancel: (state, action: PayloadAction<Point>) => {
+      const { x, y } = action.payload;
+
+      return state.filter((point) => point.x !== x || point.y !== y);
     },
 
     reset: () => cellFilterInitialState,
   },
 });
 
+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];
+};
+
 export default cellFilterSlice;

package/src/types/index.ts

@@ -1,7 +1,17 @@
+import { Result } from '@scrabble-solver/types';
+
 export type Comparator<T> = (a: T, B: T) => number;
 
 export type AutoGroupTiles = 'left' | 'right' | null;
 
+export type CellFilterType = 'include' | 'exclude';
+
+export type CellFilterEntry = {
+  x: Point['x'];
+  y: Point['y'];
+  type: CellFilterType;
+};
+
 export type Direction = 'horizontal' | 'vertical';
 
 export type InputMode = 'keyboard' | 'touchscreen';
@@ -47,9 +57,16 @@ export enum ResultColumn {
   Word = 'word',
   WordsCount = 'words-count',
 }
+
+export interface GroupedResults {
+  matching: Result[];
+  other: Result[];
+}
+
 export type TranslationKey =
   | 'cell.enter-word'
-  | 'cell.filter-cell'
+  | 'cell.filter-cell.exclude'
+  | 'cell.filter-cell.include'
   | 'cell.set-blank'
   | 'cell.set-not-blank'
   | 'cell.toggle-direction'