scrabble-solver 2.18.1 → 2.18.3

package/e2e/features/words-interactions.spec.ts

@@ -0,0 +1,179 @@
+import { expect, type Locator, type Page, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+test.describe('Created words interactions', () => {
+  test.describe('compact, non-touch', () => {
+    test.use({ hasTouch: false, viewport: { width: 800, height: 900 } });
+
+    test('offers a preview button and no insert button', async ({ page }) => {
+      await openWords(page);
+
+      await expect(Lib.getOpenModal(page).getByRole('button', { name: 'Preview', exact: true })).toBeVisible();
+      await expect(Lib.getOpenModal(page).getByRole('button', { name: 'Insert', exact: true })).toHaveCount(0);
+    });
+
+    test('marks rows as clickable', expectRowsToBeClickable);
+
+    test('leaves the highlight untouched while the pointer travels over the list', async ({ page }) => {
+      await openWords(page);
+      await expect(Lib.getWord(page, 0)).toHaveAttribute('aria-current', 'true');
+
+      await Lib.hoverWord(page, 3, 5, 'horizontal');
+      await expect(Lib.getWord(page, 0)).toHaveAttribute('aria-current', 'true');
+      await expect(Lib.getWord(page, 1)).not.toHaveAttribute('aria-current');
+
+      await Lib.moveMouseAway(page);
+      await expect(Lib.getWord(page, 0)).toHaveAttribute('aria-current', 'true');
+      await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 3));
+      await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 5));
+    });
+
+    test('picks the clicked word and keeps the modal open when it is clicked again', async ({ page }) => {
+      await openWords(page);
+
+      await Lib.getWord(page, 1).click();
+      await expect(Lib.getWord(page, 1)).toHaveAttribute('aria-current', 'true');
+      await expect(Lib.getWord(page, 0)).not.toHaveAttribute('aria-current');
+      await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 5));
+
+      await Lib.getWord(page, 1).click();
+      await Lib.expectModalToStayOpen(page);
+      await expect(Lib.getWord(page, 1)).toHaveAttribute('aria-current', 'true');
+      await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 5));
+    });
+
+    test('keeps the highlight when previewing and drops it when closing', async ({ page }) => {
+      await openWords(page);
+      await Lib.getWord(page, 1).click();
+
+      await Lib.getOpenModal(page).getByRole('button', { name: 'Preview', exact: true }).click();
+      await expect(Lib.getModal(page)).toHaveCount(0);
+      await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 5));
+
+      await Lib.openWordsModal(page);
+      await Lib.closeModalWithButton(page);
+      await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 5));
+    });
+  });
+
+  test.describe('compact, touch', () => {
+    test.use({ hasTouch: true, viewport: { width: 800, height: 900 } });
+
+    test('offers a preview button and no insert button', async ({ page }) => {
+      await openWords(page);
+
+      await expect(Lib.getOpenModal(page).getByRole('button', { name: 'Preview', exact: true })).toBeVisible();
+      await expect(Lib.getOpenModal(page).getByRole('button', { name: 'Insert', exact: true })).toHaveCount(0);
+    });
+
+    test('marks rows as clickable', expectRowsToBeClickable);
+
+    test('picks the tapped word and previews it when it is tapped again', expectRepeatedTapToPreview);
+
+    test('drops the highlight when the modal is closed', expectClosingToDropTheHighlight);
+  });
+
+  test.describe('desktop, non-touch', () => {
+    test.use({ hasTouch: false, viewport: { width: 1440, height: 900 } });
+
+    test('offers no preview or insert button', expectNoFooterButtons);
+
+    test('does not mark rows as clickable', async ({ page }) => {
+      await openWords(page);
+
+      await Lib.expectRowClickable(Lib.getWord(page, 0), false);
+    });
+
+    test('hands the highlight over to the hovered row', async ({ page }) => {
+      await openWords(page);
+      const idleBackground = await getBackgroundColor(Lib.getWord(page, 1));
+
+      await Lib.getWord(page, 1).click();
+      await expect(Lib.getWord(page, 1)).toHaveAttribute('aria-current', 'true');
+      expect(await getBackgroundColor(Lib.getWord(page, 1))).not.toBe(idleBackground);
+
+      await Lib.hoverWord(page, 3, 3, 'horizontal');
+      await expect(Lib.getWord(page, 0)).toHaveAttribute('aria-current', 'true');
+      await expect(Lib.getWord(page, 1)).not.toHaveAttribute('aria-current');
+      await expect(Lib.getWord(page, 1)).toBeFocused();
+      expect(await getBackgroundColor(Lib.getWord(page, 1))).toBe(idleBackground);
+
+      await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 3));
+      await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 5));
+    });
+
+    test('ignores clicks and drops the highlight when the pointer leaves the list', async ({ page }) => {
+      await openWords(page);
+
+      await Lib.getWord(page, 1).click();
+      await expect(Lib.getWord(page, 1)).toHaveAttribute('aria-current', 'true');
+
+      await Lib.getWord(page, 1).click();
+      await Lib.expectModalToStayOpen(page);
+
+      await Lib.moveMouseAway(page);
+      await expect(Lib.getWord(page, 1)).not.toHaveAttribute('aria-current');
+      await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 5));
+    });
+  });
+
+  test.describe('desktop, touch', () => {
+    test.use({ hasTouch: true, viewport: { width: 1440, height: 900 } });
+
+    test('offers no preview or insert button', expectNoFooterButtons);
+
+    test('marks rows as clickable', expectRowsToBeClickable);
+
+    test('picks the tapped word and previews it when it is tapped again', expectRepeatedTapToPreview);
+
+    test('drops the highlight when the modal is closed', expectClosingToDropTheHighlight);
+  });
+});
+
+async function expectRowsToBeClickable({ page }: { page: Page }): Promise<void> {
+  await openWords(page);
+
+  await Lib.expectRowClickable(Lib.getWord(page, 0), true);
+}
+
+async function expectRepeatedTapToPreview({ page }: { page: Page }): Promise<void> {
+  await openWords(page);
+
+  await Lib.getWord(page, 1).click();
+  await expect(Lib.getWord(page, 1)).toHaveAttribute('aria-current', 'true');
+  await Lib.expectModalToStayOpen(page);
+  await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 5));
+
+  await Lib.getWord(page, 1).click();
+  await expect(Lib.getModal(page)).toHaveCount(0);
+  await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 5));
+}
+
+async function expectClosingToDropTheHighlight({ page }: { page: Page }): Promise<void> {
+  await openWords(page);
+  await Lib.getWord(page, 1).click();
+  await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 5));
+
+  await Lib.closeModalWithButton(page);
+  await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 5));
+}
+
+async function expectNoFooterButtons({ page }: { page: Page }): Promise<void> {
+  await openWords(page);
+
+  await expect(Lib.getOpenModal(page).getByRole('button', { name: 'Preview', exact: true })).toHaveCount(0);
+  await expect(Lib.getOpenModal(page).getByRole('button', { name: 'Insert', exact: true })).toHaveCount(0);
+}
+
+async function openWords(page: Page): Promise<void> {
+  await Lib.preferKeyboardInput(page);
+  await Lib.visitIndex(page);
+  await Lib.typeBoard(page, 'cat', 'horizontal', { x: 3, y: 3 });
+  await Lib.typeBoard(page, 'dog', 'horizontal', { x: 3, y: 5 });
+  await Lib.openWordsModal(page);
+}
+
+function getBackgroundColor(row: Locator): Promise<string> {
+  return row.evaluate((element) => globalThis.getComputedStyle(element).backgroundColor);
+}

