@logic-pad/core 0.1.0

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

@@ -0,0 +1,29 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { RuleState } from '../primitives';
+import { Shape } from '../shapes';
+import Rule, { SearchVariant } from './rule';
+export default class BanPatternRule extends Rule {
+    private static readonly EXAMPLE_GRID;
+    private static readonly CONFIGS;
+    private static readonly SEARCH_VARIANTS;
+    readonly pattern: GridData;
+    readonly cache: Shape[];
+    /**
+     * **Don't make this pattern**
+     *
+     * @param pattern - GridData representing the banned pattern. Only non-gray tiles are considered.
+     */
+    constructor(pattern: GridData);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ pattern }: {
+        pattern?: GridData;
+    }): this;
+    withPattern(pattern: GridData): this;
+}
+export declare const instance: BanPatternRule;

package/dist/data/rules/banPatternRule.js

@@ -0,0 +1,133 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { array } from '../dataHelper';
+import { Color, State } from '../primitives';
+import { getShapeVariants, tilesToShape } from '../shapes';
+import Rule from './rule';
+class BanPatternRule extends Rule {
+    /**
+     * **Don't make this pattern**
+     *
+     * @param pattern - GridData representing the banned pattern. Only non-gray tiles are considered.
+     */
+    constructor(pattern) {
+        super();
+        Object.defineProperty(this, "pattern", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.pattern = pattern
+            // unlock all tiles
+            .withTiles(tiles => tiles.map(row => row.map(t => t.withFixed(false))))
+            // strip all symbols and rules
+            .withRules([])
+            .withSymbols(new Map());
+        this.cache = getShapeVariants(tilesToShape(this.pattern.tiles));
+    }
+    get id() {
+        return `ban_pattern`;
+    }
+    get explanation() {
+        return `Don't make this pattern`;
+    }
+    get configs() {
+        return BanPatternRule.CONFIGS;
+    }
+    createExampleGrid() {
+        let minX = Number.POSITIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY;
+        let maxY = Number.NEGATIVE_INFINITY;
+        this.pattern.forEach((tile, x, y) => {
+            if (tile.color !== Color.Gray && tile.exists) {
+                minX = Math.min(minX, x);
+                minY = Math.min(minY, y);
+                maxX = Math.max(maxX, x);
+                maxY = Math.max(maxY, y);
+            }
+        });
+        const width = maxX - minX + 1;
+        const height = maxY - minY + 1;
+        const tiles = array(width, height, (x, y) => {
+            const tile = this.pattern.getTile(x + minX, y + minY);
+            if (!tile.exists || tile.color !== Color.Gray)
+                return tile;
+            return tile.withExists(false);
+        });
+        return new GridData(width, height, tiles);
+    }
+    get searchVariants() {
+        return BanPatternRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        for (const pattern of this.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.exists || t.color !== tile.color) {
+                            match = false;
+                            break;
+                        }
+                    }
+                    if (match) {
+                        return {
+                            state: State.Error,
+                            positions: pattern.elements.map(tile => ({
+                                x: x + tile.x,
+                                y: y + tile.y,
+                            })),
+                        };
+                    }
+                }
+            }
+        }
+        return { state: grid.isComplete() ? State.Satisfied : State.Incomplete };
+    }
+    copyWith({ pattern }) {
+        return new BanPatternRule(pattern ?? this.pattern);
+    }
+    withPattern(pattern) {
+        return this.copyWith({ pattern });
+    }
+}
+Object.defineProperty(BanPatternRule, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['nnnnn', 'nnnnn', 'wwwwn', 'nnnnn', 'nnnnn']))
+});
+Object.defineProperty(BanPatternRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Tile,
+            default: BanPatternRule.EXAMPLE_GRID,
+            resizable: true,
+            field: 'pattern',
+            description: 'Pattern',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(BanPatternRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new BanPatternRule(BanPatternRule.EXAMPLE_GRID).searchVariant(),
+    ]
+});
+export default BanPatternRule;
+export const instance = new BanPatternRule(GridData.create([]));

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

