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

package/dist/index.browser.js

@@ -0,0 +1,37 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2025 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.
+ */
+// Browser entry point - excludes Node.js filesystem dependencies
+// eslint-disable-next-line @rushstack/packlets/mechanics -- browser-specific entry point excludes Node.js fs dependencies
+import * as Files from './packlets/files/index.browser';
+import * as Hints from './packlets/hints';
+import * as Puzzles from './packlets/puzzles';
+export * from './packlets/collections';
+export * from './packlets/common';
+export { Files, Hints, Puzzles };
+// Excluded from browser:
+// - Files.loadJsonPuzzlesFileSync (requires Node.js fs via JsonFile.convertJsonFileSync)
+//
+// Included in browser (via FileTree):
+// - Files.loadJsonPuzzlesFromTree (browser-compatible via FileTree)
+//# sourceMappingURL=index.browser.js.map

package/dist/index.js

@@ -0,0 +1,30 @@
+/*
+ * 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 Files from './packlets/files';
+import * as Hints from './packlets/hints';
+import * as Puzzles from './packlets/puzzles';
+export * from './packlets/collections';
+export * from './packlets/common';
+export { Files, Hints, Puzzles };
+//# sourceMappingURL=index.js.map

package/dist/packlets/collections/collections.js

@@ -0,0 +1,136 @@
+/*
+ * 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 Files from '../files';
+import * as Puzzles from '../puzzles';
+import { captureResult, fail, succeed } from '@fgv/ts-utils';
+import { PuzzleDefinitionFactory, PuzzleSession } from '../common';
+import DefaultPuzzles from './data/puzzles.json';
+/**
+ * A collection of puzzles of various types.
+ * @public
+ */
+export class PuzzleCollection {
+    constructor(puzzles) {
+        this.puzzles = puzzles.puzzles;
+        this._byId = new Map(this.puzzles
+            .map((p) => [p.id, p])
+            .filter((p) => p[0] !== undefined));
+    }
+    /**
+     * Creates a new puzzle from a loaded {@link Files.Model.IPuzzlesFile | PuzzlesFile}
+     * @param from - The {@link Files.Model.IPuzzlesFile | puzzles file} to be loaded.
+     * @returns `Success` with the resulting {@link PuzzleCollection | PuzzleCollection}
+     * or `Failure` with details if an error occurs.
+     */
+    static create(from) {
+        return captureResult(() => new PuzzleCollection(from));
+    }
+    /**
+     * Creates a new puzzle from a JSON file.
+     * @param path - path to the JSON file to be loaded.
+     * @returns `Success` with the resulting {@link PuzzleCollection | PuzzleCollection}
+     * or `Failure` with details if an error occurs.
+     */
+    static load(file) {
+        return Files.Converters.loadPuzzlesFile(file).onSuccess(PuzzleCollection.create);
+    }
+    /**
+     * Gets a puzzle by id from this collection.
+     * @param id - The string ID of the puzzle to be returned.
+     * @returns `Success` with the requested {@link PuzzleSession | puzzle}, or
+     * `Failure` with details if an error occurs.
+     */
+    getPuzzle(id) {
+        return this.getDescription(id)
+            .onSuccess((desc) => {
+            return this._convertToDefinition(desc);
+        })
+            .onSuccess((def) => {
+            return Puzzles.Any.create(def);
+        })
+            .onSuccess((puzzle) => {
+            return PuzzleSession.create(puzzle);
+        });
+    }
+    /**
+     * Converts IPuzzleFileData to IPuzzleDefinition format.
+     * @param fileData - The puzzle file data to convert
+     * @returns Result containing the puzzle definition
+     */
+    _convertToDefinition(fileData) {
+        // Validate that dimensions match cell count
+        const config = fileData.dimensions;
+        const expectedCells = config.cageWidthInCells *
+            config.cageHeightInCells *
+            config.boardWidthInCages *
+            config.boardHeightInCages;
+        // For killer sudoku, cells includes cage definitions after '|' separator
+        const gridCells = fileData.type === 'killer-sudoku' ? fileData.cells.split('|')[0] : fileData.cells;
+        const actualCells = gridCells.length;
+        if (actualCells !== expectedCells) {
+            return fail(`Dimensions mismatch: dimensions specify ${expectedCells} cells (${config.cageWidthInCells}x${config.cageHeightInCells} cages in ${config.boardWidthInCages}x${config.boardHeightInCages} layout) but cells string contains ${actualCells} cells`);
+        }
+        return PuzzleDefinitionFactory.create(config, {
+            id: fileData.id,
+            description: fileData.description,
+            type: fileData.type,
+            level: fileData.level,
+            cells: fileData.cells
+        });
+    }
+    /**
+     * Gets a puzzle by id from this collection.
+     * @param id - The string ID of the puzzle to be returned.
+     * @returns `Success` with the requested {@link PuzzleSession | puzzle}, or
+     * `Failure` with details if an error occurs.
+     */
+    getDescription(id) {
+        const fileData = this._byId.get(id);
+        /* c8 ignore next 3 - tested but coverage fails intermittently */
+        if (!fileData) {
+            return fail(`Puzzle "${id}" not found`);
+        }
+        return succeed(fileData);
+    }
+}
+/**
+ * Get well-known {@link PuzzleCollection | puzzle collections}.
+ * @public
+ */
+export class PuzzleCollections {
+    /**
+     * The default {@link PuzzleCollection | puzzle collection}.
+     */
+    static get default() {
+        if (!PuzzleCollections._default) {
+            PuzzleCollections._default = Files.Converters.puzzlesFile
+                .convert(DefaultPuzzles)
+                .onSuccess(PuzzleCollection.create)
+                .orThrow();
+        }
+        return PuzzleCollections._default;
+    }
+}
+PuzzleCollections._default = undefined;
+//# sourceMappingURL=collections.js.map

