@redis-ui/components 47.4.0 → 47.5.1

package/dist/node_modules/@tanstack/hotkeys/dist/match.js

@@ -0,0 +1,59 @@
+import { PUNCTUATION_CODE_MAP, detectPlatform, isSingleLetterKey, normalizeKeyName } from "./constants.js";
+import { parseHotkey } from "./parse.js";
+//#region ../../node_modules/@tanstack/hotkeys/dist/match.js
+/**
+* Checks if a KeyboardEvent matches a hotkey.
+*
+* Uses the `key` property from KeyboardEvent for matching, with a fallback to `code`
+* for letter keys, digit keys (0-9), and punctuation keys when `key` produces special
+* characters (e.g., macOS Option+letter, Shift+number, or Option+punctuation).
+* Letter keys are matched case-insensitively.
+*
+* Also handles "dead key" events where `event.key` is `'Dead'` instead of the expected
+* character. This commonly occurs on macOS with Option+letter combinations (e.g., Option+E,
+* Option+I, Option+U, Option+N) and on Windows/Linux with international keyboard layouts.
+* In these cases, `event.code` is used to determine the physical key.
+*
+* @param event - The KeyboardEvent to check
+* @param hotkey - The hotkey string or ParsedHotkey to match against
+* @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)
+* @returns True if the event matches the hotkey
+*
+* @example
+* ```ts
+* document.addEventListener('keydown', (event) => {
+*   if (matchesKeyboardEvent(event, 'Mod+S')) {
+*     event.preventDefault()
+*     handleSave()
+*   }
+* })
+* ```
+*/
+function matchesKeyboardEvent(event, hotkey, platform = detectPlatform()) {
+	const parsed = typeof hotkey === "string" ? parseHotkey(hotkey, platform) : hotkey;
+	if (event.ctrlKey !== parsed.ctrl) return false;
+	if (event.shiftKey !== parsed.shift) return false;
+	if (event.altKey !== parsed.alt) return false;
+	if (event.metaKey !== parsed.meta) return false;
+	const eventKey = normalizeKeyName(event.key);
+	const hotkeyKey = parsed.key;
+	if (eventKey !== "Dead" && eventKey.length === 1 && hotkeyKey.length === 1) {
+		if (eventKey.toUpperCase() === hotkeyKey.toUpperCase()) return true;
+		if (isSingleLetterKey(eventKey) && (/^[A-Za-z]$/.test(eventKey) || !event.altKey)) return false;
+	}
+	if (event.code && (eventKey === "Dead" || eventKey.length === 1 && hotkeyKey.length === 1)) {
+		if (event.code.startsWith("Key")) {
+			const codeLetter = event.code.slice(3);
+			if (codeLetter.length === 1 && /^[A-Za-z]$/.test(codeLetter)) return codeLetter.toUpperCase() === hotkeyKey.toUpperCase();
+		}
+		if (event.code.startsWith("Digit")) {
+			const codeDigit = event.code.slice(5);
+			if (codeDigit.length === 1 && /^[0-9]$/.test(codeDigit)) return codeDigit === hotkeyKey;
+		}
+		if (event.code in PUNCTUATION_CODE_MAP) return PUNCTUATION_CODE_MAP[event.code] === hotkeyKey;
+		return false;
+	}
+	return eventKey === hotkeyKey;
+}
+//#endregion
+export { matchesKeyboardEvent };

package/dist/node_modules/@tanstack/hotkeys/dist/parse.cjs

