scrabble-solver 2.18.9 → 2.18.10-alpha.0

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

@@ -1,23 +0,0 @@
-import { type Comparator } from '@/types';
-
-import { createStringComparator } from './createStringComparator';
-import { numberComparator } from './numberComparator';
-
-export const createKeyComparator = <T extends object>(key: keyof T, locale: string): Comparator<T> => {
-  const stringComparator = createStringComparator(locale);
-
-  return (a: T, b: T): number => {
-    const aValue = a[key];
-    const bValue = b[key];
-
-    if (typeof aValue === 'string' && typeof bValue === 'string') {
-      return stringComparator(aValue, bValue);
-    }
-
-    if (typeof aValue === 'number' && typeof bValue === 'number') {
-      return numberComparator(aValue, bValue);
-    }
-
-    return 0;
-  };
-};

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

@@ -1,46 +0,0 @@
-import { type KeyboardEventHandler } from 'react';
-
-import { noop } from './noop';
-
-interface Parameters {
-  onArrowDown?: KeyboardEventHandler<HTMLInputElement>;
-  onArrowLeft?: KeyboardEventHandler<HTMLInputElement>;
-  onArrowRight?: KeyboardEventHandler<HTMLInputElement>;
-  onArrowUp?: KeyboardEventHandler<HTMLInputElement>;
-  onBackspace?: KeyboardEventHandler<HTMLInputElement>;
-  onDelete?: KeyboardEventHandler<HTMLInputElement>;
-  onEnter?: KeyboardEventHandler<HTMLInputElement>;
-  onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
-  onSpace?: KeyboardEventHandler<HTMLInputElement>;
-}
-
-export const createKeyboardNavigation = ({
-  onArrowDown = noop,
-  onArrowLeft = noop,
-  onArrowRight = noop,
-  onArrowUp = noop,
-  onBackspace = noop,
-  onDelete = noop,
-  onEnter = noop,
-  onKeyDown = noop,
-  onSpace = noop,
-}: Parameters): KeyboardEventHandler<HTMLInputElement> => {
-  const handlers: Record<string, KeyboardEventHandler<HTMLInputElement>> = {
-    ArrowUp: onArrowUp,
-    ArrowDown: onArrowDown,
-    ArrowLeft: onArrowLeft,
-    ArrowRight: onArrowRight,
-    Backspace: onBackspace,
-    Delete: onDelete,
-    Enter: onEnter,
-    ' ': onSpace,
-  };
-
-  const handleKeyDown: KeyboardEventHandler<HTMLInputElement> = (event) => {
-    const handler = handlers[event.key] || noop;
-    handler(event);
-    onKeyDown(event);
-  };
-
-  return handleKeyDown;
-};

package/packages/scrabble-solver/src/lib/createNullMovingComparator.test.ts

@@ -1,15 +0,0 @@
-import { createNullMovingComparator } from './createNullMovingComparator';
-
-describe('createNullMovingComparator', () => {
-  it('Moves nulls left', () => {
-    const input = [null, 3, null, 2, null, 1, null];
-    const comparator = createNullMovingComparator('left');
-    expect([...input].sort(comparator)).toEqual([null, null, null, null, 3, 2, 1]);
-  });
-
-  it('Moves nulls right', () => {
-    const input = [null, 3, null, 2, null, 1, null];
-    const comparator = createNullMovingComparator('right');
-    expect([...input].sort(comparator)).toEqual([3, 2, 1, null, null, null, null]);
-  });
-});

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

@@ -1,17 +0,0 @@
-export const createNullMovingComparator = <T>(direction: 'left' | 'right') => {
-  return (a: T | null, b: T | null): number => {
-    if (a === b) {
-      return 0;
-    }
-
-    if (a === null) {
-      return direction === 'right' ? 1 : -1;
-    }
-
-    if (b === null) {
-      return direction === 'right' ? -1 : 1;
-    }
-
-    return 0;
-  };
-};

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

