@tanstack/vue-hotkeys 0.11.0 → 0.12.0

package/dist/useHotkeyRecorder.d.cts

@@ -1,61 +0,0 @@
-import { Hotkey, HotkeyRecorderOptions } from "@tanstack/hotkeys";
-import { MaybeRefOrGetter, Ref } from "vue";
-
-//#region src/useHotkeyRecorder.d.ts
-interface VueHotkeyRecorder {
-  /** Whether recording is currently active */
-  isRecording: Ref<boolean>;
-  /** The currently recorded hotkey (for live preview) */
-  recordedHotkey: Ref<Hotkey | null>;
-  /** Start recording a new hotkey */
-  startRecording: () => void;
-  /** Stop recording (same as cancel) */
-  stopRecording: () => void;
-  /** Cancel recording without saving */
-  cancelRecording: () => void;
-}
-/**
- * Vue composable for recording keyboard shortcuts.
- *
- * This composable provides a thin wrapper around the framework-agnostic `HotkeyRecorder`
- * class, managing 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.
- *
- * @param options - Configuration options for the recorder
- * @returns An object with recording state and control functions
- *
- * @example
- * ```vue
- * <script setup>
- * import { ref } from 'vue'
- * import { useHotkeyRecorder } from '@tanstack/vue-hotkeys'
- *
- * const shortcut = ref<Hotkey>('Mod+S')
- *
- * const recorder = useHotkeyRecorder({
- *   onRecord: (hotkey) => {
- *     shortcut.value = hotkey
- *   },
- *   onCancel: () => {
- *     console.log('Recording cancelled')
- *   },
- * })
- * </script>
- *
- * <template>
- *   <div>
- *     <button @click="recorder.startRecording()">
- *       {{ recorder.isRecording ? 'Recording...' : 'Edit Shortcut' }}
- *     </button>
- *     <div v-if="recorder.recordedHotkey">
- *       Recording: {{ recorder.recordedHotkey }}
- *     </div>
- *   </div>
- * </template>
- * ```
- */
-declare function useHotkeyRecorder(options: MaybeRefOrGetter<HotkeyRecorderOptions>): VueHotkeyRecorder;
-//#endregion
-export { VueHotkeyRecorder, useHotkeyRecorder };
-//# sourceMappingURL=useHotkeyRecorder.d.cts.map

