scrabble-solver 2.17.0 → 2.18.0

package/e2e/app.spec.ts

@@ -0,0 +1,124 @@
+import { expect, type Page, test } from '@playwright/test';
+
+import {
+  assertResult,
+  closeModal,
+  expectTileHighlighted,
+  expectTileNotHighlighted,
+  getBoardTile,
+  getDictionary,
+  getDictionaryInput,
+  getDictionaryTitles,
+  getLoading,
+  getRackTile,
+  getResult,
+  getSettingOption,
+  getSettingsButton,
+  getTooltip,
+  hoverResult,
+  moveMouseAway,
+  solve,
+  typeRack,
+  visitIndex,
+} from './lib';
+
+test.describe('app', () => {
+  test('has title', async ({ page }) => {
+    await visitIndex(page);
+
+    await expect(page).toHaveTitle('Scrabble Solver 2');
+  });
+
+  test('has default setting values', async ({ page }) => {
+    await visitIndex(page);
+    await getSettingsButton(page).click();
+
+    await expect(getSettingOption(page, 'Game', 'Scrabble')).toBeChecked();
+    await expect(getSettingOption(page, 'Language', 'English (US)')).toBeChecked();
+    await expect(getSettingOption(page, 'Coordinates', 'Original')).toBeChecked();
+    await expect(getSettingOption(page, 'Input mode', 'Keyboard')).toBeChecked();
+    await expect(getSettingOption(page, 'Group remaining tiles', 'Do not group')).toBeChecked();
+  });
+
+  test.describe('full app test', () => {
+    test('Scrabble - Polish', async ({ page }) => {
+      await visitIndex(page);
+      await getSettingsButton(page).click();
+      await getSettingOption(page, 'Language', 'Polski').check();
+      await closeModal(page);
+      await typeRack(page, 'abł');
+      await solve(page);
+
+      await assertResult(page, 0, 'bał', 14);
+      const definitionsResponse = waitForDictionaryResponse(page);
+      await hoverResult(page, 0);
+      await expect(getLoading(page)).toBeVisible();
+      await definitionsResponse;
+      await expectTileHighlighted(getRackTile(page, 0));
+      await expectTileHighlighted(getRackTile(page, 1));
+      await expectTileHighlighted(getRackTile(page, 2));
+      await expect(getBoardTile(page, 5, 7)).toHaveValue('b');
+      await expect(getBoardTile(page, 6, 7)).toHaveValue('a');
+      await expect(getBoardTile(page, 7, 7)).toHaveValue('ł');
+      await expectTileHighlighted(getBoardTile(page, 5, 7));
+      await expectTileHighlighted(getBoardTile(page, 6, 7));
+      await expectTileHighlighted(getBoardTile(page, 7, 7));
+      await expect(getDictionaryInput(page)).toHaveValue('bał');
+      await expect(getLoading(page)).toHaveCount(0);
+      await expect(getTooltip(page)).toBeVisible();
+      await moveMouseAway(page);
+      await expect(getTooltip(page)).toHaveCount(0);
+      await expectTileNotHighlighted(getRackTile(page, 0));
+      await expect(getDictionaryTitles(page)).toHaveCount(1);
+      await expect(getDictionaryTitles(page)).toHaveText('bał');
+      await expect(getDictionary(page)).toContainText('bać się');
+      await expect(getDictionary(page)).toContainText('odczuwać lęk, strach');
+      await expect(getDictionary(page)).toContainText('być niespokojnym o kogoś lub o coś');
+      await expect(getDictionary(page)).toContainText('nie śmieć, nie odważać się na coś');
+
+      await page.getByLabel('Punkty', { exact: true }).click();
+      await expect(getTooltip(page)).toBeVisible();
+      await expect(getTooltip(page)).toHaveText('Punkty');
+      await assertResult(page, 0, 'ba', 8);
+      const nextDefinitionsResponse = waitForDictionaryResponse(page);
+      await hoverResult(page, 0);
+      await expectTileHighlighted(getRackTile(page, 0));
+      await expectTileHighlighted(getRackTile(page, 1));
+      await expectTileNotHighlighted(getRackTile(page, 2));
+      await expect(getBoardTile(page, 5, 7)).toHaveValue('');
+      await expect(getBoardTile(page, 6, 7)).toHaveValue('b');
+      await expect(getBoardTile(page, 7, 7)).toHaveValue('a');
+      await expectTileNotHighlighted(getBoardTile(page, 5, 7));
+      await expectTileHighlighted(getBoardTile(page, 6, 7));
+      await expectTileHighlighted(getBoardTile(page, 7, 7));
+      await expect(getDictionaryInput(page)).toHaveValue('ba');
+      await expect(getLoading(page)).toBeVisible();
+      await nextDefinitionsResponse;
+      await expect(getLoading(page)).toHaveCount(0);
+      await expect(getDictionaryTitles(page)).toHaveCount(1);
+      await expect(getDictionaryTitles(page)).toHaveText('ba');
+      await expect(getDictionary(page)).toContainText('wykrzyknik, który wyraża głównie podziw, zdziwienie');
+      await expect(getDictionary(page)).toContainText(
+        'w wierzeniach staroegipskich: dusza ludzka ginąca wraz z ciałem',
+      );
+
+      await getResult(page, 0).click();
+      await expectTileNotHighlighted(getRackTile(page, 0));
+      await expectTileNotHighlighted(getRackTile(page, 1));
+      await expectTileNotHighlighted(getRackTile(page, 2));
+      await expect(getRackTile(page, 0)).toHaveValue('');
+      await expect(getRackTile(page, 1)).toHaveValue('');
+      await expect(getRackTile(page, 2)).toHaveValue('ł');
+      await expect(getBoardTile(page, 6, 7)).toHaveValue('b');
+      await expect(getBoardTile(page, 7, 7)).toHaveValue('a');
+
+      const solveButton = page.getByLabel('Rozwiąż', { exact: true });
+      await expect(solveButton).toBeVisible();
+      await expect(solveButton).toBeEnabled();
+    });
+  });
+});
+
+function waitForDictionaryResponse(page: Page) {
+  return page.waitForResponse('**/api/dictionary/*/*');
+}

