@logic-pad/core 0.1.4 → 0.2.0

package/dist/data/dataHelper.d.ts

@@ -75,3 +75,11 @@ export declare function escape(text: string, escapeCharacters?: string): string;
  * @returns The unescaped text.
  */
 export declare function unescape(text: string, escapeCharacters?: string): string;
+export declare class CachedAccess<T> {
+    private readonly getter;
+    private static readonly UNCACHED;
+    private cache;
+    private constructor();
+    static of<T>(getter: () => T): CachedAccess<T>;
+    get value(): T;
+}

package/dist/data/dataHelper.js

@@ -188,3 +188,34 @@ export function unescape(text, escapeCharacters = '=,:|') {
     }
     return result + text.substring(index);
 }
+export class CachedAccess {
+    constructor(getter) {
+        Object.defineProperty(this, "getter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: getter
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: CachedAccess.UNCACHED
+        });
+    }
+    static of(getter) {
+        return new CachedAccess(getter);
+    }
+    get value() {
+        if (this.cache === CachedAccess.UNCACHED) {
+            this.cache = this.getter();
+        }
+        return this.cache;
+    }
+}
+Object.defineProperty(CachedAccess, "UNCACHED", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Symbol('uncached')
+});

package/dist/data/events/onSymbolDisplay.d.ts

@@ -0,0 +1,15 @@
+import GridData from '../grid.js';
+import Instruction from '../instruction.js';
+import Symbol from '../symbols/symbol.js';
+export interface SymbolDisplayHandler {
+    /**
+     * Controls whether a symbol should be visible in the grid.
+     *
+     * @param grid The grid that is being displayed.
+     * @param symbol The symbol that is being displayed.
+     * @param editing Whether the grid is being edited.
+     * @returns True if the symbol should be displayed, false otherwise. The symbol will not be displayed if any handler returns false.
+     */
+    onSymbolDisplay(grid: GridData, symbol: Symbol, editing: boolean): boolean;
+}
+export declare function handlesSymbolDisplay<T extends Instruction>(val: T): val is T & SymbolDisplayHandler;

package/dist/data/events/onSymbolDisplay.js

@@ -0,0 +1,4 @@
+import { isEventHandler } from './eventHelper.js';
+export function handlesSymbolDisplay(val) {
+    return isEventHandler(val, 'onSymbolDisplay');
+}

package/dist/data/grid.d.ts

@@ -1,8 +1,12 @@
 import GridConnections from './gridConnections.js';
+import { CachedAccess } from './dataHelper.js';
 import { Color, Direction, Orientation, Position } from './primitives.js';
 import Rule from './rules/rule.js';
 import Symbol from './symbols/symbol.js';
 import TileData from './tile.js';
