@tanstack/angular-hotkeys 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -3,6 +3,7 @@ const require_hotkeys_provider = require('./hotkeys-provider.cjs');
 const require_injectHotkey = require('./injectHotkey.cjs');
 const require_injectHotkeys = require('./injectHotkeys.cjs');
 const require_injectHotkeySequence = require('./injectHotkeySequence.cjs');
+const require_injectHotkeySequences = require('./injectHotkeySequences.cjs');
 const require_injectHeldKeys = require('./injectHeldKeys.cjs');
 const require_injectHeldKeyCodes = require('./injectHeldKeyCodes.cjs');
 const require_injectKeyHold = require('./injectKeyHold.cjs');
@@ -17,6 +18,7 @@ exports.injectHotkey = require_injectHotkey.injectHotkey;
 exports.injectHotkeyRecorder = require_injectHotkeyRecorder.injectHotkeyRecorder;
 exports.injectHotkeySequence = require_injectHotkeySequence.injectHotkeySequence;
 exports.injectHotkeySequenceRecorder = require_injectHotkeySequenceRecorder.injectHotkeySequenceRecorder;
+exports.injectHotkeySequences = require_injectHotkeySequences.injectHotkeySequences;
 exports.injectHotkeys = require_injectHotkeys.injectHotkeys;
 exports.injectHotkeysContext = require_hotkeys_provider.injectHotkeysContext;
 exports.injectKeyHold = require_injectKeyHold.injectKeyHold;

package/dist/index.d.cts

@@ -2,10 +2,11 @@ import { InjectHotkeyOptions, injectHotkey } from "./injectHotkey.cjs";
 import { InjectHotkeySequenceOptions, injectHotkeySequence } from "./injectHotkeySequence.cjs";
 import { HOTKEYS_INJECTION_TOKEN, HotkeysContextValue, HotkeysProviderOptions, injectDefaultHotkeysOptions, injectHotkeysContext, provideHotkeys } from "./hotkeys-provider.cjs";
 import { InjectHotkeyDefinition, injectHotkeys } from "./injectHotkeys.cjs";
+import { InjectHotkeySequenceDefinition, injectHotkeySequences } from "./injectHotkeySequences.cjs";
 import { injectHeldKeys } from "./injectHeldKeys.cjs";
 import { injectHeldKeyCodes } from "./injectHeldKeyCodes.cjs";
 import { injectKeyHold } from "./injectKeyHold.cjs";
 import { AngularHotkeyRecorder, injectHotkeyRecorder } from "./injectHotkeyRecorder.cjs";
 import { AngularHotkeySequenceRecorder, injectHotkeySequenceRecorder } from "./injectHotkeySequenceRecorder.cjs";
 export * from "@tanstack/hotkeys";
-export { AngularHotkeyRecorder, AngularHotkeySequenceRecorder, HOTKEYS_INJECTION_TOKEN, HotkeysContextValue, HotkeysProviderOptions, InjectHotkeyDefinition, InjectHotkeyOptions, InjectHotkeySequenceOptions, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeySequenceRecorder, injectHotkeys, injectHotkeysContext, injectKeyHold, provideHotkeys };
+export { AngularHotkeyRecorder, AngularHotkeySequenceRecorder, HOTKEYS_INJECTION_TOKEN, HotkeysContextValue, HotkeysProviderOptions, InjectHotkeyDefinition, InjectHotkeyOptions, InjectHotkeySequenceDefinition, InjectHotkeySequenceOptions, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeySequenceRecorder, injectHotkeySequences, injectHotkeys, injectHotkeysContext, injectKeyHold, provideHotkeys };

package/dist/index.d.ts

@@ -2,10 +2,11 @@ import { InjectHotkeyOptions, injectHotkey } from "./injectHotkey.js";
 import { InjectHotkeySequenceOptions, injectHotkeySequence } from "./injectHotkeySequence.js";
 import { HOTKEYS_INJECTION_TOKEN, HotkeysContextValue, HotkeysProviderOptions, injectDefaultHotkeysOptions, injectHotkeysContext, provideHotkeys } from "./hotkeys-provider.js";
 import { InjectHotkeyDefinition, injectHotkeys } from "./injectHotkeys.js";
+import { InjectHotkeySequenceDefinition, injectHotkeySequences } from "./injectHotkeySequences.js";
 import { injectHeldKeys } from "./injectHeldKeys.js";
 import { injectHeldKeyCodes } from "./injectHeldKeyCodes.js";
 import { injectKeyHold } from "./injectKeyHold.js";
 import { AngularHotkeyRecorder, injectHotkeyRecorder } from "./injectHotkeyRecorder.js";
 import { AngularHotkeySequenceRecorder, injectHotkeySequenceRecorder } from "./injectHotkeySequenceRecorder.js";
 export * from "@tanstack/hotkeys";
-export { AngularHotkeyRecorder, AngularHotkeySequenceRecorder, HOTKEYS_INJECTION_TOKEN, HotkeysContextValue, HotkeysProviderOptions, InjectHotkeyDefinition, InjectHotkeyOptions, InjectHotkeySequenceOptions, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeySequenceRecorder, injectHotkeys, injectHotkeysContext, injectKeyHold, provideHotkeys };
+export { AngularHotkeyRecorder, AngularHotkeySequenceRecorder, HOTKEYS_INJECTION_TOKEN, HotkeysContextValue, HotkeysProviderOptions, InjectHotkeyDefinition, InjectHotkeyOptions, InjectHotkeySequenceDefinition, InjectHotkeySequenceOptions, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeySequenceRecorder, injectHotkeySequences, injectHotkeys, injectHotkeysContext, injectKeyHold, provideHotkeys };

package/dist/index.js

