@remcostoeten/use-shortcut 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-01-22
+
+### Added
+
+- Chainable API for fluent shortcut definitions (`$.cmd.key("s").on(handler)`)
+- Cross-platform `mod` modifier (⌘ on Mac, Ctrl on Windows/Linux)
+- Context-aware exceptions with `.except()` for inputs, modals, and custom predicates
+- Full TypeScript intellisense at every step of the chain
+- Platform-aware display formatting (⌘S on Mac, Ctrl+S on Windows)
+- `useShortcut` hook for React with automatic cleanup
+- `createShortcut` for non-React usage
+- CLI for shadcn-style copy-paste installation
+- Shortcut result object with `enable()`, `disable()`, `trigger()`, and `unbind()`

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Remco Stoeten
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,210 @@
+# @remcostoeten/use-shortcut
+
+Chainable keyboard shortcuts for React with **perfect TypeScript intellisense**.
+
+```tsx
+const $ = useShortcut()
+
+$.cmd.shift.key("s").on(() => save())
+$.mod.key("k").on(() => search())
+$.key("/").except("typing").on(() => focusSearch())
+```
+
+## Features
+
+- **Chainable API** - Fluent, readable shortcut definitions
+- **Perfect TypeScript** - Intellisense at every step
+- **Cross-platform** - `mod` = ⌘ on Mac, Ctrl on Windows/Linux
+- **Context-aware** - Skip shortcuts in inputs with `.except()`
+- **Zero dependencies** - Only React as peer dependency
+- **Tiny** - ~3KB gzipped
+
+## Installation
+
+### npm/pnpm/bun
+
+```bash
+npm install @remcostoeten/use-shortcut
+pnpm add @remcostoeten/use-shortcut
+bun add @remcostoeten/use-shortcut
+```
+
+### Copy-paste (shadcn-style)
+
+```bash
+npx @remcostoeten/use-shortcut init
+# or
+bunx @remcostoeten/use-shortcut init
+```
+
+This copies the source files directly into your project at `hooks/use-shortcut/`.
+
+## Quick Start
+
+```tsx
+"use client"
+
+import { useShortcut } from "@remcostoeten/use-shortcut"
+
+export function App() {
+  const $ = useShortcut()
+
+  $.cmd.key("s").on(() => {
+    console.log("Save!")
+  })
+
+  $.mod.key("k").on(() => {
+    console.log("Search!")
+  })
+
+  return <div>Press ⌘+S or ⌘+K</div>
+}
+```
+
+## API
+
+### Modifiers
+
+Chain modifiers before calling `.key()`:
+
+```tsx
+$.ctrl.key("s")           // Ctrl+S
+$.shift.key("enter")      // Shift+Enter
+$.alt.key("n")            // Alt+N
+$.cmd.key("k")            // ⌘+K (Mac) or Ctrl+K (Windows)
+$.mod.key("k")            // Cross-platform: ⌘ on Mac, Ctrl on Windows/Linux
+
+// Multiple modifiers
+$.ctrl.shift.key("p")     // Ctrl+Shift+P
+$.cmd.shift.alt.key("a")  // ⌘+Shift+Alt+A
+```
+
+### Keys
+
+Supports all standard keys:
+
+```tsx
+// Letters
+$.mod.key("s")            // a-z
+
+// Numbers
+$.mod.key("1")            // 0-9
+
+// Function keys
+$.key("f1")               // f1-f12
+
+// Special keys
+$.key("escape")           // escape, enter, space, tab
+$.key("backspace")        // backspace, delete
+$.mod.key("up")           // up, down, left, right
+$.key("home")             // home, end, pageup, pagedown
+
+// Symbols
+$.mod.key("slash")        // slash, backslash, comma, period
+$.mod.key("/")            // Also works with actual symbol
+```
+
+### Exception Handling
+
+Skip shortcuts in certain contexts:
+
+```tsx
+// Built-in presets
+$.key("/").except("input").on(handler)     // Skip in <input>, <textarea>, <select>
+$.key("/").except("editable").on(handler)  // Skip in contenteditable
+$.key("/").except("typing").on(handler)    // Skip in any text input
+$.key("escape").except("modal").on(handler) // Skip when modal is open
+$.key("enter").except("disabled").on(handler) // Skip on disabled elements
+
+// Multiple presets
+$.key("/").except(["input", "modal"]).on(handler)
+
+// Custom predicate
+$.key("k").except((e) => {
+  return e.target.classList.contains("no-shortcuts")
+}).on(handler)
+```
+
+### Handler Options
+
+```tsx
+$.mod.key("s").on(save, {
+  preventDefault: true,    // Prevent browser default (default: true)
+  stopPropagation: false,  // Stop event bubbling (default: false)
+  delay: 100,              // Delay before firing (ms)
+  description: "Save doc", // For accessibility
+  disabled: false,         // Temporarily disable
+})
+```
+
+### Result Object
+
+`.on()` returns a result object:
+
+```tsx
+const save = $.mod.key("s").on(handleSave)
+
+save.display    // "⌘S" on Mac, "Ctrl+S" on Windows
+save.combo      // "cmd+s"
+save.isEnabled  // true/false
+save.enable()   // Enable the shortcut
+save.disable()  // Disable the shortcut
+save.unbind()   // Remove the shortcut
+save.trigger()  // Programmatically trigger
+```
+
+### Hook Options
+
+```tsx
+const $ = useShortcut({
+  debug: true,           // Log all shortcuts to console
+  delay: 0,              // Global delay for all shortcuts
+  ignoreInputs: true,    // Ignore in form elements (default: true)
+  disabled: false,       // Disable all shortcuts
+  eventType: "keydown",  // or "keyup"
+  target: window,        // Custom event target
+})
+```
+
+## Vanilla JS (Non-React)
+
+```tsx
+import { createShortcut } from "@remcostoeten/use-shortcut"
+
+const $ = createShortcut()
+
+const save = $.mod.key("s").on(() => {
+  console.log("Saved!")
+})
+
+// Clean up when done
+save.unbind()
+```
+
+## Display Formatting
+
+```tsx
+import { formatShortcut } from "@remcostoeten/use-shortcut"
+
+formatShortcut("cmd+s")        // "⌘S" on Mac, "Ctrl+S" on Windows
+formatShortcut("ctrl+shift+p") // "⌃⇧P" on Mac, "Ctrl+Shift+P" on Windows
+```
+
+## TypeScript
+
+Full type definitions with intellisense:
+
+```tsx
+import type {
+  ShortcutBuilder,
+  ShortcutResult,
+  ShortcutHandler,
+  HandlerOptions,
+  ActionKey,
+  ModifierName,
+} from "@remcostoeten/use-shortcut"
+```
+
+## License
+
+MIT © Remco Stoeten

