@tanstack/hotkeys 0.9.0 → 0.10.1

package/src/match.ts

@@ -1,210 +0,0 @@
-import { matchKeyboardEvent } from './_match'
-import { parseHotkey, parseRegisterableHotkey } from './parse'
-import { detectPlatform } from './platform'
-import { keysEqual } from './_keyboard-event'
-import type {
-  Hotkey,
-  HotkeyCallback,
-  HotkeyCallbackContext,
-  ParsedHotkey,
-  RegisterableHotkey,
-} from './hotkey.types'
-
-export interface KeyboardEventMatch {
-  matched: boolean
-  score: 0 | 1 | 2 | 3
-  source?: 'key' | 'code' | 'fallback'
-  identity?: { key: string; code: string }
-}
-
-/**
- * Checks if a KeyboardEvent matches a hotkey.
- *
- * Physical bindings such as `Mod+[KeyS]` match `event.code` exactly.
- * Logical bindings use `event.key`, 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()
- *   }
- * })
- * ```
- */
-export function matchesKeyboardEvent(
-  event: KeyboardEvent,
-  hotkey: Hotkey | ParsedHotkey,
-  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),
-): boolean {
-  return matchKeyboardEvent(event, hotkey, platform).matched
-}
-
-/**
- * Options for creating a hotkey handler.
- */
-export interface CreateHotkeyHandlerOptions {
-  /** Prevent the default browser action when the hotkey matches. Defaults to true */
-  preventDefault?: boolean
-  /** Stop event propagation when the hotkey matches. Defaults to true */
-  stopPropagation?: boolean
-  /** The target platform for resolving 'Mod' */
-  platform?: 'mac' | 'windows' | 'linux'
-}
-
-/**
- * Creates a keyboard event handler that calls the callback when the hotkey matches.
- *
- * @param hotkey - The hotkey string or ParsedHotkey to match
- * @param callback - The function to call when the hotkey matches
- * @param options - Options for matching and handling
- * @returns A function that can be used as an event handler
- *
- * @example
- * ```ts
- * const handler = createHotkeyHandler('Mod+S', (event, { hotkey, parsedHotkey }) => {
- *   console.log(`${hotkey} was pressed`)
- *   handleSave()
- * })
- *
- * document.addEventListener('keydown', handler)
- * ```
- */
-export function createHotkeyHandler(
-  hotkey: Hotkey | ParsedHotkey,
-  callback: HotkeyCallback,
-  options: CreateHotkeyHandlerOptions = {},
-): (event: KeyboardEvent) => void {
-  const { preventDefault = true, stopPropagation = true, platform } = options
-  const resolvedPlatform = platform ?? detectPlatform()
-
-  const hotkeyString: Hotkey =
-    typeof hotkey === 'string' ? hotkey : formatParsedHotkey(hotkey)
-  const parsed =
-    typeof hotkey === 'string' ? parseHotkey(hotkey, resolvedPlatform) : hotkey
-
-  const context: HotkeyCallbackContext = {
-    hotkey: hotkeyString,
-    parsedHotkey: parsed,
-  }
-
-  return (event: KeyboardEvent) => {
-    if (matchesKeyboardEvent(event, parsed, resolvedPlatform)) {
-      if (preventDefault) {
-        event.preventDefault()
-      }
-      if (stopPropagation) {
-        event.stopPropagation()
-      }
-      callback(event, context)
-    }
-  }
-}
-
-export type MultiHotkeyHandler = { [K in Hotkey]?: HotkeyCallback }
-
-/**
- * Creates a handler that matches multiple hotkeys.
- *
- * @param handlers - A map of hotkey strings to their handlers
- * @param options - Options for matching and handling
- * @returns A function that can be used as an event handler
- *
- * @example
- * ```ts
- * const handler = createMultiHotkeyHandler({
- *   'Mod+S': (event, { hotkey }) => handleSave(),
- *   'Mod+Z': (event, { hotkey }) => handleUndo(),
- *   'Mod+Shift+Z': (event, { hotkey }) => handleRedo(),
- * })
- *
- * document.addEventListener('keydown', handler)
- * ```
- */
-export function createMultiHotkeyHandler(
-  handlers: MultiHotkeyHandler,
-  options: CreateHotkeyHandlerOptions = {},
-): (event: KeyboardEvent) => void {
-  const { preventDefault = true, stopPropagation = true, platform } = options
-  const resolvedPlatform = platform ?? detectPlatform()
-
-  // Pre-parse all hotkeys for efficiency
-  const parsedHandlers = Object.entries(handlers)
-    .filter((entry): entry is [string, HotkeyCallback] => Boolean(entry[1]))
-    .map(([hotkey, handler]) => {
-      const parsed = parseHotkey(hotkey as Hotkey, resolvedPlatform)
-      const context: HotkeyCallbackContext = {
-        hotkey: hotkey as Hotkey,
-        parsedHotkey: parsed,
-      }
-      return { parsed, handler, context }
-    })
-
-  return (event: KeyboardEvent) => {
-    for (const { parsed, handler, context } of parsedHandlers) {
-      if (matchesKeyboardEvent(event, parsed, resolvedPlatform)) {
-        if (preventDefault) {
-          event.preventDefault()
-        }
-        if (stopPropagation) {
-          event.stopPropagation()
-        }
-        handler(event, context)
-        return // Only handle the first match
-      }
-    }
-  }
-}
-
-/**
- * Formats a ParsedHotkey back to a hotkey string.
- * Used internally to provide the hotkey string in callback context.
- */
-function formatParsedHotkey(parsed: ParsedHotkey): Hotkey {
-  const parts: Array<string> = []
-
-  if (parsed.ctrl) parts.push('Control')
-  if (parsed.alt) parts.push('Alt')
-  if (parsed.shift) parts.push('Shift')
-  if (parsed.meta) parts.push('Meta')
-  parts.push(parsed.code !== undefined ? `[${parsed.code}]` : parsed.key)
-
-  return parts.join('+') as Hotkey
-}
-
-/**
- * Compares normalized binding identity, including all four modifiers.
- * Aliases resolve on the supplied platform. A physical code and a logical key
- * remain distinct even when one keyboard event could match both.
- */
-export function areHotkeysEqual(
-  left: RegisterableHotkey,
-  right: RegisterableHotkey,
-  platform = detectPlatform(),
-): boolean {
-  const a = parseRegisterableHotkey(left, platform)
-  const b = parseRegisterableHotkey(right, platform)
-  return (
-    a.ctrl === b.ctrl &&
-    a.alt === b.alt &&
-    a.shift === b.shift &&
-    a.meta === b.meta &&
-    (a.code !== undefined || b.code !== undefined
-      ? a.code === b.code
-      : keysEqual(a.key, b.key))
-  )
-}