@@ -0,0 +1,143 @@
+const require_constants = require("./constants.cjs");
+//#region ../../node_modules/@tanstack/hotkeys/dist/parse.js
+/**
+* Parses a hotkey string into its component parts.
+*
+* @param hotkey - The hotkey string to parse (e.g., 'Mod+Shift+S')
+* @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)
+* @returns A ParsedHotkey object with the key and modifier flags
+*
+* @example
+* ```ts
+* parseHotkey('Mod+S') // On Mac: { key: 'S', ctrl: false, shift: false, alt: false, meta: true, modifiers: ['Meta'] }
+* parseHotkey('Mod+S') // On Windows: { key: 'S', ctrl: true, shift: false, alt: false, meta: false, modifiers: ['Control'] }
+* parseHotkey('Control+Shift+A') // { key: 'A', ctrl: true, shift: true, alt: false, meta: false, modifiers: ['Control', 'Shift'] }
+* ```
+*/
+function parseHotkey(hotkey, platform = require_constants.detectPlatform()) {
+	const parts = hotkey.split("+");
+	const modifiers = /* @__PURE__ */ new Set();
+	let key = "";
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i].trim();
+		if (i === parts.length - 1) key = require_constants.normalizeKeyName(part);
+		else {
+			const alias = require_constants.MODIFIER_ALIASES[part] ?? require_constants.MODIFIER_ALIASES[part.toLowerCase()];
+			if (alias) {
+				const resolved = require_constants.resolveModifier(alias, platform);
+				modifiers.add(resolved);
+			} else if (parts.length === 1) key = require_constants.normalizeKeyName(part);
+		}
+	}
+	if (!key && parts.length > 0) key = require_constants.normalizeKeyName(parts[parts.length - 1].trim());
+	return {
+		key,
+		ctrl: modifiers.has("Control"),
+		shift: modifiers.has("Shift"),
+		alt: modifiers.has("Alt"),
+		meta: modifiers.has("Meta"),
+		modifiers: require_constants.MODIFIER_ORDER.filter((m) => modifiers.has(m))
+	};
+}
+/**
+* Converts a RawHotkey object to a ParsedHotkey.
+* Optional modifier booleans default to false; modifiers array is derived from them.
+* When `mod` is true, it is resolved to Control or Meta based on platform.
+*
+* @param raw - The raw hotkey object
+* @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)
+* @returns A ParsedHotkey suitable for matching and formatting
+*
+* @example
+* ```ts
+* rawHotkeyToParsedHotkey({ key: 'Escape' })
+* // { key: 'Escape', ctrl: false, shift: false, alt: false, meta: false, modifiers: [] }
+*
+* rawHotkeyToParsedHotkey({ key: 'S', mod: true }, 'mac')
+* // { key: 'S', ctrl: false, shift: false, alt: false, meta: true, modifiers: ['Meta'] }
+*
+* rawHotkeyToParsedHotkey({ key: 'S', mod: true, shift: true }, 'windows')
+* // { key: 'S', ctrl: true, shift: true, alt: false, meta: false, modifiers: ['Control', 'Shift'] }
+* ```
+*/
+function rawHotkeyToParsedHotkey(raw, platform = require_constants.detectPlatform()) {
+	let ctrl = raw.ctrl ?? false;
+	const shift = raw.shift ?? false;
+	const alt = raw.alt ?? false;
+	let meta = raw.meta ?? false;
+	if (raw.mod) if (require_constants.resolveModifier("Mod", platform) === "Control") ctrl = true;
+	else meta = true;
+	const modifiers = require_constants.MODIFIER_ORDER.filter((m) => {
+		switch (m) {
+			case "Control": return ctrl;
+			case "Shift": return shift;
+			case "Alt": return alt;
+			case "Meta": return meta;
+			default: return false;
+		}
+	});
+	return {
+		key: raw.key,
+		ctrl,
+		shift,
+		alt,
+		meta,
+		modifiers
+	};
+}
+/**
+* Serializes a parsed hotkey to the canonical string form used for registration
+* and storage: `Mod` first when the platform allows, then `Alt`, then `Shift`;
+* otherwise full `Control+Alt+Shift+Meta` order.
+*/
+function normalizedHotkeyStringFromParsed(parsed, platform) {
+	const canUseMod = platform === "mac" ? parsed.meta && !parsed.ctrl : parsed.ctrl && !parsed.meta;
+	const parts = [];
+	if (canUseMod) {
+		parts.push("Mod");
+		if (parsed.alt) parts.push("Alt");
+		if (parsed.shift) parts.push("Shift");
+	} else for (const modifier of require_constants.MODIFIER_ORDER) if (parsed.modifiers.includes(modifier)) parts.push(modifier);
+	parts.push(require_constants.normalizeKeyName(parsed.key));
+	return parts.join("+");
+}
+/**
+* Normalizes a hotkey string to its canonical form.
+*
+* - When `Mod` is allowed for the platform (Command on Mac without Control;
+*   Control on Windows/Linux without Meta): emits `Mod`, then `Alt`, then `Shift`,
+*   then the key (e.g. `Mod+Shift+E`, `Mod+S`).
+* - Otherwise: literal modifiers in `Control+Alt+Shift+Meta` order, then the key.
+* - Resolves aliases and normalizes key casing (e.g. `esc` → `Escape`, `a` → `A`).
+*
+* @param hotkey - The hotkey string to normalize
+* @param platform - The target platform for resolving `Mod` (defaults to auto-detection)
+* @returns The normalized hotkey string
+*
+* @example
+* ```ts
+* normalizeHotkey('shift+meta+e', 'mac') // 'Mod+Shift+E'
+* normalizeHotkey('ctrl+a', 'windows') // 'Mod+A'
+* normalizeHotkey('esc') // 'Escape'
+* ```
+*/
+function normalizeHotkey(hotkey, platform = require_constants.detectPlatform()) {
+	return normalizedHotkeyStringFromParsed(parseHotkey(hotkey, platform), platform);
+}
+/**
+* Same canonical string as {@link normalizeHotkey}, but from an already-parsed hotkey.
+*/
+function normalizeHotkeyFromParsed(parsed, platform = require_constants.detectPlatform()) {
+	return normalizedHotkeyStringFromParsed(parsed, platform);
+}
+/**
+* Normalizes a string or {@link RawHotkey} object to the same canonical hotkey string.
+* Use this in framework adapters instead of branching on `formatHotkey(rawHotkeyToParsedHotkey(...))`.
+*/
+function normalizeRegisterableHotkey(hotkey, platform = require_constants.detectPlatform()) {
+	return typeof hotkey === "string" ? normalizeHotkey(hotkey, platform) : normalizeHotkeyFromParsed(rawHotkeyToParsedHotkey(hotkey, platform), platform);
+}
+//#endregion
+exports.normalizeRegisterableHotkey = normalizeRegisterableHotkey;
+exports.parseHotkey = parseHotkey;
+exports.rawHotkeyToParsedHotkey = rawHotkeyToParsedHotkey;

