@fgv/ts-sudoku-lib 2.0.2-alpha.0

package/lib/packlets/common/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../../../src/packlets/common/model.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG","sourcesContent":["/*\n * MIT License\n *\n * Copyright (c) 2023 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { PuzzleType } from './common';\n\n/**\n * Description of a single puzzle.\n * @public\n */\nexport interface IPuzzleDescription {\n  id?: string;\n  description: string;\n  type: PuzzleType;\n  level: number;\n  rows: number;\n  cols: number;\n  cells: string;\n}\n"]}

package/lib/packlets/common/public.d.ts

@@ -0,0 +1,65 @@
+import { CageId, CageType, CellId } from './common';
+/**
+ * Describes the structure of a single cage in a {@link PuzzleSession | puzzle}.
+ * Does not describe state.
+ * @public
+ */
+export interface ICage {
+    /**
+     * Unique identifier for the cage.
+     */
+    readonly id: CageId;
+    /**
+     * The {@link CageType | type} of the cage.
+     */
+    readonly cageType: CageType;
+    /**
+     * The expected sum of all cells in the cage.
+     */
+    readonly total: number;
+    /**
+     * The number of cells in the cage.
+     */
+    readonly numCells: number;
+    /**
+     * The identity of each cell in the cage.
+     */
+    readonly cellIds: CellId[];
+    /**
+     * Determines if a supplied cell is present in the cage.
+     * @param id - the identifier to be searched.
+     */
+    containsCell(id: CellId): boolean;
+}
+/**
+ * Describes the structure of a single cell in a {@link PuzzleSession | puzzle}.
+ * Does not describe state.
+ * @public
+ */
+export interface ICell {
+    /**
+     * Unique identifier for the cell.
+     */
+    readonly id: CellId;
+    /**
+     * Row number of the cell.
+     */
+    readonly row: number;
+    /**
+     * Column number of the cell.
+     */
+    readonly col: number;
+    /**
+     * All of the {@Link ICage | cages} to which this cell belongs.
+     */
+    readonly cages: readonly ICage[];
+    /**
+     * Indicates whether this cell is a given value (immutable).
+     */
+    readonly immutable: boolean;
+    /**
+     * Given value of this cell, or `undefined` if the cell is not immutable.
+     */
+    readonly immutableValue?: number;
+}
+//# sourceMappingURL=public.d.ts.map

package/lib/packlets/common/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../src/packlets/common/public.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEpD;;;;GAIG;AACH,MAAM,WAAW,KAAK;IACpB;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAE5B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAE3B;;;OAGG;IACH,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;CACnC;AAED;;;;GAIG;AACH,MAAM,WAAW,KAAK;IACpB;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,KAAK,EAAE,CAAC;IAEjC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B;;OAEG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC"}

package/lib/packlets/common/public.js

@@ -0,0 +1,26 @@
+"use strict";
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=public.js.map

package/lib/packlets/common/public.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.js","sourceRoot":"","sources":["../../../src/packlets/common/public.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG","sourcesContent":["/*\n * MIT License\n *\n * Copyright (c) 2023 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { CageId, CageType, CellId } from './common';\n\n/**\n * Describes the structure of a single cage in a {@link PuzzleSession | puzzle}.\n * Does not describe state.\n * @public\n */\nexport interface ICage {\n  /**\n   * Unique identifier for the cage.\n   */\n  readonly id: CageId;\n\n  /**\n   * The {@link CageType | type} of the cage.\n   */\n  readonly cageType: CageType;\n\n  /**\n   * The expected sum of all cells in the cage.\n   */\n  readonly total: number;\n\n  /**\n   * The number of cells in the cage.\n   */\n  readonly numCells: number;\n\n  /**\n   * The identity of each cell in the cage.\n   */\n  readonly cellIds: CellId[];\n\n  /**\n   * Determines if a supplied cell is present in the cage.\n   * @param id - the identifier to be searched.\n   */\n  containsCell(id: CellId): boolean;\n}\n\n/**\n * Describes the structure of a single cell in a {@link PuzzleSession | puzzle}.\n * Does not describe state.\n * @public\n */\nexport interface ICell {\n  /**\n   * Unique identifier for the cell.\n   */\n  readonly id: CellId;\n\n  /**\n   * Row number of the cell.\n   */\n  readonly row: number;\n\n  /**\n   * Column number of the cell.\n   */\n  readonly col: number;\n\n  /**\n   * All of the {@Link ICage | cages} to which this cell belongs.\n   */\n  readonly cages: readonly ICage[];\n\n  /**\n   * Indicates whether this cell is a given value (immutable).\n   */\n  readonly immutable: boolean;\n\n  /**\n   * Given value of this cell, or `undefined` if the cell is not immutable.\n   */\n  readonly immutableValue?: number;\n}\n"]}