@@ -1,11 +0,0 @@
-export const createRegExp = (input: string): RegExp => {
-  if (input.trim().length === 0) {
-    return /.*/;
-  }
-
-  try {
-    return new RegExp(input, 'gi');
-  } catch {
-    return /.*/;
-  }
-};

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

@@ -1,22 +0,0 @@
-import { type ShowCoordinates } from '@scrabble-solver/types';
-
-import { type Comparator, type ComparatorFactory, type Sort, SortDirection } from '@/types';
-
-import { reverseComparator } from './reverseComparator';
-
-interface Parameters<Item, Id extends string> {
-  comparators: Record<Id, ComparatorFactory<Item>>;
-  locale: string;
-  showCoordinates: ShowCoordinates;
-  sort: Sort<Id>;
-}
-
-export function createSortComparator<Item, Id extends string>({
-  comparators,
-  locale,
-  showCoordinates,
-  sort,
-}: Parameters<Item, Id>): Comparator<Item> {
-  const comparator = comparators[sort.column](locale, showCoordinates);
-  return sort.direction === SortDirection.Descending ? reverseComparator(comparator) : comparator;
-}

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

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

package/packages/scrabble-solver/src/lib/extractCharacters.test.ts

@@ -1,52 +0,0 @@
-import { getConfig } from '@scrabble-solver/configs';
-import { BLANK } from '@scrabble-solver/constants';
-import { Game, Locale } from '@scrabble-solver/types';
-
-import { extractCharacters } from './extractCharacters';
-
-describe('upperCaseDigraphsOnly = false', () => {
-  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([
-      { 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/packages/scrabble-solver/src/lib/extractCharacters.ts

@@ -1,42 +0,0 @@
-import { BLANK } from '@scrabble-solver/constants';
-import { type Config, type Locale } from '@scrabble-solver/types';
-
-import { localeTransliterate } from './localeTransliterate';
-
-interface Options {
-  upperCaseDigraphsOnly?: boolean;
-}
-
-export const extractCharacters = (config: Config, value: string, options?: Options): string[] => {
-  let index = 0;
-  const characters: string[] = [];
-  const finalValue = localeTransliterate(config.locale, value);
-
-  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);
-
-    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;
-    }
-  }
-
-  return characters;
-};
-
-const isUpperCase = (locale: Locale, value: string): boolean => {
-  return value === value.toLocaleUpperCase(locale);
-};

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

@@ -1,15 +0,0 @@
-export const extractInputValue = (input: HTMLInputElement) => {
-  const value = input.value.toLocaleLowerCase();
-
-  if (input.selectionStart === null || input.selectionEnd === null) {
-    return value;
-  }
-
-  const index = Math.min(input.selectionStart, input.selectionEnd);
-
-  if (index > 0) {
-    return value.substring(index - 1, index);
-  }
-
-  return value;
-};

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

@@ -1,5 +0,0 @@
-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/packages/scrabble-solver/src/lib/getCoordinate.test.ts

@@ -1,22 +0,0 @@
-import { getCoordinate } from './getCoordinate';
-
-describe('getCoordinate', () => {
-  it.each([
-    { index: 0, type: 'number' as const, expected: '1' },
-    { index: 99, type: 'number' as const, expected: '100' },
-  ])(`getCoordinate($index, "number") === "$expected"`, ({ index, type, expected }) => {
-    expect(getCoordinate(index, type)).toEqual(expected);
-  });
-
-  it.each([
-    { index: 0, type: 'letter' as const, expected: 'A' },
-    { index: 25, type: 'letter' as const, expected: 'Z' },
-    { index: 26, type: 'letter' as const, expected: 'AA' },
-    { index: 27, type: 'letter' as const, expected: 'AB' },
-    { index: 51, type: 'letter' as const, expected: 'AZ' },
-    { index: 52, type: 'letter' as const, expected: 'BA' },
-    { index: 53, type: 'letter' as const, expected: 'BB' },
-  ])(`getCoordinate("$index", "letter") === "$expected"`, ({ index, type, expected }) => {
-    expect(getCoordinate(index, type)).toEqual(expected);
-  });
-});

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

@@ -1,17 +0,0 @@
-const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-
-export const getCoordinate = (index: number, type: 'letter' | 'number'): string => {
-  if (type === 'number') {
-    return String(index + 1);
-  }
-
-  let result = '';
-  let nextIndex = index;
-
-  while (nextIndex >= 0) {
-    result = alphabet[nextIndex % alphabet.length] + result;
-    nextIndex = Math.floor(nextIndex / alphabet.length) - 1;
-  }
-
-  return result;
-};

package/packages/scrabble-solver/src/lib/getCoordinates.test.ts

@@ -1,21 +0,0 @@
-import { getCoordinates } from './getCoordinates';
-
-describe('getCoordinates', () => {
-  const point = { x: 3, y: 5 };
-
-  it('encodes a horizontal word as row number followed by column letter in original mode', () => {
-    expect(getCoordinates({ ...point, isHorizontal: true }, 'original')).toBe('6D');
-  });
-
-  it('encodes a vertical word as column letter followed by row number in original mode', () => {
-    expect(getCoordinates({ ...point, isHorizontal: false }, 'original')).toBe('D6');
-  });
-
-  it('encodes a horizontal word as row letter followed by column number in alternative mode', () => {
-    expect(getCoordinates({ ...point, isHorizontal: true }, 'alternative')).toBe('F4');
-  });
-
-  it('encodes a vertical word as column number followed by row letter in alternative mode', () => {
-    expect(getCoordinates({ ...point, isHorizontal: false }, 'alternative')).toBe('4F');
-  });
-});

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

@@ -1,16 +0,0 @@
-import { type ShowCoordinates } from '@scrabble-solver/types';
-
-import { getCoordinate } from './getCoordinate';
-
-interface Parameters {
-  isHorizontal: boolean;
-  x: number;
-  y: number;
-}
-
-export const getCoordinates = ({ isHorizontal, x, y }: Parameters, showCoordinates: ShowCoordinates): string => {
-  const xCoordinate = getCoordinate(x, showCoordinates === 'original' ? 'letter' : 'number');
-  const yCoordinate = getCoordinate(y, showCoordinates === 'original' ? 'number' : 'letter');
-
-  return isHorizontal ? `${yCoordinate}${xCoordinate}` : `${xCoordinate}${yCoordinate}`;
-};

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

@@ -1,12 +0,0 @@
-import { type Sort, SortDirection } from '@/types';
-
-export const getNextSort = <Id extends string>(sort: Sort<Id>, column: Id): Sort<Id> => {
-  return {
-    column,
-    direction: sort.column === column ? toggleDirection(sort.direction) : sort.direction,
-  };
-};
-
-const toggleDirection = (direction: SortDirection): SortDirection => {
-  return direction === SortDirection.Ascending ? SortDirection.Descending : SortDirection.Ascending;
-};

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

@@ -1,3 +0,0 @@
-export const inverseDirection = (direction: 'left' | 'right'): 'left' | 'right' => {
-  return direction === 'left' ? 'right' : 'left';
-};

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

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

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

@@ -1,7 +0,0 @@
-export const isMac = (): boolean => {
-  if (!globalThis.navigator) {
-    return false;
-  }
-
-  return globalThis.navigator.platform.startsWith('Mac') || globalThis.navigator.platform.startsWith('iPhone');
-};

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

@@ -1,9 +0,0 @@
-export const isRegExp = (value: string): boolean => {
-  try {
-    // eslint-disable-next-line no-new
-    new RegExp(value);
-    return true;
-  } catch {
-    return false;
-  }
-};

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

@@ -1,3 +0,0 @@
-export const isStringArray = (value: unknown): value is string[] => {
-  return Array.isArray(value) && value.every((item) => typeof item === 'string');
-};

package/packages/scrabble-solver/src/lib/localeTransliterate.test.ts

@@ -1,19 +0,0 @@
-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.ES_ES, word: 'pingüino', expected: 'pinguino' },
-    { locale: Locale.FR_FR, word: 'très', expected: 'tres' },
-    { locale: Locale.FR_FR, word: 'garçon', expected: 'garcon' },
-    { locale: Locale.FR_FR, word: 'œuf', expected: 'oeuf' },
-    { locale: Locale.FR_FR, word: 'ex æquo', expected: 'ex aequo' },
-    { locale: Locale.PL_PL, word: 'źdźbło', expected: 'źdźbło' },
-    { locale: Locale.RO_RO, word: 'mămăligă', expected: 'mamaliga' },
-    { locale: Locale.RO_RO, word: 'așteaptă', expected: 'asteapta' },
-  ])(`[$locale] "$word"`, ({ locale, word, expected }) => {
-    expect(localeTransliterate(locale, word)).toEqual(expected);
-  });
-});

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

