@tanstack/preact-hotkeys 0.10.0 → 0.12.0

package/dist/HotkeysProvider.d.cts

@@ -1,29 +0,0 @@
-import { UseHotkeyOptions } from "./useHotkey.cjs";
-import { UseHotkeySequenceOptions } from "./useHotkeySequence.cjs";
-import { HotkeyRecorderOptions, HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
-import * as _$preact from "preact";
-import { ComponentChildren } from "preact";
-
-//#region src/HotkeysProvider.d.ts
-interface HotkeysProviderOptions {
-  hotkey?: Partial<UseHotkeyOptions>;
-  hotkeyRecorder?: Partial<HotkeyRecorderOptions>;
-  hotkeySequenceRecorder?: Partial<HotkeySequenceRecorderOptions>;
-  hotkeySequence?: Partial<UseHotkeySequenceOptions>;
-}
-interface HotkeysContextValue {
-  defaultOptions: HotkeysProviderOptions;
-}
-interface HotkeysProviderProps {
-  children: ComponentChildren;
-  defaultOptions?: HotkeysProviderOptions;
-}
-declare function HotkeysProvider({
-  children,
-  defaultOptions
-}: HotkeysProviderProps): _$preact.JSX.Element;
-declare function useHotkeysContext(): HotkeysContextValue | null;
-declare function useDefaultHotkeysOptions(): HotkeysProviderOptions;
-//#endregion
-export { HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, useDefaultHotkeysOptions, useHotkeysContext };
-//# sourceMappingURL=HotkeysProvider.d.cts.map

package/dist/HotkeysProvider.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HotkeysProvider.js","names":[],"sources":["../src/HotkeysProvider.tsx"],"sourcesContent":["import { createContext } from 'preact'\nimport { useContext, useMemo } from 'preact/hooks'\nimport type { ComponentChildren } from 'preact'\nimport type {\n  HotkeyRecorderOptions,\n  HotkeySequenceRecorderOptions,\n} from '@tanstack/hotkeys'\nimport type { UseHotkeyOptions } from './useHotkey'\nimport type { UseHotkeySequenceOptions } from './useHotkeySequence'\n\nexport interface HotkeysProviderOptions {\n  hotkey?: Partial<UseHotkeyOptions>\n  hotkeyRecorder?: Partial<HotkeyRecorderOptions>\n  hotkeySequenceRecorder?: Partial<HotkeySequenceRecorderOptions>\n  hotkeySequence?: Partial<UseHotkeySequenceOptions>\n}\n\ninterface HotkeysContextValue {\n  defaultOptions: HotkeysProviderOptions\n}\n\nconst HotkeysContext = createContext<HotkeysContextValue | null>(null)\n\nexport interface HotkeysProviderProps {\n  children: ComponentChildren\n  defaultOptions?: HotkeysProviderOptions\n}\n\nconst DEFAULT_OPTIONS: HotkeysProviderOptions = {}\n\nexport function HotkeysProvider({\n  children,\n  defaultOptions = DEFAULT_OPTIONS,\n}: HotkeysProviderProps) {\n  const contextValue: HotkeysContextValue = useMemo(\n    () => ({\n      defaultOptions,\n    }),\n    [defaultOptions],\n  )\n\n  return (\n    <HotkeysContext.Provider value={contextValue}>\n      {children}\n    </HotkeysContext.Provider>\n  )\n}\n\nexport function useHotkeysContext() {\n  return useContext(HotkeysContext)\n}\n\nexport function useDefaultHotkeysOptions() {\n  const context = useContext(HotkeysContext)\n  return context?.defaultOptions ?? {}\n}\n"],"mappings":";;;;;AAqBA,MAAM,iBAAiB,cAA0C,KAAK;AAOtE,MAAM,kBAA0C,EAAE;AAElD,SAAgB,gBAAgB,EAC9B,UACA,iBAAiB,mBACM;CACvB,MAAM,eAAoC,eACjC,EACL,gBACD,GACD,CAAC,eAAe,CACjB;AAED,QACE,oBAAC,eAAe,UAAhB;EAAyB,OAAO;EAC7B;EACuB;;AAI9B,SAAgB,oBAAoB;AAClC,QAAO,WAAW,eAAe;;AAGnC,SAAgB,2BAA2B;AAEzC,QADgB,WAAW,eAAe,EAC1B,kBAAkB,EAAE"}

package/dist/index.cjs

@@ -1,33 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_HotkeysProvider = require('./HotkeysProvider.cjs');
-const require_useHotkey = require('./useHotkey.cjs');
-const require_useHotkeys = require('./useHotkeys.cjs');
-const require_useHeldKeys = require('./useHeldKeys.cjs');
-const require_useHeldKeyCodes = require('./useHeldKeyCodes.cjs');
-const require_useKeyHold = require('./useKeyHold.cjs');
-const require_useHotkeySequence = require('./useHotkeySequence.cjs');
-const require_useHotkeySequences = require('./useHotkeySequences.cjs');
-const require_useHotkeyRecorder = require('./useHotkeyRecorder.cjs');
-const require_useHotkeyRegistrations = require('./useHotkeyRegistrations.cjs');
-const require_useHotkeySequenceRecorder = require('./useHotkeySequenceRecorder.cjs');
-
-exports.HotkeysProvider = require_HotkeysProvider.HotkeysProvider;
-exports.useDefaultHotkeysOptions = require_HotkeysProvider.useDefaultHotkeysOptions;
-exports.useHeldKeyCodes = require_useHeldKeyCodes.useHeldKeyCodes;
-exports.useHeldKeys = require_useHeldKeys.useHeldKeys;
-exports.useHotkey = require_useHotkey.useHotkey;
-exports.useHotkeyRecorder = require_useHotkeyRecorder.useHotkeyRecorder;
-exports.useHotkeyRegistrations = require_useHotkeyRegistrations.useHotkeyRegistrations;
-exports.useHotkeySequence = require_useHotkeySequence.useHotkeySequence;
-exports.useHotkeySequenceRecorder = require_useHotkeySequenceRecorder.useHotkeySequenceRecorder;
-exports.useHotkeySequences = require_useHotkeySequences.useHotkeySequences;
-exports.useHotkeys = require_useHotkeys.useHotkeys;
-exports.useHotkeysContext = require_HotkeysProvider.useHotkeysContext;
-exports.useKeyHold = require_useKeyHold.useKeyHold;
-var _tanstack_hotkeys = require("@tanstack/hotkeys");
-Object.keys(_tanstack_hotkeys).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return _tanstack_hotkeys[k]; }
-  });
-});

package/dist/index.d.cts

