@logic-pad/core 0.1.0

package/dist/data/rules/musicGridRule.js

@@ -0,0 +1,211 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { resize } from '../dataHelper';
+import { Color, State } from '../primitives';
+import CustomIconSymbol from '../symbols/customIconSymbol';
+import { ControlLine, Row } from './musicControlLine';
+import Rule from './rule';
+const DEFAULT_SCALLE = [
+    new Row('C5', 0.6),
+    new Row('B4', 0.6),
+    new Row('A4', 0.6),
+    new Row('G4', 0.6),
+    new Row('F4', 0.6),
+    new Row('E4', 0.6),
+    new Row('D4', 0.6),
+    new Row('C4', 0.6),
+];
+class MusicGridRule extends Rule {
+    /**
+     * **Music Grid: Listen to the solution**
+     * @param controlLines Denote changes in the playback settings. At least one control line at column 0 should be present to enable playback.
+     * @param track The grid to be played when "listen" is clicked. Set as null to play the solution.
+     */
+    constructor(controlLines, track) {
+        super();
+        Object.defineProperty(this, "controlLines", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: controlLines
+        });
+        Object.defineProperty(this, "track", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: track
+        });
+        this.controlLines = MusicGridRule.deduplicateControlLines(controlLines);
+        this.track = track;
+    }
+    get id() {
+        return `music`;
+    }
+    get explanation() {
+        return `*Music Grid:* Listen to the solution`;
+    }
+    get configs() {
+        return MusicGridRule.CONFIGS;
+    }
+    createExampleGrid() {
+        return MusicGridRule.EXAMPLE_GRID;
+    }
+    get searchVariants() {
+        return MusicGridRule.SEARCH_VARIANTS;
+    }
+    validateGrid(_grid) {
+        return { state: State.Incomplete };
+    }
+    onSetGrid(_oldGrid, newGrid) {
+        if (newGrid.getTileCount(true, undefined, Color.Gray) === 0)
+            return newGrid;
+        const tiles = newGrid.tiles.map(row => row.map(tile => tile.color === Color.Gray ? tile.withColor(Color.Light) : tile));
+        return newGrid.copyWith({ tiles });
+    }
+    onGridChange(newGrid) {
+        if (this.controlLines.length === 0)
+            return this;
+        if (newGrid.height === this.controlLines[0].rows.length &&
+            !this.controlLines.some(line => line.column >= newGrid.width))
+            return this;
+        const controlLines = this.controlLines
+            .filter(line => line.column < newGrid.width)
+            .map(line => line.withRows(resize(line.rows, newGrid.height, () => new Row(null, null))));
+        return this.copyWith({ controlLines });
+    }
+    onGridResize(_grid, mode, direction, index) {
+        if (mode === 'insert') {
+            if (direction === 'row') {
+                return this.copyWith({
+                    controlLines: this.controlLines.map(line => {
+                        const rows = line.rows.slice();
+                        rows.splice(index, 0, new Row(null, null));
+                        return line.withRows(rows);
+                    }),
+                });
+            }
+            else if (direction === 'column') {
+                return this.copyWith({
+                    controlLines: this.controlLines.map(line => line.column >= index ? line.withColumn(line.column + 1) : line),
+                });
+            }
+        }
+        else if (mode === 'remove') {
+            if (direction === 'row') {
+                return this.copyWith({
+                    controlLines: this.controlLines.map(line => line.withRows(line.rows.filter((_, idx) => idx !== index))),
+                });
+            }
+            else if (direction === 'column') {
+                const lines = [];
+                for (const line of this.controlLines) {
+                    if (line.column === index) {
+                        const nextLine = this.controlLines.find(l => l.column === index + 1);
+                        if (nextLine) {
+                            lines.push(MusicGridRule.mergeControlLines(line, nextLine));
+                        }
+                        else {
+                            lines.push(line.withColumn(index));
+                        }
+                    }
+                    else if (line.column > index) {
+                        lines.push(line.withColumn(line.column - 1));
+                    }
+                    else {
+                        lines.push(line);
+                    }
+                }
+                return this.copyWith({ controlLines: lines });
+            }
+        }
+        return this;
+    }
+    /**
+     * Add or replace a control line.
+     * @param controlLine The control line to set.
+     * @returns A new rule with the control line set.
+     */
+    setControlLine(controlLine) {
+        const controlLines = this.controlLines.filter(line => line.column !== controlLine.column);
+        return this.copyWith({
+            controlLines: [...controlLines, controlLine].sort((a, b) => a.column - b.column),
+        });
+    }
+    withTrack(track) {
+        return this.copyWith({ track });
+    }
+    copyWith({ controlLines, track, }) {
+        return new MusicGridRule(controlLines ?? this.controlLines, track !== undefined ? track : this.track);
+    }
+    get validateWithSolution() {
+        return true;
+    }
+    get isSingleton() {
+        return true;
+    }
+    static mergeControlLines(...lines) {
+        const rows = Array.from({ length: Math.max(...lines.map(l => l.rows.length)) }, (_, idx) => {
+            const note = lines
+                .map(l => l.rows[idx]?.note)
+                .reduce((a, b) => b ?? a, null);
+            const velocity = lines
+                .map(l => l.rows[idx]?.velocity)
+                .reduce((a, b) => b ?? a, null);
+            return new Row(note, velocity);
+        });
+        const bpm = lines.map(l => l.bpm).reduce((a, b) => b ?? a, null);
+        const pedal = lines.map(l => l.pedal).reduce((a, b) => b ?? a, null);
+        const checkpoint = lines.some(l => l.checkpoint);
+        return new ControlLine(lines[0].column, bpm, pedal, checkpoint, rows);
+    }
+    static deduplicateControlLines(lines) {
+        const columns = new Map();
+        for (const line of lines) {
+            if (!columns.has(line.column)) {
+                columns.set(line.column, [line]);
+            }
+            else {
+                columns.get(line.column).push(line);
+            }
+        }
+        return Array.from(columns.values()).map(lines => lines.length > 1 ? MusicGridRule.mergeControlLines(...lines) : lines[0]);
+    }
+}
+Object.defineProperty(MusicGridRule, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['.']).addSymbol(new CustomIconSymbol('', GridData.create([]), 0, 0, 'MdMusicNote')))
+});
+Object.defineProperty(MusicGridRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.ControlLines,
+            default: [new ControlLine(0, 120, false, false, DEFAULT_SCALLE)],
+            field: 'controlLines',
+            description: 'Control Lines',
+            configurable: false,
+        },
+        {
+            type: ConfigType.NullableGrid,
+            default: null,
+            nonNullDefault: new GridData(5, 4).addRule(new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALLE)], null)),
+            field: 'track',
+            description: 'Track',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(MusicGridRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALLE)], null).searchVariant(),
+    ]
+});
+export default MusicGridRule;
+export const instance = new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALLE)], null);

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