package/dist/node_modules/@tanstack/hotkeys/dist/parse.js

@@ -0,0 +1,141 @@
+import { MODIFIER_ALIASES, MODIFIER_ORDER, detectPlatform, normalizeKeyName, resolveModifier } from "./constants.js";
+//#region ../../node_modules/@tanstack/hotkeys/dist/parse.js
+/**
+* Parses a hotkey string into its component parts.
+*
+* @param hotkey - The hotkey string to parse (e.g., 'Mod+Shift+S')
+* @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)
+* @returns A ParsedHotkey object with the key and modifier flags
+*
+* @example
+* ```ts
+* parseHotkey('Mod+S') // On Mac: { key: 'S', ctrl: false, shift: false, alt: false, meta: true, modifiers: ['Meta'] }
+* parseHotkey('Mod+S') // On Windows: { key: 'S', ctrl: true, shift: false, alt: false, meta: false, modifiers: ['Control'] }
+* parseHotkey('Control+Shift+A') // { key: 'A', ctrl: true, shift: true, alt: false, meta: false, modifiers: ['Control', 'Shift'] }
+* ```
+*/
+function parseHotkey(hotkey, platform = detectPlatform()) {
+	const parts = hotkey.split("+");
+	const modifiers = /* @__PURE__ */ new Set();
+	let key = "";
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i].trim();
+		if (i === parts.length - 1) key = normalizeKeyName(part);
+		else {
+			const alias = MODIFIER_ALIASES[part] ?? MODIFIER_ALIASES[part.toLowerCase()];
+			if (alias) {
+				const resolved = resolveModifier(alias, platform);
+				modifiers.add(resolved);
+			} else if (parts.length === 1) key = normalizeKeyName(part);
+		}
+	}
+	if (!key && parts.length > 0) key = normalizeKeyName(parts[parts.length - 1].trim());
+	return {
+		key,
+		ctrl: modifiers.has("Control"),
+		shift: modifiers.has("Shift"),
+		alt: modifiers.has("Alt"),
+		meta: modifiers.has("Meta"),
+		modifiers: MODIFIER_ORDER.filter((m) => modifiers.has(m))
+	};
+}
+/**
+* Converts a RawHotkey object to a ParsedHotkey.
+* Optional modifier booleans default to false; modifiers array is derived from them.
+* When `mod` is true, it is resolved to Control or Meta based on platform.
+*
+* @param raw - The raw hotkey object
+* @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)
+* @returns A ParsedHotkey suitable for matching and formatting
+*
+* @example
+* ```ts
+* rawHotkeyToParsedHotkey({ key: 'Escape' })
+* // { key: 'Escape', ctrl: false, shift: false, alt: false, meta: false, modifiers: [] }
+*
+* rawHotkeyToParsedHotkey({ key: 'S', mod: true }, 'mac')
+* // { key: 'S', ctrl: false, shift: false, alt: false, meta: true, modifiers: ['Meta'] }
+*
+* rawHotkeyToParsedHotkey({ key: 'S', mod: true, shift: true }, 'windows')
+* // { key: 'S', ctrl: true, shift: true, alt: false, meta: false, modifiers: ['Control', 'Shift'] }
+* ```
+*/
+function rawHotkeyToParsedHotkey(raw, platform = detectPlatform()) {
+	let ctrl = raw.ctrl ?? false;
+	const shift = raw.shift ?? false;
+	const alt = raw.alt ?? false;
+	let meta = raw.meta ?? false;
+	if (raw.mod) if (resolveModifier("Mod", platform) === "Control") ctrl = true;
+	else meta = true;
+	const modifiers = MODIFIER_ORDER.filter((m) => {
+		switch (m) {
+			case "Control": return ctrl;
+			case "Shift": return shift;
+			case "Alt": return alt;
+			case "Meta": return meta;
+			default: return false;
+		}
+	});
+	return {
+		key: raw.key,
+		ctrl,
+		shift,
+		alt,
+		meta,
+		modifiers
+	};
+}
+/**
+* Serializes a parsed hotkey to the canonical string form used for registration
+* and storage: `Mod` first when the platform allows, then `Alt`, then `Shift`;
+* otherwise full `Control+Alt+Shift+Meta` order.
+*/
+function normalizedHotkeyStringFromParsed(parsed, platform) {
+	const canUseMod = platform === "mac" ? parsed.meta && !parsed.ctrl : parsed.ctrl && !parsed.meta;
+	const parts = [];
+	if (canUseMod) {
+		parts.push("Mod");
+		if (parsed.alt) parts.push("Alt");
+		if (parsed.shift) parts.push("Shift");
+	} else for (const modifier of MODIFIER_ORDER) if (parsed.modifiers.includes(modifier)) parts.push(modifier);
+	parts.push(normalizeKeyName(parsed.key));
+	return parts.join("+");
+}
+/**
+* Normalizes a hotkey string to its canonical form.
+*
+* - When `Mod` is allowed for the platform (Command on Mac without Control;
+*   Control on Windows/Linux without Meta): emits `Mod`, then `Alt`, then `Shift`,
+*   then the key (e.g. `Mod+Shift+E`, `Mod+S`).
+* - Otherwise: literal modifiers in `Control+Alt+Shift+Meta` order, then the key.
+* - Resolves aliases and normalizes key casing (e.g. `esc` → `Escape`, `a` → `A`).
+*
+* @param hotkey - The hotkey string to normalize
+* @param platform - The target platform for resolving `Mod` (defaults to auto-detection)
+* @returns The normalized hotkey string
+*
+* @example
+* ```ts
+* normalizeHotkey('shift+meta+e', 'mac') // 'Mod+Shift+E'
+* normalizeHotkey('ctrl+a', 'windows') // 'Mod+A'
+* normalizeHotkey('esc') // 'Escape'
+* ```
+*/
+function normalizeHotkey(hotkey, platform = detectPlatform()) {
+	return normalizedHotkeyStringFromParsed(parseHotkey(hotkey, platform), platform);
+}
+/**
+* Same canonical string as {@link normalizeHotkey}, but from an already-parsed hotkey.
+*/
+function normalizeHotkeyFromParsed(parsed, platform = detectPlatform()) {
+	return normalizedHotkeyStringFromParsed(parsed, platform);
+}
+/**
+* Normalizes a string or {@link RawHotkey} object to the same canonical hotkey string.
+* Use this in framework adapters instead of branching on `formatHotkey(rawHotkeyToParsedHotkey(...))`.
+*/
+function normalizeRegisterableHotkey(hotkey, platform = detectPlatform()) {
+	return typeof hotkey === "string" ? normalizeHotkey(hotkey, platform) : normalizeHotkeyFromParsed(rawHotkeyToParsedHotkey(hotkey, platform), platform);
+}
+//#endregion
+export { normalizeRegisterableHotkey, parseHotkey, rawHotkeyToParsedHotkey };