package/e2e/features/words-preview.spec.ts

@@ -0,0 +1,140 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+test.describe('Words preview', () => {
+  test.use({ hasTouch: true, viewport: { width: 800, height: 900 } });
+
+  test.beforeEach(async ({ page }) => {
+    await Lib.preferKeyboardInput(page);
+  });
+
+  test('selects the first word on open and previews the selected word on the board', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'cat', 'horizontal', { x: 3, y: 3 });
+    await Lib.typeBoard(page, 'dog', 'horizontal', { x: 3, y: 5 });
+    await Lib.openWordsModal(page);
+
+    await expect(Lib.getWord(page, 0)).toHaveAttribute('aria-current', 'true');
+
+    await Lib.getWord(page, 1).click();
+    await expect(Lib.getWord(page, 1)).toHaveAttribute('aria-current', 'true');
+    await expect(Lib.getWord(page, 0)).not.toHaveAttribute('aria-current');
+
+    await Lib.getOpenModal(page).getByRole('button', { name: 'Preview', exact: true }).click();
+    await expect(Lib.getOpenModal(page)).toHaveCount(0);
+    await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 5));
+    await Lib.expectTileHighlighted(Lib.getBoardTile(page, 4, 5));
+    await Lib.expectTileHighlighted(Lib.getBoardTile(page, 5, 5));
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 3));
+  });
+
+  test('highlights either the result candidate or the selected word, never both', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'cat', 'horizontal', { x: 3, y: 3 });
+    await Lib.typeRack(page, 's');
+    await Lib.solve(page);
+
+    await Lib.openWordsModal(page);
+    await Lib.getOpenModal(page).getByRole('button', { name: 'Preview', exact: true }).click();
+    await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 3));
+
+    await page.getByRole('button', { name: 'Results', exact: true }).click();
+    const result = Lib.getOpenModal(page).getByTestId('result').first();
+    await expect(result).not.toHaveAttribute('aria-current');
+    await result.click();
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 3));
+  });
+
+  test('clears the highlights when the layout breakpoint changes', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'cat', 'horizontal', { x: 3, y: 3 });
+    await Lib.openWordsModal(page);
+    await Lib.getOpenModal(page).getByRole('button', { name: 'Preview', exact: true }).click();
+    await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 3));
+
+    await page.setViewportSize({ width: 1280, height: 900 });
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 3));
+  });
+
+  test('drops the highlight when the modal is closed without previewing', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'cat', 'horizontal', { x: 3, y: 3 });
+    await Lib.openWordsModal(page);
+    await expect(Lib.getWord(page, 0)).toHaveAttribute('aria-current', 'true');
+
+    await page.keyboard.press('Escape');
+    await expect(Lib.getOpenModal(page)).toHaveCount(0);
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 3));
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 4, 3));
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 5, 3));
+  });
+
+  test('drops the highlight when the language changes', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'cat', 'horizontal', { x: 3, y: 3 });
+    await Lib.openWordsModal(page);
+    await Lib.getOpenModal(page).getByRole('button', { name: 'Preview', exact: true }).click();
+    await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 3));
+
+    await Lib.getSettingsButton(page).click();
+    await Lib.getSettingOption(page, 'Language', 'Polski').check();
+    await Lib.closeModal(page);
+
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 3));
+  });
+
+  test('drops the selection when the selected word is edited on the board', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'cat', 'horizontal', { x: 3, y: 3 });
+    await Lib.typeBoard(page, 'dog', 'horizontal', { x: 3, y: 5 });
+    await Lib.openWordsModal(page);
+    await Lib.getWord(page, 1).click();
+    await expect(Lib.getWord(page, 1)).toHaveAttribute('aria-current', 'true');
+
+    await Lib.getBoardTile(page, 3, 5).focus();
+    await page.keyboard.type('z');
+
+    await expect(page.getByTestId('word-3-5-horizontal')).toHaveAttribute('aria-label', 'zog');
+    await expect(page.getByTestId('word-3-5-horizontal')).not.toHaveAttribute('aria-current');
+    await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 5));
+  });
+
+  test.describe('wide enough not to select the first word', () => {
+    test.use({ viewport: { width: 1280, height: 900 } });
+
+    test('forgets the previewed word when the board is cleared', async ({ page }) => {
+      await Lib.visitIndex(page);
+      await Lib.typeBoard(page, 'zvq', 'horizontal', { x: 3, y: 3 });
+      await Lib.openWordsModal(page);
+      await Lib.getWord(page, 0).click();
+      await Lib.getWord(page, 0).click();
+      await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 3));
+
+      await page.getByRole('button', { name: 'Clear', exact: true }).click();
+      await Lib.typeBoard(page, 'zvq', 'horizontal', { x: 3, y: 3 });
+      await Lib.openWordsModal(page);
+
+      await expect(Lib.getWord(page, 0)).toHaveAttribute('aria-label', 'zvq');
+      await expect(Lib.getWord(page, 0)).not.toHaveAttribute('aria-current');
+      await Lib.expectTileNotHighlighted(Lib.getBoardTile(page, 3, 3));
+    });
+  });
+
+  test.describe('phone', () => {
+    test.use({ viewport: { width: 420, height: 900 } });
+
+    test('previewing from the menu-opened modal returns to the board', async ({ page }) => {
+      await Lib.visitIndex(page);
+      await Lib.typeBoard(page, 'cat', 'horizontal', { x: 3, y: 3 });
+      await page.getByRole('button', { name: 'Menu', exact: true }).click();
+      await Lib.getOpenModal(page).getByLabel('Created words', { exact: true }).click();
+
+      await expect(Lib.getWord(page, 0)).toHaveAttribute('aria-current', 'true');
+
+      await page.getByRole('button', { name: 'Preview', exact: true }).click();
+      await expect(Lib.getModal(page)).toHaveCount(0);
+      await Lib.expectTileHighlighted(Lib.getBoardTile(page, 3, 3));
+    });
+  });
+});

