@logic-pad/core 0.26.1 → 0.26.2

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

@@ -1,212 +0,0 @@
-import { ConfigType } from '../config.js';
-import GridData from '../grid.js';
-import { resize } from '../dataHelper.js';
-import { Color, Instrument, MajorRule, State, } from '../primitives.js';
-import CustomIconSymbol from '../symbols/customIconSymbol.js';
-import { ControlLine, Row } from './musicControlLine.js';
-import Rule from './rule.js';
-const DEFAULT_SCALE = [
-    new Row('C5', Instrument.Piano, null),
-    new Row('B4', Instrument.Piano, null),
-    new Row('A4', Instrument.Piano, null),
-    new Row('G4', Instrument.Piano, null),
-    new Row('F4', Instrument.Piano, null),
-    new Row('E4', Instrument.Piano, null),
-    new Row('D4', Instrument.Piano, null),
-    new Row('C4', Instrument.Piano, null),
-];
-export default class MusicGridRule extends Rule {
-    controlLines;
-    track;
-    normalizeVelocity;
-    title = 'Music Grid';
-    get configExplanation() {
-        return 'Solve the grid by listening to the solution being played back.';
-    }
-    static EXAMPLE_GRID = Object.freeze(GridData.create(['.']).addSymbol(new CustomIconSymbol('', GridData.create([]), 0, 0, 'MdMusicNote')));
-    static CONFIGS = Object.freeze([
-        {
-            type: ConfigType.ControlLines,
-            default: [new ControlLine(0, 120, false, false, DEFAULT_SCALE)],
-            field: 'controlLines',
-            description: 'Control Lines',
-            configurable: false,
-        },
-        {
-            type: ConfigType.NullableGrid,
-            default: null,
-            nonNullDefault: GridData.create([
-                'wwwww',
-                'wwwww',
-                'wwwww',
-                'wwwww',
-            ]).addRule(new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALE)], null)),
-            field: 'track',
-            description: 'Track',
-            explanation: 'If set, this grid will be played instead of the solution.',
-            configurable: true,
-        },
-        {
-            type: ConfigType.Boolean,
-            default: true,
-            field: 'normalizeVelocity',
-            description: 'Normalize Velocity',
-            explanation: 'Whether to adjust note velocities by their pitch such that every note has the same perceived loudness.',
-            configurable: true,
-        },
-    ]);
-    static SEARCH_VARIANTS = [
-        new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALE)], null).searchVariant(),
-    ];
-    /**
-     * **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.
-     * @param normalizeVelocity Whether to normalize the velocity of the notes by their pitch such that lower notes are played softer.
-     */
-    constructor(controlLines, track, normalizeVelocity = true) {
-        super();
-        this.controlLines = controlLines;
-        this.track = track;
-        this.normalizeVelocity = normalizeVelocity;
-        this.controlLines = MusicGridRule.deduplicateControlLines(controlLines);
-        this.track = track;
-        this.normalizeVelocity = normalizeVelocity;
-    }
-    get id() {
-        return MajorRule.MusicGrid;
-    }
-    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, _solution) {
-        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, 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, 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, normalizeVelocity, }) {
-        return new MusicGridRule(controlLines ?? this.controlLines, track !== undefined ? track : this.track, normalizeVelocity ?? this.normalizeVelocity);
-    }
-    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 instrument = lines
-                .map(l => l.rows[idx]?.instrument)
-                .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, instrument, 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]);
-    }
-}
-export const instance = new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALE)], null);

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

