@fgv/ts-sudoku-ui 0.1.0

package/lib/contexts/DiagnosticLoggerContext.d.ts

@@ -0,0 +1,81 @@
+import React, { ReactNode } from 'react';
+import { Logging } from '@fgv/ts-utils';
+/**
+ * Default diagnostic logger (no-op for production).
+ * @public
+ */
+export declare const DefaultDiagnosticLogger: Logging.LogReporter<unknown>;
+/**
+ * React context for diagnostic logging.
+ * Provides access to diagnostic logger throughout the component tree.
+ * @public
+ */
+export declare const DiagnosticLoggerContext: React.Context<Logging.LogReporter<unknown>>;
+/**
+ * Props for the DiagnosticLoggerProvider component.
+ * @public
+ */
+export interface IDiagnosticLoggerProviderProps {
+    /** Child components that will have access to the diagnostic logger */
+    children: ReactNode;
+    /** Optional logger to provide (defaults to no-op logger) */
+    logger?: Logging.LogReporter<unknown>;
+}
+/**
+ * Provider component that makes diagnostic logger available to all child components.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage with default no-op logger
+ * <DiagnosticLoggerProvider>
+ *   <SudokuGrid />
+ * </DiagnosticLoggerProvider>
+ *
+ * // Console logging for development
+ * const consoleLogger = new Logging.LogReporter({
+ *   logger: new Logging.ConsoleLogger('info')
+ * });
+ * <DiagnosticLoggerProvider logger={consoleLogger}>
+ *   <SudokuGrid />
+ * </DiagnosticLoggerProvider>
+ *
+ * // In-memory logger for tests
+ * const testLogger = new Logging.LogReporter({
+ *   logger: new Logging.InMemoryLogger('detail')
+ * });
+ * <DiagnosticLoggerProvider logger={testLogger}>
+ *   <SudokuGrid />
+ * </DiagnosticLoggerProvider>
+ * ```
+ *
+ * @param props - Provider configuration
+ * @returns JSX provider element
+ * @public
+ */
+export declare const DiagnosticLoggerProvider: React.FC<IDiagnosticLoggerProviderProps>;
+/**
+ * Hook to access the current diagnostic logger.
+ *
+ * Provides access to diagnostic logging for development and debugging.
+ *
+ * @example
+ * ```tsx
+ * function CageOverlay({ cages }: ICageOverlayProps) {
+ *   const log = useDiagnosticLogger();
+ *
+ *   useEffect(() => {
+ *     log.info('CageOverlay rendered', {
+ *       cageCount: cages.length,
+ *       cages: cages.map((c) => ({ id: c.cage.id, cellIds: c.cage.cellIds }))
+ *     });
+ *   }, [cages, log]);
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ *
+ * @returns The current diagnostic logger
+ * @public
+ */
+export declare const useDiagnosticLogger: () => Logging.LogReporter<unknown>;
+//# sourceMappingURL=DiagnosticLoggerContext.d.ts.map

package/lib/contexts/DiagnosticLoggerContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DiagnosticLoggerContext.d.ts","sourceRoot":"","sources":["../../src/contexts/DiagnosticLoggerContext.tsx"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,EAA6B,SAAS,EAAE,MAAM,OAAO,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,OAAO,CAAC,WAAW,CAAC,OAAO,CAE/D,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CACV,CAAC;AAEvE;;;GAGG;AACH,MAAM,WAAW,8BAA8B;IAC7C,sEAAsE;IACtE,QAAQ,EAAE,SAAS,CAAC;IACpB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,wBAAwB,EAAE,KAAK,CAAC,EAAE,CAAC,8BAA8B,CAGsB,CAAC;AAErG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB,QAAO,OAAO,CAAC,WAAW,CAAC,OAAO,CAEjE,CAAC"}

package/lib/contexts/DiagnosticLoggerContext.js

