scrabble-solver 2.10.0 → 2.10.2

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

@@ -1,5 +1,7 @@
 export const GITHUB_PROJECT_URL = 'https://github.com/kamilmielnik/scrabble-solver';
 
+export const INITIALIZATION_DURATION = 100;
+
 export const TRANSITION_DURATION = 100;
 export const TRANSITION_DURATION_LONG = 250;
 

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

@@ -3,7 +3,7 @@ import { Locale, WordDefinition, WordDefinitionJson } from '@scrabble-solver/typ
 import fetchJson from './fetchJson';
 
 const findWordDefinitions = async (locale: Locale, word: string): Promise<WordDefinition[]> => {
-  const json = await fetchJson<WordDefinitionJson[]>(`/api/dictionary/${locale}/${word}`);
+  const json = await fetchJson<WordDefinitionJson[]>(`/api/dictionary/${locale}/${encodeURIComponent(word)}`);
   return json.map(WordDefinition.fromJson);
 };
 

package/packages/scrabble-solver/src/service-worker/average.ts

@@ -0,0 +1,9 @@
+const average = (numbers: number[]): number => {
+  if (numbers.length === 0) {
+    return 0;
+  }
+
+  return numbers.reduce((sum, value) => sum + value, 0) / numbers.length;
+};
+
+export default average;

package/packages/scrabble-solver/src/service-worker/routeSolveRequests.ts

@@ -1,9 +1,11 @@
+import { Trie } from '@kamilmielnik/trie';
 import { getConfig } from '@scrabble-solver/configs';
 import { BLANK } from '@scrabble-solver/constants';
 import { solve } from '@scrabble-solver/solver';
 import { Board, Locale, Tile } from '@scrabble-solver/types';
 import { registerRoute } from 'workbox-routing';
 
+import average from './average';
 import { revalidateDictionary } from './dictionaries';
 import getTrie from './getTrie';
 
@@ -11,24 +13,61 @@ const headers = {
   'Content-Type': 'application/json; charset=utf-8',
 };
 