package/lib/packlets/common/puzzle.d.ts

@@ -0,0 +1,99 @@
+import { Result } from '@fgv/ts-utils';
+import { CageId, CellId, ICellContents, ICellState, IRowColumn, NavigationDirection, NavigationWrap } from './common';
+import { Cage } from './cage';
+import { Cell } from './cell';
+import { IPuzzleDescription } from './model';
+import { ICell } from './public';
+import { PuzzleState } from './puzzleState';
+/**
+ * @internal
+ */
+export interface ICellUpdate {
+    from: ICellState;
+    to: ICellState;
+}
+/**
+ * @internal
+ */
+export interface IPuzzleUpdate {
+    from: PuzzleState;
+    to: PuzzleState;
+    cells: ICellUpdate[];
+}
+/**
+ * @internal
+ */
+export declare class Puzzle {
+    readonly id?: string;
+    readonly description: string;
+    readonly initialState: PuzzleState;
+    /**
+     * @internal
+     */
+    protected readonly _rows: Map<CageId, Cage>;
+    /**
+     * @internal
+     */
+    protected readonly _columns: Map<CageId, Cage>;
+    /**
+     * @internal
+     */
+    protected readonly _sections: Map<CageId, Cage>;
+    /**
+     * @internal
+     */
+    protected readonly _cages: Map<CageId, Cage>;
+    /**
+     * @internal
+     */
+    protected readonly _cells: Map<CellId, Cell>;
+    /**
+     * Constructs a new puzzle state.
+     * @param puzzle - {@Link Data.Model.PuzzleDescription | Puzzle description} from which this puzzle state
+     * is to be initialized.
+     */
+    protected constructor(puzzle: IPuzzleDescription, extraCages?: [CageId, Cage][]);
+    get numRows(): number;
+    get numColumns(): number;
+    get rows(): Cage[];
+    get cols(): Cage[];
+    get sections(): Cage[];
+    get cages(): Cage[];
+    get cells(): Cell[];
+    /**
+     * @internal
+     */
+    protected static _createRowCages(numRows: number, numCols: number): Result<[CageId, Cage][]>;
+    /**
+     * @internal
+     */
+    protected static _createColumnCages(numRows: number, numCols: number): Result<[CageId, Cage][]>;
+    /**
+     * @internal
+     */
+    private static _createSectionCages;
+    checkIsSolved(state: PuzzleState): boolean;
+    checkIsValid(state: PuzzleState): boolean;
+    getEmptyCells(state: PuzzleState): Cell[];
+    getInvalidCells(state: PuzzleState): Cell[];
+    getCellContents(spec: string | IRowColumn, state: PuzzleState): Result<{
+        cell: Cell;
+        contents: ICellContents;
+    }>;
+    getCell(spec: string | IRowColumn | ICell): Result<Cell>;
+    getCellNeighbor(spec: string | IRowColumn | ICell, direction: NavigationDirection, wrap: NavigationWrap): Result<ICell>;
+    updateContents(wantUpdates: ICellState[] | ICellState, state: PuzzleState): Result<IPuzzleUpdate>;
+    updateValues(wantUpdates: ICellState[] | ICellState, state: PuzzleState): Result<IPuzzleUpdate>;
+    updateNotes(wantUpdates: ICellState[] | ICellState, state: PuzzleState): Result<IPuzzleUpdate>;
+    updateCellValue(want: string | IRowColumn, value: number | undefined, state: PuzzleState): Result<IPuzzleUpdate>;
+    updateCellNotes(want: string | IRowColumn, notes: number[], state: PuzzleState): Result<IPuzzleUpdate>;
+    getRow(row: CageId | number): Result<Cage>;
+    getColumn(col: CageId | number): Result<Cage>;
+    getSection(spec: CageId | IRowColumn): Result<Cage>;
+    getCage(id: CageId): Result<Cage>;
+    toStrings(state: PuzzleState): string[];
+    toString(state: PuzzleState): string;
+    private _moveColumn;
+    private _moveRow;
+}
+//# sourceMappingURL=puzzle.d.ts.map

