@logic-pad/core 0.4.6 → 0.6.0

package/dist/data/rules/lyingSymbolRule.js

@@ -0,0 +1,239 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { Color, Orientation, State, } from '../primitives.js';
+import Rule from './rule.js';
+import validateGrid from '../validate.js';
+import Symbol from '../symbols/symbol.js';
+import LetterSymbol from '../symbols/letterSymbol.js';
+import GalaxySymbol from '../symbols/galaxySymbol.js';
+import LotusSymbol from '../symbols/lotusSymbol.js';
+import AreaNumberSymbol from '../symbols/areaNumberSymbol.js';
+class IgnoredSymbol extends Symbol {
+    constructor(symbol, state) {
+        super(symbol.x, symbol.y);
+        Object.defineProperty(this, "symbol", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: symbol
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: state
+        });
+        this.symbol = symbol;
+        this.state = state;
+    }
+    get id() {
+        return `ignored_${this.symbol.id}`;
+    }
+    get explanation() {
+        return this.symbol.explanation;
+    }
+    get configs() {
+        return [];
+    }
+    createExampleGrid() {
+        return this.symbol.createExampleGrid();
+    }
+    get necessaryForCompletion() {
+        return this.symbol.necessaryForCompletion;
+    }
+    get visibleWhenSolving() {
+        return this.symbol.visibleWhenSolving;
+    }
+    get sortOrder() {
+        return this.symbol.sortOrder;
+    }
+    validateSymbol(_grid, _solution) {
+        return this.state;
+    }
+    copyWith({ symbol, state }) {
+        return new IgnoredSymbol(symbol ?? this.symbol, state ?? this.state);
+    }
+    withSymbol(symbol) {
+        return this.copyWith({ symbol });
+    }
+    equals(other) {
+        return other === this;
+    }
+}
+class IgnoredRule extends Rule {
+    constructor(rule, state) {
+        super();
+        Object.defineProperty(this, "rule", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: rule
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: state
+        });
+        this.rule = rule;
+        this.state = state;
+    }
+    get searchVariants() {
+        return [];
+    }
+    get id() {
+        return `ignored_${this.rule.id}`;
+    }
+    get explanation() {
+        return this.rule.explanation;
+    }
+    get configs() {
+        return [];
+    }
+    createExampleGrid() {
+        return this.rule.createExampleGrid();
+    }
+    get necessaryForCompletion() {
+        return this.rule.necessaryForCompletion;
+    }
+    get visibleWhenSolving() {
+        return this.rule.visibleWhenSolving;
+    }
+    get isSingleton() {
+        return this.rule.isSingleton;
+    }
+    validateGrid(_grid) {
+        if (this.state === State.Error)
+            return { state: State.Error, positions: [] };
+        else
+            return { state: this.state };
+    }
+    copyWith({ rule, state }) {
+        return new IgnoredRule(rule ?? this.rule, state ?? this.state);
+    }
+    equals(other) {
+        return other === this;
+    }
+}
+class LyingSymbolRule extends Rule {
+    /**
+     * **<count> symbols are lying and are incorrect**
+     *
+     * @param count Number of lying symbols
+     */
+    constructor(count) {
+        super();
+        Object.defineProperty(this, "count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: count
+        });
+        this.count = count;
+    }
+    get id() {
+        return `lying_symbols`;
+    }
+    get explanation() {
+        return `${this.count} symbol${this.count <= 1 ? ' is' : 's are'} *lying* and ${this.count <= 1 ? 'is' : 'are'} incorrect`;
+    }
+    get configs() {
+        return LyingSymbolRule.CONFIGS;
+    }
+    createExampleGrid() {
+        return LyingSymbolRule.EXAMPLE_GRID;
+    }
+    get searchVariants() {
+        return LyingSymbolRule.SEARCH_VARIANTS;
+    }
+    validateGrid(_) {
+        return { state: State.Incomplete };
+    }
+    get isSingleton() {
+        return true;
+    }
+    onFinalValidation(grid, solution, state) {
+        const ignoredSymbols = [];
+        state.symbols.forEach((values, key) => {
+            values.forEach((state, idx) => {
+                if (state === State.Error)
+                    ignoredSymbols.push([key, idx]);
+            });
+        });
+        if (ignoredSymbols.length > this.count) {
+            const thisIdx = grid.rules.findIndex(rule => rule.id === this.id);
+            return {
+                final: State.Error,
+                rules: state.rules.map((rule, idx) => idx === thisIdx ? { state: State.Error, positions: [] } : rule),
+                symbols: state.symbols,
+            };
+        }
+        const newSymbols = new Map();
+        grid.symbols.forEach((values, key) => {
+            values.forEach((symbol, idx) => {
+                if (!newSymbols.has(key)) {
+                    newSymbols.set(key, []);
+                }
+                if (ignoredSymbols.some(([k, i]) => k === key && i === idx)) {
+                    newSymbols.get(key).push(new IgnoredSymbol(symbol, State.Ignored));
+                }
+                else {
+                    newSymbols.get(key).push(symbol);
+                }
+            });
+        });
+        const newRules = grid.rules.map(rule => rule.id === this.id
+            ? new IgnoredRule(this, ignoredSymbols.length === this.count
+                ? State.Satisfied
+                : grid.getTileCount(true, false, Color.Gray) === 0
+                    ? State.Error
+                    : State.Incomplete)
+            : rule);
+        return validateGrid(grid.copyWith({ rules: newRules, symbols: newSymbols }), solution);
+    }
+    copyWith({ count }) {
+        return new LyingSymbolRule(count ?? this.count);
+    }
+    withCount(count) {
+        return this.copyWith({ count });
+    }
+}
+Object.defineProperty(LyingSymbolRule, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['bbbbw', 'wwbbb', 'bbbbw', 'wbbww']).withSymbols([
+        new LetterSymbol(4, 0, 'A'),
+        new GalaxySymbol(1, 1),
+        new LotusSymbol(2, 2, Orientation.Up),
+        new LetterSymbol(0, 3, 'A'),
+        new AreaNumberSymbol(4, 3, 1),
+    ]))
+});
+Object.defineProperty(LyingSymbolRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Number,
+            default: 1,
+            min: 1,
+            max: 100,
+            step: 1,
+            field: 'count',
+            description: 'Number of liars',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(LyingSymbolRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new LyingSymbolRule(1).searchVariant(),
+    ]
+});
+export default LyingSymbolRule;
+export const instance = new LyingSymbolRule(1);