package/e2e/bugs/112-character-bonus.spec.ts

@@ -0,0 +1,25 @@
+import { test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/112
+ */
+test.describe('#112 - Scrabble - Character bonus not applied', () => {
+  test('correctly shows points for a result which gets a character bonus', async ({ page }) => {
+    await Lib.visitIndex(page);
+
+    await Lib.getSettingsButton(page).click();
+    await Lib.getSettingOption(page, 'Language', 'Français').check();
+    await Lib.closeModal(page);
+    await Lib.typeRack(page, 'jours');
+    await Lib.solve(page);
+
+    await Lib.assertResult(page, 0, 'jours', 40);
+    await Lib.assertResult(page, 1, 'jours', 40);
+    await Lib.assertResult(page, 2, 'jours', 26);
+    await Lib.assertResult(page, 3, 'jours', 26);
+    await Lib.assertResult(page, 4, 'jours', 24);
+    await Lib.assertResult(page, 5, 'jours', 24);
+  });
+});

package/e2e/bugs/129-esc-sidebar.spec.ts

@@ -0,0 +1,17 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/129
+ */
+test.describe('#129 - Esc does not close the sidebar when letters input is focused', () => {
+  test('Esc key closes the sidebar when rack is focused', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.getSettingsButton(page).click();
+    await Lib.typeRack(page, 'a');
+    await page.keyboard.press('Escape');
+
+    await expect(Lib.getModal(page)).toHaveCount(0);
+  });
+});

package/e2e/bugs/2-q-tile-in-english.spec.ts

@@ -0,0 +1,19 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/2
+ */
+test.describe('#2 - "Q" tile does not work', () => {
+  test('accepts "Q" tile in English', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'i', 'horizontal', { x: 7, y: 7 });
+    await Lib.typeRack(page, 'q');
+    await Lib.solve(page);
+
+    await expect(Lib.getResults(page)).toHaveCount(2);
+    await Lib.assertResult(page, 0, 'qi', 11);
+    await Lib.assertResult(page, 1, 'qi', 11);
+  });
+});

package/e2e/bugs/3-x-tile-in-polish.spec.ts