package/dist/cli/index.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// cli/index.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  dim: "\x1B[2m"
+};
+function log(message, color = COLORS.reset) {
+  console.log(`${color}${message}${COLORS.reset}`);
+}
+function getSrcPath() {
+  return join(__dirname, "..", "src");
+}
+function getDestPath(targetDir) {
+  return join(process.cwd(), targetDir, "use-shortcut");
+}
+var FILES = [
+  "index.ts",
+  "hook.ts",
+  "builder.ts",
+  "types.ts",
+  "parser.ts",
+  "constants.ts",
+  "formatter.ts"
+];
+function init(targetDir = "hooks") {
+  const srcPath = getSrcPath();
+  const destPath = getDestPath(targetDir);
+  log("\n\u{1F3B9} use-shortcut CLI\n", COLORS.cyan);
+  if (existsSync(destPath)) {
+    log(`\u26A0\uFE0F  Directory already exists: ${destPath}`, COLORS.yellow);
+    log("   Use --force to overwrite\n");
+    return;
+  }
+  mkdirSync(destPath, { recursive: true });
+  for (const file of FILES) {
+    const srcFile = join(srcPath, file);
+    const destFile = join(destPath, file);
+    if (!existsSync(srcFile)) {
+      log(`\u26A0\uFE0F  Source file not found: ${file}`, COLORS.yellow);
+      continue;
+    }
+    let content = readFileSync(srcFile, "utf-8");
+    content = content.replace(/"use client"\n\n/, '"use client"\n\n');
+    writeFileSync(destFile, content);
+    log(`  \u2713 ${file}`, COLORS.green);
+  }
+  log("\n\u2728 Done! Files copied to:", COLORS.green);
+  log(`   ${destPath}
+`, COLORS.dim);
+  log("Usage:", COLORS.cyan);
+  log(`  import { useShortcut } from "@/${targetDir}/use-shortcut"
+`, COLORS.dim);
+  log("  const $ = useShortcut()", COLORS.dim);
+  log('  $.mod.key("k").on(() => console.log("Search!"))\n', COLORS.dim);
+}
+function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (command === "init") {
+    const targetIndex = args.indexOf("--target");
+    const targetDir = targetIndex !== -1 ? args[targetIndex + 1] : "hooks";
+    init(targetDir);
+  } else {
+    log("\n\u{1F3B9} use-shortcut CLI\n", COLORS.cyan);
+    log("Commands:", COLORS.yellow);
+    log("  init              Copy files to your project");
+    log("  init --target lib Copy to custom directory\n");
+  }
+}
+main();