@@ -1,13 +0,0 @@
-import { UseHotkeyOptions, useHotkey } from "./useHotkey.cjs";
-import { UseHotkeySequenceOptions, useHotkeySequence } from "./useHotkeySequence.cjs";
-import { HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, useDefaultHotkeysOptions, useHotkeysContext } from "./HotkeysProvider.cjs";
-import { UseHotkeyDefinition, useHotkeys } from "./useHotkeys.cjs";
-import { useHeldKeys } from "./useHeldKeys.cjs";
-import { useHeldKeyCodes } from "./useHeldKeyCodes.cjs";
-import { useKeyHold } from "./useKeyHold.cjs";
-import { UseHotkeySequenceDefinition, useHotkeySequences } from "./useHotkeySequences.cjs";
-import { PreactHotkeyRecorder, useHotkeyRecorder } from "./useHotkeyRecorder.cjs";
-import { HotkeyRegistrationsResult, useHotkeyRegistrations } from "./useHotkeyRegistrations.cjs";
-import { PreactHotkeySequenceRecorder, useHotkeySequenceRecorder } from "./useHotkeySequenceRecorder.cjs";
-export * from "@tanstack/hotkeys";
-export { HotkeyRegistrationsResult, HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, PreactHotkeyRecorder, PreactHotkeySequenceRecorder, UseHotkeyDefinition, UseHotkeyOptions, UseHotkeySequenceDefinition, UseHotkeySequenceOptions, useDefaultHotkeysOptions, useHeldKeyCodes, useHeldKeys, useHotkey, useHotkeyRecorder, useHotkeyRegistrations, useHotkeySequence, useHotkeySequenceRecorder, useHotkeySequences, useHotkeys, useHotkeysContext, useKeyHold };

package/dist/useHeldKeyCodes.cjs

@@ -1,37 +0,0 @@
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _tanstack_preact_store = require("@tanstack/preact-store");
-
-//#region src/useHeldKeyCodes.ts
-/**
-* Preact hook that returns a map of currently held key names to their physical `event.code` values.
-*
-* This is useful for debugging which physical key was pressed (e.g. distinguishing
-* left vs right Shift via "ShiftLeft" / "ShiftRight").
-*
-* @returns Record mapping normalized key names to their `event.code` values
-*
-* @example
-* ```tsx
-* function KeyDebugDisplay() {
-*   const heldKeys = useHeldKeys()
-*   const heldCodes = useHeldKeyCodes()
-*
-*   return (
-*     <div>
-*       {heldKeys.map((key) => (
-*         <kbd key={key}>
-*           {key} <small>{heldCodes[key]}</small>
-*         </kbd>
-*       ))}
-*     </div>
-*   )
-* }
-* ```
-*/
-function useHeldKeyCodes() {
-	return (0, _tanstack_preact_store.useSelector)((0, _tanstack_hotkeys.getKeyStateTracker)().store, (state) => state.heldCodes);
-}
-
-//#endregion
-exports.useHeldKeyCodes = useHeldKeyCodes;
-//# sourceMappingURL=useHeldKeyCodes.cjs.map

package/dist/useHeldKeyCodes.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHeldKeyCodes.cjs","names":[],"sources":["../src/useHeldKeyCodes.ts"],"sourcesContent":["import { useSelector } from '@tanstack/preact-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\n\n/**\n * Preact hook that returns a map of currently held key names to their physical `event.code` values.\n *\n * This is useful for debugging which physical key was pressed (e.g. distinguishing\n * left vs right Shift via \"ShiftLeft\" / \"ShiftRight\").\n *\n * @returns Record mapping normalized key names to their `event.code` values\n *\n * @example\n * ```tsx\n * function KeyDebugDisplay() {\n *   const heldKeys = useHeldKeys()\n *   const heldCodes = useHeldKeyCodes()\n *\n *   return (\n *     <div>\n *       {heldKeys.map((key) => (\n *         <kbd key={key}>\n *           {key} <small>{heldCodes[key]}</small>\n *         </kbd>\n *       ))}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useHeldKeyCodes(): Record<string, string> {\n  const tracker = getKeyStateTracker()\n  return useSelector(tracker.store, (state) => state.heldCodes)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,kBAA0C;AAExD,2FADoC,CACT,QAAQ,UAAU,MAAM,UAAU"}

package/dist/useHeldKeyCodes.d.cts

@@ -1,31 +0,0 @@
-//#region src/useHeldKeyCodes.d.ts
-/**
- * Preact hook that returns a map of currently held key names to their physical `event.code` values.
- *
- * This is useful for debugging which physical key was pressed (e.g. distinguishing
- * left vs right Shift via "ShiftLeft" / "ShiftRight").
- *
- * @returns Record mapping normalized key names to their `event.code` values
- *
- * @example
- * ```tsx
- * function KeyDebugDisplay() {
- *   const heldKeys = useHeldKeys()
- *   const heldCodes = useHeldKeyCodes()
- *
- *   return (
- *     <div>
- *       {heldKeys.map((key) => (
- *         <kbd key={key}>
- *           {key} <small>{heldCodes[key]}</small>
- *         </kbd>
- *       ))}
- *     </div>
- *   )
- * }
- * ```
- */
-declare function useHeldKeyCodes(): Record<string, string>;
-//#endregion
-export { useHeldKeyCodes };
-//# sourceMappingURL=useHeldKeyCodes.d.cts.map

package/dist/useHeldKeyCodes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHeldKeyCodes.js","names":[],"sources":["../src/useHeldKeyCodes.ts"],"sourcesContent":["import { useSelector } from '@tanstack/preact-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\n\n/**\n * Preact hook that returns a map of currently held key names to their physical `event.code` values.\n *\n * This is useful for debugging which physical key was pressed (e.g. distinguishing\n * left vs right Shift via \"ShiftLeft\" / \"ShiftRight\").\n *\n * @returns Record mapping normalized key names to their `event.code` values\n *\n * @example\n * ```tsx\n * function KeyDebugDisplay() {\n *   const heldKeys = useHeldKeys()\n *   const heldCodes = useHeldKeyCodes()\n *\n *   return (\n *     <div>\n *       {heldKeys.map((key) => (\n *         <kbd key={key}>\n *           {key} <small>{heldCodes[key]}</small>\n *         </kbd>\n *       ))}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useHeldKeyCodes(): Record<string, string> {\n  const tracker = getKeyStateTracker()\n  return useSelector(tracker.store, (state) => state.heldCodes)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,kBAA0C;AAExD,QAAO,YADS,oBAAoB,CACT,QAAQ,UAAU,MAAM,UAAU"}

package/dist/useHeldKeys.cjs

@@ -1,33 +0,0 @@
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _tanstack_preact_store = require("@tanstack/preact-store");
-
-//#region src/useHeldKeys.ts
-/**
-* Preact hook that returns an array of currently held keyboard keys.
-*
-* This hook uses `useSelector` from `@tanstack/preact-store` to subscribe
-* to the global KeyStateTracker and updates whenever keys are pressed
-* or released.
-*
-* @returns Array of currently held key names
-*
-* @example
-* ```tsx
-* function KeyDisplay() {
-*   const heldKeys = useHeldKeys()
-*
-*   return (
-*     <div>
-*       Currently pressed: {heldKeys.join(' + ') || 'None'}
-*     </div>
-*   )
-* }
-* ```
-*/
-function useHeldKeys() {
-	return (0, _tanstack_preact_store.useSelector)((0, _tanstack_hotkeys.getKeyStateTracker)().store, (state) => state.heldKeys);
-}
-
-//#endregion
-exports.useHeldKeys = useHeldKeys;
-//# sourceMappingURL=useHeldKeys.cjs.map

