@logic-pad/core 0.23.0 → 0.23.2

package/README.md

@@ -8,7 +8,7 @@ This package is part of Logic Pad. [Bun >=v1.1.0](https://bun.sh/) is required f
 
 ```bash
 # 1. Clone this repository
-git clone https://github.com/hlysine/logic-pad.git
+git clone https://github.com/logic-pad/logic-pad.git
 
 # 2. Restore dependencies
 cd logic-pad

package/assets/logic-core.global.d.ts

@@ -2333,6 +2333,9 @@ declare global {
      * first iteration indicates that the grid is unsolvable. Yielding `null` on the second iteration indicates that the
      * solution is unique.
      *
+     * If the solve finds the trivial solution of not filling any tiles, such as in the case of an underclued grid with
+     * too many alternate solutions, it must yield the solution instead of yielding `null`.
+     *
      * In the current UI implementation, the solver will be terminated after yielding `null`, or after 2 iterations if
      * `null` is never yielded. The solver should perform any necessary cleanup in the `finally` block of the generator.
      *

package/dist/data/dataHelper.js

@@ -116,7 +116,6 @@ export function resize(array, newSize, defaultValue) {
  * @param values The values to compare.
  * @returns Whether all the values are equal.
  */
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
 export function allEqual(...values) {
     return values.every(value => value === values[0]);
 }

package/dist/data/events/eventHelper.js

@@ -1,4 +1,3 @@
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
 export function isEventHandler(val, event) {
     if (typeof val !== 'object' || val === null || val === undefined)
         return false;

package/dist/data/grid.js

@@ -924,34 +924,97 @@ export default class GridData {
                 newTiles[origin.y + y][origin.x + x] = tile;
         });
         const connections = new GridConnections([
-            ...this.connections.edges,
-            ...grid.connections.edges.map(edge => ({
+            ...this.connections.edges.filter(edge => edge.x1 < origin.x ||
+                edge.y1 < origin.y ||
+                edge.x2 < origin.x ||
+                edge.y2 < origin.y ||
+                edge.x1 >= origin.x + grid.width ||
+                edge.y1 >= origin.y + grid.height ||
+                edge.x2 >= origin.x + grid.width ||
+                edge.y2 >= origin.y + grid.height),
+            ...grid.connections.edges
+                .map(edge => ({
                 x1: edge.x1 + origin.x,
                 y1: edge.y1 + origin.y,
                 x2: edge.x2 + origin.x,
                 y2: edge.y2 + origin.y,
-            })),
+            }))
+                .filter(edge => edge.x1 >= 0 &&
+                edge.y1 >= 0 &&
+                edge.x2 >= 0 &&
+                edge.y2 >= 0 &&
+                edge.x1 < this.width &&
+                edge.y1 < this.height &&
+                edge.x2 < this.width &&
+                edge.y2 < this.height),
         ]);
         const zones = new GridZones([
-            ...this.zones.edges,
-            ...grid.zones.edges.map(edge => ({
+            ...this.zones.edges.filter(edge => edge.x1 < origin.x ||
+                edge.y1 < origin.y ||
+                edge.x2 < origin.x ||
+                edge.y2 < origin.y ||
+                edge.x1 >= origin.x + grid.width ||
+                edge.y1 >= origin.y + grid.height ||
+                edge.x2 >= origin.x + grid.width ||
+                edge.y2 >= origin.y + grid.height),
+            ...grid.zones.edges
+                .map(edge => ({
                 x1: edge.x1 + origin.x,
                 y1: edge.y1 + origin.y,
                 x2: edge.x2 + origin.x,
                 y2: edge.y2 + origin.y,
-            })),
+            }))
+                .filter(edge => edge.x1 >= 0 &&
+                edge.y1 >= 0 &&
+                edge.x2 >= 0 &&
+                edge.y2 >= 0 &&
+                edge.x1 < this.width &&
+                edge.y1 < this.height &&
+                edge.x2 < this.width &&
+                edge.y2 < this.height),
         ]);
         const symbols = new Map(this.symbols);
         for (const [id, sourceList] of grid.symbols) {
-            const symbolList = sourceList.map(symbol => symbol.copyWith({ x: symbol.x + origin.x, y: symbol.y + origin.y }));
+            const symbolList = sourceList
+                .filter(symbol => symbol.x + origin.x >= 0 &&
+                symbol.y + origin.y >= 0 &&
+                symbol.x + origin.x < this.width &&
+                symbol.y + origin.y < this.height)
+                .map(symbol => symbol.copyWith({ x: symbol.x + origin.x, y: symbol.y + origin.y }));
             if (symbols.has(id)) {
-                symbols.set(id, [...symbols.get(id), ...symbolList]);
+                const newList = [
+                    ...symbols
+                        .get(id)
+                        .filter(symbol => symbol.x < origin.x ||
+                        symbol.y < origin.y ||
+                        symbol.x >= origin.x + grid.width ||
+                        symbol.y >= origin.y + grid.height),
+                    ...symbolList,
+                ];
+                if (newList.length > 0)
+                    symbols.set(id, newList);
+                else
+                    symbols.delete(id);
             }
-            else {
+            else if (symbolList.length > 0) {
                 symbols.set(id, symbolList);
             }
         }
-        const rules = [...this.rules, ...grid.rules];
+        for (const id of [...symbols.keys()]) {
+            if (grid.symbols.has(id))
+                continue;
+            const newList = symbols
+                .get(id)
+                .filter(symbol => symbol.x < origin.x ||
+                symbol.y < origin.y ||
+                symbol.x >= origin.x + grid.width ||
+                symbol.y >= origin.y + grid.height);
+            if (newList.length > 0)
+                symbols.set(id, newList);
+            else
+                symbols.delete(id);
+        }
+        const rules = GridData.deduplicateRules([...this.rules, ...grid.rules]);
         return this.copyWith({
             tiles: newTiles,
             connections,

package/dist/data/serializer/compressor/streamCompressor.js

@@ -27,7 +27,6 @@ export default class StreamCompressor extends CompressorBase {
     }
     async decompress(input) {
         await ensureCompressionStream();
-        // eslint-disable-next-line @typescript-eslint/no-deprecated
         const bytes = Uint8Array.from(atob(input), c => c.charCodeAt(0));
         const cs = new DecompressionStream(this.algorithm);
         const writer = cs.writable.getWriter();

package/dist/data/solver/auto/autoSolver.js

@@ -97,7 +97,6 @@ class AutoSolver extends Solver {
         }
     }
     async solveOne(generator) {
-        // eslint-disable-next-line no-unreachable-loop
         for await (const grid of generator) {
             return grid;
         }

package/dist/data/solver/backtrack/backtrackWorker.js

@@ -293,12 +293,12 @@ onmessage = e => {
     let count = 0;
     solve(grid, solution => {
         // if (count === 0) console.timeLog('Solve time', 'First solution');
-        if (solution) {
-            if (solution.resetTiles().colorEquals(solution)) {
-                postMessage(null);
-                return false;
-            }
-        }
+        // if (solution) {
+        //   if (solution.resetTiles().colorEquals(solution)) {
+        //     postMessage(null);
+        //     return false;
+        //   }
+        // }
         postMessage(Serializer.stringifyGrid(solution));
         count += 1;
         return count < 2;

package/dist/data/solver/cspuz/cspuzSolver.js

@@ -78,9 +78,8 @@ class CspuzSolver extends EventIteratingSolver {
     }
     async isEnvironmentSupported() {
         try {
-            const abortController = new AbortController();
-            for await (const _ of this.solve(GridData.create(['.']), abortController.signal)) {
-                abortController.abort();
+            for await (const _ of this.solve(GridData.create(['.']))) {
+                // do nothing
             }
             return true;
         }

package/dist/data/solver/cspuz/cspuzWorker.js

@@ -30,12 +30,7 @@ function postSolution(grid, solverResult) {
             }
             return tiles;
         });
-        if (solution.resetTiles().colorEquals(solution)) {
-            postMessage(null);
-        }
-        else {
-            postMessage(Serializer.stringifyGrid(solution));
-        }
+        postMessage(Serializer.stringifyGrid(solution));
     }
 }
 onmessage = e => {

package/dist/data/solver/solver.d.ts

@@ -32,6 +32,9 @@ export default abstract class Solver {
      * first iteration indicates that the grid is unsolvable. Yielding `null` on the second iteration indicates that the
      * solution is unique.
      *
+     * If the solve finds the trivial solution of not filling any tiles, such as in the case of an underclued grid with
+     * too many alternate solutions, it must yield the solution instead of yielding `null`.
+     *
      * In the current UI implementation, the solver will be terminated after yielding `null`, or after 2 iterations if
      * `null` is never yielded. The solver should perform any necessary cleanup in the `finally` block of the generator.
      *

package/dist/data/solver/universal/universalWorker.js

@@ -115,11 +115,11 @@ onmessage = e => {
     const grid = Serializer.parseGrid(e.data);
     let count = 0;
     solve(grid, solution => {
-        if (solution) {
-            if (solution.resetTiles().colorEquals(solution)) {
-                solution = null;
-            }
-        }
+        // if (solution) {
+        //   if (solution.resetTiles().colorEquals(solution)) {
+        //     solution = null;
+        //   }
+        // }
         postMessage(solution ? Serializer.stringifyGrid(solution) : null);
         count += 1;
         return count < 2;

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@logic-pad/core",
-  "version": "0.23.0",
+  "version": "0.23.2",
   "type": "module",
   "files": [
     "dist",
     "assets"
   ],
-  "homepage": "https://github.com/hlysine/logic-pad",
+  "homepage": "https://github.com/logic-pad/logic-pad",
   "repository": {
     "type": "git",
-    "url": "https://github.com/hlysine/logic-pad.git"
+    "url": "https://github.com/logic-pad/logic-pad.git"
   },
   "keywords": [
     "logic",
@@ -42,13 +42,13 @@
   },
   "scripts": {
     "build": "rimraf dist/ && bun run codegen && bunx --bun tsc && bun run typegen",
-    "lint": "cd ../../ && eslint ./packages/logic-core --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
     "codegen": "bun ./scripts/genImports.ts && bun ./scripts/genEntry.ts",
     "typegen": "bun ./scripts/genTypes.ts",
     "prepublishOnly": "bun run build"
   },
   "engines": {
-    "bun": ">=1.1.0"
+    "bun": ">=1.1.0",
+    "node": ">=23.11.0"
   },
   "dependencies": {
     "compression-streams-polyfill": "^0.1.7",