@logic-pad/core 0.1.0

package/dist/data/rules/symbolsPerRegionRule.js

@@ -0,0 +1,211 @@
+import Rule from './rule';
+import GridData from '../grid';
+import { ConfigType } from '../config';
+import { Color, Comparison, State } from '../primitives';
+import { array } from '../dataHelper';
+import LetterSymbol from '../symbols/letterSymbol';
+import GridConnections from '../gridConnections';
+class SymbolsPerRegionRule extends Rule {
+    /**
+     * **Exactly <count> symbols per <color> area**
+     *
+     * @param color - Color of the region affected by the rule
+     * @param count - Number of symbols to have in each region
+     * @param comparison - Comparison to use when checking the number of symbols
+     */
+    constructor(color, count, comparison = Comparison.Equal) {
+        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
+        });
+        Object.defineProperty(this, "comparison", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: comparison
+        });
+        this.color = color;
+        this.count = count;
+        this.comparison = comparison;
+    }
+    get id() {
+        return `symbols_per_region`;
+    }
+    get explanation() {
+        switch (this.comparison) {
+            case Comparison.AtLeast:
+                return `At least ${this.count} symbol${this.count === 1 ? '' : 's'} per ${this.color} area`;
+            case Comparison.AtMost:
+                return `At most ${this.count} symbol${this.count === 1 ? '' : 's'} per ${this.color} area`;
+            default:
+                return `Exactly ${this.count} symbol${this.count === 1 ? '' : 's'} per ${this.color} area`;
+        }
+    }
+    get configs() {
+        return SymbolsPerRegionRule.CONFIGS;
+    }
+    createExampleGrid() {
+        if (this.count > SymbolsPerRegionRule.SYMBOL_POSITIONS.length ||
+            this.comparison !== Comparison.Equal) {
+            let description = '';
+            switch (this.comparison) {
+                case Comparison.AtLeast:
+                    description = `≥${this.count}X`;
+                    break;
+                case Comparison.AtMost:
+                    description = `≤${this.count}X`;
+                    break;
+                default:
+                    description = `${this.count}X`;
+                    break;
+            }
+            const symbol = new LetterSymbol(1.5, 1.5, description);
+            return SymbolsPerRegionRule.EXAMPLE_GRIDS[this.color]
+                .addSymbol(symbol)
+                .withConnections(GridConnections.create(['.....', '.aa..', '.aa..', '.....']));
+        }
+        const symbols = [];
+        for (let i = 0; i < this.count; i++) {
+            const { x, y } = SymbolsPerRegionRule.SYMBOL_POSITIONS[i];
+            symbols.push(new LetterSymbol(x, y, 'X'));
+        }
+        return SymbolsPerRegionRule.EXAMPLE_GRIDS[this.color].withSymbols(symbols);
+    }
+    get searchVariants() {
+        return SymbolsPerRegionRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        const visited = array(grid.width, grid.height, (i, j) => !(grid.getTile(i, j).exists && grid.getTile(i, j).color === this.color));
+        let complete = true;
+        while (true) {
+            const seed = grid.find((_tile, x, y) => !visited[y][x]);
+            if (!seed)
+                break;
+            const completed = [];
+            const gray = [];
+            let nbSymbolsIn = 0;
+            grid.iterateArea({ x: seed.x, y: seed.y }, tile => tile.color === this.color, (_, x, y) => {
+                completed.push({ x, y });
+                visited[y][x] = true;
+                nbSymbolsIn += SymbolsPerRegionRule.countAllSymbolsOfPosition(grid, x, y);
+            });
+            if (this.comparison !== Comparison.AtLeast && nbSymbolsIn > this.count) {
+                return { state: State.Error, positions: completed };
+            }
+            let nbSymbolsOut = 0;
+            if (this.color === Color.Gray) {
+                gray.push(...completed);
+                nbSymbolsOut = nbSymbolsIn;
+            }
+            else {
+                grid.iterateArea({ x: seed.x, y: seed.y }, tile => tile.color === Color.Gray || tile.color === this.color, (_, x, y) => {
+                    gray.push({ x, y });
+                    nbSymbolsOut += SymbolsPerRegionRule.countAllSymbolsOfPosition(grid, x, y);
+                });
+            }
+            if (this.comparison !== Comparison.AtMost && nbSymbolsOut < this.count) {
+                return { state: State.Error, positions: gray };
+            }
+            if (gray.length !== completed.length) {
+                complete = false;
+            }
+        }
+        return complete ? { state: State.Satisfied } : { state: State.Incomplete };
+    }
+    copyWith({ count, color, comparison, }) {
+        return new SymbolsPerRegionRule(color ?? this.color, count ?? this.count, comparison ?? this.comparison);
+    }
+    withColor(color) {
+        return this.copyWith({ color });
+    }
+    withCount(count) {
+        return this.copyWith({ count });
+    }
+    withComparison(comparison) {
+        return this.copyWith({ comparison });
+    }
+    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)) {
+                count++;
+            }
+        }
+        return count;
+    }
+}
+Object.defineProperty(SymbolsPerRegionRule, "SYMBOL_POSITIONS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        { x: 1, y: 1 },
+        { x: 2, y: 2 },
+        { x: 2, y: 1 },
+        { x: 3, y: 1 },
+        { x: 1, y: 2 },
+    ]
+});
+Object.defineProperty(SymbolsPerRegionRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Number,
+            default: 1,
+            field: 'count',
+            description: 'Count',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Color,
+            default: Color.Light,
+            field: 'color',
+            description: 'Color',
+            configurable: true,
+            allowGray: true,
+        },
+        {
+            type: ConfigType.Comparison,
+            default: Comparison.Equal,
+            field: 'comparison',
+            description: 'Comparison',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(SymbolsPerRegionRule, "EXAMPLE_GRIDS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        [Color.Dark]: GridData.create(['wwwww', 'wbbbw', 'wbbww', 'wwwww']),
+        [Color.Light]: GridData.create(['bbbbb', 'bwwwb', 'bwwbb', 'bbbbb']),
+        [Color.Gray]: GridData.create(['bwbwb', 'wnnnw', 'bnnwb', 'wbwbw']),
+    }
+});
+Object.defineProperty(SymbolsPerRegionRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new SymbolsPerRegionRule(Color.Light, 1).searchVariant(),
+        new SymbolsPerRegionRule(Color.Dark, 1).searchVariant(),
+        new SymbolsPerRegionRule(Color.Light, 1, Comparison.AtLeast).searchVariant(),
+        new SymbolsPerRegionRule(Color.Dark, 1, Comparison.AtLeast).searchVariant(),
+        new SymbolsPerRegionRule(Color.Light, 1, Comparison.AtMost).searchVariant(),
+        new SymbolsPerRegionRule(Color.Dark, 1, Comparison.AtMost).searchVariant(),
+    ]
+});
+export default SymbolsPerRegionRule;
+export const instance = new SymbolsPerRegionRule(Color.Dark, 1);

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

