scrabble-solver 2.18.2 → 2.18.4

package/packages/scrabble-solver/src/pages/api/dictionary/[locale]/index.ts

@@ -1,65 +1,61 @@
 import { type Gaddag } from '@kamilmielnik/gaddag';
 import { dictionaries } from '@scrabble-solver/dictionaries';
-import { logger } from '@scrabble-solver/logger';
+import { logEvent } from '@scrabble-solver/logger';
 import { isLocale, type Locale } from '@scrabble-solver/types';
 import { type NextApiRequest, type NextApiResponse } from 'next';
 import { promisify } from 'util';
 import { gzip } from 'zlib';
 
-import { getServerLoggingData } from '@/api';
+import { type ApiContext, BadRequestError, withApiLog } from '@/api';
 
 interface RequestData {
   locale: Locale;
 }
 
-const dictionary = async (request: NextApiRequest, response: NextApiResponse): Promise<void> => {
-  const meta = getServerLoggingData(request);
+export default withApiLog('download', dictionary);
 
-  try {
-    const { locale } = parseRequest(request);
+async function dictionary(request: NextApiRequest, response: NextApiResponse, { ip, getElapsedMs }: ApiContext) {
+  const { locale } = parseRequest(request);
+  const gaddag = await dictionaries.get(locale);
+  const encoding = acceptsGzip(request) ? 'gzip' : 'identity';
+  const body = encoding === 'gzip' ? await getCompressedDictionary(gaddag) : getSerializedDictionary(gaddag);
 
-    logger.info('dictionary - request', {
-      meta,
-      payload: {
-        locale,
-      },
-    });
+  // no-cache makes clients store the payload but revalidate it, so unchanged
+  // re-downloads become 304s, answered by Next's built-in ETag handling.
+  response.setHeader('Cache-Control', 'no-cache');
+  response.setHeader('Content-Type', 'application/octet-stream');
+  response.setHeader('Vary', 'Accept-Encoding');
 
-    const gaddag = await dictionaries.get(locale);
-    const isGzip = acceptsGzip(request);
-    const body = isGzip ? await getCompressedDictionary(gaddag) : getSerializedDictionary(gaddag);
+  if (encoding === 'gzip') {
+    response.setHeader('Content-Encoding', 'gzip');
+  }
 
-    // no-cache makes clients store the payload but revalidate it, so unchanged
-    // re-downloads become 304s, answered by Next's built-in ETag handling.
-    response.setHeader('Cache-Control', 'no-cache');
-    response.setHeader('Content-Type', 'application/octet-stream');
-    response.setHeader('Vary', 'Accept-Encoding');
+  response.status(200).send(body);
 
-    if (isGzip) {
-      response.setHeader('Content-Encoding', 'gzip');
-    }
-
-    response.status(200).send(body);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    logger.error('dictionary - error', { error, meta });
-    response.status(500).send({ error: 'Server error', message });
-  }
-};
+  logEvent({
+    type: 'download',
+    ip,
+    ms: getElapsedMs(),
+    locale,
+    status: response.statusCode,
+    encoding,
+    bytes: response.statusCode === 304 ? 0 : body.byteLength,
+  });
+}
 
-const parseRequest = (request: NextApiRequest): RequestData => {
+function parseRequest(request: NextApiRequest): RequestData {
   const { locale } = request.query;
 
   if (!isLocale(locale)) {
-    throw new Error('Invalid "locale" parameter');
+    throw new BadRequestError('Invalid "locale" parameter');
   }
 
   return {
     locale,
   };
-};
+}
 
-const acceptsGzip = (request: NextApiRequest): boolean => {
+function acceptsGzip(request: NextApiRequest): boolean {
   const acceptEncoding = request.headers['accept-encoding'];
   const header = Array.isArray(acceptEncoding) ? acceptEncoding.join(',') : acceptEncoding;
 
@@ -86,14 +82,14 @@ const acceptsGzip = (request: NextApiRequest): boolean => {
   }
 
   return wildcardAccepts;
-};
+}
 
 // Dictionaries rebuild at most daily, so each response variant is produced
 // once and lives exactly as long as the in-memory dictionary it was made from.
 const serializedCache = new WeakMap<Gaddag, Buffer>();
 const compressedCache = new WeakMap<Gaddag, Promise<Buffer>>();
 