package/dist/index.d.mts

@@ -0,0 +1,316 @@
+declare const Platform: {
+    readonly MAC: "mac";
+    readonly WINDOWS: "windows";
+    readonly LINUX: "linux";
+};
+type PlatformType = (typeof Platform)[keyof typeof Platform];
+declare function detectPlatform(): PlatformType;
+declare const ModifierKey: {
+    readonly META: "meta";
+    readonly CTRL: "ctrl";
+    readonly ALT: "alt";
+    readonly SHIFT: "shift";
+};
+type ModifierKeyType = (typeof ModifierKey)[keyof typeof ModifierKey];
+declare const ModifierAliases: Record<string, ModifierKeyType>;
+declare const SpecialKeyMap: Record<string, string>;
+declare const ModifierDisplaySymbols: Record<PlatformType, Record<ModifierKeyType, string>>;
+declare const ModifierDisplayOrder: Record<PlatformType, ModifierKeyType[]>;
+
+/** Lowercase letter keys a-z */
+type AlphaKey = "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";
+/** Number keys 0-9 */
+type NumericKey = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+/** Function keys F1-F12 */
+type FunctionKey = "f1" | "f2" | "f3" | "f4" | "f5" | "f6" | "f7" | "f8" | "f9" | "f10" | "f11" | "f12";
+/** Arrow and navigation keys */
+type NavigationKey = "up" | "down" | "left" | "right" | "arrowup" | "arrowdown" | "arrowleft" | "arrowright" | "home" | "end" | "pageup" | "pagedown";
+/** Special action keys like Enter, Escape, Tab */
+type SpecialKey = "enter" | "return" | "escape" | "esc" | "space" | "tab" | "backspace" | "delete" | "del" | "insert";
+/** Symbol and punctuation keys */
+type SymbolKey = "minus" | "plus" | "equal" | "equals" | "bracketleft" | "bracketright" | "backslash" | "slash" | "/" | "comma" | "period" | "semicolon" | "quote" | "backtick";
+/**
+ * All valid action keys that can be used with `.key()`
+ * @example $.mod.key("s") // "s" is an ActionKey
+ */
+type ActionKey = AlphaKey | NumericKey | FunctionKey | NavigationKey | SpecialKey | SymbolKey;
+/** Modifier key names used in the chainable API */
+type ModifierName = "ctrl" | "shift" | "alt" | "cmd" | "mod";
+/** Internal modifier state flags */
+type ModifierFlags = {
+    ctrl: boolean;
+    shift: boolean;
+    alt: boolean;
+    cmd: boolean;
+};
+/** Modifier key state from a keyboard event */
+type ModifierState = {
+    meta: boolean;
+    ctrl: boolean;
+    alt: boolean;
+    shift: boolean;
+};
+/** Result of parsing a shortcut string */
+type ParsedShortcut = {
+    modifiers: ModifierState;
+    key: string;
+    original: string;
+};
+type EmptyModifiers = {};
+/**
+ * Handler function called when a shortcut is triggered
+ * @param event - The keyboard event that triggered the shortcut
+ */
+type ShortcutHandler = (event: KeyboardEvent) => void;
+/**
+ * Custom predicate for excluding shortcuts in certain conditions
+ * @param event - The keyboard event to evaluate
+ * @returns `true` to skip the shortcut, `false` to allow it
+ */
+type ExceptPredicate = (event: KeyboardEvent) => boolean;
+/**
+ * Built-in exception presets for common scenarios
+ * - `"input"` - Skip when focused on input, textarea, or select
+ * - `"editable"` - Skip when focused on contentEditable elements
+ * - `"typing"` - Skip in any text input context (combines input + editable)
+ * - `"modal"` - Skip when a modal/dialog is open (checks [data-modal] or [role="dialog"])
+ * - `"disabled"` - Skip when focused element is disabled
+ */
+type ExceptPreset = "input" | "editable" | "typing" | "modal" | "disabled";
+/**
+ * Options for shortcut handler registration
+ */
+type HandlerOptions = {
+    /** Prevent the browser's default action (default: `true`) */
+    preventDefault?: boolean;
+    /** Stop event propagation */
+    stopPropagation?: boolean;
+    /** Delay handler execution in milliseconds */
+    delay?: number;
+    /** Description for documentation/debugging */
+    description?: string;
+    /** Disable this specific shortcut */
+    disabled?: boolean;
+    /** Limit shortcut to a specific DOM element */
+    scope?: HTMLElement | null;
+    /** Conditions to skip the shortcut */
+    except?: ExceptPreset | ExceptPreset[] | ExceptPredicate;
+};
+/**
+ * Result object returned when registering a shortcut
+ * Provides control over the shortcut and display information
+ */
+type ShortcutResult = {
+    /** Remove the keyboard listener */
+    unbind: () => void;
+    /** Platform-aware display string (e.g., "⌘S" on Mac, "Ctrl+S" on Windows) */
+    display: string;
+    /** Normalized combo string (e.g., "cmd+s") */
+    combo: string;
+    /** Programmatically trigger the shortcut handler */
+    trigger: () => void;
+    /** Whether the shortcut is currently enabled */
+    isEnabled: boolean;
+    /** Enable the shortcut (after being disabled) */
+    enable: () => void;
+    /** Temporarily disable the shortcut */
+    disable: () => void;
+    /** Subscribe to shortcut attempt events (useful for visual feedback) */
+    onAttempt?: (callback: (matched: boolean, event: KeyboardEvent) => void) => () => void;
+};
+/**
+ * Chainable modifier builder with type-safe exhaustion
+ * Each modifier can only be used once in a chain
+ */
+type ModifierChain<Used extends Partial<ModifierFlags>> = {
+    ctrl: Used["ctrl"] extends true ? never : ModifierChain<Used & {
+        ctrl: true;
+    }>;
+    shift: Used["shift"] extends true ? never : ModifierChain<Used & {
+        shift: true;
+    }>;
+    alt: Used["alt"] extends true ? never : ModifierChain<Used & {
+        alt: true;
+    }>;
+    cmd: Used["cmd"] extends true ? never : ModifierChain<Used & {
+        cmd: true;
+    }>;
+    mod: Used["cmd"] extends true ? never : ModifierChain<Used & {
+        cmd: true;
+    }>;
+    key: <K extends ActionKey>(key: K) => KeyChain<Used, K>;
+};
+/**
+ * Chain state after calling `.key()` - ready to attach a handler
+ */
+type KeyChain<Used extends Partial<ModifierFlags>, Key extends ActionKey> = {
+    /** Attach a handler to this shortcut */
+    on: (handler: ShortcutHandler, options?: HandlerOptions) => ShortcutResult;
+    /** Attach a handler with inline options */
+    handle: (options: HandlerOptions & {
+        handler: ShortcutHandler;
+    }) => ShortcutResult;
+    /** Add exception conditions before attaching handler */
+    except: (condition: ExceptPreset | ExceptPreset[] | ExceptPredicate) => KeyChainWithExcept<Used, Key>;
+};
+/**
+ * Chain state after calling `.except()` - ready to attach a handler
+ */
+type KeyChainWithExcept<Used extends Partial<ModifierFlags>, Key extends ActionKey> = {
+    on: (handler: ShortcutHandler, options?: Omit<HandlerOptions, "except">) => ShortcutResult;
+};
+/**
+ * The main shortcut builder interface returned by `useShortcut()`
+ * @example
+ * const $ = useShortcut()
+ * $.mod.key("s").on(() => save())
+ * $.ctrl.shift.key("p").on(() => openPalette())
+ * $.key("/").except("typing").on(() => focusSearch())
+ */
+type ShortcutBuilder = ModifierChain<EmptyModifiers> & {
+    ctrl: ModifierChain<{
+        ctrl: true;
+    }>;
+    shift: ModifierChain<{
+        shift: true;
+    }>;
+    alt: ModifierChain<{
+        alt: true;
+    }>;
+    cmd: ModifierChain<{
+        cmd: true;
+    }>;
+    mod: ModifierChain<{
+        cmd: true;
+    }>;
+    key: <K extends ActionKey>(key: K) => KeyChain<EmptyModifiers, K>;
+};
+/**
+ * Options for the `useShortcut` hook
+ */
+type UseShortcutOptions = {
+    /** Enable debug logging to console */
+    debug?: boolean;
+    /** Global delay for all handlers in milliseconds */
+    delay?: number;
+    /** Skip shortcuts when focused on input elements (default: `true`) */
+    ignoreInputs?: boolean;
+    /** Target element for keyboard listeners (default: `window`) */
+    target?: HTMLElement | Window | null;
+    /** Keyboard event type to listen for (default: `"keydown"`) */
+    eventType?: "keydown" | "keyup";
+    /** Globally disable all shortcuts from this hook */
+    disabled?: boolean;
+};
+
+/**
+ * Parse a shortcut string into its components
+ *
+ * @param shortcut - Shortcut string (e.g., "cmd+s", "ctrl+shift+p")
+ * @returns Parsed shortcut with modifiers, key, and original string
+ *
+ * @example
+ * ```ts
+ * const parsed = parseShortcut("cmd+s")
+ * // { modifiers: { meta: true, ... }, key: "s", original: "cmd+s" }
+ * ```
+ */
+declare function parseShortcut(shortcut: string): ParsedShortcut;
+/**
+ * Parse multiple shortcut strings
+ *
+ * @param shortcuts - Single shortcut or array of shortcuts
+ * @returns Array of parsed shortcuts
+ */
+declare function parseShortcuts(shortcuts: string | string[]): ParsedShortcut[];
+/**
+ * Extract modifier state from a keyboard event
+ *
+ * @param event - The keyboard event
+ * @returns Object with meta, ctrl, alt, shift boolean flags
+ */
+declare function getModifiersFromEvent(event: KeyboardEvent): ModifierState;
+/**
+ * Check if a keyboard event matches a parsed shortcut
+ *
+ * @param event - The keyboard event to check
+ * @param parsed - The parsed shortcut to match against
+ * @returns `true` if the event matches the shortcut
+ */
+declare function matchesShortcut(event: KeyboardEvent, parsed: ParsedShortcut): boolean;
+/**
+ * Check if a keyboard event matches any of the parsed shortcuts
+ *
+ * @param event - The keyboard event to check
+ * @param parsedShortcuts - Array of parsed shortcuts to match against
+ * @returns `true` if the event matches any shortcut
+ */
+declare function matchesAnyShortcut(event: KeyboardEvent, parsedShortcuts: ParsedShortcut[]): boolean;
+
+/**
+ * Format a shortcut string for display with platform-aware symbols
+ *
+ * @param shortcut - Shortcut string (e.g., "cmd+s")
+ * @param platform - Optional platform override (default: auto-detect)
+ * @returns Formatted display string (e.g., "⌘S" on Mac, "Ctrl+S" on Windows)
+ *
+ * @example
+ * ```ts
+ * formatShortcut("cmd+s") // "⌘S" on Mac, "Ctrl+S" on Windows
+ * formatShortcut("ctrl+shift+p", "mac") // "⌃⇧P"
+ * ```
+ */
+declare function formatShortcut(shortcut: string, platform?: PlatformType): string;
+/**
+ * Get the modifier key symbols for a platform
+ *
+ * @param platform - Optional platform override (default: auto-detect)
+ * @returns Object mapping modifier keys to display symbols
+ *
+ * @example
+ * ```ts
+ * getModifierSymbols("mac") // { meta: "⌘", ctrl: "⌃", alt: "⌥", shift: "⇧" }
+ * ```
+ */
+declare function getModifierSymbols(platform?: PlatformType): Record<ModifierKeyType, string>;
+
+/**
+ * React hook for registering chainable keyboard shortcuts
+ *
+ * @param options - Configuration options for the hook
+ * @returns A chainable shortcut builder (`$`)
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const $ = useShortcut()
+ *
+ *   $.mod.key("s").on(() => save())
+ *   $.ctrl.shift.key("p").on(() => openPalette())
+ *   $.key("/").except("typing").on(() => focusSearch())
+ *
+ *   return <div>Press ⌘S to save</div>
+ * }
+ * ```
+ */
+declare function useShortcut(options?: UseShortcutOptions): ShortcutBuilder;
+/**
+ * Create a shortcut builder for non-React usage
+ *
+ * Unlike `useShortcut`, this does not auto-cleanup - you must call `.unbind()` manually.
+ *
+ * @param options - Configuration options
+ * @returns A chainable shortcut builder
+ *
+ * @example
+ * ```ts
+ * const $ = createShortcut()
+ * const save = $.mod.key("s").on(() => save())
+ *
+ * // Cleanup when done
+ * save.unbind()
+ * ```
+ */
+declare function createShortcut(options?: UseShortcutOptions): ShortcutBuilder;
+
+export { type ActionKey, type AlphaKey, type ExceptPredicate, type ExceptPreset, type FunctionKey, type HandlerOptions, type KeyChain, ModifierAliases, type ModifierChain, ModifierDisplayOrder, ModifierDisplaySymbols, type ModifierFlags, ModifierKey, type ModifierName, type ModifierState, type NavigationKey, type NumericKey, type ParsedShortcut, Platform, type ShortcutBuilder, type ShortcutHandler, type ShortcutResult, type SpecialKey, SpecialKeyMap, type SymbolKey, type UseShortcutOptions, createShortcut, detectPlatform, formatShortcut, getModifierSymbols, getModifiersFromEvent, matchesAnyShortcut, matchesShortcut, parseShortcut, parseShortcuts, useShortcut };