@@ -0,0 +1,37 @@
+import { AnyConfig } from '../config';
+import { FinalValidationHandler } from '../events/onFinalValidation';
+import { GridChangeHandler } from '../events/onGridChange';
+import { GridResizeHandler } from '../events/onGridResize';
+import GridData from '../grid';
+import { GridState, RuleState } from '../primitives';
+import Rule, { SearchVariant } from './rule';
+export default class MysteryRule extends Rule implements FinalValidationHandler, GridChangeHandler, GridResizeHandler {
+    readonly solution: GridData;
+    readonly visible: boolean;
+    private static readonly EXAMPLE_GRID;
+    private static readonly CONFIGS;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Mystery: alternate solution**
+     */
+    constructor(solution: GridData, visible: boolean);
+    get id(): string;
+    get explanation(): string;
+    get visibleWhenSolving(): boolean;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    get necessaryForCompletion(): boolean;
+    onFinalValidation(grid: GridData, _solution: GridData | null, state: GridState): GridState;
+    onGridChange(newGrid: GridData): this;
+    onGridResize(_grid: GridData, mode: 'insert' | 'remove', direction: 'row' | 'column', index: number): this | null;
+    copyWith({ solution, visible, }: {
+        solution?: GridData;
+        visible?: boolean;
+    }): this;
+    withSolution(solution: GridData): this;
+    withVisible(visible: boolean): this;
+    static cleanSolution(solution: GridData, baseGrid?: GridData): GridData;
+}
+export declare const instance: MysteryRule;

package/dist/data/rules/mysteryRule.js

