@tanstack/react-hotkeys 0.11.0 → 0.12.1

package/dist/useHotkeys.cjs

@@ -1,125 +0,0 @@
-const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
-const require_HotkeysProvider = require('./HotkeysProvider.cjs');
-const require_utils = require('./utils.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let react = require("react");
-
-//#region src/useHotkeys.ts
-/**
-* React hook for registering multiple keyboard hotkeys at once.
-*
-* Uses the singleton HotkeyManager for efficient event handling.
-* Accepts a dynamic array of hotkey definitions, making it safe to use
-* with variable-length lists without violating the rules of hooks.
-*
-* Options are merged in this order:
-* HotkeysProvider defaults < commonOptions < per-definition options
-*
-* Callbacks and options are synced on every render to avoid stale closures.
-*
-* @param hotkeys - Array of hotkey definitions to register
-* @param commonOptions - Shared options applied to all hotkeys (overridden by per-definition options).
-*   Per-row `enabled: false` still registers that hotkey: `HotkeyManager` suppresses execution only (the row
-*   stays in the store and appears in TanStack Hotkeys devtools). Toggling `enabled` updates the existing handle
-*   via `setOptions` (no unregister/re-register churn).
-*
-* @example
-* ```tsx
-* function Editor() {
-*   useHotkeys([
-*     { hotkey: 'Mod+S', callback: () => save() },
-*     { hotkey: 'Mod+Z', callback: () => undo() },
-*     { hotkey: 'Escape', callback: () => close() },
-*   ])
-* }
-* ```
-*
-* @example
-* ```tsx
-* function MenuShortcuts({ items }) {
-*   // Dynamic hotkeys from data -- safe because it's a single hook call
-*   useHotkeys(
-*     items.map((item) => ({
-*       hotkey: item.shortcut,
-*       callback: item.action,
-*       options: { enabled: item.enabled },
-*     })),
-*     { preventDefault: true },
-*   )
-* }
-* ```
-*/
-function useHotkeys(hotkeys, commonOptions = {}) {
-	const defaultOptions = require_HotkeysProvider.useDefaultHotkeysOptions().hotkey;
-	const manager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	const platform = commonOptions.platform ?? defaultOptions?.platform ?? (0, _tanstack_hotkeys.detectPlatform)();
-	const registrationsRef = (0, react.useRef)(/* @__PURE__ */ new Map());
-	const hotkeysRef = (0, react.useRef)(hotkeys);
-	const hotkeyStringsRef = (0, react.useRef)([]);
-	const commonOptionsRef = (0, react.useRef)(commonOptions);
-	const defaultOptionsRef = (0, react.useRef)(defaultOptions);
-	const managerRef = (0, react.useRef)(manager);
-	const hotkeyStrings = hotkeys.map((def) => (0, _tanstack_hotkeys.normalizeRegisterableHotkey)(def.hotkey, platform));
-	hotkeysRef.current = hotkeys;
-	hotkeyStringsRef.current = hotkeyStrings;
-	commonOptionsRef.current = commonOptions;
-	defaultOptionsRef.current = defaultOptions;
-	managerRef.current = manager;
-	(0, react.useEffect)(() => {
-		const prevRegistrations = registrationsRef.current;
-		const nextRegistrations = /* @__PURE__ */ new Map();
-		const rows = [];
-		for (let i = 0; i < hotkeysRef.current.length; i++) {
-			const def = hotkeysRef.current[i];
-			const hotkeyStr = hotkeyStringsRef.current[i];
-			const mergedOptions = {
-				...defaultOptionsRef.current,
-				...commonOptionsRef.current,
-				...def.options
-			};
-			const resolvedTarget = require_utils.isRef(mergedOptions.target) ? mergedOptions.target.current : mergedOptions.target ?? (typeof document !== "undefined" ? document : null);
-			if (!resolvedTarget) continue;
-			const registrationKey = `${i}:${hotkeyStr}`;
-			rows.push({
-				registrationKey,
-				def,
-				hotkeyStr,
-				mergedOptions,
-				resolvedTarget
-			});
-		}
-		const nextKeys = new Set(rows.map((r) => r.registrationKey));
-		for (const [key, record] of prevRegistrations) if (!nextKeys.has(key) && record.handle.isActive) record.handle.unregister();
-		for (const row of rows) {
-			const { registrationKey, def, hotkeyStr, mergedOptions, resolvedTarget } = row;
-			const existing = prevRegistrations.get(registrationKey);
-			if (existing?.handle.isActive && existing.target === resolvedTarget) {
-				existing.handle.callback = def.callback;
-				const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-				existing.handle.setOptions(optionsWithoutTarget);
-				nextRegistrations.set(registrationKey, existing);
-				continue;
-			}
-			if (existing?.handle.isActive) existing.handle.unregister();
-			const handle = managerRef.current.register(hotkeyStr, def.callback, {
-				...mergedOptions,
-				target: resolvedTarget
-			});
-			nextRegistrations.set(registrationKey, {
-				handle,
-				target: resolvedTarget
-			});
-		}
-		registrationsRef.current = nextRegistrations;
-	});
-	(0, react.useEffect)(() => {
-		return () => {
-			for (const { handle } of registrationsRef.current.values()) if (handle.isActive) handle.unregister();
-			registrationsRef.current = /* @__PURE__ */ new Map();
-		};
-	}, []);
-}
-
-//#endregion
-exports.useHotkeys = useHotkeys;
-//# sourceMappingURL=useHotkeys.cjs.map

package/dist/useHotkeys.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeys.cjs","names":["useDefaultHotkeysOptions","isRef"],"sources":["../src/useHotkeys.ts"],"sourcesContent":["import { useEffect, useRef } from 'react'\nimport {\n  detectPlatform,\n  getHotkeyManager,\n  normalizeRegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport { isRef } from './utils'\nimport type { UseHotkeyOptions } from './useHotkey'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\n/**\n * A single hotkey definition for use with `useHotkeys`.\n */\nexport interface UseHotkeyDefinition {\n  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */\n  hotkey: RegisterableHotkey\n  /** The function to call when the hotkey is pressed */\n  callback: HotkeyCallback\n  /** Per-hotkey options (merged on top of commonOptions) */\n  options?: UseHotkeyOptions\n}\n\n/**\n * React hook for registering multiple keyboard hotkeys at once.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * Accepts a dynamic array of hotkey definitions, making it safe to use\n * with variable-length lists without violating the rules of hooks.\n *\n * Options are merged in this order:\n * HotkeysProvider defaults < commonOptions < per-definition options\n *\n * Callbacks and options are synced on every render to avoid stale closures.\n *\n * @param hotkeys - Array of hotkey definitions to register\n * @param commonOptions - Shared options applied to all hotkeys (overridden by per-definition options).\n *   Per-row `enabled: false` still registers that hotkey: `HotkeyManager` suppresses execution only (the row\n *   stays in the store and appears in TanStack Hotkeys devtools). Toggling `enabled` updates the existing handle\n *   via `setOptions` (no unregister/re-register churn).\n *\n * @example\n * ```tsx\n * function Editor() {\n *   useHotkeys([\n *     { hotkey: 'Mod+S', callback: () => save() },\n *     { hotkey: 'Mod+Z', callback: () => undo() },\n *     { hotkey: 'Escape', callback: () => close() },\n *   ])\n * }\n * ```\n *\n * @example\n * ```tsx\n * function MenuShortcuts({ items }) {\n *   // Dynamic hotkeys from data -- safe because it's a single hook call\n *   useHotkeys(\n *     items.map((item) => ({\n *       hotkey: item.shortcut,\n *       callback: item.action,\n *       options: { enabled: item.enabled },\n *     })),\n *     { preventDefault: true },\n *   )\n * }\n * ```\n */\nexport function useHotkeys(\n  hotkeys: Array<UseHotkeyDefinition>,\n  commonOptions: UseHotkeyOptions = {},\n): void {\n  type RegistrationRecord = {\n    handle: HotkeyRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = useDefaultHotkeysOptions().hotkey\n  const manager = getHotkeyManager()\n  const platform =\n    commonOptions.platform ?? defaultOptions?.platform ?? detectPlatform()\n\n  const registrationsRef = useRef<Map<string, RegistrationRecord>>(new Map())\n  const hotkeysRef = useRef(hotkeys)\n  const hotkeyStringsRef = useRef<Array<Hotkey>>([])\n  const commonOptionsRef = useRef(commonOptions)\n  const defaultOptionsRef = useRef(defaultOptions)\n  const managerRef = useRef(manager)\n\n  const hotkeyStrings = hotkeys.map((def) =>\n    normalizeRegisterableHotkey(def.hotkey, platform),\n  )\n\n  hotkeysRef.current = hotkeys\n  hotkeyStringsRef.current = hotkeyStrings\n  commonOptionsRef.current = commonOptions\n  defaultOptionsRef.current = defaultOptions\n  managerRef.current = manager\n\n  useEffect(() => {\n    const prevRegistrations = registrationsRef.current\n    const nextRegistrations = new Map<string, RegistrationRecord>()\n\n    const rows: Array<{\n      registrationKey: string\n      def: (typeof hotkeysRef.current)[number]\n      hotkeyStr: Hotkey\n      mergedOptions: UseHotkeyOptions\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < hotkeysRef.current.length; i++) {\n      const def = hotkeysRef.current[i]!\n      const hotkeyStr = hotkeyStringsRef.current[i]!\n      const mergedOptions = {\n        ...defaultOptionsRef.current,\n        ...commonOptionsRef.current,\n        ...def.options,\n      } as UseHotkeyOptions\n\n      const resolvedTarget = isRef(mergedOptions.target)\n        ? mergedOptions.target.current\n        : (mergedOptions.target ??\n          (typeof document !== 'undefined' ? document : null))\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${hotkeyStr}`\n      rows.push({\n        registrationKey,\n        def,\n        hotkeyStr,\n        mergedOptions,\n        resolvedTarget,\n      })\n    }\n\n    const nextKeys = new Set(rows.map((r) => r.registrationKey))\n\n    for (const [key, record] of prevRegistrations) {\n      if (!nextKeys.has(key) && record.handle.isActive) {\n        record.handle.unregister()\n      }\n    }\n\n    for (const row of rows) {\n      const { registrationKey, def, hotkeyStr, mergedOptions, resolvedTarget } =\n        row\n\n      const existing = prevRegistrations.get(registrationKey)\n      if (existing?.handle.isActive && existing.target === resolvedTarget) {\n        // Publish callback/options only after commit, never during render.\n        existing.handle.callback = def.callback\n        const { target: _target, ...optionsWithoutTarget } = mergedOptions\n        existing.handle.setOptions(optionsWithoutTarget)\n        nextRegistrations.set(registrationKey, existing)\n        continue\n      }\n\n      if (existing?.handle.isActive) {\n        existing.handle.unregister()\n      }\n\n      const handle = managerRef.current.register(hotkeyStr, def.callback, {\n        ...mergedOptions,\n        target: resolvedTarget,\n      })\n      nextRegistrations.set(registrationKey, {\n        handle,\n        target: resolvedTarget,\n      })\n    }\n\n    registrationsRef.current = nextRegistrations\n  })\n\n  useEffect(() => {\n    return () => {\n      for (const { handle } of registrationsRef.current.values()) {\n        if (handle.isActive) {\n          handle.unregister()\n        }\n      }\n      registrationsRef.current = new Map()\n    }\n  }, [])\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,SAAgB,WACd,SACA,gBAAkC,EAAE,EAC9B;CAMN,MAAM,iBAAiBA,kDAA0B,CAAC;CAClD,MAAM,mDAA4B;CAClC,MAAM,WACJ,cAAc,YAAY,gBAAgB,mDAA4B;CAExE,MAAM,qDAA2D,IAAI,KAAK,CAAC;CAC3E,MAAM,+BAAoB,QAAQ;CAClC,MAAM,qCAAyC,EAAE,CAAC;CAClD,MAAM,qCAA0B,cAAc;CAC9C,MAAM,sCAA2B,eAAe;CAChD,MAAM,+BAAoB,QAAQ;CAElC,MAAM,gBAAgB,QAAQ,KAAK,2DACL,IAAI,QAAQ,SAAS,CAClD;AAED,YAAW,UAAU;AACrB,kBAAiB,UAAU;AAC3B,kBAAiB,UAAU;AAC3B,mBAAkB,UAAU;AAC5B,YAAW,UAAU;AAErB,4BAAgB;EACd,MAAM,oBAAoB,iBAAiB;EAC3C,MAAM,oCAAoB,IAAI,KAAiC;EAE/D,MAAM,OAMD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,QAAQ,KAAK;GAClD,MAAM,MAAM,WAAW,QAAQ;GAC/B,MAAM,YAAY,iBAAiB,QAAQ;GAC3C,MAAM,gBAAgB;IACpB,GAAG,kBAAkB;IACrB,GAAG,iBAAiB;IACpB,GAAG,IAAI;IACR;GAED,MAAM,iBAAiBC,oBAAM,cAAc,OAAO,GAC9C,cAAc,OAAO,UACpB,cAAc,WACd,OAAO,aAAa,cAAc,WAAW;AAElD,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,GAAG;AAChC,QAAK,KAAK;IACR;IACA;IACA;IACA;IACA;IACD,CAAC;;EAGJ,MAAM,WAAW,IAAI,IAAI,KAAK,KAAK,MAAM,EAAE,gBAAgB,CAAC;AAE5D,OAAK,MAAM,CAAC,KAAK,WAAW,kBAC1B,KAAI,CAAC,SAAS,IAAI,IAAI,IAAI,OAAO,OAAO,SACtC,QAAO,OAAO,YAAY;AAI9B,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,EAAE,iBAAiB,KAAK,WAAW,eAAe,mBACtD;GAEF,MAAM,WAAW,kBAAkB,IAAI,gBAAgB;AACvD,OAAI,UAAU,OAAO,YAAY,SAAS,WAAW,gBAAgB;AAEnE,aAAS,OAAO,WAAW,IAAI;IAC/B,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AACrD,aAAS,OAAO,WAAW,qBAAqB;AAChD,sBAAkB,IAAI,iBAAiB,SAAS;AAChD;;AAGF,OAAI,UAAU,OAAO,SACnB,UAAS,OAAO,YAAY;GAG9B,MAAM,SAAS,WAAW,QAAQ,SAAS,WAAW,IAAI,UAAU;IAClE,GAAG;IACH,QAAQ;IACT,CAAC;AACF,qBAAkB,IAAI,iBAAiB;IACrC;IACA,QAAQ;IACT,CAAC;;AAGJ,mBAAiB,UAAU;GAC3B;AAEF,4BAAgB;AACd,eAAa;AACX,QAAK,MAAM,EAAE,YAAY,iBAAiB,QAAQ,QAAQ,CACxD,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,oBAAiB,0BAAU,IAAI,KAAK;;IAErC,EAAE,CAAC"}

package/dist/useHotkeys.d.cts

@@ -1,63 +0,0 @@
-import { UseHotkeyOptions } from "./useHotkey.cjs";
-import { HotkeyCallback, RegisterableHotkey } from "@tanstack/hotkeys";
-
-//#region src/useHotkeys.d.ts
-/**
- * A single hotkey definition for use with `useHotkeys`.
- */
-interface UseHotkeyDefinition {
-  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */
-  hotkey: RegisterableHotkey;
-  /** The function to call when the hotkey is pressed */
-  callback: HotkeyCallback;
-  /** Per-hotkey options (merged on top of commonOptions) */
-  options?: UseHotkeyOptions;
-}
-/**
- * React hook for registering multiple keyboard hotkeys at once.
- *
- * Uses the singleton HotkeyManager for efficient event handling.
- * Accepts a dynamic array of hotkey definitions, making it safe to use
- * with variable-length lists without violating the rules of hooks.
- *
- * Options are merged in this order:
- * HotkeysProvider defaults < commonOptions < per-definition options
- *
- * Callbacks and options are synced on every render to avoid stale closures.
- *
- * @param hotkeys - Array of hotkey definitions to register
- * @param commonOptions - Shared options applied to all hotkeys (overridden by per-definition options).
- *   Per-row `enabled: false` still registers that hotkey: `HotkeyManager` suppresses execution only (the row
- *   stays in the store and appears in TanStack Hotkeys devtools). Toggling `enabled` updates the existing handle
- *   via `setOptions` (no unregister/re-register churn).
- *
- * @example
- * ```tsx
- * function Editor() {
- *   useHotkeys([
- *     { hotkey: 'Mod+S', callback: () => save() },
- *     { hotkey: 'Mod+Z', callback: () => undo() },
- *     { hotkey: 'Escape', callback: () => close() },
- *   ])
- * }
- * ```
- *
- * @example
- * ```tsx
- * function MenuShortcuts({ items }) {
- *   // Dynamic hotkeys from data -- safe because it's a single hook call
- *   useHotkeys(
- *     items.map((item) => ({
- *       hotkey: item.shortcut,
- *       callback: item.action,
- *       options: { enabled: item.enabled },
- *     })),
- *     { preventDefault: true },
- *   )
- * }
- * ```
- */
-declare function useHotkeys(hotkeys: Array<UseHotkeyDefinition>, commonOptions?: UseHotkeyOptions): void;
-//#endregion
-export { UseHotkeyDefinition, useHotkeys };
-//# sourceMappingURL=useHotkeys.d.cts.map

package/dist/useHotkeys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeys.js","names":[],"sources":["../src/useHotkeys.ts"],"sourcesContent":["import { useEffect, useRef } from 'react'\nimport {\n  detectPlatform,\n  getHotkeyManager,\n  normalizeRegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport { isRef } from './utils'\nimport type { UseHotkeyOptions } from './useHotkey'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\n/**\n * A single hotkey definition for use with `useHotkeys`.\n */\nexport interface UseHotkeyDefinition {\n  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */\n  hotkey: RegisterableHotkey\n  /** The function to call when the hotkey is pressed */\n  callback: HotkeyCallback\n  /** Per-hotkey options (merged on top of commonOptions) */\n  options?: UseHotkeyOptions\n}\n\n/**\n * React hook for registering multiple keyboard hotkeys at once.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * Accepts a dynamic array of hotkey definitions, making it safe to use\n * with variable-length lists without violating the rules of hooks.\n *\n * Options are merged in this order:\n * HotkeysProvider defaults < commonOptions < per-definition options\n *\n * Callbacks and options are synced on every render to avoid stale closures.\n *\n * @param hotkeys - Array of hotkey definitions to register\n * @param commonOptions - Shared options applied to all hotkeys (overridden by per-definition options).\n *   Per-row `enabled: false` still registers that hotkey: `HotkeyManager` suppresses execution only (the row\n *   stays in the store and appears in TanStack Hotkeys devtools). Toggling `enabled` updates the existing handle\n *   via `setOptions` (no unregister/re-register churn).\n *\n * @example\n * ```tsx\n * function Editor() {\n *   useHotkeys([\n *     { hotkey: 'Mod+S', callback: () => save() },\n *     { hotkey: 'Mod+Z', callback: () => undo() },\n *     { hotkey: 'Escape', callback: () => close() },\n *   ])\n * }\n * ```\n *\n * @example\n * ```tsx\n * function MenuShortcuts({ items }) {\n *   // Dynamic hotkeys from data -- safe because it's a single hook call\n *   useHotkeys(\n *     items.map((item) => ({\n *       hotkey: item.shortcut,\n *       callback: item.action,\n *       options: { enabled: item.enabled },\n *     })),\n *     { preventDefault: true },\n *   )\n * }\n * ```\n */\nexport function useHotkeys(\n  hotkeys: Array<UseHotkeyDefinition>,\n  commonOptions: UseHotkeyOptions = {},\n): void {\n  type RegistrationRecord = {\n    handle: HotkeyRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = useDefaultHotkeysOptions().hotkey\n  const manager = getHotkeyManager()\n  const platform =\n    commonOptions.platform ?? defaultOptions?.platform ?? detectPlatform()\n\n  const registrationsRef = useRef<Map<string, RegistrationRecord>>(new Map())\n  const hotkeysRef = useRef(hotkeys)\n  const hotkeyStringsRef = useRef<Array<Hotkey>>([])\n  const commonOptionsRef = useRef(commonOptions)\n  const defaultOptionsRef = useRef(defaultOptions)\n  const managerRef = useRef(manager)\n\n  const hotkeyStrings = hotkeys.map((def) =>\n    normalizeRegisterableHotkey(def.hotkey, platform),\n  )\n\n  hotkeysRef.current = hotkeys\n  hotkeyStringsRef.current = hotkeyStrings\n  commonOptionsRef.current = commonOptions\n  defaultOptionsRef.current = defaultOptions\n  managerRef.current = manager\n\n  useEffect(() => {\n    const prevRegistrations = registrationsRef.current\n    const nextRegistrations = new Map<string, RegistrationRecord>()\n\n    const rows: Array<{\n      registrationKey: string\n      def: (typeof hotkeysRef.current)[number]\n      hotkeyStr: Hotkey\n      mergedOptions: UseHotkeyOptions\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < hotkeysRef.current.length; i++) {\n      const def = hotkeysRef.current[i]!\n      const hotkeyStr = hotkeyStringsRef.current[i]!\n      const mergedOptions = {\n        ...defaultOptionsRef.current,\n        ...commonOptionsRef.current,\n        ...def.options,\n      } as UseHotkeyOptions\n\n      const resolvedTarget = isRef(mergedOptions.target)\n        ? mergedOptions.target.current\n        : (mergedOptions.target ??\n          (typeof document !== 'undefined' ? document : null))\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${hotkeyStr}`\n      rows.push({\n        registrationKey,\n        def,\n        hotkeyStr,\n        mergedOptions,\n        resolvedTarget,\n      })\n    }\n\n    const nextKeys = new Set(rows.map((r) => r.registrationKey))\n\n    for (const [key, record] of prevRegistrations) {\n      if (!nextKeys.has(key) && record.handle.isActive) {\n        record.handle.unregister()\n      }\n    }\n\n    for (const row of rows) {\n      const { registrationKey, def, hotkeyStr, mergedOptions, resolvedTarget } =\n        row\n\n      const existing = prevRegistrations.get(registrationKey)\n      if (existing?.handle.isActive && existing.target === resolvedTarget) {\n        // Publish callback/options only after commit, never during render.\n        existing.handle.callback = def.callback\n        const { target: _target, ...optionsWithoutTarget } = mergedOptions\n        existing.handle.setOptions(optionsWithoutTarget)\n        nextRegistrations.set(registrationKey, existing)\n        continue\n      }\n\n      if (existing?.handle.isActive) {\n        existing.handle.unregister()\n      }\n\n      const handle = managerRef.current.register(hotkeyStr, def.callback, {\n        ...mergedOptions,\n        target: resolvedTarget,\n      })\n      nextRegistrations.set(registrationKey, {\n        handle,\n        target: resolvedTarget,\n      })\n    }\n\n    registrationsRef.current = nextRegistrations\n  })\n\n  useEffect(() => {\n    return () => {\n      for (const { handle } of registrationsRef.current.values()) {\n        if (handle.isActive) {\n          handle.unregister()\n        }\n      }\n      registrationsRef.current = new Map()\n    }\n  }, [])\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,SAAgB,WACd,SACA,gBAAkC,EAAE,EAC9B;CAMN,MAAM,iBAAiB,0BAA0B,CAAC;CAClD,MAAM,UAAU,kBAAkB;CAClC,MAAM,WACJ,cAAc,YAAY,gBAAgB,YAAY,gBAAgB;CAExE,MAAM,mBAAmB,uBAAwC,IAAI,KAAK,CAAC;CAC3E,MAAM,aAAa,OAAO,QAAQ;CAClC,MAAM,mBAAmB,OAAsB,EAAE,CAAC;CAClD,MAAM,mBAAmB,OAAO,cAAc;CAC9C,MAAM,oBAAoB,OAAO,eAAe;CAChD,MAAM,aAAa,OAAO,QAAQ;CAElC,MAAM,gBAAgB,QAAQ,KAAK,QACjC,4BAA4B,IAAI,QAAQ,SAAS,CAClD;AAED,YAAW,UAAU;AACrB,kBAAiB,UAAU;AAC3B,kBAAiB,UAAU;AAC3B,mBAAkB,UAAU;AAC5B,YAAW,UAAU;AAErB,iBAAgB;EACd,MAAM,oBAAoB,iBAAiB;EAC3C,MAAM,oCAAoB,IAAI,KAAiC;EAE/D,MAAM,OAMD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,QAAQ,KAAK;GAClD,MAAM,MAAM,WAAW,QAAQ;GAC/B,MAAM,YAAY,iBAAiB,QAAQ;GAC3C,MAAM,gBAAgB;IACpB,GAAG,kBAAkB;IACrB,GAAG,iBAAiB;IACpB,GAAG,IAAI;IACR;GAED,MAAM,iBAAiB,MAAM,cAAc,OAAO,GAC9C,cAAc,OAAO,UACpB,cAAc,WACd,OAAO,aAAa,cAAc,WAAW;AAElD,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,GAAG;AAChC,QAAK,KAAK;IACR;IACA;IACA;IACA;IACA;IACD,CAAC;;EAGJ,MAAM,WAAW,IAAI,IAAI,KAAK,KAAK,MAAM,EAAE,gBAAgB,CAAC;AAE5D,OAAK,MAAM,CAAC,KAAK,WAAW,kBAC1B,KAAI,CAAC,SAAS,IAAI,IAAI,IAAI,OAAO,OAAO,SACtC,QAAO,OAAO,YAAY;AAI9B,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,EAAE,iBAAiB,KAAK,WAAW,eAAe,mBACtD;GAEF,MAAM,WAAW,kBAAkB,IAAI,gBAAgB;AACvD,OAAI,UAAU,OAAO,YAAY,SAAS,WAAW,gBAAgB;AAEnE,aAAS,OAAO,WAAW,IAAI;IAC/B,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AACrD,aAAS,OAAO,WAAW,qBAAqB;AAChD,sBAAkB,IAAI,iBAAiB,SAAS;AAChD;;AAGF,OAAI,UAAU,OAAO,SACnB,UAAS,OAAO,YAAY;GAG9B,MAAM,SAAS,WAAW,QAAQ,SAAS,WAAW,IAAI,UAAU;IAClE,GAAG;IACH,QAAQ;IACT,CAAC;AACF,qBAAkB,IAAI,iBAAiB;IACrC;IACA,QAAQ;IACT,CAAC;;AAGJ,mBAAiB,UAAU;GAC3B;AAEF,iBAAgB;AACd,eAAa;AACX,QAAK,MAAM,EAAE,YAAY,iBAAiB,QAAQ,QAAQ,CACxD,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,oBAAiB,0BAAU,IAAI,KAAK;;IAErC,EAAE,CAAC"}

package/dist/useKeyHold.cjs

@@ -1,54 +0,0 @@
-const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _tanstack_react_store = require("@tanstack/react-store");
-
-//#region src/useKeyHold.ts
-/**
-* React hook that returns whether a specific key is currently being held.
-*
-* This hook uses `useSelector` from `@tanstack/react-store` to subscribe
-* to the global KeyStateTracker and uses a selector to determine if
-* the specified key is held.
-*
-* @param key - The key to check (e.g., 'Shift', 'Control', 'A')
-* @returns True if the key is currently held down
-*
-* @example
-* ```tsx
-* function ShiftIndicator() {
-*   const isShiftHeld = useKeyHold('Shift')
-*
-*   return (
-*     <div style={{ opacity: isShiftHeld ? 1 : 0.5 }}>
-*       {isShiftHeld ? 'Shift is pressed!' : 'Press Shift'}
-*     </div>
-*   )
-* }
-* ```
-*
-* @example
-* ```tsx
-* function ModifierIndicators() {
-*   const ctrl = useKeyHold('Control')
-*   const shift = useKeyHold('Shift')
-*   const alt = useKeyHold('Alt')
-*
-*   return (
-*     <div>
-*       <span style={{ opacity: ctrl ? 1 : 0.3 }}>Ctrl</span>
-*       <span style={{ opacity: shift ? 1 : 0.3 }}>Shift</span>
-*       <span style={{ opacity: alt ? 1 : 0.3 }}>Alt</span>
-*     </div>
-*   )
-* }
-* ```
-*/
-function useKeyHold(key) {
-	const tracker = (0, _tanstack_hotkeys.getKeyStateTracker)();
-	const normalizedKey = key.toLowerCase();
-	return (0, _tanstack_react_store.useSelector)(tracker.store, (state) => state.heldKeys.some((heldKey) => heldKey.toLowerCase() === normalizedKey));
-}
-
-//#endregion
-exports.useKeyHold = useKeyHold;
-//# sourceMappingURL=useKeyHold.cjs.map

package/dist/useKeyHold.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useKeyHold.cjs","names":[],"sources":["../src/useKeyHold.ts"],"sourcesContent":["import { useSelector } from '@tanstack/react-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\nimport type { IndividualKey } from '@tanstack/hotkeys'\n\n/**\n * React hook that returns whether a specific key is currently being held.\n *\n * This hook uses `useSelector` from `@tanstack/react-store` to subscribe\n * to the global KeyStateTracker and uses a selector to determine if\n * the specified key is held.\n *\n * @param key - The key to check (e.g., 'Shift', 'Control', 'A')\n * @returns True if the key is currently held down\n *\n * @example\n * ```tsx\n * function ShiftIndicator() {\n *   const isShiftHeld = useKeyHold('Shift')\n *\n *   return (\n *     <div style={{ opacity: isShiftHeld ? 1 : 0.5 }}>\n *       {isShiftHeld ? 'Shift is pressed!' : 'Press Shift'}\n *     </div>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * function ModifierIndicators() {\n *   const ctrl = useKeyHold('Control')\n *   const shift = useKeyHold('Shift')\n *   const alt = useKeyHold('Alt')\n *\n *   return (\n *     <div>\n *       <span style={{ opacity: ctrl ? 1 : 0.3 }}>Ctrl</span>\n *       <span style={{ opacity: shift ? 1 : 0.3 }}>Shift</span>\n *       <span style={{ opacity: alt ? 1 : 0.3 }}>Alt</span>\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useKeyHold(key: IndividualKey): boolean {\n  const tracker = getKeyStateTracker()\n  const normalizedKey = key.toLowerCase()\n\n  return useSelector(tracker.store, (state) =>\n    state.heldKeys.some((heldKey) => heldKey.toLowerCase() === normalizedKey),\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAgB,WAAW,KAA6B;CACtD,MAAM,qDAA8B;CACpC,MAAM,gBAAgB,IAAI,aAAa;AAEvC,+CAAmB,QAAQ,QAAQ,UACjC,MAAM,SAAS,MAAM,YAAY,QAAQ,aAAa,KAAK,cAAc,CAC1E"}

package/dist/useKeyHold.d.cts

@@ -1,47 +0,0 @@
-import { IndividualKey } from "@tanstack/hotkeys";
-
-//#region src/useKeyHold.d.ts
-/**
- * React hook that returns whether a specific key is currently being held.
- *
- * This hook uses `useSelector` from `@tanstack/react-store` to subscribe
- * to the global KeyStateTracker and uses a selector to determine if
- * the specified key is held.
- *
- * @param key - The key to check (e.g., 'Shift', 'Control', 'A')
- * @returns True if the key is currently held down
- *
- * @example
- * ```tsx
- * function ShiftIndicator() {
- *   const isShiftHeld = useKeyHold('Shift')
- *
- *   return (
- *     <div style={{ opacity: isShiftHeld ? 1 : 0.5 }}>
- *       {isShiftHeld ? 'Shift is pressed!' : 'Press Shift'}
- *     </div>
- *   )
- * }
- * ```
- *
- * @example
- * ```tsx
- * function ModifierIndicators() {
- *   const ctrl = useKeyHold('Control')
- *   const shift = useKeyHold('Shift')
- *   const alt = useKeyHold('Alt')
- *
- *   return (
- *     <div>
- *       <span style={{ opacity: ctrl ? 1 : 0.3 }}>Ctrl</span>
- *       <span style={{ opacity: shift ? 1 : 0.3 }}>Shift</span>
- *       <span style={{ opacity: alt ? 1 : 0.3 }}>Alt</span>
- *     </div>
- *   )
- * }
- * ```
- */
-declare function useKeyHold(key: IndividualKey): boolean;
-//#endregion
-export { useKeyHold };
-//# sourceMappingURL=useKeyHold.d.cts.map

package/dist/useKeyHold.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useKeyHold.js","names":[],"sources":["../src/useKeyHold.ts"],"sourcesContent":["import { useSelector } from '@tanstack/react-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\nimport type { IndividualKey } from '@tanstack/hotkeys'\n\n/**\n * React hook that returns whether a specific key is currently being held.\n *\n * This hook uses `useSelector` from `@tanstack/react-store` to subscribe\n * to the global KeyStateTracker and uses a selector to determine if\n * the specified key is held.\n *\n * @param key - The key to check (e.g., 'Shift', 'Control', 'A')\n * @returns True if the key is currently held down\n *\n * @example\n * ```tsx\n * function ShiftIndicator() {\n *   const isShiftHeld = useKeyHold('Shift')\n *\n *   return (\n *     <div style={{ opacity: isShiftHeld ? 1 : 0.5 }}>\n *       {isShiftHeld ? 'Shift is pressed!' : 'Press Shift'}\n *     </div>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * function ModifierIndicators() {\n *   const ctrl = useKeyHold('Control')\n *   const shift = useKeyHold('Shift')\n *   const alt = useKeyHold('Alt')\n *\n *   return (\n *     <div>\n *       <span style={{ opacity: ctrl ? 1 : 0.3 }}>Ctrl</span>\n *       <span style={{ opacity: shift ? 1 : 0.3 }}>Shift</span>\n *       <span style={{ opacity: alt ? 1 : 0.3 }}>Alt</span>\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useKeyHold(key: IndividualKey): boolean {\n  const tracker = getKeyStateTracker()\n  const normalizedKey = key.toLowerCase()\n\n  return useSelector(tracker.store, (state) =>\n    state.heldKeys.some((heldKey) => heldKey.toLowerCase() === normalizedKey),\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAgB,WAAW,KAA6B;CACtD,MAAM,UAAU,oBAAoB;CACpC,MAAM,gBAAgB,IAAI,aAAa;AAEvC,QAAO,YAAY,QAAQ,QAAQ,UACjC,MAAM,SAAS,MAAM,YAAY,QAAQ,aAAa,KAAK,cAAc,CAC1E"}

package/dist/utils.cjs

@@ -1,12 +0,0 @@
-
-//#region src/utils.ts
-/**
-* Type guard to check if a value is a React ref-like object.
-*/
-function isRef(value) {
-	return value !== null && typeof value === "object" && "current" in value;
-}
-
-//#endregion
-exports.isRef = isRef;
-//# sourceMappingURL=utils.cjs.map

package/dist/utils.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.cjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import type React from 'react'\n\n/**\n * Type guard to check if a value is a React ref-like object.\n */\nexport function isRef(\n  value: unknown,\n): value is React.RefObject<HTMLElement | null> {\n  return value !== null && typeof value === 'object' && 'current' in value\n}\n"],"mappings":";;;;;AAKA,SAAgB,MACd,OAC8C;AAC9C,QAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,aAAa"}

package/dist/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import type React from 'react'\n\n/**\n * Type guard to check if a value is a React ref-like object.\n */\nexport function isRef(\n  value: unknown,\n): value is React.RefObject<HTMLElement | null> {\n  return value !== null && typeof value === 'object' && 'current' in value\n}\n"],"mappings":";;;;AAKA,SAAgB,MACd,OAC8C;AAC9C,QAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,aAAa"}

package/src/HotkeysProvider.tsx

@@ -1,58 +0,0 @@
-import React, { createContext, useContext, useMemo } from 'react'
-import type { ReactNode } from 'react'
-import type {
-  HotkeyRecorderOptions,
-  HotkeySequenceRecorderOptions,
-} from '@tanstack/hotkeys'
-import type { UseHotkeyOptions } from './useHotkey'
-import type { UseHotkeySequenceOptions } from './useHotkeySequence'
-
-export interface HotkeysProviderOptions {
-  hotkey?: Partial<UseHotkeyOptions>
-  hotkeyRecorder?: Partial<HotkeyRecorderOptions>
-  hotkeySequence?: Partial<UseHotkeySequenceOptions>
-  hotkeySequenceRecorder?: Partial<HotkeySequenceRecorderOptions>
-}
-
-interface HotkeysContextValue {
-  defaultOptions: HotkeysProviderOptions
-}
-
-const HotkeysContext = createContext<HotkeysContextValue | null>(null)
-
-export interface HotkeysProviderProps {
-  children: ReactNode
-  defaultOptions?: HotkeysProviderOptions
-}
-
-const DEFAULT_OPTIONS: HotkeysProviderOptions = {}
-
-export function HotkeysProvider({
-  children,
-  defaultOptions = DEFAULT_OPTIONS,
-}: HotkeysProviderProps) {
-  const contextValue: HotkeysContextValue = useMemo(
-    () => ({
-      defaultOptions,
-    }),
-    [defaultOptions],
-  )
-
-  return (
-    // eslint-disable-next-line @eslint-react/no-context-provider -- React 19+ only; we support React >=16.8
-    <HotkeysContext.Provider value={contextValue}>
-      {children}
-    </HotkeysContext.Provider>
-  )
-}
-
-export function useHotkeysContext() {
-  // eslint-disable-next-line @eslint-react/no-use-context -- React 19+ only; we support React >=16.8
-  return useContext(HotkeysContext)
-}
-
-export function useDefaultHotkeysOptions() {
-  // eslint-disable-next-line @eslint-react/no-use-context -- React 19+ only; we support React >=16.8
-  const context = useContext(HotkeysContext)
-  return context?.defaultOptions ?? {}
-}

package/src/index.ts

@@ -1,18 +0,0 @@
-// Re-export everything from the core package
-export * from '@tanstack/hotkeys'
-
-// provider
-export * from './HotkeysProvider'
-
-// React-specific exports
-export * from './useHotkey'
-export * from './useHotkeys'
-export * from './useHeldKeys'
-export * from './useHeldKeyCodes'
-export * from './useKeyHold'
-export * from './useHotkeySequence'
-export * from './useHotkeySequences'
-export * from './useHotkeyRecorder'
-export * from './useHotkeyRegistrations'
-export * from './useHotkeySequenceRecorder'
-export * from './useHotkeyHint'

package/src/useHeldKeyCodes.ts

@@ -1,33 +0,0 @@
-import { useSelector } from '@tanstack/react-store'
-import { getKeyStateTracker } from '@tanstack/hotkeys'
-
-/**
- * React 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>
- *   )
- * }
- * ```
- */
-export function useHeldKeyCodes(): Record<string, string> {
-  const tracker = getKeyStateTracker()
-  return useSelector(tracker.store, (state) => state.heldCodes)
-}

package/src/useHeldKeys.ts

@@ -1,29 +0,0 @@
-import { useSelector } from '@tanstack/react-store'
-import { getKeyStateTracker } from '@tanstack/hotkeys'
-
-/**
- * React hook that returns an array of currently held keyboard keys.
- *
- * This hook uses `useSelector` from `@tanstack/react-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>
- *   )
- * }
- * ```
- */
-export function useHeldKeys(): Array<string> {
-  const tracker = getKeyStateTracker()
-  return useSelector(tracker.store, (state) => state.heldKeys)
-}