scrabble-solver 2.16.7 → 2.18.0

package/e2e/features/solver-paths.spec.ts

@@ -0,0 +1,45 @@
+import { expect, type Page, test } from '@playwright/test';
+
+import * as Lib from '../lib';
+
+test.describe('Solver paths', () => {
+  test('solves through the server when no dictionary is available locally', async ({ page }) => {
+    await page.route('**/api/dictionary/*', (route) => route.fulfill({ status: 503 }));
+    const solveResponse = page.waitForResponse('**/api/solve');
+    await Lib.visitIndex(page);
+    await Lib.typeBoard(page, 'i', 'horizontal', { x: 7, y: 7 });
+    await Lib.typeRack(page, 'q');
+    await Lib.solve(page);
+    await solveResponse;
+
+    await expect(Lib.getResults(page)).toHaveCount(2);
+    await Lib.assertResult(page, 0, 'qi', 11);
+  });
+
+  test('solves locally once the dictionary is cached', async ({ page }) => {
+    await Lib.visitIndex(page);
+    await waitForCachedDictionary(page);
+
+    let solveRequestCount = 0;
+    await page.route('**/api/solve', (route) => {
+      solveRequestCount += 1;
+      return route.continue();
+    });
+    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);
+    expect(solveRequestCount).toBe(0);
+  });
+});
+
+function waitForCachedDictionary(page: Page): Promise<void> {
+  return expect.poll(() => page.evaluate(isDictionaryCached), { timeout: 30000 }).toBe(true);
+}
+
+async function isDictionaryCached(): Promise<boolean> {
+  const cache = await caches.open('dictionary-api-cache');
+  return typeof (await cache.match('/api/dictionary/en-US')) !== 'undefined';
+}

package/e2e/lib/actions.ts

@@ -0,0 +1,119 @@
+import { expect, type Locator, type Page } from '@playwright/test';
+import { type Direction } from '@scrabble-solver/types';
+
+import {
+  getBoardTile,
+  getLoading,
+  getModal,
+  getOpenModal,
+  getRackTile,
+  getResult,
+  getResultsContainer,
+} from './selectors';
+
+interface BoardPosition {
+  x?: number;
+  y?: number;
+}
+
+export async function visitIndex(page: Page): Promise<void> {
+  await page.goto('/');
+}
+
+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 typeRack(page: Page, tiles: string, index = 0): Promise<void> {
+  await getRackTile(page, index).focus();
+  await page.keyboard.type(tiles);
+}
+
+export async function typeBoard(
+  page: Page,
+  tiles: string,
+  direction: Direction,
+  { x = 0, y = 0 }: BoardPosition = {},
+): Promise<void> {
+  await getBoardTile(page, x, y).focus();
+  await ensureDirection(page, direction);
+
+  for (let index = 0; index < tiles.length; ++index) {
+    const xOffset = direction === 'horizontal' ? index : 0;
+    const yOffset = direction === 'vertical' ? index : 0;
+
+    await getBoardTile(page, x + xOffset, y + yOffset).focus();
+    await page.keyboard.type(tiles[index]);
+  }
+}
+
+export async function paste(target: Locator, text: string): Promise<void> {
+  await target.focus();
+  await target.evaluate((element, value) => {
+    const pasteEvent = new ClipboardEvent('paste', {
+      bubbles: true,
+      clipboardData: new DataTransfer(),
+    });
+
+    pasteEvent.clipboardData?.setData('text/plain', value);
+    element.dispatchEvent(pasteEvent);
+  }, text);
+}
+
+export async function pasteBoard(
+  page: Page,
+  word: string,
+  direction: Direction,
+  { x = 0, y = 0 }: BoardPosition = {},
+): Promise<void> {
+  await getBoardTile(page, x, y).focus();
+  await ensureDirection(page, direction);
+  await paste(getBoardTile(page, x, y), word);
+}
+
+export async function solve(page: Page): Promise<void> {
+  await getRackTile(page).evaluate((input: HTMLInputElement) => input.form?.requestSubmit());
+  await expect(getResultsContainer(page)).toHaveAttribute('data-outdated', 'false', { timeout: 90_000 });
+  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 getResult(page, index).hover();
+}
+
+export async function assertResult(page: Page, index: number, word: string, points: number): Promise<void> {
+  const result = getResult(page, index);
+
+  await expect(result).toHaveAttribute('aria-label', word);
+  await expect(result).toContainText(word);
+  await expect(result.getByTestId('points')).toHaveText(String(points));
+}
+
+export async function expectTileHighlighted(tile: Locator): Promise<void> {
+  await expect(tile.locator('..')).toHaveAttribute('role', 'mark');
+}
+
+export async function expectTileNotHighlighted(tile: Locator): Promise<void> {
+  await expect(tile.locator('..')).not.toHaveAttribute('role', 'mark');
+}
+
+export async function moveMouseAway(page: Page): Promise<void> {
+  const viewport = page.viewportSize();
+  await page.mouse.move((viewport?.width ?? 0) / 2, 0);
+}
+
+async function ensureDirection(page: Page, direction: Direction): Promise<void> {
+  const toggleDirectionButton = page.getByTestId('toggle-direction-button');
+
+  if ((await toggleDirectionButton.getAttribute('data-direction')) !== direction) {
+    await toggleDirectionButton.click();
+  }
+}