@@ -0,0 +1,22 @@
+import GridData from '../grid';
+import { RuleState } from '../primitives';
+import Rule, { SearchVariant } from './rule';
+export default class UndercluedRule extends Rule {
+    private static readonly EXAMPLE_GRID;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Underclued Grid: Mark only what is definitely true**
+     *
+     * 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: UndercluedRule;

package/dist/data/rules/undercluedRule.js

@@ -0,0 +1,60 @@
+import GridData from '../grid';
+import { State } from '../primitives';
+import AreaNumberSymbol from '../symbols/areaNumberSymbol';
+import CustomTextSymbol from '../symbols/customTextSymbol';
+import Rule from './rule';
+class UndercluedRule extends Rule {
+    /**
+     * **Underclued Grid: Mark only what is definitely true**
+     *
+     * This rule validates answers based on the provided solution.
+     */
+    constructor() {
+        super();
+    }
+    get id() {
+        return `underclued`;
+    }
+    get explanation() {
+        return `*Underclued Grid:* Mark only what is definitely true`;
+    }
+    createExampleGrid() {
+        return UndercluedRule.EXAMPLE_GRID;
+    }
+    get searchVariants() {
+        return UndercluedRule.SEARCH_VARIANTS;
+    }
+    validateGrid(_grid) {
+        return { state: State.Incomplete };
+    }
+    copyWith(_) {
+        return new UndercluedRule();
+    }
+    get validateWithSolution() {
+        return true;
+    }
+    get isSingleton() {
+        return true;
+    }
+}
+Object.defineProperty(UndercluedRule, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['nbnnn', 'bwbnn', 'nbnnn', 'wwwnn'])
+        .addSymbol(new AreaNumberSymbol(1, 1, 1))
+        .addSymbol(new AreaNumberSymbol(0, 3, 4))
+        .addSymbol(new CustomTextSymbol('', GridData.create([]), 0, 2, '?'))
+        .addSymbol(new CustomTextSymbol('', GridData.create([]), 2, 2, '?'))
+        .addSymbol(new CustomTextSymbol('', GridData.create([]), 3, 3, '?')))
+});
+Object.defineProperty(UndercluedRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new UndercluedRule().searchVariant(),
+    ]
+});
+export default UndercluedRule;
+export const instance = new UndercluedRule();

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