package/dist/packlets/collections/data/puzzles.json

@@ -0,0 +1,56 @@
+{
+  "puzzles": [
+    {
+      "id": "hidden-pair",
+      "description": "hidden pair sample",
+      "type": "sudoku",
+      "level": 1,
+      "cells": ".........9.46.7....768.41..3.97.1.8.7.8...3.1.513.87.2..75.261...54.32.8.........",
+      "dimensions": {
+        "cageWidthInCells": 3,
+        "cageHeightInCells": 3,
+        "boardWidthInCages": 3,
+        "boardHeightInCages": 3
+      }
+    },
+    {
+      "id": "almost-done",
+      "description": "nearly complete puzzle missing only 1 in cell A1",
+      "type": "sudoku",
+      "level": 1,
+      "cells": ".46728539837549126259316748685297413312684957794153862428965371571832694963471285",
+      "dimensions": {
+        "cageWidthInCells": 3,
+        "cageHeightInCells": 3,
+        "boardWidthInCages": 3,
+        "boardHeightInCages": 3
+      }
+    },
+    {
+      "id": "sudoku-x-example",
+      "description": "sample x-sudoku puzzle",
+      "type": "sudoku-x",
+      "level": 1,
+      "cells": "4.....13....6.1.....7..29...76.....2....3..9.9.1....577...1.6..3...5.7...4......1",
+      "dimensions": {
+        "cageWidthInCells": 3,
+        "cageHeightInCells": 3,
+        "boardWidthInCages": 3,
+        "boardHeightInCages": 3
+      }
+    },
+    {
+      "id": "killer-insane",
+      "description": "Insane (3208329) example from djape.net",
+      "type": "killer-sudoku",
+      "level": 100,
+      "cells": "ABCCCDDDEABFFGGGDEHIJKMGLLLHIJKMGLNNHOPPMQQNROOSTMUVWRSSSTTUVWRXYTTTZZabXYYYcccab|A11,B09,C09,D20,E16,F17,G30,H17,I13,J09,K11,L16,M16,N11,O16,P07,Q11,R10,S14,T39,U08,V17,W16,X06,Y26,Z06,a09,b09,c11",
+      "dimensions": {
+        "cageWidthInCells": 3,
+        "cageHeightInCells": 3,
+        "boardWidthInCages": 3,
+        "boardHeightInCages": 3
+      }
+    }
+  ]
+}