@@ -1,38 +0,0 @@
-import { Locale } from '@scrabble-solver/types';
-
-const COMBINING_MARKS = /[̀-ͯ]/g;
-
-const NON_DECOMPOSABLE: Record<string, string> = {
-  Æ: 'AE',
-  Œ: 'OE',
-  æ: 'ae',
-  œ: 'oe',
-};
-
-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) => foldDiacritics(word, ['ñ', 'Ñ']),
-  [Locale.FA_IR]: (word) => word,
-  [Locale.FR_FR]: (word) => foldDiacritics(word),
-  [Locale.PL_PL]: (word) => word,
-  [Locale.RO_RO]: (word) => foldDiacritics(word),
-  [Locale.TR_TR]: (word) => word,
-};
-
-export function localeTransliterate(locale: Locale, value: string): string {
-  return transliteratePerLocale[locale](value);
-}
-
-function foldDiacritics(word: string, ignore: readonly string[] = []): string {
-  return Array.from(word)
-    .map((character) => {
-      if (ignore.includes(character)) {
-        return character;
-      }
-
-      return NON_DECOMPOSABLE[character] ?? character.normalize('NFD').replace(COMBINING_MARKS, '');
-    })
-    .join('');
-}

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

@@ -1,64 +0,0 @@
-interface AnyFunction<Args extends unknown[], Result> {
-  (...parameters: Args): Result;
-}
-
-interface Entry<Args extends unknown[], Result> {
-  parameters: Args;
-  result: Result;
-}
-
-export const memoize = <Args extends unknown[], Result>(
-  fn: AnyFunction<Args, Result>,
-): AnyFunction<Args, Result> & {
-  hasCache: (...parameters: Args) => boolean;
-} => {
-  const cache: Entry<Args, Result>[] = [];
-
-  const hasCache = (...parameters: Args): boolean => Boolean(readCache(parameters));
-
-  const readCache = (parameters: Args): Result | undefined => {
-    return cache.find((entry) => parametersEqual(entry.parameters, parameters))?.result;
-  };
-
-  const removeCache = (parameters: Args): void => {
-    const index = cache.findIndex((entry) => parametersEqual(entry.parameters, parameters));
-
-    if (index >= 0) {
-      cache.splice(index, 1);
-    }
-  };
-
-  const writeCache = (parameters: Args, result: Result): void => {
-    cache.push({ parameters, result });
-  };
-
-  const memoized = (...parameters: Args): Result => {
-    const cached = readCache(parameters);
-
-    if (cached) {
-      return cached;
-    }
-
-    const result = fn(...parameters);
-
-    if (result instanceof Promise) {
-      result.catch(() => {
-        removeCache(parameters);
-      });
-    }
-
-    writeCache(parameters, result);
-
-    return result;
-  };
-
-  return Object.assign(memoized, { hasCache });
-};
-
-const parametersEqual = <Args extends unknown[]>(a: Args, b: Args): boolean => {
-  if (a.length !== b.length) {
-    return false;
-  }
-
-  return a.every((parameter: Args[typeof index], index: number) => parameter === b[index]);
-};

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

