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

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

@@ -0,0 +1,49 @@
+import { type PayloadAction, createSlice } from '@reduxjs/toolkit';
+import type { Cell } from '@scrabble-solver/types';
+
+import type { Point } from '@/types';
+
+import { cellFiltersInitialState } from './initialState';
+import { toggleCellFilterState } from './lib';
+
+export const cellFiltersSlice = createSlice({
+  initialState: cellFiltersInitialState,
+  name: 'cellFilters',
+  reducers: {
+    toggle: (state, action: PayloadAction<Point>) => {
+      const { x, y } = action.payload;
+      const currentEntry = state.find((point) => point.x === x && point.y === y);
+      const has = Boolean(currentEntry);
+      const nextType = currentEntry ? toggleCellFilterState(currentEntry.type) : 'include';
+
+      if (nextType === null) {
+        return state.filter((point) => point.x !== x || point.y !== y);
+      }
+
+      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);
+    },
+
+    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,
+  },
+});

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

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

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

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

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

@@ -0,0 +1,34 @@
+import { type PayloadAction, createSlice } from '@reduxjs/toolkit';
+import { type WordDefinition } from '@scrabble-solver/types';
+
+import { dictionaryInitialState } from './initialState';
+
+export const dictionarySlice = createSlice({
+  initialState: dictionaryInitialState,
+  name: 'dictionary',
+  reducers: {
+    changeInput: (state, action: PayloadAction<string>) => {
+      return { ...state, input: action.payload };
+    },
+
+    reset: () => dictionaryInitialState,
+
+    submit: (state) => {
+      const error = dictionaryInitialState.error;
+      const results = dictionaryInitialState.results;
+      return { ...state, error, isLoading: true, results };
+    },
+
+    submitFailure: (state, action: PayloadAction<unknown>) => {
+      const error = action.payload;
+      const results = dictionaryInitialState.results;
+      return { ...state, error, isLoading: false, results };
+    },
+
+    submitSuccess: (state, action: PayloadAction<WordDefinition[]>) => {
+      const error = dictionaryInitialState.error;
+      const results = action.payload;
+      return { ...state, error, isLoading: false, results };
+    },
+  },
+});

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

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

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

@@ -0,0 +1,5 @@
+import type { HoveredTileState } from './types';
+
+export const hoveredTileInitialState: HoveredTileState = {
+  character: null,
+};

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

@@ -0,0 +1,3 @@
+import type { RootState } from '../types';
+
+export const selectHoveredCharacter = (state: RootState): string | null => state.hoveredTile.character;

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

@@ -0,0 +1,16 @@
+import { type PayloadAction, createSlice } from '@reduxjs/toolkit';
+
+import { hoveredTileInitialState } from './initialState';
+
+export const hoveredTileSlice = createSlice({
+  initialState: hoveredTileInitialState,
+  name: 'hoveredTile',
+  reducers: {
+    set: (state, action: PayloadAction<string>) => {
+      state.character = action.payload;
+    },
+    clear: (state) => {
+      state.character = null;
+    },
+  },
+});

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

@@ -0,0 +1,3 @@
+export interface HoveredTileState {
+  character: string | null;
+}

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

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

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

@@ -0,0 +1,5 @@
+import type { HoveredWordState } from './types';
+
+export const hoveredWordInitialState: HoveredWordState = {
+  word: null,
+};

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

@@ -0,0 +1,5 @@
+import type { VerifiedWord } from '@/types';
+
+import type { RootState } from '../types';
+
+export const selectHoveredWord = (state: RootState): VerifiedWord | null => state.hoveredWord.word;

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

@@ -0,0 +1,18 @@
+import { type PayloadAction, createSlice } from '@reduxjs/toolkit';
+
+import { type VerifiedWord } from '@/types';
+
+import { hoveredWordInitialState } from './initialState';
+
+export const hoveredWordSlice = createSlice({
+  initialState: hoveredWordInitialState,
+  name: 'hoveredWord',
+  reducers: {
+    set: (state, action: PayloadAction<VerifiedWord>) => {
+      state.word = action.payload;
+    },
+    clear: (state) => {
+      state.word = null;
+    },
+  },
+});

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

@@ -0,0 +1,5 @@
+import type { VerifiedWord } from '@/types';
+
+export interface HoveredWordState {
+  word: VerifiedWord | null;
+}

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

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

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

@@ -0,0 +1,5 @@
+import type { I18nState } from './types';
+
+export const i18nInitialState: I18nState = {
+  translations: {},
+};

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

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

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

@@ -0,0 +1,16 @@
+import { type PayloadAction, createSlice } from '@reduxjs/toolkit';
+import { type Locale } from '@scrabble-solver/types';
+
+import type { Translations } from '@/types';
+
+import { i18nInitialState } from './initialState';
+
+export const i18nSlice = createSlice({
+  initialState: i18nInitialState,
+  name: 'i18n',
+  reducers: {
+    loaded: (state, action: PayloadAction<{ locale: Locale; translations: Translations }>) => {
+      state.translations[action.payload.locale] = action.payload.translations;
+    },
+  },
+});

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

