@logic-pad/core 0.1.0

package/dist/data/gridConnections.d.ts

@@ -0,0 +1,38 @@
+import { Edge, Position } from './primitives';
+import TileConnections from './tileConnections';
+export default class GridConnections {
+    readonly edges: readonly Edge[];
+    constructor(edges?: readonly Edge[]);
+    addEdge(edge: Edge): GridConnections;
+    removeEdge(edge: Edge): GridConnections;
+    isConnected(edge: Edge): boolean;
+    getConnectionsAt({ x, y }: Position): readonly Edge[];
+    getForTile({ x, y }: Position): TileConnections;
+    getConnectedTiles({ x, y }: Position): readonly Position[];
+    /**
+     * Create new GridConnections from a string array.
+     *
+     * - Use `.` for cells that don't connect to anything.
+     * - Use any other character for cells that connect to the same character.
+     *
+     * @param array - The string array to create the connections from.
+     * @returns The created connections. You can apply this to a GridData object using GridData.withConnections.
+     */
+    static create(array: string[]): GridConnections;
+    /**
+     * Check if two GridConnections objects are equal.
+     * @param other The other GridConnections object to compare to.
+     * @returns Whether the two objects are equal.
+     */
+    equals(other: GridConnections): boolean;
+    /**
+     * Deduplicate an array of edges.
+     * @param edges The array of edges to deduplicate.
+     * @returns The deduplicated array of edges.
+     */
+    static deduplicateEdges(edges: readonly Edge[]): readonly Edge[];
+    insertColumn(index: number): GridConnections;
+    insertRow(index: number): GridConnections;
+    removeColumn(index: number): GridConnections;
+    removeRow(index: number): GridConnections;
+}

package/dist/data/gridConnections.js

