scrabble-solver 2.18.9 → 2.18.10-alpha.1

package/packages/scrabble-solver/src/solver-worker/dictionaries/revalidateDictionary.ts

@@ -1,86 +0,0 @@
-import { type Locale } from '@scrabble-solver/types';
-
-import { DICTIONARY_CACHE } from './constants';
-import { expirationManager } from './expirationManager';
-import { getDictionaryUrl } from './getDictionaryUrl';
-import { clearRevalidatedAt, readRevalidatedAt, writeRevalidatedAt } from './revalidatedAt';
-
-const REVALIDATION_INTERVAL = 60 * 60 * 1000;
-
-const requests: Partial<Record<Locale, Promise<void> | undefined>> = {};
-const resetWhileRevalidating = new Set<Locale>();
-
-export function revalidateDictionary(locale: Locale): Promise<void> {
-  const inFlight = requests[locale];
-
-  if (inFlight) {
-    return inFlight;
-  }
-
-  // Registered before the first await, so concurrent callers share this request.
-  const request = revalidateWhenStale(locale).finally(() => {
-    requests[locale] = undefined;
-  });
-
-  requests[locale] = request;
-  return request;
-}
-
-/**
- * Lets the next access revalidate immediately - used when the cached dictionary
- * is deleted, so its replacement is not stuck behind the throttle.
- * A revalidation already in flight when this runs saw the deleted entry, so it
- * must not arm the throttle when it finishes.
- * Both in-memory guards are raised before the first await, so a caller that
- * runs this straight after deleting the entry leaves no gap for a revalidation
- * to slip into.
- */
-export async function resetRevalidationThrottle(locale: Locale): Promise<void> {
-  resetWhileRevalidating.add(locale);
-  await clearRevalidatedAt(locale);
-}
-
-async function revalidateWhenStale(locale: Locale): Promise<void> {
-  if (Date.now() - (await readRevalidatedAt(locale)) < REVALIDATION_INTERVAL) {
-    return;
-  }
-
-  resetWhileRevalidating.delete(locale);
-  await revalidate(locale);
-
-  if (!resetWhileRevalidating.has(locale)) {
-    await writeRevalidatedAt(locale, Date.now());
-  }
-}
-
-/**
- * `no-cache` revalidates against the server without letting the HTTP cache
- * answer, while still allowing a 304 that keeps the multi-megabyte cached body
- * untouched; only a real 200 rewrites it. `no-store` would look equivalent but
- * makes the browser send `Cache-Control: no-cache`, which Next.js reads as an
- * unconditional request and answers with the whole body every time.
- */
-async function revalidate(locale: Locale): Promise<void> {
-  await expirationManager.expireEntries();
-
-  const url = getDictionaryUrl(locale);
-  const cache = await caches.open(DICTIONARY_CACHE);
-  const cached = await cache.match(url);
-  const etag = cached?.headers.get('etag');
-  const response = await fetch(url, {
-    cache: 'no-cache',
-    headers: etag ? { 'If-None-Match': etag } : {},
-  });
-
-  if (response.status === 304) {
-    await expirationManager.updateTimestamp(url);
-    return;
-  }
-
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-  }
-
-  await cache.put(url, response);
-  await expirationManager.updateTimestamp(url);
-}

package/packages/scrabble-solver/src/solver-worker/dictionaries/revalidatedAt.ts

@@ -1,43 +0,0 @@
-import { type Locale } from '@scrabble-solver/types';
-
-import { REVALIDATED_AT_CACHE } from './constants';
-import { getDictionaryUrl } from './getDictionaryUrl';
-
-const timestamps: Partial<Record<Locale, number>> = {};
-
-/**
- * A dedicated worker is created per page, so a timestamp kept only in memory
- * would let every navigation revalidate again. The Cache API is the only
- * storage a worker shares with other tabs, so the throttle lives there and is
- * read at most once per locale per worker.
- */
-export async function readRevalidatedAt(locale: Locale): Promise<number> {
-  const known = timestamps[locale];
-
-  if (typeof known !== 'undefined') {
-    return known;
-  }
-
-  const persisted = await readPersistedRevalidatedAt(locale);
-  // A reset that landed while reading wins over the value it invalidated.
-  return (timestamps[locale] ??= persisted);
-}
-
-export async function writeRevalidatedAt(locale: Locale, timestamp: number): Promise<void> {
-  timestamps[locale] = timestamp;
-  const cache = await caches.open(REVALIDATED_AT_CACHE);
-  await cache.put(getDictionaryUrl(locale), new Response(String(timestamp)));
-}
-
-export async function clearRevalidatedAt(locale: Locale): Promise<void> {
-  timestamps[locale] = 0;
-  const cache = await caches.open(REVALIDATED_AT_CACHE);
-  await cache.delete(getDictionaryUrl(locale));
-}
-
-async function readPersistedRevalidatedAt(locale: Locale): Promise<number> {
-  const cache = await caches.open(REVALIDATED_AT_CACHE);
-  const response = await cache.match(getDictionaryUrl(locale));
-  const timestamp = Number(await response?.text());
-  return Number.isFinite(timestamp) ? timestamp : 0;
-}