package/dist/useHeldKeys.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHeldKeys.cjs","names":[],"sources":["../src/useHeldKeys.ts"],"sourcesContent":["import { useSelector } from '@tanstack/preact-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\n\n/**\n * Preact hook that returns an array of currently held keyboard keys.\n *\n * This hook uses `useSelector` from `@tanstack/preact-store` to subscribe\n * to the global KeyStateTracker and updates whenever keys are pressed\n * or released.\n *\n * @returns Array of currently held key names\n *\n * @example\n * ```tsx\n * function KeyDisplay() {\n *   const heldKeys = useHeldKeys()\n *\n *   return (\n *     <div>\n *       Currently pressed: {heldKeys.join(' + ') || 'None'}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useHeldKeys(): Array<string> {\n  const tracker = getKeyStateTracker()\n  return useSelector(tracker.store, (state) => state.heldKeys)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,cAA6B;AAE3C,2FADoC,CACT,QAAQ,UAAU,MAAM,SAAS"}

package/dist/useHeldKeys.d.cts

@@ -1,27 +0,0 @@
-//#region src/useHeldKeys.d.ts
-/**
- * Preact hook that returns an array of currently held keyboard keys.
- *
- * This hook uses `useSelector` from `@tanstack/preact-store` to subscribe
- * to the global KeyStateTracker and updates whenever keys are pressed
- * or released.
- *
- * @returns Array of currently held key names
- *
- * @example
- * ```tsx
- * function KeyDisplay() {
- *   const heldKeys = useHeldKeys()
- *
- *   return (
- *     <div>
- *       Currently pressed: {heldKeys.join(' + ') || 'None'}
- *     </div>
- *   )
- * }
- * ```
- */
-declare function useHeldKeys(): Array<string>;
-//#endregion
-export { useHeldKeys };
-//# sourceMappingURL=useHeldKeys.d.cts.map

package/dist/useHeldKeys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHeldKeys.js","names":[],"sources":["../src/useHeldKeys.ts"],"sourcesContent":["import { useSelector } from '@tanstack/preact-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\n\n/**\n * Preact hook that returns an array of currently held keyboard keys.\n *\n * This hook uses `useSelector` from `@tanstack/preact-store` to subscribe\n * to the global KeyStateTracker and updates whenever keys are pressed\n * or released.\n *\n * @returns Array of currently held key names\n *\n * @example\n * ```tsx\n * function KeyDisplay() {\n *   const heldKeys = useHeldKeys()\n *\n *   return (\n *     <div>\n *       Currently pressed: {heldKeys.join(' + ') || 'None'}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useHeldKeys(): Array<string> {\n  const tracker = getKeyStateTracker()\n  return useSelector(tracker.store, (state) => state.heldKeys)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,cAA6B;AAE3C,QAAO,YADS,oBAAoB,CACT,QAAQ,UAAU,MAAM,SAAS"}

package/dist/useHotkey.cjs