@@ -0,0 +1,7 @@
+import { type Locale } from '@scrabble-solver/types';
+
+import type { Translations } from '@/types';
+
+export interface I18nState {
+  translations: Partial<Record<Locale, Translations>>;
+}

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

@@ -0,0 +1,19 @@
+export * from './actions';
+export * from './app';
+export * from './board';
+export * from './cellFilters';
+export * from './dictionary';
+export * from './hoveredTile';
+export * from './hoveredWord';
+export * from './i18n';
+export * from './localStorage';
+export * from './rack';
+export * from './results';
+export * from './selectors';
+export * from './settings';
+export * from './solve';
+export * from './store';
+export * from './useTranslate';
+export * from './useTypedSelector';
+export * from './useTypedStore';
+export * from './verify';

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

@@ -0,0 +1,46 @@
+import { BLANK } from '@scrabble-solver/constants';
+import { type Board, type Config } from '@scrabble-solver/types';
+
+import { createKeyComparator } from '@/lib/createKeyComparator';
+import { type RemainingTile } from '@/types';
+
+export const getRemainingTiles = (
+  config: Config,
+  board: Board,
+  characters: string[],
+  locale: string,
+): RemainingTile[] => {
+  const nonEmptyCells = board.rows.flat().filter((cell) => !cell.isEmpty);
+  const letterCells = nonEmptyCells.filter((cell) => !cell.tile.isBlank);
+  const remainingTiles = Object.fromEntries(config.tiles.map((tile) => [tile.character, { ...tile, usedCount: 0 }]));
+  const blank: RemainingTile = {
+    character: BLANK,
+    count: config.blanksCount,
+    score: config.blankScore,
+    usedCount:
+      nonEmptyCells.filter((cell) => cell.tile.isBlank).length +
+      characters.filter((character) => character === BLANK).length,
+  };
+  const letters = [
+    ...letterCells.map((cell) => cell.tile.character),
+    ...characters.filter((letter) => letter !== BLANK),
+  ];
+  const unknownLetters = letters.filter((letter) => typeof remainingTiles[letter] === 'undefined');
+
+  for (const letter of unknownLetters) {
+    remainingTiles[letter] = {
+      character: letter,
+      count: 0,
+      score: 0,
+      usedCount: 0,
+    };
+  }
+
+  for (const letter of letters) {
+    ++remainingTiles[letter].usedCount;
+  }
+
+  const comparator = createKeyComparator('character', locale);
+
+  return [...Object.values(remainingTiles).sort(comparator), blank];
+};

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