package/packages/scrabble-solver/src/solver-worker/getGaddag.test.ts

@@ -1,109 +0,0 @@
-import { Gaddag } from '@kamilmielnik/gaddag';
-import { Locale } from '@scrabble-solver/types';
-import { describe, expect, it, mock } from 'bun:test';
-
-import type * as getGaddagModule from './getGaddag';
-
-let dictionary: Response | undefined;
-const deletedLocales: Locale[] = [];
-
-await mock.module('./dictionaries', () => ({
-  deleteDictionary: (locale: Locale) => {
-    deletedLocales.push(locale);
-    return Promise.resolve();
-  },
-  getDictionary: () => Promise.resolve(dictionary),
-}));
-
-const { getGaddag }: typeof getGaddagModule = await import('./getGaddag');
-
-describe('getGaddag', () => {
-  it('returns undefined when there is no cached dictionary', async () => {
-    dictionary = undefined;
-    expect(await getGaddag(Locale.EN_US)).toBeUndefined();
-  });
-
-  it('deserializes a cached dictionary', async () => {
-    dictionary = createDictionary(['scrabble', 'solver']);
-    const gaddag = await getGaddag(Locale.EN_US);
-
-    expect(gaddag?.has('scrabble')).toBe(true);
-    expect(gaddag?.has('trie')).toBe(false);
-  });
-
-  it('deletes a dictionary cached by an app version with an incompatible format', async () => {
-    dictionary = new Response('serialized trie from a previous app version');
-
-    expect(await getGaddag(Locale.PL_PL)).toBeUndefined();
-    expect(deletedLocales).toContain(Locale.PL_PL);
-  });
-
-  it('deletes a corrupted dictionary', async () => {
-    dictionary = new Response(Gaddag.fromArray(['scrabble']).serialize().subarray(0, 10));
-
-    expect(await getGaddag(Locale.FA_IR)).toBeUndefined();
-    expect(deletedLocales).toContain(Locale.FA_IR);
-  });
-
-  it('reuses the deserialized dictionary while the cached response is unchanged', async () => {
-    dictionary = createDictionary(['scrabble'], { etag: '"v1"' });
-    const first = await getGaddag(Locale.EN_GB);
-    dictionary = createDictionary(['scrabble'], { etag: '"v1"' });
-    const second = await getGaddag(Locale.EN_GB);
-
-    expect(first?.has('scrabble')).toBe(true);
-    expect(second).toBe(first);
-  });
-
-  it('reuses the deserialized dictionary when a revalidation only refreshes the Date header', async () => {
-    dictionary = createDictionary(['scrabble'], { date: 'Thu, 06 Aug 2026 00:00:00 GMT', etag: '"v1"' });
-    const first = await getGaddag(Locale.FR_FR);
-    dictionary = createDictionary(['scrabble'], { date: 'Fri, 07 Aug 2026 00:00:00 GMT', etag: '"v1"' });
-    const second = await getGaddag(Locale.FR_FR);
-
-    expect(first?.has('scrabble')).toBe(true);
-    expect(second).toBe(first);
-  });
-
-  it('picks up a dictionary another tab wrote into the shared cache', async () => {
-    dictionary = createDictionary(['scrabble'], { etag: '"v1"' });
-    const first = await getGaddag(Locale.TR_TR);
-    dictionary = createDictionary(['solver'], { etag: '"v2"' });
-    const second = await getGaddag(Locale.TR_TR);
-
-    expect(first?.has('scrabble')).toBe(true);
-    expect(second).not.toBe(first);
-    expect(second?.has('solver')).toBe(true);
-  });
-
-  it('falls back to the Date header for responses without an ETag', async () => {
-    dictionary = createDictionary(['scrabble'], { date: 'Thu, 06 Aug 2026 00:00:00 GMT' });
-    const first = await getGaddag(Locale.DE_DE);
-    dictionary = createDictionary(['scrabble'], { date: 'Thu, 06 Aug 2026 00:00:00 GMT' });
-    const second = await getGaddag(Locale.DE_DE);
-    dictionary = createDictionary(['scrabble'], { date: 'Fri, 07 Aug 2026 00:00:00 GMT' });
-    const third = await getGaddag(Locale.DE_DE);
-
-    expect(first?.has('scrabble')).toBe(true);
-    expect(second).toBe(first);
-    expect(third).not.toBe(first);
-    expect(third?.has('scrabble')).toBe(true);
-  });
-
-  it('memoizes each locale independently', async () => {
-    dictionary = createDictionary(['scrabble'], { etag: '"es"' });
-    const spanish = await getGaddag(Locale.ES_ES);
-    dictionary = createDictionary(['solver'], { etag: '"ro"' });
-    const romanian = await getGaddag(Locale.RO_RO);
-    dictionary = createDictionary(['scrabble'], { etag: '"es"' });
-    const spanishAgain = await getGaddag(Locale.ES_ES);
-
-    expect(spanish?.has('scrabble')).toBe(true);
-    expect(romanian?.has('solver')).toBe(true);
-    expect(spanishAgain).toBe(spanish);
-  });
-});
-
-function createDictionary(words: string[], headers: Record<string, string> = {}): Response {
-  return new Response(Gaddag.fromArray(words).serialize(), { headers });
-}