+import MusicGridRule from './rules/musicGridRule.js';
+import CompletePatternRule from './rules/completePatternRule.js';
+import UndercluedRule from './rules/undercluedRule.js';
 export default class GridData {
     readonly width: number;
     readonly height: number;
@@ -10,6 +14,9 @@ export default class GridData {
     readonly connections: GridConnections;
     readonly symbols: ReadonlyMap<string, readonly Symbol[]>;
     readonly rules: readonly Rule[];
+    readonly musicGrid: CachedAccess<MusicGridRule | undefined>;
+    readonly completePattern: CachedAccess<CompletePatternRule | undefined>;
+    readonly underclued: CachedAccess<UndercluedRule | undefined>;
     /**
      * Create a new grid with tiles, connections, symbols and rules.
      * @param width The width of the grid.

package/dist/data/grid.js

@@ -2,8 +2,8 @@ import { handlesGridChange } from './events/onGridChange.js';
 import { handlesGridResize } from './events/onGridResize.js';
 import { handlesSetGrid } from './events/onSetGrid.js';
 import GridConnections from './gridConnections.js';
-import { array, move } from './dataHelper.js';
-import { Color } from './primitives.js';
+import { CachedAccess, array, move } from './dataHelper.js';
+import { Color, MajorRule, } from './primitives.js';
 import TileData from './tile.js';
 const NEIGHBOR_OFFSETS = [
     { x: -1, y: 0 },
@@ -12,6 +12,7 @@ const NEIGHBOR_OFFSETS = [
     { x: 0, y: 1 },
 ];
 export default class GridData {
+    /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */
     /**
      * Create a new grid with tiles, connections, symbols and rules.
      * @param width The width of the grid.
@@ -58,6 +59,26 @@ export default class GridData {
             writable: true,
             value: void 0
         });
+        // Important rules are cached for quick access
+        /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+        Object.defineProperty(this, "musicGrid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.MusicGrid))
+        });
+        Object.defineProperty(this, "completePattern", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.CompletePattern))
+        });
+        Object.defineProperty(this, "underclued", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.Underclued))
+        });
         this.width = width;
         this.height = height;
         this.tiles = tiles ?? array(width, height, () => TileData.empty());

package/dist/data/instruction.d.ts

@@ -9,6 +9,7 @@ export default abstract class Instruction extends Configurable {
      */
     get validateWithSolution(): boolean;
     get necessaryForCompletion(): boolean;
+    get visibleWhenSolving(): boolean;
     /**
      * Check if this instruction is equal to another instruction by comparing their IDs and configs.
      *

package/dist/data/instruction.js

@@ -9,6 +9,9 @@ export default class Instruction extends Configurable {
     get necessaryForCompletion() {
         return true;
     }
+    get visibleWhenSolving() {
+        return true;
+    }
     /**
      * Check if this instruction is equal to another instruction by comparing their IDs and configs.
      *

package/dist/data/primitives.d.ts

@@ -8,6 +8,14 @@ export interface Edge {
     readonly x2: number;
     readonly y2: number;
 }
+/**
+ * Major rules are frequently referenced in grids to provide additional UI.
+ */
+export declare enum MajorRule {
+    MusicGrid = "music",
+    CompletePattern = "complete_pattern",
+    Underclued = "underclued"
+}
 export declare enum State {
     Error = "error",
     Satisfied = "satisfied",

package/dist/data/primitives.js

@@ -1,3 +1,12 @@
+/**
+ * Major rules are frequently referenced in grids to provide additional UI.
+ */
+export var MajorRule;
+(function (MajorRule) {
+    MajorRule["MusicGrid"] = "music";
+    MajorRule["CompletePattern"] = "complete_pattern";
+    MajorRule["Underclued"] = "underclued";
+})(MajorRule || (MajorRule = {}));
 export var State;
 (function (State) {
     State["Error"] = "error";

package/dist/data/rules/completePatternRule.js

@@ -1,5 +1,5 @@
 import GridData from '../grid.js';
-import { State } from '../primitives.js';
+import { MajorRule, State } from '../primitives.js';
 import Rule from './rule.js';
 class CompletePatternRule extends Rule {
     /**
@@ -11,7 +11,7 @@ class CompletePatternRule extends Rule {
         super();
     }
     get id() {
-        return `complete_pattern`;
+        return MajorRule.CompletePattern;
     }
     get explanation() {
         return `Complete the pattern`;

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

@@ -21,6 +21,7 @@ export default class ForesightRule extends Rule {
     get searchVariants(): SearchVariant[];
     validateGrid(_grid: GridData): RuleState;
     get necessaryForCompletion(): boolean;
+    get isSingleton(): boolean;
     copyWith({ count, regenInterval, startFull, }: {
         count?: number;
         regenInterval?: number;

package/dist/data/rules/foresightRule.js

@@ -55,6 +55,9 @@ class ForesightRule extends Rule {
     get necessaryForCompletion() {
         return false;
     }
+    get isSingleton() {
+        return true;
+    }
     copyWith({ count, regenInterval, startFull, }) {
         return new ForesightRule(count ?? this.count, regenInterval ?? this.regenInterval, startFull ?? this.startFull);
     }

package/dist/data/rules/musicGridRule.js

@@ -1,7 +1,7 @@
 import { ConfigType } from '../config.js';
 import GridData from '../grid.js';
 import { resize } from '../dataHelper.js';
-import { Color, State } from '../primitives.js';
+import { Color, MajorRule, State } from '../primitives.js';
 import CustomIconSymbol from '../symbols/customIconSymbol.js';
 import { ControlLine, Row } from './musicControlLine.js';
 import Rule from './rule.js';
@@ -39,7 +39,7 @@ class MusicGridRule extends Rule {
         this.track = track;
     }
     get id() {
-        return `music`;
+        return MajorRule.MusicGrid;
     }
     get explanation() {
         return `*Music Grid:* Listen to the solution`;

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

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

package/dist/data/rules/offByXRule.js

@@ -63,6 +63,9 @@ class OffByXRule extends Rule {
             return undefined;
         }
     }
+    get isSingleton() {
+        return true;
+    }
     copyWith({ number }) {
         return new OffByXRule(number ?? this.number);
     }

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

@@ -9,7 +9,6 @@ export default abstract class Rule extends Instruction {
     abstract validateGrid(grid: GridData): RuleState;
     abstract get searchVariants(): SearchVariant[];
     searchVariant(): SearchVariant;
-    get visibleWhenSolving(): boolean;
     /**
      * Whether only one instance of this rule is allowed in a grid.
      */

package/dist/data/rules/rule.js

@@ -6,9 +6,6 @@ export default class Rule extends Instruction {
             rule: this,
         };
     }
-    get visibleWhenSolving() {
-        return true;
-    }
     /**
      * Whether only one instance of this rule is allowed in a grid.
      */

package/dist/data/rules/symbolsPerRegionRule.js

@@ -136,7 +136,9 @@ class SymbolsPerRegionRule extends Rule {
     static countAllSymbolsOfPosition(grid, x, y) {
         let count = 0;
         for (const symbolKind of grid.symbols.values()) {
-            if (symbolKind.some(symbol => Math.floor(symbol.x) === x && Math.floor(symbol.y) === y)) {
+            if (symbolKind.some(symbol => Math.floor(symbol.x) === x &&
+                Math.floor(symbol.y) === y &&
+                symbol.necessaryForCompletion)) {
                 count++;
             }
         }

package/dist/data/rules/undercluedRule.js

@@ -1,5 +1,5 @@
 import GridData from '../grid.js';
-import { State } from '../primitives.js';
+import { MajorRule, State } from '../primitives.js';
 import AreaNumberSymbol from '../symbols/areaNumberSymbol.js';
 import CustomTextSymbol from '../symbols/customTextSymbol.js';
 import Rule from './rule.js';
@@ -13,7 +13,7 @@ class UndercluedRule extends Rule {
         super();
     }
     get id() {
-        return `underclued`;
+        return MajorRule.Underclued;
     }
     get explanation() {
         return `*Underclued Grid:* Mark only what is definitely true`;

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

@@ -218,13 +218,13 @@ function solveNormal(input, solutionFn) {
 }
 function solveUnderclued(input) {
     let grid = input;
-    let count = 0;
+    // let count = 0;
     const possibles = array(grid.width, grid.height, () => ({
         dark: false,
         light: false,
     }));
     function search(x, y, tile, color) {
-        count++;
+        // count++;
         // console.log(`Trying (${x}, ${y}) with ${color}`);
         const newGrid = grid.setTile(x, y, tile.withColor(color));
         // Solve
@@ -263,7 +263,7 @@ function solveUnderclued(input) {
                 grid = grid.setTile(x, y, tile.withColor(Color.Light));
         }
     }
-    console.log(`Solve count: ${count}`);
+    // console.log(`Solve count: ${count}`);
     return grid;
 }
 function solve(grid, solutionFn) {
@@ -278,16 +278,15 @@ function solve(grid, solutionFn) {
 }
 onmessage = e => {
     const grid = Serializer.parseGrid(e.data);
-    console.time('Solve time');
+    // console.time('Solve time');
     let count = 0;
     solve(grid, solution => {
-        if (count === 0)
-            console.timeLog('Solve time', 'First solution');
+        // if (count === 0) console.timeLog('Solve time', 'First solution');
         postMessage(Serializer.stringifyGrid(solution));
         count += 1;
         return count < 2;
     });
-    console.timeEnd('Solve time');
+    // console.timeEnd('Solve time');
     postMessage(null);
 };
 // make typescript happy

package/dist/data/solver/backtrack/rules/banPattern.d.ts

@@ -4,6 +4,6 @@ import BTModule, { BTGridData, CheckResult } from '../data.js';
 export default class BanPatternBTModule extends BTModule {
     instr: BanPatternRule;
     constructor(instr: BanPatternRule);
-    checkGlobal(_: BTGridData): CheckResult | false;
+    checkGlobal(grid: BTGridData): CheckResult | false;
     checkLocal(grid: BTGridData, positions: Position[]): CheckResult | false;
 }

package/dist/data/solver/backtrack/rules/banPattern.js

@@ -10,8 +10,24 @@ export default class BanPatternBTModule extends BTModule {
         });
         this.instr = instr;
     }
-    checkGlobal(_) {
-        // TODO: Impl this properly
+    checkGlobal(grid) {
+        for (const pattern of this.instr.cache) {
+            for (let y = 0; y <= grid.height - pattern.height; y++) {
+                for (let x = 0; x <= grid.width - pattern.width; x++) {
+                    let match = true;
+                    for (const tile of pattern.elements) {
+                        const t = grid.getTile(x + tile.x, y + tile.y);
+                        if (t !== colorToBTTile(tile.color)) {
+                            match = false;
+                            break;
+                        }
+                    }
+                    if (match) {
+                        return false;
+                    }
+                }
+            }
+        }
         return { tilesNeedCheck: null, ratings: null };
     }
     checkLocal(grid, positions) {

package/dist/data/solver/backtrack/symbols/dart.d.ts

@@ -2,7 +2,6 @@ import DartSymbol from '../../../symbols/dartSymbol.js';
 import BTModule, { BTGridData, CheckResult } from '../data.js';
 export default class DartBTModule extends BTModule {
     instr: DartSymbol;
-    private cachedCheckResult?;
     constructor(instr: DartSymbol);
     checkGlobal(grid: BTGridData): CheckResult | false;
     private buildCheckAndRating;

package/dist/data/solver/backtrack/symbols/dart.js

@@ -9,12 +9,6 @@ export default class DartBTModule extends BTModule {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "cachedCheckResult", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.instr = instr;
     }
     checkGlobal(grid) {
@@ -38,9 +32,7 @@ export default class DartBTModule extends BTModule {
         }
         if (completed + empty < this.instr.number)
             return false;
-        if (!this.cachedCheckResult)
-            this.cachedCheckResult = this.buildCheckAndRating(grid);
-        return this.cachedCheckResult;
+        return this.buildCheckAndRating(grid);
     }
     buildCheckAndRating(grid) {
         const tilesNeedCheck = IntArray2D.create(grid.width, grid.height);

package/dist/data/solver/underclued/undercluedSolver.js

@@ -26,14 +26,14 @@ export default class UndercluedSolver extends Solver {
             const solved = await new Promise(resolve => {
                 worker.addEventListener('message', e => {
                     const solution = Serializer.parseGrid(e.data);
-                    console.timeEnd('Solve time');
+                    // console.timeEnd('Solve time');
                     if (solution.resetTiles().equals(solution))
                         resolve(null);
                     else
                         resolve(solution);
                 });
                 worker.postMessage(Serializer.stringifyGrid(grid));
-                console.time('Solve time');
+                // console.time('Solve time');
             });
             yield solved;
             if (solved) {

package/dist/data/solver/underclued/undercluedWorker.js

@@ -70,18 +70,20 @@ function computeSolution(initialGrid) {
     let anyNewGrid;
     while (assumptions.length > 0 || lastValidGrid.length === 0) {
         [currentGrid, assumptions, anyNewGrid] = getValidGrid(currentGrid, assumptions, canAssump);
-        console.log(currentGrid.tiles
-            .map(row => row
-            .map(t => {
-            const color = t.color === Color.Light ? 'w' : 'b';
-            if (t.color === Color.Gray)
-                return 'n';
-            if (!t.exists)
-                return '.';
-            return t.fixed ? color.toUpperCase() : color;
-        })
-            .join(''))
-            .join('\n'));
+        // console.log(
+        //   currentGrid.tiles
+        //     .map(row =>
+        //       row
+        //         .map(t => {
+        //           const color = t.color === Color.Light ? 'w' : 'b';
+        //           if (t.color === Color.Gray) return 'n';
+        //           if (!t.exists) return '.';
+        //           return t.fixed ? color.toUpperCase() : color;
+        //         })
+        //         .join('')
+        //     )
+        //     .join('\n')
+        // );
         if (!anyNewGrid) {
             break;
         }
@@ -105,18 +107,20 @@ function computeSolution(initialGrid) {
         const coords = posToCoords(i, solutionGrid.width);
         solutionGrid = solutionGrid.setTile(coords[0], coords[1], tile => tile.withColor(color));
     });
-    console.log(solutionGrid.tiles
-        .map(row => row
-        .map(t => {
-        const color = t.color === Color.Light ? 'w' : 'b';
-        if (t.color === Color.Gray)
-            return 'n';
-        if (!t.exists)
-            return '.';
-        return t.fixed ? color.toUpperCase() : color;
-    })
-        .join(''))
-        .join('\n'));
+    // console.log(
+    //   solutionGrid.tiles
+    //     .map(row =>
+    //       row
+    //         .map(t => {
+    //           const color = t.color === Color.Light ? 'w' : 'b';
+    //           if (t.color === Color.Gray) return 'n';
+    //           if (!t.exists) return '.';
+    //           return t.fixed ? color.toUpperCase() : color;
+    //         })
+    //         .join('')
+    //     )
+    //     .join('\n')
+    // );
     return solutionGrid;
 }
 onmessage = e => {

package/dist/data/symbols/hiddenSymbol.d.ts

@@ -0,0 +1,36 @@
+import { AnyConfig } from '../config.js';
+import { SymbolDisplayHandler } from '../events/onSymbolDisplay.js';
+import GridData from '../grid.js';
+import { Color, State } from '../primitives.js';
+import Symbol from './symbol.js';
+export default class HiddenSymbol extends Symbol implements SymbolDisplayHandler {
+    readonly x: number;
+    readonly y: number;
+    readonly color: Color;
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    /**
+     * **Hidden Symbols: color cells correctly to reveal more clues**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param color - The target color of the cell.
+     */
+    constructor(x: number, y: number, color: Color);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get necessaryForCompletion(): boolean;
+    get visibleWhenSolving(): boolean;
+    get sortOrder(): number;
+    validateSymbol(grid: GridData): State;
+    onSymbolDisplay(grid: GridData, symbol: Symbol, editing: boolean): boolean;
+    copyWith({ x, y, color, }: {
+        x?: number;
+        y?: number;
+        color?: Color;
+    }): this;
+    withColor(color: Color): this;
+}
+export declare const instance: HiddenSymbol;