@fgv/ts-sudoku-lib 5.0.1-9 → 5.0.2-0

package/dist/packlets/common/ids.js

@@ -0,0 +1,152 @@
+/*
+ * 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.
+ */
+import { fail, succeed } from '@fgv/ts-utils';
+import * as Converters from './converters';
+const firstRowIdChar = 'A'.charCodeAt(0);
+/**
+ * Convert a column index (0-based) to column letters (A-Z, AA-AZ, BA-BZ, etc.)
+ * @param col - 0-based column index
+ * @returns Column identifier string
+ */
+function columnToLetters(col) {
+    if (col < 26) {
+        // Single letter: A-Z
+        return String.fromCharCode(firstRowIdChar + col);
+        /* c8 ignore next 8 - functional code tested but coverage intermittently missed */
+    }
+    else {
+        // Double letters: AA, AB, ..., ZZ
+        const firstLetter = Math.floor(col / 26) - 1;
+        const secondLetter = col % 26;
+        return (String.fromCharCode(firstRowIdChar + firstLetter) + String.fromCharCode(firstRowIdChar + secondLetter));
+    }
+}
+/**
+ * Convert a row index (0-based) to row number string (1-based with zero-padding)
+ * @param row - 0-based row index
+ * @param maxRow - Maximum row index (optional, for determining padding width)
+ * @returns Row number string with zero-padding
+ */
+function rowToNumber(row, maxRow) {
+    const rowNum = row + 1;
+    /* c8 ignore next 5 - functional code tested but coverage intermittently missed */
+    if (maxRow !== undefined) {
+        const maxRowNum = maxRow + 1;
+        const width = maxRowNum.toString().length;
+        return rowNum.toString().padStart(width, '0');
+    }
+    // Default: pad to 2 digits for grids up to 99x99
+    return rowNum.toString().padStart(2, '0');
+}
+/**
+ * Parse a cell ID string back to row/column coordinates
+ * @param cellId - Cell ID string (e.g., "A1", "A01", "AB15")
+ * @returns Row and column indices (0-based) or undefined if invalid
+ * @public
+ */
+export function parseCellId(cellId) {
+    const match = cellId.match(/^([A-Z]{1,2})([0-9]{1,3})$/);
+    /* c8 ignore next 3 - functional code tested but coverage intermittently missed */
+    if (!match) {
+        return undefined;
+    }
+    const rowLetters = match[1];
+    const colNumber = parseInt(match[2], 10);
+    let row;
+    if (rowLetters.length === 1) {
+        // Single letter: A-Z maps to rows 0-25
+        row = rowLetters.charCodeAt(0) - firstRowIdChar;
+        /* c8 ignore next 6 - functional code tested but coverage intermittently missed */
+    }
+    else {
+        // Double letters: AA-ZZ for rows 26+
+        const firstLetter = rowLetters.charCodeAt(0) - firstRowIdChar;
+        const secondLetter = rowLetters.charCodeAt(1) - firstRowIdChar;
+        row = (firstLetter + 1) * 26 + secondLetter;
+    }
+    const col = colNumber - 1; // Convert from 1-based to 0-based
+    return { row, col };
+}
+function isRowColumn(from) {
+    return typeof from === 'object' && from !== null && 'row' in from && `col` in from;
+}
+/**
+ * @public
+ */
+export class Ids {
+    static cageId(from) {
+        if (typeof from === 'string') {
+            return Converters.cageId.convert(from);
+        }
+        /* c8 ignore next 2 - functional code tested but coverage intermittently missed */
+        return succeed(from.id);
+    }
+    static cellId(spec) {
+        if (isRowColumn(spec)) {
+            if ('id' in spec) {
+                return succeed(spec.id);
+            }
+            // Standard sudoku convention: Letters for rows (A-I), numbers for columns (1-9)
+            const rowLetter = columnToLetters(spec.row);
+            // For 9x9 grids, use single digit format for backward compatibility
+            // For larger grids, use zero-padding
+            const colNumber = spec.col < 9 ? (spec.col + 1).toString() : rowToNumber(spec.col);
+            return succeed(`${rowLetter}${colNumber}`);
+        }
+        return Converters.cellId.convert(spec);
+    }
+    static rowCageId(row) {
+        return `R${columnToLetters(row)}`;
+    }
+    static columnCageId(col) {
+        // For backward compatibility, use single digit for columns < 9
+        const colNumber = col < 9 ? (col + 1).toString() : rowToNumber(col);
+        return `C${colNumber}`;
+    }
+    static sectionCageId(row, col, cageHeight = 3, cageWidth = 3) {
+        row = Math.floor(row / cageHeight) * cageHeight;
+        col = Math.floor(col / cageWidth) * cageWidth;
+        // Section IDs use row letter and column number
+        const rowLetter = columnToLetters(row);
+        const colNumber = col < 9 ? (col + 1).toString() : rowToNumber(col);
+        return `S${rowLetter}${colNumber}`;
+    }
+    static cellIds(firstRow, numRows, firstCol, numCols) {
+        const cellIds = [];
+        for (let row = firstRow; row < firstRow + numRows; row++) {
+            for (let col = firstCol; col < firstCol + numCols; col++) {
+                const result = this.cellId({ row, col }).onSuccess((id) => {
+                    cellIds.push(id);
+                    return succeed(id);
+                });
+                /* c8 ignore next 3 - defense in depth should not happen */
+                if (result.isFailure()) {
+                    return fail(result.message);
+                }
+            }
+        }
+        return succeed(cellIds);
+    }
+}
+//# sourceMappingURL=ids.js.map