package/packages/scrabble-solver/src/solver-worker/getGaddag.ts

@@ -1,62 +0,0 @@
-import { Gaddag } from '@kamilmielnik/gaddag';
-import { type Locale } from '@scrabble-solver/types';
-
-import { deleteDictionary, getDictionary } from './dictionaries';
-
-interface DeserializedDictionary {
-  gaddag: Gaddag;
-  version: string;
-}
-
-const deserializedDictionaries: Partial<Record<Locale, DeserializedDictionary>> = {};
-
-/**
- * Returns undefined when there is no cached dictionary or when the cached
- * dictionary cannot be deserialized (it was downloaded by an app version with
- * an incompatible format). An undeserializable entry is deleted before
- * returning, so the revalidation the caller triggers next downloads a fresh
- * dictionary instead of getting a 304 for the broken bytes.
- */
-export async function getGaddag(locale: Locale): Promise<Gaddag | undefined> {
-  const response = await getDictionary(locale);
-
-  if (typeof response === 'undefined') {
-    return undefined;
-  }
-
-  const version = readVersion(response);
-  const deserialized = deserializedDictionaries[locale];
-
-  if (deserialized && deserialized.version === version) {
-    return deserialized.gaddag;
-  }
-
-  try {
-    const gaddag = Gaddag.deserialize(new Uint8Array(await response.arrayBuffer()));
-
-    if (typeof version !== 'undefined') {
-      deserializedDictionaries[locale] = { gaddag, version };
-    }
-
-    return gaddag;
-  } catch {
-    delete deserializedDictionaries[locale];
-    await deleteDictionary(locale);
-    return undefined;
-  }
-}
-
-/**
- * Read from the cached response rather than tracked in memory, so a dictionary
- * another tab downloaded into the shared cache is picked up here too.
- */
-function readVersion(response: Response): string | undefined {
-  const etag = response.headers.get('etag');
-
-  if (etag !== null) {
-    return etag;
-  }
-
-  const parts = ['date', 'content-length'].map((name) => response.headers.get(name) ?? '');
-  return parts.every((part) => part === '') ? undefined : parts.join('|');
-}

package/packages/scrabble-solver/src/solver-worker/index.ts

@@ -1 +0,0 @@
-export { prefetchDictionary, solveLocally, verifyLocally } from './client';

package/packages/scrabble-solver/src/solver-worker/index.worker.ts

