@tanstack/vue-hotkeys 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -7,6 +7,7 @@ const require_useHeldKeys = require('./useHeldKeys.cjs');
 const require_useHeldKeyCodes = require('./useHeldKeyCodes.cjs');
 const require_useKeyHold = require('./useKeyHold.cjs');
 const require_useHotkeySequence = require('./useHotkeySequence.cjs');
+const require_useHotkeySequences = require('./useHotkeySequences.cjs');
 const require_useHotkeyRecorder = require('./useHotkeyRecorder.cjs');
 const require_useHotkeySequenceRecorder = require('./useHotkeySequenceRecorder.cjs');
 
@@ -19,6 +20,7 @@ exports.useHotkey = require_useHotkey.useHotkey;
 exports.useHotkeyRecorder = require_useHotkeyRecorder.useHotkeyRecorder;
 exports.useHotkeySequence = require_useHotkeySequence.useHotkeySequence;
 exports.useHotkeySequenceRecorder = require_useHotkeySequenceRecorder.useHotkeySequenceRecorder;
+exports.useHotkeySequences = require_useHotkeySequences.useHotkeySequences;
 exports.useHotkeys = require_useHotkeys.useHotkeys;
 exports.useHotkeysContext = require_HotkeysProviderContext.useHotkeysContext;
 exports.useKeyHold = require_useKeyHold.useKeyHold;

package/dist/index.d.cts

@@ -6,7 +6,8 @@ import { UseHotkeyDefinition, useHotkeys } from "./useHotkeys.cjs";
 import { useHeldKeys } from "./useHeldKeys.cjs";
 import { useHeldKeyCodes } from "./useHeldKeyCodes.cjs";
 import { useKeyHold } from "./useKeyHold.cjs";
+import { UseHotkeySequenceDefinition, useHotkeySequences } from "./useHotkeySequences.cjs";
 import { VueHotkeyRecorder, useHotkeyRecorder } from "./useHotkeyRecorder.cjs";
 import { VueHotkeySequenceRecorder, useHotkeySequenceRecorder } from "./useHotkeySequenceRecorder.cjs";
 export * from "@tanstack/hotkeys";
-export { HotkeysProvider, HotkeysProviderOptions, UseHotkeyDefinition, UseHotkeyOptions, UseHotkeySequenceOptions, VueHotkeyRecorder, VueHotkeySequenceRecorder, provideHotkeysContext, useDefaultHotkeysOptions, useHeldKeyCodes, useHeldKeys, useHotkey, useHotkeyRecorder, useHotkeySequence, useHotkeySequenceRecorder, useHotkeys, useHotkeysContext, useKeyHold };
+export { HotkeysProvider, HotkeysProviderOptions, UseHotkeyDefinition, UseHotkeyOptions, UseHotkeySequenceDefinition, UseHotkeySequenceOptions, VueHotkeyRecorder, VueHotkeySequenceRecorder, provideHotkeysContext, useDefaultHotkeysOptions, useHeldKeyCodes, useHeldKeys, useHotkey, useHotkeyRecorder, useHotkeySequence, useHotkeySequenceRecorder, useHotkeySequences, useHotkeys, useHotkeysContext, useKeyHold };

package/dist/index.d.ts

@@ -6,7 +6,8 @@ import { UseHotkeyDefinition, useHotkeys } from "./useHotkeys.js";
 import { useHeldKeys } from "./useHeldKeys.js";
 import { useHeldKeyCodes } from "./useHeldKeyCodes.js";
 import { useKeyHold } from "./useKeyHold.js";
+import { UseHotkeySequenceDefinition, useHotkeySequences } from "./useHotkeySequences.js";
 import { VueHotkeyRecorder, useHotkeyRecorder } from "./useHotkeyRecorder.js";
 import { VueHotkeySequenceRecorder, useHotkeySequenceRecorder } from "./useHotkeySequenceRecorder.js";
 export * from "@tanstack/hotkeys";
-export { HotkeysProvider, HotkeysProviderOptions, UseHotkeyDefinition, UseHotkeyOptions, UseHotkeySequenceOptions, VueHotkeyRecorder, VueHotkeySequenceRecorder, provideHotkeysContext, useDefaultHotkeysOptions, useHeldKeyCodes, useHeldKeys, useHotkey, useHotkeyRecorder, useHotkeySequence, useHotkeySequenceRecorder, useHotkeys, useHotkeysContext, useKeyHold };
+export { HotkeysProvider, HotkeysProviderOptions, UseHotkeyDefinition, UseHotkeyOptions, UseHotkeySequenceDefinition, UseHotkeySequenceOptions, VueHotkeyRecorder, VueHotkeySequenceRecorder, provideHotkeysContext, useDefaultHotkeysOptions, useHeldKeyCodes, useHeldKeys, useHotkey, useHotkeyRecorder, useHotkeySequence, useHotkeySequenceRecorder, useHotkeySequences, useHotkeys, useHotkeysContext, useKeyHold };

package/dist/index.js

@@ -6,9 +6,10 @@ import { useHeldKeys } from "./useHeldKeys.js";
 import { useHeldKeyCodes } from "./useHeldKeyCodes.js";
 import { useKeyHold } from "./useKeyHold.js";
 import { useHotkeySequence } from "./useHotkeySequence.js";
+import { useHotkeySequences } from "./useHotkeySequences.js";
 import { useHotkeyRecorder } from "./useHotkeyRecorder.js";
 import { useHotkeySequenceRecorder } from "./useHotkeySequenceRecorder.js";
 
 export * from "@tanstack/hotkeys"
 
-export { HotkeysProvider, provideHotkeysContext, useDefaultHotkeysOptions, useHeldKeyCodes, useHeldKeys, useHotkey, useHotkeyRecorder, useHotkeySequence, useHotkeySequenceRecorder, useHotkeys, useHotkeysContext, useKeyHold };
+export { HotkeysProvider, provideHotkeysContext, useDefaultHotkeysOptions, useHeldKeyCodes, useHeldKeys, useHotkey, useHotkeyRecorder, useHotkeySequence, useHotkeySequenceRecorder, useHotkeySequences, useHotkeys, useHotkeysContext, useKeyHold };