@@ -0,0 +1,98 @@
+/*
+ * 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 React, { createContext, useContext } from 'react';
+import { Logging } from '@fgv/ts-utils';
+/**
+ * Default diagnostic logger (no-op for production).
+ * @public
+ */
+export const DefaultDiagnosticLogger = new Logging.LogReporter({
+    logger: new Logging.NoOpLogger()
+});
+/**
+ * React context for diagnostic logging.
+ * Provides access to diagnostic logger throughout the component tree.
+ * @public
+ */
+export const DiagnosticLoggerContext = createContext(DefaultDiagnosticLogger);
+/**
+ * Provider component that makes diagnostic logger available to all child components.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage with default no-op logger
+ * <DiagnosticLoggerProvider>
+ *   <SudokuGrid />
+ * </DiagnosticLoggerProvider>
+ *
+ * // Console logging for development
+ * const consoleLogger = new Logging.LogReporter({
+ *   logger: new Logging.ConsoleLogger('info')
+ * });
+ * <DiagnosticLoggerProvider logger={consoleLogger}>
+ *   <SudokuGrid />
+ * </DiagnosticLoggerProvider>
+ *
+ * // In-memory logger for tests
+ * const testLogger = new Logging.LogReporter({
+ *   logger: new Logging.InMemoryLogger('detail')
+ * });
+ * <DiagnosticLoggerProvider logger={testLogger}>
+ *   <SudokuGrid />
+ * </DiagnosticLoggerProvider>
+ * ```
+ *
+ * @param props - Provider configuration
+ * @returns JSX provider element
+ * @public
+ */
+export const DiagnosticLoggerProvider = ({ children, logger = DefaultDiagnosticLogger }) => React.createElement(DiagnosticLoggerContext.Provider, { value: logger }, children);
+/**
+ * Hook to access the current diagnostic logger.
+ *
+ * Provides access to diagnostic logging for development and debugging.
+ *
+ * @example
+ * ```tsx
+ * function CageOverlay({ cages }: ICageOverlayProps) {
+ *   const log = useDiagnosticLogger();
+ *
+ *   useEffect(() => {
+ *     log.info('CageOverlay rendered', {
+ *       cageCount: cages.length,
+ *       cages: cages.map((c) => ({ id: c.cage.id, cellIds: c.cage.cellIds }))
+ *     });
+ *   }, [cages, log]);
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ *
+ * @returns The current diagnostic logger
+ * @public
+ */
+export const useDiagnosticLogger = () => {
+    return useContext(DiagnosticLoggerContext);
+};
+//# sourceMappingURL=DiagnosticLoggerContext.js.map