@@ -0,0 +1,27 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { Color, RuleState } from '../primitives';
+import RegionShapeRule from './regionShapeRule';
+import { SearchVariant } from './rule';
+export default class UniqueShapeRule extends RegionShapeRule {
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **No two <color> areas have the same shape and size**
+     *
+     * @param color - The color of the regions to compare.
+     */
+    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;
+}
+export declare const instance: UniqueShapeRule;

package/dist/data/rules/uniqueShapeRule.js

@@ -0,0 +1,85 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { Color, State } from '../primitives';
+import RegionShapeRule from './regionShapeRule';
+class UniqueShapeRule extends RegionShapeRule {
+    /**
+     * **No two <color> areas have the same shape and size**
+     *
+     * @param color - The color of the regions to compare.
+     */
+    constructor(color) {
+        super(color);
+    }
+    get id() {
+        return `unique_shape`;
+    }
+    get explanation() {
+        return `No two ${this.color} areas have the same shape and size`;
+    }
+    get configs() {
+        return UniqueShapeRule.CONFIGS;
+    }
+    createExampleGrid() {
+        return this.color === Color.Light
+            ? UniqueShapeRule.EXAMPLE_GRID_LIGHT
+            : UniqueShapeRule.EXAMPLE_GRID_DARK;
+    }
+    get searchVariants() {
+        return UniqueShapeRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        const { regions, complete } = this.getShapeRegions(grid);
+        const errorRegion = regions.find(r => r.count > 1);
+        if (errorRegion) {
+            return {
+                state: State.Error,
+                positions: errorRegion.positions,
+            };
+        }
+        else {
+            return { state: complete ? State.Satisfied : State.Incomplete };
+        }
+    }
+    copyWith({ color }) {
+        return new UniqueShapeRule(color ?? this.color);
+    }
+}
+Object.defineProperty(UniqueShapeRule, "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(UniqueShapeRule, "EXAMPLE_GRID_LIGHT", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['bwbww', 'wwbww', 'wbwbb', 'bwwbw']))
+});
+Object.defineProperty(UniqueShapeRule, "EXAMPLE_GRID_DARK", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['wbwbb', 'bbwbb', 'bwbww', 'wbbwb']))
+});
+Object.defineProperty(UniqueShapeRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new UniqueShapeRule(Color.Light).searchVariant(),
+        new UniqueShapeRule(Color.Dark).searchVariant(),
+    ]
+});
+export default UniqueShapeRule;
+export const instance = new UniqueShapeRule(Color.Dark);

package/dist/data/serializer/allSerializers.d.ts

@@ -0,0 +1,30 @@
+import GridData from '../grid';
+import { Puzzle } from '../puzzle';
+import Rule from '../rules/rule';
+import Symbol from '../symbols/symbol';
+/**
+ * The master serializer for puzzles.
+ *
+ * It uses the default serializer when stringifying puzzles, and select the correct deserializer when parsing puzzles.
+ */
+declare const Serializer: {
+    stringifyRule(rule: Rule): string;
+    parseRule(input: string): Rule;
+    stringifySymbol(symbol: Symbol): string;
+    parseSymbol(input: string): Symbol;
+    stringifyGrid(grid: GridData): string;
+    parseGrid(input: string): GridData;
+    /**
+     * Convert a puzzle to a string.
+     * @param puzzle The puzzle to convert.
+     * @returns The string representation of the puzzle.
+     */
+    stringifyPuzzle(puzzle: Puzzle): string;
+    /**
+     * Parse a puzzle from a string.
+     * @param input The string to parse.
+     * @returns The parsed puzzle.
+     */
+    parsePuzzle(input: string): Puzzle;
+};
+export { Serializer };