@@ -0,0 +1,142 @@
+import { type BoardJson, type Locale, Board, isObject } from '@scrabble-solver/types';
+import store2 from 'store2';
+
+import { englishTranslations } from '@/i18n/i18n';
+import type { Rack, TranslationKey, Translations } from '@/types';
+
+import type { SettingsState } from './settings/types';
+
+const BOARD = 'board';
+const RACK = 'rack';
+const SETTINGS = 'settings';
+const TRANSLATIONS = 'translations';
+
+interface PersistedTranslations {
+  locale: Locale;
+  translations: Translations;
+  version: string;
+}
+
+const LEGACY_KEYS: Record<keyof SettingsState, string> = {
+  autoGroupTiles: 'auto-group-tiles',
+  game: 'config-id',
+  highlightUnreachableCells: 'highlight-unreachable-cells',
+  inputMode: 'input-mode',
+  locale: 'locale',
+  removeCellFilters: 'remove-cell-filters',
+  showCoordinates: 'show-coordinates',
+};
+
+const store = store2.namespace('scrabble-solver');
+
+export const localStorage = {
+  getBoard(): Board | undefined {
+    try {
+      const serialized = store.get(BOARD) as string | undefined;
+      return serialized ? Board.fromJson(JSON.parse(serialized) as BoardJson) : undefined;
+    } catch {
+      store.remove(BOARD);
+      return undefined;
+    }
+  },
+
+  setBoard(board: Board | undefined): void {
+    const serialized = board ? JSON.stringify(board.toJson()) : board;
+    store.set(BOARD, serialized, true);
+  },
+
+  getRack(): Rack | undefined {
+    const rack = store.get(RACK) as Rack | undefined;
+
+    if (rack !== undefined && !Array.isArray(rack)) {
+      store.remove(RACK);
+      return undefined;
+    }
+
+    return rack;
+  },
+
+  setRack(rack: Rack | undefined): void {
+    store.set(RACK, rack, true);
+  },
+
+  getSettings(): Partial<SettingsState> {
+    const stored = store.get(SETTINGS) as Partial<SettingsState> | undefined;
+
+    if (stored !== undefined && !isObject(stored)) {
+      store.remove(SETTINGS);
+    }
+
+    return migrateHiddenShowCoordinates(isObject(stored) ? stored : migrateLegacySettings());
+  },
+
+  setSettings(settings: SettingsState): void {
+    store.set(SETTINGS, settings, true);
+  },
+
+  getTranslations(locale: Locale, version: string): Translations | undefined {
+    const stored = store.get(TRANSLATIONS) as PersistedTranslations | undefined;
+
+    if (typeof stored === 'undefined') {
+      return undefined;
+    }
+
+    if (
+      !isObject(stored) ||
+      stored.locale !== locale ||
+      stored.version !== version ||
+      !isObject(stored.translations) ||
+      !hasEveryTranslation(stored.translations)
+    ) {
+      store.remove(TRANSLATIONS);
+      return undefined;
+    }
+
+    return stored.translations;
+  },
+
+  setTranslations(locale: Locale, version: string, translations: Translations): void {
+    store.set(TRANSLATIONS, { locale, translations, version } satisfies PersistedTranslations, true);
+  },
+};
+
+function hasEveryTranslation(translations: Translations): boolean {
+  return (Object.keys(englishTranslations) as TranslationKey[]).every((key) => typeof translations[key] === 'string');
+}
+
+/**
+ * Introduced in 2.15.26 on 2026/04/27.
+ * Life expectancy: 1y.
+ */
+function migrateLegacySettings(): Partial<SettingsState> {
+  const settings: Partial<SettingsState> = {};
+  let hasLegacy = false;
+
+  for (const [setting, legacyKey] of Object.entries(LEGACY_KEYS) as [keyof SettingsState, string][]) {
+    if (store.has(legacyKey)) {
+      settings[setting] = store.get(legacyKey);
+      store.remove(legacyKey);
+      hasLegacy = true;
+    }
+  }
+
+  if (hasLegacy) {
+    store.set(SETTINGS, settings, true);
+  }
+
+  return settings;
+}
+
+/**
+ * The 'hidden' showCoordinates option was removed on 2026/08/13.
+ * Life expectancy: 1y.
+ */
+function migrateHiddenShowCoordinates(settings: Partial<SettingsState>): Partial<SettingsState> {
+  if (String(settings.showCoordinates) !== 'hidden') {
+    return settings;
+  }
+
+  const migrated: Partial<SettingsState> = { ...settings, showCoordinates: 'original' };
+  store.set(SETTINGS, migrated, true);
+  return migrated;
+}

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

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

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

@@ -0,0 +1,11 @@
+import { getConfig } from '@scrabble-solver/configs';
+
+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 = rackDefaultState;

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

@@ -0,0 +1,56 @@
+import { type PayloadAction, createSlice } from '@reduxjs/toolkit';
+import { type Tile } from '@scrabble-solver/types';
+
+import { arrayEquals } from '@/lib/arrayEquals';
+import { createNullMovingComparator } from '@/lib/createNullMovingComparator';
+import { inverseDirection } from '@/lib/inverseDirection';
+import { zipCharactersAndTiles } from '@/lib/zipCharactersAndTiles';
+import { type AutoGroupTiles, type Rack } from '@/types';
+
+import { rackDefaultState, rackInitialState } from './initialState';
+
+export const rackSlice = createSlice({
+  initialState: rackInitialState,
+  name: 'rack',
+  reducers: {
+    changeCharacter: (state, action: PayloadAction<{ character: string | null; index: number }>) => {
+      const { character, index } = action.payload;
+      return [...state.slice(0, index), character, ...state.slice(index + 1)];
+    },
+
+    changeCharacters: (state, action: PayloadAction<{ characters: Rack; index: number }>) => {
+      const { characters, index } = action.payload;
+
+      if (characters.length === 0) {
+        return state;
+      }
+
+      const expectedRackLength = state.length;
+      const rack = [...state.slice(0, index), ...characters, ...state.slice(index + characters.length)];
+      return rack.slice(0, expectedRackLength);
+    },
+
+    groupTiles: (state, action: PayloadAction<AutoGroupTiles>) => {
+      if (action.payload === null) {
+        return state;
+      }
+
+      const nullMovingComparator = createNullMovingComparator(inverseDirection(action.payload));
+      const sortedTiles = [...state].sort(nullMovingComparator);
+      return arrayEquals(state, sortedTiles) ? state : sortedTiles;
+    },
+
+    init: (state, action: PayloadAction<Rack>) => {
+      return arrayEquals(state, action.payload) ? state : action.payload;
+    },
+
+    removeTiles: (state, action: PayloadAction<Tile[]>) => {
+      const tilesToRemove = action.payload;
+      const charactersAndTiles = zipCharactersAndTiles(state, tilesToRemove);
+      const charactersWithoutMatchingTiles = charactersAndTiles.map(({ character, tile }) => (tile ? null : character));
+      return charactersWithoutMatchingTiles;
+    },
+
+    reset: () => rackDefaultState,
+  },
+});

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

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

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

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

package/packages/scrabble-solver/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,
+  },
+};