@@ -1 +0,0 @@
-export const noop = (): void => undefined;

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

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

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

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

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

@@ -1,12 +0,0 @@
-import { createComparator } from './createComparator';
-
-export const unorderedArraysEqual = <T>(a: T[], b: T[], locale: string): boolean => {
-  if (a.length !== b.length) {
-    return false;
-  }
-
-  const comparator = createComparator(locale);
-  const aSorted = [...a].sort(comparator);
-  const bSorted = [...b].sort(comparator);
-  return aSorted.every((character, index) => character === bSorted[index]);
-};

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

@@ -1,44 +0,0 @@
-export function waitForIdleOrFirstIntent(): Promise<void> {
-  return new Promise((resolve) => {
-    const settle = onFirstIntent(resolve);
-    whenIdle(settle);
-  });
-}
-
-export function waitForFirstIntent(): Promise<void> {
-  return new Promise((resolve) => {
-    onFirstIntent(resolve);
-  });
-}
-
-export function waitForIdle(): Promise<void> {
-  return new Promise((resolve) => whenIdle(resolve));
-}
-
-function onFirstIntent(callback: () => void): () => void {
-  const settle = () => {
-    window.removeEventListener('pointerdown', settle);
-    window.removeEventListener('keydown', settle);
-    callback();
-  };
-
-  window.addEventListener('pointerdown', settle, { once: true });
-  window.addEventListener('keydown', settle, { once: true });
-  return settle;
-}
-
-function whenIdle(callback: () => void): void {
-  const requestIdle = () => {
-    if ('requestIdleCallback' in window) {
-      window.requestIdleCallback(callback, { timeout: 5000 });
-    } else {
-      setTimeout(callback, 5000);
-    }
-  };
-
-  if (document.readyState === 'complete') {
-    requestIdle();
-  } else {
-    window.addEventListener('load', requestIdle, { once: true });
-  }
-}

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

