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

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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,12 @@
+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

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

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

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

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,64 @@
+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

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

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

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

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,22 @@
+.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

@@ -0,0 +1,8 @@
+// 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;