@scrabble-solver/scrabble-solver 2.15.11 → 2.15.13

package/src/components/Tooltip/TooltipContent.tsx

@@ -1,5 +1,5 @@
 import { FloatingArrow, FloatingPortal, useDelayGroup, useMergeRefs, useTransitionStyles } from '@floating-ui/react';
-import { forwardRef, HTMLProps } from 'react';
+import { forwardRef, type HTMLProps } from 'react';
 
 import { TOOLTIP_DURATION } from 'parameters';
 

package/src/components/Tooltip/TooltipTrigger.tsx

@@ -1,6 +1,6 @@
 import { useMergeRefs } from '@floating-ui/react';
 import { isObject } from '@scrabble-solver/types';
-import { HTMLProps, ReactElement, RefObject, cloneElement, forwardRef, isValidElement } from 'react';
+import { type HTMLProps, type ReactElement, type RefObject, cloneElement, forwardRef, isValidElement } from 'react';
 
 import { useTooltipContext } from './context';
 

package/src/components/Tooltip/context.ts

@@ -1,6 +1,6 @@
 import { createContext, useContext } from 'react';
 
-import { useTooltip } from './useTooltip';
+import { type useTooltip } from './useTooltip';
 
 type TooltipContextType = ReturnType<typeof useTooltip> | null;
 

package/src/components/Tooltip/useTooltip.ts