package/e2e/lib/selectors.ts

@@ -0,0 +1,71 @@
+import { type Locator, type Page } from '@playwright/test';
+
+export function getModal(page: Page): Locator {
+  return page.getByRole('dialog');
+}
+
+export function getOpenModal(page: Page): Locator {
+  return page.locator('.ReactModal__Overlay--after-open').getByRole('dialog');
+}
+
+export function getBoardContainer(page: Page): Locator {
+  return page.getByTestId('board');
+}
+
+export function getBoardTile(page: Page, x = 0, y = 0, boardWidth = 15): Locator {
+  const index = y * boardWidth + x;
+  return getBoardContainer(page).getByRole('textbox', { includeHidden: true }).nth(index);
+}
+
+export function getDictionary(page: Page): Locator {
+  return page.getByTestId('dictionary');
+}
+
+export function getDictionaryInput(page: Page): Locator {
+  return getDictionary(page).getByRole('textbox');
+}
+
+export function getDictionaryTitles(page: Page): Locator {
+  return getDictionary(page).locator('h2');
+}
+
+export function getLoading(page: Page): Locator {
+  return page.getByTestId('loading');
+}
+
+export function getRackContainer(page: Page): Locator {
+  return page.getByTestId('rack');
+}
+
+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);
+}
+
+export function getResultsContainer(page: Page): Locator {
+  return page.getByTestId('results');
+}
+
+export function getResults(page: Page): Locator {
+  return getResultsContainer(page).getByTestId('result');
+}
+
+export function getResultsFilterInput(page: Page): Locator {
+  return getResultsContainer(page).getByRole('textbox');
+}
+
+export function getResult(page: Page, index = 0): Locator {
+  return getResults(page).nth(index);
+}
+
+export function getSettingsButton(page: Page): Locator {
+  return page.getByTestId('settings-button');
+}
+
+export function getSettingOption(page: Page, section: string, option: string): Locator {
+  return getOpenModal(page).getByLabel(section, { exact: true }).getByLabel(option, { exact: true });
+}
+
+export function getTooltip(page: Page): Locator {
+  return page.getByRole('tooltip');
+}

package/e2e/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.json",
+
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["../playwright.config.ts", "./**/*.ts"],
+  "exclude": []
+}