package/dist/useHotkey.cjs

@@ -71,6 +71,8 @@ function useHotkey(hotkey, callback, options = {}) {
 	const defaultOptions = require_HotkeysProviderContext.useDefaultHotkeysOptions();
 	const manager = (0, _tanstack_hotkeys.getHotkeyManager)();
 	let registration = null;
+	let lastHotkeyString = null;
+	let lastTarget = null;
 	const stopWatcher = (0, vue.watch)(() => {
 		const resolvedHotkey = resolveMaybeRefOrGetter(hotkey);
 		const resolvedOptions = resolveMaybeRefOrGetter(options);
@@ -87,17 +89,30 @@ function useHotkey(hotkey, callback, options = {}) {
 	}, ({ resolvedHotkey, mergedOptions, resolvedEnabled, resolvedTarget }) => {
 		const platform = mergedOptions.platform ?? (0, _tanstack_hotkeys.detectPlatform)();
 		const hotkeyString = typeof resolvedHotkey === "string" ? resolvedHotkey : (0, _tanstack_hotkeys.formatHotkey)((0, _tanstack_hotkeys.rawHotkeyToParsedHotkey)(resolvedHotkey, platform));
-		const finalTarget = resolvedTarget ?? (typeof document !== "undefined" ? document : null);
-		if (!finalTarget) return;
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
+		const finalTarget = resolvedTarget === void 0 ? typeof document !== "undefined" ? document : null : resolvedTarget;
+		if (!finalTarget) {
+			if (registration?.isActive) {
+				registration.unregister();
+				registration = null;
+			}
+			lastHotkeyString = null;
+			lastTarget = null;
+			return;
 		}
 		const { target: _target, enabled: _enabled, ...restOptions } = mergedOptions;
 		const optionsWithoutTarget = {
 			...restOptions,
 			...resolvedEnabled === void 0 ? {} : { enabled: resolvedEnabled }
 		};
+		if (registration?.isActive && lastHotkeyString === hotkeyString && lastTarget === finalTarget) {
+			registration.callback = callback;
+			registration.setOptions(optionsWithoutTarget);
+			return;
+		}
+		if (registration?.isActive) {
+			registration.unregister();
+			registration = null;
+		}
 		registration = manager.register(hotkeyString, callback, {
 			...optionsWithoutTarget,
 			target: finalTarget
@@ -106,6 +121,8 @@ function useHotkey(hotkey, callback, options = {}) {
 			registration.callback = callback;
 			registration.setOptions(optionsWithoutTarget);
 		}
+		lastHotkeyString = hotkeyString;
+		lastTarget = finalTarget;
 	}, { immediate: true });
 	(0, vue.onUnmounted)(() => {
 		stopWatcher();

package/dist/useHotkey.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useHotkey.cjs","names":["useDefaultHotkeysOptions"],"sources":["../src/useHotkey.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport {\n  detectPlatform,\n  formatHotkey,\n  getHotkeyManager,\n  rawHotkeyToParsedHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport type { MaybeRefOrGetter } from 'vue'\n\nexport interface UseHotkeyOptions extends Omit<\n  HotkeyOptions,\n  'enabled' | 'target'\n> {\n  /**\n   * Whether the hotkey 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 hotkey.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * The callback receives both the keyboard event and a context object\n * containing the hotkey string and parsed hotkey.\n *\n * This composable automatically tracks reactive dependencies and updates\n * the registration when options or the callback change.\n *\n * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const count = ref(0)\n *\n * // Callback always has access to latest count value\n * useHotkey('Mod+S', (event, { hotkey }) => {\n *   console.log(`Save triggered, count is ${count.value}`)\n *   handleSave()\n * })\n * </script>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const isOpen = ref(false)\n *\n * // enabled option is reactive\n * useHotkey('Escape', () => {\n *   isOpen.value = false\n * }, { enabled: isOpen })\n * </script>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const editorRef = ref<HTMLDivElement | null>(null)\n *\n * // Scoped to a specific element\n * useHotkey('Mod+S', () => {\n *   save()\n * }, { target: editorRef })\n * </script>\n *\n * <template>\n *   <div ref=\"editorRef\">...</div>\n * </template>\n * ```\n */\nexport function useHotkey(\n  hotkey: MaybeRefOrGetter<RegisterableHotkey>,\n  callback: HotkeyCallback,\n  options: MaybeRefOrGetter<UseHotkeyOptions> = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  let registration: HotkeyRegistrationHandle | null = null\n\n  // Watch for changes to reactive dependencies\n  const stopWatcher = watch(\n    () => {\n      const resolvedHotkey = resolveMaybeRefOrGetter(hotkey)\n      const resolvedOptions = resolveMaybeRefOrGetter(options)\n      const mergedOptions = {\n        ...defaultOptions.hotkey,\n        ...resolvedOptions,\n      } as UseHotkeyOptions\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        resolvedHotkey,\n        mergedOptions,\n        resolvedEnabled,\n        resolvedTarget,\n      }\n    },\n    ({ resolvedHotkey, mergedOptions, resolvedEnabled, resolvedTarget }) => {\n      // Normalize to hotkey string\n      const platform = mergedOptions.platform ?? detectPlatform()\n      const hotkeyString: Hotkey =\n        typeof resolvedHotkey === 'string'\n          ? resolvedHotkey\n          : (formatHotkey(\n              rawHotkeyToParsedHotkey(resolvedHotkey as any, platform),\n            ) as Hotkey)\n\n      // Resolve target\n      const finalTarget =\n        resolvedTarget ?? (typeof document !== 'undefined' ? document : null)\n\n      if (!finalTarget) {\n        return\n      }\n\n      // Unregister previous registration if it exists\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\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      // Register the hotkey\n      registration = manager.register(hotkeyString, callback, {\n        ...optionsWithoutTarget,\n        target: finalTarget,\n      })\n\n      // Update callback and options\n      if (registration.isActive) {\n        registration.callback = callback\n        registration.setOptions(optionsWithoutTarget)\n      }\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGA,SAAgB,UACd,QACA,UACA,UAA8C,EAAE,EAC1C;CACN,MAAM,iBAAiBA,yDAA0B;CACjD,MAAM,mDAA4B;CAElC,IAAI,eAAgD;CAGpD,MAAM,mCACE;EACJ,MAAM,iBAAiB,wBAAwB,OAAO;EACtD,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,gBAAgB,eAAe,iBAAiB,qBAAqB;EAEtE,MAAM,WAAW,cAAc,mDAA4B;EAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,oGAE0B,gBAAuB,SAAS,CACzD;EAGP,MAAM,cACJ,mBAAmB,OAAO,aAAa,cAAc,WAAW;AAElE,MAAI,CAAC,YACH;AAIF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;EAIjB,MAAM,EACJ,QAAQ,SACR,SAAS,UACT,GAAG,gBACD;EACJ,MAAM,uBAAuB;GAC3B,GAAG;GACH,GAAI,oBAAoB,SAAY,EAAE,GAAG,EAAE,SAAS,iBAAiB;GACtE;AAGD,iBAAe,QAAQ,SAAS,cAAc,UAAU;GACtD,GAAG;GACH,QAAQ;GACT,CAAC;AAGF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;IAGjD,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"}
+{"version":3,"file":"useHotkey.cjs","names":["useDefaultHotkeysOptions"],"sources":["../src/useHotkey.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport {\n  detectPlatform,\n  formatHotkey,\n  getHotkeyManager,\n  rawHotkeyToParsedHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport type { MaybeRefOrGetter } from 'vue'\n\nexport interface UseHotkeyOptions extends Omit<\n  HotkeyOptions,\n  'enabled' | 'target'\n> {\n  /**\n   * Whether the hotkey 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 hotkey.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * The callback receives both the keyboard event and a context object\n * containing the hotkey string and parsed hotkey.\n *\n * This composable automatically tracks reactive dependencies and updates\n * the registration when options or the callback change.\n *\n * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const count = ref(0)\n *\n * // Callback always has access to latest count value\n * useHotkey('Mod+S', (event, { hotkey }) => {\n *   console.log(`Save triggered, count is ${count.value}`)\n *   handleSave()\n * })\n * </script>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const isOpen = ref(false)\n *\n * // enabled option is reactive\n * useHotkey('Escape', () => {\n *   isOpen.value = false\n * }, { enabled: isOpen })\n * </script>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const editorRef = ref<HTMLDivElement | null>(null)\n *\n * // Scoped to a specific element\n * useHotkey('Mod+S', () => {\n *   save()\n * }, { target: editorRef })\n * </script>\n *\n * <template>\n *   <div ref=\"editorRef\">...</div>\n * </template>\n * ```\n */\nexport function useHotkey(\n  hotkey: MaybeRefOrGetter<RegisterableHotkey>,\n  callback: HotkeyCallback,\n  options: MaybeRefOrGetter<UseHotkeyOptions> = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  let registration: HotkeyRegistrationHandle | null = null\n  let lastHotkeyString: Hotkey | 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 resolvedHotkey = resolveMaybeRefOrGetter(hotkey)\n      const resolvedOptions = resolveMaybeRefOrGetter(options)\n      const mergedOptions = {\n        ...defaultOptions.hotkey,\n        ...resolvedOptions,\n      } as UseHotkeyOptions\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        resolvedHotkey,\n        mergedOptions,\n        resolvedEnabled,\n        resolvedTarget,\n      }\n    },\n    ({ resolvedHotkey, mergedOptions, resolvedEnabled, resolvedTarget }) => {\n      // Normalize to hotkey string\n      const platform = mergedOptions.platform ?? detectPlatform()\n      const hotkeyString: Hotkey =\n        typeof resolvedHotkey === 'string'\n          ? resolvedHotkey\n          : (formatHotkey(\n              rawHotkeyToParsedHotkey(resolvedHotkey as any, platform),\n            ) as Hotkey)\n\n      // Resolve target\n      const finalTarget =\n        resolvedTarget === undefined\n          ? typeof document !== 'undefined'\n            ? document\n            : null\n          : resolvedTarget\n\n      if (!finalTarget) {\n        if (registration?.isActive) {\n          registration.unregister()\n          registration = null\n        }\n        lastHotkeyString = null\n        lastTarget = null\n        return\n      }\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        lastHotkeyString === hotkeyString &&\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(hotkeyString, callback, {\n        ...optionsWithoutTarget,\n        target: finalTarget,\n      })\n\n      if (registration.isActive) {\n        registration.callback = callback\n        registration.setOptions(optionsWithoutTarget)\n      }\n\n      lastHotkeyString = hotkeyString\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGA,SAAgB,UACd,QACA,UACA,UAA8C,EAAE,EAC1C;CACN,MAAM,iBAAiBA,yDAA0B;CACjD,MAAM,mDAA4B;CAElC,IAAI,eAAgD;CACpD,IAAI,mBAAkC;CACtC,IAAI,aAAqD;CAGzD,MAAM,mCACE;EACJ,MAAM,iBAAiB,wBAAwB,OAAO;EACtD,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,gBAAgB,eAAe,iBAAiB,qBAAqB;EAEtE,MAAM,WAAW,cAAc,mDAA4B;EAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,oGAE0B,gBAAuB,SAAS,CACzD;EAGP,MAAM,cACJ,mBAAmB,SACf,OAAO,aAAa,cAClB,WACA,OACF;AAEN,MAAI,CAAC,aAAa;AAChB,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,sBAAmB;AACnB,gBAAa;AACb;;EAIF,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,qBAAqB,gBACrB,eAAe,aACf;AACA,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;AAC7C;;AAGF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAGjB,iBAAe,QAAQ,SAAS,cAAc,UAAU;GACtD,GAAG;GACH,QAAQ;GACT,CAAC;AAEF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAG/C,qBAAmB;AACnB,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/useHotkey.js

@@ -71,6 +71,8 @@ function useHotkey(hotkey, callback, options = {}) {
 	const defaultOptions = useDefaultHotkeysOptions();
 	const manager = getHotkeyManager();
 	let registration = null;
+	let lastHotkeyString = null;
+	let lastTarget = null;
 	const stopWatcher = watch(() => {
 		const resolvedHotkey = resolveMaybeRefOrGetter(hotkey);
 		const resolvedOptions = resolveMaybeRefOrGetter(options);
@@ -87,17 +89,30 @@ function useHotkey(hotkey, callback, options = {}) {
 	}, ({ resolvedHotkey, mergedOptions, resolvedEnabled, resolvedTarget }) => {
 		const platform = mergedOptions.platform ?? detectPlatform();
 		const hotkeyString = typeof resolvedHotkey === "string" ? resolvedHotkey : formatHotkey(rawHotkeyToParsedHotkey(resolvedHotkey, platform));
-		const finalTarget = resolvedTarget ?? (typeof document !== "undefined" ? document : null);
-		if (!finalTarget) return;
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
+		const finalTarget = resolvedTarget === void 0 ? typeof document !== "undefined" ? document : null : resolvedTarget;
+		if (!finalTarget) {
+			if (registration?.isActive) {
+				registration.unregister();
+				registration = null;
+			}
+			lastHotkeyString = null;
+			lastTarget = null;
+			return;
 		}
 		const { target: _target, enabled: _enabled, ...restOptions } = mergedOptions;
 		const optionsWithoutTarget = {
 			...restOptions,
 			...resolvedEnabled === void 0 ? {} : { enabled: resolvedEnabled }
 		};
+		if (registration?.isActive && lastHotkeyString === hotkeyString && lastTarget === finalTarget) {
+			registration.callback = callback;
+			registration.setOptions(optionsWithoutTarget);
+			return;
+		}
+		if (registration?.isActive) {
+			registration.unregister();
+			registration = null;
+		}
 		registration = manager.register(hotkeyString, callback, {
 			...optionsWithoutTarget,
 			target: finalTarget
@@ -106,6 +121,8 @@ function useHotkey(hotkey, callback, options = {}) {
 			registration.callback = callback;
 			registration.setOptions(optionsWithoutTarget);
 		}
+		lastHotkeyString = hotkeyString;
+		lastTarget = finalTarget;
 	}, { immediate: true });
 	onUnmounted(() => {
 		stopWatcher();

package/dist/useHotkey.js.map

@@ -1 +1 @@
-{"version":3,"file":"useHotkey.js","names":[],"sources":["../src/useHotkey.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport {\n  detectPlatform,\n  formatHotkey,\n  getHotkeyManager,\n  rawHotkeyToParsedHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport type { MaybeRefOrGetter } from 'vue'\n\nexport interface UseHotkeyOptions extends Omit<\n  HotkeyOptions,\n  'enabled' | 'target'\n> {\n  /**\n   * Whether the hotkey 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 hotkey.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * The callback receives both the keyboard event and a context object\n * containing the hotkey string and parsed hotkey.\n *\n * This composable automatically tracks reactive dependencies and updates\n * the registration when options or the callback change.\n *\n * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const count = ref(0)\n *\n * // Callback always has access to latest count value\n * useHotkey('Mod+S', (event, { hotkey }) => {\n *   console.log(`Save triggered, count is ${count.value}`)\n *   handleSave()\n * })\n * </script>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const isOpen = ref(false)\n *\n * // enabled option is reactive\n * useHotkey('Escape', () => {\n *   isOpen.value = false\n * }, { enabled: isOpen })\n * </script>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const editorRef = ref<HTMLDivElement | null>(null)\n *\n * // Scoped to a specific element\n * useHotkey('Mod+S', () => {\n *   save()\n * }, { target: editorRef })\n * </script>\n *\n * <template>\n *   <div ref=\"editorRef\">...</div>\n * </template>\n * ```\n */\nexport function useHotkey(\n  hotkey: MaybeRefOrGetter<RegisterableHotkey>,\n  callback: HotkeyCallback,\n  options: MaybeRefOrGetter<UseHotkeyOptions> = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  let registration: HotkeyRegistrationHandle | null = null\n\n  // Watch for changes to reactive dependencies\n  const stopWatcher = watch(\n    () => {\n      const resolvedHotkey = resolveMaybeRefOrGetter(hotkey)\n      const resolvedOptions = resolveMaybeRefOrGetter(options)\n      const mergedOptions = {\n        ...defaultOptions.hotkey,\n        ...resolvedOptions,\n      } as UseHotkeyOptions\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        resolvedHotkey,\n        mergedOptions,\n        resolvedEnabled,\n        resolvedTarget,\n      }\n    },\n    ({ resolvedHotkey, mergedOptions, resolvedEnabled, resolvedTarget }) => {\n      // Normalize to hotkey string\n      const platform = mergedOptions.platform ?? detectPlatform()\n      const hotkeyString: Hotkey =\n        typeof resolvedHotkey === 'string'\n          ? resolvedHotkey\n          : (formatHotkey(\n              rawHotkeyToParsedHotkey(resolvedHotkey as any, platform),\n            ) as Hotkey)\n\n      // Resolve target\n      const finalTarget =\n        resolvedTarget ?? (typeof document !== 'undefined' ? document : null)\n\n      if (!finalTarget) {\n        return\n      }\n\n      // Unregister previous registration if it exists\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\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      // Register the hotkey\n      registration = manager.register(hotkeyString, callback, {\n        ...optionsWithoutTarget,\n        target: finalTarget,\n      })\n\n      // Update callback and options\n      if (registration.isActive) {\n        registration.callback = callback\n        registration.setOptions(optionsWithoutTarget)\n      }\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGA,SAAgB,UACd,QACA,UACA,UAA8C,EAAE,EAC1C;CACN,MAAM,iBAAiB,0BAA0B;CACjD,MAAM,UAAU,kBAAkB;CAElC,IAAI,eAAgD;CAGpD,MAAM,cAAc,YACZ;EACJ,MAAM,iBAAiB,wBAAwB,OAAO;EACtD,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,gBAAgB,eAAe,iBAAiB,qBAAqB;EAEtE,MAAM,WAAW,cAAc,YAAY,gBAAgB;EAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,iBACC,aACC,wBAAwB,gBAAuB,SAAS,CACzD;EAGP,MAAM,cACJ,mBAAmB,OAAO,aAAa,cAAc,WAAW;AAElE,MAAI,CAAC,YACH;AAIF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;EAIjB,MAAM,EACJ,QAAQ,SACR,SAAS,UACT,GAAG,gBACD;EACJ,MAAM,uBAAuB;GAC3B,GAAG;GACH,GAAI,oBAAoB,SAAY,EAAE,GAAG,EAAE,SAAS,iBAAiB;GACtE;AAGD,iBAAe,QAAQ,SAAS,cAAc,UAAU;GACtD,GAAG;GACH,QAAQ;GACT,CAAC;AAGF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;IAGjD,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"}
+{"version":3,"file":"useHotkey.js","names":[],"sources":["../src/useHotkey.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport {\n  detectPlatform,\n  formatHotkey,\n  getHotkeyManager,\n  rawHotkeyToParsedHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport type { MaybeRefOrGetter } from 'vue'\n\nexport interface UseHotkeyOptions extends Omit<\n  HotkeyOptions,\n  'enabled' | 'target'\n> {\n  /**\n   * Whether the hotkey 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 hotkey.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * The callback receives both the keyboard event and a context object\n * containing the hotkey string and parsed hotkey.\n *\n * This composable automatically tracks reactive dependencies and updates\n * the registration when options or the callback change.\n *\n * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const count = ref(0)\n *\n * // Callback always has access to latest count value\n * useHotkey('Mod+S', (event, { hotkey }) => {\n *   console.log(`Save triggered, count is ${count.value}`)\n *   handleSave()\n * })\n * </script>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const isOpen = ref(false)\n *\n * // enabled option is reactive\n * useHotkey('Escape', () => {\n *   isOpen.value = false\n * }, { enabled: isOpen })\n * </script>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { ref } from 'vue'\n * import { useHotkey } from '@tanstack/vue-hotkeys'\n *\n * const editorRef = ref<HTMLDivElement | null>(null)\n *\n * // Scoped to a specific element\n * useHotkey('Mod+S', () => {\n *   save()\n * }, { target: editorRef })\n * </script>\n *\n * <template>\n *   <div ref=\"editorRef\">...</div>\n * </template>\n * ```\n */\nexport function useHotkey(\n  hotkey: MaybeRefOrGetter<RegisterableHotkey>,\n  callback: HotkeyCallback,\n  options: MaybeRefOrGetter<UseHotkeyOptions> = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  let registration: HotkeyRegistrationHandle | null = null\n  let lastHotkeyString: Hotkey | 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 resolvedHotkey = resolveMaybeRefOrGetter(hotkey)\n      const resolvedOptions = resolveMaybeRefOrGetter(options)\n      const mergedOptions = {\n        ...defaultOptions.hotkey,\n        ...resolvedOptions,\n      } as UseHotkeyOptions\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        resolvedHotkey,\n        mergedOptions,\n        resolvedEnabled,\n        resolvedTarget,\n      }\n    },\n    ({ resolvedHotkey, mergedOptions, resolvedEnabled, resolvedTarget }) => {\n      // Normalize to hotkey string\n      const platform = mergedOptions.platform ?? detectPlatform()\n      const hotkeyString: Hotkey =\n        typeof resolvedHotkey === 'string'\n          ? resolvedHotkey\n          : (formatHotkey(\n              rawHotkeyToParsedHotkey(resolvedHotkey as any, platform),\n            ) as Hotkey)\n\n      // Resolve target\n      const finalTarget =\n        resolvedTarget === undefined\n          ? typeof document !== 'undefined'\n            ? document\n            : null\n          : resolvedTarget\n\n      if (!finalTarget) {\n        if (registration?.isActive) {\n          registration.unregister()\n          registration = null\n        }\n        lastHotkeyString = null\n        lastTarget = null\n        return\n      }\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        lastHotkeyString === hotkeyString &&\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(hotkeyString, callback, {\n        ...optionsWithoutTarget,\n        target: finalTarget,\n      })\n\n      if (registration.isActive) {\n        registration.callback = callback\n        registration.setOptions(optionsWithoutTarget)\n      }\n\n      lastHotkeyString = hotkeyString\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGA,SAAgB,UACd,QACA,UACA,UAA8C,EAAE,EAC1C;CACN,MAAM,iBAAiB,0BAA0B;CACjD,MAAM,UAAU,kBAAkB;CAElC,IAAI,eAAgD;CACpD,IAAI,mBAAkC;CACtC,IAAI,aAAqD;CAGzD,MAAM,cAAc,YACZ;EACJ,MAAM,iBAAiB,wBAAwB,OAAO;EACtD,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,gBAAgB,eAAe,iBAAiB,qBAAqB;EAEtE,MAAM,WAAW,cAAc,YAAY,gBAAgB;EAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,iBACC,aACC,wBAAwB,gBAAuB,SAAS,CACzD;EAGP,MAAM,cACJ,mBAAmB,SACf,OAAO,aAAa,cAClB,WACA,OACF;AAEN,MAAI,CAAC,aAAa;AAChB,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,sBAAmB;AACnB,gBAAa;AACb;;EAIF,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,qBAAqB,gBACrB,eAAe,aACf;AACA,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;AAC7C;;AAGF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAGjB,iBAAe,QAAQ,SAAS,cAAc,UAAU;GACtD,GAAG;GACH,QAAQ;GACT,CAAC;AAEF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAG/C,qBAAmB;AACnB,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/useHotkeySequence.cjs

@@ -53,6 +53,8 @@ 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);
@@ -67,18 +69,31 @@ function useHotkeySequence(sequence, callback, options = {}) {
 			resolvedTarget: mergedOptions.target === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.target)
 		};
 	}, ({ resolvedSequence, mergedOptions, resolvedEnabled, resolvedTarget }) => {
-		if (resolvedEnabled === false || resolvedSequence.length === 0) return;
-		const finalTarget = resolvedTarget ?? (typeof document !== "undefined" ? document : null);
-		if (!finalTarget) return;
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
+		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
@@ -87,6 +102,8 @@ function useHotkeySequence(sequence, callback, options = {}) {
 			registration.callback = callback;
 			registration.setOptions(optionsWithoutTarget);
 		}
+		lastSequenceKey = sequenceKey;
+		lastTarget = finalTarget;
 	}, { immediate: true });
 	(0, vue.onUnmounted)(() => {
 		stopWatcher();

package/dist/useHotkeySequence.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useHotkeySequence.cjs","names":["useDefaultHotkeysOptions"],"sources":["../src/useHotkeySequence.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport { 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\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      if (resolvedEnabled === false || resolvedSequence.length === 0) {\n        return\n      }\n\n      // Resolve target\n      const finalTarget =\n        resolvedTarget ?? (typeof document !== 'undefined' ? document : null)\n\n      if (!finalTarget) {\n        return\n      }\n\n      // Unregister previous registration if it exists\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\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      // Register the sequence\n      registration = manager.register(resolvedSequence, callback, {\n        ...optionsWithoutTarget,\n        target: finalTarget,\n      })\n\n      // Update callback and options\n      if (registration.isActive) {\n        registration.callback = callback\n        registration.setOptions(optionsWithoutTarget)\n      }\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;CAGtD,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;AACxE,MAAI,oBAAoB,SAAS,iBAAiB,WAAW,EAC3D;EAIF,MAAM,cACJ,mBAAmB,OAAO,aAAa,cAAc,WAAW;AAElE,MAAI,CAAC,YACH;AAIF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;EAIjB,MAAM,EACJ,QAAQ,SACR,SAAS,UACT,GAAG,gBACD;EACJ,MAAM,uBAAuB;GAC3B,GAAG;GACH,GAAI,oBAAoB,SAAY,EAAE,GAAG,EAAE,SAAS,iBAAiB;GACtE;AAGD,iBAAe,QAAQ,SAAS,kBAAkB,UAAU;GAC1D,GAAG;GACH,QAAQ;GACT,CAAC;AAGF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;IAGjD,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"}
+{"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.js

@@ -1,5 +1,5 @@
 import { useDefaultHotkeysOptions } from "./HotkeysProviderContext.js";
-import { getSequenceManager } from "@tanstack/hotkeys";
+import { formatHotkeySequence, getSequenceManager } from "@tanstack/hotkeys";
 import { onUnmounted, unref, watch } from "vue";
 
 //#region src/useHotkeySequence.ts
@@ -53,6 +53,8 @@ function useHotkeySequence(sequence, callback, options = {}) {
 	const defaultOptions = useDefaultHotkeysOptions();
 	const manager = getSequenceManager();
 	let registration = null;
+	let lastSequenceKey = null;
+	let lastTarget = null;
 	const stopWatcher = watch(() => {
 		const resolvedSequence = resolveMaybeRefOrGetter(sequence);
 		const resolvedOptions = resolveMaybeRefOrGetter(options);
@@ -67,18 +69,31 @@ function useHotkeySequence(sequence, callback, options = {}) {
 			resolvedTarget: mergedOptions.target === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.target)
 		};
 	}, ({ resolvedSequence, mergedOptions, resolvedEnabled, resolvedTarget }) => {
-		if (resolvedEnabled === false || resolvedSequence.length === 0) return;
-		const finalTarget = resolvedTarget ?? (typeof document !== "undefined" ? document : null);
-		if (!finalTarget) return;
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
+		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 = 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
@@ -87,6 +102,8 @@ function useHotkeySequence(sequence, callback, options = {}) {
 			registration.callback = callback;
 			registration.setOptions(optionsWithoutTarget);
 		}
+		lastSequenceKey = sequenceKey;
+		lastTarget = finalTarget;
 	}, { immediate: true });
 	onUnmounted(() => {
 		stopWatcher();

package/dist/useHotkeySequence.js.map

@@ -1 +1 @@
-{"version":3,"file":"useHotkeySequence.js","names":[],"sources":["../src/useHotkeySequence.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport { 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\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      if (resolvedEnabled === false || resolvedSequence.length === 0) {\n        return\n      }\n\n      // Resolve target\n      const finalTarget =\n        resolvedTarget ?? (typeof document !== 'undefined' ? document : null)\n\n      if (!finalTarget) {\n        return\n      }\n\n      // Unregister previous registration if it exists\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\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      // Register the sequence\n      registration = manager.register(resolvedSequence, callback, {\n        ...optionsWithoutTarget,\n        target: finalTarget,\n      })\n\n      // Update callback and options\n      if (registration.isActive) {\n        registration.callback = callback\n        registration.setOptions(optionsWithoutTarget)\n      }\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;CAGtD,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;AACxE,MAAI,oBAAoB,SAAS,iBAAiB,WAAW,EAC3D;EAIF,MAAM,cACJ,mBAAmB,OAAO,aAAa,cAAc,WAAW;AAElE,MAAI,CAAC,YACH;AAIF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;EAIjB,MAAM,EACJ,QAAQ,SACR,SAAS,UACT,GAAG,gBACD;EACJ,MAAM,uBAAuB;GAC3B,GAAG;GACH,GAAI,oBAAoB,SAAY,EAAE,GAAG,EAAE,SAAS,iBAAiB;GACtE;AAGD,iBAAe,QAAQ,SAAS,kBAAkB,UAAU;GAC1D,GAAG;GACH,QAAQ;GACT,CAAC;AAGF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;IAGjD,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"}
+{"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/useHotkeySequences.cjs

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1 @@
+{"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"}

package/dist/useHotkeySequences.d.cts

@@ -0,0 +1,64 @@
+import { UseHotkeySequenceOptions } from "./useHotkeySequence.cjs";
+import { HotkeyCallback, HotkeySequence } from "@tanstack/hotkeys";
+import { MaybeRefOrGetter } from "vue";
+
+//#region src/useHotkeySequences.d.ts
+/**
+ * A single sequence definition for use with `useHotkeySequences`.
+ */
+interface UseHotkeySequenceDefinition {
+  /** Array of hotkey strings that form the sequence */
+  sequence: MaybeRefOrGetter<HotkeySequence>;
+  /** The function to call when the sequence is completed */
+  callback: HotkeyCallback;
+  /** Per-sequence options (merged on top of commonOptions) */
+  options?: MaybeRefOrGetter<UseHotkeySequenceOptions>;
+}
+/**
+ * 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>
+ * ```
+ */
+declare function useHotkeySequences(definitions: MaybeRefOrGetter<Array<UseHotkeySequenceDefinition>>, commonOptions?: MaybeRefOrGetter<UseHotkeySequenceOptions>): void;
+//#endregion
+export { UseHotkeySequenceDefinition, useHotkeySequences };
+//# sourceMappingURL=useHotkeySequences.d.cts.map

package/dist/useHotkeySequences.d.ts

@@ -0,0 +1,64 @@
+import { UseHotkeySequenceOptions } from "./useHotkeySequence.js";
+import { HotkeyCallback, HotkeySequence } from "@tanstack/hotkeys";
+import { MaybeRefOrGetter } from "vue";
+
+//#region src/useHotkeySequences.d.ts
+/**
+ * A single sequence definition for use with `useHotkeySequences`.
+ */
+interface UseHotkeySequenceDefinition {
+  /** Array of hotkey strings that form the sequence */
+  sequence: MaybeRefOrGetter<HotkeySequence>;
+  /** The function to call when the sequence is completed */
+  callback: HotkeyCallback;
+  /** Per-sequence options (merged on top of commonOptions) */
+  options?: MaybeRefOrGetter<UseHotkeySequenceOptions>;
+}
+/**
+ * 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>
+ * ```
+ */
+declare function useHotkeySequences(definitions: MaybeRefOrGetter<Array<UseHotkeySequenceDefinition>>, commonOptions?: MaybeRefOrGetter<UseHotkeySequenceOptions>): void;
+//#endregion
+export { UseHotkeySequenceDefinition, useHotkeySequences };
+//# sourceMappingURL=useHotkeySequences.d.ts.map

package/dist/useHotkeySequences.js

@@ -0,0 +1,140 @@
+import { useDefaultHotkeysOptions } from "./HotkeysProviderContext.js";
+import { formatHotkeySequence, getSequenceManager } from "@tanstack/hotkeys";
+import { onUnmounted, unref, watch } from "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 = useDefaultHotkeysOptions();
+	const manager = getSequenceManager();
+	const registrations = /* @__PURE__ */ new Map();
+	const stopWatcher = 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 = 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 });
+	onUnmounted(() => {
+		stopWatcher();
+		for (const { handle } of registrations.values()) if (handle.isActive) handle.unregister();
+		registrations.clear();
+	});
+}
+function resolveMaybeRefOrGetter(value) {
+	return typeof value === "function" ? value() : unref(value);
+}
+
+//#endregion
+export { useHotkeySequences };
+//# sourceMappingURL=useHotkeySequences.js.map

package/dist/useHotkeySequences.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHotkeySequences.js","names":[],"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,iBAAiB,0BAA0B;CACjD,MAAM,UAAU,oBAAoB;CAEpC,MAAM,gCAAgB,IAAI,KAAiC;CAE3D,MAAM,cAAc,YACZ;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,iBAAiB,qBAAqB,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,mBAAkB;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,GAAG,MAAM,MAAM"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/vue-hotkeys",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Vue adapter for TanStack Hotkeys",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/index.ts

@@ -12,5 +12,6 @@ export * from './useHeldKeys'
 export * from './useHeldKeyCodes'
 export * from './useKeyHold'
 export * from './useHotkeySequence'
+export * from './useHotkeySequences'
 export * from './useHotkeyRecorder'
 export * from './useHotkeySequenceRecorder'

package/src/useHotkey.ts

@@ -106,6 +106,8 @@ export function useHotkey(
   const manager = getHotkeyManager()
 
   let registration: HotkeyRegistrationHandle | null = null
+  let lastHotkeyString: Hotkey | null = null
+  let lastTarget: HTMLElement | Document | Window | null = null
 
   // Watch for changes to reactive dependencies
   const stopWatcher = watch(
@@ -144,18 +146,22 @@ export function useHotkey(
 
       // Resolve target
       const finalTarget =
-        resolvedTarget ?? (typeof document !== 'undefined' ? document : null)
+        resolvedTarget === undefined
+          ? typeof document !== 'undefined'
+            ? document
+            : null
+          : resolvedTarget
 
       if (!finalTarget) {
+        if (registration?.isActive) {
+          registration.unregister()
+          registration = null
+        }
+        lastHotkeyString = null
+        lastTarget = null
         return
       }
 
-      // Unregister previous registration if it exists
-      if (registration?.isActive) {
-        registration.unregister()
-        registration = null
-      }
-
       // Extract options without target (target is handled separately)
       const {
         target: _target,
@@ -167,17 +173,33 @@ export function useHotkey(
         ...(resolvedEnabled === undefined ? {} : { enabled: resolvedEnabled }),
       }
 
-      // Register the hotkey
+      if (
+        registration?.isActive &&
+        lastHotkeyString === hotkeyString &&
+        lastTarget === finalTarget
+      ) {
+        registration.callback = callback
+        registration.setOptions(optionsWithoutTarget)
+        return
+      }
+
+      if (registration?.isActive) {
+        registration.unregister()
+        registration = null
+      }
+
       registration = manager.register(hotkeyString, callback, {
         ...optionsWithoutTarget,
         target: finalTarget,
       })
 
-      // Update callback and options
       if (registration.isActive) {
         registration.callback = callback
         registration.setOptions(optionsWithoutTarget)
       }
+
+      lastHotkeyString = hotkeyString
+      lastTarget = finalTarget
     },
     { immediate: true },
   )

package/src/useHotkeySequence.ts

@@ -1,5 +1,5 @@
 import { onUnmounted, unref, watch } from 'vue'
-import { getSequenceManager } from '@tanstack/hotkeys'
+import { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'
 import { useDefaultHotkeysOptions } from './HotkeysProviderContext'
 import type { MaybeRefOrGetter } from 'vue'
 import type {
@@ -82,6 +82,8 @@ export function useHotkeySequence(
   const manager = getSequenceManager()
 
   let registration: SequenceRegistrationHandle | null = null
+  let lastSequenceKey: string | null = null
+  let lastTarget: HTMLElement | Document | Window | null = null
 
   // Watch for changes to reactive dependencies
   const stopWatcher = watch(
@@ -109,23 +111,24 @@ export function useHotkeySequence(
       }
     },
     ({ resolvedSequence, mergedOptions, resolvedEnabled, resolvedTarget }) => {
-      if (resolvedEnabled === false || resolvedSequence.length === 0) {
-        return
-      }
-
-      // Resolve target
       const finalTarget =
-        resolvedTarget ?? (typeof document !== 'undefined' ? document : null)
+        resolvedTarget === undefined
+          ? typeof document !== 'undefined'
+            ? document
+            : null
+          : resolvedTarget
 
-      if (!finalTarget) {
+      if (resolvedSequence.length === 0 || !finalTarget) {
+        if (registration?.isActive) {
+          registration.unregister()
+          registration = null
+        }
+        lastSequenceKey = null
+        lastTarget = null
         return
       }
 
-      // Unregister previous registration if it exists
-      if (registration?.isActive) {
-        registration.unregister()
-        registration = null
-      }
+      const sequenceKey = formatHotkeySequence(resolvedSequence)
 
       // Extract options without target (target is handled separately)
       const {
@@ -138,17 +141,33 @@ export function useHotkeySequence(
         ...(resolvedEnabled === undefined ? {} : { enabled: resolvedEnabled }),
       }
 
-      // Register the sequence
+      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,
       })
 
-      // Update callback and options
       if (registration.isActive) {
         registration.callback = callback
         registration.setOptions(optionsWithoutTarget)
       }
+
+      lastSequenceKey = sequenceKey
+      lastTarget = finalTarget
     },
     { immediate: true },
   )

package/src/useHotkeySequences.ts

@@ -0,0 +1,221 @@
+import { onUnmounted, unref, watch } from 'vue'
+import { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'
+import { useDefaultHotkeysOptions } from './HotkeysProviderContext'
+import type { UseHotkeySequenceOptions } from './useHotkeySequence'
+import type {
+  HotkeyCallback,
+  HotkeySequence,
+  SequenceRegistrationHandle,
+} from '@tanstack/hotkeys'
+import type { MaybeRefOrGetter } from 'vue'
+
+/**
+ * A single sequence definition for use with `useHotkeySequences`.
+ */
+export interface UseHotkeySequenceDefinition {
+  /** Array of hotkey strings that form the sequence */
+  sequence: MaybeRefOrGetter<HotkeySequence>
+  /** The function to call when the sequence is completed */
+  callback: HotkeyCallback
+  /** Per-sequence options (merged on top of commonOptions) */
+  options?: MaybeRefOrGetter<UseHotkeySequenceOptions>
+}
+
+/**
+ * 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>
+ * ```
+ */
+export function useHotkeySequences(
+  definitions: MaybeRefOrGetter<Array<UseHotkeySequenceDefinition>>,
+  commonOptions: MaybeRefOrGetter<UseHotkeySequenceOptions> = {},
+): void {
+  type RegistrationRecord = {
+    handle: SequenceRegistrationHandle
+    target: Document | HTMLElement | Window
+  }
+
+  const defaultOptions = useDefaultHotkeysOptions()
+  const manager = getSequenceManager()
+
+  const registrations = new Map<string, RegistrationRecord>()
+
+  const stopWatcher = 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,
+        } as UseHotkeySequenceOptions
+
+        const sequenceString = formatHotkeySequence(resolvedSequence)
+
+        const resolvedEnabled =
+          mergedOptions.enabled === undefined
+            ? undefined
+            : resolveMaybeRefOrGetter(mergedOptions.enabled)
+        const resolvedTarget =
+          mergedOptions.target === undefined
+            ? undefined
+            : resolveMaybeRefOrGetter(mergedOptions.target as any)
+
+        return {
+          index: i,
+          resolvedSequence,
+          sequenceString,
+          callback: def.callback,
+          mergedOptions,
+          resolvedEnabled,
+          resolvedTarget,
+        }
+      })
+    },
+    (resolved) => {
+      const nextKeys = new Set<string>()
+      const prepared: Array<{
+        registrationKey: string
+        entry: (typeof resolved)[number]
+        finalTarget: Document | HTMLElement | Window
+      }> = []
+
+      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 === undefined
+              ? {}
+              : { 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 === undefined
+            ? {}
+            : { enabled: entry.resolvedEnabled }),
+        }
+
+        const handle = manager.register(
+          entry.resolvedSequence,
+          entry.callback,
+          {
+            ...optionsWithoutTarget,
+            target: finalTarget,
+          },
+        )
+        registrations.set(registrationKey, { handle, target: finalTarget })
+      }
+    },
+    { immediate: true },
+  )
+
+  onUnmounted(() => {
+    stopWatcher()
+    for (const { handle } of registrations.values()) {
+      if (handle.isActive) {
+        handle.unregister()
+      }
+    }
+    registrations.clear()
+  })
+}
+
+function resolveMaybeRefOrGetter<T>(value: MaybeRefOrGetter<T>): T {
+  return typeof value === 'function' ? (value as () => T)() : unref(value)
+}