@@ -0,0 +1,328 @@
+import TileConnections from './tileConnections';
+function isSameEdge(a, b) {
+    return ((a.x1 === b.x1 && a.y1 === b.y1 && a.x2 === b.x2 && a.y2 === b.y2) ||
+        (a.x1 === b.x2 && a.y1 === b.y2 && a.x2 === b.x1 && a.y2 === b.y1));
+}
+export default class GridConnections {
+    constructor(edges) {
+        Object.defineProperty(this, "edges", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.edges = GridConnections.deduplicateEdges(edges ?? []);
+    }
+    addEdge(edge) {
+        if (this.edges.some(e => isSameEdge(e, edge))) {
+            return this;
+        }
+        return new GridConnections([...this.edges, edge]);
+    }
+    removeEdge(edge) {
+        return new GridConnections(this.edges.filter(e => !isSameEdge(e, edge)));
+    }
+    isConnected(edge) {
+        if (edge.x1 === edge.x2 && edge.y1 === edge.y2)
+            return true;
+        return this.edges.some(e => isSameEdge(e, edge));
+    }
+    getConnectionsAt({ x, y }) {
+        return this.edges.filter(e => (e.x1 === x && e.y1 === y) || (e.x2 === x && e.y2 === y));
+    }
+    getForTile({ x, y }) {
+        const result = new TileConnections();
+        // Get all connections within 2 steps of the tile
+        const edges = this.getConnectionsAt({ x, y });
+        const edges2 = [
+            ...edges,
+            ...edges.flatMap(edge => {
+                if (edge.x1 === x && edge.y1 === y) {
+                    return this.getConnectionsAt({ x: edge.x2, y: edge.y2 });
+                }
+                else {
+                    return this.getConnectionsAt({ x: edge.x1, y: edge.y1 });
+                }
+            }),
+        ];
+        // Fill in the connections
+        for (const edge of edges2) {
+            if (edge.x1 !== x || edge.y1 !== y) {
+                const offsetX = edge.x1 - x;
+                const offsetY = edge.y1 - y;
+                if (offsetX >= -1 && offsetX <= 1 && offsetY >= -1 && offsetY <= 1) {
+                    result[offsetY][offsetX] = true;
+                }
+            }
+            if (edge.x2 !== x || edge.y2 !== y) {
+                const offsetX = edge.x2 - x;
+                const offsetY = edge.y2 - y;
+                if (offsetX >= -1 && offsetX <= 1 && offsetY >= -1 && offsetY <= 1) {
+                    result[offsetY][offsetX] = true;
+                }
+            }
+        }
+        // Fix the center and corner connections
+        result.center = true;
+        if (!result.top || !result.left) {
+            result.topLeft = false;
+        }
+        if (!result.top || !result.right) {
+            result.topRight = false;
+        }
+        if (!result.bottom || !result.left) {
+            result.bottomLeft = false;
+        }
+        if (!result.bottom || !result.right) {
+            result.bottomRight = false;
+        }
+        return result;
+    }
+    getConnectedTiles({ x, y }) {
+        const result = [];
+        const visited = new Set();
+        const queue = [{ x, y }];
+        while (queue.length > 0) {
+            const current = queue.pop();
+            if (visited.has(`${current.x},${current.y}`)) {
+                continue;
+            }
+            visited.add(`${current.x},${current.y}`);
+            result.push(current);
+            const edges = this.getConnectionsAt(current);
+            for (const edge of edges) {
+                if (edge.x1 === current.x && edge.y1 === current.y) {
+                    queue.push({ x: edge.x2, y: edge.y2 });
+                }
+                else {
+                    queue.push({ x: edge.x1, y: edge.y1 });
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Create new GridConnections from a string array.
+     *
+     * - Use `.` for cells that don't connect to anything.
+     * - Use any other character for cells that connect to the same character.
+     *
+     * @param array - The string array to create the connections from.
+     * @returns The created connections. You can apply this to a GridData object using GridData.withConnections.
+     */
+    static create(array) {
+        const edges = [];
+        for (let y = 0; y < array.length; y++) {
+            for (let x = 0; x < array[y].length; x++) {
+                if (array[y][x] === '.') {
+                    continue;
+                }
+                if (x > 0 && array[y][x - 1] === array[y][x]) {
+                    edges.push({ x1: x - 1, y1: y, x2: x, y2: y });
+                }
+                if (y > 0 && array[y - 1][x] === array[y][x]) {
+                    edges.push({ x1: x, y1: y - 1, x2: x, y2: y });
+                }
+            }
+        }
+        return new GridConnections(edges);
+    }
+    /**
+     * Check if two GridConnections objects are equal.
+     * @param other The other GridConnections object to compare to.
+     * @returns Whether the two objects are equal.
+     */
+    equals(other) {
+        if (this.edges.length !== other.edges.length)
+            return false;
+        for (const edge of this.edges) {
+            if (!other.isConnected(edge))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Deduplicate an array of edges.
+     * @param edges The array of edges to deduplicate.
+     * @returns The deduplicated array of edges.
+     */
+    static deduplicateEdges(edges) {
+        return edges.filter((edge, index) => edges.findIndex(e => isSameEdge(e, edge)) === index);
+    }
+    insertColumn(index) {
+        return new GridConnections(this.edges.flatMap(edge => {
+            if ((edge.x1 < index && edge.x2 < index) ||
+                (edge.x1 >= index && edge.x2 >= index)) {
+                if (edge.x1 < index) {
+                    return [edge];
+                }
+                return [
+                    { x1: edge.x1 + 1, y1: edge.y1, x2: edge.x2 + 1, y2: edge.y2 },
+                ];
+            }
+            return [
+                { x1: edge.x1, y1: edge.y1, x2: edge.x2, y2: edge.y2 },
+                { x1: edge.x1 + 1, y1: edge.y1, x2: edge.x2 + 1, y2: edge.y2 },
+            ];
+        }));
+    }
+    insertRow(index) {
+        return new GridConnections(this.edges.flatMap(edge => {
+            if ((edge.y1 < index && edge.y2 < index) ||
+                (edge.y1 >= index && edge.y2 >= index)) {
+                if (edge.y1 < index) {
+                    return [edge];
+                }
+                return [
+                    { x1: edge.x1, y1: edge.y1 + 1, x2: edge.x2, y2: edge.y2 + 1 },
+                ];
+            }
+            return [
+                { x1: edge.x1, y1: edge.y1, x2: edge.x2, y2: edge.y2 },
+                { x1: edge.x1, y1: edge.y1 + 1, x2: edge.x2, y2: edge.y2 + 1 },
+            ];
+        }));
+    }
+    removeColumn(index) {
+        const toProcess = new Map();
+        const toKeep = [];
+        this.edges.forEach(edge => {
+            if ((edge.x1 < index && edge.x2 < index) ||
+                (edge.x1 > index && edge.x2 > index)) {
+                if (edge.x1 < index) {
+                    toKeep.push(edge);
+                }
+                else {
+                    toKeep.push({
+                        x1: edge.x1 - 1,
+                        y1: edge.y1,
+                        x2: edge.x2 - 1,
+                        y2: edge.y2,
+                    });
+                }
+            }
+            else if (edge.x1 !== index && edge.x2 !== index) {
+                toKeep.push({
+                    x1: edge.x1 > index ? edge.x1 - 1 : edge.x1,
+                    y1: edge.y1,
+                    x2: edge.x2 > index ? edge.x2 - 1 : edge.x2,
+                    y2: edge.y2,
+                });
+            }
+            else {
+                if (edge.x1 === index) {
+                    if (!toProcess.has(edge.y1)) {
+                        toProcess.set(edge.y1, [edge]);
+                    }
+                    else {
+                        toProcess.get(edge.y1).push(edge);
+                    }
+                }
+                else if (edge.x2 === index) {
+                    if (!toProcess.has(edge.y2)) {
+                        toProcess.set(edge.y2, [edge]);
+                    }
+                    else {
+                        toProcess.get(edge.y2).push(edge);
+                    }
+                }
+            }
+        });
+        for (const [key, list] of toProcess.entries()) {
+            for (let i = 1; i < list.length; i++) {
+                if (!isSameEdge(list[i], list[i - 1])) {
+                    let x1, y1, x2, y2;
+                    if (list[i].x1 === index && list[i].y1 === key) {
+                        x1 = list[i].x2 > index ? list[i].x2 - 1 : list[i].x2;
+                        y1 = list[i].y2;
+                    }
+                    else {
+                        x1 = list[i].x1 > index ? list[i].x1 - 1 : list[i].x1;
+                        y1 = list[i].y1;
+                    }
+                    if (list[i - 1].x1 === index && list[i - 1].y1 === key) {
+                        x2 = list[i - 1].x2 > index ? list[i - 1].x2 - 1 : list[i - 1].x2;
+                        y2 = list[i - 1].y2;
+                    }
+                    else {
+                        x2 = list[i - 1].x1 > index ? list[i - 1].x1 - 1 : list[i - 1].x1;
+                        y2 = list[i - 1].y1;
+                    }
+                    toKeep.push({ x1, y1, x2, y2 });
+                }
+            }
+        }
+        return new GridConnections(toKeep);
+    }
+    removeRow(index) {
+        const toProcess = new Map();
+        const toKeep = [];
+        this.edges.forEach(edge => {
+            if ((edge.y1 < index && edge.y2 < index) ||
+                (edge.y1 > index && edge.y2 > index)) {
+                if (edge.y1 < index) {
+                    toKeep.push(edge);
+                }
+                else {
+                    toKeep.push({
+                        x1: edge.x1,
+                        y1: edge.y1 - 1,
+                        x2: edge.x2,
+                        y2: edge.y2 - 1,
+                    });
+                }
+            }
+            else if (edge.y1 !== index && edge.y2 !== index) {
+                toKeep.push({
+                    x1: edge.x1,
+                    y1: edge.y1 > index ? edge.y1 - 1 : edge.y1,
+                    x2: edge.x2,
+                    y2: edge.y2 > index ? edge.y2 - 1 : edge.y2,
+                });
+            }
+            else {
+                if (edge.y1 === index) {
+                    if (!toProcess.has(edge.x1)) {
+                        toProcess.set(edge.x1, [edge]);
+                    }
+                    else {
+                        toProcess.get(edge.x1).push(edge);
+                    }
+                }
+                else if (edge.y2 === index) {
+                    if (!toProcess.has(edge.x2)) {
+                        toProcess.set(edge.x2, [edge]);
+                    }
+                    else {
+                        toProcess.get(edge.x2).push(edge);
+                    }
+                }
+            }
+        });
+        for (const [key, list] of toProcess.entries()) {
+            for (let i = 1; i < list.length; i++) {
+                if (!isSameEdge(list[i], list[i - 1])) {
+                    let x1, y1, x2, y2;
+                    if (list[i].y1 === index && list[i].x1 === key) {
+                        x1 = list[i].x2;
+                        y1 = list[i].y2 > index ? list[i].y2 - 1 : list[i].y2;
+                    }
+                    else {
+                        x1 = list[i].x1;
+                        y1 = list[i].y1 > index ? list[i].y1 - 1 : list[i].y1;
+                    }
+                    if (list[i - 1].y1 === index && list[i - 1].x1 === key) {
+                        x2 = list[i - 1].x2;
+                        y2 = list[i - 1].y2 > index ? list[i - 1].y2 - 1 : list[i - 1].y2;
+                    }
+                    else {
+                        x2 = list[i - 1].x1;
+                        y2 = list[i - 1].y1 > index ? list[i - 1].y1 - 1 : list[i - 1].y1;
+                    }
+                    toKeep.push({ x1, y1, x2, y2 });
+                }
+            }
+        }
+        return new GridConnections(toKeep);
+    }
+}

package/dist/data/instruction.d.ts

@@ -0,0 +1,19 @@
+import Configurable from './configurable';
+import GridData from './grid';
+export default abstract class Instruction extends Configurable {
+    abstract get id(): string;
+    abstract get explanation(): string;
+    abstract createExampleGrid(): GridData;
+    /**
+     * Indicates that validation by logic is not available and the solution must be used for validation
+     */
+    get validateWithSolution(): boolean;
+    get necessaryForCompletion(): boolean;
+    /**
+     * Check if this instruction is equal to another instruction by comparing their IDs and configs.
+     *
+     * @param other The other instruction to compare to.
+     * @returns Whether the two instructions are equal.
+     */
+    equals(other: Instruction): boolean;
+}

package/dist/data/instruction.js

@@ -0,0 +1,23 @@
+import Configurable from './configurable';
+export default class Instruction extends Configurable {
+    /**
+     * Indicates that validation by logic is not available and the solution must be used for validation
+     */
+    get validateWithSolution() {
+        return false;
+    }
+    get necessaryForCompletion() {
+        return true;
+    }
+    /**
+     * Check if this instruction is equal to another instruction by comparing their IDs and configs.
+     *
+     * @param other The other instruction to compare to.
+     * @returns Whether the two instructions are equal.
+     */
+    equals(other) {
+        if (this.id !== other.id)
+            return false;
+        return super.equals(other);
+    }
+}

package/dist/data/primitives.d.ts

@@ -0,0 +1,85 @@
+export interface Position {
+    readonly x: number;
+    readonly y: number;
+}
+export interface Edge {
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+}
+export declare enum State {
+    Error = "error",
+    Satisfied = "satisfied",
+    Incomplete = "incomplete"
+}
+export type RuleState = {
+    readonly state: State.Error;
+    readonly positions: readonly Position[];
+} | {
+    readonly state: State.Satisfied;
+} | {
+    readonly state: State.Incomplete;
+};
+export interface GridState {
+    final: State;
+    rules: readonly RuleState[];
+    symbols: ReadonlyMap<string, State[]>;
+}
+export declare enum Color {
+    Dark = "dark",
+    Light = "light",
+    Gray = "gray"
+}
+export declare enum Comparison {
+    Equal = "eq",
+    AtLeast = "ge",
+    AtMost = "le"
+}
+export declare const COMPARISONS: readonly Comparison[];
+export declare enum Direction {
+    Up = "up",
+    Down = "down",
+    Left = "left",
+    Right = "right"
+}
+export declare const DIRECTIONS: readonly Direction[];
+export type DirectionMap<T> = {
+    [key in Direction]: T;
+};
+export type DirectionToggle = Readonly<DirectionMap<boolean>>;
+export declare function directionToggle(...directions: readonly Direction[]): {
+    up: boolean;
+    down: boolean;
+    left: boolean;
+    right: boolean;
+};
+export declare enum Orientation {
+    Up = "up",
+    UpRight = "up-right",
+    Right = "right",
+    DownRight = "down-right",
+    Down = "down",
+    DownLeft = "down-left",
+    Left = "left",
+    UpLeft = "up-left"
+}
+export declare const ORIENTATIONS: readonly Orientation[];
+export type OrientationMap<T> = {
+    [key in Orientation]: T;
+};
+export type OrientationToggle = Readonly<OrientationMap<boolean>>;
+export declare function orientationToggle(...orientations: readonly Orientation[]): {
+    up: boolean;
+    'up-right': boolean;
+    right: boolean;
+    'down-right': boolean;
+    down: boolean;
+    'down-left': boolean;
+    left: boolean;
+    'up-left': boolean;
+};
+export declare enum Mode {
+    Create = "create",
+    Solve = "solve"
+}

package/dist/data/primitives.js

@@ -0,0 +1,90 @@
+export var State;
+(function (State) {
+    State["Error"] = "error";
+    State["Satisfied"] = "satisfied";
+    State["Incomplete"] = "incomplete";
+})(State || (State = {}));
+export var Color;
+(function (Color) {
+    Color["Dark"] = "dark";
+    Color["Light"] = "light";
+    Color["Gray"] = "gray";
+})(Color || (Color = {}));
+export var Comparison;
+(function (Comparison) {
+    Comparison["Equal"] = "eq";
+    Comparison["AtLeast"] = "ge";
+    Comparison["AtMost"] = "le";
+})(Comparison || (Comparison = {}));
+export const COMPARISONS = [
+    Comparison.Equal,
+    Comparison.AtLeast,
+    Comparison.AtMost,
+];
+export var Direction;
+(function (Direction) {
+    Direction["Up"] = "up";
+    Direction["Down"] = "down";
+    Direction["Left"] = "left";
+    Direction["Right"] = "right";
+})(Direction || (Direction = {}));
+export const DIRECTIONS = [
+    Direction.Up,
+    Direction.Down,
+    Direction.Left,
+    Direction.Right,
+];
+export function directionToggle(...directions) {
+    const result = {
+        up: false,
+        down: false,
+        left: false,
+        right: false,
+    };
+    for (const direction of directions) {
+        result[direction] = true;
+    }
+    return result;
+}
+export var Orientation;
+(function (Orientation) {
+    Orientation["Up"] = "up";
+    Orientation["UpRight"] = "up-right";
+    Orientation["Right"] = "right";
+    Orientation["DownRight"] = "down-right";
+    Orientation["Down"] = "down";
+    Orientation["DownLeft"] = "down-left";
+    Orientation["Left"] = "left";
+    Orientation["UpLeft"] = "up-left";
+})(Orientation || (Orientation = {}));
+export const ORIENTATIONS = [
+    Orientation.Up,
+    Orientation.UpRight,
+    Orientation.Right,
+    Orientation.DownRight,
+    Orientation.Down,
+    Orientation.DownLeft,
+    Orientation.Left,
+    Orientation.UpLeft,
+];
+export function orientationToggle(...orientations) {
+    const result = {
+        up: false,
+        'up-right': false,
+        right: false,
+        'down-right': false,
+        down: false,
+        'down-left': false,
+        left: false,
+        'up-left': false,
+    };
+    for (const orientation of orientations) {
+        result[orientation] = true;
+    }
+    return result;
+}
+export var Mode;
+(function (Mode) {
+    Mode["Create"] = "create";
+    Mode["Solve"] = "solve";
+})(Mode || (Mode = {}));

package/dist/data/puzzle.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import GridData from './grid';
+export type PuzzleMetadata = {
+    /**
+     * The title of the puzzle. (required)
+     */
+    title: string;
+    /**
+     * The author of the puzzle. (required)
+     */
+    author: string;
+    /**
+     * A description of the puzzle. (can be empty)
+     */
+    description: string;
+    /**
+     * A link to a place to discuss this puzzle. (can be empty)
+     */
+    link: string;
+    /**
+     * The difficulty of the puzzle, from 1 to 10. (required)
+     *
+     * 6-10 represent star difficulties.
+     */
+    difficulty: number;
+};
+export declare const MetadataSchema: z.ZodObject<{
+    title: z.ZodString;
+    author: z.ZodString;
+    description: z.ZodString;
+    link: z.ZodString;
+    difficulty: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+    title: string;
+    author: string;
+    link: string;
+    difficulty: number;
+}, {
+    description: string;
+    title: string;
+    author: string;
+    link: string;
+    difficulty: number;
+}>;
+export declare const PuzzleSchema: z.ZodObject<{
+    title: z.ZodString;
+    author: z.ZodString;
+    description: z.ZodString;
+    link: z.ZodString;
+    difficulty: z.ZodNumber;
+    grid: z.ZodType<GridData, z.ZodTypeDef, GridData>;
+    solution: z.ZodNullable<z.ZodType<GridData, z.ZodTypeDef, GridData>>;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+    grid: GridData;
+    title: string;
+    author: string;
+    link: string;
+    difficulty: number;
+    solution: GridData | null;
+}, {
+    description: string;
+    grid: GridData;
+    title: string;
+    author: string;
+    link: string;
+    difficulty: number;
+    solution: GridData | null;
+}>;
+export type Puzzle = PuzzleMetadata & {
+    /**
+     * The grid of the puzzle. (required)
+     *
+     * You must fix all given cells in the grid. The rest of the cells will be cleared.
+     */
+    grid: GridData;
+    /**
+     * The solution to the puzzle. (optional)
+     *
+     * You should provide a solution if a rule requires it. Otherwise, the rule can never be satisfied.
+     *
+     * If there are no rules that require a solution, this field will be ignored.
+     */
+    solution: GridData | null;
+};

package/dist/data/puzzle.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import GridData from './grid';
+export const MetadataSchema = z
+    .object({
+    title: z.string().min(1),
+    author: z.string().min(1),
+    description: z.string(),
+    link: z.string(),
+    difficulty: z.number().int().min(1).max(10),
+})
+    .strict();
+export const PuzzleSchema = z
+    .object({
+    title: z.string().min(1),
+    author: z.string().min(1),
+    description: z.string(),
+    link: z.string(),
+    difficulty: z.number().int().min(1).max(10),
+    grid: z.instanceof(GridData),
+    solution: z.instanceof(GridData).nullable(),
+})
+    .strict();