@fgv/ts-sudoku-ui 5.0.1-2

package/lib-commonjs/index.js

@@ -0,0 +1,73 @@
+"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.CombinationCard = exports.CombinationGrid = exports.KillerCombinationsModal = exports.KillerCombinationsPanel = exports.KillerCombinationsExplorer = exports.useKeyboardShortcut = exports.useCombinationElimination = exports.useKillerCombinations = exports.useResponsiveLayout = exports.usePuzzleSession = exports.CageSumIndicator = exports.CageOverlay = exports.NumberKeypad = exports.DualKeypad = exports.CompactControlRibbon = exports.ValidationDisplay = exports.SudokuControls = exports.SudokuCell = exports.SudokuGrid = exports.SudokuGridEntry = void 0;
+const tslib_1 = require("tslib");
+// Main components
+var SudokuGridEntry_1 = require("./components/SudokuGridEntry");
+Object.defineProperty(exports, "SudokuGridEntry", { enumerable: true, get: function () { return SudokuGridEntry_1.SudokuGridEntry; } });
+var SudokuGrid_1 = require("./components/SudokuGrid");
+Object.defineProperty(exports, "SudokuGrid", { enumerable: true, get: function () { return SudokuGrid_1.SudokuGrid; } });
+var SudokuCell_1 = require("./components/SudokuCell");
+Object.defineProperty(exports, "SudokuCell", { enumerable: true, get: function () { return SudokuCell_1.SudokuCell; } });
+var SudokuControls_1 = require("./components/SudokuControls");
+Object.defineProperty(exports, "SudokuControls", { enumerable: true, get: function () { return SudokuControls_1.SudokuControls; } });
+var ValidationDisplay_1 = require("./components/ValidationDisplay");
+Object.defineProperty(exports, "ValidationDisplay", { enumerable: true, get: function () { return ValidationDisplay_1.ValidationDisplay; } });
+var CompactControlRibbon_1 = require("./components/CompactControlRibbon");
+Object.defineProperty(exports, "CompactControlRibbon", { enumerable: true, get: function () { return CompactControlRibbon_1.CompactControlRibbon; } });
+var DualKeypad_1 = require("./components/DualKeypad");
+Object.defineProperty(exports, "DualKeypad", { enumerable: true, get: function () { return DualKeypad_1.DualKeypad; } });
+var NumberKeypad_1 = require("./components/NumberKeypad");
+Object.defineProperty(exports, "NumberKeypad", { enumerable: true, get: function () { return NumberKeypad_1.NumberKeypad; } });
+var CageOverlay_1 = require("./components/CageOverlay");
+Object.defineProperty(exports, "CageOverlay", { enumerable: true, get: function () { return CageOverlay_1.CageOverlay; } });
+var CageSumIndicator_1 = require("./components/CageSumIndicator");
+Object.defineProperty(exports, "CageSumIndicator", { enumerable: true, get: function () { return CageSumIndicator_1.CageSumIndicator; } });
+// Contexts
+tslib_1.__exportStar(require("./contexts/DiagnosticLoggerContext"), exports);
+// Hooks
+var usePuzzleSession_1 = require("./hooks/usePuzzleSession");
+Object.defineProperty(exports, "usePuzzleSession", { enumerable: true, get: function () { return usePuzzleSession_1.usePuzzleSession; } });
+var useResponsiveLayout_1 = require("./hooks/useResponsiveLayout");
+Object.defineProperty(exports, "useResponsiveLayout", { enumerable: true, get: function () { return useResponsiveLayout_1.useResponsiveLayout; } });
+var useKillerCombinations_1 = require("./hooks/useKillerCombinations");
+Object.defineProperty(exports, "useKillerCombinations", { enumerable: true, get: function () { return useKillerCombinations_1.useKillerCombinations; } });
+var useCombinationElimination_1 = require("./hooks/useCombinationElimination");
+Object.defineProperty(exports, "useCombinationElimination", { enumerable: true, get: function () { return useCombinationElimination_1.useCombinationElimination; } });
+var useKeyboardShortcut_1 = require("./hooks/useKeyboardShortcut");
+Object.defineProperty(exports, "useKeyboardShortcut", { enumerable: true, get: function () { return useKeyboardShortcut_1.useKeyboardShortcut; } });
+// Killer Combinations Components
+var KillerCombinationsExplorer_1 = require("./components/KillerCombinationsExplorer");
+Object.defineProperty(exports, "KillerCombinationsExplorer", { enumerable: true, get: function () { return KillerCombinationsExplorer_1.KillerCombinationsExplorer; } });
+var KillerCombinationsPanel_1 = require("./components/KillerCombinationsPanel");
+Object.defineProperty(exports, "KillerCombinationsPanel", { enumerable: true, get: function () { return KillerCombinationsPanel_1.KillerCombinationsPanel; } });
+var KillerCombinationsModal_1 = require("./components/KillerCombinationsModal");
+Object.defineProperty(exports, "KillerCombinationsModal", { enumerable: true, get: function () { return KillerCombinationsModal_1.KillerCombinationsModal; } });
+var CombinationGrid_1 = require("./components/CombinationGrid");
+Object.defineProperty(exports, "CombinationGrid", { enumerable: true, get: function () { return CombinationGrid_1.CombinationGrid; } });
+var CombinationCard_1 = require("./components/CombinationCard");
+Object.defineProperty(exports, "CombinationCard", { enumerable: true, get: function () { return CombinationCard_1.CombinationCard; } });
+//# sourceMappingURL=index.js.map