@@ -1,121 +0,0 @@
-const require_HotkeysProvider = require('./HotkeysProvider.cjs');
-const require_utils = require('./utils.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let preact_hooks = require("preact/hooks");
-
-//#region src/useHotkey.ts
-/**
-* Preact hook for registering a keyboard hotkey.
-*
-* Uses the singleton HotkeyManager for efficient event handling.
-* The callback receives both the keyboard event and a context object
-* containing the hotkey string and parsed hotkey.
-*
-* This hook syncs the callback and options on every render to avoid
-* stale closures. This means
-* callbacks that reference Preact state will always have access to
-* the latest values.
-*
-* @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)
-* @param callback - The function to call when the hotkey is pressed
-* @param options - Options for the hotkey behavior. `enabled: false` keeps the registration (visible in devtools)
-*   and only suppresses firing; the hook updates the existing handle instead of unregistering.
-*
-* @example
-* ```tsx
-* function SaveButton() {
-*   const [count, setCount] = useState(0)
-*
-*   // Callback always has access to latest count value
-*   useHotkey('Mod+S', (event, { hotkey }) => {
-*     console.log(`Save triggered, count is ${count}`)
-*     handleSave()
-*   })
-*
-*   return <button onClick={() => setCount(c => c + 1)}>Count: {count}</button>
-* }
-* ```
-*
-* @example
-* ```tsx
-* function Modal({ isOpen, onClose }) {
-*   // enabled option is synced on every render
-*   useHotkey('Escape', () => {
-*     onClose()
-*   }, { enabled: isOpen })
-*
-*   if (!isOpen) return null
-*   return <div className="modal">...</div>
-* }
-* ```
-*
-* @example
-* ```tsx
-* function Editor() {
-*   const editorRef = useRef<HTMLDivElement>(null)
-*
-*   // Scoped to a specific element
-*   useHotkey('Mod+S', () => {
-*     save()
-*   }, { target: editorRef })
-*
-*   return <div ref={editorRef}>...</div>
-* }
-* ```
-*/
-function useHotkey(hotkey, callback, options = {}) {
-	const mergedOptions = {
-		...require_HotkeysProvider.useDefaultHotkeysOptions().hotkey,
-		...options
-	};
-	const manager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	const registrationRef = (0, preact_hooks.useRef)(null);
-	const callbackRef = (0, preact_hooks.useRef)(callback);
-	const optionsRef = (0, preact_hooks.useRef)(mergedOptions);
-	const managerRef = (0, preact_hooks.useRef)(manager);
-	callbackRef.current = callback;
-	optionsRef.current = mergedOptions;
-	managerRef.current = manager;
-	const prevTargetRef = (0, preact_hooks.useRef)(null);
-	const prevHotkeyRef = (0, preact_hooks.useRef)(null);
-	const hotkeyString = (0, _tanstack_hotkeys.normalizeRegisterableHotkey)(hotkey, mergedOptions.platform ?? (0, _tanstack_hotkeys.detectPlatform)());
-	const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-	(0, preact_hooks.useEffect)(() => {
-		const resolvedTarget = require_utils.isRef(optionsRef.current.target) ? optionsRef.current.target.current : optionsRef.current.target ?? (typeof document !== "undefined" ? document : null);
-		if (!resolvedTarget) {
-			if (registrationRef.current?.isActive) {
-				registrationRef.current.unregister();
-				registrationRef.current = null;
-			}
-			prevTargetRef.current = null;
-			prevHotkeyRef.current = null;
-			return;
-		}
-		const targetChanged = prevTargetRef.current !== null && prevTargetRef.current !== resolvedTarget;
-		const hotkeyChanged = prevHotkeyRef.current !== null && prevHotkeyRef.current !== hotkeyString;
-		if (registrationRef.current?.isActive && (targetChanged || hotkeyChanged)) {
-			registrationRef.current.unregister();
-			registrationRef.current = null;
-		}
-		if (!registrationRef.current || !registrationRef.current.isActive) registrationRef.current = managerRef.current.register(hotkeyString, callbackRef.current, {
-			...optionsRef.current,
-			target: resolvedTarget
-		});
-		prevTargetRef.current = resolvedTarget;
-		prevHotkeyRef.current = hotkeyString;
-		return () => {
-			if (registrationRef.current?.isActive) {
-				registrationRef.current.unregister();
-				registrationRef.current = null;
-			}
-		};
-	}, [hotkeyString]);
-	if (registrationRef.current?.isActive) {
-		registrationRef.current.callback = callback;
-		registrationRef.current.setOptions(optionsWithoutTarget);
-	}
-}
-
-//#endregion
-exports.useHotkey = useHotkey;
-//# sourceMappingURL=useHotkey.cjs.map

package/dist/useHotkey.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkey.cjs","names":["useDefaultHotkeysOptions","isRef"],"sources":["../src/useHotkey.ts"],"sourcesContent":["import { useEffect, useRef } from 'preact/hooks'\nimport {\n  detectPlatform,\n  getHotkeyManager,\n  normalizeRegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport { isRef } from './utils'\nimport type { RefObject } from 'preact'\nimport type {\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\nexport interface UseHotkeyOptions extends Omit<HotkeyOptions, 'target'> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a Preact ref, direct DOM element, or null.\n   * Defaults to document.\n   */\n  target?:\n    | RefObject<HTMLElement | null>\n    | HTMLElement\n    | Document\n    | Window\n    | null\n}\n\n/**\n * Preact hook for registering a keyboard hotkey.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * The callback receives both the keyboard event and a context object\n * containing the hotkey string and parsed hotkey.\n *\n * This hook syncs the callback and options on every render to avoid\n * stale closures. This means\n * callbacks that reference Preact state will always have access to\n * the latest values.\n *\n * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior. `enabled: false` keeps the registration (visible in devtools)\n *   and only suppresses firing; the hook updates the existing handle instead of unregistering.\n *\n * @example\n * ```tsx\n * function SaveButton() {\n *   const [count, setCount] = useState(0)\n *\n *   // Callback always has access to latest count value\n *   useHotkey('Mod+S', (event, { hotkey }) => {\n *     console.log(`Save triggered, count is ${count}`)\n *     handleSave()\n *   })\n *\n *   return <button onClick={() => setCount(c => c + 1)}>Count: {count}</button>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Modal({ isOpen, onClose }) {\n *   // enabled option is synced on every render\n *   useHotkey('Escape', () => {\n *     onClose()\n *   }, { enabled: isOpen })\n *\n *   if (!isOpen) return null\n *   return <div className=\"modal\">...</div>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Editor() {\n *   const editorRef = useRef<HTMLDivElement>(null)\n *\n *   // Scoped to a specific element\n *   useHotkey('Mod+S', () => {\n *     save()\n *   }, { target: editorRef })\n *\n *   return <div ref={editorRef}>...</div>\n * }\n * ```\n */\nexport function useHotkey(\n  hotkey: RegisterableHotkey,\n  callback: HotkeyCallback,\n  options: UseHotkeyOptions = {},\n): void {\n  const mergedOptions = {\n    ...useDefaultHotkeysOptions().hotkey,\n    ...options,\n  } as UseHotkeyOptions\n\n  const manager = getHotkeyManager()\n\n  // Stable ref for registration handle\n  const registrationRef = useRef<HotkeyRegistrationHandle | null>(null)\n\n  // Refs to capture current values for use in effect without adding dependencies\n  const callbackRef = useRef(callback)\n  const optionsRef = useRef(mergedOptions)\n  const managerRef = useRef(manager)\n\n  // Update refs on every render\n  callbackRef.current = callback\n  optionsRef.current = mergedOptions\n  managerRef.current = manager\n\n  // Track previous target and hotkey to detect changes requiring re-registration\n  const prevTargetRef = useRef<HTMLElement | Document | Window | null>(null)\n  const prevHotkeyRef = useRef<string | null>(null)\n\n  // Normalize to hotkey string\n  const platform = mergedOptions.platform ?? detectPlatform()\n  const hotkeyString = normalizeRegisterableHotkey(hotkey, platform)\n\n  // Extract options without target (target is handled separately)\n  const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n  useEffect(() => {\n    // Resolve target inside the effect so refs are already attached after mount\n    const resolvedTarget = isRef(optionsRef.current.target)\n      ? optionsRef.current.target.current\n      : (optionsRef.current.target ??\n        (typeof document !== 'undefined' ? document : null))\n\n    // Skip if no valid target (SSR or ref still null)\n    if (!resolvedTarget) {\n      if (registrationRef.current?.isActive) {\n        registrationRef.current.unregister()\n        registrationRef.current = null\n      }\n      prevTargetRef.current = null\n      prevHotkeyRef.current = null\n      return\n    }\n\n    // Check if we need to re-register (target or hotkey changed)\n    const targetChanged =\n      prevTargetRef.current !== null && prevTargetRef.current !== resolvedTarget\n    const hotkeyChanged =\n      prevHotkeyRef.current !== null && prevHotkeyRef.current !== hotkeyString\n\n    // If we have an active registration and target/hotkey changed, unregister first\n    if (registrationRef.current?.isActive && (targetChanged || hotkeyChanged)) {\n      registrationRef.current.unregister()\n      registrationRef.current = null\n    }\n\n    // Register if needed (no active registration)\n    // Use refs to access current values without adding them to dependencies\n    if (!registrationRef.current || !registrationRef.current.isActive) {\n      registrationRef.current = managerRef.current.register(\n        hotkeyString,\n        callbackRef.current,\n        {\n          ...optionsRef.current,\n          target: resolvedTarget,\n        },\n      )\n    }\n\n    // Update tracking refs\n    prevTargetRef.current = resolvedTarget\n    prevHotkeyRef.current = hotkeyString\n\n    // Cleanup on unmount\n    return () => {\n      if (registrationRef.current?.isActive) {\n        registrationRef.current.unregister()\n        registrationRef.current = null\n      }\n    }\n  }, [hotkeyString])\n\n  // Sync callback and options on EVERY render (outside useEffect)\n  // This avoids stale closures - the callback always has access to latest state\n  if (registrationRef.current?.isActive) {\n    registrationRef.current.callback = callback\n    registrationRef.current.setOptions(optionsWithoutTarget)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyFA,SAAgB,UACd,QACA,UACA,UAA4B,EAAE,EACxB;CACN,MAAM,gBAAgB;EACpB,GAAGA,kDAA0B,CAAC;EAC9B,GAAG;EACJ;CAED,MAAM,mDAA4B;CAGlC,MAAM,2CAA0D,KAAK;CAGrE,MAAM,uCAAqB,SAAS;CACpC,MAAM,sCAAoB,cAAc;CACxC,MAAM,sCAAoB,QAAQ;AAGlC,aAAY,UAAU;AACtB,YAAW,UAAU;AACrB,YAAW,UAAU;CAGrB,MAAM,yCAA+D,KAAK;CAC1E,MAAM,yCAAsC,KAAK;CAIjD,MAAM,kEAA2C,QADhC,cAAc,mDAA4B,CACO;CAGlE,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,mCAAgB;EAEd,MAAM,iBAAiBC,oBAAM,WAAW,QAAQ,OAAO,GACnD,WAAW,QAAQ,OAAO,UACzB,WAAW,QAAQ,WACnB,OAAO,aAAa,cAAc,WAAW;AAGlD,MAAI,CAAC,gBAAgB;AACnB,OAAI,gBAAgB,SAAS,UAAU;AACrC,oBAAgB,QAAQ,YAAY;AACpC,oBAAgB,UAAU;;AAE5B,iBAAc,UAAU;AACxB,iBAAc,UAAU;AACxB;;EAIF,MAAM,gBACJ,cAAc,YAAY,QAAQ,cAAc,YAAY;EAC9D,MAAM,gBACJ,cAAc,YAAY,QAAQ,cAAc,YAAY;AAG9D,MAAI,gBAAgB,SAAS,aAAa,iBAAiB,gBAAgB;AACzE,mBAAgB,QAAQ,YAAY;AACpC,mBAAgB,UAAU;;AAK5B,MAAI,CAAC,gBAAgB,WAAW,CAAC,gBAAgB,QAAQ,SACvD,iBAAgB,UAAU,WAAW,QAAQ,SAC3C,cACA,YAAY,SACZ;GACE,GAAG,WAAW;GACd,QAAQ;GACT,CACF;AAIH,gBAAc,UAAU;AACxB,gBAAc,UAAU;AAGxB,eAAa;AACX,OAAI,gBAAgB,SAAS,UAAU;AACrC,oBAAgB,QAAQ,YAAY;AACpC,oBAAgB,UAAU;;;IAG7B,CAAC,aAAa,CAAC;AAIlB,KAAI,gBAAgB,SAAS,UAAU;AACrC,kBAAgB,QAAQ,WAAW;AACnC,kBAAgB,QAAQ,WAAW,qBAAqB"}

package/dist/useHotkey.d.cts

@@ -1,75 +0,0 @@
-import { HotkeyCallback, HotkeyOptions, RegisterableHotkey } from "@tanstack/hotkeys";
-import { RefObject } from "preact";
-
-//#region src/useHotkey.d.ts
-interface UseHotkeyOptions extends Omit<HotkeyOptions, 'target'> {
-  /**
-   * The DOM element to attach the event listener to.
-   * Can be a Preact ref, direct DOM element, or null.
-   * Defaults to document.
-   */
-  target?: RefObject<HTMLElement | null> | HTMLElement | Document | Window | null;
-}
-/**
- * Preact hook for registering a keyboard hotkey.
- *
- * Uses the singleton HotkeyManager for efficient event handling.
- * The callback receives both the keyboard event and a context object
- * containing the hotkey string and parsed hotkey.
- *
- * This hook syncs the callback and options on every render to avoid
- * stale closures. This means
- * callbacks that reference Preact state will always have access to
- * the latest values.
- *
- * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)
- * @param callback - The function to call when the hotkey is pressed
- * @param options - Options for the hotkey behavior. `enabled: false` keeps the registration (visible in devtools)
- *   and only suppresses firing; the hook updates the existing handle instead of unregistering.
- *
- * @example
- * ```tsx
- * function SaveButton() {
- *   const [count, setCount] = useState(0)
- *
- *   // Callback always has access to latest count value
- *   useHotkey('Mod+S', (event, { hotkey }) => {
- *     console.log(`Save triggered, count is ${count}`)
- *     handleSave()
- *   })
- *
- *   return <button onClick={() => setCount(c => c + 1)}>Count: {count}</button>
- * }
- * ```
- *
- * @example
- * ```tsx
- * function Modal({ isOpen, onClose }) {
- *   // enabled option is synced on every render
- *   useHotkey('Escape', () => {
- *     onClose()
- *   }, { enabled: isOpen })
- *
- *   if (!isOpen) return null
- *   return <div className="modal">...</div>
- * }
- * ```
- *
- * @example
- * ```tsx
- * function Editor() {
- *   const editorRef = useRef<HTMLDivElement>(null)
- *
- *   // Scoped to a specific element
- *   useHotkey('Mod+S', () => {
- *     save()
- *   }, { target: editorRef })
- *
- *   return <div ref={editorRef}>...</div>
- * }
- * ```
- */
-declare function useHotkey(hotkey: RegisterableHotkey, callback: HotkeyCallback, options?: UseHotkeyOptions): void;
-//#endregion
-export { UseHotkeyOptions, useHotkey };
-//# sourceMappingURL=useHotkey.d.cts.map

package/dist/useHotkey.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkey.js","names":[],"sources":["../src/useHotkey.ts"],"sourcesContent":["import { useEffect, useRef } from 'preact/hooks'\nimport {\n  detectPlatform,\n  getHotkeyManager,\n  normalizeRegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport { isRef } from './utils'\nimport type { RefObject } from 'preact'\nimport type {\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\nexport interface UseHotkeyOptions extends Omit<HotkeyOptions, 'target'> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a Preact ref, direct DOM element, or null.\n   * Defaults to document.\n   */\n  target?:\n    | RefObject<HTMLElement | null>\n    | HTMLElement\n    | Document\n    | Window\n    | null\n}\n\n/**\n * Preact hook for registering a keyboard hotkey.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * The callback receives both the keyboard event and a context object\n * containing the hotkey string and parsed hotkey.\n *\n * This hook syncs the callback and options on every render to avoid\n * stale closures. This means\n * callbacks that reference Preact state will always have access to\n * the latest values.\n *\n * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior. `enabled: false` keeps the registration (visible in devtools)\n *   and only suppresses firing; the hook updates the existing handle instead of unregistering.\n *\n * @example\n * ```tsx\n * function SaveButton() {\n *   const [count, setCount] = useState(0)\n *\n *   // Callback always has access to latest count value\n *   useHotkey('Mod+S', (event, { hotkey }) => {\n *     console.log(`Save triggered, count is ${count}`)\n *     handleSave()\n *   })\n *\n *   return <button onClick={() => setCount(c => c + 1)}>Count: {count}</button>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Modal({ isOpen, onClose }) {\n *   // enabled option is synced on every render\n *   useHotkey('Escape', () => {\n *     onClose()\n *   }, { enabled: isOpen })\n *\n *   if (!isOpen) return null\n *   return <div className=\"modal\">...</div>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Editor() {\n *   const editorRef = useRef<HTMLDivElement>(null)\n *\n *   // Scoped to a specific element\n *   useHotkey('Mod+S', () => {\n *     save()\n *   }, { target: editorRef })\n *\n *   return <div ref={editorRef}>...</div>\n * }\n * ```\n */\nexport function useHotkey(\n  hotkey: RegisterableHotkey,\n  callback: HotkeyCallback,\n  options: UseHotkeyOptions = {},\n): void {\n  const mergedOptions = {\n    ...useDefaultHotkeysOptions().hotkey,\n    ...options,\n  } as UseHotkeyOptions\n\n  const manager = getHotkeyManager()\n\n  // Stable ref for registration handle\n  const registrationRef = useRef<HotkeyRegistrationHandle | null>(null)\n\n  // Refs to capture current values for use in effect without adding dependencies\n  const callbackRef = useRef(callback)\n  const optionsRef = useRef(mergedOptions)\n  const managerRef = useRef(manager)\n\n  // Update refs on every render\n  callbackRef.current = callback\n  optionsRef.current = mergedOptions\n  managerRef.current = manager\n\n  // Track previous target and hotkey to detect changes requiring re-registration\n  const prevTargetRef = useRef<HTMLElement | Document | Window | null>(null)\n  const prevHotkeyRef = useRef<string | null>(null)\n\n  // Normalize to hotkey string\n  const platform = mergedOptions.platform ?? detectPlatform()\n  const hotkeyString = normalizeRegisterableHotkey(hotkey, platform)\n\n  // Extract options without target (target is handled separately)\n  const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n  useEffect(() => {\n    // Resolve target inside the effect so refs are already attached after mount\n    const resolvedTarget = isRef(optionsRef.current.target)\n      ? optionsRef.current.target.current\n      : (optionsRef.current.target ??\n        (typeof document !== 'undefined' ? document : null))\n\n    // Skip if no valid target (SSR or ref still null)\n    if (!resolvedTarget) {\n      if (registrationRef.current?.isActive) {\n        registrationRef.current.unregister()\n        registrationRef.current = null\n      }\n      prevTargetRef.current = null\n      prevHotkeyRef.current = null\n      return\n    }\n\n    // Check if we need to re-register (target or hotkey changed)\n    const targetChanged =\n      prevTargetRef.current !== null && prevTargetRef.current !== resolvedTarget\n    const hotkeyChanged =\n      prevHotkeyRef.current !== null && prevHotkeyRef.current !== hotkeyString\n\n    // If we have an active registration and target/hotkey changed, unregister first\n    if (registrationRef.current?.isActive && (targetChanged || hotkeyChanged)) {\n      registrationRef.current.unregister()\n      registrationRef.current = null\n    }\n\n    // Register if needed (no active registration)\n    // Use refs to access current values without adding them to dependencies\n    if (!registrationRef.current || !registrationRef.current.isActive) {\n      registrationRef.current = managerRef.current.register(\n        hotkeyString,\n        callbackRef.current,\n        {\n          ...optionsRef.current,\n          target: resolvedTarget,\n        },\n      )\n    }\n\n    // Update tracking refs\n    prevTargetRef.current = resolvedTarget\n    prevHotkeyRef.current = hotkeyString\n\n    // Cleanup on unmount\n    return () => {\n      if (registrationRef.current?.isActive) {\n        registrationRef.current.unregister()\n        registrationRef.current = null\n      }\n    }\n  }, [hotkeyString])\n\n  // Sync callback and options on EVERY render (outside useEffect)\n  // This avoids stale closures - the callback always has access to latest state\n  if (registrationRef.current?.isActive) {\n    registrationRef.current.callback = callback\n    registrationRef.current.setOptions(optionsWithoutTarget)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyFA,SAAgB,UACd,QACA,UACA,UAA4B,EAAE,EACxB;CACN,MAAM,gBAAgB;EACpB,GAAG,0BAA0B,CAAC;EAC9B,GAAG;EACJ;CAED,MAAM,UAAU,kBAAkB;CAGlC,MAAM,kBAAkB,OAAwC,KAAK;CAGrE,MAAM,cAAc,OAAO,SAAS;CACpC,MAAM,aAAa,OAAO,cAAc;CACxC,MAAM,aAAa,OAAO,QAAQ;AAGlC,aAAY,UAAU;AACtB,YAAW,UAAU;AACrB,YAAW,UAAU;CAGrB,MAAM,gBAAgB,OAA+C,KAAK;CAC1E,MAAM,gBAAgB,OAAsB,KAAK;CAIjD,MAAM,eAAe,4BAA4B,QADhC,cAAc,YAAY,gBAAgB,CACO;CAGlE,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,iBAAgB;EAEd,MAAM,iBAAiB,MAAM,WAAW,QAAQ,OAAO,GACnD,WAAW,QAAQ,OAAO,UACzB,WAAW,QAAQ,WACnB,OAAO,aAAa,cAAc,WAAW;AAGlD,MAAI,CAAC,gBAAgB;AACnB,OAAI,gBAAgB,SAAS,UAAU;AACrC,oBAAgB,QAAQ,YAAY;AACpC,oBAAgB,UAAU;;AAE5B,iBAAc,UAAU;AACxB,iBAAc,UAAU;AACxB;;EAIF,MAAM,gBACJ,cAAc,YAAY,QAAQ,cAAc,YAAY;EAC9D,MAAM,gBACJ,cAAc,YAAY,QAAQ,cAAc,YAAY;AAG9D,MAAI,gBAAgB,SAAS,aAAa,iBAAiB,gBAAgB;AACzE,mBAAgB,QAAQ,YAAY;AACpC,mBAAgB,UAAU;;AAK5B,MAAI,CAAC,gBAAgB,WAAW,CAAC,gBAAgB,QAAQ,SACvD,iBAAgB,UAAU,WAAW,QAAQ,SAC3C,cACA,YAAY,SACZ;GACE,GAAG,WAAW;GACd,QAAQ;GACT,CACF;AAIH,gBAAc,UAAU;AACxB,gBAAc,UAAU;AAGxB,eAAa;AACX,OAAI,gBAAgB,SAAS,UAAU;AACrC,oBAAgB,QAAQ,YAAY;AACpC,oBAAgB,UAAU;;;IAG7B,CAAC,aAAa,CAAC;AAIlB,KAAI,gBAAgB,SAAS,UAAU;AACrC,kBAAgB,QAAQ,WAAW;AACnC,kBAAgB,QAAQ,WAAW,qBAAqB"}

package/dist/useHotkeyRecorder.cjs

@@ -1,71 +0,0 @@
-const require_HotkeysProvider = require('./HotkeysProvider.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let preact_hooks = require("preact/hooks");
-let _tanstack_preact_store = require("@tanstack/preact-store");
-
-//#region src/useHotkeyRecorder.ts
-/**
-* Preact hook for recording keyboard shortcuts.
-*
-* This hook provides a thin wrapper around the framework-agnostic `HotkeyRecorder`
-* class, managing all the complexity of capturing keyboard events, converting them
-* to hotkey strings, and handling edge cases like Escape to cancel or Backspace/Delete
-* to clear.
-*
-* @param options - Configuration options for the recorder
-* @returns An object with recording state and control functions
-*
-* @example
-* ```tsx
-* function ShortcutSettings() {
-*   const [shortcut, setShortcut] = useState<Hotkey>('Mod+S')
-*
-*   const recorder = useHotkeyRecorder({
-*     onRecord: (hotkey) => {
-*       setShortcut(hotkey)
-*     },
-*     onCancel: () => {
-*       console.log('Recording cancelled')
-*     },
-*   })
-*
-*   return (
-*     <div>
-*       <button onClick={recorder.startRecording}>
-*         {recorder.isRecording ? 'Recording...' : 'Edit Shortcut'}
-*       </button>
-*       {recorder.recordedHotkey && (
-*         <div>Recording: {recorder.recordedHotkey}</div>
-*       )}
-*     </div>
-*   )
-* }
-* ```
-*/
-function useHotkeyRecorder(options) {
-	const mergedOptions = {
-		...require_HotkeysProvider.useDefaultHotkeysOptions().hotkeyRecorder,
-		...options
-	};
-	const recorderRef = (0, preact_hooks.useRef)(null);
-	if (!recorderRef.current) recorderRef.current = new _tanstack_hotkeys.HotkeyRecorder(mergedOptions);
-	recorderRef.current.setOptions(mergedOptions);
-	const isRecording = (0, _tanstack_preact_store.useSelector)(recorderRef.current.store, (state) => state.isRecording);
-	const recordedHotkey = (0, _tanstack_preact_store.useSelector)(recorderRef.current.store, (state) => state.recordedHotkey);
-	(0, preact_hooks.useEffect)(() => {
-		return () => {
-			recorderRef.current?.destroy();
-		};
-	}, []);
-	return {
-		isRecording,
-		recordedHotkey,
-		startRecording: () => recorderRef.current?.start(),
-		stopRecording: () => recorderRef.current?.stop(),
-		cancelRecording: () => recorderRef.current?.cancel()
-	};
-}
-
-//#endregion
-exports.useHotkeyRecorder = useHotkeyRecorder;
-//# sourceMappingURL=useHotkeyRecorder.cjs.map

package/dist/useHotkeyRecorder.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeyRecorder.cjs","names":["useDefaultHotkeysOptions","HotkeyRecorder"],"sources":["../src/useHotkeyRecorder.ts"],"sourcesContent":["import { useEffect, useRef } from 'preact/hooks'\nimport { useSelector } from '@tanstack/preact-store'\nimport { HotkeyRecorder } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type { Hotkey, HotkeyRecorderOptions } from '@tanstack/hotkeys'\n\nexport interface PreactHotkeyRecorder {\n  /** Whether recording is currently active */\n  isRecording: boolean\n  /** The currently recorded hotkey (for live preview) */\n  recordedHotkey: Hotkey | null\n  /** Start recording a new hotkey */\n  startRecording: () => void\n  /** Stop recording (same as cancel) */\n  stopRecording: () => void\n  /** Cancel recording without saving */\n  cancelRecording: () => void\n}\n\n/**\n * Preact hook for recording keyboard shortcuts.\n *\n * This hook provides a thin wrapper around the framework-agnostic `HotkeyRecorder`\n * class, managing all the complexity of capturing keyboard events, converting them\n * to hotkey strings, and handling edge cases like Escape to cancel or Backspace/Delete\n * to clear.\n *\n * @param options - Configuration options for the recorder\n * @returns An object with recording state and control functions\n *\n * @example\n * ```tsx\n * function ShortcutSettings() {\n *   const [shortcut, setShortcut] = useState<Hotkey>('Mod+S')\n *\n *   const recorder = useHotkeyRecorder({\n *     onRecord: (hotkey) => {\n *       setShortcut(hotkey)\n *     },\n *     onCancel: () => {\n *       console.log('Recording cancelled')\n *     },\n *   })\n *\n *   return (\n *     <div>\n *       <button onClick={recorder.startRecording}>\n *         {recorder.isRecording ? 'Recording...' : 'Edit Shortcut'}\n *       </button>\n *       {recorder.recordedHotkey && (\n *         <div>Recording: {recorder.recordedHotkey}</div>\n *       )}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useHotkeyRecorder(\n  options: HotkeyRecorderOptions,\n): PreactHotkeyRecorder {\n  const mergedOptions = {\n    ...useDefaultHotkeysOptions().hotkeyRecorder,\n    ...options,\n  } as HotkeyRecorderOptions\n\n  const recorderRef = useRef<HotkeyRecorder | null>(null)\n\n  // Create recorder instance once\n  if (!recorderRef.current) {\n    recorderRef.current = new HotkeyRecorder(mergedOptions)\n  }\n\n  // Sync options on every render (same pattern as useHotkey)\n  // This ensures callbacks always have access to latest values\n  recorderRef.current.setOptions(mergedOptions)\n\n  // Subscribe to recorder state using useSelector (same pattern as useHeldKeys)\n  const isRecording = useSelector(\n    recorderRef.current.store,\n    (state) => state.isRecording,\n  )\n  const recordedHotkey = useSelector(\n    recorderRef.current.store,\n    (state) => state.recordedHotkey,\n  )\n\n  // Cleanup on unmount\n  useEffect(() => {\n    return () => {\n      recorderRef.current?.destroy()\n    }\n  }, [])\n\n  return {\n    isRecording,\n    recordedHotkey,\n    startRecording: () => recorderRef.current?.start(),\n    stopRecording: () => recorderRef.current?.stop(),\n    cancelRecording: () => recorderRef.current?.cancel(),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,kBACd,SACsB;CACtB,MAAM,gBAAgB;EACpB,GAAGA,kDAA0B,CAAC;EAC9B,GAAG;EACJ;CAED,MAAM,uCAA4C,KAAK;AAGvD,KAAI,CAAC,YAAY,QACf,aAAY,UAAU,IAAIC,iCAAe,cAAc;AAKzD,aAAY,QAAQ,WAAW,cAAc;CAG7C,MAAM,sDACJ,YAAY,QAAQ,QACnB,UAAU,MAAM,YAClB;CACD,MAAM,yDACJ,YAAY,QAAQ,QACnB,UAAU,MAAM,eAClB;AAGD,mCAAgB;AACd,eAAa;AACX,eAAY,SAAS,SAAS;;IAE/B,EAAE,CAAC;AAEN,QAAO;EACL;EACA;EACA,sBAAsB,YAAY,SAAS,OAAO;EAClD,qBAAqB,YAAY,SAAS,MAAM;EAChD,uBAAuB,YAAY,SAAS,QAAQ;EACrD"}

package/dist/useHotkeyRecorder.d.cts

@@ -1,57 +0,0 @@
-import { Hotkey, HotkeyRecorderOptions } from "@tanstack/hotkeys";
-
-//#region src/useHotkeyRecorder.d.ts
-interface PreactHotkeyRecorder {
-  /** Whether recording is currently active */
-  isRecording: boolean;
-  /** The currently recorded hotkey (for live preview) */
-  recordedHotkey: Hotkey | null;
-  /** Start recording a new hotkey */
-  startRecording: () => void;
-  /** Stop recording (same as cancel) */
-  stopRecording: () => void;
-  /** Cancel recording without saving */
-  cancelRecording: () => void;
-}
-/**
- * Preact hook for recording keyboard shortcuts.
- *
- * This hook provides a thin wrapper around the framework-agnostic `HotkeyRecorder`
- * class, managing all the complexity of capturing keyboard events, converting them
- * to hotkey strings, and handling edge cases like Escape to cancel or Backspace/Delete
- * to clear.
- *
- * @param options - Configuration options for the recorder
- * @returns An object with recording state and control functions
- *
- * @example
- * ```tsx
- * function ShortcutSettings() {
- *   const [shortcut, setShortcut] = useState<Hotkey>('Mod+S')
- *
- *   const recorder = useHotkeyRecorder({
- *     onRecord: (hotkey) => {
- *       setShortcut(hotkey)
- *     },
- *     onCancel: () => {
- *       console.log('Recording cancelled')
- *     },
- *   })
- *
- *   return (
- *     <div>
- *       <button onClick={recorder.startRecording}>
- *         {recorder.isRecording ? 'Recording...' : 'Edit Shortcut'}
- *       </button>
- *       {recorder.recordedHotkey && (
- *         <div>Recording: {recorder.recordedHotkey}</div>
- *       )}
- *     </div>
- *   )
- * }
- * ```
- */
-declare function useHotkeyRecorder(options: HotkeyRecorderOptions): PreactHotkeyRecorder;
-//#endregion
-export { PreactHotkeyRecorder, useHotkeyRecorder };
-//# sourceMappingURL=useHotkeyRecorder.d.cts.map

package/dist/useHotkeyRecorder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeyRecorder.js","names":[],"sources":["../src/useHotkeyRecorder.ts"],"sourcesContent":["import { useEffect, useRef } from 'preact/hooks'\nimport { useSelector } from '@tanstack/preact-store'\nimport { HotkeyRecorder } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type { Hotkey, HotkeyRecorderOptions } from '@tanstack/hotkeys'\n\nexport interface PreactHotkeyRecorder {\n  /** Whether recording is currently active */\n  isRecording: boolean\n  /** The currently recorded hotkey (for live preview) */\n  recordedHotkey: Hotkey | null\n  /** Start recording a new hotkey */\n  startRecording: () => void\n  /** Stop recording (same as cancel) */\n  stopRecording: () => void\n  /** Cancel recording without saving */\n  cancelRecording: () => void\n}\n\n/**\n * Preact hook for recording keyboard shortcuts.\n *\n * This hook provides a thin wrapper around the framework-agnostic `HotkeyRecorder`\n * class, managing all the complexity of capturing keyboard events, converting them\n * to hotkey strings, and handling edge cases like Escape to cancel or Backspace/Delete\n * to clear.\n *\n * @param options - Configuration options for the recorder\n * @returns An object with recording state and control functions\n *\n * @example\n * ```tsx\n * function ShortcutSettings() {\n *   const [shortcut, setShortcut] = useState<Hotkey>('Mod+S')\n *\n *   const recorder = useHotkeyRecorder({\n *     onRecord: (hotkey) => {\n *       setShortcut(hotkey)\n *     },\n *     onCancel: () => {\n *       console.log('Recording cancelled')\n *     },\n *   })\n *\n *   return (\n *     <div>\n *       <button onClick={recorder.startRecording}>\n *         {recorder.isRecording ? 'Recording...' : 'Edit Shortcut'}\n *       </button>\n *       {recorder.recordedHotkey && (\n *         <div>Recording: {recorder.recordedHotkey}</div>\n *       )}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useHotkeyRecorder(\n  options: HotkeyRecorderOptions,\n): PreactHotkeyRecorder {\n  const mergedOptions = {\n    ...useDefaultHotkeysOptions().hotkeyRecorder,\n    ...options,\n  } as HotkeyRecorderOptions\n\n  const recorderRef = useRef<HotkeyRecorder | null>(null)\n\n  // Create recorder instance once\n  if (!recorderRef.current) {\n    recorderRef.current = new HotkeyRecorder(mergedOptions)\n  }\n\n  // Sync options on every render (same pattern as useHotkey)\n  // This ensures callbacks always have access to latest values\n  recorderRef.current.setOptions(mergedOptions)\n\n  // Subscribe to recorder state using useSelector (same pattern as useHeldKeys)\n  const isRecording = useSelector(\n    recorderRef.current.store,\n    (state) => state.isRecording,\n  )\n  const recordedHotkey = useSelector(\n    recorderRef.current.store,\n    (state) => state.recordedHotkey,\n  )\n\n  // Cleanup on unmount\n  useEffect(() => {\n    return () => {\n      recorderRef.current?.destroy()\n    }\n  }, [])\n\n  return {\n    isRecording,\n    recordedHotkey,\n    startRecording: () => recorderRef.current?.start(),\n    stopRecording: () => recorderRef.current?.stop(),\n    cancelRecording: () => recorderRef.current?.cancel(),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,kBACd,SACsB;CACtB,MAAM,gBAAgB;EACpB,GAAG,0BAA0B,CAAC;EAC9B,GAAG;EACJ;CAED,MAAM,cAAc,OAA8B,KAAK;AAGvD,KAAI,CAAC,YAAY,QACf,aAAY,UAAU,IAAI,eAAe,cAAc;AAKzD,aAAY,QAAQ,WAAW,cAAc;CAG7C,MAAM,cAAc,YAClB,YAAY,QAAQ,QACnB,UAAU,MAAM,YAClB;CACD,MAAM,iBAAiB,YACrB,YAAY,QAAQ,QACnB,UAAU,MAAM,eAClB;AAGD,iBAAgB;AACd,eAAa;AACX,eAAY,SAAS,SAAS;;IAE/B,EAAE,CAAC;AAEN,QAAO;EACL;EACA;EACA,sBAAsB,YAAY,SAAS,OAAO;EAClD,qBAAqB,YAAY,SAAS,MAAM;EAChD,uBAAuB,YAAY,SAAS,QAAQ;EACrD"}

package/dist/useHotkeyRegistrations.cjs

@@ -1,26 +0,0 @@
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _tanstack_preact_store = require("@tanstack/preact-store");
-
-//#region src/useHotkeyRegistrations.ts
-/**
-* Preact hook that reactively reads all hotkey and sequence registrations
-* from the singleton managers.
-*
-* This is a standalone hook that does NOT require the HotkeysProvider.
-* It subscribes to both HotkeyManager and SequenceManager stores and
-* re-renders when registrations change.
-*
-* @returns Object with `hotkeys` and `sequences` arrays
-*/
-function useHotkeyRegistrations() {
-	const hotkeyManager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	const sequenceManager = (0, _tanstack_hotkeys.getSequenceManager)();
-	return {
-		hotkeys: (0, _tanstack_preact_store.useSelector)(hotkeyManager.registrations, (state) => Array.from(state.values()).map(_tanstack_hotkeys.toHotkeyRegistrationView)),
-		sequences: (0, _tanstack_preact_store.useSelector)(sequenceManager.registrations, (state) => Array.from(state.values()))
-	};
-}
-
-//#endregion
-exports.useHotkeyRegistrations = useHotkeyRegistrations;
-//# sourceMappingURL=useHotkeyRegistrations.cjs.map