@scrabble-solver/solver 2.8.9 → 2.8.10

package/build/generateEndIndices.js

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const generateEndIndices = (cells, startIndex) => {
-    return Array(cells.length - startIndex - 1)
-        .fill(0)
-        .map((_, endIndex) => endIndex + startIndex + 1)
-        .filter((endIndex) => endIndex >= cells.length - 1 || !cells[endIndex + 1].hasTile());
+    if (cells.length === 0) {
+        return [];
+    }
+    const endIndices = [];
+    for (let endIndex = startIndex + 1; endIndex < cells.length - 1; ++endIndex) {
+        if (!cells[endIndex + 1].hasTile()) {
+            endIndices.push(endIndex);
+        }
+    }
+    endIndices.push(cells.length - 1);
+    return endIndices;
 };
 exports.default = generateEndIndices;

package/build/generateStartIndices.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const generateStartIndices = (cells) => {
-    return Array(cells.length - 1)
-        .fill(0)
-        .map((_, startIndex) => startIndex)
-        .filter((startIndex) => startIndex === 0 || !cells[startIndex - 1].hasTile());
+    if (cells.length === 0) {
+        return [];
+    }
+    const startIndices = [0];
+    for (let startIndex = 1; startIndex < cells.length - 1; ++startIndex) {
+        if (!cells[startIndex - 1].hasTile()) {
+            startIndices.push(startIndex);
+        }
+    }
+    return startIndices;
 };
 exports.default = generateStartIndices;

package/build/generateVectors.d.ts

@@ -1,6 +1,7 @@
 import { Cell } from '@scrabble-solver/types';
-declare const generateVectors: ({ getNthVector, vectorsCount, }: {
+interface Parameters {
     getNthVector: (index: number) => Cell[];
     vectorsCount: number;
-}) => Cell[][];
+}
+declare const generateVectors: ({ getNthVector, vectorsCount }: Parameters) => Cell[][];
 export default generateVectors;