package/lib-commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;;;;AAEH,kBAAkB;AAClB,gEAA+D;AAAtD,kHAAA,eAAe,OAAA;AACxB,sDAAqD;AAA5C,wGAAA,UAAU,OAAA;AACnB,sDAAqD;AAA5C,wGAAA,UAAU,OAAA;AACnB,8DAA6D;AAApD,gHAAA,cAAc,OAAA;AACvB,oEAAmE;AAA1D,sHAAA,iBAAiB,OAAA;AAC1B,0EAAyE;AAAhE,4HAAA,oBAAoB,OAAA;AAC7B,sDAAqD;AAA5C,wGAAA,UAAU,OAAA;AACnB,0DAAyD;AAAhD,4GAAA,YAAY,OAAA;AACrB,wDAAuD;AAA9C,0GAAA,WAAW,OAAA;AACpB,kEAAiE;AAAxD,oHAAA,gBAAgB,OAAA;AAEzB,WAAW;AACX,6EAAmD;AAEnD,QAAQ;AACR,6DAA4D;AAAnD,oHAAA,gBAAgB,OAAA;AACzB,mEAAkE;AAAzD,0HAAA,mBAAmB,OAAA;AAC5B,uEAAsE;AAA7D,8HAAA,qBAAqB,OAAA;AAC9B,+EAA8E;AAArE,sIAAA,yBAAyB,OAAA;AAClC,mEAAkE;AAAzD,0HAAA,mBAAmB,OAAA;AAE5B,iCAAiC;AACjC,sFAAqF;AAA5E,wIAAA,0BAA0B,OAAA;AACnC,gFAA+E;AAAtE,kIAAA,uBAAuB,OAAA;AAChC,gFAA+E;AAAtE,kIAAA,uBAAuB,OAAA;AAChC,gEAA+D;AAAtD,kHAAA,eAAe,OAAA;AACxB,gEAA+D;AAAtD,kHAAA,eAAe,OAAA","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\n// Main components\nexport { SudokuGridEntry } from './components/SudokuGridEntry';\nexport { SudokuGrid } from './components/SudokuGrid';\nexport { SudokuCell } from './components/SudokuCell';\nexport { SudokuControls } from './components/SudokuControls';\nexport { ValidationDisplay } from './components/ValidationDisplay';\nexport { CompactControlRibbon } from './components/CompactControlRibbon';\nexport { DualKeypad } from './components/DualKeypad';\nexport { NumberKeypad } from './components/NumberKeypad';\nexport { CageOverlay } from './components/CageOverlay';\nexport { CageSumIndicator } from './components/CageSumIndicator';\n\n// Contexts\nexport * from './contexts/DiagnosticLoggerContext';\n\n// Hooks\nexport { usePuzzleSession } from './hooks/usePuzzleSession';\nexport { useResponsiveLayout } from './hooks/useResponsiveLayout';\nexport { useKillerCombinations } from './hooks/useKillerCombinations';\nexport { useCombinationElimination } from './hooks/useCombinationElimination';\nexport { useKeyboardShortcut } from './hooks/useKeyboardShortcut';\n\n// Killer Combinations Components\nexport { KillerCombinationsExplorer } from './components/KillerCombinationsExplorer';\nexport { KillerCombinationsPanel } from './components/KillerCombinationsPanel';\nexport { KillerCombinationsModal } from './components/KillerCombinationsModal';\nexport { CombinationGrid } from './components/CombinationGrid';\nexport { CombinationCard } from './components/CombinationCard';\n\n// Types\nexport type {\n  IValidationError,\n  ISudokuGridEntryProps,\n  ISudokuGridProps,\n  ICellDisplayInfo,\n  ISudokuCellProps,\n  ISudokuControlsProps,\n  IValidationDisplayProps,\n  ICageDisplayInfo,\n  ICageOverlayProps,\n  ICageSumIndicatorProps,\n  IKillerCombinationsMode,\n  ICombinationDisplayInfo,\n  IEliminationState,\n  IKillerCombinationsExplorerProps,\n  ICombinationCardProps,\n  ICombinationGridProps\n} from './types';\n\n// Compact control ribbon types\nexport type { ICompactControlRibbonProps } from './components/CompactControlRibbon';\n\n// Dual keypad types\nexport type { INumberKeypadProps } from './components/NumberKeypad';\nexport type { IDualKeypadProps } from './components/DualKeypad';\n\n// Responsive layout types\nexport type {\n  DeviceType,\n  ScreenOrientation,\n  KeypadLayoutMode,\n  IResponsiveLayoutInfo\n} from './hooks/useResponsiveLayout';\n\n// Keyboard shortcut types\nexport type { IKeyboardShortcutOptions } from './hooks/useKeyboardShortcut';\n"]}

package/lib-commonjs/test/fixtures/killerSudokuPuzzles.js