@@ -0,0 +1,32 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { Color, RuleState } from '../primitives';
+import Rule, { SearchVariant } from './rule';
+export default class CellCountRule extends Rule {
+    readonly color: Color;
+    readonly count: number;
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **There are <count> <color> cells in total**
+     *
+     * @param color - The color of the cells to count.
+     * @param count - The total number of cells of the given color.
+     */
+    constructor(color: Color, count: number);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ color, count }: {
+        color?: Color;
+        count?: number;
+    }): this;
+    withColor(color: Color): this;
+    withCount(count: number): this;
+}
+export declare const instance: CellCountRule;

package/dist/data/rules/cellCountRule.js

@@ -0,0 +1,166 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { Color, State } from '../primitives';
+import AreaNumberSymbol from '../symbols/areaNumberSymbol';
+import Rule from './rule';
+class CellCountRule extends Rule {
+    /**
+     * **There are <count> <color> cells in total**
+     *
+     * @param color - The color of the cells to count.
+     * @param count - The total number of cells of the given color.
+     */
+    constructor(color, count) {
+        super();
+        Object.defineProperty(this, "color", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: color
+        });
+        Object.defineProperty(this, "count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: count
+        });
+        this.color = color;
+        this.count = count;
+    }
+    get id() {
+        return `cell_count`;
+    }
+    get explanation() {
+        return `There ${this.count === 1 ? 'is' : 'are'} ${this.count} ${this.color} cell${this.count === 1 ? '' : 's'} *in total*`;
+    }
+    get configs() {
+        return CellCountRule.CONFIGS;
+    }
+    createExampleGrid() {
+        if (this.count < CellCountRule.EXAMPLE_GRID_LIGHT.length) {
+            if (this.color === Color.Light) {
+                return CellCountRule.EXAMPLE_GRID_LIGHT[this.count];
+            }
+            else {
+                return CellCountRule.EXAMPLE_GRID_DARK[this.count];
+            }
+        }
+        else {
+            const grid = this.color === Color.Light
+                ? GridData.create(['wbbbb', 'wwbbb', 'wwwbb', 'wwwwb'])
+                : GridData.create(['bwwww', 'bbwww', 'bbbww', 'bbbbw']);
+            return grid.addSymbol(new AreaNumberSymbol(1, 2, this.count));
+        }
+    }
+    get searchVariants() {
+        return CellCountRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        let colored = 0;
+        let possible = 0;
+        grid.forEach(tile => {
+            if (!tile.exists)
+                return;
+            if (tile.color === this.color)
+                colored++;
+            if (tile.color === Color.Gray)
+                possible++;
+        });
+        if (colored > this.count || colored + possible < this.count) {
+            return { state: State.Error, positions: [] };
+        }
+        else if (colored === this.count && possible === 0) {
+            return { state: State.Satisfied };
+        }
+        else {
+            return { state: State.Incomplete };
+        }
+    }
+    copyWith({ color, count }) {
+        return new CellCountRule(color ?? this.color, count ?? this.count);
+    }
+    withColor(color) {
+        return this.copyWith({ color });
+    }
+    withCount(count) {
+        return this.copyWith({ count });
+    }
+}
+Object.defineProperty(CellCountRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Color,
+            default: Color.Light,
+            allowGray: false,
+            field: 'color',
+            description: 'Color',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Number,
+            default: 10,
+            min: 0,
+            field: 'count',
+            description: 'Count',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(CellCountRule, "EXAMPLE_GRID_LIGHT", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        GridData.create(['bbbbb', 'bbbbb', 'bbbbb', 'bbbbb']),
+        GridData.create(['bbbbb', 'bbbbb', 'bwbbb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 1),
+        ]),
+        GridData.create(['bbbbb', 'bbbbb', 'bwwbb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 2),
+        ]),
+        GridData.create(['bbbbb', 'bwbbb', 'bwwbb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 3),
+        ]),
+        GridData.create(['bbbbb', 'bwwbb', 'bwwbb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 4),
+        ]),
+        GridData.create(['bbbbb', 'bwwbb', 'bwwwb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 5),
+        ]),
+        GridData.create(['bbbbb', 'bwwwb', 'bwwwb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 6),
+        ]),
+        GridData.create(['bbbbb', 'bbbbb', 'wwwbb', 'wwwwb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 7),
+        ]),
+        GridData.create(['bbbbb', 'wbbbb', 'wwwbb', 'wwwwb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 8),
+        ]),
+        GridData.create(['bbbbb', 'wwbbb', 'wwwbb', 'wwwwb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 9),
+        ]),
+        GridData.create(['wbbbb', 'wwbbb', 'wwwbb', 'wwwwb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 10),
+        ]),
+    ])
+});
+Object.defineProperty(CellCountRule, "EXAMPLE_GRID_DARK", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(CellCountRule.EXAMPLE_GRID_LIGHT.map(grid => grid.withTiles(tiles => tiles.map(row => row.map(tile => tile.withColor(tile.color === Color.Dark ? Color.Light : Color.Dark))))))
+});
+Object.defineProperty(CellCountRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new CellCountRule(Color.Light, 10).searchVariant(),
+        new CellCountRule(Color.Dark, 10).searchVariant(),
+    ]
+});
+export default CellCountRule;
+export const instance = new CellCountRule(Color.Dark, 10);

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