@@ -1,39 +0,0 @@
-import { AnyConfig } from '../config.js';
-import { FinalValidationHandler } from '../events/onFinalValidation.js';
-import { GridChangeHandler } from '../events/onGridChange.js';
-import { GridResizeHandler } from '../events/onGridResize.js';
-import GridData from '../grid.js';
-import { GridState, RuleState } from '../primitives.js';
-import Rule, { SearchVariant } from './rule.js';
-export default class MysteryRule extends Rule implements FinalValidationHandler, GridChangeHandler, GridResizeHandler {
-    readonly solution: GridData;
-    readonly visible: boolean;
-    readonly title = "Alternate Solution";
-    get configExplanation(): string;
-    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/src/data/rules/mysteryRule.js

@@ -1,146 +0,0 @@
-import { ConfigType } from '../config.js';
-import GridData from '../grid.js';
-import { array } from '../dataHelper.js';
-import { Color, State } from '../primitives.js';
-import CustomTextSymbol from '../symbols/customTextSymbol.js';
-import Rule from './rule.js';
-export default class MysteryRule extends Rule {
-    solution;
-    visible;
-    title = 'Alternate Solution';
-    get configExplanation() {
-        return 'You may use multiple instances of this rule to provide multiple alternate solutions.';
-    }
-    static EXAMPLE_GRID = Object.freeze(GridData.create(['.']).addSymbol(new CustomTextSymbol('', GridData.create([]), 0, 0, '?')));
-    static CONFIGS = Object.freeze([
-        {
-            type: ConfigType.Tile,
-            default: MysteryRule.EXAMPLE_GRID,
-            resizable: false,
-            field: 'solution',
-            description: 'Solution',
-            explanation: 'The alternate solution to the puzzle. Does not need to satisfy puzzle rules / symbols.',
-            configurable: true,
-        },
-        {
-            type: ConfigType.Boolean,
-            default: true,
-            field: 'visible',
-            description: 'Visible',
-            explanation: 'Display this rule to the player.',
-            configurable: true,
-        },
-    ]);
-    static SEARCH_VARIANTS = [
-        new MysteryRule(MysteryRule.EXAMPLE_GRID, true).searchVariant(),
-    ];
-    /**
-     * **Mystery: alternate solution**
-     */
-    constructor(solution, visible) {
-        super();
-        this.solution = solution;
-        this.visible = 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.isSatisfied(state.final))
-            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 GridData.create(baseGrid?.width ?? solution.width, baseGrid?.height ?? solution.height, tiles);
-    }
-}
-export const instance = new MysteryRule(GridData.create([]), true);

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

@@ -1,29 +0,0 @@
-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 NoLoopsRule extends Rule {
-    readonly color: Color;
-    readonly title = "No Loops";
-    private static readonly CONFIGS;
-    private static readonly EXAMPLE_GRID_LIGHT;
-    private static readonly EXAMPLE_GRID_DARK;
-    private static readonly SEARCH_VARIANTS;
-    /**
-     * **No loops in <color> cells**
-     *
-     * @param color - The color of the cells to check.
-     */
-    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;
-    withColor(color: Color): this;
-}
-export declare const instance: NoLoopsRule;

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