package/lib/packlets/common/puzzle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"puzzle.d.ts","sourceRoot":"","sources":["../../../src/packlets/common/puzzle.ts"],"names":[],"mappings":"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"}

package/lib/packlets/common/puzzle.js

@@ -0,0 +1,389 @@
+"use strict";
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Puzzle = void 0;
+const ts_utils_1 = require("@fgv/ts-utils");
+const cage_1 = require("./cage");
+const cell_1 = require("./cell");
+const ids_1 = require("./ids");
+const puzzleState_1 = require("./puzzleState");
+const basicCageTotal = 45;
+/**
+ * @internal
+ */
+class Puzzle {
+    /**
+     * Constructs a new puzzle state.
+     * @param puzzle - {@Link Data.Model.PuzzleDescription | Puzzle description} from which this puzzle state
+     * is to be initialized.
+     */
+    constructor(puzzle, extraCages) {
+        /* c8 ignore next - ?? is defense in depth */
+        extraCages = extraCages !== null && extraCages !== void 0 ? extraCages : [];
+        if (puzzle.rows !== 9) {
+            throw new Error(`Puzzle '${puzzle.description}' unsupported row count ${puzzle.rows}`);
+        }
+        if (puzzle.cols !== 9) {
+            throw new Error(`Puzzle '${puzzle.description}' unsupported column count ${puzzle.cols}`);
+        }
+        if (puzzle.cells.length !== puzzle.rows * puzzle.cols) {
+            throw new Error(`Puzzle '${puzzle.description}" expected ${puzzle.rows * puzzle.cols} cells, found ${puzzle.cells.length}`);
+        }
+        this.id = puzzle.id;
+        this.description = puzzle.description;
+        const rows = Puzzle._createRowCages(puzzle.rows, puzzle.cols).orThrow();
+        const columns = Puzzle._createColumnCages(puzzle.rows, puzzle.cols).orThrow();
+        const sections = Puzzle._createSectionCages(puzzle.rows, puzzle.cols).orThrow();
+        const cages = [...rows, ...columns, ...sections, ...extraCages];
+        this._rows = new Map(rows);
+        this._columns = new Map(columns);
+        this._sections = new Map(sections);
+        this._cages = new Map(cages);
+        this._cells = new Map();
+        const cellInit = [...puzzle.cells];
+        for (let row = 0; row < this._rows.size; row++) {
+            const rowCage = this.getRow(row).orThrow();
+            for (let col = 0; col < this._columns.size; col++) {
+                const id = ids_1.Ids.cellId({ row, col }).orThrow();
+                const colCage = this.getColumn(col).orThrow();
+                const sectionCage = this.getSection({ row, col }).orThrow();
+                const otherCages = extraCages.filter(([__key, cage]) => cage.containsCell(id));
+                const init = cellInit.shift();
+                /* c8 ignore next - defense in depth/make type check happy. undefined init should never happen */
+                const immutableValue = init === '.' ? undefined : Number.parseInt(init !== null && init !== void 0 ? init : '0');
+                if (immutableValue !== undefined &&
+                    (Number.isNaN(immutableValue) || immutableValue < 1 || immutableValue > 9)) {
+                    throw new Error(`Puzzle ${puzzle.description} illegal value "${init}" for cell ${id}`);
+                }
+                const cages = [rowCage, colCage, sectionCage, ...otherCages.map(([__key, state]) => state)];
+                const cell = new cell_1.Cell({ id, immutableValue, row, col }, cages);
+                this._cells.set(id, cell);
+            }
+        }
+        this.initialState = puzzleState_1.PuzzleState.create(Array.from(this._cells.entries()).map(([id, state]) => {
+            return { id, value: state.immutableValue, notes: [] };
+        })).orThrow();
+    }
+    get numRows() {
+        return this._rows.size;
+    }
+    get numColumns() {
+        return this._columns.size;
+    }
+    get rows() {
+        return Array.from(this._rows.values());
+    }
+    get cols() {
+        return Array.from(this._columns.values());
+    }
+    get sections() {
+        return Array.from(this._sections.values());
+    }
+    get cages() {
+        return Array.from(this._cages.values());
+    }
+    get cells() {
+        return Array.from(this._cells.values());
+    }
+    /**
+     * @internal
+     */
+    static _createRowCages(numRows, numCols) {
+        const cages = [];
+        for (let r = 0; r < numRows; r++) {
+            const id = ids_1.Ids.rowCageId(r);
+            const cellIds = ids_1.Ids.cellIds(r, 1, 0, numCols);
+            /* c8 ignore next 3 - defense in depth should never happen */
+            if (cellIds.isFailure()) {
+                return (0, ts_utils_1.fail)(cellIds.message);
+            }
+            const result = cage_1.Cage.create(id, 'row', basicCageTotal, cellIds.value).onSuccess((cage) => {
+                cages.push([id, cage]);
+                return (0, ts_utils_1.succeed)(cage);
+            });
+            /* c8 ignore next 3 - defense in depth should never happen */
+            if (result.isFailure()) {
+                return (0, ts_utils_1.fail)(result.message);
+            }
+        }
+        return (0, ts_utils_1.succeed)(cages);
+    }
+    /**
+     * @internal
+     */
+    static _createColumnCages(numRows, numCols) {
+        const cages = [];
+        for (let c = 0; c < numCols; c++) {
+            const id = ids_1.Ids.columnCageId(c);
+            const cellIds = ids_1.Ids.cellIds(0, numRows, c, 1);
+            /* c8 ignore next 3 - defense in depth should never happen */
+            if (cellIds.isFailure()) {
+                return (0, ts_utils_1.fail)(cellIds.message);
+            }
+            const result = cage_1.Cage.create(id, 'column', basicCageTotal, cellIds.value).onSuccess((cage) => {
+                cages.push([id, cage]);
+                return (0, ts_utils_1.succeed)(cage);
+            });
+            /* c8 ignore next 3 - defense in depth should never happen */
+            if (result.isFailure()) {
+                return (0, ts_utils_1.fail)(result.message);
+            }
+        }
+        return (0, ts_utils_1.succeed)(cages);
+    }
+    /**
+     * @internal
+     */
+    static _createSectionCages(numRows, numCols) {
+        const cages = [];
+        for (let r = 0; r < numRows; r += 3) {
+            for (let c = 0; c < numCols; c += 3) {
+                const id = ids_1.Ids.sectionCageId(r, c);
+                const cellIds = ids_1.Ids.cellIds(r, 3, c, 3);
+                /* c8 ignore next 3 - defense in depth should never happen */
+                if (cellIds.isFailure()) {
+                    return (0, ts_utils_1.fail)(cellIds.message);
+                }
+                const result = cage_1.Cage.create(id, 'section', basicCageTotal, cellIds.value).onSuccess((cage) => {
+                    cages.push([id, cage]);
+                    return (0, ts_utils_1.succeed)(cage);
+                });
+                /* c8 ignore next 3 - defense in depth should never happen */
+                if (result.isFailure()) {
+                    return (0, ts_utils_1.fail)(result.message);
+                }
+            }
+        }
+        return (0, ts_utils_1.succeed)(cages);
+    }
+    checkIsSolved(state) {
+        for (const id of this._cells.keys()) {
+            if (!state.hasValue(id)) {
+                return false;
+            }
+        }
+        for (const cell of this._cells.values()) {
+            if (!cell.isValid(state)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    checkIsValid(state) {
+        for (const cell of this._cells.values()) {
+            if (!cell.isValid(state)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getEmptyCells(state) {
+        return Array.from(this._cells.values()).filter((c) => !state.hasValue(c.id));
+    }
+    getInvalidCells(state) {
+        return Array.from(this._cells.values()).filter((c) => !c.isValid(state));
+    }
+    getCellContents(spec, state) {
+        return this.getCell(spec).onSuccess((cell) => {
+            if (cell.immutable) {
+                const contents = { value: cell.immutableValue, notes: [] };
+                return (0, ts_utils_1.succeed)({ cell, contents });
+            }
+            return state.getCellContents(cell.id).onSuccess((contents) => {
+                return (0, ts_utils_1.succeed)({ cell, contents });
+            });
+        });
+    }
+    getCell(spec) {
+        const want = ids_1.Ids.cellId(spec);
+        if (want.isFailure()) {
+            return (0, ts_utils_1.fail)(want.message);
+        }
+        const cell = this._cells.get(want.value);
+        return cell ? (0, ts_utils_1.succeed)(cell) : (0, ts_utils_1.fail)(`Cell ${want.value} not found`);
+    }
+    getCellNeighbor(spec, direction, wrap) {
+        return this.getCell(spec).onSuccess((cell) => {
+            const move = direction === 'left' || direction === 'right'
+                ? this._moveColumn(cell, direction, wrap)
+                : this._moveRow(cell, direction, wrap);
+            return move.onSuccess((next) => this.getCell(next));
+        });
+    }
+    updateContents(wantUpdates, state) {
+        wantUpdates = Array.isArray(wantUpdates) ? wantUpdates : [wantUpdates];
+        return (0, ts_utils_1.mapResults)(wantUpdates.map((u) => this.getCellContents(u.id, state).onSuccess((existing) => existing.cell.update(u.value, u.notes).onSuccess((to) => {
+            const from = Object.assign({ id: u.id }, existing.contents);
+            return (0, ts_utils_1.succeed)({ from, to });
+        })))).onSuccess((cellUpdates) => {
+            return state.update(cellUpdates.map(({ to }) => to)).onSuccess((updatedState) => {
+                return (0, ts_utils_1.succeed)({
+                    from: state,
+                    to: updatedState,
+                    cells: cellUpdates
+                });
+            });
+        });
+    }
+    updateValues(wantUpdates, state) {
+        wantUpdates = Array.isArray(wantUpdates) ? wantUpdates : [wantUpdates];
+        return (0, ts_utils_1.mapResults)(wantUpdates.map((u) => this.getCellContents(u.id, state).onSuccess((existing) => existing.cell.update(u.value, existing.contents.notes).onSuccess((to) => {
+            const from = Object.assign({ id: u.id }, existing.contents);
+            return (0, ts_utils_1.succeed)({ from, to });
+        })))).onSuccess((cellUpdates) => {
+            return state.update(cellUpdates.map(({ to }) => to)).onSuccess((updatedState) => {
+                return (0, ts_utils_1.succeed)({
+                    from: state,
+                    to: updatedState,
+                    cells: cellUpdates
+                });
+            });
+        });
+    }
+    updateNotes(wantUpdates, state) {
+        wantUpdates = Array.isArray(wantUpdates) ? wantUpdates : [wantUpdates];
+        return (0, ts_utils_1.mapResults)(wantUpdates.map((u) => this.getCellContents(u.id, state).onSuccess((existing) => existing.cell.update(existing.contents.value, u.notes).onSuccess((to) => {
+            const from = Object.assign({ id: u.id }, existing.contents);
+            return (0, ts_utils_1.succeed)({ from, to });
+        })))).onSuccess((cellUpdates) => {
+            return state.update(cellUpdates.map(({ to }) => to)).onSuccess((updatedState) => {
+                return (0, ts_utils_1.succeed)({
+                    from: state,
+                    to: updatedState,
+                    cells: cellUpdates
+                });
+            });
+        });
+    }
+    updateCellValue(want, value, state) {
+        const idResult = typeof want === 'string' ? ids_1.Ids.cellId(want) : ids_1.Ids.cellId(want);
+        const notes = [];
+        return idResult.onSuccess((id) => {
+            const update = { id, value, notes };
+            return this.updateValues([update], state);
+        });
+    }
+    updateCellNotes(want, notes, state) {
+        const idResult = typeof want === 'string' ? ids_1.Ids.cellId(want) : ids_1.Ids.cellId(want);
+        const value = undefined;
+        return idResult.onSuccess((id) => {
+            const update = { id, value, notes };
+            return this.updateNotes([update], state);
+        });
+    }
+    getRow(row) {
+        const id = typeof row === 'number' ? ids_1.Ids.rowCageId(row) : row;
+        const cage = this._rows.get(id);
+        return cage ? (0, ts_utils_1.succeed)(cage) : (0, ts_utils_1.fail)(`Row ${id} not found`);
+    }
+    getColumn(col) {
+        const id = typeof col === 'number' ? ids_1.Ids.columnCageId(col) : col;
+        const cage = this._columns.get(id);
+        return cage ? (0, ts_utils_1.succeed)(cage) : (0, ts_utils_1.fail)(`Column ${id} not found`);
+    }
+    getSection(spec) {
+        const id = typeof spec === 'object' ? ids_1.Ids.sectionCageId(spec.row, spec.col) : spec;
+        const cage = this._sections.get(id);
+        return cage ? (0, ts_utils_1.succeed)(cage) : (0, ts_utils_1.fail)(`Section ${id} not found`);
+    }
+    getCage(id) {
+        const cage = this._cages.get(id);
+        return cage ? (0, ts_utils_1.succeed)(cage) : (0, ts_utils_1.fail)(`Cage ${id} not found`);
+    }
+    toStrings(state) {
+        return Array.from(this._rows.values()).map((row) => row.toString(state));
+    }
+    toString(state) {
+        return this.toStrings(state).join('\n');
+    }
+    _moveColumn(current, direction, wrap) {
+        const row = current.row;
+        let col = current.col;
+        if (direction === 'left') {
+            if (col > 0) {
+                col = col - 1;
+            }
+            else if (wrap !== 'none') {
+                col = this.numColumns - 1;
+                if (wrap === 'wrap-next') {
+                    return this._moveRow({ row, col }, 'up', 'wrap-around');
+                }
+            }
+            else {
+                return (0, ts_utils_1.fail)(`cannot move left from column ${current.col}`);
+            }
+        }
+        else if (direction === 'right') {
+            if (col < this.numColumns - 1) {
+                col = col + 1;
+            }
+            else if (wrap !== 'none') {
+                col = 0;
+                if (wrap === 'wrap-next') {
+                    return this._moveRow({ row, col }, 'down', 'wrap-around');
+                }
+            }
+            else {
+                return (0, ts_utils_1.fail)(`cannot move right from column ${current.col}`);
+            }
+        }
+        return (0, ts_utils_1.succeed)({ row, col });
+    }
+    _moveRow(current, direction, wrap) {
+        let row = current.row;
+        const col = current.col;
+        if (direction === 'up') {
+            if (row > 0) {
+                row = row - 1;
+            }
+            else if (wrap !== 'none') {
+                row = this.numRows - 1;
+                if (wrap === 'wrap-next') {
+                    return this._moveColumn({ row, col }, 'left', 'wrap-around');
+                }
+            }
+            else {
+                return (0, ts_utils_1.fail)(`cannot move up from row ${current.row}`);
+            }
+        }
+        else if (direction === 'down') {
+            if (row < this.numRows - 1) {
+                row = row + 1;
+            }
+            else if (wrap !== 'none') {
+                row = 0;
+                if (wrap === 'wrap-next') {
+                    return this._moveColumn({ row, col }, 'right', 'wrap-around');
+                }
+            }
+            else {
+                return (0, ts_utils_1.fail)(`cannot move down from row ${current.row}`);
+            }
+        }
+        return (0, ts_utils_1.succeed)({ row, col });
+    }
+}
+exports.Puzzle = Puzzle;
+//# sourceMappingURL=puzzle.js.map