package/dist/packlets/common/index.js

@@ -0,0 +1,36 @@
+/*
+ * 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.
+ */
+import * as Converters from './converters';
+export * from './cage';
+export * from './cell';
+export * from './common';
+export { Ids, parseCellId } from './ids';
+export { DefaultSudokuLogger } from './logging';
+export * from './public';
+export * from './puzzle';
+export * from './puzzleDefinitions';
+export * from './puzzleSession';
+export * from './puzzleState';
+export { Converters };
+//# sourceMappingURL=index.js.map

package/dist/packlets/common/logging.js

@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+import { Logging } from '@fgv/ts-utils';
+/**
+ * Default no-op logger for use when diagnostic logging is not needed.
+ * @public
+ */
+export const DefaultSudokuLogger = new Logging.LogReporter({
+    logger: new Logging.NoOpLogger()
+});
+//# sourceMappingURL=logging.js.map

package/dist/packlets/common/public.js

@@ -0,0 +1,25 @@
+/*
+ * 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.
+ */
+export {};
+//# sourceMappingURL=public.js.map

package/dist/packlets/common/puzzle.js

@@ -0,0 +1,411 @@
+/*
+ * 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.
+ */
+import { fail, mapResults, succeed } from '@fgv/ts-utils';
+import { Cage } from './cage';
+import { Cell } from './cell';
+import { Ids } from './ids';
+import { PuzzleState } from './puzzleState';
+/**
+ * Abstract base class for all puzzles.
+ * @public
+ */
+export class Puzzle {
+    /**
+     * Constructs a new puzzle state.
+     * @param puzzle - {@Link IPuzzleDefinition | Puzzle definition} 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 : [];
+        // Validate cell count matches grid size
+        /* c8 ignore next 7 - defensive test - not reachable in practice */
+        if (puzzle.cells.length !== puzzle.totalRows * puzzle.totalColumns) {
+            throw new Error(`Puzzle '${puzzle.description}" expected ${puzzle.totalRows * puzzle.totalColumns} cells, found ${puzzle.cells.length}`);
+        }
+        this.id = puzzle.id;
+        this.description = puzzle.description;
+        this.type = puzzle.type;
+        this.dimensions = puzzle;
+        const rows = Puzzle._createRowCages(puzzle.totalRows, puzzle.totalColumns, puzzle.basicCageTotal).orThrow();
+        const columns = Puzzle._createColumnCages(puzzle.totalRows, puzzle.totalColumns, puzzle.basicCageTotal).orThrow();
+        const sections = Puzzle._createSectionCages(puzzle).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.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 : this._parseAlphanumericValue(init !== null && init !== void 0 ? init : '0');
+                if (immutableValue !== undefined &&
+                    (Number.isNaN(immutableValue) || immutableValue < 1 || immutableValue > puzzle.maxValue)) {
+                    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({ id, immutableValue, row, col }, cages);
+                this._cells.set(id, cell);
+            }
+        }
+        this.initialState = 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, basicCageTotal) {
+        const cages = [];
+        for (let r = 0; r < numRows; r++) {
+            const id = Ids.rowCageId(r);
+            const cellIds = Ids.cellIds(r, 1, 0, numCols);
+            /* c8 ignore next 3 - defense in depth should never happen */
+            if (cellIds.isFailure()) {
+                return fail(cellIds.message);
+            }
+            const result = Cage.create(id, 'row', basicCageTotal, cellIds.value).onSuccess((cage) => {
+                cages.push([id, cage]);
+                return succeed(cage);
+            });
+            /* c8 ignore next 3 - defense in depth should never happen */
+            if (result.isFailure()) {
+                return fail(result.message);
+            }
+        }
+        return succeed(cages);
+    }
+    /**
+     * @internal
+     */
+    static _createColumnCages(numRows, numCols, basicCageTotal) {
+        const cages = [];
+        for (let c = 0; c < numCols; c++) {
+            const id = Ids.columnCageId(c);
+            const cellIds = Ids.cellIds(0, numRows, c, 1);
+            /* c8 ignore next 3 - defense in depth should never happen */
+            if (cellIds.isFailure()) {
+                return fail(cellIds.message);
+            }
+            const result = Cage.create(id, 'column', basicCageTotal, cellIds.value).onSuccess((cage) => {
+                cages.push([id, cage]);
+                return succeed(cage);
+            });
+            /* c8 ignore next 3 - defense in depth should never happen */
+            if (result.isFailure()) {
+                return fail(result.message);
+            }
+        }
+        return succeed(cages);
+    }
+    /**
+     * Parse alphanumeric cell value (1-9, A-Z for values 10-35)
+     * @internal
+     */
+    _parseAlphanumericValue(char) {
+        // Handle digits 1-9
+        if (char >= '1' && char <= '9') {
+            return Number.parseInt(char, 10);
+        }
+        // Handle uppercase A-Z for values 10-35
+        if (char >= 'A' && char <= 'Z') {
+            return char.charCodeAt(0) - 'A'.charCodeAt(0) + 10;
+        }
+        // Handle lowercase a-z for values 10-35
+        if (char >= 'a' && char <= 'z') {
+            return char.charCodeAt(0) - 'a'.charCodeAt(0) + 10;
+        }
+        // Invalid character, return NaN to trigger error handling
+        return Number.NaN;
+    }
+    /**
+     * @internal
+     */
+    static _createSectionCages(puzzle) {
+        const cages = [];
+        const cageWidth = puzzle.cageWidthInCells;
+        const cageHeight = puzzle.cageHeightInCells;
+        const boardWidth = puzzle.boardWidthInCages;
+        const boardHeight = puzzle.boardHeightInCages;
+        for (let boardRow = 0; boardRow < boardHeight; boardRow++) {
+            for (let boardCol = 0; boardCol < boardWidth; boardCol++) {
+                const startRow = boardRow * cageHeight;
+                const startCol = boardCol * cageWidth;
+                const id = Ids.sectionCageId(startRow, startCol, cageHeight, cageWidth);
+                const cellIds = Ids.cellIds(startRow, cageHeight, startCol, cageWidth);
+                /* c8 ignore next 3 - defense in depth should never happen */
+                if (cellIds.isFailure()) {
+                    return fail(cellIds.message);
+                }
+                const result = Cage.create(id, 'section', puzzle.basicCageTotal, cellIds.value).onSuccess((cage) => {
+                    cages.push([id, cage]);
+                    return succeed(cage);
+                });
+                /* c8 ignore next 3 - defense in depth should never happen */
+                if (result.isFailure()) {
+                    return fail(result.message);
+                }
+            }
+        }
+        return 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 succeed({ cell, contents });
+            }
+            return state.getCellContents(cell.id).onSuccess((contents) => {
+                return succeed({ cell, contents });
+            });
+        });
+    }
+    getCell(spec) {
+        const want = Ids.cellId(spec);
+        if (want.isFailure()) {
+            return fail(want.message);
+        }
+        const cell = this._cells.get(want.value);
+        return cell ? succeed(cell) : 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 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 succeed({ from, to });
+        })))).onSuccess((cellUpdates) => {
+            return state.update(cellUpdates.map(({ to }) => to)).onSuccess((updatedState) => {
+                return succeed({
+                    from: state,
+                    to: updatedState,
+                    cells: cellUpdates
+                });
+            });
+        });
+    }
+    updateValues(wantUpdates, state) {
+        wantUpdates = Array.isArray(wantUpdates) ? wantUpdates : [wantUpdates];
+        return 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 succeed({ from, to });
+        })))).onSuccess((cellUpdates) => {
+            return state.update(cellUpdates.map(({ to }) => to)).onSuccess((updatedState) => {
+                return succeed({
+                    from: state,
+                    to: updatedState,
+                    cells: cellUpdates
+                });
+            });
+        });
+    }
+    updateNotes(wantUpdates, state) {
+        wantUpdates = Array.isArray(wantUpdates) ? wantUpdates : [wantUpdates];
+        return 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 succeed({ from, to });
+        })))).onSuccess((cellUpdates) => {
+            return state.update(cellUpdates.map(({ to }) => to)).onSuccess((updatedState) => {
+                return succeed({
+                    from: state,
+                    to: updatedState,
+                    cells: cellUpdates
+                });
+            });
+        });
+    }
+    updateCellValue(want, value, state) {
+        const idResult = 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 = 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.rowCageId(row) : row;
+        const cage = this._rows.get(id);
+        return cage ? succeed(cage) : fail(`Row ${id} not found`);
+    }
+    getColumn(col) {
+        const id = typeof col === 'number' ? Ids.columnCageId(col) : col;
+        const cage = this._columns.get(id);
+        return cage ? succeed(cage) : fail(`Column ${id} not found`);
+    }
+    getSection(spec) {
+        const id = typeof spec === 'object'
+            ? Ids.sectionCageId(spec.row, spec.col, this.dimensions.cageHeightInCells, this.dimensions.cageWidthInCells)
+            : spec;
+        const cage = this._sections.get(id);
+        return cage ? succeed(cage) : fail(`Section ${id} not found`);
+    }
+    getCage(id) {
+        const cage = this._cages.get(id);
+        return cage ? succeed(cage) : 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 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 fail(`cannot move right from column ${current.col}`);
+            }
+        }
+        return 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 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 fail(`cannot move down from row ${current.row}`);
+            }
+        }
+        return succeed({ row, col });
+    }
+}
+//# sourceMappingURL=puzzle.js.map