@@ -1,124 +0,0 @@
-/// <reference lib="WebWorker" />
-
-import { getConfig } from '@scrabble-solver/configs';
-import { BLANK } from '@scrabble-solver/constants';
-import { solve } from '@scrabble-solver/solver';
-import { Board, type Locale, Tile } from '@scrabble-solver/types';
-
-import { type SolveRequestPayload, type VerifiedWord, type VerifyRequestPayload } from '@/types';
-
-import { revalidateDictionary } from './dictionaries';
-import { getGaddag } from './getGaddag';
-import { type SolverWorkerRequest, type SolverWorkerResponse } from './messages';
-
-declare const self: DedicatedWorkerGlobalScope;
-
-/**
- * Solves run synchronously on the single worker thread, so a burst of requests
- * would queue stale solves ahead of the latest one.
- */
-let latestSolveId = 0;
-
-self.addEventListener('message', ({ data }: MessageEvent<SolverWorkerRequest>) => {
-  if (data.type === 'solve') {
-    latestSolveId = data.id;
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    respond(data.id, () => handleSolve(data.id, data.payload));
-  } else if (data.type === 'verify') {
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    respond(data.id, () => handleVerify(data.id, data.payload));
-  } else if (data.type === 'prefetch') {
-    prefetchDictionary(data.locale).catch(() => undefined);
-  }
-});
-
-async function handleSolve(id: number, payload: SolveRequestPayload): Promise<SolverWorkerResponse> {
-  const { board, characters, game, locale } = payload;
-  const gaddag = await getGaddag(locale);
-  revalidateInBackground(locale);
-
-  if (!gaddag) {
-    return { id, outcome: 'unavailable' };
-  }
-
-  await yieldToQueuedMessages();
-
-  if (latestSolveId !== id) {
-    return { id, outcome: 'superseded' };
-  }
-
-  const config = getConfig(game, locale);
-  const tiles = characters.map((character) => new Tile({ character, isBlank: character === BLANK }));
-  return { data: solve(gaddag, config, Board.fromJson(board), tiles), id, outcome: 'answered' };
-}
-
-async function handleVerify(
-  id: number,
-  { board: boardJson, locale }: VerifyRequestPayload,
-): Promise<SolverWorkerResponse> {
-  const gaddag = await getGaddag(locale);
-  revalidateInBackground(locale);
-
-  if (!gaddag) {
-    return { id, outcome: 'unavailable' };
-  }
-
-  const board = Board.fromJson(boardJson);
-  const words = board.getWords().sort((a, b) => a.word.localeCompare(b.word, locale));
-  const invalidWords: VerifiedWord[] = [];
-  const validWords: VerifiedWord[] = [];
-
-  for (const word of words) {
-    if (gaddag.has(word.word)) {
-      validWords.push({ ...word, isValid: true });
-    } else {
-      invalidWords.push({ ...word, isValid: false });
-    }
-  }
-
-  return { data: { invalidWords, validWords }, id, outcome: 'answered' };
-}
-
-/**
- * Deserializes the dictionary ahead of the first solve, so it does not pay the
- * cold-start cost. Warms even when revalidation fails (e.g. offline) - a
- * previously cached dictionary can still be deserialized.
- */
-async function prefetchDictionary(locale: Locale): Promise<void> {
-  try {
-    await revalidateDictionary(locale);
-  } catch {
-    // Solving falls back to the server until a later revalidation succeeds.
-  }
-
-  await getGaddag(locale);
-}
-
-/**
- * Revalidation failures are expected (offline, server down) and must not
- * surface as unhandled rejections - solving keeps using the cached dictionary
- * until a later revalidation succeeds.
- */
-function revalidateInBackground(locale: Locale): void {
-  revalidateDictionary(locale).catch(() => undefined);
-}
-
-async function respond(id: number, handle: () => Promise<SolverWorkerResponse>): Promise<void> {
-  try {
-    self.postMessage(await handle());
-  } catch {
-    self.postMessage({ id, outcome: 'unavailable' } satisfies SolverWorkerResponse);
-  }
-}
-
-/**
- * Messages queued behind this handler dispatch only between macrotasks - a
- * MessageChannel round-trip lets them register before an expensive solve.
- */
-function yieldToQueuedMessages(): Promise<void> {
-  return new Promise((resolve) => {
-    const { port1, port2 } = new MessageChannel();
-    port1.onmessage = () => resolve();
-    port2.postMessage(null);
-  });
-}

package/packages/scrabble-solver/src/solver-worker/messages.ts