@@ -0,0 +1,22 @@
+import GridData from '../grid';
+import { RuleState } from '../primitives';
+import Rule, { SearchVariant } from './rule';
+export default class CompletePatternRule extends Rule {
+    private static readonly EXAMPLE_GRID;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Complete the pattern**
+     *
+     * This rule validates answers based on the provided solution.
+     */
+    constructor();
+    get id(): string;
+    get explanation(): string;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(_grid: GridData): RuleState;
+    copyWith(_: object): this;
+    get validateWithSolution(): boolean;
+    get isSingleton(): boolean;
+}
+export declare const instance: CompletePatternRule;

package/dist/data/rules/completePatternRule.js

@@ -0,0 +1,53 @@
+import GridData from '../grid';
+import { State } from '../primitives';
+import Rule from './rule';
+class CompletePatternRule extends Rule {
+    /**
+     * **Complete the pattern**
+     *
+     * This rule validates answers based on the provided solution.
+     */
+    constructor() {
+        super();
+    }
+    get id() {
+        return `complete_pattern`;
+    }
+    get explanation() {
+        return `Complete the pattern`;
+    }
+    createExampleGrid() {
+        return CompletePatternRule.EXAMPLE_GRID;
+    }
+    get searchVariants() {
+        return CompletePatternRule.SEARCH_VARIANTS;
+    }
+    validateGrid(_grid) {
+        return { state: State.Incomplete };
+    }
+    copyWith(_) {
+        return new CompletePatternRule();
+    }
+    get validateWithSolution() {
+        return true;
+    }
+    get isSingleton() {
+        return true;
+    }
+}
+Object.defineProperty(CompletePatternRule, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['wbwbw', 'bwbwb', 'wbwbw', 'bwbwb']))
+});
+Object.defineProperty(CompletePatternRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new CompletePatternRule().searchVariant(),
+    ]
+});
+export default CompletePatternRule;
+export const instance = new CompletePatternRule();

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

@@ -0,0 +1,28 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { Color, RuleState } from '../primitives';
+import Rule, { SearchVariant } from './rule';
+export default class ConnectAllRule extends Rule {
+    readonly color: Color;
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Connect all <color> cells**
+     *
+     * @param color - The color of the cells to connect.
+     */
+    constructor(color: Color);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ color }: {
+        color?: Color;
+    }): this;
+    withColor(color: Color): this;
+}
+export declare const instance: ConnectAllRule;