package/lib/contexts/DiagnosticLoggerContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DiagnosticLoggerContext.js","sourceRoot":"","sources":["../../src/contexts/DiagnosticLoggerContext.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,EAAE,aAAa,EAAE,UAAU,EAAa,MAAM,OAAO,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAiC,IAAI,OAAO,CAAC,WAAW,CAAC;IAC3F,MAAM,EAAE,IAAI,OAAO,CAAC,UAAU,EAAE;CACjC,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAClC,aAAa,CAA+B,uBAAuB,CAAC,CAAC;AAavE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAA6C,CAAC,EACjF,QAAQ,EACR,MAAM,GAAG,uBAAuB,EACjC,EAAE,EAAE,CAAC,oBAAC,uBAAuB,CAAC,QAAQ,IAAC,KAAK,EAAE,MAAM,IAAG,QAAQ,CAAoC,CAAC;AAErG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAiC,EAAE;IACpE,OAAO,UAAU,CAAC,uBAAuB,CAAC,CAAC;AAC7C,CAAC,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\nimport React, { createContext, useContext, ReactNode } from 'react';\nimport { Logging } from '@fgv/ts-utils';\n\n/**\n * Default diagnostic logger (no-op for production).\n * @public\n */\nexport const DefaultDiagnosticLogger: Logging.LogReporter<unknown> = new Logging.LogReporter({\n  logger: new Logging.NoOpLogger()\n});\n\n/**\n * React context for diagnostic logging.\n * Provides access to diagnostic logger throughout the component tree.\n * @public\n */\nexport const DiagnosticLoggerContext: React.Context<Logging.LogReporter<unknown>> =\n  createContext<Logging.LogReporter<unknown>>(DefaultDiagnosticLogger);\n\n/**\n * Props for the DiagnosticLoggerProvider component.\n * @public\n */\nexport interface IDiagnosticLoggerProviderProps {\n  /** Child components that will have access to the diagnostic logger */\n  children: ReactNode;\n  /** Optional logger to provide (defaults to no-op logger) */\n  logger?: Logging.LogReporter<unknown>;\n}\n\n/**\n * Provider component that makes diagnostic logger available to all child components.\n *\n * @example\n * ```tsx\n * // Basic usage with default no-op logger\n * <DiagnosticLoggerProvider>\n *   <SudokuGrid />\n * </DiagnosticLoggerProvider>\n *\n * // Console logging for development\n * const consoleLogger = new Logging.LogReporter({\n *   logger: new Logging.ConsoleLogger('info')\n * });\n * <DiagnosticLoggerProvider logger={consoleLogger}>\n *   <SudokuGrid />\n * </DiagnosticLoggerProvider>\n *\n * // In-memory logger for tests\n * const testLogger = new Logging.LogReporter({\n *   logger: new Logging.InMemoryLogger('detail')\n * });\n * <DiagnosticLoggerProvider logger={testLogger}>\n *   <SudokuGrid />\n * </DiagnosticLoggerProvider>\n * ```\n *\n * @param props - Provider configuration\n * @returns JSX provider element\n * @public\n */\nexport const DiagnosticLoggerProvider: React.FC<IDiagnosticLoggerProviderProps> = ({\n  children,\n  logger = DefaultDiagnosticLogger\n}) => <DiagnosticLoggerContext.Provider value={logger}>{children}</DiagnosticLoggerContext.Provider>;\n\n/**\n * Hook to access the current diagnostic logger.\n *\n * Provides access to diagnostic logging for development and debugging.\n *\n * @example\n * ```tsx\n * function CageOverlay({ cages }: ICageOverlayProps) {\n *   const log = useDiagnosticLogger();\n *\n *   useEffect(() => {\n *     log.info('CageOverlay rendered', {\n *       cageCount: cages.length,\n *       cages: cages.map((c) => ({ id: c.cage.id, cellIds: c.cage.cellIds }))\n *     });\n *   }, [cages, log]);\n *\n *   return <div>...</div>;\n * }\n * ```\n *\n * @returns The current diagnostic logger\n * @public\n */\nexport const useDiagnosticLogger = (): Logging.LogReporter<unknown> => {\n  return useContext(DiagnosticLoggerContext);\n};\n"]}

package/lib/contexts/index.d.ts

@@ -0,0 +1,3 @@
+export { DiagnosticLoggerContext, DiagnosticLoggerProvider, useDiagnosticLogger, DefaultDiagnosticLogger } from './DiagnosticLoggerContext';
+export type { IDiagnosticLoggerProviderProps } from './DiagnosticLoggerContext';
+//# sourceMappingURL=index.d.ts.map

package/lib/contexts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contexts/index.ts"],"names":[],"mappings":"AAwBA,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC"}

package/lib/contexts/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 { DiagnosticLoggerContext, DiagnosticLoggerProvider, useDiagnosticLogger, DefaultDiagnosticLogger } from './DiagnosticLoggerContext';
+//# sourceMappingURL=index.js.map

package/lib/contexts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contexts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,2BAA2B,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\nexport {\n  DiagnosticLoggerContext,\n  DiagnosticLoggerProvider,\n  useDiagnosticLogger,\n  DefaultDiagnosticLogger\n} from './DiagnosticLoggerContext';\nexport type { IDiagnosticLoggerProviderProps } from './DiagnosticLoggerContext';\n"]}

package/lib/hooks/useCombinationElimination.d.ts

@@ -0,0 +1,10 @@
+import { IEliminationState } from '../types';
+/**
+ * Hook for managing combination elimination state with session storage persistence
+ * @param puzzleId - Unique identifier for the puzzle
+ * @param cageId - Unique identifier for the cage
+ * @returns Elimination state with toggle and clear operations
+ * @public
+ */
+export declare function useCombinationElimination(puzzleId: string | undefined, cageId: string | undefined): IEliminationState;
+//# sourceMappingURL=useCombinationElimination.d.ts.map