@@ -0,0 +1,164 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { array } from '../dataHelper';
+import { Color, State } from '../primitives';
+import CustomTextSymbol from '../symbols/customTextSymbol';
+import Rule from './rule';
+class MysteryRule extends Rule {
+    /**
+     * **Mystery: alternate solution**
+     */
+    constructor(solution, visible) {
+        super();
+        Object.defineProperty(this, "solution", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: solution
+        });
+        Object.defineProperty(this, "visible", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: visible
+        });
+        this.solution = MysteryRule.cleanSolution(solution);
+        this.visible = visible;
+    }
+    get id() {
+        return `mystery`;
+    }
+    get explanation() {
+        return `*Mystery:* Alternate solution`;
+    }
+    get visibleWhenSolving() {
+        return this.visible;
+    }
+    get configs() {
+        return MysteryRule.CONFIGS;
+    }
+    createExampleGrid() {
+        return MysteryRule.EXAMPLE_GRID;
+    }
+    get searchVariants() {
+        return MysteryRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        if (grid.colorEquals(this.solution))
+            return { state: State.Satisfied };
+        return { state: State.Incomplete };
+    }
+    get necessaryForCompletion() {
+        return false;
+    }
+    onFinalValidation(grid, _solution, state) {
+        if (state.final === State.Satisfied)
+            return state;
+        if (grid.colorEquals(this.solution))
+            return {
+                final: State.Satisfied,
+                symbols: state.symbols,
+                rules: state.rules,
+            };
+        return state;
+    }
+    onGridChange(newGrid) {
+        if (newGrid.width === this.solution.width &&
+            newGrid.height === this.solution.height) {
+            if (!newGrid.tiles.some((row, y) => row.some((tile, x) => {
+                const solutionTile = this.solution.getTile(x, y);
+                if (solutionTile.exists !== tile.exists)
+                    return true;
+                if (solutionTile.fixed !== tile.fixed)
+                    return true;
+                if (solutionTile.exists &&
+                    solutionTile.fixed &&
+                    solutionTile.color !== tile.color)
+                    return true;
+                return false;
+            })))
+                return this;
+        }
+        return this.withSolution(MysteryRule.cleanSolution(this.solution, newGrid));
+    }
+    onGridResize(_grid, mode, direction, index) {
+        if (mode === 'insert') {
+            if (direction === 'row') {
+                return this.withSolution(this.solution.insertRow(index));
+            }
+            else if (direction === 'column') {
+                return this.withSolution(this.solution.insertColumn(index));
+            }
+        }
+        else if (mode === 'remove') {
+            if (direction === 'row') {
+                return this.withSolution(this.solution.removeRow(index));
+            }
+            else if (direction === 'column') {
+                return this.withSolution(this.solution.removeColumn(index));
+            }
+        }
+        return this;
+    }
+    copyWith({ solution, visible, }) {
+        return new MysteryRule(solution ?? this.solution, visible ?? this.visible);
+    }
+    withSolution(solution) {
+        return this.copyWith({ solution });
+    }
+    withVisible(visible) {
+        return this.copyWith({ visible });
+    }
+    static cleanSolution(solution, baseGrid) {
+        const tiles = baseGrid
+            ? array(baseGrid.width, baseGrid.height, (x, y) => {
+                const tile = baseGrid.getTile(x, y);
+                if (!tile.exists || tile.fixed)
+                    return tile;
+                const solutionTile = solution.getTile(x, y);
+                if (!solutionTile.exists || solutionTile.color === Color.Gray)
+                    return tile;
+                return tile.withColor(solutionTile.color);
+            })
+            : solution.tiles;
+        return new GridData(baseGrid?.width ?? solution.width, baseGrid?.height ?? solution.height, tiles);
+    }
+}
+Object.defineProperty(MysteryRule, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['.']).addSymbol(new CustomTextSymbol('', GridData.create([]), 0, 0, '?')))
+});
+Object.defineProperty(MysteryRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Tile,
+            default: MysteryRule.EXAMPLE_GRID,
+            resizable: false,
+            field: 'solution',
+            description: 'Solution',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Boolean,
+            default: true,
+            field: 'visible',
+            description: 'Visible',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(MysteryRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new MysteryRule(MysteryRule.EXAMPLE_GRID, true).searchVariant(),
+    ]
+});
+export default MysteryRule;
+export const instance = new MysteryRule(GridData.create([]), true);

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

@@ -0,0 +1,30 @@
+import { AnyConfig } from '../config';
+import { SymbolValidationHandler } from '../events/onSymbolValidation';
+import GridData from '../grid';
+import { RuleState, State } from '../primitives';
+import Symbol from '../symbols/symbol';
+import Rule, { SearchVariant } from './rule';
+export default class OffByXRule extends Rule implements SymbolValidationHandler {
+    readonly number: number;
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **All numbers are off by <number>**
+     *
+     * @param number - The number that all cells are off by.
+     */
+    constructor(number: number);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(_grid: GridData): RuleState;
+    onSymbolValidation(grid: GridData, symbol: Symbol, _validator: (grid: GridData) => State): State | undefined;
+    copyWith({ number }: {
+        number?: number;
+    }): this;
+    withNumber(number: number): this;
+}
+export declare const instance: OffByXRule;

package/dist/data/rules/offByXRule.js