package/dist/data/serializer/allSerializers.js

@@ -0,0 +1,64 @@
+import SerializerV0 from './serializer_v0';
+const allSerializers = new Map();
+function register(prototype) {
+    allSerializers.set(prototype.version, prototype);
+}
+let defaultSerializer;
+register((defaultSerializer = new SerializerV0()));
+function selectSerializer(input) {
+    const match = input.match(/^(\d+)_/);
+    const version = match ? parseInt(match[1]) : 0;
+    const serializer = allSerializers.get(version);
+    if (serializer) {
+        return { serializer, data: input.slice(match?.[0].length ?? 0) };
+    }
+    else {
+        throw new Error(`Unknown serializer version for ${input}`);
+    }
+}
+/**
+ * The master serializer for puzzles.
+ *
+ * It uses the default serializer when stringifying puzzles, and select the correct deserializer when parsing puzzles.
+ */
+const Serializer = {
+    stringifyRule(rule) {
+        return `${defaultSerializer.version}_${defaultSerializer.stringifyRule(rule)}`;
+    },
+    parseRule(input) {
+        const { serializer, data } = selectSerializer(input);
+        return serializer.parseRule(data);
+    },
+    stringifySymbol(symbol) {
+        return `${defaultSerializer.version}_${defaultSerializer.stringifySymbol(symbol)}`;
+    },
+    parseSymbol(input) {
+        const { serializer, data } = selectSerializer(input);
+        return serializer.parseSymbol(data);
+    },
+    stringifyGrid(grid) {
+        return `${defaultSerializer.version}_${defaultSerializer.stringifyGrid(grid)}`;
+    },
+    parseGrid(input) {
+        const { serializer, data } = selectSerializer(input);
+        return serializer.parseGrid(data);
+    },
+    /**
+     * Convert a puzzle to a string.
+     * @param puzzle The puzzle to convert.
+     * @returns The string representation of the puzzle.
+     */
+    stringifyPuzzle(puzzle) {
+        return `${defaultSerializer.version}_${defaultSerializer.stringifyPuzzle(puzzle)}`;
+    },
+    /**
+     * Parse a puzzle from a string.
+     * @param input The string to parse.
+     * @returns The parsed puzzle.
+     */
+    parsePuzzle(input) {
+        const { serializer, data } = selectSerializer(input);
+        return serializer.parsePuzzle(data);
+    },
+};
+export { Serializer };

package/dist/data/serializer/compressor/allCompressors.d.ts

@@ -0,0 +1,14 @@
+import CompressorBase from './compressorBase';
+/**
+ * The master compressor for compressing and decompressing strings.
+ *
+ * It compares the output of multiple compressors and selects the one with the smallest size (slow),
+ * and selects the correct decompressor when decompressing.
+ */
+declare class MasterCompressor extends CompressorBase {
+    get id(): string;
+    compress(input: string): Promise<string>;
+    decompress(input: string): Promise<string>;
+}
+declare const Compressor: MasterCompressor;
+export { Compressor };

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

@@ -0,0 +1,43 @@
+import { minBy } from '../../dataHelper';
+import CompressorBase from './compressorBase';
+import GzipCompressor from './gzipCompressor';
+import DeflateCompressor from './deflateCompressor';
+const allCompressors = new Map();
+function register(prototype) {
+    allCompressors.set(prototype.id, prototype);
+}
+const activeCompressors = [new DeflateCompressor()];
+activeCompressors.forEach(register);
+register(new GzipCompressor());
+/**
+ * The master compressor for compressing and decompressing strings.
+ *
+ * It compares the output of multiple compressors and selects the one with the smallest size (slow),
+ * and selects the correct decompressor when decompressing.
+ */
+class MasterCompressor extends CompressorBase {
+    get id() {
+        return `compressor`;
+    }
+    async compress(input) {
+        const compressed = await Promise.all(activeCompressors.map(async (compressor) => `${compressor.id}_${await compressor.compress(input)}`));
+        return minBy(compressed, c => encodeURIComponent(c).length) ?? '';
+    }
+    async decompress(input) {
+        const match = input.match(/^([^_]+?)_(.+)$/);
+        let compressorId;
+        let compressed;
+        if (match) {
+            compressorId = match[1];
+            compressed = match[2];
+        }
+        else {
+            compressorId = 'gzip';
+            compressed = input;
+        }
+        const compressor = allCompressors.get(compressorId);
+        return compressor.decompress(compressed);
+    }
+}
+const Compressor = new MasterCompressor();
+export { Compressor };