+const MIN_MEASUREMENTS = 5;
+const localDurations: number[] = [];
+const serverDurations: number[] = [];
+
+const isSlowDevice = (): boolean | undefined => {
+  if (localDurations.length < MIN_MEASUREMENTS || serverDurations.length < MIN_MEASUREMENTS) {
+    return undefined;
+  }
+
+  const count = Math.min(localDurations.length, serverDurations.length);
+  return average(localDurations.slice(0, count)) > average(serverDurations.slice(0, count));
+};
+
 const routeSolveRequests = () => {
   registerRoute(
     ({ url }) => url.origin === location.origin && url.pathname === '/api/solve',
     async ({ request }) => {
       const { board, characters, configId, locale } = await request.clone().json();
+
+      const solveLocal = async (trie: Trie) => {
+        const config = getConfig(configId)[locale as Locale];
+        const tiles = characters.map((character: string) => new Tile({ character, isBlank: character === BLANK }));
+        const resultsJson = solve(trie, config, Board.fromJson(board), tiles);
+        const json = JSON.stringify(resultsJson);
+        return new Response(json, { headers });
+      };
+
+      const solveServer = () => fetch(request);
+
       const trie = await getTrie(locale);
 
-      if (!trie) {
-        const response = await fetch(request);
+      if (trie && typeof isSlowDevice() === 'undefined') {
+        const response = await Promise.race([
+          (async () => {
+            const start = Date.now();
+            const result = await solveLocal(trie);
+            localDurations.push(Date.now() - start);
+            return result;
+          })(),
+          (async () => {
+            const start = Date.now();
+            const result = await solveServer();
+            serverDurations.push(Date.now() - start);
+            return result;
+          })(),
+        ]);
+
         revalidateDictionary(locale);
         return response;
       }
 
-      const config = getConfig(configId)[locale as Locale];
-      const tiles = characters.map((character: string) => new Tile({ character, isBlank: character === BLANK }));
-      const resultsJson = solve(trie, config, Board.fromJson(board), tiles);
-      const json = JSON.stringify(resultsJson);
-      return new Response(json, { headers });
+      const handleSolve = trie && !isSlowDevice() ? () => solveLocal(trie) : () => solveServer();
+      const response = await handleSolve();
+      revalidateDictionary(locale);
+      return response;
     },
     'POST',
   );

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

@@ -7,13 +7,13 @@ import { findWordDefinitions, solve, verify, visit } from 'sdk';
 
 import { initialize, reset } from './actions';
 import {
-  selectAutoGroupTiles,
   selectBoard,
   selectCellIsFiltered,
   selectCharacters,
   selectConfig,
   selectDictionary,
   selectLocale,
+  selectLocaleAutoGroupTiles,
 } from './selectors';
 import {
   boardSlice,
@@ -65,7 +65,7 @@ function* onRackValueChange(): AnyGenerator {
 }
 
 function* onApplyResult({ payload: result }: PayloadAction<Result>): AnyGenerator {
-  const autoGroupTiles = yield select(selectAutoGroupTiles);
+  const autoGroupTiles = yield select(selectLocaleAutoGroupTiles);
   yield put(boardSlice.actions.applyResult(result));
   yield put(cellFilterSlice.actions.reset());
   yield put(rackSlice.actions.removeTiles(result.tiles));
@@ -74,8 +74,15 @@ function* onApplyResult({ payload: result }: PayloadAction<Result>): AnyGenerato
 }
 
 function* onConfigIdChange(): AnyGenerator {
+  const characters = yield select(selectCharacters);
+
+  if (characters.length > 0) {
+    yield put(solveSlice.actions.submit());
+  } else {
+    yield put(resultsSlice.actions.reset());
+  }
+
   yield put(resultsSlice.actions.reset());
-  yield put(solveSlice.actions.submit());
   yield put(verifySlice.actions.submit());
   yield* ensureProperTilesCount();
 }
@@ -112,9 +119,16 @@ function* onReset(): AnyGenerator {
 }
 
 function* onLocaleChange(): AnyGenerator {
+  const characters = yield select(selectCharacters);
+
+  if (characters.length > 0) {
+    yield put(solveSlice.actions.submit());
+  } else {
+    yield put(resultsSlice.actions.reset());
+  }
+
   yield put(dictionarySlice.actions.reset());
   yield put(resultsSlice.actions.changeResultCandidate(null));
-  yield put(solveSlice.actions.submit());
   yield put(verifySlice.actions.submit());
 }
 
@@ -181,7 +195,7 @@ function* ensureProperTilesCount(): AnyGenerator {
   } else if (config.maximumCharactersCount < characters.length) {
     const nonNulls = characters.filter(Boolean).slice(0, config.maximumCharactersCount);
     const differenceCount = Math.abs(config.maximumCharactersCount - nonNulls.length);
-    const autoGroupTiles = yield select(selectAutoGroupTiles);
+    const autoGroupTiles = yield select(selectLocaleAutoGroupTiles);
     yield put(rackSlice.actions.init([...nonNulls, ...Array(differenceCount).fill(null)]));
     yield put(rackSlice.actions.groupTiles(autoGroupTiles));
   }

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

@@ -1,8 +1,9 @@
 import { createSelector } from '@reduxjs/toolkit';
 import { getLocaleConfig } from '@scrabble-solver/configs';
+import { BLANK } from '@scrabble-solver/constants';
 import { Cell, Config, isError, Result, Tile } from '@scrabble-solver/types';
 
-import i18n from 'i18n';
+import i18n, { LOCALE_FEATURES } from 'i18n';
 import { findCell, getRemainingTiles, getRemainingTilesGroups, sortResults, unorderedArraysEqual } from 'lib';
 import { Translations } from 'types';
 
@@ -38,9 +39,17 @@ export const selectDictionaryError = createSelector([selectDictionaryRoot], (dic
   return isError(dictionary.error) ? dictionary.error : undefined;
 });
 
+export const selectLocale = createSelector([selectSettingsRoot], (settings) => settings.locale);
+
 export const selectAutoGroupTiles = createSelector([selectSettingsRoot], (settings) => settings.autoGroupTiles);
 
-export const selectLocale = createSelector([selectSettingsRoot], (settings) => settings.locale);
+export const selectLocaleAutoGroupTiles = createSelector([selectLocale, selectSettingsRoot], (locale, settings) => {
+  if (LOCALE_FEATURES[locale].direction === 'ltr' || settings.autoGroupTiles === null) {
+    return settings.autoGroupTiles;
+  }
+
+  return settings.autoGroupTiles === 'left' ? 'right' : 'left';
+});
 
 export const selectBoard = selectBoardRoot;
 
@@ -54,6 +63,14 @@ export const selectCellIsFiltered = createSelector([selectCellFilter, selectPoin
   return cellFilter.some((cell) => cell.x === x && cell.y === y);
 });
 
+export const selectCellIsValid = createSelector([selectConfig, selectCell], (config, cell) => {
+  if (!cell.hasTile()) {
+    return true;
+  }
+
+  return config.tiles.some((tile) => tile.character === cell.tile.character);
+});
+
 export const selectResults = createSelector([selectResultsRoot], (results) => results.results);
 
 export const selectResultsQuery = createSelector([selectResultsRoot], (results) => results.query);
@@ -132,6 +149,17 @@ export const selectCharacterPoints = createSelector(
   },
 );
 
+export const selectCharacterIsValid = createSelector(
+  [selectConfig, selectCharacter],
+  (config: Config, character: string | null) => {
+    if (character === null || character === BLANK) {
+      return true;
+    }
+
+    return config.tiles.some((tile) => tile.character === character);
+  },
+);
+
 export const selectTilePoints = createSelector([selectConfig, selectTile], (config: Config, tile: Tile | null) => {
   return config.getTilePoints(tile);
 });

package/packages/scrabble-solver/src/state/slices/boardInitialState.ts

@@ -7,4 +7,31 @@ const { configId, locale } = settingsInitialState;
 const { boardHeight, boardWidth } = getLocaleConfig(configId, locale);
 const boardInitialState: Board = 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;
+// };
+
 export default boardInitialState;

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

@@ -1,4 +1,4 @@
-@mixin tablet() {
+@mixin tablet {
   @media (max-width: 1024px) {
     @content;
   }
@@ -73,3 +73,8 @@
   font-size: var(--font--size--s);
   font-family: var(--font--family);
 }
+
+@mixin text-stroke($color, $size: 1px) {
+  text-shadow: $size 0 $color, (-$size) 0 $color, 0 $size $color, 0 (-$size) $color, (-$size) (-$size) $color,
+    (-$size) $size $color, $size (-$size) $color, $size $size $color;
+}

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

@@ -2,6 +2,7 @@ $easeOutSine: cubic-bezier(0.61, 1, 0.88, 1);
 
 :root {
   --border--color: #cdcdcd;
+  --border--color--light: #d9d9d9;
   --border--radius: 5px;
   --border--width: 1px;
   --border: var(--border--width) solid var(--border--color);
@@ -41,13 +42,15 @@ $easeOutSine: cubic-bezier(0.61, 1, 0.88, 1);
   --color--blue: #c7d8f9;
   --color--blue--light: #dde4f6;
   --color--light-blue: #7bb5e5;
-  --color--light-blue--light: #{rgba(#7bb5e5, 0.5)};
+  --color--light-blue--light: #b8d5ed;
   --color--dark-blue: #1868ad;
-  --color--dark-blue--light: #{rgba(#1868ad, 0.5)};
+  --color--dark-blue--light: #86aed1;
   --color--red: #f7c2aa;
   --color--red--light: #fbe0d4;
   --color--violet: #78387f;
-  --color--violet--light: #{rgba(#78387f, 0.5)};
+  --color--violet--light: #b284b8;
+  --color--orange: #fbc997;
+  --color--pink: #f19393;
 
   --font--family: 'Open Sans', sans-serif;
   --font--family--title: 'Lato', sans-serif;

package/packages/solver/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.10.0",
+  "version": "2.10.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrabble-solver/solver",
-      "version": "2.10.0",
+      "version": "2.10.2",
       "license": "CC-BY-NC-ND-4.0",
       "dependencies": {
         "@kamilmielnik/trie": "^2.0.1"

package/packages/solver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.10.0",
+  "version": "2.10.2",
   "description": "Scrabble Solver 2 - Solver",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -25,12 +25,12 @@
   },
   "dependencies": {
     "@kamilmielnik/trie": "^2.0.1",
-    "@scrabble-solver/types": "^2.10.0"
+    "@scrabble-solver/types": "^2.10.2"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.10.0",
-    "@scrabble-solver/constants": "^2.10.0",
-    "@scrabble-solver/dictionaries": "^2.10.0"
+    "@scrabble-solver/configs": "^2.10.2",
+    "@scrabble-solver/constants": "^2.10.2",
+    "@scrabble-solver/dictionaries": "^2.10.2"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }

package/packages/solver/src/generatePattern.ts

@@ -12,6 +12,7 @@ const generatePattern = <P extends Pattern>({
   board: Board;
   cells: Cell[];
   config: Config;
+  // eslint-disable-next-line @typescript-eslint/no-shadow
   PatternModel: new (board: Board, cells: Cell[]) => P;
 }): P[] => {
   const startIndices = generateStartIndices(cells);

package/packages/types/build/Board.js

@@ -7,11 +7,6 @@ const constants_1 = require("@scrabble-solver/constants");
 const Cell_1 = __importDefault(require("./Cell"));
 const Tile_1 = __importDefault(require("./Tile"));
 class Board {
-    constructor({ rows }) {
-        this.rows = rows;
-        this.columnsCount = rows[0].length;
-        this.rowsCount = rows.length;
-    }
     static create(width, height) {
         return Board.fromStringArray(Array(height).fill(Array(width).fill(' ').join('')));
     }
@@ -30,6 +25,11 @@ class Board {
             }))),
         });
     }