package/e2e/features/words-table-filtering.spec.ts

@@ -0,0 +1,22 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+test.describe('Words table filtering', () => {
+  test('groups matching words first and dims the rest', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'cat', 'horizontal', { x: 3, y: 3 });
+    await Lib.typeBoard(page, 'dog', 'horizontal', { x: 3, y: 5 });
+    await Lib.openWordsModal(page);
+
+    await Lib.assertWord(page, 0, 'cat');
+    await Lib.assertWord(page, 1, 'dog');
+
+    await Lib.getWordsFilterInput(page).pressSequentially('d');
+
+    await Lib.assertWord(page, 0, 'dog');
+    await Lib.assertWord(page, 1, 'cat');
+    await expect(Lib.getWord(page, 0)).not.toHaveAttribute('aria-hidden');
+    await expect(Lib.getWord(page, 1)).toHaveAttribute('aria-hidden', 'true');
+  });
+});

package/e2e/features/words-table-sorting.spec.ts

@@ -0,0 +1,33 @@
+import { expect, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+test.describe('Words table sorting', () => {
+  test('sorts by word, validity, and coordinates with the results-table sort behavior', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'cat', 'horizontal', { x: 3, y: 3 });
+    await Lib.typeBoard(page, 'zvq', 'horizontal', { x: 3, y: 5 });
+    await Lib.openWordsModal(page);
+    const modal = Lib.getOpenModal(page);
+
+    await Lib.assertWord(page, 0, 'cat');
+    await Lib.assertWord(page, 1, 'zvq');
+    await expect(Lib.getWord(page, 0)).toContainText('4D');
+
+    await modal.getByRole('button', { name: 'Word', exact: true }).click();
+    await Lib.assertWord(page, 0, 'zvq');
+    await Lib.assertWord(page, 1, 'cat');
+
+    await modal.getByRole('button', { name: 'Validity', exact: true }).click();
+    await Lib.assertWord(page, 0, 'cat');
+    await Lib.assertWord(page, 1, 'zvq');
+
+    await modal.getByRole('button', { name: 'Validity', exact: true }).click();
+    await Lib.assertWord(page, 0, 'zvq');
+    await Lib.assertWord(page, 1, 'cat');
+
+    await modal.getByRole('button', { name: 'Coordinates', exact: true }).click();
+    await Lib.assertWord(page, 0, 'cat');
+    await Lib.assertWord(page, 1, 'zvq');
+  });
+});