@@ -0,0 +1,60 @@
+"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.KILLER_SUDOKU_FIXTURES = exports.VALID_KILLER_SUDOKU = void 0;
+/**
+ * Stable killer sudoku puzzle definitions for testing.
+ * These puzzles have been validated and are used across multiple test files
+ * to ensure consistency in testing killer sudoku functionality.
+ *
+ * @remarks
+ * Killer sudoku cells format: "GRID_MAPPING|CAGE_DEFINITIONS"
+ * - GRID_MAPPING: 81 characters mapping each cell to a cage ID (A-Z, a-z)
+ * - CAGE_DEFINITIONS: Comma-separated list of cageId+total (e.g., "A11,B09,C20")
+ *
+ * Example: "AABBCC....|A11,B09,C20,..."
+ * - Cells 0-1 are in cage A with total 11
+ * - Cells 2-3 are in cage B with total 09
+ * - Cells 4-5 are in cage C with total 20
+ *
+ * @public
+ */
+/**
+ * Valid killer sudoku puzzle with complete cage definitions.
+ * This is a standard 9x9 killer sudoku with 27 cages.
+ */
+exports.VALID_KILLER_SUDOKU = 'ABCCCDDDEABFFGGGDEHIJKGGLLLHIJKMGLNNHOPPMQQNROOSTMUVWRSSSTTUVWRXYTTTZZabXYYYcccab|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';
+/**
+ * Collection of validated killer sudoku puzzles for testing.
+ */
+exports.KILLER_SUDOKU_FIXTURES = [
+    {
+        id: 'valid-killer-1',
+        description: 'Valid Killer Sudoku Puzzle',
+        level: 1,
+        cells: exports.VALID_KILLER_SUDOKU
+    }
+];
+//# sourceMappingURL=killerSudokuPuzzles.js.map

package/lib-commonjs/test/fixtures/killerSudokuPuzzles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"killerSudokuPuzzles.js","sourceRoot":"","sources":["../../../src/test/fixtures/killerSudokuPuzzles.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;;;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACU,QAAA,mBAAmB,GAC9B,uMAAuM,CAAC;AAY1M;;GAEG;AACU,QAAA,sBAAsB,GAA2B;IAC5D;QACE,EAAE,EAAE,gBAAgB;QACpB,WAAW,EAAE,4BAA4B;QACzC,KAAK,EAAE,CAAC;QACR,KAAK,EAAE,2BAAmB;KAC3B;CACF,CAAC","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\n/**\n * Stable killer sudoku puzzle definitions for testing.\n * These puzzles have been validated and are used across multiple test files\n * to ensure consistency in testing killer sudoku functionality.\n *\n * @remarks\n * Killer sudoku cells format: \"GRID_MAPPING|CAGE_DEFINITIONS\"\n * - GRID_MAPPING: 81 characters mapping each cell to a cage ID (A-Z, a-z)\n * - CAGE_DEFINITIONS: Comma-separated list of cageId+total (e.g., \"A11,B09,C20\")\n *\n * Example: \"AABBCC....|A11,B09,C20,...\"\n * - Cells 0-1 are in cage A with total 11\n * - Cells 2-3 are in cage B with total 09\n * - Cells 4-5 are in cage C with total 20\n *\n * @public\n */\n\n/**\n * Valid killer sudoku puzzle with complete cage definitions.\n * This is a standard 9x9 killer sudoku with 27 cages.\n */\nexport const VALID_KILLER_SUDOKU: string =\n  'ABCCCDDDEABFFGGGDEHIJKGGLLLHIJKMGLNNHOPPMQQNROOSTMUVWRSSSTTUVWRXYTTTZZabXYYYcccab|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';\n\n/**\n * Killer sudoku puzzle metadata.\n */\nexport interface IKillerSudokuFixture {\n  id: string;\n  description: string;\n  level: number;\n  cells: string;\n}\n\n/**\n * Collection of validated killer sudoku puzzles for testing.\n */\nexport const KILLER_SUDOKU_FIXTURES: IKillerSudokuFixture[] = [\n  {\n    id: 'valid-killer-1',\n    description: 'Valid Killer Sudoku Puzzle',\n    level: 1,\n    cells: VALID_KILLER_SUDOKU\n  }\n];\n"]}

package/lib-commonjs/test/unit/components/SudokuGridEntry.testHelpers.js

