@tanstack/hotkeys 0.0.1 → 0.1.0

package/dist/parse.js

@@ -0,0 +1,258 @@
+import { MODIFIER_ALIASES, MODIFIER_ORDER, detectPlatform, normalizeKeyName, resolveModifier } from "./constants.js";
+
+//#region src/parse.ts
+/**
+* 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
+	};
+}
+/**
+* Normalizes a hotkey string to its canonical form.
+*
+* The canonical form uses:
+* - Full modifier names (Control, Alt, Shift, Meta)
+* - Modifiers in order: Control+Alt+Shift+Meta
+* - Uppercase letters for single-character keys
+* - Proper casing for special keys (Escape, not escape)
+*
+* @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('mod+shift+s') // On Mac: 'Shift+Meta+S'
+* normalizeHotkey('ctrl+a') // 'Control+A'
+* normalizeHotkey('esc') // 'Escape'
+* ```
+*/
+function normalizeHotkey(hotkey, platform = detectPlatform()) {
+	const parsed = parseHotkey(hotkey, platform);
+	const parts = [];
+	for (const modifier of MODIFIER_ORDER) if (parsed.modifiers.includes(modifier)) parts.push(modifier);
+	parts.push(parsed.key);
+	return parts.join("+");
+}
+/**
+* Checks if a string represents a modifier key.
+*
+* @param key - The string to check
+* @returns True if the string is a recognized modifier
+*/
+function isModifier(key) {
+	return key in MODIFIER_ALIASES || key.toLowerCase() in MODIFIER_ALIASES;
+}
+/**
+* Parses a KeyboardEvent into a ParsedHotkey object.
+*
+* This function extracts the key and modifier state from a keyboard event
+* and converts it into the same format used by `parseHotkey()`.
+*
+* @param event - The KeyboardEvent to parse
+* @param platform - The target platform for resolving modifiers (defaults to auto-detection)
+* @returns A ParsedHotkey object representing the keyboard event
+*
+* @example
+* ```ts
+* document.addEventListener('keydown', (event) => {
+*   const parsed = parseKeyboardEvent(event)
+*   console.log(parsed) // { key: 'S', ctrl: true, shift: false, ... }
+* })
+* ```
+*/
+function parseKeyboardEvent(event) {
+	const normalizedKey = normalizeKeyName(event.key);
+	const modifiers = [];
+	if (event.ctrlKey) modifiers.push("Control");
+	if (event.altKey) modifiers.push("Alt");
+	if (event.shiftKey) modifiers.push("Shift");
+	if (event.metaKey) modifiers.push("Meta");
+	return {
+		key: normalizedKey,
+		ctrl: event.ctrlKey,
+		shift: event.shiftKey,
+		alt: event.altKey,
+		meta: event.metaKey,
+		modifiers
+	};
+}
+/**
+* Converts a KeyboardEvent directly to a hotkey string.
+*
+* This is a convenience function that combines `parseKeyboardEvent()` and formatting.
+* The resulting hotkey string uses canonical modifier names (Control, Alt, Shift, Meta)
+* and is suitable for use with `useHotkey()` and other hotkey functions.
+*
+* @param event - The KeyboardEvent to convert
+* @param platform - The target platform (defaults to auto-detection)
+* @returns A hotkey string in canonical form (e.g., 'Control+Shift+S')
+*
+* @example
+* ```ts
+* document.addEventListener('keydown', (event) => {
+*   const hotkey = keyboardEventToHotkey(event)
+*   console.log(hotkey) // 'Control+Shift+S'
+*   useHotkey(hotkey, () => console.log('Shortcut triggered'))
+* })
+* ```
+*/
+function keyboardEventToHotkey(event) {
+	const parsed = parseKeyboardEvent(event);
+	const parts = [];
+	for (const modifier of MODIFIER_ORDER) if (parsed.modifiers.includes(modifier)) parts.push(modifier);
+	parts.push(parsed.key);
+	return parts.join("+");
+}
+/**
+* Checks if a KeyboardEvent represents a modifier-only key press.
+*
+* Modifier-only keys are keys like 'Control', 'Shift', 'Alt', 'Meta', etc.
+* that don't have an associated character or action key. This is useful
+* for filtering out modifier key presses when recording shortcuts.
+*
+* @param event - The KeyboardEvent to check
+* @returns True if the event represents a modifier-only key
+*
+* @example
+* ```ts
+* document.addEventListener('keydown', (event) => {
+*   if (isModifierKey(event)) {
+*     console.log('Modifier key pressed, waiting for action key...')
+*     return
+*   }
+*   // Process non-modifier key
+* })
+* ```
+*/
+function isModifierKey(event) {
+	const key = event.key;
+	return key === "Control" || key === "Shift" || key === "Alt" || key === "Meta" || key === "Command" || key === "OS" || key === "Win";
+}
+/**
+* Checks if a hotkey or ParsedHotkey contains at least one non-modifier key.
+*
+* This is useful for validating that a recorded hotkey is complete and not
+* just a combination of modifiers without an action key.
+*
+* @param hotkey - The hotkey string or ParsedHotkey to check
+* @param platform - The target platform for parsing (defaults to auto-detection)
+* @returns True if the hotkey contains at least one non-modifier key
+*
+* @example
+* ```ts
+* hasNonModifierKey('Control+Shift+S') // true
+* hasNonModifierKey('Control+Shift') // false (no action key)
+* hasNonModifierKey(parseHotkey('Mod+A')) // true
+* ```
+*/
+function hasNonModifierKey(hotkey, platform = detectPlatform()) {
+	const parsed = typeof hotkey === "string" ? parseHotkey(hotkey, platform) : hotkey;
+	return !isModifier(parsed.key) && parsed.key.length > 0;
+}
+/**
+* Converts a hotkey string to use 'Mod' format for portability.
+*
+* On macOS, converts 'Meta' to 'Mod'. On Windows/Linux, converts 'Control' to 'Mod'.
+* This enables cross-platform hotkey definitions that work consistently.
+*
+* @param hotkey - The hotkey string to convert
+* @param platform - The target platform (defaults to auto-detection)
+* @returns The hotkey string with 'Mod' format applied
+*
+* @example
+* ```ts
+* convertToModFormat('Meta+S', 'mac') // 'Mod+S'
+* convertToModFormat('Control+S', 'windows') // 'Mod+S'
+* convertToModFormat('Control+Meta+S', 'mac') // 'Control+Meta+S' (both present, no conversion)
+* ```
+*/
+function convertToModFormat(hotkey, platform = detectPlatform()) {
+	const parsed = parseHotkey(hotkey, platform);
+	if (platform === "mac" && parsed.meta && !parsed.ctrl) return hotkey.split("+").map((part) => part === "Meta" ? "Mod" : part).join("+");
+	else if (platform !== "mac" && parsed.ctrl && !parsed.meta) return hotkey.split("+").map((part) => part === "Control" ? "Mod" : part).join("+");
+	return hotkey;
+}
+
+//#endregion
+export { convertToModFormat, hasNonModifierKey, isModifier, isModifierKey, keyboardEventToHotkey, normalizeHotkey, parseHotkey, parseKeyboardEvent, rawHotkeyToParsedHotkey };
+//# sourceMappingURL=parse.js.map