@@ -0,0 +1,19 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/3
+ */
+test.describe('#3 - "X" tile is allowed in Polish', () => {
+  test('does not accept "X" tile in Polish', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.getSettingsButton(page).click();
+    await Lib.getSettingOption(page, 'Language', 'Polski').check();
+    await Lib.closeModal(page);
+    await Lib.typeBoard(page, 'x', 'horizontal', { x: 7, y: 7 });
+    await Lib.typeRack(page, 'x');
+
+    await expect(page.getByText('x', { exact: true })).toHaveCount(0);
+  });
+});

package/e2e/bugs/30-click-inside-radio-icon.spec.ts

@@ -0,0 +1,25 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/30
+ */
+test.describe('#30 - Clicking inside an icon of non-first unchecked radio button does not select that option', () => {
+  test('Clicking inside an icon of first unchecked radio button selects it', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.getSettingsButton(page).click();
+    await Lib.getSettingOption(page, 'Language', 'English (GB)').click();
+
+    const icon = Lib.getSettingOption(page, 'Language', 'English (US)')
+      .locator('..')
+      .getByRole('img', { includeHidden: true })
+      .first();
+
+    // force - the icon is fully covered by the radio's invisible input overlay,
+    // which is exactly what a click at the icon's coordinates is meant to hit
+    await icon.click({ force: true });
+
+    await expect(Lib.getSettingOption(page, 'Language', 'English (US)')).toBeChecked();
+  });
+});

package/e2e/bugs/333-disabled-radio-cursor.spec.ts

@@ -0,0 +1,18 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/333
+ */
+test.describe('#333 - Disabled radio button has cursor: pointer', () => {
+  test('Disabled radio button has cursor: not-allowed', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.getSettingsButton(page).click();
+    await Lib.getSettingOption(page, 'Language', 'Polski').check();
+    await Lib.getSettingOption(page, 'Gra', 'Scrabble').scrollIntoViewIfNeeded();
+
+    await expect(Lib.getSettingOption(page, 'Gra', 'Super Scrabble')).toBeDisabled();
+    await expect(Lib.getSettingOption(page, 'Gra', 'Super Scrabble')).toHaveCSS('cursor', 'not-allowed');
+  });
+});

package/e2e/bugs/342-results-sorting.spec.ts

@@ -0,0 +1,30 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/342
+ */
+test.describe('#342 - Incorrect sorting when filtering', () => {
+  test('correctly sorts valid results first when text filter is active', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.getSettingsButton(page).click();
+    await Lib.getSettingOption(page, 'Language', 'Polski').check();
+    await Lib.closeModal(page);
+    await Lib.typeBoard(page, 'bopie', 'horizontal', { x: 6, y: 3 });
+    await Lib.typeBoard(page, 'apu', 'vertical', { x: 8, y: 4 });
+    await Lib.typeBoard(page, 'o', 'vertical', { x: 10, y: 4 });
+    await Lib.typeRack(page, 'oe');
+    await Lib.solve(page);
+    await Lib.getResultsFilterInput(page).pressSequentially('p');
+
+    await Lib.assertResult(page, 0, 'po', 5);
+    await Lib.assertResult(page, 1, 'pe', 5);
+    await Lib.assertResult(page, 2, 'op', 3);
+    await Lib.assertResult(page, 3, 'eo', 6);
+    await expect(Lib.getResult(page, 0)).not.toHaveAttribute('aria-hidden');
+    await expect(Lib.getResult(page, 1)).not.toHaveAttribute('aria-hidden');
+    await expect(Lib.getResult(page, 2)).not.toHaveAttribute('aria-hidden');
+    await expect(Lib.getResult(page, 3)).toHaveAttribute('aria-hidden', 'true');
+  });
+});

package/e2e/bugs/352-dictionary-race-condition.spec.ts

@@ -0,0 +1,27 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/352
+ */
+test.describe('#352 - Race condition: dictionary result shows up after clearing the board', () => {
+  test('Clearing the board prevents pending dictionary results from showing up', async ({ page }) => {
+    await page.route('**/api/dictionary/en-US/123', async (route) => {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      await route.fulfill({ body: '' });
+    });
+
+    await Lib.visitIndex(page);
+
+    const dictionaryResponse = page.waitForResponse('**/api/dictionary/en-US/123');
+    await Lib.getDictionaryInput(page).pressSequentially('123');
+    await Lib.getDictionaryInput(page).press('Enter');
+    await page.getByLabel('Clear', { exact: true }).click();
+    await dictionaryResponse;
+
+    await expect(Lib.getDictionary(page)).not.toContainText('This word is not allowed');
+    await expect(Lib.getDictionary(page)).not.toContainText('Unexpected end of JSON input');
+    await expect(Lib.getDictionary(page)).toContainText('Word definition will be shown here.');
+  });
+});