-const getSerializedDictionary = (gaddag: Gaddag): Buffer => {
+function getSerializedDictionary(gaddag: Gaddag): Buffer {
   let serialized = serializedCache.get(gaddag);
 
   if (!serialized) {
@@ -104,11 +100,11 @@ const getSerializedDictionary = (gaddag: Gaddag): Buffer => {
   }
 
   return serialized;
-};
+}
 
 const gzipAsync = promisify(gzip);
 
-const getCompressedDictionary = (gaddag: Gaddag): Promise<Buffer> => {
+function getCompressedDictionary(gaddag: Gaddag): Promise<Buffer> {
   let compressed = compressedCache.get(gaddag);
 
   if (!compressed) {
@@ -118,12 +114,10 @@ const getCompressedDictionary = (gaddag: Gaddag): Promise<Buffer> => {
   }
 
   return compressed;
-};
+}
 
 export const config = {
   api: {
     responseLimit: '50mb',
   },
 };
-
-export default dictionary;

package/packages/scrabble-solver/src/pages/api/solve.ts

@@ -1,7 +1,7 @@
 import { getConfig, hasConfig } from '@scrabble-solver/configs';
 import { BLANK } from '@scrabble-solver/constants';
 import { dictionaries } from '@scrabble-solver/dictionaries';
-import { logger } from '@scrabble-solver/logger';
+import { logEvent } from '@scrabble-solver/logger';
 import { solve as solveScrabble } from '@scrabble-solver/solver';
 import {
   Board,
@@ -15,7 +15,7 @@ import {
 } from '@scrabble-solver/types';
 import { type NextApiRequest, type NextApiResponse } from 'next';
 
-import { getServerLoggingData, isBoardValid, isCharacterValid } from '@/api';
+import { type ApiContext, BadRequestError, isBoardValid, isCharacterValid, withApiLog } from '@/api';
 import { isStringArray } from '@/lib/isStringArray';
 
 interface RequestData {
@@ -26,71 +26,63 @@ interface RequestData {
   locale: Locale;
 }
 
-const solve = async (request: NextApiRequest, response: NextApiResponse): Promise<void> => {
-  const meta = getServerLoggingData(request);
-
-  try {
-    const { board, characters, config, game, locale } = parseRequest(request);
-
-    logger.info('solve - request', {
-      meta,
-      payload: {
-        board: board.toString(),
-        configId: config.game,
-        boardBlanksCount: board.getBlanksCount(),
-        boardTilesCount: board.getTilesCount(),
-        characters: characters.join(''),
-        game,
-        locale,
-      },
-    });
-
-    const gaddag = await dictionaries.get(locale);
-    const tiles = characters.map((character) => new Tile({ character, isBlank: character === BLANK }));
-    const results = solveScrabble(gaddag, config, board, tiles);
-    response.status(200).send(results);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    logger.error('solve - error', { error, meta });
-    response.status(500).send({ error: 'Server error', message });
-  }
-};
+export default withApiLog('solve', solve);
+
+async function solve(request: NextApiRequest, response: NextApiResponse, { ip, getElapsedMs }: ApiContext) {
+  const { board, characters, config, game, locale } = parseRequest(request);
+  const gaddag = await dictionaries.get(locale);
+  const tiles = characters.map((character) => new Tile({ character, isBlank: character === BLANK }));
+  const results = solveScrabble(gaddag, config, board, tiles);
+  response.status(200).send(results);
+
+  logEvent({
+    type: 'solve',
+    ip,
+    ms: getElapsedMs(),
+    locale,
+    game,
+    tiles: board.getTilesCount(),
+    blanks: board.getBlanksCount(),
+    rack: characters.join(','),
+    results: results.length,
+  });
+}
 
-const parseRequest = (request: NextApiRequest): RequestData => {
+function parseRequest(request: NextApiRequest): RequestData {
   const { board: boardJson, characters, game, locale } = request.body;
 
   if (!isLocale(locale)) {
-    throw new Error('Invalid "locale" parameter');
+    throw new BadRequestError('Invalid "locale" parameter');
   }
 
   if (!isGame(game)) {
-    throw new Error('Invalid "game" parameter');
+    throw new BadRequestError('Invalid "game" parameter');
   }
 
   if (!isStringArray(characters) || characters.length === 0) {
-    throw new Error('Invalid "characters" parameter');
+    throw new BadRequestError('Invalid "characters" parameter');
   }
 
   if (!hasConfig(game, locale)) {
-    throw new Error(`No game "${game}" in "${locale}"`);
+    throw new BadRequestError(`No game "${game}" in "${locale}"`);
   }
 
   const config = getConfig(game, locale);
 
   for (const character of characters) {
     if (!isCharacterValid(character)) {
-      throw new Error('Invalid "characters" parameter');
+      throw new BadRequestError('Invalid "characters" parameter');
     }
   }
 
   const blanksCount = characters.filter((character) => character === BLANK).length;
 
   if (blanksCount > config.blanksCount) {
-    throw new Error('Too many blank tiles passed');
+    throw new BadRequestError('Too many blank tiles passed');
   }
 
   if (!isBoardJson(boardJson) || !isBoardValid(boardJson, config)) {
-    throw new Error('Invalid "board" parameter');
+    throw new BadRequestError('Invalid "board" parameter');
   }
 
   const board = Board.fromJson(boardJson);
@@ -102,12 +94,10 @@ const parseRequest = (request: NextApiRequest): RequestData => {
     game,
     locale,
   };
-};
+}
 
 export const config = {
   api: {
     responseLimit: '25mb',
   },
 };
-
-export default solve;

package/packages/scrabble-solver/src/pages/api/verify.ts

@@ -1,10 +1,10 @@
 import { getConfig, hasConfig } from '@scrabble-solver/configs';
 import { dictionaries } from '@scrabble-solver/dictionaries';
-import { logger } from '@scrabble-solver/logger';
+import { logEvent } from '@scrabble-solver/logger';
 import { Board, type Config, type Game, type Locale, isBoardJson, isGame, isLocale } from '@scrabble-solver/types';
 import { type NextApiRequest, type NextApiResponse } from 'next';
 
-import { getServerLoggingData, isBoardValid } from '@/api';
+import { type ApiContext, BadRequestError, isBoardValid, withApiLog } from '@/api';
 import { type VerifiedWord } from '@/types';
 
 interface RequestData {
@@ -14,63 +14,57 @@ interface RequestData {
   locale: Locale;
 }
 
-const verify = async (request: NextApiRequest, response: NextApiResponse): Promise<void> => {
-  const meta = getServerLoggingData(request);
+export default withApiLog('verify', verify);
 
-  try {
-    const { board, game, locale } = parseRequest(request);
+async function verify(request: NextApiRequest, response: NextApiResponse, { ip, getElapsedMs }: ApiContext) {
+  const { board, game, locale } = parseRequest(request);
+  const gaddag = await dictionaries.get(locale);
+  const words = board.getWords().sort((a, b) => a.word.localeCompare(b.word, locale));
+  const invalidWords: VerifiedWord[] = [];
+  const validWords: VerifiedWord[] = [];
 
-    logger.info('verify - request', {
-      meta,
-      payload: {
-        board: board.toString(),
-        boardBlanksCount: board.getBlanksCount(),
-        boardTilesCount: board.getTilesCount(),
-        game,
-        locale,
-      },
-    });
-
-    const gaddag = await dictionaries.get(locale);
-    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 });
-      }
+  for (const word of words) {
+    if (gaddag.has(word.word)) {
+      validWords.push({ ...word, isValid: true });
+    } else {
+      invalidWords.push({ ...word, isValid: false });
     }
-
-    response.status(200).send({ invalidWords, validWords });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    logger.error('verify - error', { error, meta });
-    response.status(500).send({ error: 'Server error', message });
   }
-};
 
-const parseRequest = (request: NextApiRequest): RequestData => {
+  response.status(200).send({ invalidWords, validWords });
+
+  logEvent({
+    type: 'verify',
+    ip,
+    ms: getElapsedMs(),
+    locale,
+    game,
+    tiles: board.getTilesCount(),
+    blanks: board.getBlanksCount(),
+    valid: validWords.length,
+    invalid: invalidWords.length,
+  });
+}
+
+function parseRequest(request: NextApiRequest): RequestData {
   const { board: boardJson, game, locale } = request.body;
 
   if (!isLocale(locale)) {
-    throw new Error('Invalid "locale" parameter');
+    throw new BadRequestError('Invalid "locale" parameter');
   }
 
   if (!isGame(game)) {
-    throw new Error('Invalid "game" parameter');
+    throw new BadRequestError('Invalid "game" parameter');
   }
 
   if (!hasConfig(game, locale)) {
-    throw new Error(`No game "${game}" in "${locale}"`);
+    throw new BadRequestError(`No game "${game}" in "${locale}"`);
   }
 
   const config = getConfig(game, locale);
 
   if (!isBoardJson(boardJson) || !isBoardValid(boardJson, config)) {
-    throw new Error('Invalid "board" parameter');
+    throw new BadRequestError('Invalid "board" parameter');
   }
 
   const board = Board.fromJson(boardJson);
@@ -81,6 +75,4 @@ const parseRequest = (request: NextApiRequest): RequestData => {
     game,
     locale,
   };
-};
-
-export default verify;
+}

package/packages/scrabble-solver/src/pages/api/visit.ts

@@ -1,19 +1,44 @@
-import { logger } from '@scrabble-solver/logger';
+import { logEvent } from '@scrabble-solver/logger';
+import { isGame, isLocale, isObject } from '@scrabble-solver/types';
 import { type NextApiRequest, type NextApiResponse } from 'next';
 
-import { getServerLoggingData } from '@/api';
+import { type ApiContext, withApiLog } from '@/api';
 
-const visit = (request: NextApiRequest, response: NextApiResponse): void => {
-  const meta = getServerLoggingData(request);
+interface RequestData {
+  game: string | undefined;
+  locale: string | undefined;
+  referrer: string | undefined;
+  url: string | undefined;
+}
 
-  try {
-    logger.info('visit - request', { meta });
-    response.status(200).send(true);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    logger.error('visit - error', { error, meta });
-    response.status(500).send({ error: 'Server error', message });
+const URL_MAX_LENGTH = 256;
+
+export default withApiLog('visit', visit);
+
+function visit(request: NextApiRequest, response: NextApiResponse, { ip, ua }: ApiContext) {
+  const { game, locale, referrer, url } = parseRequest(request);
+  response.status(200).send(true);
+  logEvent({ type: 'visit', ip, ua, referrer, locale, game, url });
+}
+
+// A visit is only a ping - unexpected fields are ignored, never rejected.
+function parseRequest(request: NextApiRequest): RequestData {
+  const body: unknown = request.body;
+
+  if (!isObject(body)) {
+    return { game: undefined, locale: undefined, referrer: undefined, url: undefined };
   }
-};
 
-export default visit;
+  const { game, locale, referrer, url } = body;
+
+  return {
+    game: isGame(game) ? game : undefined,
+    locale: isLocale(locale) ? locale : undefined,
+    referrer: parseUrl(referrer),
+    url: parseUrl(url),
+  };
+}
+
+function parseUrl(value: unknown): string | undefined {
+  return typeof value === 'string' && value.length > 0 ? value.slice(0, URL_MAX_LENGTH) : undefined;
+}

package/packages/scrabble-solver/src/pages/index.tsx

@@ -14,9 +14,9 @@ import { NavButtons } from '@/components/NavButtons';
 import { Solver } from '@/components/Solver';
 import { useDirection } from '@/hooks/useDirection';
 import { useEffectOnce } from '@/hooks/useEffectOnce';
-import { useIsCompactLayout } from '@/hooks/useIsCompactLayout';
 import { useLanguage } from '@/hooks/useLanguage';
 import { useLocalStorage } from '@/hooks/useLocalStorage';
+import { useMediaQuery } from '@/hooks/useMediaQuery';
 import { LOCALE_FEATURES } from '@/i18n/constants';
 import { schedulePreloadModals } from '@/modals/preload';
 import { CONFIG_PENDING_CLASS, GITHUB_PROJECT_URL, NPM_PACKAGE_URL, SITE_DESCRIPTION, SITE_URL } from '@/parameters';
@@ -74,7 +74,7 @@ const WEB_APPLICATION_JSON_LD = JSON.stringify({
   inLanguage: ['en-US', 'en-GB', 'de-DE', 'es-ES', 'fa-IR', 'fr-FR', 'pl-PL', 'ro-RO', 'tr-TR'],
   featureList: [
     'Finds the highest-scoring words for a given board and rack',
-    'Supports Scrabble, Super Scrabble, Scrabble Duel, Letter League, Crossplay, Literaki, and Kelimelik',
+    'Supports Scrabble, Super Scrabble, Scrabble Duel, Letter League, Crossplay, Literaki, Kelimelik, and Wyrazy',
     'Dictionaries and word definitions in 8 languages',
     'Works offline once a dictionary is cached',
     'Free, open source, no ads, no sign-up',
@@ -94,7 +94,7 @@ const Index: FunctionComponent<Props> = ({ version }) => {
   const config = useTypedSelector(selectConfig);
   const locale = useTypedSelector(selectLocale);
   const isHydrated = useTypedSelector(selectIsHydrated);
-  const isCompactLayout = useIsCompactLayout();
+  const isCompactLayout = useMediaQuery('<l');
   const previousIsCompactLayout = useRef(isCompactLayout);
   const [modals, setModals] = useState<Record<Modal, boolean>>({
     dictionary: false,

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

@@ -8,8 +8,6 @@ export const BREAKPOINTS = {
   xl: Number(variables.breakpointXl),
 };
 
-export const BREAKPOINT_HEIGHT_L = Number(variables.breakpointHeightL);
-
 export const GITHUB_PROJECT_URL = 'https://github.com/kamilmielnik/scrabble-solver';
 
 export const NPM_PACKAGE_URL = 'https://www.npmjs.com/package/scrabble-solver';

package/packages/scrabble-solver/src/sdk/solve.ts

@@ -1,17 +1,11 @@
-import { Board, type BoardJson, type Game, type Locale, Result, type ResultJson } from '@scrabble-solver/types';
+import { Board, Result, type ResultJson } from '@scrabble-solver/types';
 
 import { solveLocally } from '@/solver-worker';
+import { type SolveRequestPayload } from '@/types';
 
 import { fetchJson } from './fetchJson';
 
-interface Payload {
-  board: BoardJson;
-  characters: string[];
-  game: Game;
-  locale: Locale;
-}
-
-export const solve = async ({ board, characters, game, locale }: Payload): Promise<Result[]> => {
+export const solve = async ({ board, characters, game, locale }: SolveRequestPayload): Promise<Result[]> => {
   const payload = { board, characters, game, locale };
   const json =
     (await solveLocally(payload)) ??

package/packages/scrabble-solver/src/sdk/verify.ts

@@ -1,22 +1,14 @@
-import { type BoardJson, type Game, type Locale } from '@scrabble-solver/types';
-
 import { verifyLocally } from '@/solver-worker';
-import { type VerifiedWord } from '@/types';
+import { type VerifiedWord, type VerifyRequestPayload } from '@/types';
 
 import { fetchJson } from './fetchJson';
 
-interface Payload {
-  board: BoardJson;
-  game: Game;
-  locale: Locale;
-}
-
 interface Response {
   invalidWords: VerifiedWord[];
   validWords: VerifiedWord[];
 }
 
-export const verify = async ({ board, game, locale }: Payload): Promise<Response> => {
+export const verify = async ({ board, game, locale }: VerifyRequestPayload): Promise<Response> => {
   const payload = { board, game, locale };
   return (
     (await verifyLocally(payload)) ??

package/packages/scrabble-solver/src/sdk/visit.ts

@@ -1,5 +1,10 @@
-export const visit = (): Promise<Response> => {
-  return fetch('/api/visit', {
+import { type VisitRequestPayload } from '@/types';
+
+import { fetchJson } from './fetchJson';
+
+export function visit(payload: VisitRequestPayload): Promise<boolean> {
+  return fetchJson<boolean>('/api/visit', {
     method: 'PUT',
+    body: JSON.stringify(payload),
   });
-};
+}

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

@@ -204,7 +204,13 @@ function* hydratePersistedTranslations(locale: Locale, version: string): AnyGene
 
 function* visitWhenIdle(): AnyGenerator {
   yield call(waitForIdleOrFirstIntent);
-  yield call(visit);
+  const locale = yield select(selectLocale);
+  const game = yield select(selectGame);
+
+  try {
+    yield call(visit, { game, locale, referrer: document.referrer, url: location.href });
+    // oxlint-disable-next-line no-empty
+  } catch {}
 }
 
 function* prefetchDictionaryOnFirstIntent(): AnyGenerator {

package/packages/scrabble-solver/src/styles/_tokens.scss

@@ -10,8 +10,6 @@ $breakpoint-m: 992px;
 $breakpoint-l: 1200px;
 $breakpoint-xl: 1400px;
 
-$breakpoint-height-l: 860px;
-
 $border-color: #cdcdcd;
 $border-color-light: #d9d9d9;
 $border-radius: 5px;

package/packages/scrabble-solver/src/styles/mixins.scss

@@ -10,11 +10,6 @@
   ),
   $media-expressions: (
     touch: '(hover: none)',
-    /**
-     * Keep in sync with useIsCompactLayout
-     */
-    compact: '(max-width: #{$breakpoint-l - 1px}), (max-height: #{$breakpoint-height-l - 1px})',
-    desktop: '(min-width: #{$breakpoint-l}) and (min-height: #{$breakpoint-height-l})',
   )
 );
 

package/packages/scrabble-solver/src/styles/variables.module.scss

@@ -6,7 +6,6 @@
   breakpointM: strip-unit($breakpoint-m);
   breakpointL: strip-unit($breakpoint-l);
   breakpointXl: strip-unit($breakpoint-xl);
-  breakpointHeightL: strip-unit($breakpoint-height-l);
 
   borderColorLight: $border-color-light;
   borderWidth: strip-unit($border-width);

package/packages/scrabble-solver/src/styles/variables.module.scss.d.ts

@@ -2,7 +2,6 @@
 declare const styles: {
   readonly borderColorLight: string;
   readonly borderWidth: string;
-  readonly breakpointHeightL: string;
   readonly breakpointL: string;
   readonly breakpointM: string;
   readonly breakpointS: string;

package/packages/scrabble-solver/src/styles/variables.scss

@@ -153,7 +153,7 @@ $easeOutSine: cubic-bezier(0.61, 1, 0.88, 1);
     --components-spacing: var(--spacing--l);
   }
 
-  @include media('compact') {
+  @include media('<l') {
     --dictionary--height: var(--dictionary--height--mobile);
     --logo--height: #{$logo-height-small};
     --solver-column-total: 0px;

package/packages/scrabble-solver/src/types/api.ts

@@ -12,3 +12,10 @@ export interface VerifyRequestPayload {
   game: Game;
   locale: Locale;
 }
+
+export interface VisitRequestPayload {
+  game: Game;
+  locale: Locale;
+  referrer: string;
+  url: string;
+}