+    constructor({ rows }) {
+        this.rows = rows;
+        this.columnsCount = rows[0].length;
+        this.rowsCount = rows.length;
+    }
     get center() {
         const x = Math.floor(this.columnsCount / 2);
         const y = Math.floor(this.rowsCount / 2);

package/packages/types/build/BoardJson.d.ts

@@ -1,4 +1,4 @@
 import CellJson from './CellJson';
-declare type BoardJson = CellJson[][];
+type BoardJson = CellJson[][];
 export declare const isBoardJson: (value: unknown) => value is BoardJson;
 export default BoardJson;

package/packages/types/build/Cell.js

@@ -5,13 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const Tile_1 = __importDefault(require("./Tile"));
 class Cell {
-    // eslint-disable-next-line no-undef
-    constructor({ isEmpty = true, tile = Tile_1.default.Null, x, y }) {
-        this.isEmpty = isEmpty;
-        this.tile = tile;
-        this.x = x;
-        this.y = y;
-    }
     static fromJson(json) {
         return new Cell({
             isEmpty: json.isEmpty,
@@ -20,6 +13,13 @@ class Cell {
             y: json.y,
         });
     }
+    // eslint-disable-next-line no-undef
+    constructor({ isEmpty = true, tile = Tile_1.default.Null, x, y }) {
+        this.isEmpty = isEmpty;
+        this.tile = tile;
+        this.x = x;
+        this.y = y;
+    }
     clone() {
         return new Cell({
             isEmpty: this.isEmpty,

package/packages/types/build/Collision.d.ts

@@ -1,3 +1,3 @@
 import Cell from './Cell';
-declare type Collision = Cell[];
+type Collision = Cell[];
 export default Collision;

package/packages/types/build/CollisionJson.d.ts

@@ -1,3 +1,3 @@
 import CellJson from './CellJson';
-declare type CollisionJson = CellJson[];
+type CollisionJson = CellJson[];
 export default CollisionJson;

package/packages/types/build/Config.js

@@ -7,14 +7,14 @@ const constants_1 = require("@scrabble-solver/constants");
 const CharacterBonus_1 = __importDefault(require("./CharacterBonus"));
 const WordBonus_1 = __importDefault(require("./WordBonus"));
 class Config {
+    static fromJson(json) {
+        return new Config(json);
+    }
     constructor(config) {
         this.bonuses = getBonuses(config);
         this.config = config;
         this.pointsMap = getPointsMap(this.config);
     }
-    static fromJson(json) {
-        return new Config(json);
-    }
     get allTilesBonusScore() {
         return this.config.allTilesBonusScore;
     }

package/packages/types/build/Result.d.ts

@@ -1,7 +1,7 @@
 import Cell from './Cell';
 import ResultJson from './ResultJson';
 import Tile from './Tile';
-declare type Collision = Cell[];
+type Collision = Cell[];
 declare class Result {
     static fromJson(json: ResultJson): Result;
     readonly blanksCount: number;

package/packages/types/build/Result.js

@@ -6,6 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const constants_1 = require("@scrabble-solver/constants");
 const Cell_1 = __importDefault(require("./Cell"));
 class Result {
+    static fromJson(json) {
+        return new Result({
+            id: json.id,
+            cells: json.cells.map(Cell_1.default.fromJson),
+            collisions: json.collisions.map((collision) => collision.map(Cell_1.default.fromJson)),
+            points: json.points,
+        });
+    }
     constructor({ cells, id, collisions, points, }) {
         const tiles = getTiles(cells);
         this.blanksCount = getBlanks(tiles).length;
@@ -23,14 +31,6 @@ class Result {
         this.words = getWords(cells, collisions);
         this.wordsCount = 1 + this.collisions.length;
     }
-    static fromJson(json) {
-        return new Result({
-            id: json.id,
-            cells: json.cells.map(Cell_1.default.fromJson),
-            collisions: json.collisions.map((collision) => collision.map(Cell_1.default.fromJson)),
-            points: json.points,
-        });
-    }
     toJson() {
         return {
             cells: this.cells.map((cell) => cell.toJson()),

package/packages/types/build/Tile.js

@@ -2,10 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const constants_1 = require("@scrabble-solver/constants");
 class Tile {
-    constructor({ character, isBlank = false }) {
-        this.character = character;
-        this.isBlank = isBlank;
-    }
     static fromJson(json) {
         if (!json) {
             return Tile.Null;
@@ -15,6 +11,10 @@ class Tile {
             isBlank: json.isBlank,
         });
     }
+    constructor({ character, isBlank = false }) {
+        this.character = character;
+        this.isBlank = isBlank;
+    }
     clone() {
         return new Tile({
             character: this.character,

package/packages/types/build/WordDefinition.js

@@ -1,12 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class WordDefinition {
-    constructor({ definitions, exists, isAllowed, word }) {
-        this.definitions = definitions;
-        this.exists = exists;
-        this.isAllowed = isAllowed;
-        this.word = word;
-    }
     static fromJson(json) {
         if (!json) {
             return WordDefinition.Null;
@@ -18,6 +12,12 @@ class WordDefinition {
             word: json.word,
         });
     }
+    constructor({ definitions, exists, isAllowed, word }) {
+        this.definitions = definitions;
+        this.exists = exists;
+        this.isAllowed = isAllowed;
+        this.word = word;
+    }
     toJson() {
         return {
             definitions: this.definitions,

package/packages/types/package-lock.json

@@ -0,0 +1,28 @@
+{
+  "name": "@scrabble-solver/types",
+  "version": "2.10.2",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@scrabble-solver/types",
+      "version": "2.10.2",
+      "license": "CC-BY-NC-ND-4.0",
+      "dependencies": {
+        "@scrabble-solver/constants": "^2.10.2"
+      }
+    },
+    "node_modules/@scrabble-solver/constants": {
+      "version": "2.10.1",
+      "resolved": "https://registry.npmjs.org/@scrabble-solver/constants/-/constants-2.10.1.tgz",
+      "integrity": "sha512-XrLcJQREt1OHHA1VY+/8mS9avJCcS0jaXKmUABxQCPpBOZMD39G4E/0ebgwp4uNjxogIYZccRQXG2olYSZukwA=="
+    }
+  },
+  "dependencies": {
+    "@scrabble-solver/constants": {
+      "version": "2.10.1",
+      "resolved": "https://registry.npmjs.org/@scrabble-solver/constants/-/constants-2.10.1.tgz",
+      "integrity": "sha512-XrLcJQREt1OHHA1VY+/8mS9avJCcS0jaXKmUABxQCPpBOZMD39G4E/0ebgwp4uNjxogIYZccRQXG2olYSZukwA=="
+    }
+  }
+}

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/types",
-  "version": "2.10.0",
+  "version": "2.10.2",
   "description": "Scrabble Solver 2 - Types",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -24,7 +24,7 @@
     "clean:force": "npm run clean && rimraf package-lock.json"
   },
   "dependencies": {
-    "@scrabble-solver/constants": "^2.10.0"
+    "@scrabble-solver/constants": "^2.10.2"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }

package/packages/word-definitions/build/parse/parseEnglish.js

@@ -8,7 +8,7 @@ const parseEnglish = (html) => {
     const $ = (0, cheerio_1.load)(html);
     $('strong.mw_t_bc').replaceWith(', ');
     $('.text-lowercase').remove();
-    $('[id^=dictionary-entry]').find('.dtText > *:not(a)').remove();
+    $('.sub-content-thread').remove();
     const $definitions = $('[id^=dictionary-entry]').find('.dtText, .cxl-ref');
     return {
         definitions: Array.from($definitions).map((definition) => $(definition).text().replace(/\n/g, '')),

package/packages/word-definitions/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@scrabble-solver/word-definitions",
-  "version": "2.10.0",
+  "version": "2.10.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrabble-solver/word-definitions",
-      "version": "2.10.0",
+      "version": "2.10.2",
       "license": "CC-BY-NC-ND-4.0",
       "dependencies": {
         "cheerio": "^1.0.0-rc.12",

package/packages/word-definitions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/word-definitions",
-  "version": "2.10.0",
+  "version": "2.10.2",
   "description": "Scrabble Solver 2 - Word definitions",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -23,7 +23,7 @@
     "clean": "rimraf build/ node_modules/ package-lock.json"
   },
   "dependencies": {
-    "@scrabble-solver/types": "^2.10.0",
+    "@scrabble-solver/types": "^2.10.2",
     "cheerio": "^1.0.0-rc.12",
     "follow-redirects": "^1.15.2",
     "striptags": "^3.2.0"