package/src/parse.ts

@@ -1,369 +0,0 @@
-import {
-  assertLogicalKey,
-  normalizeKeyboardEvent,
-  splitHotkeyParts,
-} from './_keyboard-event'
-import { MODIFIER_ALIASES, MODIFIER_ORDER, normalizeKeyName } from './constants'
-import { detectPlatform, resolveModifier } from './platform'
-import type { CanonicalModifier, Key } from './key.types'
-import type {
-  Hotkey,
-  ParsedHotkey,
-  RawHotkey,
-  RegisterableHotkey,
-} from './hotkey.types'
-
-/**
- * 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 with either logical key or physical code 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'] }
- * ```
- */
-export function parseHotkey(
-  hotkey: Hotkey | (string & {}),
-  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),
-): ParsedHotkey {
-  const parts = splitHotkeyParts(hotkey)
-  const modifiers: Set<CanonicalModifier> = new Set()
-  let key = ''
-
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i]!.trim()
-
-    if (i === parts.length - 1) {
-      // Last part is always the key
-      key = normalizeKeyName(part)
-    } else {
-      // All other parts are modifiers
-      const alias =
-        MODIFIER_ALIASES[part] ?? MODIFIER_ALIASES[part.toLowerCase()]
-
-      if (alias) {
-        const resolved = resolveModifier(alias, platform)
-        modifiers.add(resolved)
-      } else {
-        // Unknown modifier, treat as part of the key if it's the only part
-        // or ignore if there are more parts
-        if (parts.length === 1) {
-          key = normalizeKeyName(part)
-        }
-      }
-    }
-  }
-
-  // If no key was found (empty string), use the last part as-is
-  if (!key && parts.length > 0) {
-    key = normalizeKeyName(parts[parts.length - 1]!.trim())
-  }
-
-  const code = /^\[([A-Za-z][A-Za-z0-9]*)\]$/.exec(key)?.[1]
-  return {
-    ...(code !== undefined ? { code } : { 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'] }
- * ```
- */
-export function rawHotkeyToParsedHotkey(
-  raw: RawHotkey,
-  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),
-): ParsedHotkey {
-  if (raw.code === undefined) assertLogicalKey(raw.key)
-  let ctrl = raw.ctrl ?? false
-  const shift = raw.shift ?? false
-  const alt = raw.alt ?? false
-  let meta = raw.meta ?? false
-
-  if (raw.mod) {
-    const resolved = resolveModifier('Mod', platform)
-    if (resolved === 'Control') {
-      ctrl = true
-    } else {
-      meta = true
-    }
-  }
-
-  const modifiers: Array<CanonicalModifier> = 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 {
-    ...(raw.code !== undefined
-      ? { code: raw.code }
-      : { key: normalizeKeyName(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: ParsedHotkey,
-  platform: 'mac' | 'windows' | 'linux',
-): Hotkey {
-  if (parsed.code === undefined) assertLogicalKey(parsed.key)
-  const canUseMod =
-    platform === 'mac'
-      ? parsed.meta && !parsed.ctrl
-      : parsed.ctrl && !parsed.meta
-
-  const parts: Array<string> = []
-
-  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(
-    parsed.code !== undefined
-      ? `[${parsed.code}]`
-      : normalizeKeyName(parsed.key),
-  )
-  return parts.join('+') as Hotkey
-}
-
-/**
- * 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'
- * ```
- */
-export function normalizeHotkey(
-  hotkey: Key | (string & {}),
-  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),
-): Hotkey {
-  return normalizedHotkeyStringFromParsed(
-    parseHotkey(hotkey, platform),
-    platform,
-  )
-}
-
-/**
- * Same canonical string as {@link normalizeHotkey}, but from an already-parsed hotkey.
- */
-export function normalizeHotkeyFromParsed(
-  parsed: ParsedHotkey,
-  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),
-): Hotkey {
-  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(...))`.
- */
-export function normalizeRegisterableHotkey(
-  hotkey: RegisterableHotkey,
-  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),
-): Hotkey {
-  return typeof hotkey === 'string'
-    ? normalizeHotkey(hotkey, platform)
-    : normalizeHotkeyFromParsed(
-        rawHotkeyToParsedHotkey(hotkey, platform),
-        platform,
-      )
-}
-
-/**
- * Checks if a string is a recognized modifier token (including aliases).
- *
- * For a `KeyboardEvent`, use `isModifier(normalizeKeyName(event.key))` so DOM
- * spellings like `OS` / `Win` match the same alias table.
- *
- * @param key - Key name or alias (e.g. from a hotkey string or `event.key`)
- * @returns True if the string is a recognized modifier
- */
-export function isModifierKey(
-  key: Key | (string & {}),
-): key is keyof typeof MODIFIER_ALIASES {
-  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, ... }
- * })
- * ```
- */
-export function parseKeyboardEvent(
-  event: KeyboardEvent,
-  platform?: 'mac' | 'windows' | 'linux',
-): ParsedHotkey {
-  const normalized = normalizeKeyboardEvent(event, platform)
-  // AltGraph is a character-production modifier, not an ordinary Control+Alt
-  // shortcut. Record the produced glyph instead of a synthetic Ctrl+Alt chord.
-  const ctrl = normalized.altGraph ? false : normalized.ctrl
-  const alt = normalized.altGraph ? false : normalized.alt
-  // Shift is a real modifier even during AltGraph input; preserve it for replay.
-  const shift = normalized.shift
-
-  // Build modifiers array in canonical order
-  const modifiers: Array<CanonicalModifier> = []
-  if (ctrl) modifiers.push('Control')
-  if (alt) modifiers.push('Alt')
-  if (shift) modifiers.push('Shift')
-  if (normalized.meta) modifiers.push('Meta')
-
-  return {
-    key: normalized.key,
-    ctrl,
-    shift,
-    alt,
-    meta: normalized.meta,
-    modifiers,
-  }
-}
-
-/**
- * Normalizes a keyboard event to the same canonical hotkey string as {@link normalizeHotkey}.
- *
- * @param event - The keyboard event (typically `keydown`)
- * @param platform - Target platform for `Mod` eligibility
- */
-export function normalizeHotkeyFromEvent(
-  event: KeyboardEvent,
-  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),
-): Hotkey {
-  return normalizedHotkeyStringFromParsed(
-    parseKeyboardEvent(event, platform),
-    platform,
-  )
-}
-
-/**
- * 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
- * ```
- */
-export function hasNonModifierKey(
-  hotkey: Hotkey | ParsedHotkey | (string & {}),
-  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),
-): boolean {
-  const parsed =
-    typeof hotkey === 'string' ? parseHotkey(hotkey, platform) : hotkey
-
-  if (parsed.code !== undefined) {
-    // Physical modifier codes identify a side, but still are not action keys.
-    return (
-      parsed.code.length > 0 &&
-      !/^(Control|Shift|Alt|Meta)(Left|Right)$/.test(parsed.code)
-    )
-  }
-
-  // Check if the key part is actually a modifier
-  const keyIsModifier = isModifierKey(parsed.key)
-
-  // A valid hotkey must have a non-modifier key
-  return !keyIsModifier && parsed.key.length > 0
-}
-
-/**
- * Parses a string or raw binding, resolving Mod for the supplied platform.
- * Physical tokens such as `[KeyQ]` retain `code`; they never become logical Q.
- */
-export function parseRegisterableHotkey(
-  hotkey: RegisterableHotkey,
-  platform = detectPlatform(),
-): ParsedHotkey {
-  return typeof hotkey === 'string'
-    ? parseHotkey(hotkey, platform)
-    : rawHotkeyToParsedHotkey(hotkey, platform)
-}