package/dist/node_modules/@tanstack/react-hotkeys/dist/HotkeysProvider.cjs

@@ -0,0 +1,10 @@
+const require_runtime = require("../../../../_virtual/_rolldown/runtime.cjs");
+let react = require("react");
+react = require_runtime.__toESM(react, 1);
+//#region ../../node_modules/@tanstack/react-hotkeys/dist/HotkeysProvider.js
+var HotkeysContext = (0, react.createContext)(null);
+function useDefaultHotkeysOptions() {
+	return (0, react.useContext)(HotkeysContext)?.defaultOptions ?? {};
+}
+//#endregion
+exports.useDefaultHotkeysOptions = useDefaultHotkeysOptions;

package/dist/node_modules/@tanstack/react-hotkeys/dist/HotkeysProvider.js

@@ -0,0 +1,8 @@
+import { createContext, useContext } from "react";
+//#region ../../node_modules/@tanstack/react-hotkeys/dist/HotkeysProvider.js
+var HotkeysContext = createContext(null);
+function useDefaultHotkeysOptions() {
+	return useContext(HotkeysContext)?.defaultOptions ?? {};
+}
+//#endregion
+export { useDefaultHotkeysOptions };

package/dist/node_modules/@tanstack/react-hotkeys/dist/useHotkey.cjs