package/dist/data/serializer/compressor/compressorBase.d.ts

@@ -0,0 +1,16 @@
+export default abstract class CompressorBase {
+    /**
+     * The unique identifier for this compressor.
+     */
+    abstract get id(): string;
+    /**
+     * Compress the given input string into URL-safe compressed string.
+     * @param input The input string to compress.
+     */
+    abstract compress(input: string): Promise<string>;
+    /**
+     * Decompress the given compressed string back into the original string.
+     * @param input The compressed string to decompress.
+     */
+    abstract decompress(input: string): Promise<string>;
+}

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

@@ -0,0 +1,2 @@
+export default class CompressorBase {
+}

package/dist/data/serializer/compressor/deflateCompressor.d.ts

@@ -0,0 +1,7 @@
+import StreamCompressor from './streamCompressor';
+export default class DeflateCompressor extends StreamCompressor {
+    get id(): string;
+    protected get algorithm(): CompressionFormat;
+    compress(input: string): Promise<string>;
+    decompress(input: string): Promise<string>;
+}

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

@@ -0,0 +1,17 @@
+import StreamCompressor from './streamCompressor';
+export default class DeflateCompressor extends StreamCompressor {
+    get id() {
+        return `dfl`;
+    }
+    get algorithm() {
+        return 'deflate-raw';
+    }
+    async compress(input) {
+        const result = await super.compress(input);
+        return result.replace(/\+/g, '-').replace(/\//g, '_');
+    }
+    async decompress(input) {
+        input = input.replace(/-/g, '+').replace(/_/g, '/');
+        return await super.decompress(input);
+    }
+}

package/dist/data/serializer/compressor/gzipCompressor.d.ts

@@ -0,0 +1,5 @@
+import StreamCompressor from './streamCompressor';
+export default class GzipCompressor extends StreamCompressor {
+    get id(): string;
+    protected get algorithm(): CompressionFormat;
+}

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

@@ -0,0 +1,9 @@
+import StreamCompressor from './streamCompressor';
+export default class GzipCompressor extends StreamCompressor {
+    get id() {
+        return `gzip`;
+    }
+    get algorithm() {
+        return 'gzip';
+    }
+}

package/dist/data/serializer/compressor/streamCompressor.d.ts

@@ -0,0 +1,6 @@
+import CompressorBase from './compressorBase';
+export default abstract class StreamCompressor extends CompressorBase {
+    protected abstract get algorithm(): CompressionFormat;
+    compress(input: string): Promise<string>;
+    decompress(input: string): Promise<string>;
+}

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

@@ -0,0 +1,36 @@
+import CompressorBase from './compressorBase';
+function ensureCompressionStream() {
+    if (!globalThis.CompressionStream || !globalThis.DecompressionStream) {
+        console.log('CompressionStream not supported. Loading polyfill.');
+        return import('../../../polyfill/streamPolyfill');
+    }
+    return Promise.resolve();
+}
+export default class StreamCompressor extends CompressorBase {
+    /* eslint-disable @typescript-eslint/no-floating-promises */
+    async compress(input) {
+        await ensureCompressionStream();
+        const blobToBase64 = (blob) => new Promise(resolve => {
+            const reader = new FileReader();
+            reader.onloadend = () => resolve(reader.result.split(',')[1]);
+            reader.readAsDataURL(blob);
+        });
+        const byteArray = new TextEncoder().encode(input);
+        const cs = new CompressionStream(this.algorithm);
+        const writer = cs.writable.getWriter();
+        writer.write(byteArray);
+        writer.close();
+        return new Response(cs.readable).blob().then(blobToBase64);
+    }
+    async decompress(input) {
+        await ensureCompressionStream();
+        const bytes = Uint8Array.from(atob(input), c => c.charCodeAt(0));
+        const cs = new DecompressionStream(this.algorithm);
+        const writer = cs.writable.getWriter();
+        writer.write(bytes);
+        writer.close();
+        return new Response(cs.readable).arrayBuffer().then(function (arrayBuffer) {
+            return new TextDecoder().decode(arrayBuffer);
+        });
+    }
+}