package/dist/useHotkeyRecorder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeyRecorder.js","names":[],"sources":["../src/useHotkeyRecorder.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport { useSelector } from '@tanstack/vue-store'\nimport { HotkeyRecorder } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type { MaybeRefOrGetter, Ref } from 'vue'\nimport type { Hotkey, HotkeyRecorderOptions } from '@tanstack/hotkeys'\n\nexport interface VueHotkeyRecorder {\n  /** Whether recording is currently active */\n  isRecording: Ref<boolean>\n  /** The currently recorded hotkey (for live preview) */\n  recordedHotkey: Ref<Hotkey | null>\n  /** Start recording a new hotkey */\n  startRecording: () => void\n  /** Stop recording (same as cancel) */\n  stopRecording: () => void\n  /** Cancel recording without saving */\n  cancelRecording: () => void\n}\n\n/**\n * Vue composable for recording keyboard shortcuts.\n *\n * This composable provides a thin wrapper around the framework-agnostic `HotkeyRecorder`\n * class, managing all the complexity of capturing keyboard events, converting them\n * to hotkey strings, and handling edge cases like Escape to cancel or Backspace/Delete\n * to clear.\n *\n * @param options - Configuration options for the recorder\n * @returns An object with recording state and control functions\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkeyRecorder } from '@tanstack/vue-hotkeys'\n *\n * const shortcut = ref<Hotkey>('Mod+S')\n *\n * const recorder = useHotkeyRecorder({\n *   onRecord: (hotkey) => {\n *     shortcut.value = hotkey\n *   },\n *   onCancel: () => {\n *     console.log('Recording cancelled')\n *   },\n * })\n * </script>\n *\n * <template>\n *   <div>\n *     <button @click=\"recorder.startRecording()\">\n *       {{ recorder.isRecording ? 'Recording...' : 'Edit Shortcut' }}\n *     </button>\n *     <div v-if=\"recorder.recordedHotkey\">\n *       Recording: {{ recorder.recordedHotkey }}\n *     </div>\n *   </div>\n * </template>\n * ```\n */\nexport function useHotkeyRecorder(\n  options: MaybeRefOrGetter<HotkeyRecorderOptions>,\n): VueHotkeyRecorder {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const recorder = new HotkeyRecorder(\n    resolveRecorderOptions(options, defaultOptions),\n  )\n\n  // Subscribe to recorder state using useSelector\n  const isRecording = useSelector(recorder.store, (state) => state.isRecording)\n  const recordedHotkey = useSelector(\n    recorder.store,\n    (state) => state.recordedHotkey,\n  )\n\n  const stopWatcher = watch(\n    () => resolveRecorderOptions(options, defaultOptions),\n    (resolvedOptions) => {\n      recorder.setOptions(resolvedOptions)\n    },\n    { immediate: true },\n  )\n\n  // Cleanup on unmount\n  onUnmounted(() => {\n    stopWatcher()\n    recorder.destroy()\n  })\n\n  return {\n    isRecording: isRecording as Ref<boolean>,\n    recordedHotkey: recordedHotkey as Ref<Hotkey | null>,\n    startRecording: () => recorder.start(),\n    stopRecording: () => recorder.stop(),\n    cancelRecording: () => recorder.cancel(),\n  }\n}\n\nfunction resolveRecorderOptions(\n  options: MaybeRefOrGetter<HotkeyRecorderOptions>,\n  defaultOptions: ReturnType<typeof useDefaultHotkeysOptions>,\n): HotkeyRecorderOptions {\n  return {\n    ...defaultOptions.hotkeyRecorder,\n    ...resolveMaybeRefOrGetter(options),\n  } as HotkeyRecorderOptions\n}\n\nfunction resolveMaybeRefOrGetter<T>(value: MaybeRefOrGetter<T>): T {\n  return typeof value === 'function' ? (value as () => T)() : unref(value)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,SAAgB,kBACd,SACmB;CACnB,MAAM,iBAAiB,0BAA0B;CACjD,MAAM,WAAW,IAAI,eACnB,uBAAuB,SAAS,eAAe,CAChD;CAGD,MAAM,cAAc,YAAY,SAAS,QAAQ,UAAU,MAAM,YAAY;CAC7E,MAAM,iBAAiB,YACrB,SAAS,QACR,UAAU,MAAM,eAClB;CAED,MAAM,cAAc,YACZ,uBAAuB,SAAS,eAAe,GACpD,oBAAoB;AACnB,WAAS,WAAW,gBAAgB;IAEtC,EAAE,WAAW,MAAM,CACpB;AAGD,mBAAkB;AAChB,eAAa;AACb,WAAS,SAAS;GAClB;AAEF,QAAO;EACQ;EACG;EAChB,sBAAsB,SAAS,OAAO;EACtC,qBAAqB,SAAS,MAAM;EACpC,uBAAuB,SAAS,QAAQ;EACzC;;AAGH,SAAS,uBACP,SACA,gBACuB;AACvB,QAAO;EACL,GAAG,eAAe;EAClB,GAAG,wBAAwB,QAAQ;EACpC;;AAGH,SAAS,wBAA2B,OAA+B;AACjE,QAAO,OAAO,UAAU,aAAc,OAAmB,GAAG,MAAM,MAAM"}

package/dist/useHotkeyRegistrations.cjs

@@ -1,26 +0,0 @@
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _tanstack_vue_store = require("@tanstack/vue-store");
-
-//#region src/useHotkeyRegistrations.ts
-/**
-* Vue composable that reactively reads all hotkey and sequence registrations
-* from the singleton managers.
-*
-* This is a standalone composable that does NOT require the HotkeysProvider.
-* It subscribes to both HotkeyManager and SequenceManager stores and
-* triggers reactivity when registrations change.
-*
-* @returns Object with `hotkeys` and `sequences` refs
-*/
-function useHotkeyRegistrations() {
-	const hotkeyManager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	const sequenceManager = (0, _tanstack_hotkeys.getSequenceManager)();
-	return {
-		hotkeys: (0, _tanstack_vue_store.useSelector)(hotkeyManager.registrations, (state) => Array.from(state.values()).map(_tanstack_hotkeys.toHotkeyRegistrationView)),
-		sequences: (0, _tanstack_vue_store.useSelector)(sequenceManager.registrations, (state) => Array.from(state.values()))
-	};
-}
-
-//#endregion
-exports.useHotkeyRegistrations = useHotkeyRegistrations;
-//# sourceMappingURL=useHotkeyRegistrations.cjs.map

package/dist/useHotkeyRegistrations.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeyRegistrations.cjs","names":["toHotkeyRegistrationView"],"sources":["../src/useHotkeyRegistrations.ts"],"sourcesContent":["import { useSelector } from '@tanstack/vue-store'\nimport {\n  getHotkeyManager,\n  getSequenceManager,\n  toHotkeyRegistrationView,\n} from '@tanstack/hotkeys'\nimport type {\n  HotkeyRegistrationView,\n  SequenceRegistrationView,\n} from '@tanstack/hotkeys'\nimport type { Ref } from 'vue'\n\n/**\n * Return type for useHotkeyRegistrations.\n */\nexport interface HotkeyRegistrationsResult {\n  /** All registered hotkeys (public view, no callbacks) */\n  hotkeys: Ref<Array<HotkeyRegistrationView>>\n  /** All registered sequences */\n  sequences: Ref<Array<SequenceRegistrationView>>\n}\n\n/**\n * Vue composable that reactively reads all hotkey and sequence registrations\n * from the singleton managers.\n *\n * This is a standalone composable that does NOT require the HotkeysProvider.\n * It subscribes to both HotkeyManager and SequenceManager stores and\n * triggers reactivity when registrations change.\n *\n * @returns Object with `hotkeys` and `sequences` refs\n */\nexport function useHotkeyRegistrations(): HotkeyRegistrationsResult {\n  const hotkeyManager = getHotkeyManager()\n  const sequenceManager = getSequenceManager()\n\n  const hotkeys = useSelector(hotkeyManager.registrations, (state) =>\n    Array.from(state.values()).map(toHotkeyRegistrationView),\n  )\n\n  const sequences = useSelector(sequenceManager.registrations, (state) =>\n    Array.from(state.values()),\n  )\n\n  return { hotkeys, sequences }\n}\n"],"mappings":";;;;;;;;;;;;;;AAgCA,SAAgB,yBAAoD;CAClE,MAAM,yDAAkC;CACxC,MAAM,6DAAsC;AAU5C,QAAO;EAAE,8CARmB,cAAc,gBAAgB,UACxD,MAAM,KAAK,MAAM,QAAQ,CAAC,CAAC,IAAIA,2CAAyB,CACzD;EAMiB,gDAJY,gBAAgB,gBAAgB,UAC5D,MAAM,KAAK,MAAM,QAAQ,CAAC,CAC3B;EAE4B"}

package/dist/useHotkeyRegistrations.d.cts

@@ -1,27 +0,0 @@
-import { HotkeyRegistrationView, SequenceRegistrationView } from "@tanstack/hotkeys";
-import { Ref } from "vue";
-
-//#region src/useHotkeyRegistrations.d.ts
-/**
- * Return type for useHotkeyRegistrations.
- */
-interface HotkeyRegistrationsResult {
-  /** All registered hotkeys (public view, no callbacks) */
-  hotkeys: Ref<Array<HotkeyRegistrationView>>;
-  /** All registered sequences */
-  sequences: Ref<Array<SequenceRegistrationView>>;
-}
-/**
- * Vue composable that reactively reads all hotkey and sequence registrations
- * from the singleton managers.
- *
- * This is a standalone composable that does NOT require the HotkeysProvider.
- * It subscribes to both HotkeyManager and SequenceManager stores and
- * triggers reactivity when registrations change.
- *
- * @returns Object with `hotkeys` and `sequences` refs
- */
-declare function useHotkeyRegistrations(): HotkeyRegistrationsResult;
-//#endregion
-export { HotkeyRegistrationsResult, useHotkeyRegistrations };
-//# sourceMappingURL=useHotkeyRegistrations.d.cts.map

package/dist/useHotkeyRegistrations.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeyRegistrations.js","names":[],"sources":["../src/useHotkeyRegistrations.ts"],"sourcesContent":["import { useSelector } from '@tanstack/vue-store'\nimport {\n  getHotkeyManager,\n  getSequenceManager,\n  toHotkeyRegistrationView,\n} from '@tanstack/hotkeys'\nimport type {\n  HotkeyRegistrationView,\n  SequenceRegistrationView,\n} from '@tanstack/hotkeys'\nimport type { Ref } from 'vue'\n\n/**\n * Return type for useHotkeyRegistrations.\n */\nexport interface HotkeyRegistrationsResult {\n  /** All registered hotkeys (public view, no callbacks) */\n  hotkeys: Ref<Array<HotkeyRegistrationView>>\n  /** All registered sequences */\n  sequences: Ref<Array<SequenceRegistrationView>>\n}\n\n/**\n * Vue composable that reactively reads all hotkey and sequence registrations\n * from the singleton managers.\n *\n * This is a standalone composable that does NOT require the HotkeysProvider.\n * It subscribes to both HotkeyManager and SequenceManager stores and\n * triggers reactivity when registrations change.\n *\n * @returns Object with `hotkeys` and `sequences` refs\n */\nexport function useHotkeyRegistrations(): HotkeyRegistrationsResult {\n  const hotkeyManager = getHotkeyManager()\n  const sequenceManager = getSequenceManager()\n\n  const hotkeys = useSelector(hotkeyManager.registrations, (state) =>\n    Array.from(state.values()).map(toHotkeyRegistrationView),\n  )\n\n  const sequences = useSelector(sequenceManager.registrations, (state) =>\n    Array.from(state.values()),\n  )\n\n  return { hotkeys, sequences }\n}\n"],"mappings":";;;;;;;;;;;;;;AAgCA,SAAgB,yBAAoD;CAClE,MAAM,gBAAgB,kBAAkB;CACxC,MAAM,kBAAkB,oBAAoB;AAU5C,QAAO;EAAE,SARO,YAAY,cAAc,gBAAgB,UACxD,MAAM,KAAK,MAAM,QAAQ,CAAC,CAAC,IAAI,yBAAyB,CACzD;EAMiB,WAJA,YAAY,gBAAgB,gBAAgB,UAC5D,MAAM,KAAK,MAAM,QAAQ,CAAC,CAC3B;EAE4B"}

package/dist/useHotkeySequence.cjs

@@ -1,122 +0,0 @@
-const require_HotkeysProviderContext = require('./HotkeysProviderContext.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let vue = require("vue");
-
-//#region src/useHotkeySequence.ts
-/**
-* Vue composable for registering a keyboard shortcut sequence (Vim-style).
-*
-* This composable allows you to register multi-key sequences like 'g g' or 'd d'
-* that trigger when the full sequence is pressed within a timeout.
-*
-* Each step may include modifiers. You can chain the same modifier across
-* steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
-* Control, Alt, or Meta pressed alone) are ignored while matching—they do not
-* advance the sequence or reset progress.
-*
-* @param sequence - Array of hotkey strings that form the sequence
-* @param callback - Function to call when the sequence is completed
-* @param options - Options for the sequence behavior
-*
-* @example
-* ```vue
-* <script setup>
-* import { useHotkeySequence } from '@tanstack/vue-hotkeys'
-*
-* // 'g g' to go to top
-* useHotkeySequence(['G', 'G'], () => {
-*   scrollToTop()
-* })
-*
-* // 'd d' to delete line
-* useHotkeySequence(['D', 'D'], () => {
-*   deleteLine()
-* })
-*
-* // 'd i w' to delete inner word
-* useHotkeySequence(['D', 'I', 'W'], () => {
-*   deleteInnerWord()
-* }, { timeout: 500 })
-*
-* // Same modifier on consecutive steps (bare Shift between chords is ignored)
-* useHotkeySequence(['Shift+R', 'Shift+T'], () => {
-*   nextAction()
-* })
-* <\/script>
-*
-* <template>
-*   <div>...</div>
-* </template>
-* ```
-*/
-function useHotkeySequence(sequence, callback, options = {}) {
-	const defaultOptions = require_HotkeysProviderContext.useDefaultHotkeysOptions();
-	const manager = (0, _tanstack_hotkeys.getSequenceManager)();
-	let registration = null;
-	let lastSequenceKey = null;
-	let lastTarget = null;
-	const stopWatcher = (0, vue.watch)(() => {
-		const resolvedSequence = resolveMaybeRefOrGetter(sequence);
-		const resolvedOptions = resolveMaybeRefOrGetter(options);
-		const mergedOptions = {
-			...defaultOptions.hotkeySequence,
-			...resolvedOptions
-		};
-		return {
-			resolvedSequence,
-			mergedOptions,
-			resolvedEnabled: mergedOptions.enabled === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.enabled),
-			resolvedTarget: mergedOptions.target === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.target)
-		};
-	}, ({ resolvedSequence, mergedOptions, resolvedEnabled, resolvedTarget }) => {
-		const finalTarget = resolvedTarget === void 0 ? typeof document !== "undefined" ? document : null : resolvedTarget;
-		if (resolvedSequence.length === 0 || !finalTarget) {
-			if (registration?.isActive) {
-				registration.unregister();
-				registration = null;
-			}
-			lastSequenceKey = null;
-			lastTarget = null;
-			return;
-		}
-		const sequenceKey = (0, _tanstack_hotkeys.formatHotkeySequence)(resolvedSequence);
-		const { target: _target, enabled: _enabled, ...restOptions } = mergedOptions;
-		const optionsWithoutTarget = {
-			...restOptions,
-			...resolvedEnabled === void 0 ? {} : { enabled: resolvedEnabled }
-		};
-		if (registration?.isActive && lastSequenceKey === sequenceKey && lastTarget === finalTarget) {
-			registration.callback = callback;
-			registration.setOptions(optionsWithoutTarget);
-			return;
-		}
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
-		}
-		registration = manager.register(resolvedSequence, callback, {
-			...optionsWithoutTarget,
-			target: finalTarget
-		});
-		if (registration.isActive) {
-			registration.callback = callback;
-			registration.setOptions(optionsWithoutTarget);
-		}
-		lastSequenceKey = sequenceKey;
-		lastTarget = finalTarget;
-	}, { immediate: true });
-	(0, vue.onUnmounted)(() => {
-		stopWatcher();
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
-		}
-	});
-}
-function resolveMaybeRefOrGetter(value) {
-	return typeof value === "function" ? value() : (0, vue.unref)(value);
-}
-
-//#endregion
-exports.useHotkeySequence = useHotkeySequence;
-//# sourceMappingURL=useHotkeySequence.cjs.map