@@ -2,6 +2,7 @@ import { HOTKEYS_INJECTION_TOKEN, injectDefaultHotkeysOptions, injectHotkeysCont
 import { injectHotkey } from "./injectHotkey.js";
 import { injectHotkeys } from "./injectHotkeys.js";
 import { injectHotkeySequence } from "./injectHotkeySequence.js";
+import { injectHotkeySequences } from "./injectHotkeySequences.js";
 import { injectHeldKeys } from "./injectHeldKeys.js";
 import { injectHeldKeyCodes } from "./injectHeldKeyCodes.js";
 import { injectKeyHold } from "./injectKeyHold.js";
@@ -10,4 +11,4 @@ import { injectHotkeySequenceRecorder } from "./injectHotkeySequenceRecorder.js"
 
 export * from "@tanstack/hotkeys"
 
-export { HOTKEYS_INJECTION_TOKEN, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeySequenceRecorder, injectHotkeys, injectHotkeysContext, injectKeyHold, provideHotkeys };
+export { HOTKEYS_INJECTION_TOKEN, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeySequenceRecorder, injectHotkeySequences, injectHotkeys, injectHotkeysContext, injectKeyHold, provideHotkeys };

package/dist/injectHotkey.cjs

@@ -13,6 +13,8 @@ let _angular_core = require("@angular/core");
 * Call in an injection context (e.g. constructor or field initializer).
 * Uses effect() to track reactive dependencies and update registration
 * when options or the callback change.
+* `enabled: false` keeps the registration (visible in devtools) and only suppresses firing; the same
+* handle is updated instead of unregistering and re-registering when identity is unchanged.
 *
 * @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function
 * @param callback - The function to call when the hotkey is pressed
@@ -62,7 +64,19 @@ let _angular_core = require("@angular/core");
 function injectHotkey(hotkey, callback, options = {}) {
 	const defaultOptions = require_hotkeys_provider.injectDefaultHotkeysOptions();
 	const manager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	(0, _angular_core.effect)((onCleanup) => {
+	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
+	let registration = null;
+	let lastHotkeyString = null;
+	let lastTarget = null;
+	destroyRef.onDestroy(() => {
+		if (registration?.isActive) {
+			registration.unregister();
+			registration = null;
+		}
+		lastHotkeyString = null;
+		lastTarget = null;
+	});
+	(0, _angular_core.effect)(() => {
 		const resolvedHotkey = typeof hotkey === "function" ? hotkey() : hotkey;
 		const resolvedOptions = typeof options === "function" ? options() : options;
 		const mergedOptions = {
@@ -72,9 +86,26 @@ function injectHotkey(hotkey, callback, options = {}) {
 		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 resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
-		if (!resolvedTarget) return;
+		if (!resolvedTarget) {
+			if (registration?.isActive) {
+				registration.unregister();
+				registration = null;
+			}
+			lastHotkeyString = null;
+			lastTarget = null;
+			return;
+		}
 		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-		const registration = manager.register(hotkeyString, callback, {
+		if (registration?.isActive && lastHotkeyString === hotkeyString && lastTarget === resolvedTarget) {
+			registration.callback = callback;
+			registration.setOptions(optionsWithoutTarget);
+			return;
+		}
+		if (registration?.isActive) {
+			registration.unregister();
+			registration = null;
+		}
+		registration = manager.register(hotkeyString, callback, {
 			...optionsWithoutTarget,
 			target: resolvedTarget
 		});
@@ -82,9 +113,8 @@ function injectHotkey(hotkey, callback, options = {}) {
 			registration.callback = callback;
 			registration.setOptions(optionsWithoutTarget);
 		}
-		onCleanup(() => {
-			if (registration.isActive) registration.unregister();
-		});
+		lastHotkeyString = hotkeyString;
+		lastTarget = resolvedTarget;
 	});
 }
 

package/dist/injectHotkey.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"injectHotkey.cjs","names":["injectDefaultHotkeysOptions"],"sources":["../src/injectHotkey.ts"],"sourcesContent":["import { effect } from '@angular/core'\nimport {\n  detectPlatform,\n  formatHotkey,\n  getHotkeyManager,\n  rawHotkeyToParsedHotkey,\n} from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\nexport interface InjectHotkeyOptions extends Omit<HotkeyOptions, 'target'> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor (for reactive targets that become\n   * available after mount), or null. Defaults to document.\n   * When using scoped targets, pass an accessor: () => ({ target: elementSignal() })\n   * so the hotkey waits for the element to be attached before registering.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * Angular inject-based API 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 * Call in an injection context (e.g. constructor or field initializer).\n * Uses effect() to track reactive dependencies and update registration\n * when options or the callback change.\n *\n * @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior, or getter for reactive options\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class SaveButtonComponent {\n *   private readonly saveCount = signal(0)\n *\n *   constructor() {\n *     injectHotkey('Mod+S', (event, { hotkey }) => {\n *       event.preventDefault()\n *       this.saveCount.update(c => c + 1)\n *     })\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class ModalComponent {\n *   isOpen = signal(true)\n *\n *   constructor() {\n *     injectHotkey('Escape', () => this.close(), () => ({ enabled: this.isOpen() }))\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class EditorComponent {\n *   private readonly editorRef = viewChild<ElementRef<HTMLDivElement>>('editorRef')\n *\n *   constructor() {\n *     injectHotkey('Mod+B', () => this.toggleBold(), () => ({\n *       target: this.editorRef()?.nativeElement ?? null,\n *     }))\n *   }\n * }\n * ```\n */\nexport function injectHotkey(\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey),\n  callback: HotkeyCallback,\n  options: InjectHotkeyOptions | (() => InjectHotkeyOptions) = {},\n): void {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  effect((onCleanup) => {\n    // Resolve reactive values\n    const resolvedHotkey = typeof hotkey === 'function' ? hotkey() : hotkey\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkey,\n      ...resolvedOptions,\n    } as InjectHotkeyOptions\n\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, platform),\n          ) as Hotkey)\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches React's ref handling.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (!resolvedTarget) {\n      return\n    }\n\n    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    // Register the hotkey\n    const registration = manager.register(hotkeyString, callback, {\n      ...optionsWithoutTarget,\n      target: resolvedTarget,\n    })\n\n    // Update callback and options on every effect run\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    // Cleanup on disposal\n    onCleanup(() => {\n      if (registration.isActive) {\n        registration.unregister()\n      }\n    })\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,SAAgB,aACd,QACA,UACA,UAA6D,EAAE,EACzD;CACN,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,mDAA4B;AAElC,4BAAQ,cAAc;EAEpB,MAAM,iBAAiB,OAAO,WAAW,aAAa,QAAQ,GAAG;EACjE,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAGD,MAAM,WAAW,cAAc,mDAA4B;EAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,oGAE0B,gBAAgB,SAAS,CAClD;EAIP,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,eACH;EAIF,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;EAGrD,MAAM,eAAe,QAAQ,SAAS,cAAc,UAAU;GAC5D,GAAG;GACH,QAAQ;GACT,CAAC;AAGF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAI/C,kBAAgB;AACd,OAAI,aAAa,SACf,cAAa,YAAY;IAE3B;GACF"}
+{"version":3,"file":"injectHotkey.cjs","names":["injectDefaultHotkeysOptions","DestroyRef"],"sources":["../src/injectHotkey.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport {\n  detectPlatform,\n  formatHotkey,\n  getHotkeyManager,\n  rawHotkeyToParsedHotkey,\n} from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\nexport interface InjectHotkeyOptions extends Omit<HotkeyOptions, 'target'> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor (for reactive targets that become\n   * available after mount), or null. Defaults to document.\n   * When using scoped targets, pass an accessor: () => ({ target: elementSignal() })\n   * so the hotkey waits for the element to be attached before registering.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * Angular inject-based API 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 * Call in an injection context (e.g. constructor or field initializer).\n * Uses effect() to track reactive dependencies and update registration\n * when options or the callback change.\n * `enabled: false` keeps the registration (visible in devtools) and only suppresses firing; the same\n * handle is updated instead of unregistering and re-registering when identity is unchanged.\n *\n * @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior, or getter for reactive options\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class SaveButtonComponent {\n *   private readonly saveCount = signal(0)\n *\n *   constructor() {\n *     injectHotkey('Mod+S', (event, { hotkey }) => {\n *       event.preventDefault()\n *       this.saveCount.update(c => c + 1)\n *     })\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class ModalComponent {\n *   isOpen = signal(true)\n *\n *   constructor() {\n *     injectHotkey('Escape', () => this.close(), () => ({ enabled: this.isOpen() }))\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class EditorComponent {\n *   private readonly editorRef = viewChild<ElementRef<HTMLDivElement>>('editorRef')\n *\n *   constructor() {\n *     injectHotkey('Mod+B', () => this.toggleBold(), () => ({\n *       target: this.editorRef()?.nativeElement ?? null,\n *     }))\n *   }\n * }\n * ```\n */\nexport function injectHotkey(\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey),\n  callback: HotkeyCallback,\n  options: InjectHotkeyOptions | (() => InjectHotkeyOptions) = {},\n): void {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n  const destroyRef = inject(DestroyRef)\n\n  let registration: HotkeyRegistrationHandle | null = null\n  let lastHotkeyString: Hotkey | null = null\n  let lastTarget: HTMLElement | Document | Window | null = null\n\n  destroyRef.onDestroy(() => {\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n    lastHotkeyString = null\n    lastTarget = null\n  })\n\n  effect(() => {\n    // Resolve reactive values\n    const resolvedHotkey = typeof hotkey === 'function' ? hotkey() : hotkey\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkey,\n      ...resolvedOptions,\n    } as InjectHotkeyOptions\n\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, platform),\n          ) as Hotkey)\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches React's ref handling.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (!resolvedTarget) {\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 { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    if (\n      registration?.isActive &&\n      lastHotkeyString === hotkeyString &&\n      lastTarget === resolvedTarget\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: resolvedTarget,\n    })\n\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    lastHotkeyString = hotkeyString\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqFA,SAAgB,aACd,QACA,UACA,UAA6D,EAAE,EACzD;CACN,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,mDAA4B;CAClC,MAAM,uCAAoBC,yBAAW;CAErC,IAAI,eAAgD;CACpD,IAAI,mBAAkC;CACtC,IAAI,aAAqD;AAEzD,YAAW,gBAAgB;AACzB,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAEjB,qBAAmB;AACnB,eAAa;GACb;AAEF,iCAAa;EAEX,MAAM,iBAAiB,OAAO,WAAW,aAAa,QAAQ,GAAG;EACjE,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAGD,MAAM,WAAW,cAAc,mDAA4B;EAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,oGAE0B,gBAAgB,SAAS,CAClD;EAIP,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,gBAAgB;AACnB,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,sBAAmB;AACnB,gBAAa;AACb;;EAIF,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,MACE,cAAc,YACd,qBAAqB,gBACrB,eAAe,gBACf;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;GACb"}

package/dist/injectHotkey.d.cts

@@ -21,6 +21,8 @@ interface InjectHotkeyOptions extends Omit<HotkeyOptions, 'target'> {
  * Call in an injection context (e.g. constructor or field initializer).
  * Uses effect() to track reactive dependencies and update registration
  * when options or the callback change.
+ * `enabled: false` keeps the registration (visible in devtools) and only suppresses firing; the same
+ * handle is updated instead of unregistering and re-registering when identity is unchanged.
  *
  * @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function
  * @param callback - The function to call when the hotkey is pressed

package/dist/injectHotkey.d.ts

@@ -21,6 +21,8 @@ interface InjectHotkeyOptions extends Omit<HotkeyOptions, 'target'> {
  * Call in an injection context (e.g. constructor or field initializer).
  * Uses effect() to track reactive dependencies and update registration
  * when options or the callback change.
+ * `enabled: false` keeps the registration (visible in devtools) and only suppresses firing; the same
+ * handle is updated instead of unregistering and re-registering when identity is unchanged.
  *
  * @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function
  * @param callback - The function to call when the hotkey is pressed

package/dist/injectHotkey.js

@@ -1,6 +1,6 @@
 import { injectDefaultHotkeysOptions } from "./hotkeys-provider.js";
 import { detectPlatform, formatHotkey, getHotkeyManager, rawHotkeyToParsedHotkey } from "@tanstack/hotkeys";
-import { effect } from "@angular/core";
+import { DestroyRef, effect, inject } from "@angular/core";
 
 //#region src/injectHotkey.ts
 /**
@@ -13,6 +13,8 @@ import { effect } from "@angular/core";
 * Call in an injection context (e.g. constructor or field initializer).
 * Uses effect() to track reactive dependencies and update registration
 * when options or the callback change.
+* `enabled: false` keeps the registration (visible in devtools) and only suppresses firing; the same
+* handle is updated instead of unregistering and re-registering when identity is unchanged.
 *
 * @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function
 * @param callback - The function to call when the hotkey is pressed
@@ -62,7 +64,19 @@ import { effect } from "@angular/core";
 function injectHotkey(hotkey, callback, options = {}) {
 	const defaultOptions = injectDefaultHotkeysOptions();
 	const manager = getHotkeyManager();
-	effect((onCleanup) => {
+	const destroyRef = inject(DestroyRef);
+	let registration = null;
+	let lastHotkeyString = null;
+	let lastTarget = null;
+	destroyRef.onDestroy(() => {
+		if (registration?.isActive) {
+			registration.unregister();
+			registration = null;
+		}
+		lastHotkeyString = null;
+		lastTarget = null;
+	});
+	effect(() => {
 		const resolvedHotkey = typeof hotkey === "function" ? hotkey() : hotkey;
 		const resolvedOptions = typeof options === "function" ? options() : options;
 		const mergedOptions = {
@@ -72,9 +86,26 @@ function injectHotkey(hotkey, callback, options = {}) {
 		const platform = mergedOptions.platform ?? detectPlatform();
 		const hotkeyString = typeof resolvedHotkey === "string" ? resolvedHotkey : formatHotkey(rawHotkeyToParsedHotkey(resolvedHotkey, platform));
 		const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
-		if (!resolvedTarget) return;
+		if (!resolvedTarget) {
+			if (registration?.isActive) {
+				registration.unregister();
+				registration = null;
+			}
+			lastHotkeyString = null;
+			lastTarget = null;
+			return;
+		}
 		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-		const registration = manager.register(hotkeyString, callback, {
+		if (registration?.isActive && lastHotkeyString === hotkeyString && lastTarget === resolvedTarget) {
+			registration.callback = callback;
+			registration.setOptions(optionsWithoutTarget);
+			return;
+		}
+		if (registration?.isActive) {
+			registration.unregister();
+			registration = null;
+		}
+		registration = manager.register(hotkeyString, callback, {
 			...optionsWithoutTarget,
 			target: resolvedTarget
 		});
@@ -82,9 +113,8 @@ function injectHotkey(hotkey, callback, options = {}) {
 			registration.callback = callback;
 			registration.setOptions(optionsWithoutTarget);
 		}
-		onCleanup(() => {
-			if (registration.isActive) registration.unregister();
-		});
+		lastHotkeyString = hotkeyString;
+		lastTarget = resolvedTarget;
 	});
 }
 

package/dist/injectHotkey.js.map

@@ -1 +1 @@
-{"version":3,"file":"injectHotkey.js","names":[],"sources":["../src/injectHotkey.ts"],"sourcesContent":["import { effect } from '@angular/core'\nimport {\n  detectPlatform,\n  formatHotkey,\n  getHotkeyManager,\n  rawHotkeyToParsedHotkey,\n} from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\nexport interface InjectHotkeyOptions extends Omit<HotkeyOptions, 'target'> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor (for reactive targets that become\n   * available after mount), or null. Defaults to document.\n   * When using scoped targets, pass an accessor: () => ({ target: elementSignal() })\n   * so the hotkey waits for the element to be attached before registering.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * Angular inject-based API 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 * Call in an injection context (e.g. constructor or field initializer).\n * Uses effect() to track reactive dependencies and update registration\n * when options or the callback change.\n *\n * @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior, or getter for reactive options\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class SaveButtonComponent {\n *   private readonly saveCount = signal(0)\n *\n *   constructor() {\n *     injectHotkey('Mod+S', (event, { hotkey }) => {\n *       event.preventDefault()\n *       this.saveCount.update(c => c + 1)\n *     })\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class ModalComponent {\n *   isOpen = signal(true)\n *\n *   constructor() {\n *     injectHotkey('Escape', () => this.close(), () => ({ enabled: this.isOpen() }))\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class EditorComponent {\n *   private readonly editorRef = viewChild<ElementRef<HTMLDivElement>>('editorRef')\n *\n *   constructor() {\n *     injectHotkey('Mod+B', () => this.toggleBold(), () => ({\n *       target: this.editorRef()?.nativeElement ?? null,\n *     }))\n *   }\n * }\n * ```\n */\nexport function injectHotkey(\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey),\n  callback: HotkeyCallback,\n  options: InjectHotkeyOptions | (() => InjectHotkeyOptions) = {},\n): void {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  effect((onCleanup) => {\n    // Resolve reactive values\n    const resolvedHotkey = typeof hotkey === 'function' ? hotkey() : hotkey\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkey,\n      ...resolvedOptions,\n    } as InjectHotkeyOptions\n\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, platform),\n          ) as Hotkey)\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches React's ref handling.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (!resolvedTarget) {\n      return\n    }\n\n    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    // Register the hotkey\n    const registration = manager.register(hotkeyString, callback, {\n      ...optionsWithoutTarget,\n      target: resolvedTarget,\n    })\n\n    // Update callback and options on every effect run\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    // Cleanup on disposal\n    onCleanup(() => {\n      if (registration.isActive) {\n        registration.unregister()\n      }\n    })\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,SAAgB,aACd,QACA,UACA,UAA6D,EAAE,EACzD;CACN,MAAM,iBAAiB,6BAA6B;CACpD,MAAM,UAAU,kBAAkB;AAElC,SAAQ,cAAc;EAEpB,MAAM,iBAAiB,OAAO,WAAW,aAAa,QAAQ,GAAG;EACjE,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAGD,MAAM,WAAW,cAAc,YAAY,gBAAgB;EAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,iBACC,aACC,wBAAwB,gBAAgB,SAAS,CAClD;EAIP,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,eACH;EAIF,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;EAGrD,MAAM,eAAe,QAAQ,SAAS,cAAc,UAAU;GAC5D,GAAG;GACH,QAAQ;GACT,CAAC;AAGF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAI/C,kBAAgB;AACd,OAAI,aAAa,SACf,cAAa,YAAY;IAE3B;GACF"}
+{"version":3,"file":"injectHotkey.js","names":[],"sources":["../src/injectHotkey.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport {\n  detectPlatform,\n  formatHotkey,\n  getHotkeyManager,\n  rawHotkeyToParsedHotkey,\n} from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\nexport interface InjectHotkeyOptions extends Omit<HotkeyOptions, 'target'> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor (for reactive targets that become\n   * available after mount), or null. Defaults to document.\n   * When using scoped targets, pass an accessor: () => ({ target: elementSignal() })\n   * so the hotkey waits for the element to be attached before registering.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * Angular inject-based API 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 * Call in an injection context (e.g. constructor or field initializer).\n * Uses effect() to track reactive dependencies and update registration\n * when options or the callback change.\n * `enabled: false` keeps the registration (visible in devtools) and only suppresses firing; the same\n * handle is updated instead of unregistering and re-registering when identity is unchanged.\n *\n * @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior, or getter for reactive options\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class SaveButtonComponent {\n *   private readonly saveCount = signal(0)\n *\n *   constructor() {\n *     injectHotkey('Mod+S', (event, { hotkey }) => {\n *       event.preventDefault()\n *       this.saveCount.update(c => c + 1)\n *     })\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class ModalComponent {\n *   isOpen = signal(true)\n *\n *   constructor() {\n *     injectHotkey('Escape', () => this.close(), () => ({ enabled: this.isOpen() }))\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class EditorComponent {\n *   private readonly editorRef = viewChild<ElementRef<HTMLDivElement>>('editorRef')\n *\n *   constructor() {\n *     injectHotkey('Mod+B', () => this.toggleBold(), () => ({\n *       target: this.editorRef()?.nativeElement ?? null,\n *     }))\n *   }\n * }\n * ```\n */\nexport function injectHotkey(\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey),\n  callback: HotkeyCallback,\n  options: InjectHotkeyOptions | (() => InjectHotkeyOptions) = {},\n): void {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n  const destroyRef = inject(DestroyRef)\n\n  let registration: HotkeyRegistrationHandle | null = null\n  let lastHotkeyString: Hotkey | null = null\n  let lastTarget: HTMLElement | Document | Window | null = null\n\n  destroyRef.onDestroy(() => {\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n    lastHotkeyString = null\n    lastTarget = null\n  })\n\n  effect(() => {\n    // Resolve reactive values\n    const resolvedHotkey = typeof hotkey === 'function' ? hotkey() : hotkey\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkey,\n      ...resolvedOptions,\n    } as InjectHotkeyOptions\n\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, platform),\n          ) as Hotkey)\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches React's ref handling.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (!resolvedTarget) {\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 { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    if (\n      registration?.isActive &&\n      lastHotkeyString === hotkeyString &&\n      lastTarget === resolvedTarget\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: resolvedTarget,\n    })\n\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    lastHotkeyString = hotkeyString\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqFA,SAAgB,aACd,QACA,UACA,UAA6D,EAAE,EACzD;CACN,MAAM,iBAAiB,6BAA6B;CACpD,MAAM,UAAU,kBAAkB;CAClC,MAAM,aAAa,OAAO,WAAW;CAErC,IAAI,eAAgD;CACpD,IAAI,mBAAkC;CACtC,IAAI,aAAqD;AAEzD,YAAW,gBAAgB;AACzB,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAEjB,qBAAmB;AACnB,eAAa;GACb;AAEF,cAAa;EAEX,MAAM,iBAAiB,OAAO,WAAW,aAAa,QAAQ,GAAG;EACjE,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAGD,MAAM,WAAW,cAAc,YAAY,gBAAgB;EAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,iBACC,aACC,wBAAwB,gBAAgB,SAAS,CAClD;EAIP,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,gBAAgB;AACnB,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,sBAAmB;AACnB,gBAAa;AACb;;EAIF,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,MACE,cAAc,YACd,qBAAqB,gBACrB,eAAe,gBACf;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;GACb"}

package/dist/injectHotkeySequence.cjs

@@ -16,7 +16,8 @@ let _angular_core = require("@angular/core");
 *
 * @param sequence - Array of hotkey strings that form the sequence (or getter function)
 * @param callback - Function to call when the sequence is completed
-* @param options - Options for the sequence behavior (or getter function)
+* @param options - Options for the sequence behavior (or getter function). `enabled: false` still registers
+*   the sequence (visible in devtools); only execution is suppressed.
 *
 * @example
 * ```ts
@@ -35,24 +36,55 @@ let _angular_core = require("@angular/core");
 */
 function injectHotkeySequence(sequence, callback, options = {}) {
 	const defaultOptions = require_hotkeys_provider.injectDefaultHotkeysOptions();
-	(0, _angular_core.effect)((onCleanup) => {
+	const manager = (0, _tanstack_hotkeys.getSequenceManager)();
+	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
+	let handle = null;
+	let lastSequenceKey = null;
+	let lastTarget = null;
+	destroyRef.onDestroy(() => {
+		if (handle?.isActive) {
+			handle.unregister();
+			handle = null;
+		}
+		lastSequenceKey = null;
+		lastTarget = null;
+	});
+	(0, _angular_core.effect)(() => {
 		const resolvedSequence = typeof sequence === "function" ? sequence() : sequence;
 		const resolvedOptions = typeof options === "function" ? options() : options;
 		const { enabled = true, ...sequenceOptions } = {
 			...defaultOptions.hotkeySequence,
 			...resolvedOptions
 		};
-		if (!enabled || resolvedSequence.length === 0) return;
-		const manager = (0, _tanstack_hotkeys.getSequenceManager)();
-		const registerOptions = {
+		const resolvedTarget = "target" in sequenceOptions ? sequenceOptions.target ?? null : typeof document !== "undefined" ? document : null;
+		if (resolvedSequence.length === 0 || !resolvedTarget) {
+			if (handle?.isActive) {
+				handle.unregister();
+				handle = null;
+			}
+			lastSequenceKey = null;
+			lastTarget = null;
+			return;
+		}
+		const sequenceKey = (0, _tanstack_hotkeys.formatHotkeySequence)(resolvedSequence);
+		const registerPayload = {
 			...sequenceOptions,
-			enabled: true,
-			target: sequenceOptions.target ?? (typeof document !== "undefined" ? document : void 0)
+			enabled,
+			target: resolvedTarget
 		};
-		const handle = manager.register(resolvedSequence, callback, registerOptions);
-		onCleanup(() => {
-			if (handle.isActive) handle.unregister();
-		});
+		const { target: _t, ...optionsWithoutTarget } = registerPayload;
+		if (handle?.isActive && lastSequenceKey === sequenceKey && lastTarget === resolvedTarget) {
+			handle.callback = callback;
+			handle.setOptions(optionsWithoutTarget);
+			return;
+		}
+		if (handle?.isActive) {
+			handle.unregister();
+			handle = null;
+		}
+		handle = manager.register(resolvedSequence, callback, registerPayload);
+		lastSequenceKey = sequenceKey;
+		lastTarget = resolvedTarget;
 	});
 }
 

package/dist/injectHotkeySequence.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"injectHotkeySequence.cjs","names":["injectDefaultHotkeysOptions"],"sources":["../src/injectHotkeySequence.ts"],"sourcesContent":["import { effect } from '@angular/core'\nimport { getSequenceManager } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n} from '@tanstack/hotkeys'\n\nexport interface InjectHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'enabled'\n> {\n  /** Whether the sequence is enabled. Defaults to true. */\n  enabled?: boolean\n}\n\n/**\n * Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).\n *\n * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger\n * 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 (or getter function)\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior (or getter function)\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class VimEditorComponent {\n *   lastSequence = signal<string | null>(null)\n *\n *   constructor() {\n *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))\n *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))\n *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })\n *     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))\n *   }\n * }\n * ```\n */\nexport function injectHotkeySequence(\n  sequence: HotkeySequence | (() => HotkeySequence),\n  callback: HotkeyCallback,\n  options:\n    | InjectHotkeySequenceOptions\n    | (() => InjectHotkeySequenceOptions) = {},\n): void {\n  const defaultOptions = injectDefaultHotkeysOptions()\n\n  effect((onCleanup) => {\n    // Resolve reactive values\n    const resolvedSequence =\n      typeof sequence === 'function' ? sequence() : sequence\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkeySequence,\n      ...resolvedOptions,\n    } as InjectHotkeySequenceOptions\n\n    const { enabled = true, ...sequenceOptions } = mergedOptions\n\n    if (!enabled || resolvedSequence.length === 0) {\n      return\n    }\n\n    const manager = getSequenceManager()\n\n    // Pass through options; default target to document when not provided\n    const registerOptions: SequenceOptions = {\n      ...sequenceOptions,\n      enabled: true,\n      target:\n        sequenceOptions.target ??\n        (typeof document !== 'undefined' ? document : undefined),\n    }\n\n    const handle = manager.register(resolvedSequence, callback, registerOptions)\n\n    onCleanup(() => {\n      if (handle.isActive) {\n        handle.unregister()\n      }\n    })\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiBA,sDAA6B;AAEpD,4BAAQ,cAAc;EAEpB,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAOpE,MAAM,EAAE,UAAU,MAAM,GAAG,oBALL;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;AAID,MAAI,CAAC,WAAW,iBAAiB,WAAW,EAC1C;EAGF,MAAM,qDAA8B;EAGpC,MAAM,kBAAmC;GACvC,GAAG;GACH,SAAS;GACT,QACE,gBAAgB,WACf,OAAO,aAAa,cAAc,WAAW;GACjD;EAED,MAAM,SAAS,QAAQ,SAAS,kBAAkB,UAAU,gBAAgB;AAE5E,kBAAgB;AACd,OAAI,OAAO,SACT,QAAO,YAAY;IAErB;GACF"}
+{"version":3,"file":"injectHotkeySequence.cjs","names":["injectDefaultHotkeysOptions","DestroyRef"],"sources":["../src/injectHotkeySequence.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\ntype SequenceTarget = Document | HTMLElement | Window\n\nexport interface InjectHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'enabled' | 'target'\n> {\n  /** Whether the sequence is enabled. Defaults to true. */\n  enabled?: boolean\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor target, or null.\n   * Defaults to document when omitted.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).\n *\n * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger\n * 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 (or getter function)\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior (or getter function). `enabled: false` still registers\n *   the sequence (visible in devtools); only execution is suppressed.\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class VimEditorComponent {\n *   lastSequence = signal<string | null>(null)\n *\n *   constructor() {\n *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))\n *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))\n *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })\n *     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))\n *   }\n * }\n * ```\n */\nexport function injectHotkeySequence(\n  sequence: HotkeySequence | (() => HotkeySequence),\n  callback: HotkeyCallback,\n  options:\n    | InjectHotkeySequenceOptions\n    | (() => InjectHotkeySequenceOptions) = {},\n): void {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n  const destroyRef = inject(DestroyRef)\n\n  let handle: SequenceRegistrationHandle | null = null\n  let lastSequenceKey: string | null = null\n  let lastTarget: SequenceTarget | null = null\n\n  destroyRef.onDestroy(() => {\n    if (handle?.isActive) {\n      handle.unregister()\n      handle = null\n    }\n    lastSequenceKey = null\n    lastTarget = null\n  })\n\n  effect(() => {\n    // Resolve reactive values\n    const resolvedSequence =\n      typeof sequence === 'function' ? sequence() : sequence\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkeySequence,\n      ...resolvedOptions,\n    } as InjectHotkeySequenceOptions\n\n    const { enabled = true, ...sequenceOptions } = mergedOptions\n\n    const resolvedTarget =\n      'target' in sequenceOptions\n        ? (sequenceOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (resolvedSequence.length === 0 || !resolvedTarget) {\n      if (handle?.isActive) {\n        handle.unregister()\n        handle = null\n      }\n      lastSequenceKey = null\n      lastTarget = null\n      return\n    }\n\n    const sequenceKey = formatHotkeySequence(resolvedSequence)\n\n    const registerPayload: SequenceOptions = {\n      ...sequenceOptions,\n      enabled,\n      target: resolvedTarget,\n    }\n    const { target: _t, ...optionsWithoutTarget } = registerPayload\n\n    if (\n      handle?.isActive &&\n      lastSequenceKey === sequenceKey &&\n      lastTarget === resolvedTarget\n    ) {\n      handle.callback = callback\n      handle.setOptions(optionsWithoutTarget)\n      return\n    }\n\n    if (handle?.isActive) {\n      handle.unregister()\n      handle = null\n    }\n\n    handle = manager.register(resolvedSequence, callback, registerPayload)\n    lastSequenceKey = sequenceKey\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,qDAA8B;CACpC,MAAM,uCAAoBC,yBAAW;CAErC,IAAI,SAA4C;CAChD,IAAI,kBAAiC;CACrC,IAAI,aAAoC;AAExC,YAAW,gBAAgB;AACzB,MAAI,QAAQ,UAAU;AACpB,UAAO,YAAY;AACnB,YAAS;;AAEX,oBAAkB;AAClB,eAAa;GACb;AAEF,iCAAa;EAEX,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAOpE,MAAM,EAAE,UAAU,MAAM,GAAG,oBALL;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAID,MAAM,iBACJ,YAAY,kBACP,gBAAgB,UAAU,OAC3B,OAAO,aAAa,cAClB,WACA;AAER,MAAI,iBAAiB,WAAW,KAAK,CAAC,gBAAgB;AACpD,OAAI,QAAQ,UAAU;AACpB,WAAO,YAAY;AACnB,aAAS;;AAEX,qBAAkB;AAClB,gBAAa;AACb;;EAGF,MAAM,0DAAmC,iBAAiB;EAE1D,MAAM,kBAAmC;GACvC,GAAG;GACH;GACA,QAAQ;GACT;EACD,MAAM,EAAE,QAAQ,IAAI,GAAG,yBAAyB;AAEhD,MACE,QAAQ,YACR,oBAAoB,eACpB,eAAe,gBACf;AACA,UAAO,WAAW;AAClB,UAAO,WAAW,qBAAqB;AACvC;;AAGF,MAAI,QAAQ,UAAU;AACpB,UAAO,YAAY;AACnB,YAAS;;AAGX,WAAS,QAAQ,SAAS,kBAAkB,UAAU,gBAAgB;AACtE,oBAAkB;AAClB,eAAa;GACb"}

package/dist/injectHotkeySequence.d.cts

@@ -1,9 +1,15 @@
 import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
 
 //#region src/injectHotkeySequence.d.ts
-interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled'> {
+interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled' | 'target'> {
   /** Whether the sequence is enabled. Defaults to true. */
   enabled?: boolean;
+  /**
+   * The DOM element to attach the event listener to.
+   * Can be a direct DOM element, an accessor target, or null.
+   * Defaults to document when omitted.
+   */
+  target?: HTMLElement | Document | Window | null;
 }
 /**
  * Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).
@@ -18,7 +24,8 @@ interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled'> {
  *
  * @param sequence - Array of hotkey strings that form the sequence (or getter function)
  * @param callback - Function to call when the sequence is completed
- * @param options - Options for the sequence behavior (or getter function)
+ * @param options - Options for the sequence behavior (or getter function). `enabled: false` still registers
+ *   the sequence (visible in devtools); only execution is suppressed.
  *
  * @example
  * ```ts

package/dist/injectHotkeySequence.d.ts

@@ -1,9 +1,15 @@
 import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
 
 //#region src/injectHotkeySequence.d.ts
-interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled'> {
+interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled' | 'target'> {
   /** Whether the sequence is enabled. Defaults to true. */
   enabled?: boolean;
+  /**
+   * The DOM element to attach the event listener to.
+   * Can be a direct DOM element, an accessor target, or null.
+   * Defaults to document when omitted.
+   */
+  target?: HTMLElement | Document | Window | null;
 }
 /**
  * Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).
@@ -18,7 +24,8 @@ interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled'> {
  *
  * @param sequence - Array of hotkey strings that form the sequence (or getter function)
  * @param callback - Function to call when the sequence is completed
- * @param options - Options for the sequence behavior (or getter function)
+ * @param options - Options for the sequence behavior (or getter function). `enabled: false` still registers
+ *   the sequence (visible in devtools); only execution is suppressed.
  *
  * @example
  * ```ts

package/dist/injectHotkeySequence.js

@@ -1,6 +1,6 @@
 import { injectDefaultHotkeysOptions } from "./hotkeys-provider.js";
-import { getSequenceManager } from "@tanstack/hotkeys";
-import { effect } from "@angular/core";
+import { formatHotkeySequence, getSequenceManager } from "@tanstack/hotkeys";
+import { DestroyRef, effect, inject } from "@angular/core";
 
 //#region src/injectHotkeySequence.ts
 /**
@@ -16,7 +16,8 @@ import { effect } from "@angular/core";
 *
 * @param sequence - Array of hotkey strings that form the sequence (or getter function)
 * @param callback - Function to call when the sequence is completed
-* @param options - Options for the sequence behavior (or getter function)
+* @param options - Options for the sequence behavior (or getter function). `enabled: false` still registers
+*   the sequence (visible in devtools); only execution is suppressed.
 *
 * @example
 * ```ts
@@ -35,24 +36,55 @@ import { effect } from "@angular/core";
 */
 function injectHotkeySequence(sequence, callback, options = {}) {
 	const defaultOptions = injectDefaultHotkeysOptions();
-	effect((onCleanup) => {
+	const manager = getSequenceManager();
+	const destroyRef = inject(DestroyRef);
+	let handle = null;
+	let lastSequenceKey = null;
+	let lastTarget = null;
+	destroyRef.onDestroy(() => {
+		if (handle?.isActive) {
+			handle.unregister();
+			handle = null;
+		}
+		lastSequenceKey = null;
+		lastTarget = null;
+	});
+	effect(() => {
 		const resolvedSequence = typeof sequence === "function" ? sequence() : sequence;
 		const resolvedOptions = typeof options === "function" ? options() : options;
 		const { enabled = true, ...sequenceOptions } = {
 			...defaultOptions.hotkeySequence,
 			...resolvedOptions
 		};
-		if (!enabled || resolvedSequence.length === 0) return;
-		const manager = getSequenceManager();
-		const registerOptions = {
+		const resolvedTarget = "target" in sequenceOptions ? sequenceOptions.target ?? null : typeof document !== "undefined" ? document : null;
+		if (resolvedSequence.length === 0 || !resolvedTarget) {
+			if (handle?.isActive) {
+				handle.unregister();
+				handle = null;
+			}
+			lastSequenceKey = null;
+			lastTarget = null;
+			return;
+		}
+		const sequenceKey = formatHotkeySequence(resolvedSequence);
+		const registerPayload = {
 			...sequenceOptions,
-			enabled: true,
-			target: sequenceOptions.target ?? (typeof document !== "undefined" ? document : void 0)
+			enabled,
+			target: resolvedTarget
 		};
-		const handle = manager.register(resolvedSequence, callback, registerOptions);
-		onCleanup(() => {
-			if (handle.isActive) handle.unregister();
-		});
+		const { target: _t, ...optionsWithoutTarget } = registerPayload;
+		if (handle?.isActive && lastSequenceKey === sequenceKey && lastTarget === resolvedTarget) {
+			handle.callback = callback;
+			handle.setOptions(optionsWithoutTarget);
+			return;
+		}
+		if (handle?.isActive) {
+			handle.unregister();
+			handle = null;
+		}
+		handle = manager.register(resolvedSequence, callback, registerPayload);
+		lastSequenceKey = sequenceKey;
+		lastTarget = resolvedTarget;
 	});
 }
 

package/dist/injectHotkeySequence.js.map

@@ -1 +1 @@
-{"version":3,"file":"injectHotkeySequence.js","names":[],"sources":["../src/injectHotkeySequence.ts"],"sourcesContent":["import { effect } from '@angular/core'\nimport { getSequenceManager } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n} from '@tanstack/hotkeys'\n\nexport interface InjectHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'enabled'\n> {\n  /** Whether the sequence is enabled. Defaults to true. */\n  enabled?: boolean\n}\n\n/**\n * Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).\n *\n * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger\n * 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 (or getter function)\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior (or getter function)\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class VimEditorComponent {\n *   lastSequence = signal<string | null>(null)\n *\n *   constructor() {\n *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))\n *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))\n *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })\n *     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))\n *   }\n * }\n * ```\n */\nexport function injectHotkeySequence(\n  sequence: HotkeySequence | (() => HotkeySequence),\n  callback: HotkeyCallback,\n  options:\n    | InjectHotkeySequenceOptions\n    | (() => InjectHotkeySequenceOptions) = {},\n): void {\n  const defaultOptions = injectDefaultHotkeysOptions()\n\n  effect((onCleanup) => {\n    // Resolve reactive values\n    const resolvedSequence =\n      typeof sequence === 'function' ? sequence() : sequence\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkeySequence,\n      ...resolvedOptions,\n    } as InjectHotkeySequenceOptions\n\n    const { enabled = true, ...sequenceOptions } = mergedOptions\n\n    if (!enabled || resolvedSequence.length === 0) {\n      return\n    }\n\n    const manager = getSequenceManager()\n\n    // Pass through options; default target to document when not provided\n    const registerOptions: SequenceOptions = {\n      ...sequenceOptions,\n      enabled: true,\n      target:\n        sequenceOptions.target ??\n        (typeof document !== 'undefined' ? document : undefined),\n    }\n\n    const handle = manager.register(resolvedSequence, callback, registerOptions)\n\n    onCleanup(() => {\n      if (handle.isActive) {\n        handle.unregister()\n      }\n    })\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiB,6BAA6B;AAEpD,SAAQ,cAAc;EAEpB,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAOpE,MAAM,EAAE,UAAU,MAAM,GAAG,oBALL;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;AAID,MAAI,CAAC,WAAW,iBAAiB,WAAW,EAC1C;EAGF,MAAM,UAAU,oBAAoB;EAGpC,MAAM,kBAAmC;GACvC,GAAG;GACH,SAAS;GACT,QACE,gBAAgB,WACf,OAAO,aAAa,cAAc,WAAW;GACjD;EAED,MAAM,SAAS,QAAQ,SAAS,kBAAkB,UAAU,gBAAgB;AAE5E,kBAAgB;AACd,OAAI,OAAO,SACT,QAAO,YAAY;IAErB;GACF"}
+{"version":3,"file":"injectHotkeySequence.js","names":[],"sources":["../src/injectHotkeySequence.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\ntype SequenceTarget = Document | HTMLElement | Window\n\nexport interface InjectHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'enabled' | 'target'\n> {\n  /** Whether the sequence is enabled. Defaults to true. */\n  enabled?: boolean\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor target, or null.\n   * Defaults to document when omitted.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).\n *\n * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger\n * 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 (or getter function)\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior (or getter function). `enabled: false` still registers\n *   the sequence (visible in devtools); only execution is suppressed.\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class VimEditorComponent {\n *   lastSequence = signal<string | null>(null)\n *\n *   constructor() {\n *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))\n *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))\n *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })\n *     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))\n *   }\n * }\n * ```\n */\nexport function injectHotkeySequence(\n  sequence: HotkeySequence | (() => HotkeySequence),\n  callback: HotkeyCallback,\n  options:\n    | InjectHotkeySequenceOptions\n    | (() => InjectHotkeySequenceOptions) = {},\n): void {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n  const destroyRef = inject(DestroyRef)\n\n  let handle: SequenceRegistrationHandle | null = null\n  let lastSequenceKey: string | null = null\n  let lastTarget: SequenceTarget | null = null\n\n  destroyRef.onDestroy(() => {\n    if (handle?.isActive) {\n      handle.unregister()\n      handle = null\n    }\n    lastSequenceKey = null\n    lastTarget = null\n  })\n\n  effect(() => {\n    // Resolve reactive values\n    const resolvedSequence =\n      typeof sequence === 'function' ? sequence() : sequence\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkeySequence,\n      ...resolvedOptions,\n    } as InjectHotkeySequenceOptions\n\n    const { enabled = true, ...sequenceOptions } = mergedOptions\n\n    const resolvedTarget =\n      'target' in sequenceOptions\n        ? (sequenceOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (resolvedSequence.length === 0 || !resolvedTarget) {\n      if (handle?.isActive) {\n        handle.unregister()\n        handle = null\n      }\n      lastSequenceKey = null\n      lastTarget = null\n      return\n    }\n\n    const sequenceKey = formatHotkeySequence(resolvedSequence)\n\n    const registerPayload: SequenceOptions = {\n      ...sequenceOptions,\n      enabled,\n      target: resolvedTarget,\n    }\n    const { target: _t, ...optionsWithoutTarget } = registerPayload\n\n    if (\n      handle?.isActive &&\n      lastSequenceKey === sequenceKey &&\n      lastTarget === resolvedTarget\n    ) {\n      handle.callback = callback\n      handle.setOptions(optionsWithoutTarget)\n      return\n    }\n\n    if (handle?.isActive) {\n      handle.unregister()\n      handle = null\n    }\n\n    handle = manager.register(resolvedSequence, callback, registerPayload)\n    lastSequenceKey = sequenceKey\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiB,6BAA6B;CACpD,MAAM,UAAU,oBAAoB;CACpC,MAAM,aAAa,OAAO,WAAW;CAErC,IAAI,SAA4C;CAChD,IAAI,kBAAiC;CACrC,IAAI,aAAoC;AAExC,YAAW,gBAAgB;AACzB,MAAI,QAAQ,UAAU;AACpB,UAAO,YAAY;AACnB,YAAS;;AAEX,oBAAkB;AAClB,eAAa;GACb;AAEF,cAAa;EAEX,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAOpE,MAAM,EAAE,UAAU,MAAM,GAAG,oBALL;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAID,MAAM,iBACJ,YAAY,kBACP,gBAAgB,UAAU,OAC3B,OAAO,aAAa,cAClB,WACA;AAER,MAAI,iBAAiB,WAAW,KAAK,CAAC,gBAAgB;AACpD,OAAI,QAAQ,UAAU;AACpB,WAAO,YAAY;AACnB,aAAS;;AAEX,qBAAkB;AAClB,gBAAa;AACb;;EAGF,MAAM,cAAc,qBAAqB,iBAAiB;EAE1D,MAAM,kBAAmC;GACvC,GAAG;GACH;GACA,QAAQ;GACT;EACD,MAAM,EAAE,QAAQ,IAAI,GAAG,yBAAyB;AAEhD,MACE,QAAQ,YACR,oBAAoB,eACpB,eAAe,gBACf;AACA,UAAO,WAAW;AAClB,UAAO,WAAW,qBAAqB;AACvC;;AAGF,MAAI,QAAQ,UAAU;AACpB,UAAO,YAAY;AACnB,YAAS;;AAGX,WAAS,QAAQ,SAAS,kBAAkB,UAAU,gBAAgB;AACtE,oBAAkB;AAClB,eAAa;GACb"}