@@ -0,0 +1,125 @@
+"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.defaultProps = exports.invalidPuzzleDescription = exports.sudokuXPuzzleDescription = exports.simplePuzzleDescription = exports.validPuzzleDescription = exports.mockMatchMedia = exports.createPuzzleDefinition = void 0;
+exports.customRender = customRender;
+exports.advanceByLongPress = advanceByLongPress;
+exports.setWindowDimensions = setWindowDimensions;
+exports.renderWithMobilePortrait = renderWithMobilePortrait;
+exports.renderWithDesktop = renderWithDesktop;
+const react_1 = require("@testing-library/react");
+const puzzleDefinitionHelper_1 = require("../../../utils/puzzleDefinitionHelper");
+Object.defineProperty(exports, "createPuzzleDefinition", { enumerable: true, get: function () { return puzzleDefinitionHelper_1.createPuzzleDefinition; } });
+// Custom render function - just use standard render
+function customRender(ui, options) {
+    return (0, react_1.render)(ui, options);
+}
+// Helper function to simulate long press delay using fake timers
+function advanceByLongPress(ms = 600) {
+    (0, react_1.act)(() => {
+        jest.advanceTimersByTime(ms);
+    });
+}
+// Helper to set window dimensions for different device types
+function setWindowDimensions(width, height) {
+    Object.defineProperty(window, 'innerWidth', {
+        writable: true,
+        configurable: true,
+        value: width
+    });
+    Object.defineProperty(window, 'innerHeight', {
+        writable: true,
+        configurable: true,
+        value: height
+    });
+}
+// Helper to render with mobile portrait layout (side-by-side keypads)
+function renderWithMobilePortrait(component, options) {
+    setWindowDimensions(375, 667);
+    return customRender(component, options);
+}
+// Helper to render with desktop layout (hidden/overlay keypads)
+function renderWithDesktop(component, options) {
+    setWindowDimensions(1024, 768);
+    return customRender(component, options);
+}
+// Mock window.matchMedia for responsive layout tests
+const mockMatchMedia = (query) => {
+    return {
+        matches: false,
+        media: query,
+        onchange: null,
+        addListener: jest.fn(),
+        removeListener: jest.fn(),
+        addEventListener: jest.fn(),
+        removeEventListener: jest.fn(),
+        dispatchEvent: jest.fn()
+    };
+};
+exports.mockMatchMedia = mockMatchMedia;
+// Test puzzle definitions
+exports.validPuzzleDescription = (0, puzzleDefinitionHelper_1.createPuzzleDefinition)({
+    id: 'test-puzzle',
+    description: 'Test Puzzle',
+    type: 'sudoku',
+    level: 1,
+    totalRows: 9,
+    totalColumns: 9,
+    cells: '123456789456789123789123456234567891567891234891234567345678912678912345912345678'
+});
+exports.simplePuzzleDescription = (0, puzzleDefinitionHelper_1.createPuzzleDefinition)({
+    id: 'simple-puzzle',
+    description: 'Simple Test Puzzle',
+    type: 'sudoku',
+    level: 1,
+    totalRows: 9,
+    totalColumns: 9,
+    cells: '1' + '.'.repeat(80) // 81 total characters
+});
+exports.sudokuXPuzzleDescription = (0, puzzleDefinitionHelper_1.createPuzzleDefinition)({
+    id: 'sudoku-x-puzzle',
+    description: 'Sudoku-X Test Puzzle',
+    type: 'sudoku-x',
+    level: 1,
+    totalRows: 9,
+    totalColumns: 9,
+    cells: '.'.repeat(81)
+});
+exports.invalidPuzzleDescription = (0, puzzleDefinitionHelper_1.createPuzzleDefinition)({
+    id: 'invalid-puzzle',
+    description: 'Invalid Puzzle',
+    type: 'sudoku',
+    level: 1,
+    totalRows: 9,
+    totalColumns: 9,
+    cells: 'invalid' // Too short
+});
+exports.defaultProps = {
+    initialPuzzleDescription: undefined,
+    onStateChange: undefined,
+    onValidationErrors: undefined,
+    className: undefined
+};
+//# sourceMappingURL=SudokuGridEntry.testHelpers.js.map

package/lib-commonjs/test/unit/components/SudokuGridEntry.testHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SudokuGridEntry.testHelpers.js","sourceRoot":"","sources":["../../../../src/test/unit/components/SudokuGridEntry.testHelpers.ts"],"names":[],"mappings":"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","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 { render, RenderResult, RenderOptions, act } from '@testing-library/react';\nimport { IPuzzleDefinition } from '@fgv/ts-sudoku-lib';\nimport { createPuzzleDefinition } from '../../../utils/puzzleDefinitionHelper';\n\n// Re-export for use in test files\nexport type { IPuzzleDefinition };\nexport { createPuzzleDefinition };\n\n// Custom render function - just use standard render\nexport function customRender(ui: React.ReactElement, options?: RenderOptions): RenderResult {\n  return render(ui, options);\n}\n\n// Helper function to simulate long press delay using fake timers\nexport function advanceByLongPress(ms: number = 600): void {\n  act(() => {\n    jest.advanceTimersByTime(ms);\n  });\n}\n\n// Helper to set window dimensions for different device types\nexport function setWindowDimensions(width: number, height: number): void {\n  Object.defineProperty(window, 'innerWidth', {\n    writable: true,\n    configurable: true,\n    value: width\n  });\n  Object.defineProperty(window, 'innerHeight', {\n    writable: true,\n    configurable: true,\n    value: height\n  });\n}\n\n// Helper to render with mobile portrait layout (side-by-side keypads)\nexport function renderWithMobilePortrait(\n  component: React.ReactElement,\n  options?: RenderOptions\n): RenderResult {\n  setWindowDimensions(375, 667);\n  return customRender(component, options);\n}\n\n// Helper to render with desktop layout (hidden/overlay keypads)\nexport function renderWithDesktop(component: React.ReactElement, options?: RenderOptions): RenderResult {\n  setWindowDimensions(1024, 768);\n  return customRender(component, options);\n}\n\n// Mock window.matchMedia for responsive layout tests\nexport const mockMatchMedia = (query: string): MediaQueryList => {\n  return {\n    matches: false,\n    media: query,\n    onchange: null,\n    addListener: jest.fn(),\n    removeListener: jest.fn(),\n    addEventListener: jest.fn(),\n    removeEventListener: jest.fn(),\n    dispatchEvent: jest.fn()\n  } as unknown as MediaQueryList;\n};\n\n// Test puzzle definitions\nexport const validPuzzleDescription: IPuzzleDefinition = createPuzzleDefinition({\n  id: 'test-puzzle',\n  description: 'Test Puzzle',\n  type: 'sudoku',\n  level: 1,\n  totalRows: 9,\n  totalColumns: 9,\n  cells: '123456789456789123789123456234567891567891234891234567345678912678912345912345678'\n});\n\nexport const simplePuzzleDescription: IPuzzleDefinition = createPuzzleDefinition({\n  id: 'simple-puzzle',\n  description: 'Simple Test Puzzle',\n  type: 'sudoku',\n  level: 1,\n  totalRows: 9,\n  totalColumns: 9,\n  cells: '1' + '.'.repeat(80) // 81 total characters\n});\n\nexport const sudokuXPuzzleDescription: IPuzzleDefinition = createPuzzleDefinition({\n  id: 'sudoku-x-puzzle',\n  description: 'Sudoku-X Test Puzzle',\n  type: 'sudoku-x',\n  level: 1,\n  totalRows: 9,\n  totalColumns: 9,\n  cells: '.'.repeat(81)\n});\n\nexport const invalidPuzzleDescription: IPuzzleDefinition = createPuzzleDefinition({\n  id: 'invalid-puzzle',\n  description: 'Invalid Puzzle',\n  type: 'sudoku',\n  level: 1,\n  totalRows: 9,\n  totalColumns: 9,\n  cells: 'invalid' // Too short\n});\n\nexport const defaultProps: {\n  initialPuzzleDescription: undefined;\n  onStateChange: undefined;\n  onValidationErrors: undefined;\n  className: undefined;\n} = {\n  initialPuzzleDescription: undefined,\n  onStateChange: undefined,\n  onValidationErrors: undefined,\n  className: undefined\n};\n"]}