package/e2e/lib/actions.ts

@@ -2,15 +2,21 @@ import { expect, type Locator, type Page } from '@playwright/test';
 import { type Direction } from '@scrabble-solver/types';
 
 import {
+  getBoardContainer,
   getBoardTile,
   getLoading,
   getModal,
+  getModalResult,
   getOpenModal,
   getRackTile,
   getResult,
+  getResultCandidatePicker,
   getResultsContainer,
+  getWord,
 } from './selectors';
 
+const MODAL_CLOSE_TRANSITION_TIMEOUT = 500;
+
 interface BoardPosition {
   x?: number;
   y?: number;
@@ -20,12 +26,38 @@ export async function visitIndex(page: Page): Promise<void> {
   await page.goto('/');
 }
 
+export async function preferKeyboardInput(page: Page): Promise<void> {
+  await page.addInitScript(() => {
+    localStorage.setItem('scrabble-solver.settings', JSON.stringify({ inputMode: 'keyboard' }));
+  });
+}
+
 export async function closeModal(page: Page): Promise<void> {
   await expect(getOpenModal(page)).toBeVisible();
   await page.keyboard.press('Escape');
   await expect(getModal(page)).toHaveCount(0);
 }
 
+export async function openWordsModal(page: Page): Promise<void> {
+  await page.getByLabel('Created words', { exact: true }).click();
+  await expect(getOpenModal(page)).toBeVisible();
+}
+
+export async function openResultsModal(page: Page): Promise<void> {
+  await getResultCandidatePicker(page).click();
+  await expect(getOpenModal(page)).toBeVisible();
+}
+
+export async function closeModalWithButton(page: Page): Promise<void> {
+  await getOpenModal(page).getByLabel('Close', { exact: true }).click();
+  await expect(getModal(page)).toHaveCount(0);
+}
+
+export async function expectModalToStayOpen(page: Page): Promise<void> {
+  await page.waitForTimeout(MODAL_CLOSE_TRANSITION_TIMEOUT);
+  await expect(getOpenModal(page)).toBeVisible();
+}
+
 export async function typeRack(page: Page, tiles: string, index = 0): Promise<void> {
   await getRackTile(page, index).focus();
   await page.keyboard.type(tiles);
@@ -79,16 +111,34 @@ export async function solve(page: Page): Promise<void> {
   await expect(getLoading(page)).toHaveCount(0);
 }
 
-/**
- * react-window remounts rows during its initial measure pass, and a row
- * replaced under an already-hovered cursor never receives a new mouseenter -
- * let the list settle before hovering.
- */
 export async function hoverResult(page: Page, index = 0): Promise<void> {
-  await page.waitForTimeout(100);
+  await waitForReactWindowToSettle(page);
   await getResult(page, index).hover();
 }
 
+export async function hoverModalResult(page: Page, index = 0): Promise<void> {
+  await waitForReactWindowToSettle(page);
+  await getModalResult(page, index).hover();
+}
+
+export async function hoverWord(page: Page, x: number, y: number, direction: Direction): Promise<void> {
+  await waitForReactWindowToSettle(page);
+  await page.getByTestId(`word-${x}-${y}-${direction}`).hover();
+}
+
+async function waitForReactWindowToSettle(page: Page) {
+  /**
+   * react-window remounts rows during its initial measure pass, and a row
+   * replaced under an already-hovered cursor never receives a new mouseenter -
+   * let the list settle before hovering.
+   */
+  await page.waitForTimeout(100);
+}
+
+export async function assertWord(page: Page, index: number, word: string): Promise<void> {
+  await expect(getWord(page, index)).toHaveAttribute('aria-label', word);
+}
+
 export async function assertResult(page: Page, index: number, word: string, points: number): Promise<void> {
   const result = getResult(page, index);
 
@@ -97,6 +147,26 @@ export async function assertResult(page: Page, index: number, word: string, poin
   await expect(result.getByTestId('points')).toHaveText(String(points));
 }
 
+export async function expectBoardCharacters(page: Page, characters: string[]): Promise<void> {
+  await expect
+    .poll(() =>
+      getBoardContainer(page)
+        .getByRole('textbox', { includeHidden: true })
+        .evaluateAll((inputs) => inputs.map((input) => (input as HTMLInputElement).value).filter(Boolean)),
+    )
+    .toEqual(characters);
+}
+
+export async function expectRowClickable(row: Locator, clickable: boolean): Promise<void> {
+  const cursor = await row.evaluate((element) => globalThis.getComputedStyle(element).cursor);
+
+  if (clickable) {
+    expect(cursor).toBe('pointer');
+  } else {
+    expect(cursor).not.toBe('pointer');
+  }
+}
+
 export async function expectTileHighlighted(tile: Locator): Promise<void> {
   await expect(tile.locator('..')).toHaveAttribute('role', 'mark');
 }

package/e2e/lib/selectors.ts

@@ -22,13 +22,19 @@ export function getDictionary(page: Page): Locator {
 }
 
 export function getDictionaryInput(page: Page): Locator {
-  return getDictionary(page).getByRole('textbox');
+  return getDictionary(page).getByRole('textbox', {
+    includeHidden: true, // so that the dictionary can be asserted on while modal is opened
+  });
 }
 
 export function getDictionaryTitles(page: Page): Locator {
   return getDictionary(page).locator('h2');
 }
 
+export function getModalDictionary(page: Page): Locator {
+  return getOpenModal(page).locator('[class*="dictionary"]');
+}
+
 export function getLoading(page: Page): Locator {
   return page.getByTestId('loading');
 }
@@ -38,8 +44,11 @@ export function getRackContainer(page: Page): Locator {
 }
 
 export function getRackTile(page: Page, index = 0): Locator {
-  // includeHidden: true so that rack can be interacted with while modal is opened
-  return getRackContainer(page).getByRole('textbox', { includeHidden: true }).nth(index);
+  return getRackContainer(page)
+    .getByRole('textbox', {
+      includeHidden: true, // so that rack can be interacted with while modal is opened
+    })
+    .nth(index);
 }
 
 export function getResultsContainer(page: Page): Locator {
@@ -58,6 +67,34 @@ export function getResult(page: Page, index = 0): Locator {
   return getResults(page).nth(index);
 }
 
+export function getResultCandidatePicker(page: Page): Locator {
+  return page.getByTestId('result-candidate-picker');
+}
+
+export function getModalResults(page: Page): Locator {
+  return getOpenModal(page).getByTestId('result');
+}
+
+export function getModalResult(page: Page, index = 0): Locator {
+  return getModalResults(page).nth(index);
+}
+
+export function getWordsContainer(page: Page): Locator {
+  return page.getByTestId('words');
+}
+
+export function getWords(page: Page): Locator {
+  return getWordsContainer(page).locator('[data-testid^="word-"]');
+}
+
+export function getWord(page: Page, index = 0): Locator {
+  return getWords(page).nth(index);
+}
+
+export function getWordsFilterInput(page: Page): Locator {
+  return getWordsContainer(page).getByRole('textbox');
+}
+
 export function getSettingsButton(page: Page): Locator {
   return page.getByTestId('settings-button');
 }

package/lerna.json

@@ -6,6 +6,6 @@
     "access": "public"
   },
   "tagVersionPrefix": "",
-  "version": "2.18.1",
+  "version": "2.18.3",
   "$schema": "node_modules/lerna/schemas/lerna-schema.json"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "scrabble-solver",
-  "version": "2.18.1",
-  "description": "Scrabble Solver 2 - Free, open-source, cross-platform, multi-language analysis tool for Scrabble, Scrabble Duel, Super Scrabble, Letter League, Crossplay, Literaki, and Kelimelik. Quickly find the top-scoring words using the given board and tiles.",
+  "version": "2.18.3",
+  "description": "Scrabble Solver 2 - Free, open-source, cross-platform, multi-language analysis tool for Scrabble, Scrabble Duel, Super Scrabble, Letter League, Crossplay, Literaki, Kelimelik, and Wyrazy. Quickly find the top-scoring words using the given board and tiles.",
   "keywords": [
     "scrabble",
     "scrabble-solver",
@@ -17,11 +17,12 @@
     "crossplay",
     "literaki",
     "kelimelik",
+    "wyrazy",
     "board game",
     "gaddag"
   ],
   "engines": {
-    "bun": ">=1.3",
+    "bun": ">=1.4",
     "node": ">=24"
   },
   "bin": {
@@ -42,7 +43,7 @@
     "release:publish": "bun run version:bump && np --no-cleanup --package-manager bun && lerna publish from-package --yes",
     "screencast": "start-server-and-test start:app http://localhost:3333 screencast:record",
     "screencast:record": "bun scripts/record-screencast.ts",
-    "start": "concurrently -n w: bun:start:*",
+    "start": "bun run --parallel --no-orphans 'start:*'",
     "start:app": "bun run --cwd packages/scrabble-solver start",
     "start:browser": "wait-on http://localhost:3333 && open-cli http://localhost:3333",
     "test": "bun run build && bun run test-unit && start-server-and-test start:app http://localhost:3333 test-playwright:run",
@@ -79,23 +80,22 @@
     "packages/scrabble-solver"
   ],
   "dependencies": {
-    "@scrabble-solver/scrabble-solver": "^2.18.1",
-    "concurrently": "^10.0.5",
+    "@scrabble-solver/scrabble-solver": "^2.18.3",
     "open-cli": "^9.0.0",
     "wait-on": "^9.1.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.62.1",
-    "@types/bun": "^1.3.14",
+    "@types/bun": "^1.4.0",
     "@types/node": "^26.2.0",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-playwright": "^2.11.0",
     "eslint-plugin-react": "^7.37.5",
-    "lerna": "^10.0.0",
+    "lerna": "^10.0.1",
     "np": "^12.0.1",
-    "oxfmt": "^0.63.0",
-    "oxlint": "^1.78.0",
+    "oxfmt": "^0.64.0",
+    "oxlint": "^1.79.0",
     "oxlint-tsgolint": "^7.0.2001",
     "rimraf": "^6.1.3",
     "start-server-and-test": "^3.0.12",

package/packages/configs/build/games/index.d.ts

@@ -5,3 +5,4 @@ export * from './literaki';
 export * from './scrabble';
 export * from './scrabbleDuel';
 export * from './superScrabble';
+export * from './wyrazy';

package/packages/configs/build/games/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./literaki"), exports);
 __exportStar(require("./scrabble"), exports);
 __exportStar(require("./scrabbleDuel"), exports);
 __exportStar(require("./superScrabble"), exports);
+__exportStar(require("./wyrazy"), exports);

package/packages/configs/build/games/wyrazy.d.ts

@@ -0,0 +1,19 @@
+import { Game } from '@scrabble-solver/types';
+export declare const wyrazy: {
+    bingo: {
+        score: number;
+    };
+    blankScore: number;
+    blanksCount: number;
+    boardHeight: number;
+    boardWidth: number;
+    game: Game;
+    name: string;
+    rackSize: number;
+    bonuses: {
+        multiplier: number;
+        type: string;
+        x: number;
+        y: number;
+    }[];
+};