@logic-pad/core 0.26.1 → 0.26.2

package/dist/src/data/gridConnections.d.ts

@@ -1,25 +0,0 @@
-import GridZones from './gridZones.js';
-import { Edge, Position } from './primitives.js';
-import TileConnections from './tileConnections.js';
-export default class GridConnections extends GridZones {
-    constructor(edges?: readonly Edge[]);
-    addEdge(edge: Edge): GridConnections;
-    removeEdge(edge: Edge): GridConnections;
-    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;
-    static validateEdges(connections: GridConnections, width: number, height: number): GridConnections;
-    insertColumn(index: number): GridConnections;
-    insertRow(index: number): GridConnections;
-    removeColumn(index: number): GridConnections;
-    removeRow(index: number): GridConnections;
-}

package/dist/src/data/gridConnections.js

@@ -1,309 +0,0 @@
-import { isSameEdge } from './dataHelper.js';
-import GridZones from './gridZones.js';
-import TileConnections from './tileConnections.js';
-export default class GridConnections extends GridZones {
-    constructor(edges) {
-        super(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)));
-    }
-    getForTile({ x, y }) {
-        const result = new TileConnections();
-        // Get all connections within 2 steps of the tile
-        const edges = this.getEdgesAt({ x, y });
-        const edges2 = [
-            ...edges,
-            ...edges.flatMap(edge => {
-                if (edge.x1 === x && edge.y1 === y) {
-                    return this.getEdgesAt({ x: edge.x2, y: edge.y2 });
-                }
-                else {
-                    return this.getEdgesAt({ 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.getEdgesAt(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);
-    }
-    static validateEdges(connections, width, height) {
-        const newEdges = [];
-        for (const edge of connections.edges) {
-            if (edge.x1 < 0 || edge.x1 >= width || edge.y1 < 0 || edge.y1 >= height) {
-                continue;
-            }
-            if (edge.x2 < 0 || edge.x2 >= width || edge.y2 < 0 || edge.y2 >= height) {
-                continue;
-            }
-            if (Math.abs(edge.x1 - edge.x2) + Math.abs(edge.y1 - edge.y2) !== 1) {
-                continue;
-            }
-            newEdges.push(edge);
-        }
-        if (newEdges.length === connections.edges.length) {
-            return connections;
-        }
-        return new GridConnections(newEdges);
-    }
-    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/src/data/gridZones.d.ts

@@ -1,26 +0,0 @@
-import { Edge, Position } from './primitives.js';
-export default class GridZones {
-    readonly edges: readonly Edge[];
-    constructor(edges?: readonly Edge[]);
-    addEdge(edge: Edge): GridZones;
-    removeEdge(edge: Edge): GridZones;
-    hasEdge(edge: Edge): boolean;
-    getEdgesAt({ x, y }: Position): readonly Edge[];
-    /**
-     * Check if two GridZones objects are equal.
-     * @param other The other GridZones object to compare to.
-     * @returns Whether the two objects are equal.
-     */
-    equals(other: GridZones): 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[];
-    static validateEdges(connections: GridZones, width: number, height: number): GridZones;
-    insertColumn(index: number): GridZones;
-    insertRow(index: number): GridZones;
-    removeColumn(index: number): GridZones;
-    removeRow(index: number): GridZones;
-}

package/dist/src/data/gridZones.js

@@ -1,117 +0,0 @@
-import { isSameEdge } from './dataHelper.js';
-export default class GridZones {
-    edges;
-    constructor(edges) {
-        this.edges = GridZones.deduplicateEdges(edges ?? []);
-    }
-    addEdge(edge) {
-        if (this.edges.some(e => isSameEdge(e, edge))) {
-            return this;
-        }
-        return new GridZones([...this.edges, edge]);
-    }
-    removeEdge(edge) {
-        return new GridZones(this.edges.filter(e => !isSameEdge(e, edge)));
-    }
-    hasEdge(edge) {
-        if (edge.x1 === edge.x2 && edge.y1 === edge.y2)
-            return true;
-        return this.edges.some(e => isSameEdge(e, edge));
-    }
-    getEdgesAt({ x, y }) {
-        return this.edges.filter(e => (e.x1 === x && e.y1 === y) || (e.x2 === x && e.y2 === y));
-    }
-    /**
-     * Check if two GridZones objects are equal.
-     * @param other The other GridZones 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.hasEdge(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);
-    }
-    static validateEdges(connections, width, height) {
-        const newEdges = [];
-        for (const edge of connections.edges) {
-            if (edge.x1 < -1 ||
-                edge.x1 >= width + 1 ||
-                edge.y1 < -1 ||
-                edge.y1 >= height + 1) {
-                continue;
-            }
-            if (edge.x2 < -1 ||
-                edge.x2 >= width + 1 ||
-                edge.y2 < -1 ||
-                edge.y2 >= height + 1) {
-                continue;
-            }
-            if ((edge.x1 < 0 && edge.x2 < 0) ||
-                (edge.y1 < 0 && edge.y2 < 0) ||
-                (edge.x1 >= width && edge.x2 >= width) ||
-                (edge.y1 >= height && edge.y2 >= height)) {
-                continue;
-            }
-            if (Math.abs(edge.x1 - edge.x2) + Math.abs(edge.y1 - edge.y2) !== 1) {
-                continue;
-            }
-            newEdges.push(edge);
-        }
-        if (newEdges.length === connections.edges.length) {
-            return connections;
-        }
-        return new GridZones(newEdges);
-    }
-    insertColumn(index) {
-        return new GridZones(this.edges.map(edge => {
-            if (edge.x1 < index || edge.x2 < index) {
-                return edge;
-            }
-            else {
-                return { x1: edge.x1 + 1, y1: edge.y1, x2: edge.x2 + 1, y2: edge.y2 };
-            }
-        }));
-    }
-    insertRow(index) {
-        return new GridZones(this.edges.map(edge => {
-            if (edge.y1 < index || edge.y2 < index) {
-                return edge;
-            }
-            else {
-                return { x1: edge.x1, y1: edge.y1 + 1, x2: edge.x2, y2: edge.y2 + 1 };
-            }
-        }));
-    }
-    removeColumn(index) {
-        return new GridZones(this.edges.map(edge => {
-            if (edge.x1 > index || edge.x2 > index) {
-                return { x1: edge.x1 - 1, y1: edge.y1, x2: edge.x2 - 1, y2: edge.y2 };
-            }
-            else {
-                return edge;
-            }
-        }));
-    }
-    removeRow(index) {
-        return new GridZones(this.edges.map(edge => {
-            if (edge.y1 > index || edge.y2 > index) {
-                return { x1: edge.x1, y1: edge.y1 - 1, x2: edge.x2, y2: edge.y2 - 1 };
-            }
-            else {
-                return edge;
-            }
-        }));
-    }
-}

package/dist/src/data/instruction.d.ts

@@ -1,26 +0,0 @@
-import Configurable from './configurable.js';
-import GridData from './grid.js';
-import { Mode } from './primitives.js';
-export default abstract class Instruction extends Configurable {
-    abstract get id(): string;
-    abstract get explanation(): string;
-    get configExplanation(): 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;
-    get visibleWhenSolving(): boolean;
-    /**
-     * Return a variant of this instruction that is suitable for the given mode.
-     */
-    abstract modeVariant(mode: Mode): Instruction | null;
-    /**
-     * 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/src/data/instruction.js

@@ -1,29 +0,0 @@
-import Configurable from './configurable.js';
-export default class Instruction extends Configurable {
-    get configExplanation() {
-        return this.explanation;
-    }
-    /**
-     * Indicates that validation by logic is not available and the solution must be used for validation
-     */
-    get validateWithSolution() {
-        return false;
-    }
-    get necessaryForCompletion() {
-        return true;
-    }
-    get visibleWhenSolving() {
-        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/src/data/primitives.d.ts

@@ -1,138 +0,0 @@
-export interface Position {
-    readonly x: number;
-    readonly y: number;
-}
-export interface Edge {
-    readonly x1: number;
-    readonly y1: number;
-    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",
-    WrapAround = "wrap_around"
-}
-/**
- * General puzzle types for categorization. One puzzle can have multiple types.
- */
-export declare enum PuzzleType {
-    Logic = "logic",
-    Underclued = "underclued",
-    Pattern = "pattern",
-    Music = "music"
-}
-export declare enum State {
-    /**
-     * Describes the violation of a rule.
-     */
-    Error = "error",
-    /**
-     * Describes that a rule is satisfied and complete in the current grid.
-     */
-    Satisfied = "satisfied",
-    /**
-     * Describes that a rule is not violated, but is not yet complete in the current grid.
-     */
-    Incomplete = "incomplete",
-    /**
-     * Describes that a rule is violated but ignored due to the effect of another rule.
-     */
-    Ignored = "ignored"
-}
-export declare namespace State {
-    function isSatisfied(state: State): boolean;
-}
-export type RuleState = {
-    readonly state: State.Error;
-    readonly positions: readonly Position[];
-} | {
-    readonly state: State.Satisfied;
-} | {
-    readonly state: State.Incomplete;
-} | {
-    readonly state: State.Ignored;
-};
-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 Wrapping {
-    None = "none",
-    Wrap = "wrap",
-    WrapReverse = "wrap-reverse",
-    ReflectReverse = "reflect-reverse"
-}
-export declare const WRAPPINGS: readonly Wrapping[];
-export declare enum Direction {
-    Up = "up",
-    Down = "down",
-    Left = "left",
-    Right = "right"
-}
-export declare const DIRECTIONS: readonly Direction[];
-export type DirectionMap<T> = Record<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> = Record<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",
-    Perfection = "perfection"
-}
-export declare enum Instrument {
-    Piano = "piano",
-    Drum = "drum",
-    Violin = "violin",
-    Xylophone = "xylophone",
-    GuitarAcoustic = "guitar-acoustic",
-    GuitarElectric = "guitar-electric",
-    Flute = "flute",
-    Trumpet = "trumpet"
-}
-export declare const INSTRUMENTS: readonly Instrument[];
-export declare const DRUM_SAMPLES: readonly ["snare", "kick", "hihat", "hihat-open", "crash", "tom", "rim"];
-export declare function isDrumSample(note: string): boolean;