package/lib/hooks/useCombinationElimination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCombinationElimination.d.ts","sourceRoot":"","sources":["../../src/hooks/useCombinationElimination.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAmD7C;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,iBAAiB,CAkDnB"}

package/lib/hooks/useCombinationElimination.js

@@ -0,0 +1,123 @@
+/*
+ * 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 { useState, useCallback, useEffect } from 'react';
+/**
+ * Generate session storage key for a cage's eliminated combinations
+ */
+function getStorageKey(puzzleId, cageId) {
+    return `killer-combinations-${puzzleId}-${cageId}`;
+}
+/**
+ * Load eliminated combinations from session storage
+ */
+function loadFromSessionStorage(puzzleId, cageId) {
+    try {
+        const key = getStorageKey(puzzleId, cageId);
+        const stored = sessionStorage.getItem(key);
+        if (stored) {
+            const parsed = JSON.parse(stored);
+            return new Set(parsed);
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return new Set();
+}
+/**
+ * Save eliminated combinations to session storage
+ */
+function saveToSessionStorage(puzzleId, cageId, eliminated) {
+    try {
+        const key = getStorageKey(puzzleId, cageId);
+        const array = Array.from(eliminated);
+        sessionStorage.setItem(key, JSON.stringify(array));
+    }
+    catch {
+        // Ignore storage errors
+    }
+}
+/**
+ * Clear eliminated combinations from session storage
+ */
+function clearFromSessionStorage(puzzleId, cageId) {
+    try {
+        const key = getStorageKey(puzzleId, cageId);
+        sessionStorage.removeItem(key);
+    }
+    catch {
+        // Ignore storage errors
+    }
+}
+/**
+ * Hook for managing combination elimination state with session storage persistence
+ * @param puzzleId - Unique identifier for the puzzle
+ * @param cageId - Unique identifier for the cage
+ * @returns Elimination state with toggle and clear operations
+ * @public
+ */
+export function useCombinationElimination(puzzleId, cageId) {
+    const [eliminated, setEliminated] = useState(() => {
+        if (!puzzleId || !cageId) {
+            return new Set();
+        }
+        return loadFromSessionStorage(puzzleId, cageId);
+    });
+    // Update state when puzzleId or cageId changes
+    useEffect(() => {
+        if (!puzzleId || !cageId) {
+            setEliminated(new Set());
+            return;
+        }
+        setEliminated(loadFromSessionStorage(puzzleId, cageId));
+    }, [puzzleId, cageId]);
+    const toggleElimination = useCallback((signature) => {
+        setEliminated((prev) => {
+            const next = new Set(prev);
+            if (next.has(signature)) {
+                next.delete(signature);
+            }
+            else {
+                next.add(signature);
+            }
+            // Persist to session storage
+            if (puzzleId && cageId) {
+                saveToSessionStorage(puzzleId, cageId, next);
+            }
+            return next;
+        });
+    }, [puzzleId, cageId]);
+    const clearAll = useCallback(() => {
+        setEliminated(new Set());
+        if (puzzleId && cageId) {
+            clearFromSessionStorage(puzzleId, cageId);
+        }
+    }, [puzzleId, cageId]);
+    return {
+        eliminatedSignatures: eliminated,
+        toggleElimination,
+        clearAll
+    };
+}
+//# sourceMappingURL=useCombinationElimination.js.map

package/lib/hooks/useCombinationElimination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCombinationElimination.js","sourceRoot":"","sources":["../../src/hooks/useCombinationElimination.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 { useState, useCallback, useEffect } from 'react';\nimport { IEliminationState } from '../types';\n\n/**\n * Generate session storage key for a cage's eliminated combinations\n */\nfunction getStorageKey(puzzleId: string, cageId: string): string {\n  return `killer-combinations-${puzzleId}-${cageId}`;\n}\n\n/**\n * Load eliminated combinations from session storage\n */\nfunction loadFromSessionStorage(puzzleId: string, cageId: string): Set<string> {\n  try {\n    const key = getStorageKey(puzzleId, cageId);\n    const stored = sessionStorage.getItem(key);\n    if (stored) {\n      const parsed = JSON.parse(stored) as string[];\n      return new Set(parsed);\n    }\n  } catch {\n    // Ignore parse errors\n  }\n  return new Set();\n}\n\n/**\n * Save eliminated combinations to session storage\n */\nfunction saveToSessionStorage(puzzleId: string, cageId: string, eliminated: Set<string>): void {\n  try {\n    const key = getStorageKey(puzzleId, cageId);\n    const array = Array.from(eliminated);\n    sessionStorage.setItem(key, JSON.stringify(array));\n  } catch {\n    // Ignore storage errors\n  }\n}\n\n/**\n * Clear eliminated combinations from session storage\n */\nfunction clearFromSessionStorage(puzzleId: string, cageId: string): void {\n  try {\n    const key = getStorageKey(puzzleId, cageId);\n    sessionStorage.removeItem(key);\n  } catch {\n    // Ignore storage errors\n  }\n}\n\n/**\n * Hook for managing combination elimination state with session storage persistence\n * @param puzzleId - Unique identifier for the puzzle\n * @param cageId - Unique identifier for the cage\n * @returns Elimination state with toggle and clear operations\n * @public\n */\nexport function useCombinationElimination(\n  puzzleId: string | undefined,\n  cageId: string | undefined\n): IEliminationState {\n  const [eliminated, setEliminated] = useState<Set<string>>(() => {\n    if (!puzzleId || !cageId) {\n      return new Set();\n    }\n    return loadFromSessionStorage(puzzleId, cageId);\n  });\n\n  // Update state when puzzleId or cageId changes\n  useEffect(() => {\n    if (!puzzleId || !cageId) {\n      setEliminated(new Set());\n      return;\n    }\n    setEliminated(loadFromSessionStorage(puzzleId, cageId));\n  }, [puzzleId, cageId]);\n\n  const toggleElimination = useCallback(\n    (signature: string) => {\n      setEliminated((prev) => {\n        const next = new Set(prev);\n        if (next.has(signature)) {\n          next.delete(signature);\n        } else {\n          next.add(signature);\n        }\n\n        // Persist to session storage\n        if (puzzleId && cageId) {\n          saveToSessionStorage(puzzleId, cageId, next);\n        }\n\n        return next;\n      });\n    },\n    [puzzleId, cageId]\n  );\n\n  const clearAll = useCallback(() => {\n    setEliminated(new Set());\n    if (puzzleId && cageId) {\n      clearFromSessionStorage(puzzleId, cageId);\n    }\n  }, [puzzleId, cageId]);\n\n  return {\n    eliminatedSignatures: eliminated,\n    toggleElimination,\n    clearAll\n  };\n}\n"]}

package/lib/hooks/useKeyboardShortcut.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Options for keyboard shortcut configuration
+ * @public
+ */
+export interface IKeyboardShortcutOptions {
+    readonly ctrl?: boolean;
+    readonly meta?: boolean;
+    readonly shift?: boolean;
+    readonly preventDefault?: boolean;
+}
+/**
+ * Hook for registering global keyboard shortcuts
+ * @param key - The key to listen for (e.g., 'k', 'Escape')
+ * @param callback - Function to call when shortcut is activated
+ * @param options - Optional modifier keys and behavior
+ * @public
+ */
+export declare function useKeyboardShortcut(key: string, callback: () => void, options?: IKeyboardShortcutOptions): void;
+//# sourceMappingURL=useKeyboardShortcut.d.ts.map

package/lib/hooks/useKeyboardShortcut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardShortcut.d.ts","sourceRoot":"","sources":["../../src/hooks/useKeyboardShortcut.ts"],"names":[],"mappings":"AA0BA;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;CACnC;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,IAAI,EACpB,OAAO,CAAC,EAAE,wBAAwB,GACjC,IAAI,CA2BN"}

package/lib/hooks/useKeyboardShortcut.js

@@ -0,0 +1,55 @@
+/*
+ * 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 { useEffect } from 'react';
+/**
+ * Hook for registering global keyboard shortcuts
+ * @param key - The key to listen for (e.g., 'k', 'Escape')
+ * @param callback - Function to call when shortcut is activated
+ * @param options - Optional modifier keys and behavior
+ * @public
+ */
+export function useKeyboardShortcut(key, callback, options) {
+    useEffect(() => {
+        function handleKeyDown(event) {
+            const matchesKey = event.key.toLowerCase() === key.toLowerCase();
+            // Check modifier keys if specified
+            const matchesCtrl = options?.ctrl ? event.ctrlKey : !event.ctrlKey;
+            const matchesMeta = options?.meta ? event.metaKey : !event.metaKey;
+            const matchesShift = options?.shift ? event.shiftKey : !event.shiftKey;
+            // For cross-platform support, treat Ctrl+K on Windows/Linux as Cmd+K on Mac
+            const isPlatformShortcut = options?.ctrl && options?.meta
+                ? (event.ctrlKey || event.metaKey) && !event.shiftKey
+                : matchesCtrl && matchesMeta && matchesShift;
+            if (matchesKey && isPlatformShortcut) {
+                if (options?.preventDefault) {
+                    event.preventDefault();
+                }
+                callback();
+            }
+        }
+        window.addEventListener('keydown', handleKeyDown);
+        return () => window.removeEventListener('keydown', handleKeyDown);
+    }, [key, callback, options]);
+}
+//# sourceMappingURL=useKeyboardShortcut.js.map

package/lib/hooks/useKeyboardShortcut.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardShortcut.js","sourceRoot":"","sources":["../../src/hooks/useKeyboardShortcut.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAalC;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CACjC,GAAW,EACX,QAAoB,EACpB,OAAkC;IAElC,SAAS,CAAC,GAAG,EAAE;QACb,SAAS,aAAa,CAAC,KAAoB;YACzC,MAAM,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,GAAG,CAAC,WAAW,EAAE,CAAC;YAEjE,mCAAmC;YACnC,MAAM,WAAW,GAAG,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC;YACnE,MAAM,WAAW,GAAG,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC;YACnE,MAAM,YAAY,GAAG,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC;YAEvE,4EAA4E;YAC5E,MAAM,kBAAkB,GACtB,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,IAAI;gBAC5B,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ;gBACrD,CAAC,CAAC,WAAW,IAAI,WAAW,IAAI,YAAY,CAAC;YAEjD,IAAI,UAAU,IAAI,kBAAkB,EAAE,CAAC;gBACrC,IAAI,OAAO,EAAE,cAAc,EAAE,CAAC;oBAC5B,KAAK,CAAC,cAAc,EAAE,CAAC;gBACzB,CAAC;gBACD,QAAQ,EAAE,CAAC;YACb,CAAC;QACH,CAAC;QAED,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;QAClD,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;IACpE,CAAC,EAAE,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;AAC/B,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\nimport { useEffect } from 'react';\n\n/**\n * Options for keyboard shortcut configuration\n * @public\n */\nexport interface IKeyboardShortcutOptions {\n  readonly ctrl?: boolean;\n  readonly meta?: boolean;\n  readonly shift?: boolean;\n  readonly preventDefault?: boolean;\n}\n\n/**\n * Hook for registering global keyboard shortcuts\n * @param key - The key to listen for (e.g., 'k', 'Escape')\n * @param callback - Function to call when shortcut is activated\n * @param options - Optional modifier keys and behavior\n * @public\n */\nexport function useKeyboardShortcut(\n  key: string,\n  callback: () => void,\n  options?: IKeyboardShortcutOptions\n): void {\n  useEffect(() => {\n    function handleKeyDown(event: KeyboardEvent): void {\n      const matchesKey = event.key.toLowerCase() === key.toLowerCase();\n\n      // Check modifier keys if specified\n      const matchesCtrl = options?.ctrl ? event.ctrlKey : !event.ctrlKey;\n      const matchesMeta = options?.meta ? event.metaKey : !event.metaKey;\n      const matchesShift = options?.shift ? event.shiftKey : !event.shiftKey;\n\n      // For cross-platform support, treat Ctrl+K on Windows/Linux as Cmd+K on Mac\n      const isPlatformShortcut =\n        options?.ctrl && options?.meta\n          ? (event.ctrlKey || event.metaKey) && !event.shiftKey\n          : matchesCtrl && matchesMeta && matchesShift;\n\n      if (matchesKey && isPlatformShortcut) {\n        if (options?.preventDefault) {\n          event.preventDefault();\n        }\n        callback();\n      }\n    }\n\n    window.addEventListener('keydown', handleKeyDown);\n    return () => window.removeEventListener('keydown', handleKeyDown);\n  }, [key, callback, options]);\n}\n"]}

package/lib/hooks/useKillerCombinations.d.ts

@@ -0,0 +1,11 @@
+import { Result } from '@fgv/ts-utils';
+import { ICage } from '@fgv/ts-sudoku-lib';
+import { ICombinationDisplayInfo } from '../types';
+/**
+ * Hook to get all valid killer cage combinations for a selected cage
+ * @param cage - The selected killer cage
+ * @returns Result containing combination display information
+ * @public
+ */
+export declare function useKillerCombinations(cage: ICage | null): Result<ICombinationDisplayInfo[]>;
+//# sourceMappingURL=useKillerCombinations.d.ts.map

package/lib/hooks/useKillerCombinations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKillerCombinations.d.ts","sourceRoot":"","sources":["../../src/hooks/useKillerCombinations.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,MAAM,EAAiB,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,KAAK,EAAW,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AASnD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI,GAAG,MAAM,CAAC,uBAAuB,EAAE,CAAC,CA+B3F"}

package/lib/hooks/useKillerCombinations.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 { useMemo } from 'react';
+import { fail, succeed } from '@fgv/ts-utils';
+import { Puzzles } from '@fgv/ts-sudoku-lib';
+/**
+ * Generate signature for a combination (sorted numbers joined by commas)
+ */
+function getCombinationSignature(combination) {
+    return [...combination].sort((a, b) => a - b).join(',');
+}
+/**
+ * Hook to get all valid killer cage combinations for a selected cage
+ * @param cage - The selected killer cage
+ * @returns Result containing combination display information
+ * @public
+ */
+export function useKillerCombinations(cage) {
+    return useMemo(() => {
+        if (!cage) {
+            return fail('No cage selected');
+        }
+        if (cage.cageType !== 'killer') {
+            return fail('Cage is not a killer cage');
+        }
+        if (!cage.total) {
+            return fail('Killer cage does not have a total');
+        }
+        // For now, we don't apply constraints based on current values
+        // This can be enhanced later to exclude numbers already in the cage
+        const constraints = {
+            excludedNumbers: []
+        };
+        return Puzzles.KillerCombinations.getCombinations(cage.numCells, cage.total, constraints).onSuccess((combinations) => {
+            const displayInfo = combinations.map((combo) => ({
+                combination: combo,
+                signature: getCombinationSignature(combo),
+                isEliminated: false
+            }));
+            return succeed(displayInfo);
+        });
+    }, [cage]);
+}
+//# sourceMappingURL=useKillerCombinations.js.map

package/lib/hooks/useKillerCombinations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKillerCombinations.js","sourceRoot":"","sources":["../../src/hooks/useKillerCombinations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,EAAU,IAAI,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAS,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAGpD;;GAEG;AACH,SAAS,uBAAuB,CAAC,WAAqB;IACpD,OAAO,CAAC,GAAG,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAkB;IACtD,OAAO,OAAO,CAAC,GAAG,EAAE;QAClB,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAClC,CAAC;QAED,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAC/B,OAAO,IAAI,CAAC,2BAA2B,CAAC,CAAC;QAC3C,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC,mCAAmC,CAAC,CAAC;QACnD,CAAC;QAED,8DAA8D;QAC9D,oEAAoE;QACpE,MAAM,WAAW,GAAG;YAClB,eAAe,EAAE,EAAE;SACpB,CAAC;QAEF,OAAO,OAAO,CAAC,kBAAkB,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,SAAS,CACjG,CAAC,YAAwB,EAAE,EAAE;YAC3B,MAAM,WAAW,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,KAAe,EAAE,EAAE,CAAC,CAAC;gBACzD,WAAW,EAAE,KAAK;gBAClB,SAAS,EAAE,uBAAuB,CAAC,KAAK,CAAC;gBACzC,YAAY,EAAE,KAAK;aACpB,CAAC,CAAC,CAAC;YACJ,OAAO,OAAO,CAAC,WAAW,CAAC,CAAC;QAC9B,CAAC,CACF,CAAC;IACJ,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;AACb,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\nimport { useMemo } from 'react';\nimport { Result, fail, succeed } from '@fgv/ts-utils';\nimport { ICage, Puzzles } from '@fgv/ts-sudoku-lib';\nimport { ICombinationDisplayInfo } from '../types';\n\n/**\n * Generate signature for a combination (sorted numbers joined by commas)\n */\nfunction getCombinationSignature(combination: number[]): string {\n  return [...combination].sort((a, b) => a - b).join(',');\n}\n\n/**\n * Hook to get all valid killer cage combinations for a selected cage\n * @param cage - The selected killer cage\n * @returns Result containing combination display information\n * @public\n */\nexport function useKillerCombinations(cage: ICage | null): Result<ICombinationDisplayInfo[]> {\n  return useMemo(() => {\n    if (!cage) {\n      return fail('No cage selected');\n    }\n\n    if (cage.cageType !== 'killer') {\n      return fail('Cage is not a killer cage');\n    }\n\n    if (!cage.total) {\n      return fail('Killer cage does not have a total');\n    }\n\n    // For now, we don't apply constraints based on current values\n    // This can be enhanced later to exclude numbers already in the cage\n    const constraints = {\n      excludedNumbers: []\n    };\n\n    return Puzzles.KillerCombinations.getCombinations(cage.numCells, cage.total, constraints).onSuccess(\n      (combinations: number[][]) => {\n        const displayInfo = combinations.map((combo: number[]) => ({\n          combination: combo,\n          signature: getCombinationSignature(combo),\n          isEliminated: false\n        }));\n        return succeed(displayInfo);\n      }\n    );\n  }, [cage]);\n}\n"]}

package/lib/hooks/useLongPress.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Options for the useLongPress hook
+ * @public
+ */
+export interface IUseLongPressOptions {
+    /** Callback to execute on long press */
+    readonly onLongPress: (event: React.TouchEvent | React.MouseEvent) => void;
+    /** Delay before long press is triggered (ms) */
+    readonly delay?: number;
+    /** Whether to prevent default behavior during long press */
+    readonly shouldPreventDefault?: boolean;
+}
+/**
+ * Result of the useLongPress hook
+ * @public
+ */
+export interface ILongPressHandlers {
+    readonly onMouseDown: (event: React.MouseEvent) => void;
+    readonly onMouseUp: (event: React.MouseEvent) => boolean;
+    readonly onMouseLeave: (event: React.MouseEvent) => void;
+    readonly onTouchStart: (event: React.TouchEvent) => void;
+    readonly onTouchEnd: (event: React.TouchEvent) => boolean;
+}
+/**
+ * Hook to detect long press gestures on touch and mouse devices
+ * @param options - Configuration options for long press detection
+ * @returns Event handlers to spread on target element
+ * @public
+ */
+export declare function useLongPress(options: IUseLongPressOptions): ILongPressHandlers;
+//# sourceMappingURL=useLongPress.d.ts.map

package/lib/hooks/useLongPress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLongPress.d.ts","sourceRoot":"","sources":["../../src/hooks/useLongPress.ts"],"names":[],"mappings":"AA0BA;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,wCAAwC;IACxC,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IAE3E,gDAAgD;IAChD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAExB,4DAA4D;IAC5D,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;CACzC;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IACxD,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,KAAK,OAAO,CAAC;IACzD,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IACzD,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IACzD,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,KAAK,OAAO,CAAC;CAC3D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,oBAAoB,GAAG,kBAAkB,CA+C9E"}