package/src/platform.ts

@@ -1,66 +0,0 @@
-import type { CanonicalModifier } from './key.types'
-
-/**
- * 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
- * ```
- */
-export function detectPlatform(): 'mac' | 'windows' | 'linux' {
-  if (typeof navigator === 'undefined') {
-    return 'linux' // Default for SSR
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  const platform = navigator.platform?.toLowerCase() ?? ''
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  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'
-}
-
-/**
- * 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)
- * ```
- */
-export function resolveModifier(
-  modifier: CanonicalModifier | 'Mod',
-  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),
-): CanonicalModifier {
-  if (modifier === 'Mod') {
-    return platform === 'mac' ? 'Meta' : 'Control'
-  }
-  return modifier
-}

package/src/recorder-options.ts

@@ -1,34 +0,0 @@
-import type { Hotkey, ParsedHotkey } from './hotkey.types'
-import type { HotkeyConflict, HotkeyConflictOptions } from './conflicts'
-
-/** Event property used to record a binding. Physical codes are the default. */
-export type RecorderKeyMode = 'code' | 'key'
-
-export interface RecorderRejection {
-  reason: 'missing-code' | 'alt-graph' | 'invalid' | 'conflict' | 'validation'
-  message: string
-  hotkey?: Hotkey
-  sequence?: Array<Hotkey>
-  conflicts?: Array<HotkeyConflict>
-}
-
-export interface RecorderOptions {
-  /** Physical code recording is the default. Choose key to record logical characters. */
-  recordBy?: RecorderKeyMode
-  /** Platform used for Mod and AltGraph handling. Defaults to platform detection. */
-  platform?: 'mac' | 'windows' | 'linux'
-  /** Opt in to live-registry conflicts, including sequence prefixes. Default: false. */
-  detectConflicts?: boolean | HotkeyConflictOptions
-  /** Rejected candidates leave recording active. */
-  onReject?: (rejection: RecorderRejection) => void
-}
-
-export interface HotkeyRecorderValidationContext {
-  event: KeyboardEvent
-  parsedHotkey: ParsedHotkey
-}
-
-export interface HotkeySequenceRecorderValidationContext {
-  events: ReadonlyArray<KeyboardEvent>
-  parsedSequence: ReadonlyArray<ParsedHotkey>
-}