@@ -1,5 +1,5 @@
 import {
-  Placement,
+  type Placement,
   arrow,
   autoUpdate,
   flip,

package/src/hooks/useAppLayout.ts

@@ -20,7 +20,7 @@ import {
   TEXT_INPUT_HEIGHT,
 } from 'parameters';
 import { selectConfig, selectShowCoordinates, useTypedSelector } from 'state';
-import { ResultColumnId } from 'types';
+import { type ResultColumnId } from 'types';
 
 import { useColumns } from './useColumns';
 import { useIsTouchDevice } from './useIsTouchDevice';

package/src/hooks/useColumns.ts

@@ -1,6 +1,8 @@
+import { createSelector } from '@reduxjs/toolkit';
 import { useMemo } from 'react';
 
-import { selectColumns, useTypedSelector } from 'state';
+import { LOCALE_FEATURES } from 'i18n';
+import { selectLocale, selectShowCoordinates, useTypedSelector } from 'state';
 import { ResultColumnId } from 'types';
 
 import { useMediaQueries } from './useMediaQueries';
@@ -13,6 +15,31 @@ const COLUMNS_M = [...COLUMNS_XS];
 
 const COLUMNS_L = [...COLUMNS_XS];
 
+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;
+});
+
 export const useColumns = (): Partial<Record<ResultColumnId, boolean>> => {
   const columns = useTypedSelector(selectColumns);
   const { isLessThanXs, isLessThanS, isLessThanM, isLessThanL } = useMediaQueries();

package/src/hooks/useEffectOnce.ts

@@ -1,4 +1,4 @@
-import { EffectCallback, useEffect } from 'react';
+import { type EffectCallback, useEffect } from 'react';
 
 import { useLatest } from './useLatest';
 

package/src/hooks/useLocalStorage.ts

@@ -9,6 +9,7 @@ import {
   selectLocale,
   selectRack,
   selectShowCoordinates,
+  selectRemoveCellFilters,
   useTypedSelector,
 } from 'state';
 
@@ -20,6 +21,7 @@ export const useLocalStorage = () => {
   const locale = useTypedSelector(selectLocale);
   const rack = useTypedSelector(selectRack);
   const showCoordinates = useTypedSelector(selectShowCoordinates);
+  const removeCellFilters = useTypedSelector(selectRemoveCellFilters);
 
   useEffect(() => {
     if (autoGroupTiles) {
@@ -62,4 +64,10 @@ export const useLocalStorage = () => {
       localStorage.setShowCoordinates(showCoordinates);
     }
   }, [showCoordinates]);
+
+  useEffect(() => {
+    if (removeCellFilters) {
+      localStorage.setRemoveCellFilters(removeCellFilters);
+    }
+  }, [removeCellFilters]);
 };

package/src/i18n/constants.ts

@@ -1,6 +1,6 @@
 import { COMMA_ARABIC, COMMA_LATIN } from '@scrabble-solver/constants';
 import { Locale } from '@scrabble-solver/types';
-import { FunctionComponent, SVGAttributes } from 'react';
+import { type FunctionComponent, type SVGAttributes } from 'react';
 
 import { FlagDe, FlagEs, FlagFa, FlagFr, FlagGb, FlagPl, FlagRo, FlagTr, FlagUs } from 'icons';
 

package/src/i18n/i18n.ts

@@ -1,6 +1,6 @@
 import { Locale } from '@scrabble-solver/types';
 
-import { Translations } from 'types';
+import { type Translations } from 'types';
 
 import english from './languages/english.json';
 import french from './languages/french.json';

package/src/i18n/languages/english.json

@@ -68,6 +68,9 @@
   "settings.inputMode.keyboard": "Keyboard",
   "settings.inputMode.touchscreen": "Touchscreen",
   "settings.language": "Language",
+  "settings.removeCellFilters": "Automatically remove filters from board",
+  "settings.removeCellFilters.always": "Always",
+  "settings.removeCellFilters.never": "Never",
   "settings.showCoordinates": "Coordinates",
   "settings.showCoordinates.alternative": "Alternative",
   "settings.showCoordinates.hidden": "Hidden",

package/src/i18n/languages/french.json

@@ -68,6 +68,9 @@
   "settings.inputMode.keyboard": "Clavier",
   "settings.inputMode.touchscreen": "Écran tactile",
   "settings.language": "Langue",
+  "settings.removeCellFilters": "Supprimer automatiquement les filtres du plateau",
+  "settings.removeCellFilters.always": "Toujours",
+  "settings.removeCellFilters.never": "Jamais",
   "settings.showCoordinates": "Coordonnés",
   "settings.showCoordinates.alternative": "Alternative",
   "settings.showCoordinates.hidden": "Caché",

package/src/i18n/languages/german.json

@@ -68,6 +68,9 @@
   "settings.inputMode.keyboard": "Tastatur",
   "settings.inputMode.touchscreen": "Touchscreen",
   "settings.language": "Sprache",
+  "settings.removeCellFilters": "Filter automatisch vom Spielbrett entfernen",
+  "settings.removeCellFilters.always": "Immer",
+  "settings.removeCellFilters.never": "Nie",
   "settings.showCoordinates": "Koordinaten",
   "settings.showCoordinates.alternative": "Alternative",
   "settings.showCoordinates.hidden": "Versteckt",

package/src/i18n/languages/persian.json

@@ -68,6 +68,9 @@
   "settings.inputMode.keyboard": "صفحه کلید",
   "settings.inputMode.touchscreen": "صفحه لمسی",
   "settings.language": "زبان",
+  "settings.removeCellFilters": "فیلترها را به‌صورت خودکار از صفحه بازی حذف کن",
+  "settings.removeCellFilters.always": "همیشه",
+  "settings.removeCellFilters.never": "هرگز",
   "settings.showCoordinates": "مختصات",
   "settings.showCoordinates.alternative": "بديل",
   "settings.showCoordinates.hidden": "مختفي",

package/src/i18n/languages/polish.json

@@ -68,6 +68,9 @@
   "settings.inputMode.keyboard": "Klawiatura",
   "settings.inputMode.touchscreen": "Ekran dotykowy",
   "settings.language": "Język",
+  "settings.removeCellFilters": "Automatycznie usuwaj filtry z planszy",
+  "settings.removeCellFilters.always": "Zawsze",
+  "settings.removeCellFilters.never": "Nigdy",
   "settings.showCoordinates": "Współrzędne",
   "settings.showCoordinates.alternative": "Alternatywne",
   "settings.showCoordinates.hidden": "Ukryte",

package/src/i18n/languages/romanian.json

@@ -68,6 +68,9 @@
   "settings.inputMode.keyboard": "Tastatura",
   "settings.inputMode.touchscreen": "Ecran",
   "settings.language": "Limba",
+  "settings.removeCellFilters": "Elimină automat filtrele de pe tablă",
+  "settings.removeCellFilters.always": "Întotdeauna",
+  "settings.removeCellFilters.never": "Niciodată",
   "settings.showCoordinates": "Coordonate",
   "settings.showCoordinates.alternative": "Alternativă",
   "settings.showCoordinates.hidden": "Ascuns",

package/src/i18n/languages/spanish.json

@@ -68,6 +68,9 @@
   "settings.inputMode.keyboard": "Teclado",
   "settings.inputMode.touchscreen": "Pantalla táctil",
   "settings.language": "Idioma",
+  "settings.removeCellFilters": "Eliminar automáticamente los filtros del tablero",
+  "settings.removeCellFilters.always": "Siempre",
+  "settings.removeCellFilters.never": "Nunca",
   "settings.showCoordinates": "Coordenadas",
   "settings.showCoordinates.alternative": "Alternativa",
   "settings.showCoordinates.hidden": "Oculto",

package/src/i18n/languages/turkish.json

@@ -68,6 +68,9 @@
   "settings.inputMode.keyboard": "Klavye",
   "settings.inputMode.touchscreen": "Dokunmatik ekran",
   "settings.language": "Dil",
+  "settings.removeCellFilters": "Tahtadan filtreleri otomatik olarak kaldır",
+  "settings.removeCellFilters.always": "Her zaman",
+  "settings.removeCellFilters.never": "Asla",
   "settings.showCoordinates": "Koordinatlar",
   "settings.showCoordinates.alternative": "Alternatif",
   "settings.showCoordinates.hidden": "Gizlenmiş",

package/src/lib/createComparator.ts

@@ -1,4 +1,4 @@
-import { Comparator } from 'types';
+import type { Comparator } from 'types';
 
 import { createStringComparator } from './createStringComparator';
 import { numberComparator } from './numberComparator';

package/src/lib/createKeyComparator.ts

@@ -1,4 +1,4 @@
-import { Comparator } from 'types';
+import { type Comparator } from 'types';
 
 import { createStringComparator } from './createStringComparator';
 import { numberComparator } from './numberComparator';

package/src/lib/createKeyboardNavigation.ts

@@ -1,4 +1,4 @@
-import { KeyboardEventHandler } from 'react';
+import { type KeyboardEventHandler } from 'react';
 
 import { noop } from './noop';
 

package/src/lib/createStringComparator.ts

@@ -1,4 +1,4 @@
-import { Comparator } from 'types';
+import { type Comparator } from 'types';
 
 export const createStringComparator: (locale: string) => Comparator<string> = (locale) => {
   return (a, b) => {

package/src/lib/extractCharacters.test.ts

@@ -4,22 +4,49 @@ import { Game, Locale } from '@scrabble-solver/types';
 
 import { extractCharacters } from './extractCharacters';
 
-const tests = [
-  { input: 'ab ', expected: ['a', 'b', BLANK] },
-  { input: 'śćźa', expected: ['s', 'c', 'z', 'a'] },
-  { input: 'bañó', expected: ['b', 'a', 'ñ', 'o'] },
-  { input: 'bueno', expected: ['b', 'u', 'e', 'n', 'o'] },
-  { input: 'bellas', expected: ['b', 'e', 'll', 'a', 's'] },
-  { input: 'BELLAS', expected: ['b', 'e', 'll', 'a', 's'] },
-  { input: 'churro', expected: ['ch', 'u', 'rr', 'o'] },
-  { input: 'challulla', expected: ['ch', 'a', 'll', 'u', 'll', 'a'] },
-];
+describe('upperCaseDigraphsOnly = false', () => {
+  describe('extractCharacters', () => {
+    const locale = Locale.ES_ES;
+    const config = getConfig(Game.Scrabble, locale);
 
-describe('extractCharacters', () => {
-  const locale = Locale.ES_ES;
-  const config = getConfig(Game.Scrabble, locale);
+    it.each([
+      { input: 'ab ', expected: ['a', 'b', BLANK] },
+      { input: 'śćźa', expected: ['s', 'c', 'z', 'a'] },
+      { input: 'bañó', expected: ['b', 'a', 'ñ', 'o'] },
+      { input: 'bueno', expected: ['b', 'u', 'e', 'n', 'o'] },
+      { input: 'bellas', expected: ['b', 'e', 'll', 'a', 's'] },
+      { input: 'BELLAS', expected: ['b', 'e', 'll', 'a', 's'] },
+      { input: 'churro', expected: ['ch', 'u', 'rr', 'o'] },
+      { input: 'challulla', expected: ['ch', 'a', 'll', 'u', 'll', 'a'] },
+    ])(`[${locale}] "$input"`, ({ input, expected }) => {
+      expect(extractCharacters(config, input)).toEqual(expected);
+    });
+  });
+
+  describe('upperCaseDigraphsOnly = true', () => {
+    const locale = Locale.ES_ES;
+    const config = getConfig(Game.Scrabble, locale);
 
-  it.each(tests)(`[${locale}] "$input"`, ({ input, expected }) => {
-    expect(extractCharacters(config, input)).toEqual(expected);
+    it.each([
+      { input: 'ab ', expected: ['a', 'b', BLANK] },
+      { input: 'śćźa', expected: ['s', 'c', 'z', 'a'] },
+      { input: 'bañó', expected: ['b', 'a', 'ñ', 'o'] },
+      { input: 'bueno', expected: ['b', 'u', 'e', 'n', 'o'] },
+      { input: 'bellas', expected: ['b', 'e', 'l', 'l', 'a', 's'] },
+      { input: 'churro', expected: ['c', 'h', 'u', 'r', 'r', 'o'] },
+      { input: 'challulla', expected: ['c', 'h', 'a', 'l', 'l', 'u', 'l', 'l', 'a'] },
+      { input: 'beLlas', expected: ['b', 'e', 'l', 'l', 'a', 's'] },
+      { input: 'belLas', expected: ['b', 'e', 'l', 'l', 'a', 's'] },
+      { input: 'beLLas', expected: ['b', 'e', 'll', 'a', 's'] },
+      { input: 'chuRRo', expected: ['c', 'h', 'u', 'rr', 'o'] },
+      { input: 'CHuRRo', expected: ['ch', 'u', 'rr', 'o'] },
+      { input: 'CHaLLuLLa', expected: ['ch', 'a', 'll', 'u', 'll', 'a'] },
+    ])(`[${locale}] "$input"`, ({ input, expected }) => {
+      expect(
+        extractCharacters(config, input, {
+          upperCaseDigraphsOnly: true,
+        }),
+      ).toEqual(expected);
+    });
   });
 });

package/src/lib/extractCharacters.ts

@@ -1,35 +1,33 @@
 import { BLANK } from '@scrabble-solver/constants';
-import { Config, Locale } from '@scrabble-solver/types';
-import { transliterate } from 'transliteration';
-
-const transliteratePerLocale: Record<Locale, (word: string) => string> = {
-  [Locale.DE_DE]: (word) => word,
-  [Locale.EN_GB]: (word) => word,
-  [Locale.EN_US]: (word) => word,
-  [Locale.ES_ES]: (word) => transliterate(word, { ignore: ['ñ'] }),
-  [Locale.FA_IR]: (word) => word,
-  [Locale.FR_FR]: (word) => transliterate(word),
-  [Locale.PL_PL]: (word) => word,
-  [Locale.RO_RO]: (word) => transliterate(word),
-  [Locale.TR_TR]: (word) => word,
-};
+import { type Config, type Locale } from '@scrabble-solver/types';
+
+import { localeTransliterate } from './localeTransliterate';
+
+interface Options {
+  upperCaseDigraphsOnly?: boolean;
+}
 
-export const extractCharacters = (config: Config, value: string): string[] => {
+export const extractCharacters = (config: Config, value: string, options?: Options): string[] => {
   let index = 0;
   const characters: string[] = [];
-  const localeTransliterate = transliteratePerLocale[config.locale];
-  const valueLowercase = localeTransliterate(value.toLocaleLowerCase(config.locale));
+  const finalValue = localeTransliterate(config.locale, value);
 
-  while (index < valueLowercase.length) {
-    const character = valueLowercase[index];
-    const nextCharacter = valueLowercase[index + 1];
+  while (index < finalValue.length) {
+    const character = finalValue[index];
+    const characterLowercase = character.toLocaleLowerCase(config.locale);
+    const nextCharacter = finalValue[index + 1];
     const digraph = `${character}${nextCharacter}`;
+    const digraphLowercase = digraph.toLocaleLowerCase(config.locale);
 
-    if (config.twoCharacterTiles.includes(digraph)) {
-      characters.push(digraph);
-      index += digraph.length;
-    } else if (config.hasCharacter(character) || character === BLANK) {
-      characters.push(character);
+    const isValidDigraph = options?.upperCaseDigraphsOnly
+      ? config.twoCharacterTiles.includes(digraphLowercase) && isUpperCase(config.locale, digraph)
+      : config.twoCharacterTiles.includes(digraphLowercase);
+
+    if (isValidDigraph) {
+      characters.push(digraphLowercase);
+      index += digraphLowercase.length;
+    } else if (config.hasCharacter(characterLowercase) || characterLowercase === BLANK) {
+      characters.push(characterLowercase);
       ++index;
     } else {
       ++index;
@@ -38,3 +36,7 @@ export const extractCharacters = (config: Config, value: string): string[] => {
 
   return characters;
 };
+
+const isUpperCase = (locale: Locale, value: string): boolean => {
+  return value === value.toLocaleUpperCase(locale);
+};

package/src/lib/findCell.ts

@@ -1,4 +1,4 @@
-import { Cell } from '@scrabble-solver/types';
+import { type Cell } from '@scrabble-solver/types';
 
 export const findCell = (cells: Cell[], x: number, y: number): Cell | undefined => {
   return cells.find((cell) => cell.x === x && cell.y === y);

package/src/lib/index.ts

@@ -1,39 +1,24 @@
 export { arrayEquals } from './arrayEquals';
-export { createArray } from './createArray';
 export { createComparator } from './createComparator';
-export { createGridOf } from './createGridOf';
-export { createKeyComparator } from './createKeyComparator';
 export { createKeyboardNavigation } from './createKeyboardNavigation';
+export { createKeyComparator } from './createKeyComparator';
 export { createNullMovingComparator } from './createNullMovingComparator';
 export { createRegExp } from './createRegExp';
 export { createStringComparator } from './createStringComparator';
-export { detectLocale } from './detectLocale';
 export { extractCharacters } from './extractCharacters';
-export { extractCharactersByCase } from './extractCharactersByCase';
 export { extractInputValue } from './extractInputValue';
 export { findCell } from './findCell';
-export { getCellSize } from './getCellSize';
 export { getCoordinate } from './getCoordinate';
-export { getCoordinates } from './getCoordinates';
-export { getRemainingTiles } from './getRemainingTiles';
-export { getRemainingTilesCount } from './getRemainingTilesCount';
-export { getRemainingTilesGroups } from './getRemainingTilesGroups';
 export { getTileSizes } from './getTileSizes';
-export { getTotalRemainingTilesCount } from './getTotalRemainingTilesCount';
-export { groupResults } from './groupResults';
-export { guessLocale } from './guessLocale';
 export { inverseDirection } from './inverseDirection';
 export { isCtrl } from './isCtrl';
 export { isMac } from './isMac';
 export { isRegExp } from './isRegExp';
 export { isStringArray } from './isStringArray';
-export { isUpperCase } from './isUpperCase';
+export { localeTransliterate } from './localeTransliterate';
 export { memoize } from './memoize';
 export { noop } from './noop';
 export { numberComparator } from './numberComparator';
-export { resultMatchesCellFilter } from './resultMatchesCellFilter';
 export { reverseComparator } from './reverseComparator';
-export { sortGroupedResults } from './sortGroupedResults';
-export { sortResults } from './sortResults';
 export { unorderedArraysEqual } from './unorderedArraysEqual';
 export { zipCharactersAndTiles } from './zipCharactersAndTiles';

package/src/lib/isCtrl.ts

@@ -1,4 +1,4 @@
-import { KeyboardEvent } from 'react';
+import { type KeyboardEvent } from 'react';
 
 export const isCtrl = <T>(event: KeyboardEvent<T> | globalThis.KeyboardEvent): boolean => {
   return event.ctrlKey || event.metaKey;

package/src/lib/localeTransliterate.test.ts

@@ -0,0 +1,14 @@
+import { Locale } from '@scrabble-solver/types';
+
+import { localeTransliterate } from './localeTransliterate';
+
+describe('localeTransliterate', () => {
+  it.each([
+    { locale: Locale.ES_ES, word: 'bañó', expected: 'baño' },
+    { locale: Locale.FR_FR, word: 'très', expected: 'tres' },
+    { locale: Locale.PL_PL, word: 'źdźbło', expected: 'źdźbło' },
+    { locale: Locale.RO_RO, word: 'mămăligă', expected: 'mamaliga' },
+  ])(`[$locale] "$word"`, ({ locale, word, expected }) => {
+    expect(localeTransliterate(locale, word)).toEqual(expected);
+  });
+});

package/src/lib/localeTransliterate.ts

@@ -0,0 +1,18 @@
+import { Locale } from '@scrabble-solver/types';
+import { transliterate } from 'transliteration';
+
+const transliteratePerLocale: Record<Locale, (word: string) => string> = {
+  [Locale.DE_DE]: (word) => word,
+  [Locale.EN_GB]: (word) => word,
+  [Locale.EN_US]: (word) => word,
+  [Locale.ES_ES]: (word) => transliterate(word, { ignore: ['ñ', 'Ñ'] }),
+  [Locale.FA_IR]: (word) => word,
+  [Locale.FR_FR]: (word) => transliterate(word),
+  [Locale.PL_PL]: (word) => word,
+  [Locale.RO_RO]: (word) => transliterate(word),
+  [Locale.TR_TR]: (word) => word,
+};
+
+export const localeTransliterate = (locale: Locale, value: string): string => {
+  return transliteratePerLocale[locale](value);
+};

package/src/lib/numberComparator.ts

@@ -1,3 +1,3 @@
-import { Comparator } from 'types';
+import { type Comparator } from 'types';
 
 export const numberComparator: Comparator<number> = (a, b) => a - b;

package/src/lib/reverseComparator.ts

@@ -1,4 +1,4 @@
-import { Comparator } from 'types';
+import { type Comparator } from 'types';
 
 export const reverseComparator = <T>(comparator: Comparator<T>): Comparator<T> => {
   return (a: T, b: T): number => -comparator(a, b);

package/src/lib/zipCharactersAndTiles.ts

@@ -1,7 +1,7 @@
 import { BLANK } from '@scrabble-solver/constants';
-import { Tile } from '@scrabble-solver/types';
+import { type Tile } from '@scrabble-solver/types';
 
-import { Rack } from 'types';
+import { type Rack } from 'types';
 
 interface CharacterTilePair {
   character: string | null;

package/src/modals/DictionaryModal/DictionaryModal.tsx

@@ -1,4 +1,4 @@
-import { FunctionComponent, memo } from 'react';
+import { type FunctionComponent, memo } from 'react';
 
 import { Dictionary, DictionaryInput, Modal } from 'components';
 import { useTranslate } from 'state';

package/src/modals/KeyMapModal/KeyMapModal.tsx

@@ -1,4 +1,4 @@
-import { FunctionComponent, memo } from 'react';
+import { type FunctionComponent, memo } from 'react';
 
 import { Arrows, Backspace, Ctrl, Del, Enter, Key, Modal, Space } from 'components';
 import { selectConfig, useTranslate, useTypedSelector } from 'state';

package/src/modals/KeyMapModal/components/Mapping/Mapping.tsx

@@ -1,5 +1,5 @@
 import classNames from 'classnames';
-import { Fragment, FunctionComponent, ReactNode } from 'react';
+import { Fragment, type FunctionComponent, type ReactNode } from 'react';
 
 import styles from './Mapping.module.scss';
 

package/src/modals/MenuModal/MenuModal.tsx

@@ -1,4 +1,4 @@
-import { FunctionComponent, memo } from 'react';
+import { type FunctionComponent, memo } from 'react';
 
 import { Button, Modal } from 'components';
 import { LOCALE_FEATURES } from 'i18n';

package/src/modals/RemainingTilesModal/RemainingTilesModal.tsx

@@ -1,13 +1,14 @@
-import { FunctionComponent, memo } from 'react';
+import { type FunctionComponent, memo } from 'react';
 
 import { Badge, Modal } from 'components';
 import { LOCALE_FEATURES } from 'i18n';
 import { getTileSizes } from 'lib';
 import { REMAINING_TILES_TILE_SIZE } from 'parameters';
-import { selectLocale, selectRemainingTilesGroups, useTranslate, useTypedSelector } from 'state';
+import { selectLocale, useTranslate, useTypedSelector } from 'state';
 
 import { Character } from './components';
 import styles from './RemainingTilesModal.module.scss';
+import { selectRemainingTilesGroups } from './selectors';
 
 interface Props {
   className?: string;

package/src/modals/RemainingTilesModal/components/Character/Character.tsx

@@ -1,12 +1,12 @@
 import { BLANK } from '@scrabble-solver/constants';
 import classNames from 'classnames';
-import { FunctionComponent } from 'react';
+import { type FunctionComponent } from 'react';
 
 import { Progress, Tile } from 'components';
 import { LOCALE_FEATURES } from 'i18n';
 import { REMAINING_TILES_TILE_SIZE } from 'parameters';
 import { selectCharacterPoints, selectLocale, useTypedSelector } from 'state';
-import { RemainingTile } from 'types';
+import { type RemainingTile } from 'types';
 
 import styles from './Character.module.scss';