package/lib-commonjs/types/index.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=index.js.map

package/lib-commonjs/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.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 { CellId, ICellContents, NavigationDirection, IPuzzleDefinition, ICage } from '@fgv/ts-sudoku-lib';\nimport { KeypadLayoutMode } from '../hooks/useResponsiveLayout';\n\n/**\n * Validation error for display in the UI\n * @public\n */\nexport interface IValidationError {\n  readonly cellId: CellId;\n  readonly type:\n    | 'duplicate-row'\n    | 'duplicate-column'\n    | 'duplicate-section'\n    | 'duplicate-diagonal'\n    | 'invalid-value';\n  readonly conflictingCells: CellId[];\n  readonly message: string;\n}\n\n/**\n * Props for the main SudokuGridEntry component\n * @public\n */\nexport interface ISudokuGridEntryProps {\n  /**\n   * Optional initial puzzle session to load. If not provided, an empty puzzle is created.\n   */\n  readonly initialPuzzleDescription?: IPuzzleDefinition;\n\n  /**\n   * Callback fired when the puzzle state changes\n   */\n  readonly onStateChange?: (isValid: boolean, isSolved: boolean) => void;\n\n  /**\n   * Callback fired when validation errors occur\n   */\n  readonly onValidationErrors?: (errors: IValidationError[]) => void;\n\n  /**\n   * Optional CSS class name for styling\n   */\n  readonly className?: string;\n\n  /**\n   * Optional forced layout mode for testing (overrides responsive detection)\n   */\n  readonly forceLayoutMode?: KeypadLayoutMode;\n}\n\n/**\n * Props for the SudokuGrid component\n * @public\n */\nexport interface ISudokuGridProps {\n  readonly numRows: number;\n  readonly numColumns: number;\n  readonly cells: ICellDisplayInfo[];\n  readonly cages?: ICageDisplayInfo[];\n  readonly selectedCell: CellId | null;\n  readonly selectedCells: CellId[];\n  readonly inputMode: InputMode;\n  readonly puzzleType?: string;\n  readonly puzzleDimensions?: {\n    readonly cageHeightInCells: number;\n    readonly cageWidthInCells: number;\n    readonly boardWidthInCages: number;\n    readonly boardHeightInCages: number;\n    readonly totalRows: number;\n    readonly totalColumns: number;\n    readonly maxValue: number;\n    readonly totalCages: number;\n    readonly basicCageTotal: number;\n  };\n  readonly onCellSelect: (cellId: CellId, event?: React.MouseEvent) => void;\n  readonly onLongPressToggle?: (cellId: CellId, event: React.TouchEvent | React.MouseEvent) => void;\n  readonly onCellValueChange: (cellId: CellId, value: number | undefined) => void;\n  readonly onNoteToggle: (cellId: CellId, note: number) => void;\n  readonly onClearAllNotes: (cellId: CellId) => void;\n  readonly onNavigate: (direction: NavigationDirection) => void;\n  readonly onDragOver?: (cellId: CellId) => void;\n  readonly onDragEnd?: () => void;\n  readonly isDragging?: boolean;\n  readonly className?: string;\n}\n\n/**\n * Display information for a single cell\n * @public\n */\nexport interface ICellDisplayInfo {\n  readonly id: CellId;\n  readonly row: number;\n  readonly column: number;\n  readonly contents: ICellContents;\n  readonly isImmutable: boolean;\n  readonly hasValidationError: boolean;\n}\n\n/**\n * Input mode for cell interactions\n * @public\n */\nexport type InputMode = 'value' | 'notes';\n\n/**\n * Props for the SudokuCell component\n * @public\n */\nexport interface ISudokuCellProps {\n  readonly cellInfo: ICellDisplayInfo;\n  readonly isSelected: boolean;\n  readonly inputMode: InputMode;\n  readonly puzzleDimensions?: {\n    readonly numRows: number;\n    readonly numColumns: number;\n    readonly cageHeight: number;\n    readonly cageWidth: number;\n  };\n  readonly onSelect: (event?: React.MouseEvent) => void;\n  readonly onLongPressToggle?: (event: React.TouchEvent | React.MouseEvent) => void;\n  readonly onValueChange: (value: number | undefined) => void;\n  readonly onNoteToggle: (note: number) => void;\n  readonly onClearAllNotes: () => void;\n  readonly onDragOver?: () => void;\n  readonly className?: string;\n}\n\n/**\n * Props for the SudokuControls component\n * @public\n */\nexport interface ISudokuControlsProps {\n  readonly canUndo: boolean;\n  readonly canRedo: boolean;\n  readonly canReset: boolean;\n  readonly isValid: boolean;\n  readonly isSolved: boolean;\n  readonly onUndo: () => void;\n  readonly onRedo: () => void;\n  readonly onReset: () => void;\n  readonly onExport: () => void;\n  readonly className?: string;\n}\n\n/**\n * Props for the ValidationDisplay component\n * @public\n */\nexport interface IValidationDisplayProps {\n  readonly errors: IValidationError[];\n  readonly isValid: boolean;\n  readonly isSolved: boolean;\n  readonly className?: string;\n}\n\n/**\n * Display information for a cage in Killer Sudoku\n * @public\n */\nexport interface ICageDisplayInfo {\n  readonly cage: ICage;\n  readonly isHighlighted: boolean;\n  readonly currentSum?: number;\n  readonly isComplete: boolean;\n  readonly isValid: boolean;\n}\n\n/**\n * Props for the CageOverlay component\n * @public\n */\nexport interface ICageOverlayProps {\n  readonly cages: ICageDisplayInfo[];\n  readonly gridSize: { width: number; height: number };\n  readonly cellSize: number;\n  readonly numRows?: number;\n  readonly numColumns?: number;\n  readonly className?: string;\n}\n\n/**\n * Props for the CageSumIndicator component\n * @public\n */\nexport interface ICageSumIndicatorProps {\n  readonly cage: ICage;\n  readonly currentSum?: number;\n  readonly isComplete: boolean;\n  readonly isValid: boolean;\n  readonly position: { top: number; left: number };\n  readonly className?: string;\n}\n\n/**\n * Display mode for killer combinations explorer\n * @public\n */\nexport type IKillerCombinationsMode = 'panel' | 'modal';\n\n/**\n * Display information for a single combination\n * @public\n */\nexport interface ICombinationDisplayInfo {\n  readonly combination: number[];\n  readonly signature: string;\n  readonly isEliminated: boolean;\n}\n\n/**\n * State management for combination elimination\n * @public\n */\nexport interface IEliminationState {\n  readonly eliminatedSignatures: Set<string>;\n  readonly toggleElimination: (signature: string) => void;\n  readonly clearAll: () => void;\n}\n\n/**\n * Props for the KillerCombinationsExplorer component\n * @public\n */\nexport interface IKillerCombinationsExplorerProps {\n  readonly selectedCage: ICage | null;\n  readonly puzzleId?: string;\n  readonly isOpen: boolean;\n  readonly onClose: () => void;\n  readonly mobileBreakpoint?: number;\n  readonly className?: string;\n}\n\n/**\n * Props for the CombinationCard component\n * @public\n */\nexport interface ICombinationCardProps {\n  readonly combination: ICombinationDisplayInfo;\n  readonly onToggle: (signature: string) => void;\n  readonly className?: string;\n}\n\n/**\n * Props for the CombinationGrid component\n * @public\n */\nexport interface ICombinationGridProps {\n  readonly combinations: ICombinationDisplayInfo[];\n  readonly onToggle: (signature: string) => void;\n  readonly mode: IKillerCombinationsMode;\n  readonly className?: string;\n}\n"]}

