@redis-ui/components 47.4.0 → 47.5.1

package/dist/MultiSelect/components/Content/components/SelectAll/SelectAll.cjs

@@ -1,6 +1,6 @@
 require("../../../../../_virtual/_rolldown/runtime.cjs");
 const require_TextButton = require("../../../../../Button/TextButton/TextButton.cjs");
-const require_react_hotkeys_hook_esm = require("../../../../../node_modules/react-hotkeys-hook/dist/react-hotkeys-hook.esm.cjs");
+const require_useHotkey = require("../../../../../node_modules/@tanstack/react-hotkeys/dist/useHotkey.cjs");
 const require_Context = require("../../../Context/Context.cjs");
 let react_jsx_runtime = require("react/jsx-runtime");
 let react = require("react");
@@ -8,13 +8,17 @@ let react = require("react");
 var SelectAllAction = ({ selectAllTitle = "Select All", unselectAllTitle = "Unselect All", ...restProps }) => {
 	const { getSelectAllApi, hasSearch } = require_Context.useMultiSelectContext();
 	const { isAllSelected, hasSelectable, unselectAll, selectAll } = (0, react.useMemo)(() => getSelectAllApi(hasSearch), [getSelectAllApi, hasSearch]);
-	const setHotkeyComponent = require_react_hotkeys_hook_esm.useHotkeys("mod+a", () => isAllSelected ? unselectAll() : selectAll(), { preventDefault: true }, [
-		isAllSelected,
-		selectAll,
-		unselectAll
-	]);
+	const hotkeyTargetRef = (0, react.useRef)(null);
+	require_useHotkey.useHotkey("Mod+A", () => isAllSelected ? unselectAll() : selectAll(), {
+		target: hotkeyTargetRef,
+		preventDefault: true,
+		stopPropagation: false,
+		ignoreInputs: true
+	});
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_TextButton.default, {
-		ref: (0, react.useCallback)((ref) => setHotkeyComponent(ref?.closest("div[role=listbox]") || ref), [setHotkeyComponent]),
+		ref: (0, react.useCallback)((ref) => {
+			hotkeyTargetRef.current = ref?.closest("div[role=listbox]") || ref || null;
+		}, []),
 		disabled: !hasSelectable,
 		variant: "primary-inline",
 		...restProps,

package/dist/MultiSelect/components/Content/components/SelectAll/SelectAll.js

@@ -1,19 +1,23 @@
 import TextButton from "../../../../../Button/TextButton/TextButton.js";
-import { useHotkeys } from "../../../../../node_modules/react-hotkeys-hook/dist/react-hotkeys-hook.esm.js";
+import { useHotkey } from "../../../../../node_modules/@tanstack/react-hotkeys/dist/useHotkey.js";
 import { useMultiSelectContext } from "../../../Context/Context.js";
 import { jsx } from "react/jsx-runtime";
-import { useCallback, useMemo } from "react";
+import { useCallback, useMemo, useRef } from "react";
 //#region src/MultiSelect/components/Content/components/SelectAll/SelectAll.tsx
 var SelectAllAction = ({ selectAllTitle = "Select All", unselectAllTitle = "Unselect All", ...restProps }) => {
 	const { getSelectAllApi, hasSearch } = useMultiSelectContext();
 	const { isAllSelected, hasSelectable, unselectAll, selectAll } = useMemo(() => getSelectAllApi(hasSearch), [getSelectAllApi, hasSearch]);
-	const setHotkeyComponent = useHotkeys("mod+a", () => isAllSelected ? unselectAll() : selectAll(), { preventDefault: true }, [
-		isAllSelected,
-		selectAll,
-		unselectAll
-	]);
+	const hotkeyTargetRef = useRef(null);
+	useHotkey("Mod+A", () => isAllSelected ? unselectAll() : selectAll(), {
+		target: hotkeyTargetRef,
+		preventDefault: true,
+		stopPropagation: false,
+		ignoreInputs: true
+	});
 	return /* @__PURE__ */ jsx(TextButton, {
-		ref: useCallback((ref) => setHotkeyComponent(ref?.closest("div[role=listbox]") || ref), [setHotkeyComponent]),
+		ref: useCallback((ref) => {
+			hotkeyTargetRef.current = ref?.closest("div[role=listbox]") || ref || null;
+		}, []),
 		disabled: !hasSelectable,
 		variant: "primary-inline",
 		...restProps,

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

@@ -0,0 +1,389 @@
+//#region ../../node_modules/@tanstack/hotkeys/dist/constants.js
+/**
+* Detects the current platform based on browser navigator properties.
+*
+* Used internally to resolve platform-adaptive modifiers like 'Mod' (Command on Mac,
+* Control elsewhere) and for platform-specific hotkey formatting.
+*
+* @returns The detected platform: 'mac', 'windows', or 'linux'
+* @remarks Defaults to 'linux' in SSR environments where navigator is undefined
+*
+* @example
+* ```ts
+* const platform = detectPlatform() // 'mac' | 'windows' | 'linux'
+* const modifier = resolveModifier('Mod', platform) // 'Meta' on Mac, 'Control' elsewhere
+* ```
+*/
+function detectPlatform() {
+	if (typeof navigator === "undefined") return "linux";
+	const platform = navigator.platform?.toLowerCase() ?? "";
+	const userAgent = navigator.userAgent?.toLowerCase() ?? "";
+	if (platform.includes("mac") || userAgent.includes("mac")) return "mac";
+	if (platform.includes("win") || userAgent.includes("win")) return "windows";
+	return "linux";
+}
+/**
+* Canonical order for modifiers in normalized hotkey strings.
+*
+* Defines the standard order in which modifiers should appear when formatting
+* hotkeys. This ensures consistent, predictable output across the library.
+*
+* Order: Control → Alt → Shift → Meta
+*
+* @example
+* ```ts
+* // Input: 'Shift+Control+Meta+S'
+* // Normalized: 'Control+Alt+Shift+Meta+S' (following MODIFIER_ORDER)
+* ```
+*/
+var MODIFIER_ORDER = [
+	"Control",
+	"Alt",
+	"Shift",
+	"Meta"
+];
+new Set(MODIFIER_ORDER);
+/**
+* Maps modifier key aliases to their canonical form or platform-adaptive 'Mod'.
+*
+* This map allows users to write hotkeys using various aliases (e.g., 'Ctrl', 'Cmd', 'Option')
+* which are then normalized to canonical names ('Control', 'Meta', 'Alt') or the
+* platform-adaptive 'Mod' token.
+*
+* The 'Mod' and 'CommandOrControl' aliases are resolved at runtime via `resolveModifier()`
+* based on the detected platform (Command on Mac, Control elsewhere).
+*
+* @remarks Case-insensitive lookups are supported via lowercase variants
+*
+* @example
+* ```ts
+* MODIFIER_ALIASES['Ctrl'] // 'Control'
+* MODIFIER_ALIASES['Cmd'] // 'Meta'
+* MODIFIER_ALIASES['Mod'] // 'Mod' (resolved at runtime)
+* ```
+*/
+var MODIFIER_ALIASES = {
+	Control: "Control",
+	Ctrl: "Control",
+	control: "Control",
+	ctrl: "Control",
+	Shift: "Shift",
+	shift: "Shift",
+	Alt: "Alt",
+	Option: "Alt",
+	alt: "Alt",
+	option: "Alt",
+	Command: "Meta",
+	Cmd: "Meta",
+	Meta: "Meta",
+	command: "Meta",
+	cmd: "Meta",
+	meta: "Meta",
+	OS: "Meta",
+	os: "Meta",
+	Win: "Meta",
+	win: "Meta",
+	CommandOrControl: "Mod",
+	Mod: "Mod",
+	commandorcontrol: "Mod",
+	mod: "Mod"
+};
+/**
+* Resolves the platform-adaptive 'Mod' modifier to the appropriate canonical modifier.
+*
+* The 'Mod' token represents the "primary modifier" on each platform:
+* - macOS: 'Meta' (Command key ⌘)
+* - Windows/Linux: 'Control' (Ctrl key)
+*
+* This enables cross-platform hotkey definitions like 'Mod+S' that automatically
+* map to Command+S on Mac and Ctrl+S on Windows/Linux.
+*
+* @param modifier - The modifier to resolve. If 'Mod', resolves based on platform.
+* @param platform - The target platform. Defaults to auto-detection.
+* @returns The canonical modifier name ('Control', 'Shift', 'Alt', or 'Meta')
+*
+* @example
+* ```ts
+* resolveModifier('Mod', 'mac') // 'Meta'
+* resolveModifier('Mod', 'windows') // 'Control'
+* resolveModifier('Control', 'mac') // 'Control' (unchanged)
+* ```
+*/
+function resolveModifier(modifier, platform = detectPlatform()) {
+	if (modifier === "Mod") return platform === "mac" ? "Meta" : "Control";
+	return modifier;
+}
+/**
+* Set of all valid letter keys (A-Z).
+*
+* Used for validation and type checking. Letter keys are matched case-insensitively
+* in hotkey matching, but normalized to uppercase in canonical form.
+*/
+var LETTER_KEYS = new Set([
+	"A",
+	"B",
+	"C",
+	"D",
+	"E",
+	"F",
+	"G",
+	"H",
+	"I",
+	"J",
+	"K",
+	"L",
+	"M",
+	"N",
+	"O",
+	"P",
+	"Q",
+	"R",
+	"S",
+	"T",
+	"U",
+	"V",
+	"W",
+	"X",
+	"Y",
+	"Z"
+]);
+/**
+* Set of all valid number keys (0-9).
+*
+* Note: Number keys are affected by Shift (Shift+1 → '!' on US layout),
+* so they're excluded from Shift-based hotkey combinations to avoid
+* layout-dependent behavior.
+*/
+var NUMBER_KEYS = new Set([
+	"0",
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8",
+	"9"
+]);
+/**
+* Set of all valid function keys (F1-F12).
+*
+* Function keys are commonly used for system shortcuts (e.g., F12 for DevTools,
+* Alt+F4 to close windows) and application-specific commands.
+*/
+var FUNCTION_KEYS = new Set([
+	"F1",
+	"F2",
+	"F3",
+	"F4",
+	"F5",
+	"F6",
+	"F7",
+	"F8",
+	"F9",
+	"F10",
+	"F11",
+	"F12"
+]);
+/**
+* Set of all valid navigation keys for cursor movement and document navigation.
+*
+* Includes arrow keys, Home/End (line navigation), and PageUp/PageDown (page navigation).
+* These keys are commonly combined with modifiers for selection (Shift+ArrowUp) or
+* navigation shortcuts (Alt+ArrowLeft for back).
+*/
+var NAVIGATION_KEYS = new Set([
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown"
+]);
+/**
+* Set of all valid editing and special keys.
+*
+* Includes keys commonly used for text editing (Enter, Backspace, Delete, Tab) and
+* special actions (Escape, Space). These keys are frequently combined with modifiers
+* for editor shortcuts (Mod+Enter to submit, Shift+Tab to go back).
+*/
+var EDITING_KEYS = new Set([
+	"Enter",
+	"Escape",
+	"Space",
+	"Tab",
+	"Backspace",
+	"Delete"
+]);
+/**
+* Set of all valid punctuation keys commonly used in keyboard shortcuts.
+*
+* These are the literal characters as they appear in `KeyboardEvent.key` (layout-dependent,
+* typically US keyboard layout). Common shortcuts include:
+* - `Mod+/` - Toggle comment
+* - `Mod+[` / `Mod+]` - Indent/outdent
+* - `Mod+=` / `Mod+-` - Zoom in/out
+*
+* Note: Punctuation keys are affected by Shift (Shift+',' → '<' on US layout),
+* so they're excluded from Shift-based hotkey combinations to avoid layout-dependent behavior.
+*/
+var PUNCTUATION_KEYS = new Set([
+	"/",
+	"[",
+	"]",
+	"\\",
+	"=",
+	"-",
+	",",
+	".",
+	";",
+	"`"
+]);
+/**
+* Maps `KeyboardEvent.code` values for punctuation keys to their canonical characters.
+*
+* On macOS, holding the Option (Alt) key transforms punctuation keys into special characters
+* (e.g., Option+Minus → en-dash '–'), causing `event.key` to differ from the expected character.
+* However, `event.code` still reports the physical key (e.g., 'Minus'). This map enables
+* falling back to `event.code` for punctuation keys, similar to the existing `Key*`/`Digit*`
+* fallbacks for letters and digits.
+*/
+var PUNCTUATION_CODE_MAP = {
+	Backquote: "`",
+	Backslash: "\\",
+	BracketLeft: "[",
+	BracketRight: "]",
+	Comma: ",",
+	Equal: "=",
+	Minus: "-",
+	Period: ".",
+	Semicolon: ";",
+	Slash: "/"
+};
+new Set([
+	...LETTER_KEYS,
+	...NUMBER_KEYS,
+	...FUNCTION_KEYS,
+	...NAVIGATION_KEYS,
+	...EDITING_KEYS,
+	...PUNCTUATION_KEYS
+]);
+/**
+* Maps key name aliases to their canonical form.
+*
+* Handles common variations and alternative names for keys to provide a more
+* forgiving API. For example, users can write 'Esc', 'esc', or 'escape' and
+* they'll all normalize to 'Escape'.
+*
+* This map is used internally by `normalizeKeyName()` to convert user input
+* into the canonical key names used throughout the library.
+*
+* @remarks Case-insensitive lookups are supported via lowercase variants
+*
+* @example
+* ```ts
+* KEY_ALIASES['Esc'] // 'Escape'
+* KEY_ALIASES['Del'] // 'Delete'
+* KEY_ALIASES['Up'] // 'ArrowUp'
+* ```
+*/
+var KEY_ALIASES = {
+	Esc: "Escape",
+	esc: "Escape",
+	escape: "Escape",
+	Return: "Enter",
+	return: "Enter",
+	enter: "Enter",
+	" ": "Space",
+	space: "Space",
+	Spacebar: "Space",
+	spacebar: "Space",
+	tab: "Tab",
+	backspace: "Backspace",
+	Del: "Delete",
+	del: "Delete",
+	delete: "Delete",
+	Up: "ArrowUp",
+	up: "ArrowUp",
+	arrowup: "ArrowUp",
+	Down: "ArrowDown",
+	down: "ArrowDown",
+	arrowdown: "ArrowDown",
+	Left: "ArrowLeft",
+	left: "ArrowLeft",
+	arrowleft: "ArrowLeft",
+	Right: "ArrowRight",
+	right: "ArrowRight",
+	arrowright: "ArrowRight",
+	home: "Home",
+	end: "End",
+	pageup: "PageUp",
+	pagedown: "PageDown",
+	PgUp: "PageUp",
+	PgDn: "PageDown",
+	pgup: "PageUp",
+	pgdn: "PageDown"
+};
+/**
+* Normalizes a key name to its canonical form.
+*
+* Converts various key name formats (aliases, case variations) into the standard
+* canonical names used throughout the library. This enables a more forgiving API
+* where users can write keys in different ways and still get correct behavior.
+*
+* Normalization rules:
+* 1. Check aliases first (e.g., 'Esc' → 'Escape', 'Del' → 'Delete')
+* 2. Single letters → uppercase (e.g., 'a' → 'A', 's' → 'S')
+* 3. Function keys → uppercase (e.g., 'f1' → 'F1', 'F12' → 'F12')
+* 4. Other keys → returned as-is (already canonical or unknown)
+*
+* @param key - The key name to normalize (can be an alias, lowercase, etc.)
+* @returns The canonical key name
+*
+* @example
+* ```ts
+* normalizeKeyName('esc') // 'Escape'
+* normalizeKeyName('a') // 'A'
+* normalizeKeyName('f1') // 'F1'
+* normalizeKeyName('ArrowUp') // 'ArrowUp' (already canonical)
+* ```
+*/
+function isSingleLetterKey(key) {
+	return /^\p{Letter}$/u.test(key);
+}
+/**
+* Normalizes a key name to its canonical form.
+*
+* @param key - The key name to normalize (can be an alias, lowercase, etc.)
+* @returns The canonical key name
+*
+* @example
+* ```ts
+* normalizeKeyName('esc') // 'Escape'
+* normalizeKeyName('a') // 'A'
+* normalizeKeyName('f1') // 'F1'
+* normalizeKeyName('ArrowUp') // 'ArrowUp' (already canonical)
+* ```
+*/
+function normalizeKeyName(key) {
+	if (!key) return "";
+	if (key in KEY_ALIASES) return KEY_ALIASES[key];
+	if (isSingleLetterKey(key)) {
+		const upper = key.toUpperCase();
+		return upper.length === 1 ? upper : key;
+	}
+	const upperKey = key.toUpperCase();
+	if (/^F([1-9]|1[0-2])$/.test(upperKey)) return upperKey;
+	return key;
+}
+//#endregion
+exports.MODIFIER_ALIASES = MODIFIER_ALIASES;
+exports.MODIFIER_ORDER = MODIFIER_ORDER;
+exports.PUNCTUATION_CODE_MAP = PUNCTUATION_CODE_MAP;
+exports.detectPlatform = detectPlatform;
+exports.isSingleLetterKey = isSingleLetterKey;
+exports.normalizeKeyName = normalizeKeyName;
+exports.resolveModifier = resolveModifier;