package/e2e/bugs/363-dictionary-input-unique-words.spec.ts

@@ -0,0 +1,27 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/363
+ */
+test.describe('#363 - Dictionary input should display unique words', () => {
+  test('highlighting a word should cause only unique new words to be looked up in the dictionary', async ({ page }) => {
+    await page.route('**/api/dictionary/tr-TR/*', async (route) => {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      await route.fulfill({ body: '' });
+    });
+
+    await Lib.visitIndex(page);
+    await Lib.getSettingsButton(page).click();
+    await Lib.getSettingOption(page, 'Language', 'Türkçe').check();
+    await Lib.closeModal(page);
+    await Lib.typeBoard(page, 'ponje', 'horizontal', { x: 3, y: 7 });
+    await Lib.typeRack(page, 'er');
+    await Lib.solve(page);
+
+    await Lib.getResult(page, 0).hover();
+
+    await expect(Lib.getDictionaryInput(page)).toHaveValue('er, je');
+  });
+});

package/e2e/bugs/380-transliteration-when-pasting.spec.ts

@@ -0,0 +1,55 @@
+import { expect, type Page, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/380
+ */
+test.describe('#380 - No transliteration when pasting', () => {
+  test('should transliterate special characters when pasting in Romanian', async ({ page }) => {
+    await testTransliterationOnPaste(page, {
+      language: 'Română',
+      word: 'abordaserăți',
+      transliterated: 'abordaserati',
+    });
+  });
+
+  test('should transliterate special characters (except "ñ") when pasting in Spanish', async ({ page }) => {
+    await testTransliterationOnPaste(page, {
+      language: 'Español',
+      word: 'bañó',
+      transliterated: 'baño',
+    });
+  });
+
+  test('should transliterate special characters when pasting in French', async ({ page }) => {
+    await testTransliterationOnPaste(page, {
+      language: 'Français',
+      word: 'pâtisserie',
+      transliterated: 'patisserie',
+    });
+  });
+});
+
+async function testTransliterationOnPaste(
+  page: Page,
+  {
+    language,
+    word,
+    transliterated,
+  }: {
+    language: string;
+    word: string;
+    transliterated: string;
+  },
+) {
+  await Lib.visitIndex(page);
+  await Lib.getSettingsButton(page).click();
+  await Lib.getSettingOption(page, 'Language', language).check();
+  await Lib.closeModal(page);
+  await Lib.paste(Lib.getBoardTile(page, 0, 0), word);
+
+  for (const [x, value] of Array.from(transliterated).entries()) {
+    await expect(Lib.getBoardTile(page, x, 0)).toHaveValue(value);
+  }
+}

package/e2e/bugs/398-digraphs-in-created-words.spec.ts

@@ -0,0 +1,23 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/398
+ */
+test.describe('#398 - Solitary digraph tiles are recognised as created words', () => {
+  test('should transliterate special characters when pasting in French', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.getSettingsButton(page).click();
+    await Lib.getSettingOption(page, 'Language', 'Español').check();
+    await Lib.closeModal(page);
+    await Lib.pasteBoard(page, 'chiclean', 'horizontal', { x: 3, y: 7 });
+    await page.getByLabel('Palabras creadas', { exact: true }).click();
+
+    const modal = Lib.getOpenModal(page);
+    await expect(modal.getByText('ch', { exact: true })).toHaveCount(0);
+    await expect(modal.getByText('chiclean', { exact: true })).toBeVisible();
+    await expect(modal.getByLabel('Incorrecto', { exact: true }).getByText('0', { exact: true })).toBeVisible();
+    await expect(modal.getByLabel('Correcto', { exact: true }).getByText('1', { exact: true })).toBeVisible();
+  });
+});

package/e2e/bugs/401-board-state-on-game-change.spec.ts