package/dist/data/rules/connectAllRule.js

@@ -0,0 +1,113 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { array, minBy } from '../dataHelper';
+import { Color, State } from '../primitives';
+import Rule from './rule';
+class ConnectAllRule extends Rule {
+    /**
+     * **Connect all <color> cells**
+     *
+     * @param color - The color of the cells to connect.
+     */
+    constructor(color) {
+        super();
+        Object.defineProperty(this, "color", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: color
+        });
+        this.color = color;
+    }
+    get id() {
+        return `connect_all`;
+    }
+    get explanation() {
+        return `Connect all ${this.color} cells`;
+    }
+    get configs() {
+        return ConnectAllRule.CONFIGS;
+    }
+    createExampleGrid() {
+        return this.color === Color.Light
+            ? ConnectAllRule.EXAMPLE_GRID_LIGHT
+            : ConnectAllRule.EXAMPLE_GRID_DARK;
+    }
+    get searchVariants() {
+        return ConnectAllRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        let complete = true;
+        const visited = array(grid.width, grid.height, (i, j) => !(grid.getTile(i, j).exists && grid.getTile(i, j).color === this.color));
+        const islands = [];
+        while (true) {
+            const seed = grid.find((_tile, x, y) => !visited[y][x]);
+            if (!seed)
+                break;
+            const positions = [];
+            grid.iterateArea(seed, tile => tile.color === this.color || tile.color === Color.Gray, (tile, x, y) => {
+                visited[y][x] = true;
+                if (tile.color === Color.Gray)
+                    complete = false;
+                positions.push({ x, y });
+            });
+            islands.push(positions);
+        }
+        if (islands.length > 1) {
+            return {
+                state: State.Error,
+                positions: minBy(islands, island => island.length),
+            };
+        }
+        else if (islands.length <= 1) {
+            return { state: complete ? State.Satisfied : State.Incomplete };
+        }
+        else {
+            return { state: State.Incomplete }; // not reachable but the TS is not happy
+        }
+    }
+    copyWith({ color }) {
+        return new ConnectAllRule(color ?? this.color);
+    }
+    withColor(color) {
+        return this.copyWith({ color });
+    }
+}
+Object.defineProperty(ConnectAllRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Color,
+            default: Color.Light,
+            allowGray: false,
+            field: 'color',
+            description: 'Color',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(ConnectAllRule, "EXAMPLE_GRID_LIGHT", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['bwwwb', 'bwbww', 'wwwbb', 'wbwww']))
+});
+Object.defineProperty(ConnectAllRule, "EXAMPLE_GRID_DARK", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['wbbbw', 'wbwbb', 'bbbww', 'bwbbb']))
+});
+Object.defineProperty(ConnectAllRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new ConnectAllRule(Color.Light).searchVariant(),
+        new ConnectAllRule(Color.Dark).searchVariant(),
+    ]
+});
+export default ConnectAllRule;
+export const instance = new ConnectAllRule(Color.Dark);

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

@@ -0,0 +1,32 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { RuleState } from '../primitives';
+import Rule, { SearchVariant } from './rule';
+export default class CustomRule extends Rule {
+    readonly description: string;
+    readonly grid: GridData;
+    private static readonly EXAMPLE_GRID;
+    static readonly configs: readonly AnyConfig[];
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * A custom rule with a description and thumbnail grid.
+     *
+     * This rule validates answers based on the provided solution.
+     *
+     * @param description - The description of the rule.
+     * @param grid - The thumbnail grid of the rule, preferably 5x4 in size.
+     */
+    constructor(description: string, grid: GridData);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(_grid: GridData): RuleState;
+    copyWith({ description, grid, }: {
+        description?: string;
+        grid?: GridData;
+    }): this;
+    get validateWithSolution(): boolean;
+}
+export declare const instance: CustomRule;