package/lerna.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scrabble-solver",
-  "version": "2.16.7",
+  "version": "2.18.0",
   "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.",
   "keywords": [
     "Scrabble",
@@ -47,23 +47,26 @@
     "scrabble-solver": "./bin/scrabble-solver.js"
   },
   "scripts": {
+    "benchmark": "bun run --filter @scrabble-solver/solver benchmark",
     "build": "bun run --filter './packages/*' build",
     "clean": "bun run --filter './packages/*' clean && rimraf node_modules/",
     "dev": "bun run --filter @scrabble-solver/scrabble-solver dev",
     "format": "oxfmt --check './**/*.{js,ts,tsx,scss}'",
     "format:fix": "oxfmt './**/*.{js,ts,tsx,scss}'",
-    "lint": "oxlint cypress packages",
+    "lint": "oxlint e2e packages",
     "lint:fix": "bun run lint --fix",
     "reinstall": "bun run clean && bun install && bun run build",
     "release": "bun run release:prepare && bun run release:publish",
     "release:prepare": "bun run reinstall",
     "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:app": "bun run --filter @scrabble-solver/scrabble-solver 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-cypress:run",
-    "test-cypress": "cypress open",
-    "test-cypress:run": "CYPRESS_BASE_URL=http://localhost:3333 cypress run",
+    "test": "bun run build && bun run test-unit && start-server-and-test start:app http://localhost:3333 test-playwright:run",
+    "test-playwright": "playwright test --ui",
+    "test-playwright:run": "PLAYWRIGHT_BASE_URL=http://localhost:3333 playwright test",
     "test-unit": "bun run --filter '*' test",
     "version:bump": "bun run version:bump-lerna && bun run version:commit",
     "version:bump-lerna": "lerna version --force-publish --no-git-tag-version --no-push",
@@ -95,28 +98,23 @@
     "packages/scrabble-solver"
   ],
   "dependencies": {
-    "@scrabble-solver/scrabble-solver": "^2.16.7",
-    "concurrently": "^10.0.4",
+    "@scrabble-solver/scrabble-solver": "^2.18.0",
+    "concurrently": "^10.0.5",
     "open-cli": "^9.0.0",
     "wait-on": "^9.1.0"
   },
   "devDependencies": {
-    "@babel/plugin-proposal-class-properties": "^7.18.6",
-    "@cypress/webpack-batteries-included-preprocessor": "^4.2.0",
-    "@cypress/webpack-preprocessor": "^7.1.1",
-    "@testing-library/cypress": "^10.1.3",
+    "@playwright/test": "^1.62.1",
     "@types/bun": "^1.3.14",
-    "@types/node": "^26.1.2",
-    "cypress": "^15.19.0",
-    "cypress-real-events": "^1.15.0",
+    "@types/node": "^26.2.0",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-mocha": "^12.0.1",
+    "eslint-plugin-playwright": "^2.11.0",
     "eslint-plugin-react": "^7.37.5",
     "lerna": "^10.0.0",
     "np": "^12.0.1",
-    "oxfmt": "^0.61.0",
-    "oxlint": "^1.76.0",
+    "oxfmt": "^0.63.0",
+    "oxlint": "^1.78.0",
     "oxlint-tsgolint": "^7.0.2001",
     "rimraf": "^6.1.3",
     "start-server-and-test": "^3.0.12",

package/packages/configs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/configs",
-  "version": "2.16.7",
+  "version": "2.18.0",
   "description": "Scrabble Solver 2 - Configs",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -23,8 +23,8 @@
     "clean": "rimraf build/"
   },
   "dependencies": {
-    "@scrabble-solver/constants": "^2.16.7",
-    "@scrabble-solver/types": "^2.16.7"
+    "@scrabble-solver/constants": "^2.18.0",
+    "@scrabble-solver/types": "^2.18.0"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }

package/packages/constants/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/constants",
-  "version": "2.16.7",
+  "version": "2.18.0",
   "description": "Scrabble Solver 2 - Constants",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/packages/dictionaries/README.md

@@ -1,3 +1,3 @@
 # @scrabble-solver/dictionaries
 