@@ -0,0 +1,24 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+const SUPER_SCRABBLE_BOARD_WIDTH = 21;
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/401
+ */
+test.describe('#401 - Board state not preserved on game type change', () => {
+  test('preserves tiles centered on the board when switching to a larger game', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'word', 'horizontal', { x: 7, y: 7 });
+
+    await Lib.getSettingsButton(page).click();
+    await Lib.getSettingOption(page, 'Game', 'Super Scrabble').check();
+    await Lib.closeModal(page);
+
+    await expect(Lib.getBoardTile(page, 10, 10, SUPER_SCRABBLE_BOARD_WIDTH)).toHaveValue('w');
+    await expect(Lib.getBoardTile(page, 11, 10, SUPER_SCRABBLE_BOARD_WIDTH)).toHaveValue('o');
+    await expect(Lib.getBoardTile(page, 12, 10, SUPER_SCRABBLE_BOARD_WIDTH)).toHaveValue('r');
+    await expect(Lib.getBoardTile(page, 13, 10, SUPER_SCRABBLE_BOARD_WIDTH)).toHaveValue('d');
+  });
+});

package/e2e/features/198-highlight-unreachable-cells.spec.ts

@@ -0,0 +1,85 @@
+import { expect, type Page, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/198
+ */
+test.describe('#198 - Highlight unreachable cells', () => {
+  test('has no effect when the rack is empty', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'cat', 'horizontal', { x: 7, y: 7 });
+    await setHighlightUnreachableCells(page, 'On');
+
+    await expectReachable(page, 0, 0);
+    await expectReachable(page, 14, 14);
+    await expectReachable(page, 7, 7);
+    await expectReachable(page, 7, 8);
+  });
+
+  test('has no effect when the setting is off', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeRack(page, 'abcdefg');
+
+    await expectReachable(page, 0, 0);
+    await expectReachable(page, 14, 14);
+    await expectReachable(page, 7, 7);
+  });
+
+  test('dims unreachable cells on an empty board when rack has tiles', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeRack(page, 'abc');
+    await setHighlightUnreachableCells(page, 'On');
+
+    await expectReachable(page, 7, 7);
+    await expectReachable(page, 5, 7);
+    await expectReachable(page, 7, 5);
+
+    await expectUnreachable(page, 0, 0);
+    await expectUnreachable(page, 14, 14);
+    await expectUnreachable(page, 4, 7);
+    await expectUnreachable(page, 6, 6);
+  });
+
+  test('dims cells far from any placed tile or rack reach', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'cat', 'horizontal', { x: 7, y: 7 });
+    await Lib.typeRack(page, 'ab');
+    await setHighlightUnreachableCells(page, 'On');
+
+    await expectReachable(page, 7, 7);
+    await expectReachable(page, 6, 7);
+    await expectReachable(page, 10, 7);
+    await expectReachable(page, 8, 6);
+
+    await expectUnreachable(page, 0, 0);
+    await expectUnreachable(page, 14, 14);
+    await expectUnreachable(page, 0, 14);
+  });
+
+  test('updates dimming when toggled off after being on', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeRack(page, 'abc');
+    await setHighlightUnreachableCells(page, 'On');
+    await expectUnreachable(page, 0, 0);
+
+    await setHighlightUnreachableCells(page, 'Off');
+    await expectReachable(page, 0, 0);
+    await expectReachable(page, 14, 14);
+  });
+});
+
+async function setHighlightUnreachableCells(page: Page, value: 'On' | 'Off') {
+  await Lib.getSettingsButton(page).click();
+  await expect(Lib.getOpenModal(page)).toBeVisible();
+  await Lib.getSettingOption(page, 'Highlight unreachable cells', value).check();
+  await Lib.closeModal(page);
+}
+
+async function expectUnreachable(page: Page, x: number, y: number) {
+  await expect(Lib.getBoardTile(page, x, y).locator('..')).toHaveClass(/unreachable/);
+}
+
+async function expectReachable(page: Page, x: number, y: number) {
+  await expect(Lib.getBoardTile(page, x, y).locator('..')).not.toHaveClass(/unreachable/);
+}

package/e2e/features/91-hover-remaining-tile-highlights.spec.ts