package/build/generateVectors.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const generateVectors = ({ getNthVector, vectorsCount, }) => {
-    return Array(vectorsCount)
-        .fill(0)
-        .map((_, index) => getNthVector(index));
+const generateVectors = ({ getNthVector, vectorsCount }) => {
+    return Array.from({ length: vectorsCount }, (_, index) => getNthVector(index));
 };
 exports.default = generateVectors;

package/build/solve.d.ts

@@ -1,4 +1,4 @@
 import { Trie } from '@kamilmielnik/trie';
-import { Board, Config, Result, Tile } from '@scrabble-solver/types';
-declare const solve: (trie: Trie, config: Config, board: Board, tiles: Tile[]) => Result[];
+import { Board, Config, ResultJson, Tile } from '@scrabble-solver/types';
+declare const solve: (trie: Trie, config: Config, board: Board, tiles: Tile[]) => ResultJson[];
 export default solve;

package/build/solve.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("@scrabble-solver/types");
 const fillPattern_1 = __importDefault(require("./fillPattern"));
 const generatePatterns_1 = __importDefault(require("./generatePatterns"));
 const getPatternScore_1 = __importDefault(require("./getPatternScore"));
@@ -12,9 +11,9 @@ const solve = (trie, config, board, tiles) => {
     const patterns = (0, generatePatterns_1.default)(config, board);
     const filledPatterns = patterns.flatMap((pattern) => (0, fillPattern_1.default)(trie, config, pattern, tiles));
     const uniquePatterns = (0, getUniquePatterns_1.default)(filledPatterns);
-    const results = uniquePatterns.map((pattern, index) => new types_1.Result({
-        cells: pattern.cells,
-        collisions: pattern.getCollisions().map((collision) => collision.cells),
+    const results = uniquePatterns.map((pattern, index) => ({
+        cells: pattern.cells.map((cell) => cell.toJson()),
+        collisions: pattern.getCollisions().map((collision) => collision.cells.map((cell) => cell.toJson())),
         id: index,
         points: (0, getPatternScore_1.default)(config, pattern),
     }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.9",
+  "version": "2.8.10",
   "description": "Scrabble Solver 2 - Solver",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -24,13 +24,13 @@
     "clean:force": "npm run clean && rimraf package-lock.json"
   },
   "dependencies": {
-    "@kamilmielnik/trie": "^2.0.0",
-    "@scrabble-solver/types": "^2.8.9"
+    "@kamilmielnik/trie": "^2.0.1",
+    "@scrabble-solver/types": "^2.8.10"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.8.9",
-    "@scrabble-solver/constants": "^2.8.9",
-    "@scrabble-solver/dictionaries": "^2.8.9"
+    "@scrabble-solver/configs": "^2.8.10",
+    "@scrabble-solver/constants": "^2.8.10",
+    "@scrabble-solver/dictionaries": "^2.8.10"
   },
-  "gitHead": "8557cc2c5214e6689a5c59373b228b28f5dd8ed4"
+  "gitHead": "8822c74d0d632ee51bca3bf69ccfc7f517bfadb3"
 }

package/src/generateEndIndices.test.ts

@@ -6,6 +6,11 @@ describe('generateEndIndices', () => {
   const emptyCell: Cell = { hasTile: () => false } as Cell;
   const filledCell: Cell = { hasTile: () => true } as Cell;
 
+  it('returns empty array when no cells given', () => {
+    const cells: Cell[] = [];
+    expect(generateEndIndices(cells, 0).length).toBe(0);
+  });
+
   it('finds indices where a new word can end - XXOOOX', () => {
     const cells = [filledCell, filledCell, emptyCell, emptyCell, emptyCell, filledCell];
     expect(generateEndIndices(cells, 3)).toEqual([5]);

package/src/generateEndIndices.ts

@@ -1,10 +1,21 @@
 import { Cell } from '@scrabble-solver/types';
 
 const generateEndIndices = (cells: Cell[], startIndex: number): number[] => {
-  return Array(cells.length - startIndex - 1)
-    .fill(0)
-    .map((_, endIndex) => endIndex + startIndex + 1)
-    .filter((endIndex) => endIndex >= cells.length - 1 || !cells[endIndex + 1].hasTile());
+  if (cells.length === 0) {
+    return [];
+  }
+
+  const endIndices: number[] = [];
+
+  for (let endIndex = startIndex + 1; endIndex < cells.length - 1; ++endIndex) {
+    if (!cells[endIndex + 1].hasTile()) {
+      endIndices.push(endIndex);
+    }
+  }
+
+  endIndices.push(cells.length - 1);
+
+  return endIndices;
 };
 
 export default generateEndIndices;

package/src/generateStartIndices.test.ts

@@ -6,6 +6,11 @@ describe('generateStartIndices', () => {
   const emptyCell: Cell = { hasTile: () => false } as Cell;
   const filledCell: Cell = { hasTile: () => true } as Cell;
 
+  it('returns empty array when no cells given', () => {
+    const cells: Cell[] = [];
+    expect(generateStartIndices(cells).length).toBe(0);
+  });
+
   it('finds indices where a new word can start', () => {
     const cells = [filledCell, filledCell, emptyCell, emptyCell, emptyCell, filledCell];
     const startIndices = generateStartIndices(cells);

package/src/generateStartIndices.ts

@@ -1,10 +1,19 @@
 import { Cell } from '@scrabble-solver/types';
 
 const generateStartIndices = (cells: Cell[]): number[] => {
-  return Array(cells.length - 1)
-    .fill(0)
-    .map((_, startIndex) => startIndex)
-    .filter((startIndex) => startIndex === 0 || !cells[startIndex - 1].hasTile());
+  if (cells.length === 0) {
+    return [];
+  }
+
+  const startIndices: number[] = [0];
+
+  for (let startIndex = 1; startIndex < cells.length - 1; ++startIndex) {
+    if (!cells[startIndex - 1].hasTile()) {
+      startIndices.push(startIndex);
+    }
+  }
+
+  return startIndices;
 };
 
 export default generateStartIndices;

package/src/generateVectors.ts

@@ -1,15 +1,12 @@
 import { Cell } from '@scrabble-solver/types';
 
-const generateVectors = ({
-  getNthVector,
-  vectorsCount,
-}: {
+interface Parameters {
   getNthVector: (index: number) => Cell[];
   vectorsCount: number;
-}): Cell[][] => {
-  return Array(vectorsCount)
-    .fill(0)
-    .map((_, index) => getNthVector(index));
+}
+
+const generateVectors = ({ getNthVector, vectorsCount }: Parameters): Cell[][] => {
+  return Array.from({ length: vectorsCount }, (_, index) => getNthVector(index));
 };
 
 export default generateVectors;

package/src/solve.test.ts

@@ -70,7 +70,7 @@ describe('solve - PL', () => {
     ]);
     const tiles = generateTiles(['a', 'a', 'ą', 'r', 't', 'w', 'z']);
     const results = solve(trie!, config, board, tiles);
-    const bestResult = getBestResult(results);
+    const bestResult = getBestResult(results.map((result) => Result.fromJson(result)));
     expect(bestResult.word).toBe('zmartwychwstałą');
     expect(bestResult.points).toBe(682);
   });
@@ -95,7 +95,7 @@ describe('solve - PL', () => {
     ]);
     const tiles = generateTiles(['ą', 'c', 'h', 't', 'w', 'w', 'z']);
     const results = solve(trie!, config, board, tiles);
-    const bestResult = getBestResult(results);
+    const bestResult = getBestResult(results.map((result) => Result.fromJson(result)));
     expect(bestResult.word).toBe('zmartwychwstałą');
     expect(bestResult.points).toBe(1157);
   });
@@ -132,7 +132,7 @@ describe('solve - ES', () => {
     ]);
     const tiles = generateTiles(['ll', 'a', 'n', 'a']);
     const results = solve(trie!, config, board, tiles);
-    const bestResult = getBestResult(results);
+    const bestResult = getBestResult(results.map((result) => Result.fromJson(result)));
     expect(results.length).toBe(24);
     expect(bestResult.points).toBe(22);
   });

package/src/solve.ts

@@ -1,24 +1,22 @@
 import { Trie } from '@kamilmielnik/trie';
-import { Board, Config, Result, Tile } from '@scrabble-solver/types';
+import { Board, Config, ResultJson, Tile } from '@scrabble-solver/types';
 
 import fillPattern from './fillPattern';
 import generatePatterns from './generatePatterns';
 import getPatternScore from './getPatternScore';
 import getUniquePatterns from './getUniquePatterns';
 
-const solve = (trie: Trie, config: Config, board: Board, tiles: Tile[]): Result[] => {
+const solve = (trie: Trie, config: Config, board: Board, tiles: Tile[]): ResultJson[] => {
   const patterns = generatePatterns(config, board);
   const filledPatterns = patterns.flatMap((pattern) => fillPattern(trie, config, pattern, tiles));
   const uniquePatterns = getUniquePatterns(filledPatterns);
-  const results = uniquePatterns.map(
-    (pattern, index) =>
-      new Result({
-        cells: pattern.cells,
-        collisions: pattern.getCollisions().map((collision) => collision.cells),
-        id: index,
-        points: getPatternScore(config, pattern),
-      }),
-  );
+  const results = uniquePatterns.map((pattern, index) => ({
+    cells: pattern.cells.map((cell) => cell.toJson()),
+    collisions: pattern.getCollisions().map((collision) => collision.cells.map((cell) => cell.toJson())),
+    id: index,
+    points: getPatternScore(config, pattern),
+  }));
+
   return results;
 };