@@ -1,28 +0,0 @@
-import { BLANK } from '@scrabble-solver/constants';
-import { type Tile } from '@scrabble-solver/types';
-
-import { type Rack } from '@/types';
-
-interface CharacterTilePair {
-  character: string | null;
-  tile: Tile | null;
-}
-
-export const zipCharactersAndTiles = (characters: Rack, tiles: Tile[]): CharacterTilePair[] => {
-  let remainingTiles = [...tiles];
-
-  return characters.map((character) => {
-    const index = remainingTiles.findIndex((tile) =>
-      character === BLANK ? tile.isBlank : character === tile.character,
-    );
-
-    if (index >= 0) {
-      const tile = remainingTiles[index];
-      remainingTiles = [...remainingTiles.slice(0, index), ...remainingTiles.slice(index + 1)];
-
-      return { character, tile };
-    }
-
-    return { character, tile: null };
-  });
-};

package/packages/scrabble-solver/src/modals/DictionaryModal/DictionaryModal.module.scss

@@ -1,22 +0,0 @@
-.content {
-  height: 100%;
-  display: flex;
-  flex-direction: column;
-  background-color: var(--color--background--element);
-  border: var(--border);
-  border-radius: var(--border--radius);
-}
-
-.dictionary {
-  flex: 1;
-  max-height: initial;
-  border-bottom: var(--border);
-  border-top-left-radius: var(--border--radius);
-  border-top-right-radius: var(--border--radius);
-}
-
-.dictionaryInput {
-  flex: 0 0 auto;
-  border-bottom-left-radius: var(--border--radius);
-  border-bottom-right-radius: var(--border--radius);
-}

package/packages/scrabble-solver/src/modals/DictionaryModal/DictionaryModal.module.scss.d.ts

@@ -1,8 +0,0 @@
-// Generated by scripts/generate-scss-types.ts - do not edit.
-declare const styles: {
-  readonly content: string;
-  readonly dictionary: string;
-  readonly dictionaryInput: string;
-};
-
-export default styles;