@@ -0,0 +1,76 @@
+import { expect, type Page, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * @see https://github.com/kamilmielnik/scrabble-solver/issues/91
+ */
+test.describe('#91 - Hovering remaining tile highlights all same tiles on the board and rack', () => {
+  test('highlights matching letter tiles on the board and rack', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'cat', 'horizontal', { x: 7, y: 7 });
+    await Lib.typeRack(page, 'aab ');
+    await openRemainingTilesModal(page);
+
+    await hoverRemainingTile(page, 'a');
+    await Lib.expectTileHighlighted(Lib.getRackTile(page, 0));
+    await Lib.expectTileHighlighted(Lib.getRackTile(page, 1));
+    await Lib.expectTileNotHighlighted(Lib.getRackTile(page, 2));
+    await Lib.expectTileNotHighlighted(Lib.getRackTile(page, 3));
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 7, 7));
+    await Lib.expectTileHighlighted(Lib.getBoardTile(page, 8, 7));
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 9, 7));
+
+    await hoverRemainingTile(page, 'b');
+    await Lib.expectTileNotHighlighted(Lib.getRackTile(page, 0));
+    await Lib.expectTileNotHighlighted(Lib.getRackTile(page, 1));
+    await Lib.expectTileHighlighted(Lib.getRackTile(page, 2));
+    await Lib.expectTileNotHighlighted(Lib.getRackTile(page, 3));
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 7, 7));
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 8, 7));
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 9, 7));
+  });
+
+  test('highlights matching blank tiles on the board and rack', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'a', 'horizontal', { x: 7, y: 7 });
+    await Lib.getBoardTile(page, 7, 7).focus();
+    await Lib.typeBoard(page, ' ', 'horizontal', { x: 7, y: 7 });
+    await Lib.typeRack(page, ' a');
+    await openRemainingTilesModal(page);
+
+    await hoverRemainingTile(page, ' ');
+    await Lib.expectTileHighlighted(Lib.getRackTile(page, 0));
+    await Lib.expectTileNotHighlighted(Lib.getRackTile(page, 1));
+    await Lib.expectTileHighlighted(Lib.getBoardTile(page, 7, 7));
+
+    await hoverRemainingTile(page, 'a');
+    await Lib.expectTileNotHighlighted(Lib.getRackTile(page, 0));
+    await Lib.expectTileHighlighted(Lib.getRackTile(page, 1));
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 7, 7));
+  });
+
+  test('does not highlight a remaining tile in the sidebar if it has not been used', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeRack(page, 'a');
+    await openRemainingTilesModal(page);
+
+    await hoverRemainingTile(page, 'z');
+    await expect(page.getByTestId('remaining-tile-z').locator('[role="mark"]')).toHaveCount(0);
+    await Lib.expectTileNotHighlighted(Lib.getRackTile(page, 0));
+
+    await hoverRemainingTile(page, 'a');
+    await expect(page.getByTestId('remaining-tile-a').locator('[role="mark"]')).not.toHaveCount(0);
+    await Lib.expectTileHighlighted(Lib.getRackTile(page, 0));
+  });
+});
+
+async function openRemainingTilesModal(page: Page) {
+  await page.getByLabel('Remaining tiles', { exact: true }).click();
+  await expect(Lib.getOpenModal(page)).toBeVisible();
+}
+
+async function hoverRemainingTile(page: Page, character: string) {
+  const testId = character === ' ' ? 'remaining-tile-blank' : `remaining-tile-${character}`;
+  await page.getByTestId(testId).hover();
+}

package/e2e/features/hidden-coordinates-migration.spec.ts

@@ -0,0 +1,27 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+/*
+ * The 'hidden' showCoordinates option was removed on 2026/08/13.
+ * Delete this spec together with migrateHiddenShowCoordinates.
+ */
+test.describe('"hidden" coordinates migration', () => {
+  test('falls back to original coordinates when storage holds the removed "hidden" option', async ({ page }) => {
+    await page.addInitScript(() => {
+      localStorage.setItem('scrabble-solver.settings', JSON.stringify({ showCoordinates: 'hidden' }));
+    });
+
+    await Lib.visitIndex(page);
+
+    await expect(Lib.getBoardContainer(page).getByText('A', { exact: true })).toBeVisible();
+
+    await Lib.getSettingsButton(page).click();
+    await expect(Lib.getSettingOption(page, 'Coordinates', 'Original')).toBeChecked();
+    await Lib.closeModal(page);
+
+    await expect
+      .poll(() => page.evaluate(() => localStorage.getItem('scrabble-solver.settings')))
+      .toContain('"showCoordinates":"original"');
+  });
+});