@logic-pad/core 0.26.2 → 0.26.3

package/dist/src/data/primitives.js

@@ -0,0 +1,177 @@
+/**
+ * Major rules are frequently referenced in grids to provide additional UI.
+ */
+export var MajorRule;
+(function (MajorRule) {
+    MajorRule["MusicGrid"] = "music";
+    MajorRule["CompletePattern"] = "complete_pattern";
+    MajorRule["Underclued"] = "underclued";
+    MajorRule["WrapAround"] = "wrap_around";
+})(MajorRule || (MajorRule = {}));
+/**
+ * General puzzle types for categorization. One puzzle can have multiple types.
+ */
+export var PuzzleType;
+(function (PuzzleType) {
+    PuzzleType["Logic"] = "logic";
+    PuzzleType["Underclued"] = "underclued";
+    PuzzleType["Pattern"] = "pattern";
+    PuzzleType["Music"] = "music";
+})(PuzzleType || (PuzzleType = {}));
+export var State;
+(function (State) {
+    /**
+     * Describes the violation of a rule.
+     */
+    State["Error"] = "error";
+    /**
+     * Describes that a rule is satisfied and complete in the current grid.
+     */
+    State["Satisfied"] = "satisfied";
+    /**
+     * Describes that a rule is not violated, but is not yet complete in the current grid.
+     */
+    State["Incomplete"] = "incomplete";
+    /**
+     * Describes that a rule is violated but ignored due to the effect of another rule.
+     */
+    State["Ignored"] = "ignored";
+})(State || (State = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (State) {
+    function isSatisfied(state) {
+        return state === State.Satisfied || state === State.Ignored;
+    }
+    State.isSatisfied = isSatisfied;
+})(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 Wrapping;
+(function (Wrapping) {
+    Wrapping["None"] = "none";
+    Wrapping["Wrap"] = "wrap";
+    Wrapping["WrapReverse"] = "wrap-reverse";
+    Wrapping["ReflectReverse"] = "reflect-reverse";
+})(Wrapping || (Wrapping = {}));
+export const WRAPPINGS = [
+    Wrapping.None,
+    Wrapping.Wrap,
+    Wrapping.WrapReverse,
+    Wrapping.ReflectReverse,
+];
+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["Perfection"] = "perfection";
+})(Mode || (Mode = {}));
+export var Instrument;
+(function (Instrument) {
+    Instrument["Piano"] = "piano";
+    Instrument["Drum"] = "drum";
+    Instrument["Violin"] = "violin";
+    Instrument["Xylophone"] = "xylophone";
+    Instrument["GuitarAcoustic"] = "guitar-acoustic";
+    Instrument["GuitarElectric"] = "guitar-electric";
+    Instrument["Flute"] = "flute";
+    Instrument["Trumpet"] = "trumpet";
+})(Instrument || (Instrument = {}));
+export const INSTRUMENTS = [
+    Instrument.Piano,
+    Instrument.Drum,
+    Instrument.Violin,
+    Instrument.Xylophone,
+    Instrument.GuitarAcoustic,
+    Instrument.GuitarElectric,
+    Instrument.Flute,
+    Instrument.Trumpet,
+];
+export const DRUM_SAMPLES = [
+    'snare',
+    'kick',
+    'hihat',
+    'hihat-open',
+    'crash',
+    'tom',
+    'rim',
+];
+export function isDrumSample(note) {
+    return DRUM_SAMPLES.includes(note);
+}

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

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import GridData from './grid.js';
+import { GridState, PuzzleType } from './primitives.js';
+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;
+    /**
+     * The difficulty of the puzzle, from 0 to 10. (required)
+     *
+     * 0 represents an unrated puzzle, 6-10 represent star difficulties.
+     */
+    difficulty: number;
+};
+export declare const MetadataSchema: z.ZodObject<{
+    title: z.ZodString;
+    author: z.ZodString;
+    description: z.ZodString;
+    difficulty: z.ZodNumber;
+}, z.core.$strict>;
+export declare const PuzzleSchema: z.ZodObject<{
+    title: z.ZodString;
+    author: z.ZodString;
+    description: z.ZodString;
+    difficulty: z.ZodNumber;
+    grid: z.ZodCustom<GridData, GridData>;
+    solution: z.ZodNullable<z.ZodCustom<GridData, GridData>>;
+}, z.core.$strict>;
+export type PuzzleData = {
+    /**
+     * 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;
+};
+export type Puzzle = PuzzleMetadata & PuzzleData;
+/**
+ * Checks if two puzzles are equal.
+ */
+export declare function puzzleEquals(a: Puzzle, b: Puzzle): boolean;
+/**
+ * Get the types of a puzzle based on its grid properties. The returned types are ordered by their priority.
+ * The first type is the most important one.
+ */
+export declare function getPuzzleTypes(grid: GridData): PuzzleType[];
+export interface PuzzleChecklistItem {
+    id: string;
+    success: boolean;
+    mandatory: boolean;
+}
+export interface PuzzleChecklist {
+    items: PuzzleChecklistItem[];
+    isValid: boolean;
+}
+export declare function validatePuzzleChecklist(metadata: PuzzleMetadata, gridWithSolution: GridData, state: GridState): PuzzleChecklist;

package/dist/src/data/puzzle.js

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import GridData from './grid.js';
+import { Color, PuzzleType, State } from './primitives.js';
+export const MetadataSchema = z.strictObject({
+    title: z.string('Title must be a string').min(1, 'Title must not be empty'),
+    author: z
+        .string('Author must be a string')
+        .min(1, 'Author must not be empty'),
+    description: z.string('Description must be a string'),
+    difficulty: z
+        .number('Difficulty must be a number')
+        .int('Difficulty must be an integer')
+        .min(0, 'Difficulty must be at least 0')
+        .max(10, 'Difficulty must be at most 10'),
+}, 'Data must be an object');
+export const PuzzleSchema = MetadataSchema.extend({
+    grid: z.instanceof(GridData, { error: 'Grid must be a GridData instance' }),
+    solution: z
+        .instanceof(GridData, { error: 'Solution must be a GridData instance' })
+        .nullable(),
+}).strict();
+/**
+ * Checks if two puzzles are equal.
+ */
+export function puzzleEquals(a, b) {
+    return (a.title === b.title &&
+        a.author === b.author &&
+        a.description === b.description &&
+        a.difficulty === b.difficulty &&
+        a.grid.equals(b.grid) &&
+        ((a.solution === null && b.solution === null) ||
+            (!!a.solution && !!b.solution && a.solution.equals(b.solution))));
+}
+/**
+ * Get the types of a puzzle based on its grid properties. The returned types are ordered by their priority.
+ * The first type is the most important one.
+ */
+export function getPuzzleTypes(grid) {
+    const types = [];
+    let logic = true;
+    if (grid.musicGrid.value) {
+        types.push(PuzzleType.Music);
+        logic = false;
+    }
+    if (grid.completePattern.value) {
+        types.push(PuzzleType.Pattern);
+        logic = false;
+    }
+    if (grid.underclued.value) {
+        types.push(PuzzleType.Underclued);
+    }
+    if (logic) {
+        types.push(PuzzleType.Logic);
+    }
+    return types;
+}
+export function validatePuzzleChecklist(metadata, gridWithSolution, state) {
+    const checklist = {
+        items: [],
+        isValid: true,
+    };
+    checklist.items.push({
+        id: 'metadataValid',
+        success: MetadataSchema.safeParse(metadata).success,
+        mandatory: true,
+    });
+    checklist.items.push({
+        id: 'gridValid',
+        success: gridWithSolution.width > 0 && gridWithSolution.height > 0,
+        mandatory: true,
+    });
+    if (gridWithSolution.requireSolution()) {
+        checklist.items.push({
+            id: 'autoValidation',
+            success: false,
+            mandatory: false,
+        });
+        checklist.items.push({
+            id: 'solutionIsNotEmpty',
+            success: gridWithSolution.musicGrid.value
+                ? gridWithSolution.tiles.some(row => row.some(tile => !tile.fixed && tile.color === Color.Dark))
+                : gridWithSolution.tiles.some(row => row.some(tile => !tile.fixed && tile.color !== Color.Gray)),
+            mandatory: true,
+        });
+    }
+    else {
+        checklist.items.push({
+            id: 'autoValidation',
+            success: true,
+            mandatory: false,
+        });
+        checklist.items.push({
+            id: 'solutionIsComplete',
+            success: gridWithSolution.isComplete(),
+            mandatory: true,
+        });
+        checklist.items.push({
+            id: 'solutionIsValid',
+            success: state.final !== State.Error,
+            mandatory: true,
+        });
+    }
+    checklist.isValid = !checklist.items.some(x => !x.success && x.mandatory);
+    return checklist;
+}

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

@@ -0,0 +1,30 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { RuleState } from '../primitives.js';
+import { Shape } from '../shapes.js';
+import Rule, { SearchVariant } from './rule.js';
+export default class BanPatternRule extends Rule {
+    readonly title = "Ban Pattern";
+    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/src/data/rules/banPatternRule.js

@@ -0,0 +1,125 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { array } from '../dataHelper.js';
+import { Color, State } from '../primitives.js';
+import { getShapeVariants, sanitizePatternGrid, tilesToShape, } from '../shapes.js';
+import Rule from './rule.js';
+export default class BanPatternRule extends Rule {
+    title = 'Ban Pattern';
+    static EXAMPLE_GRID = Object.freeze(GridData.create(['nnnnn', 'nnnnn', 'wwwwn', 'nnnnn', 'nnnnn']));
+    static CONFIGS = Object.freeze([
+        {
+            type: ConfigType.Shape,
+            default: BanPatternRule.EXAMPLE_GRID,
+            resizable: true,
+            field: 'pattern',
+            description: 'Pattern',
+            explanation: 'The pattern to be banned. Can be a mix of dark and light tiles.',
+            configurable: true,
+        },
+    ]);
+    static SEARCH_VARIANTS = [
+        new BanPatternRule(BanPatternRule.EXAMPLE_GRID).searchVariant(),
+    ];
+    pattern;
+    cache;
+    /**
+     * **Don't make this pattern**
+     *
+     * @param pattern - GridData representing the banned pattern. Only non-gray tiles are considered.
+     */
+    constructor(pattern) {
+        super();
+        this.pattern = sanitizePatternGrid(pattern);
+        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;
+        if (!Number.isFinite(width) || !Number.isFinite(height)) {
+            return GridData.create(0, 0);
+        }
+        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 GridData.create(width, height, tiles);
+    }
+    get searchVariants() {
+        return BanPatternRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        for (const pattern of this.cache) {
+            let startX, startY, endX, endY;
+            if (grid.wrapAround.value) {
+                startX = -pattern.width;
+                startY = -pattern.height;
+                endX = grid.width - 1;
+                endY = grid.height - 1;
+            }
+            else {
+                startX = 0;
+                startY = 0;
+                endX = grid.width - pattern.width;
+                endY = grid.height - pattern.height;
+            }
+            for (let y = startY; y <= endY; y++) {
+                for (let x = startX; x <= endX; x++) {
+                    let match = true;
+                    const visited = [];
+                    for (const tile of pattern.elements) {
+                        const pos = grid.toArrayCoordinates(x + tile.x, y + tile.y);
+                        if (grid.wrapAround.value && // optimization: no need to check visited if wrapAround is disabled
+                            visited.some(p => p.x === pos.x && p.y === pos.y)) {
+                            match = false;
+                            break;
+                        }
+                        visited.push(pos);
+                        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 => grid.toArrayCoordinates(x + tile.x, 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 });
+    }
+}
+export const instance = new BanPatternRule(GridData.create([]));

package/dist/src/data/rules/cellCountPerZoneRule.d.ts

@@ -0,0 +1,23 @@
+import GridData from '../grid.js';
+import { Color, Position } from '../primitives.js';
+import Rule from './rule.js';
+export interface Zone {
+    positions: Position[];
+    completed: number;
+    possible: number;
+}
+export type ZoneCounts = {
+    zones: Zone[];
+    complete: boolean;
+};
+export default abstract class CellCountPerZoneRule extends Rule {
+    readonly color: Color;
+    get configExplanation(): string;
+    /**
+     * @param color - The color of the cells to count.
+     */
+    constructor(color: Color);
+    protected getZoneCounts(grid: GridData): ZoneCounts;
+    withColor(color: Color): this;
+}
+export declare const instance: undefined;

package/dist/src/data/rules/cellCountPerZoneRule.js

@@ -0,0 +1,39 @@
+import { Color } from '../primitives.js';
+import Rule from './rule.js';
+export default class CellCountPerZoneRule extends Rule {
+    color;
+    get configExplanation() {
+        return 'Use the zone tool to define areas on the grid.';
+    }
+    /**
+     * @param color - The color of the cells to count.
+     */
+    constructor(color) {
+        super();
+        this.color = color;
+        this.color = color;
+    }
+    getZoneCounts(grid) {
+        let complete = true;
+        const zones = grid.reduceByZone((zone, tile, x, y) => {
+            zone.positions.push({ x, y });
+            if (tile.color === this.color) {
+                zone.completed++;
+            }
+            else if (tile.color === Color.Gray) {
+                zone.possible++;
+                complete = false;
+            }
+            return zone;
+        }, () => ({
+            positions: [],
+            completed: 0,
+            possible: 0,
+        }));
+        return { zones, complete };
+    }
+    withColor(color) {
+        return this.copyWith({ color });
+    }
+}
+export const instance = undefined;

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

@@ -0,0 +1,33 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { Color, RuleState } from '../primitives.js';
+import Rule, { SearchVariant } from './rule.js';
+export default class CellCountRule extends Rule {
+    readonly color: Color;
+    readonly count: number;
+    readonly title = "Total Count";
+    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;