@@ -1,20 +0,0 @@
-import { type Locale, type ResultJson } from '@scrabble-solver/types';
-
-import { type SolveRequestPayload, type VerifiedWord, type VerifyRequestPayload } from '@/types';
-
-export interface VerifyResult {
-  invalidWords: VerifiedWord[];
-  validWords: VerifiedWord[];
-}
-
-export type SolverWorkerRequest =
-  | { id: number; type: 'prefetch'; locale: Locale }
-  | { id: number; type: 'solve'; payload: SolveRequestPayload }
-  | { id: number; type: 'verify'; payload: VerifyRequestPayload };
-
-export type SolverWorkerResponse =
-  | { id: number; outcome: 'answered'; data: ResultJson[] | VerifyResult }
-  /** No cached dictionary, or an internal error - the caller falls back to the server. */
-  | { id: number; outcome: 'unavailable' }
-  /** A newer solve replaced this one - the newer answer is the one worth waiting for. */
-  | { id: number; outcome: 'superseded' };

package/packages/scrabble-solver/src/state/actions.ts

@@ -1,5 +0,0 @@
-import { createAction } from '@reduxjs/toolkit';
-
-export const initialize = createAction<{ version: string }>('initialize');
-
-export const reset = createAction('reset');

package/packages/scrabble-solver/src/state/app/index.ts

@@ -1,4 +0,0 @@
-export * from './initialState';
-export * from './selectors';
-export * from './slice';
-export * from './types';

package/packages/scrabble-solver/src/state/app/initialState.ts

@@ -1,6 +0,0 @@
-import type { AppState } from './types';
-
-export const appInitialState: AppState = {
-  isHydrated: false,
-  version: '',
-};

package/packages/scrabble-solver/src/state/app/selectors.ts

@@ -1,5 +0,0 @@
-import type { RootState } from '../types';
-
-export const selectIsHydrated = (state: RootState): boolean => state.app.isHydrated;
-
-export const selectVersion = (state: RootState): string => state.app.version;

package/packages/scrabble-solver/src/state/app/slice.ts

@@ -1,20 +0,0 @@
-import { createSlice } from '@reduxjs/toolkit';
-
-import { initialize } from '../actions';
-
-import { appInitialState } from './initialState';
-
-export const appSlice = createSlice({
-  initialState: appInitialState,
-  name: 'app',
-  reducers: {
-    hydrated: (state) => {
-      state.isHydrated = true;
-    },
-  },
-  extraReducers: (builder) => {
-    builder.addCase(initialize, (state, action) => {
-      state.version = action.payload.version;
-    });
-  },
-});

package/packages/scrabble-solver/src/state/app/types.ts

@@ -1,4 +0,0 @@
-export interface AppState {
-  isHydrated: boolean;
-  version: string;
-}

package/packages/scrabble-solver/src/state/board/index.ts

@@ -1,4 +0,0 @@
-export * from './initialState';
-export * from './selectors';
-export * from './slice';
-export * from './types';

package/packages/scrabble-solver/src/state/board/initialState.ts

@@ -1,38 +0,0 @@
-import { getConfig } from '@scrabble-solver/configs';
-import { Board } from '@scrabble-solver/types';
-
-import { settingsInitialState } from '../settings';
-
-import type { BoardState } from './types';
-
-const { game, locale } = settingsInitialState;
-const { boardHeight, boardWidth } = getConfig(game, locale);
-
-export const boardInitialState: BoardState = Board.create(boardWidth, boardHeight);
-
-// const createOxyphenbutazone = () => {
-//   // Tiles: oypbaze
-
-//   const board = Board.fromStringArray([
-//     ' x  hen ut  on ',
-//     'puer  or amas j',
-//     'a led  a  er  a',
-//     'c ki   i elf  c',
-//     'i snot n  is  u',
-//     'f  t o w do   l',
-//     'y  e moa er   a',
-//     'i  r   solar  t',
-//     'n  v   h  t   i',
-//     'g  i   i bitten',
-//     '   e   n  v   g',
-//     '   w   g  e    ',
-//     '   e           ',
-//     '   d           ',
-//     '               ',
-//   ]);
-
-//   board.rows[4][3].tile.isBlank = true;
-//   board.rows[9][11].tile.isBlank = true;
-
-//   return board;
-// };

package/packages/scrabble-solver/src/state/board/selectors.ts

