@tanstack/vue-hotkeys 0.11.0 → 0.12.1

package/dist/useHotkeySequences.d.cts

@@ -1,64 +0,0 @@
-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.js.map

@@ -1 +0,0 @@
-{"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/dist/useHotkeys.cjs

@@ -1,139 +0,0 @@
-const require_HotkeysProviderContext = require('./HotkeysProviderContext.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let vue = require("vue");
-
-//#region src/useHotkeys.ts
-/**
-* Vue composable for registering multiple keyboard hotkeys at once.
-*
-* Uses the singleton HotkeyManager for efficient event handling.
-* Accepts a dynamic array of hotkey definitions, making it safe to use
-* with variable-length lists.
-*
-* Options are merged in this order:
-* HotkeysProvider defaults < commonOptions < per-definition options
-*
-* @param hotkeys - Array of hotkey definitions to register, or a getter/ref
-* @param commonOptions - Shared options applied to all hotkeys (overridden by per-definition options)
-*
-* @example
-* ```vue
-* <script setup>
-* import { useHotkeys } from '@tanstack/vue-hotkeys'
-*
-* useHotkeys([
-*   { hotkey: 'Mod+S', callback: () => save() },
-*   { hotkey: 'Mod+Z', callback: () => undo() },
-*   { hotkey: 'Escape', callback: () => close() },
-* ])
-* <\/script>
-* ```
-*
-* @example
-* ```vue
-* <script setup>
-* import { computed } from 'vue'
-* import { useHotkeys } from '@tanstack/vue-hotkeys'
-*
-* const items = computed(() => [...])
-* // Dynamic hotkeys from reactive data
-* useHotkeys(
-*   () => items.value.map((item) => ({
-*     hotkey: item.shortcut,
-*     callback: item.action,
-*     options: { enabled: item.enabled },
-*   })),
-*   { preventDefault: true },
-* )
-* <\/script>
-* ```
-*/
-function useHotkeys(hotkeys, commonOptions = {}) {
-	const defaultOptions = require_HotkeysProviderContext.useDefaultHotkeysOptions();
-	const manager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	const registrations = /* @__PURE__ */ new Map();
-	const stopWatcher = (0, vue.watch)(() => {
-		const resolvedHotkeys = resolveMaybeRefOrGetter(hotkeys);
-		const resolvedCommonOptions = resolveMaybeRefOrGetter(commonOptions);
-		return resolvedHotkeys.map((def, i) => {
-			const resolvedHotkey = resolveMaybeRefOrGetter(def.hotkey);
-			const resolvedDefOptions = def.options ? resolveMaybeRefOrGetter(def.options) : {};
-			const mergedOptions = {
-				...defaultOptions.hotkey,
-				...resolvedCommonOptions,
-				...resolvedDefOptions
-			};
-			const hotkeyString = (0, _tanstack_hotkeys.normalizeRegisterableHotkey)(resolvedHotkey, mergedOptions.platform ?? (0, _tanstack_hotkeys.detectPlatform)());
-			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,
-				hotkeyString,
-				callback: def.callback,
-				mergedOptions,
-				resolvedEnabled,
-				resolvedTarget
-			};
-		});
-	}, (resolved) => {
-		const nextKeys = /* @__PURE__ */ new Set();
-		const prepared = [];
-		for (const entry of resolved) {
-			const finalTarget = entry.resolvedTarget ?? (typeof document !== "undefined" ? document : null);
-			if (!finalTarget) continue;
-			const registrationKey = `${entry.index}:${entry.hotkeyString}`;
-			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.hotkeyString, 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.useHotkeys = useHotkeys;
-//# sourceMappingURL=useHotkeys.cjs.map

package/dist/useHotkeys.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeys.cjs","names":["useDefaultHotkeysOptions"],"sources":["../src/useHotkeys.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport {\n  detectPlatform,\n  getHotkeyManager,\n  normalizeRegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type { UseHotkeyOptions } from './useHotkey'\nimport type {\n  HotkeyCallback,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport type { MaybeRefOrGetter } from 'vue'\n\n/**\n * A single hotkey definition for use with `useHotkeys`.\n */\nexport interface UseHotkeyDefinition {\n  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */\n  hotkey: MaybeRefOrGetter<RegisterableHotkey>\n  /** The function to call when the hotkey is pressed */\n  callback: HotkeyCallback\n  /** Per-hotkey options (merged on top of commonOptions) */\n  options?: MaybeRefOrGetter<UseHotkeyOptions>\n}\n\n/**\n * Vue composable for registering multiple keyboard hotkeys at once.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * Accepts a dynamic array of hotkey definitions, making it safe to use\n * with variable-length lists.\n *\n * Options are merged in this order:\n * HotkeysProvider defaults < commonOptions < per-definition options\n *\n * @param hotkeys - Array of hotkey definitions to register, or a getter/ref\n * @param commonOptions - Shared options applied to all hotkeys (overridden by per-definition options)\n *\n * @example\n * ```vue\n * <script setup>\n * import { useHotkeys } from '@tanstack/vue-hotkeys'\n *\n * useHotkeys([\n *   { hotkey: 'Mod+S', callback: () => save() },\n *   { hotkey: 'Mod+Z', callback: () => undo() },\n *   { hotkey: 'Escape', callback: () => close() },\n * ])\n * </script>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { computed } from 'vue'\n * import { useHotkeys } from '@tanstack/vue-hotkeys'\n *\n * const items = computed(() => [...])\n * // Dynamic hotkeys from reactive data\n * useHotkeys(\n *   () => items.value.map((item) => ({\n *     hotkey: item.shortcut,\n *     callback: item.action,\n *     options: { enabled: item.enabled },\n *   })),\n *   { preventDefault: true },\n * )\n * </script>\n * ```\n */\nexport function useHotkeys(\n  hotkeys: MaybeRefOrGetter<Array<UseHotkeyDefinition>>,\n  commonOptions: MaybeRefOrGetter<UseHotkeyOptions> = {},\n): void {\n  type RegistrationRecord = {\n    handle: HotkeyRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  const registrations = new Map<string, RegistrationRecord>()\n\n  const stopWatcher = watch(\n    () => {\n      const resolvedHotkeys = resolveMaybeRefOrGetter(hotkeys)\n      const resolvedCommonOptions = resolveMaybeRefOrGetter(commonOptions)\n\n      return resolvedHotkeys.map((def, i) => {\n        const resolvedHotkey = resolveMaybeRefOrGetter(def.hotkey)\n        const resolvedDefOptions = def.options\n          ? resolveMaybeRefOrGetter(def.options)\n          : {}\n\n        const mergedOptions = {\n          ...defaultOptions.hotkey,\n          ...resolvedCommonOptions,\n          ...resolvedDefOptions,\n        } as UseHotkeyOptions\n\n        const platform = mergedOptions.platform ?? detectPlatform()\n        const hotkeyString = normalizeRegisterableHotkey(\n          resolvedHotkey,\n          platform,\n        )\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          hotkeyString,\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        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.hotkeyString}`\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(entry.hotkeyString, entry.callback, {\n          ...optionsWithoutTarget,\n          target: finalTarget,\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,SAAgB,WACd,SACA,gBAAoD,EAAE,EAChD;CAMN,MAAM,iBAAiBA,yDAA0B;CACjD,MAAM,mDAA4B;CAElC,MAAM,gCAAgB,IAAI,KAAiC;CAE3D,MAAM,mCACE;EACJ,MAAM,kBAAkB,wBAAwB,QAAQ;EACxD,MAAM,wBAAwB,wBAAwB,cAAc;AAEpE,SAAO,gBAAgB,KAAK,KAAK,MAAM;GACrC,MAAM,iBAAiB,wBAAwB,IAAI,OAAO;GAC1D,MAAM,qBAAqB,IAAI,UAC3B,wBAAwB,IAAI,QAAQ,GACpC,EAAE;GAEN,MAAM,gBAAgB;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;GAGD,MAAM,kEACJ,gBAFe,cAAc,mDAA4B,CAI1D;GAED,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,UAAU,IAAI;IACd;IACA;IACA;IACD;IACD;KAEH,aAAa;EACZ,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAID,EAAE;AAEP,OAAK,MAAM,SAAS,UAAU;GAC5B,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,SAAS,MAAM,cAAc,MAAM,UAAU;IAClE,GAAG;IACH,QAAQ;IACT,CAAC;AACF,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/useHotkeys.d.cts

@@ -1,65 +0,0 @@
-import { UseHotkeyOptions } from "./useHotkey.cjs";
-import { HotkeyCallback, RegisterableHotkey } from "@tanstack/hotkeys";
-import { MaybeRefOrGetter } from "vue";
-
-//#region src/useHotkeys.d.ts
-/**
- * A single hotkey definition for use with `useHotkeys`.
- */
-interface UseHotkeyDefinition {
-  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */
-  hotkey: MaybeRefOrGetter<RegisterableHotkey>;
-  /** The function to call when the hotkey is pressed */
-  callback: HotkeyCallback;
-  /** Per-hotkey options (merged on top of commonOptions) */
-  options?: MaybeRefOrGetter<UseHotkeyOptions>;
-}
-/**
- * Vue composable for registering multiple keyboard hotkeys at once.
- *
- * Uses the singleton HotkeyManager for efficient event handling.
- * Accepts a dynamic array of hotkey definitions, making it safe to use
- * with variable-length lists.
- *
- * Options are merged in this order:
- * HotkeysProvider defaults < commonOptions < per-definition options
- *
- * @param hotkeys - Array of hotkey definitions to register, or a getter/ref
- * @param commonOptions - Shared options applied to all hotkeys (overridden by per-definition options)
- *
- * @example
- * ```vue
- * <script setup>
- * import { useHotkeys } from '@tanstack/vue-hotkeys'
- *
- * useHotkeys([
- *   { hotkey: 'Mod+S', callback: () => save() },
- *   { hotkey: 'Mod+Z', callback: () => undo() },
- *   { hotkey: 'Escape', callback: () => close() },
- * ])
- * </script>
- * ```
- *
- * @example
- * ```vue
- * <script setup>
- * import { computed } from 'vue'
- * import { useHotkeys } from '@tanstack/vue-hotkeys'
- *
- * const items = computed(() => [...])
- * // Dynamic hotkeys from reactive data
- * useHotkeys(
- *   () => items.value.map((item) => ({
- *     hotkey: item.shortcut,
- *     callback: item.action,
- *     options: { enabled: item.enabled },
- *   })),
- *   { preventDefault: true },
- * )
- * </script>
- * ```
- */
-declare function useHotkeys(hotkeys: MaybeRefOrGetter<Array<UseHotkeyDefinition>>, commonOptions?: MaybeRefOrGetter<UseHotkeyOptions>): void;
-//#endregion
-export { UseHotkeyDefinition, useHotkeys };
-//# sourceMappingURL=useHotkeys.d.cts.map

package/dist/useHotkeys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeys.js","names":[],"sources":["../src/useHotkeys.ts"],"sourcesContent":["import { onUnmounted, unref, watch } from 'vue'\nimport {\n  detectPlatform,\n  getHotkeyManager,\n  normalizeRegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProviderContext'\nimport type { UseHotkeyOptions } from './useHotkey'\nimport type {\n  HotkeyCallback,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport type { MaybeRefOrGetter } from 'vue'\n\n/**\n * A single hotkey definition for use with `useHotkeys`.\n */\nexport interface UseHotkeyDefinition {\n  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */\n  hotkey: MaybeRefOrGetter<RegisterableHotkey>\n  /** The function to call when the hotkey is pressed */\n  callback: HotkeyCallback\n  /** Per-hotkey options (merged on top of commonOptions) */\n  options?: MaybeRefOrGetter<UseHotkeyOptions>\n}\n\n/**\n * Vue composable for registering multiple keyboard hotkeys at once.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * Accepts a dynamic array of hotkey definitions, making it safe to use\n * with variable-length lists.\n *\n * Options are merged in this order:\n * HotkeysProvider defaults < commonOptions < per-definition options\n *\n * @param hotkeys - Array of hotkey definitions to register, or a getter/ref\n * @param commonOptions - Shared options applied to all hotkeys (overridden by per-definition options)\n *\n * @example\n * ```vue\n * <script setup>\n * import { useHotkeys } from '@tanstack/vue-hotkeys'\n *\n * useHotkeys([\n *   { hotkey: 'Mod+S', callback: () => save() },\n *   { hotkey: 'Mod+Z', callback: () => undo() },\n *   { hotkey: 'Escape', callback: () => close() },\n * ])\n * </script>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { computed } from 'vue'\n * import { useHotkeys } from '@tanstack/vue-hotkeys'\n *\n * const items = computed(() => [...])\n * // Dynamic hotkeys from reactive data\n * useHotkeys(\n *   () => items.value.map((item) => ({\n *     hotkey: item.shortcut,\n *     callback: item.action,\n *     options: { enabled: item.enabled },\n *   })),\n *   { preventDefault: true },\n * )\n * </script>\n * ```\n */\nexport function useHotkeys(\n  hotkeys: MaybeRefOrGetter<Array<UseHotkeyDefinition>>,\n  commonOptions: MaybeRefOrGetter<UseHotkeyOptions> = {},\n): void {\n  type RegistrationRecord = {\n    handle: HotkeyRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  const registrations = new Map<string, RegistrationRecord>()\n\n  const stopWatcher = watch(\n    () => {\n      const resolvedHotkeys = resolveMaybeRefOrGetter(hotkeys)\n      const resolvedCommonOptions = resolveMaybeRefOrGetter(commonOptions)\n\n      return resolvedHotkeys.map((def, i) => {\n        const resolvedHotkey = resolveMaybeRefOrGetter(def.hotkey)\n        const resolvedDefOptions = def.options\n          ? resolveMaybeRefOrGetter(def.options)\n          : {}\n\n        const mergedOptions = {\n          ...defaultOptions.hotkey,\n          ...resolvedCommonOptions,\n          ...resolvedDefOptions,\n        } as UseHotkeyOptions\n\n        const platform = mergedOptions.platform ?? detectPlatform()\n        const hotkeyString = normalizeRegisterableHotkey(\n          resolvedHotkey,\n          platform,\n        )\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          hotkeyString,\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        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.hotkeyString}`\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(entry.hotkeyString, entry.callback, {\n          ...optionsWithoutTarget,\n          target: finalTarget,\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,SAAgB,WACd,SACA,gBAAoD,EAAE,EAChD;CAMN,MAAM,iBAAiB,0BAA0B;CACjD,MAAM,UAAU,kBAAkB;CAElC,MAAM,gCAAgB,IAAI,KAAiC;CAE3D,MAAM,cAAc,YACZ;EACJ,MAAM,kBAAkB,wBAAwB,QAAQ;EACxD,MAAM,wBAAwB,wBAAwB,cAAc;AAEpE,SAAO,gBAAgB,KAAK,KAAK,MAAM;GACrC,MAAM,iBAAiB,wBAAwB,IAAI,OAAO;GAC1D,MAAM,qBAAqB,IAAI,UAC3B,wBAAwB,IAAI,QAAQ,GACpC,EAAE;GAEN,MAAM,gBAAgB;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;GAGD,MAAM,eAAe,4BACnB,gBAFe,cAAc,YAAY,gBAAgB,CAI1D;GAED,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,UAAU,IAAI;IACd;IACA;IACA;IACD;IACD;KAEH,aAAa;EACZ,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAID,EAAE;AAEP,OAAK,MAAM,SAAS,UAAU;GAC5B,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,SAAS,MAAM,cAAc,MAAM,UAAU;IAClE,GAAG;IACH,QAAQ;IACT,CAAC;AACF,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/dist/useKeyHold.cjs

@@ -1,60 +0,0 @@
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let vue = require("vue");
-let _tanstack_vue_store = require("@tanstack/vue-store");
-
-//#region src/useKeyHold.ts
-/**
-* Vue composable that returns a reactive ref indicating whether a specific key is currently being held.
-*
-* This composable uses `useSelector` from `@tanstack/vue-store` to subscribe
-* to the global KeyStateTracker and uses a selector to determine if
-* the specified key is held.
-*
-* @param key - The key to check (e.g., 'Shift', 'Control', 'A')
-* @returns Reactive ref that is true if the key is currently held down
-*
-* @example
-* ```vue
-* <script setup>
-* import { useKeyHold } from '@tanstack/vue-hotkeys'
-*
-* const isShiftHeld = useKeyHold('Shift')
-* <\/script>
-*
-* <template>
-*   <div :style="{ opacity: isShiftHeld ? 1 : 0.5 }">
-*     {{ isShiftHeld ? 'Shift is pressed!' : 'Press Shift' }}
-*   </div>
-* </template>
-* ```
-*
-* @example
-* ```vue
-* <script setup>
-* import { useKeyHold } from '@tanstack/vue-hotkeys'
-*
-* const ctrl = useKeyHold('Control')
-* const shift = useKeyHold('Shift')
-* const alt = useKeyHold('Alt')
-* <\/script>
-*
-* <template>
-*   <div>
-*     <span :style="{ opacity: ctrl ? 1 : 0.3 }">Ctrl</span>
-*     <span :style="{ opacity: shift ? 1 : 0.3 }">Shift</span>
-*     <span :style="{ opacity: alt ? 1 : 0.3 }">Alt</span>
-*   </div>
-* </template>
-* ```
-*/
-function useKeyHold(key) {
-	return (0, _tanstack_vue_store.useSelector)((0, _tanstack_hotkeys.getKeyStateTracker)().store, (state) => {
-		const keyValue = (0, vue.unref)(key);
-		const normalizedKey = (typeof keyValue === "string" ? keyValue : String(keyValue)).toLowerCase();
-		return state.heldKeys.some((heldKey) => heldKey.toLowerCase() === normalizedKey);
-	});
-}
-
-//#endregion
-exports.useKeyHold = useKeyHold;
-//# sourceMappingURL=useKeyHold.cjs.map

package/dist/useKeyHold.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useKeyHold.cjs","names":[],"sources":["../src/useKeyHold.ts"],"sourcesContent":["import { useSelector } from '@tanstack/vue-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\nimport { unref } from 'vue'\nimport type { MaybeRefOrGetter, Ref } from 'vue'\nimport type { IndividualKey } from '@tanstack/hotkeys'\n\n/**\n * Vue composable that returns a reactive ref indicating whether a specific key is currently being held.\n *\n * This composable uses `useSelector` from `@tanstack/vue-store` to subscribe\n * to the global KeyStateTracker and uses a selector to determine if\n * the specified key is held.\n *\n * @param key - The key to check (e.g., 'Shift', 'Control', 'A')\n * @returns Reactive ref that is true if the key is currently held down\n *\n * @example\n * ```vue\n * <script setup>\n * import { useKeyHold } from '@tanstack/vue-hotkeys'\n *\n * const isShiftHeld = useKeyHold('Shift')\n * </script>\n *\n * <template>\n *   <div :style=\"{ opacity: isShiftHeld ? 1 : 0.5 }\">\n *     {{ isShiftHeld ? 'Shift is pressed!' : 'Press Shift' }}\n *   </div>\n * </template>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { useKeyHold } from '@tanstack/vue-hotkeys'\n *\n * const ctrl = useKeyHold('Control')\n * const shift = useKeyHold('Shift')\n * const alt = useKeyHold('Alt')\n * </script>\n *\n * <template>\n *   <div>\n *     <span :style=\"{ opacity: ctrl ? 1 : 0.3 }\">Ctrl</span>\n *     <span :style=\"{ opacity: shift ? 1 : 0.3 }\">Shift</span>\n *     <span :style=\"{ opacity: alt ? 1 : 0.3 }\">Alt</span>\n *   </div>\n * </template>\n * ```\n */\nexport function useKeyHold(key: MaybeRefOrGetter<IndividualKey>): Ref<boolean> {\n  const tracker = getKeyStateTracker()\n\n  const isHeld = useSelector(tracker.store, (state) => {\n    const keyValue = unref(key)\n    const normalizedKey = (\n      typeof keyValue === 'string' ? keyValue : String(keyValue)\n    ).toLowerCase()\n    return state.heldKeys.some(\n      (heldKey) => heldKey.toLowerCase() === normalizedKey,\n    )\n  })\n\n  return isHeld as Ref<boolean>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,WAAW,KAAoD;AAa7E,wFAZoC,CAED,QAAQ,UAAU;EACnD,MAAM,0BAAiB,IAAI;EAC3B,MAAM,iBACJ,OAAO,aAAa,WAAW,WAAW,OAAO,SAAS,EAC1D,aAAa;AACf,SAAO,MAAM,SAAS,MACnB,YAAY,QAAQ,aAAa,KAAK,cACxC;GACD"}

package/dist/useKeyHold.d.cts

@@ -1,52 +0,0 @@
-import { IndividualKey } from "@tanstack/hotkeys";
-import { MaybeRefOrGetter, Ref } from "vue";
-
-//#region src/useKeyHold.d.ts
-/**
- * Vue composable that returns a reactive ref indicating whether a specific key is currently being held.
- *
- * This composable uses `useSelector` from `@tanstack/vue-store` to subscribe
- * to the global KeyStateTracker and uses a selector to determine if
- * the specified key is held.
- *
- * @param key - The key to check (e.g., 'Shift', 'Control', 'A')
- * @returns Reactive ref that is true if the key is currently held down
- *
- * @example
- * ```vue
- * <script setup>
- * import { useKeyHold } from '@tanstack/vue-hotkeys'
- *
- * const isShiftHeld = useKeyHold('Shift')
- * </script>
- *
- * <template>
- *   <div :style="{ opacity: isShiftHeld ? 1 : 0.5 }">
- *     {{ isShiftHeld ? 'Shift is pressed!' : 'Press Shift' }}
- *   </div>
- * </template>
- * ```
- *
- * @example
- * ```vue
- * <script setup>
- * import { useKeyHold } from '@tanstack/vue-hotkeys'
- *
- * const ctrl = useKeyHold('Control')
- * const shift = useKeyHold('Shift')
- * const alt = useKeyHold('Alt')
- * </script>
- *
- * <template>
- *   <div>
- *     <span :style="{ opacity: ctrl ? 1 : 0.3 }">Ctrl</span>
- *     <span :style="{ opacity: shift ? 1 : 0.3 }">Shift</span>
- *     <span :style="{ opacity: alt ? 1 : 0.3 }">Alt</span>
- *   </div>
- * </template>
- * ```
- */
-declare function useKeyHold(key: MaybeRefOrGetter<IndividualKey>): Ref<boolean>;
-//#endregion
-export { useKeyHold };
-//# sourceMappingURL=useKeyHold.d.cts.map

package/dist/useKeyHold.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useKeyHold.js","names":[],"sources":["../src/useKeyHold.ts"],"sourcesContent":["import { useSelector } from '@tanstack/vue-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\nimport { unref } from 'vue'\nimport type { MaybeRefOrGetter, Ref } from 'vue'\nimport type { IndividualKey } from '@tanstack/hotkeys'\n\n/**\n * Vue composable that returns a reactive ref indicating whether a specific key is currently being held.\n *\n * This composable uses `useSelector` from `@tanstack/vue-store` to subscribe\n * to the global KeyStateTracker and uses a selector to determine if\n * the specified key is held.\n *\n * @param key - The key to check (e.g., 'Shift', 'Control', 'A')\n * @returns Reactive ref that is true if the key is currently held down\n *\n * @example\n * ```vue\n * <script setup>\n * import { useKeyHold } from '@tanstack/vue-hotkeys'\n *\n * const isShiftHeld = useKeyHold('Shift')\n * </script>\n *\n * <template>\n *   <div :style=\"{ opacity: isShiftHeld ? 1 : 0.5 }\">\n *     {{ isShiftHeld ? 'Shift is pressed!' : 'Press Shift' }}\n *   </div>\n * </template>\n * ```\n *\n * @example\n * ```vue\n * <script setup>\n * import { useKeyHold } from '@tanstack/vue-hotkeys'\n *\n * const ctrl = useKeyHold('Control')\n * const shift = useKeyHold('Shift')\n * const alt = useKeyHold('Alt')\n * </script>\n *\n * <template>\n *   <div>\n *     <span :style=\"{ opacity: ctrl ? 1 : 0.3 }\">Ctrl</span>\n *     <span :style=\"{ opacity: shift ? 1 : 0.3 }\">Shift</span>\n *     <span :style=\"{ opacity: alt ? 1 : 0.3 }\">Alt</span>\n *   </div>\n * </template>\n * ```\n */\nexport function useKeyHold(key: MaybeRefOrGetter<IndividualKey>): Ref<boolean> {\n  const tracker = getKeyStateTracker()\n\n  const isHeld = useSelector(tracker.store, (state) => {\n    const keyValue = unref(key)\n    const normalizedKey = (\n      typeof keyValue === 'string' ? keyValue : String(keyValue)\n    ).toLowerCase()\n    return state.heldKeys.some(\n      (heldKey) => heldKey.toLowerCase() === normalizedKey,\n    )\n  })\n\n  return isHeld as Ref<boolean>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,WAAW,KAAoD;AAa7E,QAVe,YAFC,oBAAoB,CAED,QAAQ,UAAU;EACnD,MAAM,WAAW,MAAM,IAAI;EAC3B,MAAM,iBACJ,OAAO,aAAa,WAAW,WAAW,OAAO,SAAS,EAC1D,aAAa;AACf,SAAO,MAAM,SAAS,MACnB,YAAY,QAAQ,aAAa,KAAK,cACxC;GACD"}

package/src/HotkeysProvider.tsx

@@ -1,29 +0,0 @@
-import { defineComponent } from 'vue'
-import { provideHotkeysContext } from './HotkeysProviderContext'
-import type { HotkeysProviderOptions } from './HotkeysProviderContext'
-
-/**
- * Vue component that provides default options for hotkeys context.
- *
- * @example
- * ```vue
- * <template>
- *   <HotkeysProvider :defaultOptions="{ hotkey: { enabled: true } }">
- *     <App />
- *   </HotkeysProvider>
- * </template>
- * ```
- */
-export const HotkeysProvider = defineComponent({
-  name: 'HotkeysProvider',
-  props: {
-    defaultOptions: {
-      type: Object as () => HotkeysProviderOptions,
-      default: undefined,
-    },
-  },
-  setup(props, { slots }) {
-    provideHotkeysContext(props.defaultOptions)
-    return () => slots.default?.()
-  },
-})

package/src/HotkeysProviderContext.ts

@@ -1,41 +0,0 @@
-import { inject, provide } from 'vue'
-import type { InjectionKey } from 'vue'
-import type {
-  HotkeyRecorderOptions,
-  HotkeySequenceRecorderOptions,
-} from '@tanstack/hotkeys'
-import type { UseHotkeyOptions } from './useHotkey'
-import type { UseHotkeySequenceOptions } from './useHotkeySequence'
-
-export interface HotkeysProviderOptions {
-  hotkey?: Partial<UseHotkeyOptions>
-  hotkeyRecorder?: Partial<HotkeyRecorderOptions>
-  hotkeySequenceRecorder?: Partial<HotkeySequenceRecorderOptions>
-  hotkeySequence?: Partial<UseHotkeySequenceOptions>
-}
-
-interface HotkeysContextValue {
-  defaultOptions: HotkeysProviderOptions
-}
-
-const HotkeysContext: InjectionKey<HotkeysContextValue> =
-  Symbol('HotkeysContext')
-
-const DEFAULT_OPTIONS: HotkeysProviderOptions = {}
-
-export function provideHotkeysContext(defaultOptions?: HotkeysProviderOptions) {
-  const contextValue: HotkeysContextValue = {
-    defaultOptions: defaultOptions ?? DEFAULT_OPTIONS,
-  }
-
-  provide(HotkeysContext, contextValue)
-}
-
-export function useHotkeysContext() {
-  return inject(HotkeysContext, null)
-}
-
-export function useDefaultHotkeysOptions() {
-  const context = inject(HotkeysContext, null)
-  return context?.defaultOptions ?? {}
-}

package/src/index.ts

@@ -1,19 +0,0 @@
-// Re-export everything from the core package
-export * from '@tanstack/hotkeys'
-
-// Provider
-export * from './HotkeysProvider'
-export * from './HotkeysProviderContext'
-
-// Vue-specific composables
-export * from './useHotkey'
-export * from './useHotkeys'
-export * from './useHeldKeys'
-export * from './useHeldKeyCodes'
-export * from './useKeyHold'
-export * from './useHotkeySequence'
-export * from './useHotkeySequences'
-export * from './useHotkeyRecorder'
-export * from './useHotkeyRegistrations'
-export * from './useHotkeySequenceRecorder'
-export * from './useHotkeyHint'

package/src/useHeldKeyCodes.ts

@@ -1,34 +0,0 @@
-import { useSelector } from '@tanstack/vue-store'
-import { getKeyStateTracker } from '@tanstack/hotkeys'
-import type { Ref } from 'vue'
-
-/**
- * Vue composable that returns a reactive ref mapping currently held key names to their physical `event.code` values.
- *
- * This is useful for debugging which physical key was pressed (e.g. distinguishing
- * left vs right Shift via "ShiftLeft" / "ShiftRight").
- *
- * @returns Reactive ref containing record mapping normalized key names to their `event.code` values
- *
- * @example
- * ```vue
- * <script setup>
- * import { useHeldKeys, useHeldKeyCodes } from '@tanstack/vue-hotkeys'
- *
- * const heldKeys = useHeldKeys()
- * const heldCodes = useHeldKeyCodes()
- * </script>
- *
- * <template>
- *   <div>
- *     <kbd v-for="key in heldKeys" :key="key">
- *       {{ key }} <small>{{ heldCodes[key] }}</small>
- *     </kbd>
- *   </div>
- * </template>
- * ```
- */
-export function useHeldKeyCodes(): Ref<Record<string, string>> {
-  const tracker = getKeyStateTracker()
-  return useSelector(tracker.store, (state) => state.heldCodes)
-}

package/src/useHeldKeys.ts

@@ -1,32 +0,0 @@
-import { useSelector } from '@tanstack/vue-store'
-import { getKeyStateTracker } from '@tanstack/hotkeys'
-import type { Ref } from 'vue'
-
-/**
- * Vue composable that returns a reactive ref of currently held keyboard keys.
- *
- * This composable uses `useSelector` from `@tanstack/vue-store` to subscribe
- * to the global KeyStateTracker and updates whenever keys are pressed
- * or released.
- *
- * @returns Reactive ref containing array of currently held key names
- *
- * @example
- * ```vue
- * <script setup>
- * import { useHeldKeys } from '@tanstack/vue-hotkeys'
- *
- * const heldKeys = useHeldKeys()
- * </script>
- *
- * <template>
- *   <div>
- *     Currently pressed: {{ heldKeys.join(' + ') || 'None' }}
- *   </div>
- * </template>
- * ```
- */
-export function useHeldKeys(): Ref<Array<string>> {
-  const tracker = getKeyStateTracker()
-  return useSelector(tracker.store, (state) => state.heldKeys)
-}