-Downloads, caches & serves dictionaries. Dictionaries are [Trie](https://github.com/kamilmielnik/trie) instances.
+Downloads, caches & serves dictionaries. Dictionaries are [Gaddag](https://github.com/kamilmielnik/gaddag) instances.

package/packages/dictionaries/build/Dictionaries.d.ts

@@ -1,10 +1,10 @@
-import { type Trie } from '@kamilmielnik/trie';
+import { type Gaddag } from '@kamilmielnik/gaddag';
 import { Locale } from '@scrabble-solver/types';
 export declare class Dictionaries {
     private readonly cache;
     private readonly downloadDictionaryProxies;
     constructor();
-    get(locale: Locale): Promise<Trie>;
+    get(locale: Locale): Promise<Gaddag>;
     remove(): void;
     update(force?: boolean): Promise<void>;
     private getLocalesToUpdate;

package/packages/dictionaries/build/Dictionaries.js

@@ -16,9 +16,9 @@ class Dictionaries {
     }
     async get(locale) {
         if (this.cache.has(locale)) {
-            const trie = await this.cache.get(locale);
-            if (trie) {
-                return trie;
+            const gaddag = await this.cache.get(locale);
+            if (gaddag) {
+                return gaddag;
             }
         }
         logger_1.logger.info('Dictionaries - cache miss', { locale });
@@ -40,9 +40,9 @@ class Dictionaries {
         logger_1.logger.info('Dictionaries - updateDictionary', { locale });
         fs_1.default.mkdirSync(constants_1.OUTPUT_DIRECTORY, { recursive: true });
         const downloadDictionaryProxy = this.downloadDictionaryProxies[locale];
-        const trie = await downloadDictionaryProxy();
-        await this.cache.set(locale, trie);
-        return trie;
+        const gaddag = await downloadDictionaryProxy();
+        await this.cache.set(locale, gaddag);
+        return gaddag;
     }
 }
 exports.Dictionaries = Dictionaries;

package/packages/dictionaries/build/lib/DiskCache.d.ts

@@ -1,10 +1,17 @@
-import { Trie } from '@kamilmielnik/trie';
+import { Gaddag } from '@kamilmielnik/gaddag';
 import { type Locale } from '@scrabble-solver/types';
 import type { Cache } from '../types';
-export declare class DiskCache implements Cache<Locale, Trie> {
-    get(locale: Locale): Promise<Trie | undefined>;
+export declare class DiskCache implements Cache<Locale, Gaddag> {
+    private readonly directory;
+    constructor(directory?: string);
+    /**
+     * Returns undefined when the cached file cannot be deserialized (it was
+     * written by an app version with an incompatible format, or it is corrupted)
+     * so that callers re-download and re-serialize the dictionary.
+     */
+    get(locale: Locale): Promise<Gaddag | undefined>;
     getLastModifiedTimestamp(locale: Locale): number | undefined;
     has(locale: Locale): boolean;
     isStale(locale: Locale): boolean | undefined;
-    set(locale: Locale, trie: Trie): Promise<void>;
+    set(locale: Locale, gaddag: Gaddag): Promise<void>;
 }

package/packages/dictionaries/build/lib/DiskCache.js

@@ -4,22 +4,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiskCache = void 0;
-const trie_1 = require("@kamilmielnik/trie");
+const gaddag_1 = require("@kamilmielnik/gaddag");
+const logger_1 = require("@scrabble-solver/logger");
 const fs_1 = __importDefault(require("fs"));
 const constants_1 = require("../constants");
 const getDictionaryFilepath_1 = require("./getDictionaryFilepath");
 class DiskCache {
+    constructor(directory = constants_1.OUTPUT_DIRECTORY) {
+        this.directory = directory;
+    }
+    /**
+     * Returns undefined when the cached file cannot be deserialized (it was
+     * written by an app version with an incompatible format, or it is corrupted)
+     * so that callers re-download and re-serialize the dictionary.
+     */
     async get(locale) {
         if (!this.has(locale)) {
             return undefined;
         }
-        const filepath = (0, getDictionaryFilepath_1.getDictionaryFilepath)(locale);
-        const serialized = await fs_1.default.promises.readFile(filepath, 'utf-8');
-        const trie = trie_1.Trie.deserialize(serialized);
-        return trie;
+        const filepath = (0, getDictionaryFilepath_1.getDictionaryFilepath)(locale, this.directory);
+        try {
+            const serialized = await fs_1.default.promises.readFile(filepath);
+            return gaddag_1.Gaddag.deserialize(new Uint8Array(serialized.buffer, serialized.byteOffset, serialized.byteLength));
+        }
+        catch (error) {
+            logger_1.logger.warn('DiskCache - incompatible or corrupted dictionary file, it will be rebuilt', { error, locale });
+            await fs_1.default.promises.rm(filepath, { force: true });
+            return undefined;
+        }
     }
     getLastModifiedTimestamp(locale) {
-        const filepath = (0, getDictionaryFilepath_1.getDictionaryFilepath)(locale);
+        const filepath = (0, getDictionaryFilepath_1.getDictionaryFilepath)(locale, this.directory);
         if (!fs_1.default.existsSync(filepath)) {
             return undefined;
         }
@@ -27,7 +42,7 @@ class DiskCache {
         return stats.mtimeMs;
     }
     has(locale) {
-        const filepath = (0, getDictionaryFilepath_1.getDictionaryFilepath)(locale);
+        const filepath = (0, getDictionaryFilepath_1.getDictionaryFilepath)(locale, this.directory);
         return fs_1.default.existsSync(filepath);
     }
     isStale(locale) {
@@ -41,9 +56,11 @@ class DiskCache {
         const timeSinceModification = Math.abs(lastModifiedTimestamp - Date.now());
         return timeSinceModification > constants_1.CACHE_STALE_THRESHOLD;
     }
-    async set(locale, trie) {
-        const filepath = (0, getDictionaryFilepath_1.getDictionaryFilepath)(locale);
-        await fs_1.default.promises.writeFile(filepath, trie.serialize());
+    async set(locale, gaddag) {
+        const filepath = (0, getDictionaryFilepath_1.getDictionaryFilepath)(locale, this.directory);
+        await fs_1.default.promises.writeFile(filepath, gaddag.serialize());
+        // Serialized-trie cache from before the GADDAG migration - remove this in #437
+        await fs_1.default.promises.rm((0, getDictionaryFilepath_1.getLegacyDictionaryFilepath)(locale, this.directory), { force: true });
     }
 }
 exports.DiskCache = DiskCache;

package/packages/dictionaries/build/lib/LayeredCache.d.ts

@@ -1,12 +1,12 @@
-import { type Trie } from '@kamilmielnik/trie';
+import { type Gaddag } from '@kamilmielnik/gaddag';
 import { type Locale } from '@scrabble-solver/types';
 import type { Cache } from '../types';
-export declare class LayeredCache implements Cache<Locale, Trie> {
+export declare class LayeredCache implements Cache<Locale, Gaddag> {
     private readonly layers;
-    get(locale: Locale): Promise<Trie | undefined>;
+    get(locale: Locale): Promise<Gaddag | undefined>;
     getLastModifiedTimestamp(locale: Locale): number | undefined;
     has(locale: Locale): boolean;
     isStale(locale: Locale): boolean | undefined;
-    set(locale: Locale, trie: Trie): Promise<void>;
+    set(locale: Locale, gaddag: Gaddag): Promise<void>;
     private getLastModifiedLayer;
 }

package/packages/dictionaries/build/lib/LayeredCache.js

@@ -39,10 +39,10 @@ class LayeredCache {
         }
         return false;
     }
-    async set(locale, trie) {
+    async set(locale, gaddag) {
         const [memoryCache, diskCache] = this.layers;
-        await diskCache.set(locale, trie);
-        await memoryCache.set(locale, trie);
+        await diskCache.set(locale, gaddag);
+        await memoryCache.set(locale, gaddag);
     }
     getLastModifiedLayer(locale) {
         const layers = this.layers.filter((cache) => cache.has(locale));

package/packages/dictionaries/build/lib/MemoryCache.d.ts

@@ -1,12 +1,12 @@
-import { type Trie } from '@kamilmielnik/trie';
+import { type Gaddag } from '@kamilmielnik/gaddag';
 import { type Locale } from '@scrabble-solver/types';
 import type { Cache } from '../types';
-export declare class MemoryCache implements Cache<Locale, Trie> {
+export declare class MemoryCache implements Cache<Locale, Gaddag> {
     private readonly cache;
     private readonly cacheTimestamps;
-    get(locale: Locale): Promise<Trie | undefined>;
+    get(locale: Locale): Promise<Gaddag | undefined>;
     getLastModifiedTimestamp(locale: Locale): number | undefined;
     has(locale: Locale): boolean;
     isStale(locale: Locale): boolean | undefined;
-    set(locale: Locale, trie: Trie): Promise<void>;
+    set(locale: Locale, gaddag: Gaddag): Promise<void>;
 }

package/packages/dictionaries/build/lib/MemoryCache.js

@@ -24,9 +24,9 @@ class MemoryCache {
         const timeSinceModification = Math.abs(timestamp - Date.now());
         return timeSinceModification > constants_1.CACHE_STALE_THRESHOLD;
     }
-    set(locale, trie) {
+    set(locale, gaddag) {
         this.cacheTimestamps[locale] = Date.now();
-        this.cache[locale] = trie;
+        this.cache[locale] = gaddag;
         return Promise.resolve();
     }
 }

package/packages/dictionaries/build/lib/createCacheTimestampComparator.d.ts

@@ -1,4 +1,4 @@
-import { type Trie } from '@kamilmielnik/trie';
+import { type Gaddag } from '@kamilmielnik/gaddag';
 import { type Locale } from '@scrabble-solver/types';
 import type { Cache } from '../types';
-export declare const createCacheTimestampComparator: (locale: Locale) => (a: Cache<Locale, Trie>, b: Cache<Locale, Trie>) => number;
+export declare const createCacheTimestampComparator: (locale: Locale) => (a: Cache<Locale, Gaddag>, b: Cache<Locale, Gaddag>) => number;

package/packages/dictionaries/build/lib/downloadDictionary.d.ts

@@ -1,3 +1,3 @@
-import { Trie } from '@kamilmielnik/trie';
+import { Gaddag } from '@kamilmielnik/gaddag';
 import { type Locale } from '@scrabble-solver/types';
-export declare const downloadDictionary: (locale: Locale) => Promise<Trie>;
+export declare const downloadDictionary: (locale: Locale) => Promise<Gaddag>;

package/packages/dictionaries/build/lib/downloadDictionary.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadDictionary = void 0;
-const trie_1 = require("@kamilmielnik/trie");
+const gaddag_1 = require("@kamilmielnik/gaddag");
 const logger_1 = require("@scrabble-solver/logger");
 const word_lists_1 = require("@scrabble-solver/word-lists");
 const downloadDictionary = async (locale) => {
     logger_1.logger.info('downloadDictionary', { locale });
     const words = await (0, word_lists_1.getWordList)(locale);
     logger_1.logger.info('downloadDictionary - success', { locale });
-    const trie = trie_1.Trie.fromArray(words);
-    return trie;
+    const gaddag = gaddag_1.Gaddag.fromArray(words);
+    logger_1.logger.info('downloadDictionary - gaddag built', { locale });
+    return gaddag;
 };
 exports.downloadDictionary = downloadDictionary;

package/packages/dictionaries/build/lib/getDictionaryFilepath.d.ts

@@ -1,2 +1,4 @@
 import { type Locale } from '@scrabble-solver/types';
-export declare const getDictionaryFilepath: (locale: Locale) => string;
+export declare const getDictionaryFilepath: (locale: Locale, directory?: string) => string;
+/** Filepath of the serialized-trie cache used before the GADDAG migration. Remove in #437. */
+export declare const getLegacyDictionaryFilepath: (locale: Locale, directory?: string) => string;

package/packages/dictionaries/build/lib/getDictionaryFilepath.js

@@ -3,10 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDictionaryFilepath = void 0;
+exports.getLegacyDictionaryFilepath = exports.getDictionaryFilepath = void 0;
 const path_1 = __importDefault(require("path"));
 const constants_1 = require("../constants");
-const getDictionaryFilepath = (locale) => {
-    return path_1.default.resolve(constants_1.OUTPUT_DIRECTORY, `${locale}.txt`);
+const getDictionaryFilepath = (locale, directory = constants_1.OUTPUT_DIRECTORY) => {
+    return path_1.default.resolve(directory, `${locale}.gaddag`);
 };
 exports.getDictionaryFilepath = getDictionaryFilepath;
+/** Filepath of the serialized-trie cache used before the GADDAG migration. Remove in #437. */
+const getLegacyDictionaryFilepath = (locale, directory = constants_1.OUTPUT_DIRECTORY) => {
+    return path_1.default.resolve(directory, `${locale}.txt`);
+};
+exports.getLegacyDictionaryFilepath = getLegacyDictionaryFilepath;