@@ -1,3 +0,0 @@
-import type { RootState } from '../types';
-
-export const selectBoard = (state: RootState) => state.board;

package/packages/scrabble-solver/src/state/board/slice.ts

@@ -1,101 +0,0 @@
-import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
-import { games } from '@scrabble-solver/configs';
-import { EMPTY_CELL } from '@scrabble-solver/constants';
-import { Board, Cell, type Result, Tile } from '@scrabble-solver/types';
-
-import { settingsSlice } from '../settings';
-
-import { boardInitialState } from './initialState';
-
-export const boardSlice = createSlice({
-  initialState: boardInitialState,
-  name: 'board',
-  reducers: {
-    applyResult: (state, action: PayloadAction<Result>) => {
-      const newBoard = state.clone();
-      const result = action.payload;
-
-      result.cells.forEach((cell) => {
-        newBoard.updateCell(cell.x, cell.y, () => new Cell({ isEmpty: false, tile: cell.tile, x: cell.x, y: cell.y }));
-      });
-
-      return newBoard;
-    },
-
-    change: (_state, action: PayloadAction<Board>) => {
-      const board = action.payload;
-      return board;
-    },
-
-    changeCellValue: (state, action: PayloadAction<{ value: string; x: number; y: number }>) => {
-      const newBoard = state.clone();
-      const { value, x, y } = action.payload;
-      const isEmpty = !value || value === EMPTY_CELL;
-      const tile = isEmpty ? Tile.Null : new Tile({ character: value });
-
-      newBoard.updateCell(x, y, (cell) => {
-        return new Cell({ isEmpty, tile, x: cell.x, y: cell.y });
-      });
-
-      return newBoard;
-    },
-
-    init: (_state, action: PayloadAction<Board>) => {
-      const board = action.payload;
-      return board;
-    },
-
-    toggleCellIsBlank: (state, action: PayloadAction<{ x: number; y: number }>) => {
-      const newBoard = state.clone();
-      const { x, y } = action.payload;
-
-      newBoard.updateCell(x, y, (cell) => {
-        const tile = cell.isEmpty
-          ? cell.tile
-          : new Tile({ isBlank: !cell.tile.isBlank, character: cell.tile.character });
-        return new Cell({ isEmpty: cell.isEmpty, tile, x: cell.x, y: cell.y });
-      });
-
-      return newBoard;
-    },
-  },
-  extraReducers: (builder) => {
-    builder.addCase(settingsSlice.actions.changeGame, (state, action) => {
-      const game = action.payload;
-      const config = Object.values(games).find((gameConfig) => gameConfig.game === game);
-
-      if (!config) {
-        throw new Error(`Cannot find config for game "${game}"`);
-      }
-
-      if (state.rows.length !== config.boardHeight || state.rows[0].length !== config.boardWidth) {
-        const newBoard = Board.create(config.boardWidth, config.boardHeight);
-        const offsetX = Math.floor(config.boardWidth / 2) - Math.floor(state.rows[0].length / 2);
-        const offsetY = Math.floor(config.boardHeight / 2) - Math.floor(state.rows.length / 2);
-
-        for (let y = 0; y < state.rows.length; ++y) {
-          for (let x = 0; x < state.rows[y].length; ++x) {
-            const cell = state.rows[y][x];
-
-            if (cell.isEmpty) {
-              continue;
-            }
-
-            const newX = x + offsetX;
-            const newY = y + offsetY;
-
-            if (newX < 0 || newX >= config.boardWidth || newY < 0 || newY >= config.boardHeight) {
-              continue;
-            }
-
-            newBoard.updateCell(newX, newY, () => new Cell({ ...cell, x: newX, y: newY }));
-          }
-        }
-
-        return newBoard;
-      }
-
-      return state;
-    });
-  },
-});

package/packages/scrabble-solver/src/state/board/types.ts

@@ -1,3 +0,0 @@
-import { type Board } from '@scrabble-solver/types';
-
-export type BoardState = Board;

package/packages/scrabble-solver/src/state/cellFilters/index.ts

@@ -1,4 +0,0 @@
-export * from './initialState';
-export * from './selectors';
-export * from './slice';
-export * from './types';

package/packages/scrabble-solver/src/state/cellFilters/initialState.ts

@@ -1,3 +0,0 @@
-import type { CellFiltersState } from './types';
-
-export const cellFiltersInitialState: CellFiltersState = [];