package/dist/data/rules/musicGridRule.js

@@ -200,7 +200,7 @@ Object.defineProperty(MusicGridRule, "CONFIGS", {
         {
             type: ConfigType.NullableGrid,
             default: null,
-            nonNullDefault: new GridData(5, 4).addRule(new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALLE)], null)),
+            nonNullDefault: GridData.create(5, 4).addRule(new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALLE)], null)),
             field: 'track',
             description: 'Track',
             configurable: true,

package/dist/data/rules/mysteryRule.js

@@ -52,7 +52,7 @@ class MysteryRule extends Rule {
         return false;
     }
     onFinalValidation(grid, _solution, state) {
-        if (state.final === State.Satisfied)
+        if (State.isSatisfied(state.final))
             return state;
         if (grid.colorEquals(this.solution))
             return {
@@ -121,7 +121,7 @@ class MysteryRule extends Rule {
                 return tile.withColor(solutionTile.color);
             })
             : solution.tiles;
-        return new GridData(baseGrid?.width ?? solution.width, baseGrid?.height ?? solution.height, tiles);
+        return GridData.create(baseGrid?.width ?? solution.width, baseGrid?.height ?? solution.height, tiles);
     }
 }
 Object.defineProperty(MysteryRule, "EXAMPLE_GRID", {

package/dist/data/rules/offByXRule.d.ts

@@ -20,7 +20,7 @@ export default class OffByXRule extends Rule implements SymbolValidationHandler
     get configs(): readonly AnyConfig[] | null;
     createExampleGrid(): GridData;
     get searchVariants(): SearchVariant[];
-    validateGrid(_grid: GridData): RuleState;
+    validateGrid(grid: GridData): RuleState;
     onSymbolValidation(grid: GridData, symbol: Symbol, _validator: (grid: GridData) => State): State | undefined;
     get isSingleton(): boolean;
     copyWith({ number }: {

package/dist/data/rules/offByXRule.js

@@ -1,6 +1,6 @@
 import { ConfigType } from '../config.js';
 import GridData from '../grid.js';
-import { State } from '../primitives.js';
+import { Color, State } from '../primitives.js';
 import AreaNumberSymbol from '../symbols/areaNumberSymbol.js';
 import NumberSymbol from '../symbols/numberSymbol.js';
 import Rule from './rule.js';
@@ -38,8 +38,12 @@ class OffByXRule extends Rule {
     get searchVariants() {
         return OffByXRule.SEARCH_VARIANTS;
     }
-    validateGrid(_grid) {
-        return { state: State.Incomplete };
+    validateGrid(grid) {
+        return {
+            state: grid.getTileCount(true, false, Color.Gray) === 0
+                ? State.Satisfied
+                : State.Incomplete,
+        };
     }
     onSymbolValidation(grid, symbol, _validator) {
         if (symbol instanceof NumberSymbol) {

package/dist/data/rules/regionAreaRule.js

@@ -62,7 +62,7 @@ class RegionAreaRule extends Rule {
                             ? Color.Dark
                             : Color.Light);
             });
-            return new GridData(5, 4, tiles);
+            return GridData.create(5, 4, tiles);
         }
     }
     get searchVariants() {
@@ -157,13 +157,13 @@ Object.defineProperty(RegionAreaRule, "EXAMPLE_GRID_LIGHT", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: Object.freeze(RegionAreaRule.EXAMPLE_GRID_DARK.map(grid => new GridData(grid.width, grid.height, grid.tiles.map(row => row.map(tile => tile.withColor(tile.color === Color.Dark ? Color.Light : Color.Dark))))))
+    value: Object.freeze(RegionAreaRule.EXAMPLE_GRID_DARK.map(grid => GridData.create(grid.width, grid.height, grid.tiles.map(row => row.map(tile => tile.withColor(tile.color === Color.Dark ? Color.Light : Color.Dark))))))
 });
 Object.defineProperty(RegionAreaRule, "EXAMPLE_GRID_GRAY", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: Object.freeze(RegionAreaRule.EXAMPLE_GRID_DARK.map(grid => new GridData(grid.width, grid.height, grid.tiles.map((row, y) => row.map((tile, x) => tile.withColor(tile.color === Color.Dark
+    value: Object.freeze(RegionAreaRule.EXAMPLE_GRID_DARK.map(grid => GridData.create(grid.width, grid.height, grid.tiles.map((row, y) => row.map((tile, x) => tile.withColor(tile.color === Color.Dark
         ? Color.Gray
         : x % 2 !== y % 2
             ? Color.Dark

package/dist/data/rules/rules.gen.d.ts

@@ -5,6 +5,7 @@ export { instance as CompletePatternRule } from './completePatternRule.js';
 export { instance as ConnectAllRule } from './connectAllRule.js';
 export { instance as CustomRule } from './customRule.js';
 export { instance as ForesightRule } from './foresightRule.js';
+export { instance as LyingSymbolRule } from './lyingSymbolRule.js';
 export { instance as MusicGridRule } from './musicGridRule.js';
 export { instance as MysteryRule } from './mysteryRule.js';
 export { instance as OffByXRule } from './offByXRule.js';

package/dist/data/rules/rules.gen.js

@@ -9,6 +9,7 @@ export { instance as CompletePatternRule } from './completePatternRule.js';
 export { instance as ConnectAllRule } from './connectAllRule.js';
 export { instance as CustomRule } from './customRule.js';
 export { instance as ForesightRule } from './foresightRule.js';
+export { instance as LyingSymbolRule } from './lyingSymbolRule.js';
 export { instance as MusicGridRule } from './musicGridRule.js';
 export { instance as MysteryRule } from './mysteryRule.js';
 export { instance as OffByXRule } from './offByXRule.js';

package/dist/data/serializer/serializer_v0.js

@@ -422,7 +422,7 @@ export default class SerializerV0 extends SerializerBase {
                 throw new Error(`Invalid data: ${d}`);
             }
         }
-        return new GridData(width ?? tiles?.[0].length ?? 0, height ?? tiles?.length ?? 0, tiles, connections, zones, symbols, rules);
+        return GridData.create(width ?? tiles?.[0].length ?? 0, height ?? tiles?.length ?? 0, tiles, connections, zones, symbols, rules);
     }
     stringifyPuzzle(puzzle) {
         let grid = puzzle.grid;

package/dist/data/solver/allSolvers.js

@@ -1,4 +1,4 @@
-import UndercluedSolver from './underclued/undercluedSolver.js';
+import UniversalSolver from './universal/universalSolver.js';
 import BacktrackSolver from './backtrack/backtrackSolver.js';
 import Z3Solver from './z3/z3Solver.js';
 const allSolvers = new Map();
@@ -6,6 +6,6 @@ function register(prototype) {
     allSolvers.set(prototype.id, prototype);
 }
 register(new BacktrackSolver());
-register(new UndercluedSolver());
+register(new UniversalSolver());
 register(new Z3Solver());
 export { allSolvers };

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

@@ -1,9 +1,8 @@
-import GridData from '../../grid.js';
-import Solver from '../solver.js';
-export default class BacktrackSolver extends Solver {
+import EventIteratingSolver from '../eventIteratingSolver.js';
+export default class BacktrackSolver extends EventIteratingSolver {
     private static readonly supportedInstrs;
     readonly id = "backtrack";
     readonly description = "Solves puzzles using backtracking with optimizations (blazingly fast). Support most rules and symbols (including underclued).";
-    solve(grid: GridData): AsyncGenerator<GridData | null>;
+    protected createWorker(): Worker;
     isInstructionSupported(instructionId: string): boolean;
 }

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

@@ -1,4 +1,3 @@
-import { EventIterator } from 'event-iterator';
 import { instance as banPatternInstance } from '../../rules/banPatternRule.js';
 import { instance as cellCountInstance } from '../../rules/cellCountRule.js';
 import { instance as regionAreaInstance } from '../../rules/regionAreaRule.js';
@@ -6,7 +5,6 @@ import { instance as sameShapeInstance } from '../../rules/sameShapeRule.js';
 import { instance as symbolsPerRegionInstance } from '../../rules/symbolsPerRegionRule.js';
 import { instance as undercluedInstance } from '../../rules/undercluedRule.js';
 import { instance as uniqueShapeInstance } from '../../rules/uniqueShapeRule.js';
-import { Serializer } from '../../serializer/allSerializers.js';
 import { instance as areaNumberInstance } from '../../symbols/areaNumberSymbol.js';
 import { instance as dartInstance } from '../../symbols/dartSymbol.js';
 import { instance as galaxyInstance } from '../../symbols/galaxySymbol.js';
@@ -15,9 +13,9 @@ import { instance as lotusInstance } from '../../symbols/lotusSymbol.js';
 import { instance as minesweeperInstance } from '../../symbols/minesweeperSymbol.js';
 import { instance as myopiaInstance } from '../../symbols/myopiaSymbol.js';
 import { instance as viewpointInstance } from '../../symbols/viewpointSymbol.js';
-import Solver from '../solver.js';
 import { instance as connectAllInstance } from '../z3/modules/connectAllModule.js';
-class BacktrackSolver extends Solver {
+import EventIteratingSolver from '../eventIteratingSolver.js';
+class BacktrackSolver extends EventIteratingSolver {
     constructor() {
         super(...arguments);
         Object.defineProperty(this, "id", {
@@ -33,34 +31,10 @@ class BacktrackSolver extends Solver {
             value: 'Solves puzzles using backtracking with optimizations (blazingly fast). Support most rules and symbols (including underclued).'
         });
     }
-    async *solve(grid) {
-        const worker = new Worker(new URL(`./backtrackWorker.js`, import.meta.url), {
+    createWorker() {
+        return new Worker(new URL(`./backtrackWorker.js`, import.meta.url), {
             type: 'module',
         });
-        try {
-            const iterator = new EventIterator(({ push, stop, fail }) => {
-                worker.postMessage(Serializer.stringifyGrid(grid.resetTiles()));
-                worker.addEventListener('message', (e) => {
-                    if (e.data) {
-                        push(Serializer.parseGrid(e.data));
-                    }
-                    else {
-                        stop();
-                    }
-                });
-                worker.addEventListener('error', (e) => {
-                    alert(`Error while solving!\n${e.message}`);
-                    fail(e);
-                });
-            });
-            for await (const solution of iterator) {
-                yield solution;
-            }
-            yield null;
-        }
-        finally {
-            worker.terminate();
-        }
     }
     isInstructionSupported(instructionId) {
         return BacktrackSolver.supportedInstrs.includes(instructionId);

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

@@ -1,2 +1 @@
-declare const _default: null;
-export default _default;
+export {};

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

@@ -74,9 +74,10 @@ function translateToBTGridData(grid) {
             else if (id === letterInstance.id) {
                 continue;
             }
-            if (!module)
+            if (!module && symbol.necessaryForCompletion)
                 throw new Error('Symbol not supported.');
-            modules.push(module);
+            if (module)
+                modules.push(module);
         }
     }
     const letterSymbols = grid.symbols.get(letterInstance.id);
@@ -226,7 +227,9 @@ function solveUnderclued(input) {
     function search(x, y, tile, color) {
         // count++;
         // console.log(`Trying (${x}, ${y}) with ${color}`);
-        const newGrid = grid.setTile(x, y, tile.withColor(color));
+        const newGrid = grid.fastCopyWith({
+            tiles: grid.setTile(x, y, tile.withColor(color)),
+        });
         // Solve
         let solution;
         solveNormal(newGrid, sol => {
@@ -258,9 +261,13 @@ function solveUnderclued(input) {
             if (!darkPossible && !lightPossible)
                 return null;
             if (darkPossible && !lightPossible)
-                grid = grid.setTile(x, y, tile.withColor(Color.Dark));
+                grid = grid.fastCopyWith({
+                    tiles: grid.setTile(x, y, tile.withColor(Color.Dark)),
+                });
             if (!darkPossible && lightPossible)
-                grid = grid.setTile(x, y, tile.withColor(Color.Light));
+                grid = grid.fastCopyWith({
+                    tiles: grid.setTile(x, y, tile.withColor(Color.Light)),
+                });
         }
     }
     // console.log(`Solve count: ${count}`);
@@ -289,6 +296,3 @@ onmessage = e => {
     // console.timeEnd('Solve time');
     postMessage(null);
 };
-// make typescript happy
-// eslint-disable-next-line import/no-anonymous-default-export
-export default null;

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

@@ -0,0 +1,6 @@
+import GridData from '../grid.js';
+import Solver, { CancelRef } from './solver.js';
+export default abstract class EventIteratingSolver extends Solver {
+    protected abstract createWorker(): Worker;
+    solve(grid: GridData, cancelRef: CancelRef): AsyncGenerator<GridData | null>;
+}

package/dist/data/solver/eventIteratingSolver.js

@@ -0,0 +1,33 @@
+import { Serializer } from '../serializer/allSerializers.js';
+import Solver from './solver.js';
+import { EventIterator } from 'event-iterator';
+export default class EventIteratingSolver extends Solver {
+    async *solve(grid, cancelRef) {
+        const worker = this.createWorker();
+        cancelRef.cancel = () => worker.terminate();
+        try {
+            const iterator = new EventIterator(({ push, stop, fail }) => {
+                worker.postMessage(Serializer.stringifyGrid(grid.resetTiles()));
+                worker.addEventListener('message', (e) => {
+                    if (e.data) {
+                        push(Serializer.parseGrid(e.data));
+                    }
+                    else {
+                        stop();
+                    }
+                });
+                worker.addEventListener('error', (e) => {
+                    alert(`Error while solving!\n${e.message}`);
+                    fail(e);
+                });
+            });
+            for await (const solution of iterator) {
+                yield solution;
+            }
+            yield null;
+        }
+        finally {
+            worker.terminate();
+        }
+    }
+}

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

@@ -1,4 +1,7 @@
 import GridData from '../grid.js';
+export interface CancelRef {
+    cancel?: () => void;
+}
 /**
  * Base class that all solvers must extend.
  */
@@ -28,8 +31,10 @@ export default abstract class Solver {
      *
      * @param grid The grid to solve. The provided grid is guaranteed to be supported by the solver. Some tiles in the
      * grid may already be filled by the user. It is up to the solver to decide whether to respect these tiles or not.
+     * @param cancelRef A reference to a function that can be called to cancel the solver. If cancellation is supported,
+     * the solver can assign a function to `cancelRef.cancel` that will stop the solver when called.
      */
-    abstract solve(grid: GridData): AsyncGenerator<GridData | null>;
+    abstract solve(grid: GridData, cancelRef: CancelRef): AsyncGenerator<GridData | null>;
     /**
      * Check if the solver supports the current browser environment. This method is called once when the user first clicks
      * the "Solve" button, and the result is cached for the duration of the editor session.

package/dist/data/solver/solver.js

@@ -47,7 +47,8 @@ export default class Solver {
         if (grid.rules.some(rule => rule.necessaryForCompletion && !this.isInstructionSupported(rule.id))) {
             return false;
         }
-        if ([...grid.symbols.keys()].some(id => !this.isInstructionSupported(id))) {
+        if ([...grid.symbols.keys()].some(id => grid.symbols.get(id)?.some(s => s.necessaryForCompletion) &&
+            !this.isInstructionSupported(id))) {
             return false;
         }
         return true;

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

@@ -0,0 +1,7 @@
+import EventIteratingSolver from '../eventIteratingSolver.js';
+export default class UniversalSolver extends EventIteratingSolver {
+    readonly id = "universal";
+    readonly description = "A backtracking solver that supports all rules and symbols (including underclued) but is less optimized.";
+    protected createWorker(): Worker;
+    isInstructionSupported(instructionId: string): boolean;
+}

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

@@ -0,0 +1,30 @@
+import { instance as undercluedInstance } from '../../rules/undercluedRule.js';
+import EventIteratingSolver from '../eventIteratingSolver.js';
+export default class UniversalSolver extends EventIteratingSolver {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'universal'
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'A backtracking solver that supports all rules and symbols (including underclued) but is less optimized.'
+        });
+    }
+    createWorker() {
+        return new Worker(new URL('./universalWorker.js', import.meta.url), {
+            type: 'module',
+        });
+    }
+    isInstructionSupported(instructionId) {
+        if (super.isInstructionSupported(instructionId)) {
+            return true;
+        }
+        return instructionId === undercluedInstance.id;
+    }
+}

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

@@ -0,0 +1 @@
+export {};