package/lib-commonjs/utils/CageLookupManager.js

@@ -0,0 +1,287 @@
+"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.CageLookupManager = exports.SegmentBit = void 0;
+/**
+ * Segment bit positions for the 12-bit mask
+ */
+var SegmentBit;
+(function (SegmentBit) {
+    // Edges (bits 0-3)
+    SegmentBit[SegmentBit["EDGE_TOP"] = 1] = "EDGE_TOP";
+    SegmentBit[SegmentBit["EDGE_RIGHT"] = 2] = "EDGE_RIGHT";
+    SegmentBit[SegmentBit["EDGE_BOTTOM"] = 4] = "EDGE_BOTTOM";
+    SegmentBit[SegmentBit["EDGE_LEFT"] = 8] = "EDGE_LEFT";
+    // Corner connectors (bits 4-7)
+    SegmentBit[SegmentBit["CORNER_TOP_RIGHT"] = 16] = "CORNER_TOP_RIGHT";
+    SegmentBit[SegmentBit["CORNER_BOTTOM_RIGHT"] = 32] = "CORNER_BOTTOM_RIGHT";
+    SegmentBit[SegmentBit["CORNER_BOTTOM_LEFT"] = 64] = "CORNER_BOTTOM_LEFT";
+    SegmentBit[SegmentBit["CORNER_TOP_LEFT"] = 128] = "CORNER_TOP_LEFT";
+    // Internal segments (bits 8-11)
+    SegmentBit[SegmentBit["INTERNAL_TOP"] = 256] = "INTERNAL_TOP";
+    SegmentBit[SegmentBit["INTERNAL_RIGHT"] = 512] = "INTERNAL_RIGHT";
+    SegmentBit[SegmentBit["INTERNAL_BOTTOM"] = 1024] = "INTERNAL_BOTTOM";
+    SegmentBit[SegmentBit["INTERNAL_LEFT"] = 2048] = "INTERNAL_LEFT";
+})(SegmentBit || (exports.SegmentBit = SegmentBit = {}));
+/**
+ * Two-stage lookup manager for cage border rendering
+ * Stage 1: 8-neighbor pattern → segment pattern ID (256 → 47)
+ * Stage 2: segment pattern ID → SVG path data (47 unique patterns)
+ */
+class CageLookupManager {
+    constructor() {
+        // Stage 1: Neighbor pattern (8-bit) to segment pattern ID mapping
+        this._neighborToSegmentLookup = new Array(256);
+        // Stage 2: Segment pattern ID to SVG path data mapping
+        this._segmentPatterns = [];
+        // Reverse lookup for debugging: segment mask to pattern ID
+        this._segmentMaskToId = new Map();
+        this._generateLookupTables();
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!CageLookupManager._instance) {
+            CageLookupManager._instance = new CageLookupManager();
+        }
+        return CageLookupManager._instance;
+    }
+    /**
+     * Convert neighbor analysis to 8-bit pattern
+     */
+    neighborsToPattern(neighbors) {
+        // should be bitwise or but that makes eslint cranky
+        return ((neighbors.north ? 1 : 0) +
+            (neighbors.northEast ? 2 : 0) +
+            (neighbors.east ? 4 : 0) +
+            (neighbors.southEast ? 8 : 0) +
+            (neighbors.south ? 16 : 0) +
+            (neighbors.southWest ? 32 : 0) +
+            (neighbors.west ? 64 : 0) +
+            (neighbors.northWest ? 128 : 0));
+    }
+    /**
+     * Get SVG path data for a given neighbor pattern
+     */
+    getPatternSVG(neighborPattern) {
+        if (neighborPattern < 0 || neighborPattern >= 256) {
+            throw new Error(`Invalid neighbor pattern: ${neighborPattern}`);
+        }
+        const segmentPatternId = this._neighborToSegmentLookup[neighborPattern];
+        return this._segmentPatterns[segmentPatternId];
+    }
+    /**
+     * Get segment pattern ID for debugging
+     */
+    getSegmentPatternId(neighborPattern) {
+        return this._neighborToSegmentLookup[neighborPattern];
+    }
+    /**
+     * Get total number of unique segment patterns
+     */
+    get uniquePatternCount() {
+        return this._segmentPatterns.length;
+    }
+    /**
+     * Generate both lookup tables
+     */
+    _generateLookupTables() {
+        // First pass: generate all unique segment masks and assign IDs
+        const uniqueSegmentMasks = new Set();
+        for (let neighborPattern = 0; neighborPattern < 256; neighborPattern++) {
+            const segmentMask = this._calculateSegmentMask(neighborPattern);
+            uniqueSegmentMasks.add(segmentMask);
+        }
+        // Convert to sorted array for consistent ordering
+        const sortedSegmentMasks = Array.from(uniqueSegmentMasks).sort((a, b) => a - b);
+        // Generate SVG patterns for each unique segment mask
+        for (let i = 0; i < sortedSegmentMasks.length; i++) {
+            const segmentMask = sortedSegmentMasks[i];
+            this._segmentMaskToId.set(segmentMask, i);
+            this._segmentPatterns[i] = this._generateSVGPattern(segmentMask);
+        }
+        // Second pass: populate neighbor-to-segment lookup
+        for (let neighborPattern = 0; neighborPattern < 256; neighborPattern++) {
+            const segmentMask = this._calculateSegmentMask(neighborPattern);
+            const segmentPatternId = this._segmentMaskToId.get(segmentMask);
+            this._neighborToSegmentLookup[neighborPattern] = segmentPatternId;
+        }
+    }
+    /**
+     * Calculate segment mask from 8-bit neighbor pattern
+     */
+    _calculateSegmentMask(neighborPattern) {
+        // Extract individual neighbor bits
+        // eslint-disable-next-line no-bitwise
+        const n = Boolean(neighborPattern & 1); // North
+        // eslint-disable-next-line no-bitwise
+        const ne = Boolean(neighborPattern & 2); // NorthEast
+        // eslint-disable-next-line no-bitwise
+        const e = Boolean(neighborPattern & 4); // East
+        // eslint-disable-next-line no-bitwise
+        const se = Boolean(neighborPattern & 8); // SouthEast
+        // eslint-disable-next-line no-bitwise
+        const s = Boolean(neighborPattern & 16); // South
+        // eslint-disable-next-line no-bitwise
+        const sw = Boolean(neighborPattern & 32); // SouthWest
+        // eslint-disable-next-line no-bitwise
+        const w = Boolean(neighborPattern & 64); // West
+        // eslint-disable-next-line no-bitwise
+        const nw = Boolean(neighborPattern & 128); // NorthWest
+        let segmentMask = 0;
+        // Edges: Draw when corresponding cardinal neighbor is NOT present
+        // eslint-disable-next-line no-bitwise
+        if (!n)
+            segmentMask |= SegmentBit.EDGE_TOP;
+        // eslint-disable-next-line no-bitwise
+        if (!e)
+            segmentMask |= SegmentBit.EDGE_RIGHT;
+        // eslint-disable-next-line no-bitwise
+        if (!s)
+            segmentMask |= SegmentBit.EDGE_BOTTOM;
+        // eslint-disable-next-line no-bitwise
+        if (!w)
+            segmentMask |= SegmentBit.EDGE_LEFT;
+        // Internal segments: Draw when corresponding cardinal neighbor IS present
+        // eslint-disable-next-line no-bitwise
+        if (n)
+            segmentMask |= SegmentBit.INTERNAL_TOP;
+        // eslint-disable-next-line no-bitwise
+        if (e)
+            segmentMask |= SegmentBit.INTERNAL_RIGHT;
+        // eslint-disable-next-line no-bitwise
+        if (s)
+            segmentMask |= SegmentBit.INTERNAL_BOTTOM;
+        // eslint-disable-next-line no-bitwise
+        if (w)
+            segmentMask |= SegmentBit.INTERNAL_LEFT;
+        // Corner connectors: Draw when diagonal is missing but both adjacent cardinals are present
+        // eslint-disable-next-line no-bitwise
+        if (!ne && n && e)
+            segmentMask |= SegmentBit.CORNER_TOP_RIGHT;
+        // eslint-disable-next-line no-bitwise
+        if (!se && s && e)
+            segmentMask |= SegmentBit.CORNER_BOTTOM_RIGHT;
+        // eslint-disable-next-line no-bitwise
+        if (!sw && s && w)
+            segmentMask |= SegmentBit.CORNER_BOTTOM_LEFT;
+        // eslint-disable-next-line no-bitwise
+        if (!nw && n && w)
+            segmentMask |= SegmentBit.CORNER_TOP_LEFT;
+        return segmentMask;
+    }
+    /**
+     * Generate SVG path data for a segment mask
+     */
+    _generateSVGPattern(segmentMask) {
+        const paths = [];
+        const inset = 0.1; // Standard inset for cage boundaries
+        const edgeExtension = 0.0; // Extend to cell edge for connections
+        // Determine which segments have internal connections (need to extend to edge)
+        // eslint-disable-next-line no-bitwise
+        const hasInternalTop = Boolean(segmentMask & SegmentBit.INTERNAL_TOP);
+        // eslint-disable-next-line no-bitwise
+        const hasInternalRight = Boolean(segmentMask & SegmentBit.INTERNAL_RIGHT);
+        // eslint-disable-next-line no-bitwise
+        const hasInternalBottom = Boolean(segmentMask & SegmentBit.INTERNAL_BOTTOM);
+        // eslint-disable-next-line no-bitwise
+        const hasInternalLeft = Boolean(segmentMask & SegmentBit.INTERNAL_LEFT);
+        // Edge segments - draw main segment with standard inset, then extensions to edge where needed
+        // eslint-disable-next-line no-bitwise
+        if (segmentMask & SegmentBit.EDGE_TOP) {
+            // Main horizontal segment
+            paths.push(`M${inset},${inset} L${1 - inset},${inset}`);
+            // Extensions to cell edges where there are internal connections
+            if (hasInternalLeft) {
+                paths.push(`M${edgeExtension},${inset} L${inset},${inset}`);
+            }
+            if (hasInternalRight) {
+                paths.push(`M${1 - inset},${inset} L${1 - edgeExtension},${inset}`);
+            }
+        }
+        // eslint-disable-next-line no-bitwise
+        if (segmentMask & SegmentBit.EDGE_RIGHT) {
+            // Main vertical segment
+            paths.push(`M${1 - inset},${inset} L${1 - inset},${1 - inset}`);
+            // Extensions to cell edges where there are internal connections
+            if (hasInternalTop) {
+                paths.push(`M${1 - inset},${edgeExtension} L${1 - inset},${inset}`);
+            }
+            if (hasInternalBottom) {
+                paths.push(`M${1 - inset},${1 - inset} L${1 - inset},${1 - edgeExtension}`);
+            }
+        }
+        // eslint-disable-next-line no-bitwise
+        if (segmentMask & SegmentBit.EDGE_BOTTOM) {
+            // Main horizontal segment
+            paths.push(`M${1 - inset},${1 - inset} L${inset},${1 - inset}`);
+            // Extensions to cell edges where there are internal connections
+            if (hasInternalRight) {
+                paths.push(`M${1 - edgeExtension},${1 - inset} L${1 - inset},${1 - inset}`);
+            }
+            if (hasInternalLeft) {
+                paths.push(`M${inset},${1 - inset} L${edgeExtension},${1 - inset}`);
+            }
+        }
+        // eslint-disable-next-line no-bitwise
+        if (segmentMask & SegmentBit.EDGE_LEFT) {
+            // Main vertical segment
+            paths.push(`M${inset},${1 - inset} L${inset},${inset}`);
+            // Extensions to cell edges where there are internal connections
+            if (hasInternalBottom) {
+                paths.push(`M${inset},${1 - edgeExtension} L${inset},${1 - inset}`);
+            }
+            if (hasInternalTop) {
+                paths.push(`M${inset},${inset} L${inset},${edgeExtension}`);
+            }
+        }
+        // Corner connectors - extend outward from cage corners
+        const cornerRadius = 0.08;
+        // eslint-disable-next-line no-bitwise
+        if (segmentMask & SegmentBit.CORNER_TOP_RIGHT) {
+            // Extend outward from top-right corner
+            paths.push(`M${1 - inset},${inset} L${1 - inset + cornerRadius},${inset} M${1 - inset},${inset} L${1 - inset},${inset - cornerRadius}`);
+        }
+        // eslint-disable-next-line no-bitwise
+        if (segmentMask & SegmentBit.CORNER_BOTTOM_RIGHT) {
+            // Extend outward from bottom-right corner
+            paths.push(`M${1 - inset},${1 - inset} L${1 - inset + cornerRadius},${1 - inset} M${1 - inset},${1 - inset} L${1 - inset},${1 - inset + cornerRadius}`);
+        }
+        // eslint-disable-next-line no-bitwise
+        if (segmentMask & SegmentBit.CORNER_BOTTOM_LEFT) {
+            // Extend outward from bottom-left corner
+            paths.push(`M${inset},${1 - inset} L${inset - cornerRadius},${1 - inset} M${inset},${1 - inset} L${inset},${1 - inset + cornerRadius}`);
+        }
+        // eslint-disable-next-line no-bitwise
+        if (segmentMask & SegmentBit.CORNER_TOP_LEFT) {
+            // Extend outward from top-left corner
+            paths.push(`M${inset},${inset} L${inset - cornerRadius},${inset} M${inset},${inset} L${inset},${inset - cornerRadius}`);
+        }
+        return paths.join(' ');
+    }
+}
+exports.CageLookupManager = CageLookupManager;
+//# sourceMappingURL=CageLookupManager.js.map