package/dist/useHotkeySequence.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeySequence.cjs","names":["useDefaultHotkeysOptions"],"sources":["../src/useHotkeySequence.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type { MaybeRefOrGetter } from 'vue'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\nexport interface UseHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'enabled' | 'target'\n> {\n  /**\n   * Whether the sequence is active.\n   * Can be a Ref, a getter function, or a boolean value.\n   * Defaults to true.\n   */\n  enabled?: MaybeRefOrGetter<boolean>\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a Ref, a getter function, direct DOM element, or null.\n   * Defaults to document.\n   */\n  target?: MaybeRefOrGetter<HTMLElement | Document | Window | null>\n}\n\n/**\n * Vue composable for registering a keyboard shortcut sequence (Vim-style).\n *\n * This composable allows you to register multi-key sequences like 'g g' or 'd d'\n * that trigger when the full sequence is pressed within a timeout.\n *\n * Each step may include modifiers. You can chain the same modifier across\n * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,\n * Control, Alt, or Meta pressed alone) are ignored while matching—they do not\n * advance the sequence or reset progress.\n *\n * @param sequence - Array of hotkey strings that form the sequence\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior\n *\n * @example\n * ```vue\n * <script setup>\n * import { useHotkeySequence } from '@tanstack/vue-hotkeys'\n *\n * // 'g g' to go to top\n * useHotkeySequence(['G', 'G'], () => {\n *   scrollToTop()\n * })\n *\n * // 'd d' to delete line\n * useHotkeySequence(['D', 'D'], () => {\n *   deleteLine()\n * })\n *\n * // 'd i w' to delete inner word\n * useHotkeySequence(['D', 'I', 'W'], () => {\n *   deleteInnerWord()\n * }, { timeout: 500 })\n *\n * // Same modifier on consecutive steps (bare Shift between chords is ignored)\n * useHotkeySequence(['Shift+R', 'Shift+T'], () => {\n *   nextAction()\n * })\n * </script>\n *\n * <template>\n *   <div>...</div>\n * </template>\n * ```\n */\nexport function useHotkeySequence(\n  sequence: MaybeRefOrGetter<HotkeySequence>,\n  callback: HotkeyCallback,\n  options: MaybeRefOrGetter<UseHotkeySequenceOptions> = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n\n  let registration: SequenceRegistrationHandle | null = null\n  let lastSequenceKey: string | null = null\n  let lastTarget: HTMLElement | Document | Window | null = null\n\n  // Watch for changes to reactive dependencies\n  const stopWatcher = watch(\n    () => {\n      const resolvedSequence = resolveMaybeRefOrGetter(sequence)\n      const resolvedOptions = resolveMaybeRefOrGetter(options)\n      const mergedOptions = {\n        ...defaultOptions.hotkeySequence,\n        ...resolvedOptions,\n      } as UseHotkeySequenceOptions\n      const resolvedEnabled =\n        mergedOptions.enabled === undefined\n          ? undefined\n          : resolveMaybeRefOrGetter(mergedOptions.enabled)\n      const resolvedTarget =\n        mergedOptions.target === undefined\n          ? undefined\n          : resolveMaybeRefOrGetter(mergedOptions.target)\n\n      return {\n        resolvedSequence,\n        mergedOptions,\n        resolvedEnabled,\n        resolvedTarget,\n      }\n    },\n    ({ resolvedSequence, mergedOptions, resolvedEnabled, resolvedTarget }) => {\n      const finalTarget =\n        resolvedTarget === undefined\n          ? typeof document !== 'undefined'\n            ? document\n            : null\n          : resolvedTarget\n\n      if (resolvedSequence.length === 0 || !finalTarget) {\n        if (registration?.isActive) {\n          registration.unregister()\n          registration = null\n        }\n        lastSequenceKey = null\n        lastTarget = null\n        return\n      }\n\n      const sequenceKey = formatHotkeySequence(resolvedSequence)\n\n      // Extract options without target (target is handled separately)\n      const {\n        target: _target,\n        enabled: _enabled,\n        ...restOptions\n      } = mergedOptions\n      const optionsWithoutTarget = {\n        ...restOptions,\n        ...(resolvedEnabled === undefined ? {} : { enabled: resolvedEnabled }),\n      }\n\n      if (\n        registration?.isActive &&\n        lastSequenceKey === sequenceKey &&\n        lastTarget === finalTarget\n      ) {\n        registration.callback = callback\n        registration.setOptions(optionsWithoutTarget)\n        return\n      }\n\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n\n      registration = manager.register(resolvedSequence, callback, {\n        ...optionsWithoutTarget,\n        target: finalTarget,\n      })\n\n      if (registration.isActive) {\n        registration.callback = callback\n        registration.setOptions(optionsWithoutTarget)\n      }\n\n      lastSequenceKey = sequenceKey\n      lastTarget = finalTarget\n    },\n    { immediate: true },\n  )\n\n  // Cleanup on unmount\n  onUnmounted(() => {\n    stopWatcher()\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n  })\n}\n\nfunction resolveMaybeRefOrGetter<T>(value: MaybeRefOrGetter<T>): T {\n  return typeof value === 'function' ? (value as () => T)() : unref(value)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAgB,kBACd,UACA,UACA,UAAsD,EAAE,EAClD;CACN,MAAM,iBAAiBA,yDAA0B;CACjD,MAAM,qDAA8B;CAEpC,IAAI,eAAkD;CACtD,IAAI,kBAAiC;CACrC,IAAI,aAAqD;CAGzD,MAAM,mCACE;EACJ,MAAM,mBAAmB,wBAAwB,SAAS;EAC1D,MAAM,kBAAkB,wBAAwB,QAAQ;EACxD,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;AAUD,SAAO;GACL;GACA;GACA,iBAXA,cAAc,YAAY,SACtB,SACA,wBAAwB,cAAc,QAAQ;GAUlD,gBARA,cAAc,WAAW,SACrB,SACA,wBAAwB,cAAc,OAAO;GAOlD;KAEF,EAAE,kBAAkB,eAAe,iBAAiB,qBAAqB;EACxE,MAAM,cACJ,mBAAmB,SACf,OAAO,aAAa,cAClB,WACA,OACF;AAEN,MAAI,iBAAiB,WAAW,KAAK,CAAC,aAAa;AACjD,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,qBAAkB;AAClB,gBAAa;AACb;;EAGF,MAAM,0DAAmC,iBAAiB;EAG1D,MAAM,EACJ,QAAQ,SACR,SAAS,UACT,GAAG,gBACD;EACJ,MAAM,uBAAuB;GAC3B,GAAG;GACH,GAAI,oBAAoB,SAAY,EAAE,GAAG,EAAE,SAAS,iBAAiB;GACtE;AAED,MACE,cAAc,YACd,oBAAoB,eACpB,eAAe,aACf;AACA,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;AAC7C;;AAGF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAGjB,iBAAe,QAAQ,SAAS,kBAAkB,UAAU;GAC1D,GAAG;GACH,QAAQ;GACT,CAAC;AAEF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAG/C,oBAAkB;AAClB,eAAa;IAEf,EAAE,WAAW,MAAM,CACpB;AAGD,4BAAkB;AAChB,eAAa;AACb,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;GAEjB;;AAGJ,SAAS,wBAA2B,OAA+B;AACjE,QAAO,OAAO,UAAU,aAAc,OAAmB,kBAAS,MAAM"}

package/dist/useHotkeySequence.d.cts

@@ -1,68 +0,0 @@
-import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
-import { MaybeRefOrGetter } from "vue";
-
-//#region src/useHotkeySequence.d.ts
-interface UseHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled' | 'target'> {
-  /**
-   * Whether the sequence is active.
-   * Can be a Ref, a getter function, or a boolean value.
-   * Defaults to true.
-   */
-  enabled?: MaybeRefOrGetter<boolean>;
-  /**
-   * The DOM element to attach the event listener to.
-   * Can be a Ref, a getter function, direct DOM element, or null.
-   * Defaults to document.
-   */
-  target?: MaybeRefOrGetter<HTMLElement | Document | Window | null>;
-}
-/**
- * Vue composable for registering a keyboard shortcut sequence (Vim-style).
- *
- * This composable allows you to register multi-key sequences like 'g g' or 'd d'
- * that trigger when the full sequence is pressed within a timeout.
- *
- * Each step may include modifiers. You can chain the same modifier across
- * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
- * Control, Alt, or Meta pressed alone) are ignored while matching—they do not
- * advance the sequence or reset progress.
- *
- * @param sequence - Array of hotkey strings that form the sequence
- * @param callback - Function to call when the sequence is completed
- * @param options - Options for the sequence behavior
- *
- * @example
- * ```vue
- * <script setup>
- * import { useHotkeySequence } from '@tanstack/vue-hotkeys'
- *
- * // 'g g' to go to top
- * useHotkeySequence(['G', 'G'], () => {
- *   scrollToTop()
- * })
- *
- * // 'd d' to delete line
- * useHotkeySequence(['D', 'D'], () => {
- *   deleteLine()
- * })
- *
- * // 'd i w' to delete inner word
- * useHotkeySequence(['D', 'I', 'W'], () => {
- *   deleteInnerWord()
- * }, { timeout: 500 })
- *
- * // Same modifier on consecutive steps (bare Shift between chords is ignored)
- * useHotkeySequence(['Shift+R', 'Shift+T'], () => {
- *   nextAction()
- * })
- * </script>
- *
- * <template>
- *   <div>...</div>
- * </template>
- * ```
- */
-declare function useHotkeySequence(sequence: MaybeRefOrGetter<HotkeySequence>, callback: HotkeyCallback, options?: MaybeRefOrGetter<UseHotkeySequenceOptions>): void;
-//#endregion
-export { UseHotkeySequenceOptions, useHotkeySequence };
-//# sourceMappingURL=useHotkeySequence.d.cts.map