@@ -1,218 +0,0 @@
-import { ConfigType } from '../config.js';
-import GridData, { NEIGHBOR_OFFSETS, NEIGHBOR_OFFSETS_8 } from '../grid.js';
-import { array } from '../dataHelper.js';
-import { Color, State } from '../primitives.js';
-import Rule from './rule.js';
-import CustomIconSymbol from '../symbols/customIconSymbol.js';
-export default class NoLoopsRule extends Rule {
-    color;
-    title = 'No Loops';
-    static CONFIGS = Object.freeze([
-        {
-            type: ConfigType.Color,
-            default: Color.Light,
-            allowGray: false,
-            field: 'color',
-            description: 'Color',
-            configurable: true,
-        },
-    ]);
-    static EXAMPLE_GRID_LIGHT = Object.freeze(GridData.create(['bwwwb', 'bwbww', 'wwwwb', 'wbbww']).withSymbols([
-        new CustomIconSymbol('', GridData.create([]), 1, 0, 'MdClear'),
-        new CustomIconSymbol('', GridData.create([]), 2, 0, 'MdClear'),
-        new CustomIconSymbol('', GridData.create([]), 3, 0, 'MdClear'),
-        new CustomIconSymbol('', GridData.create([]), 3, 1, 'MdClear'),
-        new CustomIconSymbol('', GridData.create([]), 3, 2, 'MdClear'),
-        new CustomIconSymbol('', GridData.create([]), 2, 2, 'MdClear'),
-        new CustomIconSymbol('', GridData.create([]), 1, 2, 'MdClear'),
-        new CustomIconSymbol('', GridData.create([]), 1, 1, 'MdClear'),
-    ]));
-    static EXAMPLE_GRID_DARK = Object.freeze(NoLoopsRule.EXAMPLE_GRID_LIGHT.withTiles(tiles => tiles.map(row => row.map(tile => tile.withColor(tile.color === Color.Dark ? Color.Light : Color.Dark)))));
-    static SEARCH_VARIANTS = [
-        new NoLoopsRule(Color.Light).searchVariant(),
-        new NoLoopsRule(Color.Dark).searchVariant(),
-    ];
-    /**
-     * **No loops in <color> cells**
-     *
-     * @param color - The color of the cells to check.
-     */
-    constructor(color) {
-        super();
-        this.color = color;
-        this.color = color;
-    }
-    get id() {
-        return `no_loops`;
-    }
-    get explanation() {
-        return `*No loops* in ${this.color} cells`;
-    }
-    get configs() {
-        return NoLoopsRule.CONFIGS;
-    }
-    createExampleGrid() {
-        return this.color === Color.Light
-            ? NoLoopsRule.EXAMPLE_GRID_LIGHT
-            : NoLoopsRule.EXAMPLE_GRID_DARK;
-    }
-    get searchVariants() {
-        return NoLoopsRule.SEARCH_VARIANTS;
-    }
-    validateGrid(grid) {
-        // wrap-around grids require special consideration because the "islands" assumption of the
-        // algorithm below does not hold
-        if (grid.wrapAround.value) {
-            const visited = array(grid.width, grid.height, (i, j) => {
-                const tile = grid.getTile(i, j);
-                return (!tile.exists ||
-                    (tile.color !== this.color && tile.color !== Color.Gray));
-            });
-            while (true) {
-                const seed = grid.find((tile, x, y) => !visited[y][x] && tile.color === this.color);
-                if (!seed)
-                    break;
-                let invalid = false;
-                const positions = [];
-                const stack = [[seed, null]];
-                while (stack.length > 0) {
-                    const [{ x, y }, from] = stack.pop();
-                    const { x: arrX, y: arrY } = grid.toArrayCoordinates(x, y);
-                    positions.push({ x: arrX, y: arrY });
-                    if (visited[arrY][arrX]) {
-                        invalid = true;
-                        continue;
-                    }
-                    visited[arrY][arrX] = true;
-                    for (const offset of NEIGHBOR_OFFSETS) {
-                        if (-offset.x === from?.x && -offset.y === from?.y)
-                            continue;
-                        const next = { x: x + offset.x, y: y + offset.y };
-                        if (grid.isPositionValid(next.x, next.y)) {
-                            const nextTile = grid.getTile(next.x, next.y);
-                            if (nextTile.exists && nextTile.color === this.color)
-                                stack.push([next, offset]);
-                        }
-                    }
-                }
-                if (invalid) {
-                    return {
-                        state: State.Error,
-                        positions,
-                    };
-                }
-            }
-            return {
-                state: visited.some(row => row.some(v => !v))
-                    ? State.Incomplete
-                    : State.Satisfied,
-            };
-        }
-        // special handling for 2x2 loops
-        for (let y = 0; y < grid.height; y++) {
-            for (let x = 0; x < grid.width; x++) {
-                const tlTile = grid.getTile(x, y);
-                const trTile = grid.getTile(x + 1, y);
-                const blTile = grid.getTile(x, y + 1);
-                const brTile = grid.getTile(x + 1, y + 1);
-                if (tlTile.exists &&
-                    tlTile.color === this.color &&
-                    trTile.exists &&
-                    trTile.color === this.color &&
-                    blTile.exists &&
-                    blTile.color === this.color &&
-                    brTile.exists &&
-                    brTile.color === this.color) {
-                    const positions = [
-                        grid.toArrayCoordinates(x, y),
-                        grid.toArrayCoordinates(x + 1, y),
-                        grid.toArrayCoordinates(x, y + 1),
-                        grid.toArrayCoordinates(x + 1, y + 1),
-                    ];
-                    return {
-                        state: State.Error,
-                        positions,
-                    };
-                }
-            }
-        }
-        // general case for non-wrap-around grids: a loop must form an elcosed island that does not touch the grid edge
-        const visited = array(grid.width, grid.height, (i, j) => {
-            const tile = grid.getTile(i, j);
-            return tile.exists && tile.color === this.color;
-        });
-        const shape = array(grid.width, grid.height, () => false);
-        let complete = true;
-        while (true) {
-            const seed = grid.find((tile, x, y) => !visited[y][x] && (!tile.exists || tile.color !== this.color));
-            shape.forEach(row => row.fill(false));
-            if (!seed)
-                break;
-            let isIsland = true;
-            const stack = [seed];
-            while (stack.length > 0) {
-                const { x, y } = stack.pop();
-                const { x: arrX, y: arrY } = grid.toArrayCoordinates(x, y);
-                const tile = grid.getTile(x, y);
-                if (tile.exists && tile.color === Color.Gray) {
-                    complete = false;
-                }
-                if (visited[arrY][arrX]) {
-                    continue;
-                }
-                visited[arrY][arrX] = true;
-                for (const offset of NEIGHBOR_OFFSETS_8) {
-                    const next = { x: x + offset.x, y: y + offset.y };
-                    const arrPos = grid.toArrayCoordinates(next.x, next.y);
-                    if (grid.isPositionValid(next.x, next.y)) {
-                        const nextTile = grid.getTile(next.x, next.y);
-                        shape[arrPos.y][arrPos.x] = true;
-                        if (!nextTile.exists || nextTile.color !== this.color) {
-                            stack.push(arrPos);
-                        }
-                    }
-                    else {
-                        isIsland = false;
-                    }
-                }
-            }
-            if (isIsland) {
-                const loopPositions = [];
-                for (let y = 0; y < grid.height; y++) {
-                    for (let x = 0; x < grid.width; x++) {
-                        if (shape[y][x]) {
-                            if (x > 0 &&
-                                y > 0 &&
-                                x < grid.width - 1 &&
-                                y < grid.height - 1 &&
-                                shape[y][x - 1] &&
-                                shape[y - 1][x] &&
-                                shape[y][x + 1] &&
-                                shape[y + 1][x] &&
-                                shape[y - 1][x - 1] &&
-                                shape[y - 1][x + 1] &&
-                                shape[y + 1][x - 1] &&
-                                shape[y + 1][x + 1])
-                                continue;
-                            loopPositions.push({ x, y });
-                        }
-                    }
-                }
-                return {
-                    state: State.Error,
-                    positions: loopPositions,
-                };
-            }
-        }
-        return {
-            state: complete ? State.Satisfied : State.Incomplete,
-        };
-    }
-    copyWith({ color }) {
-        return new NoLoopsRule(color ?? this.color);
-    }
-    withColor(color) {
-        return this.copyWith({ color });
-    }
-}
-export const instance = new NoLoopsRule(Color.Dark);

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

@@ -1,32 +0,0 @@
-import { AnyConfig } from '../config.js';
-import { SymbolValidationHandler } from '../events/onSymbolValidation.js';
-import GridData from '../grid.js';
-import { RuleState, State } from '../primitives.js';
-import Symbol from '../symbols/symbol.js';
-import Rule, { SearchVariant } from './rule.js';
-export default class OffByXRule extends Rule implements SymbolValidationHandler {
-    readonly number: number;
-    readonly title = "Off By X";
-    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;
-    get isSingleton(): boolean;
-    copyWith({ number }: {
-        number?: number;
-    }): this;
-    withNumber(number: number): this;
-}
-export declare const instance: OffByXRule;