package/dist/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","names":[],"sources":["../src/parse.ts"],"sourcesContent":["import {\n  MODIFIER_ALIASES,\n  MODIFIER_ORDER,\n  detectPlatform,\n  normalizeKeyName,\n  resolveModifier,\n} from './constants'\nimport type {\n  CanonicalModifier,\n  Hotkey,\n  Key,\n  ParsedHotkey,\n  RawHotkey,\n} from './hotkey'\n\n/**\n * Parses a hotkey string into its component parts.\n *\n * @param hotkey - The hotkey string to parse (e.g., 'Mod+Shift+S')\n * @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)\n * @returns A ParsedHotkey object with the key and modifier flags\n *\n * @example\n * ```ts\n * parseHotkey('Mod+S') // On Mac: { key: 'S', ctrl: false, shift: false, alt: false, meta: true, modifiers: ['Meta'] }\n * parseHotkey('Mod+S') // On Windows: { key: 'S', ctrl: true, shift: false, alt: false, meta: false, modifiers: ['Control'] }\n * parseHotkey('Control+Shift+A') // { key: 'A', ctrl: true, shift: true, alt: false, meta: false, modifiers: ['Control', 'Shift'] }\n * ```\n */\nexport function parseHotkey(\n  hotkey: Hotkey | (string & {}),\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): ParsedHotkey {\n  const parts = hotkey.split('+')\n  const modifiers: Set<CanonicalModifier> = new Set()\n  let key = ''\n\n  for (let i = 0; i < parts.length; i++) {\n    const part = parts[i]!.trim()\n\n    if (i === parts.length - 1) {\n      // Last part is always the key\n      key = normalizeKeyName(part)\n    } else {\n      // All other parts are modifiers\n      const alias =\n        MODIFIER_ALIASES[part] ?? MODIFIER_ALIASES[part.toLowerCase()]\n\n      if (alias) {\n        const resolved = resolveModifier(alias, platform)\n        modifiers.add(resolved)\n      } else {\n        // Unknown modifier, treat as part of the key if it's the only part\n        // or ignore if there are more parts\n        if (parts.length === 1) {\n          key = normalizeKeyName(part)\n        }\n      }\n    }\n  }\n\n  // If no key was found (empty string), use the last part as-is\n  if (!key && parts.length > 0) {\n    key = normalizeKeyName(parts[parts.length - 1]!.trim())\n  }\n\n  return {\n    key,\n    ctrl: modifiers.has('Control'),\n    shift: modifiers.has('Shift'),\n    alt: modifiers.has('Alt'),\n    meta: modifiers.has('Meta'),\n    modifiers: MODIFIER_ORDER.filter((m) => modifiers.has(m)),\n  }\n}\n\n/**\n * Converts a RawHotkey object to a ParsedHotkey.\n * Optional modifier booleans default to false; modifiers array is derived from them.\n * When `mod` is true, it is resolved to Control or Meta based on platform.\n *\n * @param raw - The raw hotkey object\n * @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)\n * @returns A ParsedHotkey suitable for matching and formatting\n *\n * @example\n * ```ts\n * rawHotkeyToParsedHotkey({ key: 'Escape' })\n * // { key: 'Escape', ctrl: false, shift: false, alt: false, meta: false, modifiers: [] }\n *\n * rawHotkeyToParsedHotkey({ key: 'S', mod: true }, 'mac')\n * // { key: 'S', ctrl: false, shift: false, alt: false, meta: true, modifiers: ['Meta'] }\n *\n * rawHotkeyToParsedHotkey({ key: 'S', mod: true, shift: true }, 'windows')\n * // { key: 'S', ctrl: true, shift: true, alt: false, meta: false, modifiers: ['Control', 'Shift'] }\n * ```\n */\nexport function rawHotkeyToParsedHotkey(\n  raw: RawHotkey,\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): ParsedHotkey {\n  let ctrl = raw.ctrl ?? false\n  const shift = raw.shift ?? false\n  const alt = raw.alt ?? false\n  let meta = raw.meta ?? false\n\n  if (raw.mod) {\n    const resolved = resolveModifier('Mod', platform)\n    if (resolved === 'Control') {\n      ctrl = true\n    } else {\n      meta = true\n    }\n  }\n\n  const modifiers: Array<CanonicalModifier> = MODIFIER_ORDER.filter((m) => {\n    switch (m) {\n      case 'Control':\n        return ctrl\n      case 'Shift':\n        return shift\n      case 'Alt':\n        return alt\n      case 'Meta':\n        return meta\n      default:\n        return false\n    }\n  })\n  return {\n    key: raw.key,\n    ctrl,\n    shift,\n    alt,\n    meta,\n    modifiers,\n  }\n}\n\n/**\n * Normalizes a hotkey string to its canonical form.\n *\n * The canonical form uses:\n * - Full modifier names (Control, Alt, Shift, Meta)\n * - Modifiers in order: Control+Alt+Shift+Meta\n * - Uppercase letters for single-character keys\n * - Proper casing for special keys (Escape, not escape)\n *\n * @param hotkey - The hotkey string to normalize\n * @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)\n * @returns The normalized hotkey string\n *\n * @example\n * ```ts\n * normalizeHotkey('mod+shift+s') // On Mac: 'Shift+Meta+S'\n * normalizeHotkey('ctrl+a') // 'Control+A'\n * normalizeHotkey('esc') // 'Escape'\n * ```\n */\nexport function normalizeHotkey(\n  hotkey: Key | (string & {}),\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): string {\n  const parsed = parseHotkey(hotkey, platform)\n  const parts: Array<string> = []\n\n  // Add modifiers in canonical order\n  for (const modifier of MODIFIER_ORDER) {\n    if (parsed.modifiers.includes(modifier)) {\n      parts.push(modifier)\n    }\n  }\n\n  // Add the key\n  parts.push(parsed.key)\n\n  return parts.join('+')\n}\n\n/**\n * Checks if a string represents a modifier key.\n *\n * @param key - The string to check\n * @returns True if the string is a recognized modifier\n */\nexport function isModifier(key: string): boolean {\n  return key in MODIFIER_ALIASES || key.toLowerCase() in MODIFIER_ALIASES\n}\n\n/**\n * Parses a KeyboardEvent into a ParsedHotkey object.\n *\n * This function extracts the key and modifier state from a keyboard event\n * and converts it into the same format used by `parseHotkey()`.\n *\n * @param event - The KeyboardEvent to parse\n * @param platform - The target platform for resolving modifiers (defaults to auto-detection)\n * @returns A ParsedHotkey object representing the keyboard event\n *\n * @example\n * ```ts\n * document.addEventListener('keydown', (event) => {\n *   const parsed = parseKeyboardEvent(event)\n *   console.log(parsed) // { key: 'S', ctrl: true, shift: false, ... }\n * })\n * ```\n */\nexport function parseKeyboardEvent(event: KeyboardEvent): ParsedHotkey {\n  const normalizedKey = normalizeKeyName(event.key)\n\n  // Build modifiers array in canonical order\n  const modifiers: Array<CanonicalModifier> = []\n  if (event.ctrlKey) modifiers.push('Control')\n  if (event.altKey) modifiers.push('Alt')\n  if (event.shiftKey) modifiers.push('Shift')\n  if (event.metaKey) modifiers.push('Meta')\n\n  return {\n    key: normalizedKey,\n    ctrl: event.ctrlKey,\n    shift: event.shiftKey,\n    alt: event.altKey,\n    meta: event.metaKey,\n    modifiers,\n  }\n}\n\n/**\n * Converts a KeyboardEvent directly to a hotkey string.\n *\n * This is a convenience function that combines `parseKeyboardEvent()` and formatting.\n * The resulting hotkey string uses canonical modifier names (Control, Alt, Shift, Meta)\n * and is suitable for use with `useHotkey()` and other hotkey functions.\n *\n * @param event - The KeyboardEvent to convert\n * @param platform - The target platform (defaults to auto-detection)\n * @returns A hotkey string in canonical form (e.g., 'Control+Shift+S')\n *\n * @example\n * ```ts\n * document.addEventListener('keydown', (event) => {\n *   const hotkey = keyboardEventToHotkey(event)\n *   console.log(hotkey) // 'Control+Shift+S'\n *   useHotkey(hotkey, () => console.log('Shortcut triggered'))\n * })\n * ```\n */\nexport function keyboardEventToHotkey(event: KeyboardEvent): Hotkey {\n  const parsed = parseKeyboardEvent(event)\n\n  // Build hotkey string in canonical order (same as formatHotkey)\n  const parts: Array<string> = []\n  for (const modifier of MODIFIER_ORDER) {\n    if (parsed.modifiers.includes(modifier)) {\n      parts.push(modifier)\n    }\n  }\n  parts.push(parsed.key)\n\n  return parts.join('+') as Hotkey\n}\n\n/**\n * Checks if a KeyboardEvent represents a modifier-only key press.\n *\n * Modifier-only keys are keys like 'Control', 'Shift', 'Alt', 'Meta', etc.\n * that don't have an associated character or action key. This is useful\n * for filtering out modifier key presses when recording shortcuts.\n *\n * @param event - The KeyboardEvent to check\n * @returns True if the event represents a modifier-only key\n *\n * @example\n * ```ts\n * document.addEventListener('keydown', (event) => {\n *   if (isModifierKey(event)) {\n *     console.log('Modifier key pressed, waiting for action key...')\n *     return\n *   }\n *   // Process non-modifier key\n * })\n * ```\n */\nexport function isModifierKey(event: KeyboardEvent): boolean {\n  const key = event.key\n  return (\n    key === 'Control' ||\n    key === 'Shift' ||\n    key === 'Alt' ||\n    key === 'Meta' ||\n    key === 'Command' ||\n    key === 'OS' ||\n    key === 'Win'\n  )\n}\n\n/**\n * Checks if a hotkey or ParsedHotkey contains at least one non-modifier key.\n *\n * This is useful for validating that a recorded hotkey is complete and not\n * just a combination of modifiers without an action key.\n *\n * @param hotkey - The hotkey string or ParsedHotkey to check\n * @param platform - The target platform for parsing (defaults to auto-detection)\n * @returns True if the hotkey contains at least one non-modifier key\n *\n * @example\n * ```ts\n * hasNonModifierKey('Control+Shift+S') // true\n * hasNonModifierKey('Control+Shift') // false (no action key)\n * hasNonModifierKey(parseHotkey('Mod+A')) // true\n * ```\n */\nexport function hasNonModifierKey(\n  hotkey: Hotkey | ParsedHotkey | (string & {}),\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): boolean {\n  const parsed =\n    typeof hotkey === 'string' ? parseHotkey(hotkey, platform) : hotkey\n\n  // Check if the key part is actually a modifier\n  const keyIsModifier = isModifier(parsed.key)\n\n  // A valid hotkey must have a non-modifier key\n  return !keyIsModifier && parsed.key.length > 0\n}\n\n/**\n * Converts a hotkey string to use 'Mod' format for portability.\n *\n * On macOS, converts 'Meta' to 'Mod'. On Windows/Linux, converts 'Control' to 'Mod'.\n * This enables cross-platform hotkey definitions that work consistently.\n *\n * @param hotkey - The hotkey string to convert\n * @param platform - The target platform (defaults to auto-detection)\n * @returns The hotkey string with 'Mod' format applied\n *\n * @example\n * ```ts\n * convertToModFormat('Meta+S', 'mac') // 'Mod+S'\n * convertToModFormat('Control+S', 'windows') // 'Mod+S'\n * convertToModFormat('Control+Meta+S', 'mac') // 'Control+Meta+S' (both present, no conversion)\n * ```\n */\nexport function convertToModFormat(\n  hotkey: Hotkey | (string & {}),\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): Hotkey {\n  const parsed = parseHotkey(hotkey, platform)\n\n  // Only convert if we have exactly one primary modifier\n  if (platform === 'mac' && parsed.meta && !parsed.ctrl) {\n    // Convert Meta to Mod on Mac\n    const parts = hotkey.split('+')\n    return parts\n      .map((part) => (part === 'Meta' ? 'Mod' : part))\n      .join('+') as Hotkey\n  } else if (platform !== 'mac' && parsed.ctrl && !parsed.meta) {\n    // Convert Control to Mod on Windows/Linux\n    const parts = hotkey.split('+')\n    return parts\n      .map((part) => (part === 'Control' ? 'Mod' : part))\n      .join('+') as Hotkey\n  }\n\n  // No conversion needed\n  return hotkey as Hotkey\n}\n"],"mappings":"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"}

package/dist/recorder.cjs

@@ -0,0 +1,177 @@
+const require_constants = require('./constants.cjs');
+const require_parse = require('./parse.cjs');
+let _tanstack_store = require("@tanstack/store");
+
+//#region src/recorder.ts
+/**
+* Framework-agnostic class for recording keyboard shortcuts.
+*
+* This class handles 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.
+*
+* State Management:
+* - Uses TanStack Store for reactive state management
+* - State can be accessed via `recorder.store.state` when using the class directly
+* - When using framework adapters (React), use `useStore` hooks for reactive state
+*
+* @example
+* ```ts
+* const recorder = new HotkeyRecorder({
+*   onRecord: (hotkey) => {
+*     console.log('Recorded:', hotkey)
+*   },
+*   onCancel: () => {
+*     console.log('Recording cancelled')
+*   },
+* })
+*
+* // Start recording
+* recorder.start()
+*
+* // Access state directly
+* console.log(recorder.store.state.isRecording) // true
+*
+* // Subscribe to changes with TanStack Store
+* const unsubscribe = recorder.store.subscribe(() => {
+*   console.log('Recording:', recorder.store.state.isRecording)
+* })
+*
+* // Cleanup
+* recorder.destroy()
+* unsubscribe()
+* ```
+*/
+var HotkeyRecorder = class {
+	#keydownHandler = null;
+	#options;
+	#platform;
+	constructor(options) {
+		this.store = new _tanstack_store.Store({
+			isRecording: false,
+			recordedHotkey: null
+		});
+		this.#options = options;
+		this.#platform = require_constants.detectPlatform();
+	}
+	/**
+	* Updates the recorder options, including callbacks.
+	* This allows framework adapters to sync callback changes without recreating the recorder.
+	*/
+	setOptions(options) {
+		this.#options = {
+			...this.#options,
+			...options
+		};
+	}
+	/**
+	* Start recording a new hotkey.
+	*
+	* Sets up a keydown event listener that captures keyboard events
+	* and converts them to hotkey strings. Recording continues until
+	* a valid hotkey is recorded, Escape is pressed, or stop/cancel is called.
+	*/
+	start() {
+		if (this.#keydownHandler) return;
+		this.store.setState(() => ({
+			isRecording: true,
+			recordedHotkey: null
+		}));
+		const handler = (event) => {
+			if (!this.#keydownHandler) return;
+			event.preventDefault();
+			event.stopPropagation();
+			if (event.key === "Escape") {
+				this.cancel();
+				return;
+			}
+			if (event.key === "Backspace" || event.key === "Delete") {
+				if (!event.ctrlKey && !event.shiftKey && !event.altKey && !event.metaKey) {
+					this.#options.onClear?.();
+					this.#options.onRecord("");
+					this.stop();
+					return;
+				}
+			}
+			if (require_parse.isModifierKey(event)) return;
+			const finalHotkey = require_parse.convertToModFormat(require_parse.keyboardEventToHotkey(event), this.#platform);
+			if (require_parse.hasNonModifierKey(finalHotkey, this.#platform)) {
+				const handlerToRemove = this.#keydownHandler;
+				if (handlerToRemove) {
+					this.#removeListener(handlerToRemove);
+					this.#keydownHandler = null;
+				}
+				this.store.setState(() => ({
+					isRecording: false,
+					recordedHotkey: finalHotkey
+				}));
+				this.#options.onRecord(finalHotkey);
+			}
+		};
+		this.#keydownHandler = handler;
+		this.#addListener(handler);
+	}
+	/**
+	* Stop recording (same as cancel, but doesn't call onCancel).
+	*
+	* Removes the event listener and resets the recording state.
+	*/
+	stop() {
+		if (this.#keydownHandler) {
+			this.#removeListener(this.#keydownHandler);
+			this.#keydownHandler = null;
+		}
+		this.store.setState(() => ({
+			isRecording: false,
+			recordedHotkey: null
+		}));
+	}
+	/**
+	* Cancel recording without saving.
+	*
+	* Removes the event listener, resets the recording state, and calls
+	* the onCancel callback if provided.
+	*/
+	cancel() {
+		if (this.#keydownHandler) {
+			this.#removeListener(this.#keydownHandler);
+			this.#keydownHandler = null;
+		}
+		this.store.setState(() => ({
+			isRecording: false,
+			recordedHotkey: null
+		}));
+		this.#options.onCancel?.();
+	}
+	/**
+	* Adds the keydown event listener to the document.
+	*/
+	#addListener(handler) {
+		if (typeof document === "undefined") return;
+		document.addEventListener("keydown", handler, true);
+	}
+	/**
+	* Removes the keydown event listener from the document.
+	*/
+	#removeListener(handler) {
+		if (typeof document === "undefined") return;
+		document.removeEventListener("keydown", handler, true);
+	}
+	/**
+	* Clean up event listeners and reset state.
+	*
+	* Call this when you're done with the recorder to ensure
+	* all event listeners are properly removed.
+	*/
+	destroy() {
+		this.stop();
+		this.store.setState(() => ({
+			isRecording: false,
+			recordedHotkey: null
+		}));
+	}
+};
+
+//#endregion
+exports.HotkeyRecorder = HotkeyRecorder;
+//# sourceMappingURL=recorder.cjs.map

package/dist/recorder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recorder.cjs","names":["Store","#options","#platform","detectPlatform","#keydownHandler","isModifierKey","convertToModFormat","keyboardEventToHotkey","hasNonModifierKey","#removeListener","#addListener"],"sources":["../src/recorder.ts"],"sourcesContent":["import { Store } from '@tanstack/store'\nimport { detectPlatform } from './constants'\nimport {\n  convertToModFormat,\n  hasNonModifierKey,\n  isModifierKey,\n  keyboardEventToHotkey,\n} from './parse'\nimport type { Hotkey } from './hotkey'\n\n/**\n * State interface for the HotkeyRecorder.\n */\nexport interface HotkeyRecorderState {\n  /** Whether recording is currently active */\n  isRecording: boolean\n  /** The currently recorded hotkey (for live preview) */\n  recordedHotkey: Hotkey | null\n}\n\n/**\n * Options for configuring a HotkeyRecorder instance.\n */\nexport interface HotkeyRecorderOptions {\n  /** Callback when a hotkey is successfully recorded */\n  onRecord: (hotkey: Hotkey) => void\n  /** Optional callback when recording is cancelled (Escape pressed) */\n  onCancel?: () => void\n  /** Optional callback when shortcut is cleared (Backspace/Delete pressed) */\n  onClear?: () => void\n}\n\n/**\n * Framework-agnostic class for recording keyboard shortcuts.\n *\n * This class handles all the complexity of capturing keyboard events,\n * converting them to hotkey strings, and handling edge cases like\n * Escape to cancel or Backspace/Delete to clear.\n *\n * State Management:\n * - Uses TanStack Store for reactive state management\n * - State can be accessed via `recorder.store.state` when using the class directly\n * - When using framework adapters (React), use `useStore` hooks for reactive state\n *\n * @example\n * ```ts\n * const recorder = new HotkeyRecorder({\n *   onRecord: (hotkey) => {\n *     console.log('Recorded:', hotkey)\n *   },\n *   onCancel: () => {\n *     console.log('Recording cancelled')\n *   },\n * })\n *\n * // Start recording\n * recorder.start()\n *\n * // Access state directly\n * console.log(recorder.store.state.isRecording) // true\n *\n * // Subscribe to changes with TanStack Store\n * const unsubscribe = recorder.store.subscribe(() => {\n *   console.log('Recording:', recorder.store.state.isRecording)\n * })\n *\n * // Cleanup\n * recorder.destroy()\n * unsubscribe()\n * ```\n */\nexport class HotkeyRecorder {\n  /**\n   * The TanStack Store instance containing the recorder state.\n   * Use this to subscribe to state changes or access current state.\n   */\n  readonly store: Store<HotkeyRecorderState> = new Store<HotkeyRecorderState>({\n    isRecording: false,\n    recordedHotkey: null,\n  })\n\n  #keydownHandler: ((event: KeyboardEvent) => void) | null = null\n  #options: HotkeyRecorderOptions\n  #platform: 'mac' | 'windows' | 'linux'\n\n  constructor(options: HotkeyRecorderOptions) {\n    this.#options = options\n    this.#platform = detectPlatform()\n  }\n\n  /**\n   * Updates the recorder options, including callbacks.\n   * This allows framework adapters to sync callback changes without recreating the recorder.\n   */\n  setOptions(options: Partial<HotkeyRecorderOptions>): void {\n    this.#options = {\n      ...this.#options,\n      ...options,\n    }\n  }\n\n  /**\n   * Start recording a new hotkey.\n   *\n   * Sets up a keydown event listener that captures keyboard events\n   * and converts them to hotkey strings. Recording continues until\n   * a valid hotkey is recorded, Escape is pressed, or stop/cancel is called.\n   */\n  start(): void {\n    // Prevent starting recording if already recording\n    if (this.#keydownHandler) {\n      return\n    }\n\n    // Update store state\n    this.store.setState(() => ({\n      isRecording: true,\n      recordedHotkey: null,\n    }))\n\n    // Create keydown handler\n    const handler = (event: KeyboardEvent) => {\n      // Check if we're still recording (handler might be called after stop/cancel)\n      if (!this.#keydownHandler) {\n        return\n      }\n\n      event.preventDefault()\n      event.stopPropagation()\n\n      // Handle Escape to cancel\n      if (event.key === 'Escape') {\n        this.cancel()\n        return\n      }\n\n      // Handle Backspace/Delete to clear shortcut\n      if (event.key === 'Backspace' || event.key === 'Delete') {\n        if (\n          !event.ctrlKey &&\n          !event.shiftKey &&\n          !event.altKey &&\n          !event.metaKey\n        ) {\n          this.#options.onClear?.()\n          this.#options.onRecord('' as Hotkey)\n          this.stop()\n          return\n        }\n      }\n\n      // Ignore pure modifier keys (wait for a non-modifier key)\n      if (isModifierKey(event)) {\n        return\n      }\n\n      // Convert event to hotkey string using library function\n      const hotkey = keyboardEventToHotkey(event)\n\n      // Always convert to Mod format for portability\n      const finalHotkey = convertToModFormat(hotkey, this.#platform)\n\n      // Validate: must have at least one non-modifier key\n      if (hasNonModifierKey(finalHotkey, this.#platform)) {\n        // Remove listener FIRST to prevent any additional events\n        const handlerToRemove = this.#keydownHandler as\n          | ((event: KeyboardEvent) => void)\n          | null\n        if (handlerToRemove) {\n          this.#removeListener(handlerToRemove)\n          this.#keydownHandler = null\n        }\n\n        // Update store state immediately\n        this.store.setState(() => ({\n          isRecording: false,\n          recordedHotkey: finalHotkey,\n        }))\n\n        // Call callback AFTER listener is removed and state is set\n        this.#options.onRecord(finalHotkey)\n      }\n    }\n\n    this.#keydownHandler = handler\n    this.#addListener(handler)\n  }\n\n  /**\n   * Stop recording (same as cancel, but doesn't call onCancel).\n   *\n   * Removes the event listener and resets the recording state.\n   */\n  stop(): void {\n    // Remove event listener immediately\n    if (this.#keydownHandler) {\n      this.#removeListener(this.#keydownHandler)\n      this.#keydownHandler = null\n    }\n\n    // Update store state\n    this.store.setState(() => ({\n      isRecording: false,\n      recordedHotkey: null,\n    }))\n  }\n\n  /**\n   * Cancel recording without saving.\n   *\n   * Removes the event listener, resets the recording state, and calls\n   * the onCancel callback if provided.\n   */\n  cancel(): void {\n    // Remove event listener immediately\n    if (this.#keydownHandler) {\n      this.#removeListener(this.#keydownHandler)\n      this.#keydownHandler = null\n    }\n\n    // Update store state\n    this.store.setState(() => ({\n      isRecording: false,\n      recordedHotkey: null,\n    }))\n\n    // Call cancel callback\n    this.#options.onCancel?.()\n  }\n\n  /**\n   * Adds the keydown event listener to the document.\n   */\n  #addListener(handler: (event: KeyboardEvent) => void): void {\n    if (typeof document === 'undefined') {\n      return // SSR safety\n    }\n\n    document.addEventListener('keydown', handler, true)\n  }\n\n  /**\n   * Removes the keydown event listener from the document.\n   */\n  #removeListener(handler: (event: KeyboardEvent) => void): void {\n    if (typeof document === 'undefined') {\n      return\n    }\n\n    document.removeEventListener('keydown', handler, true)\n  }\n\n  /**\n   * Clean up event listeners and reset state.\n   *\n   * Call this when you're done with the recorder to ensure\n   * all event listeners are properly removed.\n   */\n  destroy(): void {\n    this.stop()\n    this.store.setState(() => ({\n      isRecording: false,\n      recordedHotkey: null,\n    }))\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,IAAa,iBAAb,MAA4B;CAU1B,kBAA2D;CAC3D;CACA;CAEA,YAAY,SAAgC;eATC,IAAIA,sBAA2B;GAC1E,aAAa;GACb,gBAAgB;GACjB,CAAC;AAOA,QAAKC,UAAW;AAChB,QAAKC,WAAYC,kCAAgB;;;;;;CAOnC,WAAW,SAA+C;AACxD,QAAKF,UAAW;GACd,GAAG,MAAKA;GACR,GAAG;GACJ;;;;;;;;;CAUH,QAAc;AAEZ,MAAI,MAAKG,eACP;AAIF,OAAK,MAAM,gBAAgB;GACzB,aAAa;GACb,gBAAgB;GACjB,EAAE;EAGH,MAAM,WAAW,UAAyB;AAExC,OAAI,CAAC,MAAKA,eACR;AAGF,SAAM,gBAAgB;AACtB,SAAM,iBAAiB;AAGvB,OAAI,MAAM,QAAQ,UAAU;AAC1B,SAAK,QAAQ;AACb;;AAIF,OAAI,MAAM,QAAQ,eAAe,MAAM,QAAQ,UAC7C;QACE,CAAC,MAAM,WACP,CAAC,MAAM,YACP,CAAC,MAAM,UACP,CAAC,MAAM,SACP;AACA,WAAKH,QAAS,WAAW;AACzB,WAAKA,QAAS,SAAS,GAAa;AACpC,UAAK,MAAM;AACX;;;AAKJ,OAAII,4BAAc,MAAM,CACtB;GAOF,MAAM,cAAcC,iCAHLC,oCAAsB,MAAM,EAGI,MAAKL,SAAU;AAG9D,OAAIM,gCAAkB,aAAa,MAAKN,SAAU,EAAE;IAElD,MAAM,kBAAkB,MAAKE;AAG7B,QAAI,iBAAiB;AACnB,WAAKK,eAAgB,gBAAgB;AACrC,WAAKL,iBAAkB;;AAIzB,SAAK,MAAM,gBAAgB;KACzB,aAAa;KACb,gBAAgB;KACjB,EAAE;AAGH,UAAKH,QAAS,SAAS,YAAY;;;AAIvC,QAAKG,iBAAkB;AACvB,QAAKM,YAAa,QAAQ;;;;;;;CAQ5B,OAAa;AAEX,MAAI,MAAKN,gBAAiB;AACxB,SAAKK,eAAgB,MAAKL,eAAgB;AAC1C,SAAKA,iBAAkB;;AAIzB,OAAK,MAAM,gBAAgB;GACzB,aAAa;GACb,gBAAgB;GACjB,EAAE;;;;;;;;CASL,SAAe;AAEb,MAAI,MAAKA,gBAAiB;AACxB,SAAKK,eAAgB,MAAKL,eAAgB;AAC1C,SAAKA,iBAAkB;;AAIzB,OAAK,MAAM,gBAAgB;GACzB,aAAa;GACb,gBAAgB;GACjB,EAAE;AAGH,QAAKH,QAAS,YAAY;;;;;CAM5B,aAAa,SAA+C;AAC1D,MAAI,OAAO,aAAa,YACtB;AAGF,WAAS,iBAAiB,WAAW,SAAS,KAAK;;;;;CAMrD,gBAAgB,SAA+C;AAC7D,MAAI,OAAO,aAAa,YACtB;AAGF,WAAS,oBAAoB,WAAW,SAAS,KAAK;;;;;;;;CASxD,UAAgB;AACd,OAAK,MAAM;AACX,OAAK,MAAM,gBAAgB;GACzB,aAAa;GACb,gBAAgB;GACjB,EAAE"}

package/dist/recorder.d.cts

@@ -0,0 +1,108 @@
+import { Hotkey } from "./hotkey.cjs";
+import { Store } from "@tanstack/store";
+
+//#region src/recorder.d.ts
+/**
+ * State interface for the HotkeyRecorder.
+ */
+interface HotkeyRecorderState {
+  /** Whether recording is currently active */
+  isRecording: boolean;
+  /** The currently recorded hotkey (for live preview) */
+  recordedHotkey: Hotkey | null;
+}
+/**
+ * Options for configuring a HotkeyRecorder instance.
+ */
+interface HotkeyRecorderOptions {
+  /** Callback when a hotkey is successfully recorded */
+  onRecord: (hotkey: Hotkey) => void;
+  /** Optional callback when recording is cancelled (Escape pressed) */
+  onCancel?: () => void;
+  /** Optional callback when shortcut is cleared (Backspace/Delete pressed) */
+  onClear?: () => void;
+}
+/**
+ * Framework-agnostic class for recording keyboard shortcuts.
+ *
+ * This class handles 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.
+ *
+ * State Management:
+ * - Uses TanStack Store for reactive state management
+ * - State can be accessed via `recorder.store.state` when using the class directly
+ * - When using framework adapters (React), use `useStore` hooks for reactive state
+ *
+ * @example
+ * ```ts
+ * const recorder = new HotkeyRecorder({
+ *   onRecord: (hotkey) => {
+ *     console.log('Recorded:', hotkey)
+ *   },
+ *   onCancel: () => {
+ *     console.log('Recording cancelled')
+ *   },
+ * })
+ *
+ * // Start recording
+ * recorder.start()
+ *
+ * // Access state directly
+ * console.log(recorder.store.state.isRecording) // true
+ *
+ * // Subscribe to changes with TanStack Store
+ * const unsubscribe = recorder.store.subscribe(() => {
+ *   console.log('Recording:', recorder.store.state.isRecording)
+ * })
+ *
+ * // Cleanup
+ * recorder.destroy()
+ * unsubscribe()
+ * ```
+ */
+declare class HotkeyRecorder {
+  #private;
+  /**
+   * The TanStack Store instance containing the recorder state.
+   * Use this to subscribe to state changes or access current state.
+   */
+  readonly store: Store<HotkeyRecorderState>;
+  constructor(options: HotkeyRecorderOptions);
+  /**
+   * Updates the recorder options, including callbacks.
+   * This allows framework adapters to sync callback changes without recreating the recorder.
+   */
+  setOptions(options: Partial<HotkeyRecorderOptions>): void;
+  /**
+   * Start recording a new hotkey.
+   *
+   * Sets up a keydown event listener that captures keyboard events
+   * and converts them to hotkey strings. Recording continues until
+   * a valid hotkey is recorded, Escape is pressed, or stop/cancel is called.
+   */
+  start(): void;
+  /**
+   * Stop recording (same as cancel, but doesn't call onCancel).
+   *
+   * Removes the event listener and resets the recording state.
+   */
+  stop(): void;
+  /**
+   * Cancel recording without saving.
+   *
+   * Removes the event listener, resets the recording state, and calls
+   * the onCancel callback if provided.
+   */
+  cancel(): void;
+  /**
+   * Clean up event listeners and reset state.
+   *
+   * Call this when you're done with the recorder to ensure
+   * all event listeners are properly removed.
+   */
+  destroy(): void;
+}
+//#endregion
+export { HotkeyRecorder, HotkeyRecorderOptions, HotkeyRecorderState };
+//# sourceMappingURL=recorder.d.cts.map