package/dist/useHotkeySequence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeySequence.js","names":[],"sources":["../src/useHotkeySequence.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type { MaybeRefOrGetter } from 'vue'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\nexport interface UseHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'enabled' | 'target'\n> {\n  /**\n   * Whether the sequence is active.\n   * Can be a Ref, a getter function, or a boolean value.\n   * Defaults to true.\n   */\n  enabled?: MaybeRefOrGetter<boolean>\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a Ref, a getter function, direct DOM element, or null.\n   * Defaults to document.\n   */\n  target?: MaybeRefOrGetter<HTMLElement | Document | Window | null>\n}\n\n/**\n * Vue composable for registering a keyboard shortcut sequence (Vim-style).\n *\n * This composable allows you to register multi-key sequences like 'g g' or 'd d'\n * that trigger when the full sequence is pressed within a timeout.\n *\n * Each step may include modifiers. You can chain the same modifier across\n * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,\n * Control, Alt, or Meta pressed alone) are ignored while matching—they do not\n * advance the sequence or reset progress.\n *\n * @param sequence - Array of hotkey strings that form the sequence\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior\n *\n * @example\n * ```vue\n * <script setup>\n * import { useHotkeySequence } from '@tanstack/vue-hotkeys'\n *\n * // 'g g' to go to top\n * useHotkeySequence(['G', 'G'], () => {\n *   scrollToTop()\n * })\n *\n * // 'd d' to delete line\n * useHotkeySequence(['D', 'D'], () => {\n *   deleteLine()\n * })\n *\n * // 'd i w' to delete inner word\n * useHotkeySequence(['D', 'I', 'W'], () => {\n *   deleteInnerWord()\n * }, { timeout: 500 })\n *\n * // Same modifier on consecutive steps (bare Shift between chords is ignored)\n * useHotkeySequence(['Shift+R', 'Shift+T'], () => {\n *   nextAction()\n * })\n * </script>\n *\n * <template>\n *   <div>...</div>\n * </template>\n * ```\n */\nexport function useHotkeySequence(\n  sequence: MaybeRefOrGetter<HotkeySequence>,\n  callback: HotkeyCallback,\n  options: MaybeRefOrGetter<UseHotkeySequenceOptions> = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n\n  let registration: SequenceRegistrationHandle | null = null\n  let lastSequenceKey: string | null = null\n  let lastTarget: HTMLElement | Document | Window | null = null\n\n  // Watch for changes to reactive dependencies\n  const stopWatcher = watch(\n    () => {\n      const resolvedSequence = resolveMaybeRefOrGetter(sequence)\n      const resolvedOptions = resolveMaybeRefOrGetter(options)\n      const mergedOptions = {\n        ...defaultOptions.hotkeySequence,\n        ...resolvedOptions,\n      } as UseHotkeySequenceOptions\n      const resolvedEnabled =\n        mergedOptions.enabled === undefined\n          ? undefined\n          : resolveMaybeRefOrGetter(mergedOptions.enabled)\n      const resolvedTarget =\n        mergedOptions.target === undefined\n          ? undefined\n          : resolveMaybeRefOrGetter(mergedOptions.target)\n\n      return {\n        resolvedSequence,\n        mergedOptions,\n        resolvedEnabled,\n        resolvedTarget,\n      }\n    },\n    ({ resolvedSequence, mergedOptions, resolvedEnabled, resolvedTarget }) => {\n      const finalTarget =\n        resolvedTarget === undefined\n          ? typeof document !== 'undefined'\n            ? document\n            : null\n          : resolvedTarget\n\n      if (resolvedSequence.length === 0 || !finalTarget) {\n        if (registration?.isActive) {\n          registration.unregister()\n          registration = null\n        }\n        lastSequenceKey = null\n        lastTarget = null\n        return\n      }\n\n      const sequenceKey = formatHotkeySequence(resolvedSequence)\n\n      // Extract options without target (target is handled separately)\n      const {\n        target: _target,\n        enabled: _enabled,\n        ...restOptions\n      } = mergedOptions\n      const optionsWithoutTarget = {\n        ...restOptions,\n        ...(resolvedEnabled === undefined ? {} : { enabled: resolvedEnabled }),\n      }\n\n      if (\n        registration?.isActive &&\n        lastSequenceKey === sequenceKey &&\n        lastTarget === finalTarget\n      ) {\n        registration.callback = callback\n        registration.setOptions(optionsWithoutTarget)\n        return\n      }\n\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n\n      registration = manager.register(resolvedSequence, callback, {\n        ...optionsWithoutTarget,\n        target: finalTarget,\n      })\n\n      if (registration.isActive) {\n        registration.callback = callback\n        registration.setOptions(optionsWithoutTarget)\n      }\n\n      lastSequenceKey = sequenceKey\n      lastTarget = finalTarget\n    },\n    { immediate: true },\n  )\n\n  // Cleanup on unmount\n  onUnmounted(() => {\n    stopWatcher()\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n  })\n}\n\nfunction resolveMaybeRefOrGetter<T>(value: MaybeRefOrGetter<T>): T {\n  return typeof value === 'function' ? (value as () => T)() : unref(value)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAgB,kBACd,UACA,UACA,UAAsD,EAAE,EAClD;CACN,MAAM,iBAAiB,0BAA0B;CACjD,MAAM,UAAU,oBAAoB;CAEpC,IAAI,eAAkD;CACtD,IAAI,kBAAiC;CACrC,IAAI,aAAqD;CAGzD,MAAM,cAAc,YACZ;EACJ,MAAM,mBAAmB,wBAAwB,SAAS;EAC1D,MAAM,kBAAkB,wBAAwB,QAAQ;EACxD,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;AAUD,SAAO;GACL;GACA;GACA,iBAXA,cAAc,YAAY,SACtB,SACA,wBAAwB,cAAc,QAAQ;GAUlD,gBARA,cAAc,WAAW,SACrB,SACA,wBAAwB,cAAc,OAAO;GAOlD;KAEF,EAAE,kBAAkB,eAAe,iBAAiB,qBAAqB;EACxE,MAAM,cACJ,mBAAmB,SACf,OAAO,aAAa,cAClB,WACA,OACF;AAEN,MAAI,iBAAiB,WAAW,KAAK,CAAC,aAAa;AACjD,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,qBAAkB;AAClB,gBAAa;AACb;;EAGF,MAAM,cAAc,qBAAqB,iBAAiB;EAG1D,MAAM,EACJ,QAAQ,SACR,SAAS,UACT,GAAG,gBACD;EACJ,MAAM,uBAAuB;GAC3B,GAAG;GACH,GAAI,oBAAoB,SAAY,EAAE,GAAG,EAAE,SAAS,iBAAiB;GACtE;AAED,MACE,cAAc,YACd,oBAAoB,eACpB,eAAe,aACf;AACA,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;AAC7C;;AAGF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAGjB,iBAAe,QAAQ,SAAS,kBAAkB,UAAU;GAC1D,GAAG;GACH,QAAQ;GACT,CAAC;AAEF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAG/C,oBAAkB;AAClB,eAAa;IAEf,EAAE,WAAW,MAAM,CACpB;AAGD,mBAAkB;AAChB,eAAa;AACb,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;GAEjB;;AAGJ,SAAS,wBAA2B,OAA+B;AACjE,QAAO,OAAO,UAAU,aAAc,OAAmB,GAAG,MAAM,MAAM"}

package/dist/useHotkeySequenceRecorder.cjs

@@ -1,45 +0,0 @@
-const require_HotkeysProviderContext = require('./HotkeysProviderContext.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let vue = require("vue");
-let _tanstack_vue_store = require("@tanstack/vue-store");
-
-//#region src/useHotkeySequenceRecorder.ts
-/**
-* Vue composable for recording multi-chord sequences (Vim-style shortcuts).
-*/
-function useHotkeySequenceRecorder(options) {
-	const defaultOptions = require_HotkeysProviderContext.useDefaultHotkeysOptions();
-	const recorder = new _tanstack_hotkeys.HotkeySequenceRecorder(resolveHotkeySequenceRecorderOptions(options, defaultOptions));
-	const isRecording = (0, _tanstack_vue_store.useSelector)(recorder.store, (state) => state.isRecording);
-	const steps = (0, _tanstack_vue_store.useSelector)(recorder.store, (state) => state.steps);
-	const recordedSequence = (0, _tanstack_vue_store.useSelector)(recorder.store, (state) => state.recordedSequence);
-	const stopWatcher = (0, vue.watch)(() => resolveHotkeySequenceRecorderOptions(options, defaultOptions), (resolvedOptions) => {
-		recorder.setOptions(resolvedOptions);
-	}, { immediate: true });
-	(0, vue.onUnmounted)(() => {
-		stopWatcher();
-		recorder.destroy();
-	});
-	return {
-		isRecording,
-		steps,
-		recordedSequence,
-		startRecording: () => recorder.start(),
-		stopRecording: () => recorder.stop(),
-		cancelRecording: () => recorder.cancel(),
-		commitRecording: () => recorder.commit()
-	};
-}
-function resolveHotkeySequenceRecorderOptions(options, defaultOptions) {
-	return {
-		...defaultOptions.hotkeySequenceRecorder,
-		...resolveMaybeRefOrGetter(options)
-	};
-}
-function resolveMaybeRefOrGetter(value) {
-	return typeof value === "function" ? value() : (0, vue.unref)(value);
-}
-
-//#endregion
-exports.useHotkeySequenceRecorder = useHotkeySequenceRecorder;
-//# sourceMappingURL=useHotkeySequenceRecorder.cjs.map

package/dist/useHotkeySequenceRecorder.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeySequenceRecorder.cjs","names":["useDefaultHotkeysOptions","HotkeySequenceRecorder"],"sources":["../src/useHotkeySequenceRecorder.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport { useSelector } from '@tanstack/vue-store'\nimport { HotkeySequenceRecorder } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type { MaybeRefOrGetter, Ref } from 'vue'\nimport type {\n  HotkeySequence,\n  HotkeySequenceRecorderOptions,\n} from '@tanstack/hotkeys'\n\nexport interface VueHotkeySequenceRecorder {\n  isRecording: Ref<boolean>\n  steps: Ref<HotkeySequence>\n  recordedSequence: Ref<HotkeySequence | null>\n  startRecording: () => void\n  stopRecording: () => void\n  cancelRecording: () => void\n  commitRecording: () => void\n}\n\n/**\n * Vue composable for recording multi-chord sequences (Vim-style shortcuts).\n */\nexport function useHotkeySequenceRecorder(\n  options: MaybeRefOrGetter<HotkeySequenceRecorderOptions>,\n): VueHotkeySequenceRecorder {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const recorder = new HotkeySequenceRecorder(\n    resolveHotkeySequenceRecorderOptions(options, defaultOptions),\n  )\n\n  const isRecording = useSelector(recorder.store, (state) => state.isRecording)\n  const steps = useSelector(recorder.store, (state) => state.steps)\n  const recordedSequence = useSelector(\n    recorder.store,\n    (state) => state.recordedSequence,\n  )\n\n  const stopWatcher = watch(\n    () => resolveHotkeySequenceRecorderOptions(options, defaultOptions),\n    (resolvedOptions) => {\n      recorder.setOptions(resolvedOptions)\n    },\n    { immediate: true },\n  )\n\n  onUnmounted(() => {\n    stopWatcher()\n    recorder.destroy()\n  })\n\n  return {\n    isRecording: isRecording as Ref<boolean>,\n    steps: steps as Ref<HotkeySequence>,\n    recordedSequence: recordedSequence as Ref<HotkeySequence | null>,\n    startRecording: () => recorder.start(),\n    stopRecording: () => recorder.stop(),\n    cancelRecording: () => recorder.cancel(),\n    commitRecording: () => recorder.commit(),\n  }\n}\n\nfunction resolveHotkeySequenceRecorderOptions(\n  options: MaybeRefOrGetter<HotkeySequenceRecorderOptions>,\n  defaultOptions: ReturnType<typeof useDefaultHotkeysOptions>,\n): HotkeySequenceRecorderOptions {\n  return {\n    ...defaultOptions.hotkeySequenceRecorder,\n    ...resolveMaybeRefOrGetter(options),\n  } as HotkeySequenceRecorderOptions\n}\n\nfunction resolveMaybeRefOrGetter<T>(value: MaybeRefOrGetter<T>): T {\n  return typeof value === 'function' ? (value as () => T)() : unref(value)\n}\n"],"mappings":";;;;;;;;;AAuBA,SAAgB,0BACd,SAC2B;CAC3B,MAAM,iBAAiBA,yDAA0B;CACjD,MAAM,WAAW,IAAIC,yCACnB,qCAAqC,SAAS,eAAe,CAC9D;CAED,MAAM,mDAA0B,SAAS,QAAQ,UAAU,MAAM,YAAY;CAC7E,MAAM,6CAAoB,SAAS,QAAQ,UAAU,MAAM,MAAM;CACjE,MAAM,wDACJ,SAAS,QACR,UAAU,MAAM,iBAClB;CAED,MAAM,mCACE,qCAAqC,SAAS,eAAe,GAClE,oBAAoB;AACnB,WAAS,WAAW,gBAAgB;IAEtC,EAAE,WAAW,MAAM,CACpB;AAED,4BAAkB;AAChB,eAAa;AACb,WAAS,SAAS;GAClB;AAEF,QAAO;EACQ;EACN;EACW;EAClB,sBAAsB,SAAS,OAAO;EACtC,qBAAqB,SAAS,MAAM;EACpC,uBAAuB,SAAS,QAAQ;EACxC,uBAAuB,SAAS,QAAQ;EACzC;;AAGH,SAAS,qCACP,SACA,gBAC+B;AAC/B,QAAO;EACL,GAAG,eAAe;EAClB,GAAG,wBAAwB,QAAQ;EACpC;;AAGH,SAAS,wBAA2B,OAA+B;AACjE,QAAO,OAAO,UAAU,aAAc,OAAmB,kBAAS,MAAM"}

package/dist/useHotkeySequenceRecorder.d.cts

@@ -1,20 +0,0 @@
-import { HotkeySequence, HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
-import { MaybeRefOrGetter, Ref } from "vue";
-
-//#region src/useHotkeySequenceRecorder.d.ts
-interface VueHotkeySequenceRecorder {
-  isRecording: Ref<boolean>;
-  steps: Ref<HotkeySequence>;
-  recordedSequence: Ref<HotkeySequence | null>;
-  startRecording: () => void;
-  stopRecording: () => void;
-  cancelRecording: () => void;
-  commitRecording: () => void;
-}
-/**
- * Vue composable for recording multi-chord sequences (Vim-style shortcuts).
- */
-declare function useHotkeySequenceRecorder(options: MaybeRefOrGetter<HotkeySequenceRecorderOptions>): VueHotkeySequenceRecorder;
-//#endregion
-export { VueHotkeySequenceRecorder, useHotkeySequenceRecorder };
-//# sourceMappingURL=useHotkeySequenceRecorder.d.cts.map

package/dist/useHotkeySequenceRecorder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeySequenceRecorder.js","names":[],"sources":["../src/useHotkeySequenceRecorder.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport { useSelector } from '@tanstack/vue-store'\nimport { HotkeySequenceRecorder } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type { MaybeRefOrGetter, Ref } from 'vue'\nimport type {\n  HotkeySequence,\n  HotkeySequenceRecorderOptions,\n} from '@tanstack/hotkeys'\n\nexport interface VueHotkeySequenceRecorder {\n  isRecording: Ref<boolean>\n  steps: Ref<HotkeySequence>\n  recordedSequence: Ref<HotkeySequence | null>\n  startRecording: () => void\n  stopRecording: () => void\n  cancelRecording: () => void\n  commitRecording: () => void\n}\n\n/**\n * Vue composable for recording multi-chord sequences (Vim-style shortcuts).\n */\nexport function useHotkeySequenceRecorder(\n  options: MaybeRefOrGetter<HotkeySequenceRecorderOptions>,\n): VueHotkeySequenceRecorder {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const recorder = new HotkeySequenceRecorder(\n    resolveHotkeySequenceRecorderOptions(options, defaultOptions),\n  )\n\n  const isRecording = useSelector(recorder.store, (state) => state.isRecording)\n  const steps = useSelector(recorder.store, (state) => state.steps)\n  const recordedSequence = useSelector(\n    recorder.store,\n    (state) => state.recordedSequence,\n  )\n\n  const stopWatcher = watch(\n    () => resolveHotkeySequenceRecorderOptions(options, defaultOptions),\n    (resolvedOptions) => {\n      recorder.setOptions(resolvedOptions)\n    },\n    { immediate: true },\n  )\n\n  onUnmounted(() => {\n    stopWatcher()\n    recorder.destroy()\n  })\n\n  return {\n    isRecording: isRecording as Ref<boolean>,\n    steps: steps as Ref<HotkeySequence>,\n    recordedSequence: recordedSequence as Ref<HotkeySequence | null>,\n    startRecording: () => recorder.start(),\n    stopRecording: () => recorder.stop(),\n    cancelRecording: () => recorder.cancel(),\n    commitRecording: () => recorder.commit(),\n  }\n}\n\nfunction resolveHotkeySequenceRecorderOptions(\n  options: MaybeRefOrGetter<HotkeySequenceRecorderOptions>,\n  defaultOptions: ReturnType<typeof useDefaultHotkeysOptions>,\n): HotkeySequenceRecorderOptions {\n  return {\n    ...defaultOptions.hotkeySequenceRecorder,\n    ...resolveMaybeRefOrGetter(options),\n  } as HotkeySequenceRecorderOptions\n}\n\nfunction resolveMaybeRefOrGetter<T>(value: MaybeRefOrGetter<T>): T {\n  return typeof value === 'function' ? (value as () => T)() : unref(value)\n}\n"],"mappings":";;;;;;;;;AAuBA,SAAgB,0BACd,SAC2B;CAC3B,MAAM,iBAAiB,0BAA0B;CACjD,MAAM,WAAW,IAAI,uBACnB,qCAAqC,SAAS,eAAe,CAC9D;CAED,MAAM,cAAc,YAAY,SAAS,QAAQ,UAAU,MAAM,YAAY;CAC7E,MAAM,QAAQ,YAAY,SAAS,QAAQ,UAAU,MAAM,MAAM;CACjE,MAAM,mBAAmB,YACvB,SAAS,QACR,UAAU,MAAM,iBAClB;CAED,MAAM,cAAc,YACZ,qCAAqC,SAAS,eAAe,GAClE,oBAAoB;AACnB,WAAS,WAAW,gBAAgB;IAEtC,EAAE,WAAW,MAAM,CACpB;AAED,mBAAkB;AAChB,eAAa;AACb,WAAS,SAAS;GAClB;AAEF,QAAO;EACQ;EACN;EACW;EAClB,sBAAsB,SAAS,OAAO;EACtC,qBAAqB,SAAS,MAAM;EACpC,uBAAuB,SAAS,QAAQ;EACxC,uBAAuB,SAAS,QAAQ;EACzC;;AAGH,SAAS,qCACP,SACA,gBAC+B;AAC/B,QAAO;EACL,GAAG,eAAe;EAClB,GAAG,wBAAwB,QAAQ;EACpC;;AAGH,SAAS,wBAA2B,OAA+B;AACjE,QAAO,OAAO,UAAU,aAAc,OAAmB,GAAG,MAAM,MAAM"}

package/dist/useHotkeySequences.cjs

@@ -1,140 +0,0 @@
-const require_HotkeysProviderContext = require('./HotkeysProviderContext.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let vue = require("vue");
-
-//#region src/useHotkeySequences.ts
-/**
-* Vue composable for registering multiple keyboard shortcut sequences at once (Vim-style).
-*
-* Uses the singleton SequenceManager. Accepts a dynamic array of definitions, or a getter/ref
-* that returns one, so you can register variable-length lists safely.
-*
-* Options are merged in this order:
-* HotkeysProvider defaults < commonOptions < per-definition options
-*
-* Definitions with an empty `sequence` are skipped (no registration).
-*
-* @param definitions - Array of sequence definitions, or a getter/ref
-* @param commonOptions - Shared options applied to all sequences (overridden by per-definition options)
-*
-* @example
-* ```vue
-* <script setup>
-* import { useHotkeySequences } from '@tanstack/vue-hotkeys'
-*
-* useHotkeySequences([
-*   { sequence: ['G', 'G'], callback: () => scrollToTop() },
-*   { sequence: ['D', 'D'], callback: () => deleteLine() },
-* ])
-* <\/script>
-* ```
-*
-* @example
-* ```vue
-* <script setup>
-* import { computed } from 'vue'
-* import { useHotkeySequences } from '@tanstack/vue-hotkeys'
-*
-* const items = computed(() => [...])
-* useHotkeySequences(
-*   () => items.value.map((item) => ({
-*     sequence: item.chords,
-*     callback: item.action,
-*     options: { enabled: item.enabled },
-*   })),
-*   { preventDefault: true },
-* )
-* <\/script>
-* ```
-*/
-function useHotkeySequences(definitions, commonOptions = {}) {
-	const defaultOptions = require_HotkeysProviderContext.useDefaultHotkeysOptions();
-	const manager = (0, _tanstack_hotkeys.getSequenceManager)();
-	const registrations = /* @__PURE__ */ new Map();
-	const stopWatcher = (0, vue.watch)(() => {
-		const resolvedDefinitions = resolveMaybeRefOrGetter(definitions);
-		const resolvedCommonOptions = resolveMaybeRefOrGetter(commonOptions);
-		return resolvedDefinitions.map((def, i) => {
-			const resolvedSequence = resolveMaybeRefOrGetter(def.sequence);
-			const resolvedDefOptions = def.options ? resolveMaybeRefOrGetter(def.options) : {};
-			const mergedOptions = {
-				...defaultOptions.hotkeySequence,
-				...resolvedCommonOptions,
-				...resolvedDefOptions
-			};
-			const sequenceString = (0, _tanstack_hotkeys.formatHotkeySequence)(resolvedSequence);
-			const resolvedEnabled = mergedOptions.enabled === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.enabled);
-			const resolvedTarget = mergedOptions.target === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.target);
-			return {
-				index: i,
-				resolvedSequence,
-				sequenceString,
-				callback: def.callback,
-				mergedOptions,
-				resolvedEnabled,
-				resolvedTarget
-			};
-		});
-	}, (resolved) => {
-		const nextKeys = /* @__PURE__ */ new Set();
-		const prepared = [];
-		for (const entry of resolved) {
-			if (entry.resolvedSequence.length === 0) continue;
-			const finalTarget = entry.resolvedTarget ?? (typeof document !== "undefined" ? document : null);
-			if (!finalTarget) continue;
-			const registrationKey = `${entry.index}:${entry.sequenceString}`;
-			nextKeys.add(registrationKey);
-			prepared.push({
-				registrationKey,
-				entry,
-				finalTarget
-			});
-		}
-		for (const [key, record] of [...registrations.entries()]) if (!nextKeys.has(key)) {
-			if (record.handle.isActive) record.handle.unregister();
-			registrations.delete(key);
-		}
-		for (const { registrationKey, entry, finalTarget } of prepared) {
-			const existing = registrations.get(registrationKey);
-			if (existing?.handle.isActive && existing.target === finalTarget) {
-				existing.handle.callback = entry.callback;
-				const { target: _target, enabled: _enabled, ...restOptions } = entry.mergedOptions;
-				const optionsWithoutTarget = {
-					...restOptions,
-					...entry.resolvedEnabled === void 0 ? {} : { enabled: entry.resolvedEnabled }
-				};
-				existing.handle.setOptions(optionsWithoutTarget);
-				continue;
-			}
-			if (existing) {
-				if (existing.handle.isActive) existing.handle.unregister();
-				registrations.delete(registrationKey);
-			}
-			const { target: _target, enabled: _enabled, ...restOptions } = entry.mergedOptions;
-			const optionsWithoutTarget = {
-				...restOptions,
-				...entry.resolvedEnabled === void 0 ? {} : { enabled: entry.resolvedEnabled }
-			};
-			const handle = manager.register(entry.resolvedSequence, entry.callback, {
-				...optionsWithoutTarget,
-				target: finalTarget
-			});
-			registrations.set(registrationKey, {
-				handle,
-				target: finalTarget
-			});
-		}
-	}, { immediate: true });
-	(0, vue.onUnmounted)(() => {
-		stopWatcher();
-		for (const { handle } of registrations.values()) if (handle.isActive) handle.unregister();
-		registrations.clear();
-	});
-}
-function resolveMaybeRefOrGetter(value) {
-	return typeof value === "function" ? value() : (0, vue.unref)(value);
-}
-
-//#endregion
-exports.useHotkeySequences = useHotkeySequences;
-//# sourceMappingURL=useHotkeySequences.cjs.map

package/dist/useHotkeySequences.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeySequences.cjs","names":["useDefaultHotkeysOptions"],"sources":["../src/useHotkeySequences.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type { UseHotkeySequenceOptions } from './useHotkeySequence'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\nimport type { MaybeRefOrGetter } from 'vue'\n\n/**\n * A single sequence definition for use with `useHotkeySequences`.\n */\nexport interface UseHotkeySequenceDefinition {\n  /** Array of hotkey strings that form the sequence */\n  sequence: MaybeRefOrGetter<HotkeySequence>\n  /** The function to call when the sequence is completed */\n  callback: HotkeyCallback\n  /** Per-sequence options (merged on top of commonOptions) */\n  options?: MaybeRefOrGetter<UseHotkeySequenceOptions>\n}\n\n/**\n * Vue composable for registering multiple keyboard shortcut sequences at once (Vim-style).\n *\n * Uses the singleton SequenceManager. Accepts a dynamic array of definitions, or a getter/ref\n * that returns one, so you can register variable-length lists safely.\n *\n * Options are merged in this order:\n * HotkeysProvider defaults < commonOptions < per-definition options\n *\n * Definitions with an empty `sequence` are skipped (no registration).\n *\n * @param definitions - Array of sequence definitions, or a getter/ref\n * @param commonOptions - Shared options applied to all sequences (overridden by per-definition options)\n *\n * @example\n * ```vue\n * <script setup>\n * import { useHotkeySequences } from '@tanstack/vue-hotkeys'\n *\n * useHotkeySequences([\n *   { sequence: ['G', 'G'], callback: () => scrollToTop() },\n *   { sequence: ['D', 'D'], callback: () => deleteLine() },\n * ])\n * </script>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { computed } from 'vue'\n * import { useHotkeySequences } from '@tanstack/vue-hotkeys'\n *\n * const items = computed(() => [...])\n * useHotkeySequences(\n *   () => items.value.map((item) => ({\n *     sequence: item.chords,\n *     callback: item.action,\n *     options: { enabled: item.enabled },\n *   })),\n *   { preventDefault: true },\n * )\n * </script>\n * ```\n */\nexport function useHotkeySequences(\n  definitions: MaybeRefOrGetter<Array<UseHotkeySequenceDefinition>>,\n  commonOptions: MaybeRefOrGetter<UseHotkeySequenceOptions> = {},\n): void {\n  type RegistrationRecord = {\n    handle: SequenceRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n\n  const registrations = new Map<string, RegistrationRecord>()\n\n  const stopWatcher = watch(\n    () => {\n      const resolvedDefinitions = resolveMaybeRefOrGetter(definitions)\n      const resolvedCommonOptions = resolveMaybeRefOrGetter(commonOptions)\n\n      return resolvedDefinitions.map((def, i) => {\n        const resolvedSequence = resolveMaybeRefOrGetter(def.sequence)\n        const resolvedDefOptions = def.options\n          ? resolveMaybeRefOrGetter(def.options)\n          : {}\n\n        const mergedOptions = {\n          ...defaultOptions.hotkeySequence,\n          ...resolvedCommonOptions,\n          ...resolvedDefOptions,\n        } as UseHotkeySequenceOptions\n\n        const sequenceString = formatHotkeySequence(resolvedSequence)\n\n        const resolvedEnabled =\n          mergedOptions.enabled === undefined\n            ? undefined\n            : resolveMaybeRefOrGetter(mergedOptions.enabled)\n        const resolvedTarget =\n          mergedOptions.target === undefined\n            ? undefined\n            : resolveMaybeRefOrGetter(mergedOptions.target as any)\n\n        return {\n          index: i,\n          resolvedSequence,\n          sequenceString,\n          callback: def.callback,\n          mergedOptions,\n          resolvedEnabled,\n          resolvedTarget,\n        }\n      })\n    },\n    (resolved) => {\n      const nextKeys = new Set<string>()\n      const prepared: Array<{\n        registrationKey: string\n        entry: (typeof resolved)[number]\n        finalTarget: Document | HTMLElement | Window\n      }> = []\n\n      for (const entry of resolved) {\n        if (entry.resolvedSequence.length === 0) {\n          continue\n        }\n\n        const finalTarget =\n          entry.resolvedTarget ??\n          (typeof document !== 'undefined' ? document : null)\n\n        if (!finalTarget) {\n          continue\n        }\n\n        const registrationKey = `${entry.index}:${entry.sequenceString}`\n        nextKeys.add(registrationKey)\n        prepared.push({ registrationKey, entry, finalTarget })\n      }\n\n      for (const [key, record] of [...registrations.entries()]) {\n        if (!nextKeys.has(key)) {\n          if (record.handle.isActive) {\n            record.handle.unregister()\n          }\n          registrations.delete(key)\n        }\n      }\n\n      for (const { registrationKey, entry, finalTarget } of prepared) {\n        const existing = registrations.get(registrationKey)\n        if (existing?.handle.isActive && existing.target === finalTarget) {\n          existing.handle.callback = entry.callback\n          const {\n            target: _target,\n            enabled: _enabled,\n            ...restOptions\n          } = entry.mergedOptions\n          const optionsWithoutTarget = {\n            ...restOptions,\n            ...(entry.resolvedEnabled === undefined\n              ? {}\n              : { enabled: entry.resolvedEnabled }),\n          }\n          existing.handle.setOptions(optionsWithoutTarget)\n          continue\n        }\n\n        if (existing) {\n          if (existing.handle.isActive) {\n            existing.handle.unregister()\n          }\n          registrations.delete(registrationKey)\n        }\n\n        const {\n          target: _target,\n          enabled: _enabled,\n          ...restOptions\n        } = entry.mergedOptions\n        const optionsWithoutTarget = {\n          ...restOptions,\n          ...(entry.resolvedEnabled === undefined\n            ? {}\n            : { enabled: entry.resolvedEnabled }),\n        }\n\n        const handle = manager.register(\n          entry.resolvedSequence,\n          entry.callback,\n          {\n            ...optionsWithoutTarget,\n            target: finalTarget,\n          },\n        )\n        registrations.set(registrationKey, { handle, target: finalTarget })\n      }\n    },\n    { immediate: true },\n  )\n\n  onUnmounted(() => {\n    stopWatcher()\n    for (const { handle } of registrations.values()) {\n      if (handle.isActive) {\n        handle.unregister()\n      }\n    }\n    registrations.clear()\n  })\n}\n\nfunction resolveMaybeRefOrGetter<T>(value: MaybeRefOrGetter<T>): T {\n  return typeof value === 'function' ? (value as () => T)() : unref(value)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,SAAgB,mBACd,aACA,gBAA4D,EAAE,EACxD;CAMN,MAAM,iBAAiBA,yDAA0B;CACjD,MAAM,qDAA8B;CAEpC,MAAM,gCAAgB,IAAI,KAAiC;CAE3D,MAAM,mCACE;EACJ,MAAM,sBAAsB,wBAAwB,YAAY;EAChE,MAAM,wBAAwB,wBAAwB,cAAc;AAEpE,SAAO,oBAAoB,KAAK,KAAK,MAAM;GACzC,MAAM,mBAAmB,wBAAwB,IAAI,SAAS;GAC9D,MAAM,qBAAqB,IAAI,UAC3B,wBAAwB,IAAI,QAAQ,GACpC,EAAE;GAEN,MAAM,gBAAgB;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;GAED,MAAM,6DAAsC,iBAAiB;GAE7D,MAAM,kBACJ,cAAc,YAAY,SACtB,SACA,wBAAwB,cAAc,QAAQ;GACpD,MAAM,iBACJ,cAAc,WAAW,SACrB,SACA,wBAAwB,cAAc,OAAc;AAE1D,UAAO;IACL,OAAO;IACP;IACA;IACA,UAAU,IAAI;IACd;IACA;IACA;IACD;IACD;KAEH,aAAa;EACZ,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAID,EAAE;AAEP,OAAK,MAAM,SAAS,UAAU;AAC5B,OAAI,MAAM,iBAAiB,WAAW,EACpC;GAGF,MAAM,cACJ,MAAM,mBACL,OAAO,aAAa,cAAc,WAAW;AAEhD,OAAI,CAAC,YACH;GAGF,MAAM,kBAAkB,GAAG,MAAM,MAAM,GAAG,MAAM;AAChD,YAAS,IAAI,gBAAgB;AAC7B,YAAS,KAAK;IAAE;IAAiB;IAAO;IAAa,CAAC;;AAGxD,OAAK,MAAM,CAAC,KAAK,WAAW,CAAC,GAAG,cAAc,SAAS,CAAC,CACtD,KAAI,CAAC,SAAS,IAAI,IAAI,EAAE;AACtB,OAAI,OAAO,OAAO,SAChB,QAAO,OAAO,YAAY;AAE5B,iBAAc,OAAO,IAAI;;AAI7B,OAAK,MAAM,EAAE,iBAAiB,OAAO,iBAAiB,UAAU;GAC9D,MAAM,WAAW,cAAc,IAAI,gBAAgB;AACnD,OAAI,UAAU,OAAO,YAAY,SAAS,WAAW,aAAa;AAChE,aAAS,OAAO,WAAW,MAAM;IACjC,MAAM,EACJ,QAAQ,SACR,SAAS,UACT,GAAG,gBACD,MAAM;IACV,MAAM,uBAAuB;KAC3B,GAAG;KACH,GAAI,MAAM,oBAAoB,SAC1B,EAAE,GACF,EAAE,SAAS,MAAM,iBAAiB;KACvC;AACD,aAAS,OAAO,WAAW,qBAAqB;AAChD;;AAGF,OAAI,UAAU;AACZ,QAAI,SAAS,OAAO,SAClB,UAAS,OAAO,YAAY;AAE9B,kBAAc,OAAO,gBAAgB;;GAGvC,MAAM,EACJ,QAAQ,SACR,SAAS,UACT,GAAG,gBACD,MAAM;GACV,MAAM,uBAAuB;IAC3B,GAAG;IACH,GAAI,MAAM,oBAAoB,SAC1B,EAAE,GACF,EAAE,SAAS,MAAM,iBAAiB;IACvC;GAED,MAAM,SAAS,QAAQ,SACrB,MAAM,kBACN,MAAM,UACN;IACE,GAAG;IACH,QAAQ;IACT,CACF;AACD,iBAAc,IAAI,iBAAiB;IAAE;IAAQ,QAAQ;IAAa,CAAC;;IAGvE,EAAE,WAAW,MAAM,CACpB;AAED,4BAAkB;AAChB,eAAa;AACb,OAAK,MAAM,EAAE,YAAY,cAAc,QAAQ,CAC7C,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,gBAAc,OAAO;GACrB;;AAGJ,SAAS,wBAA2B,OAA+B;AACjE,QAAO,OAAO,UAAU,aAAc,OAAmB,kBAAS,MAAM"}