@@ -0,0 +1,134 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { State } from '../primitives';
+import AreaNumberSymbol from '../symbols/areaNumberSymbol';
+import NumberSymbol from '../symbols/numberSymbol';
+import Rule from './rule';
+class OffByXRule extends Rule {
+    /**
+     * **All numbers are off by <number>**
+     *
+     * @param number - The number that all cells are off by.
+     */
+    constructor(number) {
+        super();
+        Object.defineProperty(this, "number", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: number
+        });
+        this.number = number;
+    }
+    get id() {
+        return `off_by_x`;
+    }
+    get explanation() {
+        return `All numbers are off by ${this.number}`;
+    }
+    get configs() {
+        return OffByXRule.CONFIGS;
+    }
+    createExampleGrid() {
+        if (this.number < 1 || this.number >= OffByXRule.EXAMPLE_GRID.length) {
+            return GridData.create(['bbbbb', 'bbwbb', 'bbbbb', 'bbbbb']).addSymbol(new AreaNumberSymbol(2, 1, this.number + 1));
+        }
+        return OffByXRule.EXAMPLE_GRID[this.number - 1];
+    }
+    get searchVariants() {
+        return OffByXRule.SEARCH_VARIANTS;
+    }
+    validateGrid(_grid) {
+        return { state: State.Incomplete };
+    }
+    onSymbolValidation(grid, symbol, _validator) {
+        if (symbol instanceof NumberSymbol) {
+            const counts = symbol.countTiles(grid);
+            if (counts.completed > symbol.number + this.number ||
+                counts.possible < symbol.number - this.number ||
+                (counts.completed > symbol.number - this.number &&
+                    counts.possible < symbol.number + this.number)) {
+                return State.Error;
+            }
+            else if ((counts.completed === symbol.number + this.number ||
+                counts.completed === symbol.number - this.number) &&
+                counts.completed === counts.possible) {
+                return State.Satisfied;
+            }
+            else {
+                return State.Incomplete;
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    copyWith({ number }) {
+        return new OffByXRule(number ?? this.number);
+    }
+    withNumber(number) {
+        return this.copyWith({ number });
+    }
+}
+Object.defineProperty(OffByXRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Number,
+            default: 1,
+            min: 1,
+            field: 'number',
+            description: 'Number',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(OffByXRule, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        GridData.create(['bbbbb', 'bwbwb', 'bbwwb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 1, 2),
+            new AreaNumberSymbol(3, 2, 2),
+        ]),
+        GridData.create(['bbbbb', 'bwbwb', 'bbbwb', 'bwwwb']).withSymbols([
+            new AreaNumberSymbol(1, 1, 3),
+            new AreaNumberSymbol(3, 3, 3),
+        ]),
+        GridData.create(['bbbbw', 'bwbbw', 'bbbbw', 'bwwww']).withSymbols([
+            new AreaNumberSymbol(1, 1, 4),
+            new AreaNumberSymbol(4, 3, 4),
+        ]),
+        GridData.create(['bbbbw', 'bwbbw', 'bbbww', 'wwwww']).withSymbols([
+            new AreaNumberSymbol(1, 1, 5),
+            new AreaNumberSymbol(4, 3, 5),
+        ]),
+        GridData.create(['bbbww', 'bwbww', 'bbbww', 'wwwww']).withSymbols([
+            new AreaNumberSymbol(1, 1, 6),
+            new AreaNumberSymbol(4, 3, 6),
+        ]),
+        GridData.create(['wbbww', 'bbwww', 'bbwww', 'wwwww']).withSymbols([
+            new AreaNumberSymbol(0, 0, 7),
+            new AreaNumberSymbol(4, 3, 7),
+        ]),
+        GridData.create(['wbbww', 'bwwww', 'bwwww', 'wwwww']).withSymbols([
+            new AreaNumberSymbol(0, 0, 8),
+            new AreaNumberSymbol(4, 3, 8),
+        ]),
+        GridData.create(['wbwww', 'bwwww', 'wwwww', 'wwwww']).withSymbols([
+            new AreaNumberSymbol(0, 0, 9),
+            new AreaNumberSymbol(4, 3, 9),
+        ]),
+    ])
+});
+Object.defineProperty(OffByXRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [new OffByXRule(1).searchVariant()]
+});
+export default OffByXRule;
+export const instance = new OffByXRule(1);

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

@@ -0,0 +1,33 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { Color, RuleState } from '../primitives';
+import Rule, { SearchVariant } from './rule';
+export default class RegionAreaRule extends Rule {
+    readonly color: Color;
+    readonly size: number;
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_GRAY;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **All <color> regions have area <size>**
+     *
+     * @param color - The color of the regions.
+     * @param size - The area of the regions.
+     */
+    constructor(color: Color, size: number);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ color, size }: {
+        color?: Color;
+        size?: number;
+    }): this;
+    withColor(color: Color): this;
+    withSize(size: number): this;
+}
+export declare const instance: RegionAreaRule;