@@ -0,0 +1,121 @@
+require("../../../../_virtual/_rolldown/runtime.cjs");
+const require_HotkeysProvider = require("./HotkeysProvider.cjs");
+const require_utils = require("./utils.cjs");
+const require_constants = require("../../hotkeys/dist/constants.cjs");
+const require_parse = require("../../hotkeys/dist/parse.cjs");
+const require_hotkey_manager = require("../../hotkeys/dist/hotkey-manager.cjs");
+let react = require("react");
+//#region ../../node_modules/@tanstack/react-hotkeys/dist/useHotkey.js
+/**
+* React 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 React 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 = require_hotkey_manager.getHotkeyManager();
+	const registrationRef = (0, react.useRef)(null);
+	const callbackRef = (0, react.useRef)(callback);
+	const optionsRef = (0, react.useRef)(mergedOptions);
+	const managerRef = (0, react.useRef)(manager);
+	callbackRef.current = callback;
+	optionsRef.current = mergedOptions;
+	managerRef.current = manager;
+	const prevTargetRef = (0, react.useRef)(null);
+	const prevHotkeyRef = (0, react.useRef)(null);
+	const hotkeyString = require_parse.normalizeRegisterableHotkey(hotkey, mergedOptions.platform ?? require_constants.detectPlatform());
+	const { target: _target, ...optionsWithoutTarget } = mergedOptions;
+	(0, react.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;

package/dist/node_modules/@tanstack/react-hotkeys/dist/useHotkey.js

@@ -0,0 +1,120 @@
+import { useDefaultHotkeysOptions } from "./HotkeysProvider.js";
+import { isRef } from "./utils.js";
+import { detectPlatform } from "../../hotkeys/dist/constants.js";
+import { normalizeRegisterableHotkey } from "../../hotkeys/dist/parse.js";
+import { getHotkeyManager } from "../../hotkeys/dist/hotkey-manager.js";
+import { useEffect, useRef } from "react";
+//#region ../../node_modules/@tanstack/react-hotkeys/dist/useHotkey.js
+/**
+* React 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 React 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 = {
+		...useDefaultHotkeysOptions().hotkey,
+		...options
+	};
+	const manager = getHotkeyManager();
+	const registrationRef = useRef(null);
+	const callbackRef = useRef(callback);
+	const optionsRef = useRef(mergedOptions);
+	const managerRef = useRef(manager);
+	callbackRef.current = callback;
+	optionsRef.current = mergedOptions;
+	managerRef.current = manager;
+	const prevTargetRef = useRef(null);
+	const prevHotkeyRef = useRef(null);
+	const hotkeyString = normalizeRegisterableHotkey(hotkey, mergedOptions.platform ?? detectPlatform());
+	const { target: _target, ...optionsWithoutTarget } = mergedOptions;
+	useEffect(() => {
+		const resolvedTarget = 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
+export { useHotkey };

package/dist/node_modules/@tanstack/react-hotkeys/dist/utils.cjs

@@ -0,0 +1,9 @@
+//#region ../../node_modules/@tanstack/react-hotkeys/dist/utils.js
+/**
+* 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;

package/dist/node_modules/@tanstack/react-hotkeys/dist/utils.js

@@ -0,0 +1,9 @@
+//#region ../../node_modules/@tanstack/react-hotkeys/dist/utils.js
+/**
+* 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
+export { isRef };