package/dist/packlets/collections/index.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 * from './collections';
+//# sourceMappingURL=index.js.map

package/dist/packlets/common/cage.js

@@ -0,0 +1,83 @@
+/*
+ * 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 { captureResult } from '@fgv/ts-utils';
+/**
+ * @internal
+ */
+export class Cage {
+    constructor(id, type, total, cells) {
+        this.id = id;
+        this.cageType = type;
+        this.total = total;
+        this._cellIds = Array.from(cells);
+        this._values = new Set();
+    }
+    get cellIds() {
+        return Array.from(this._cellIds);
+    }
+    get numCells() {
+        return this._cellIds.length;
+    }
+    static create(id, type, total, cells) {
+        return captureResult(() => new Cage(id, type, total, cells));
+    }
+    containsCell(id) {
+        return this._cellIds.includes(id);
+    }
+    containsValue(value, state, ignore) {
+        var _a;
+        for (const cellId of this._cellIds) {
+            if (!(ignore === null || ignore === void 0 ? void 0 : ignore.includes(cellId))) {
+                /* c8 ignore next - defense in depth, ? should never happen */
+                if (((_a = state.getCellContents(cellId).orDefault()) === null || _a === void 0 ? void 0 : _a.value) === value) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    containedValues(state) {
+        var _a;
+        const values = new Set();
+        for (const cellId of this._cellIds) {
+            /* c8 ignore next - defense in depth, ? should never happen */
+            const value = (_a = state.getCellContents(cellId).orDefault()) === null || _a === void 0 ? void 0 : _a.value;
+            if (value !== undefined) {
+                values.add(value);
+            }
+        }
+        return values;
+    }
+    toString(state) {
+        return this._cellIds
+            .map((id) => {
+            var _a;
+            /* c8 ignore next - defense in depth, ? should never happen */
+            const value = (_a = state === null || state === void 0 ? void 0 : state.getCellContents(id).orDefault()) === null || _a === void 0 ? void 0 : _a.value;
+            return value ? String(value) : '.';
+        })
+            .join('');
+    }
+}
+//# sourceMappingURL=cage.js.map

package/dist/packlets/common/cell.js

@@ -0,0 +1,88 @@
+/*
+ * 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';
+/**
+ * @internal
+ */
+export class Cell {
+    constructor(init, cages) {
+        this.id = init.id;
+        this.row = init.row;
+        this.col = init.col;
+        this.cages = [...cages];
+        this.immutableValue = init.immutableValue;
+        this.immutable = init.immutableValue !== undefined;
+    }
+    isValid(state) {
+        if (this.immutable) {
+            return true;
+        }
+        const cell = state.getCellContents(this.id).orDefault();
+        return cell !== undefined && this.isValidValue(cell.value, state);
+    }
+    hasValue(state) {
+        if (this.immutable) {
+            return true;
+        }
+        const cell = state.getCellContents(this.id).orDefault();
+        /* c8 ignore next - defense in depth ? should never happen */
+        return (cell === null || cell === void 0 ? void 0 : cell.value) !== undefined;
+    }
+    isValidValue(value, state) {
+        if (this.immutable) {
+            return false;
+        }
+        else if (value === undefined) {
+            return true;
+        }
+        return !this.cages.find((cage) => cage.containsValue(value, state, [this.id]));
+    }
+    update(value, notes) {
+        if (this.immutable) {
+            return fail(`cannot set value "${value}" in immutable cell ${this.id}`);
+        }
+        return succeed({
+            id: this.id,
+            value,
+            notes
+        });
+    }
+    updateValue(value, state) {
+        return state.getCellContents(this.id).onSuccess((contents) => {
+            return this.update(value, contents.notes);
+        });
+    }
+    updateNotes(notes, state) {
+        return state.getCellContents(this.id).onSuccess((contents) => {
+            return this.update(contents.value, notes);
+        });
+    }
+    toString(state) {
+        var _a;
+        const contents = state === null || state === void 0 ? void 0 : state.getCellContents(this.id).orDefault();
+        const value = (_a = this.immutableValue) !== null && _a !== void 0 ? _a : contents === null || contents === void 0 ? void 0 : contents.value;
+        return value && value >= 1 && value <= 9 ? String(value) : '.';
+    }
+}
+//# sourceMappingURL=cell.js.map

package/dist/packlets/common/common.js

@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+/**
+ * All supported public types.
+ * @public
+ */
+export const allPuzzleTypes = ['killer-sudoku', 'sudoku', 'sudoku-x'];
+/**
+ * The minimum and maximum possible values for a {@link ICage | cage}, by cage size in
+ * {@link ICell | cells}.
+ * @public
+ */
+/**
+ * Calculate the minimum and maximum possible totals for a cage of given size
+ * @param cageSize - Number of cells in the cage
+ * @param maxValue - Maximum value allowed in a cell (e.g., 9 for 9x9, 16 for 16x16)
+ * @returns Object with min and max possible totals
+ * @public
+ */
+export function getCageTotalBounds(cageSize, maxValue) {
+    /* c8 ignore next 3 - functional code tested but coverage intermittently missed */
+    if (cageSize <= 0) {
+        return { min: 0, max: 0 };
+    }
+    // Minimum is sum of first cageSize numbers (1, 2, 3, ...)
+    const min = (cageSize * (cageSize + 1)) / 2;
+    // Maximum is sum of last cageSize numbers (maxValue, maxValue-1, ...)
+    // But cageSize cannot exceed maxValue
+    const effectiveCageSize = Math.min(cageSize, maxValue);
+    const max = effectiveCageSize * maxValue - (effectiveCageSize * (effectiveCageSize - 1)) / 2;
+    return { min, max };
+}
+/**
+ * Legacy array for backward compatibility - supports standard 9x9 Sudoku
+ * @public
+ */
+export const totalsByCageSize = [
+    { min: 0, max: 0 },
+    { min: 1, max: 9 },
+    { min: 3, max: 17 },
+    { min: 6, max: 24 },
+    { min: 10, max: 30 },
+    { min: 15, max: 35 },
+    { min: 21, max: 39 },
+    { min: 28, max: 42 },
+    { min: 36, max: 44 },
+    { min: 45, max: 45 }
+];
+//# sourceMappingURL=common.js.map

package/dist/packlets/common/converters.js

@@ -0,0 +1,65 @@
+/*
+ * 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 { Converters, fail, succeed } from '@fgv/ts-utils';
+import { allPuzzleTypes } from './common';
+// Updated to support larger grids:
+// - Row IDs: R followed by A-Z or AA-ZZ for rows
+// - Column IDs: C followed by 1-99+ for columns
+// - Section IDs: S followed by row letter(s) and column number(s)
+// - X diagonals: X1, X2
+// - Killer cages: K followed by letter(s)
+const cageIdRegExp = /^(R[A-Z]{1,2}$)|(C[0-9]{1,3}$)|(S[A-Z]{1,2}[0-9]{1,3}$)|(X[1-2]$)|(K[A-Za-z]+$)/;
+function validateCageId(from) {
+    if (cageIdRegExp.test(from)) {
+        return succeed(from);
+    }
+    return fail(`malformed cage ID "${from}"`);
+}
+// Updated to support larger grids:
+// - Rows: A-Z for 0-25, then AA-ZZ for 26+
+// - Columns: 1-999 for any size grid
+const cellIdRegExp = /^[A-Z]{1,2}[0-9]{1,3}$/;
+function validateCellId(from) {
+    // Check basic format
+    if (!cellIdRegExp.test(from)) {
+        return fail(`malformed cell ID "${from}" (expected row letter(s) followed by column number)`);
+    }
+    return succeed(from);
+}
+/**
+ * Converts an arbitrary value to a {@link CageId | CageId}.
+ * @public
+ */
+export const cageId = Converters.string.map(validateCageId);
+/**
+ * Converts an arbitrary value to a {@link CellId | CellId}.
+ * @public
+ */
+export const cellId = Converters.string.map(validateCellId);
+/**
+ * Converts an arbitrary value to a {@link PuzzleType | PuzzleType}.
+ * @public
+ */
+export const puzzleType = Converters.enumeratedValue(allPuzzleTypes);
+//# sourceMappingURL=converters.js.map