@tanstack/angular-hotkeys 0.6.0 → 0.7.0

package/dist/injectHotkeySequences.cjs

@@ -0,0 +1,105 @@
+const require_hotkeys_provider = require('./hotkeys-provider.cjs');
+let _tanstack_hotkeys = require("@tanstack/hotkeys");
+let _angular_core = require("@angular/core");
+
+//#region src/injectHotkeySequences.ts
+/**
+* Angular inject-based API for registering multiple keyboard shortcut sequences at once (Vim-style).
+*
+* Uses the singleton SequenceManager. Call in an injection context (e.g. constructor).
+* Uses `effect()` to track reactive dependencies when definitions or options are getters.
+*
+* Options are merged in this order:
+* provideHotkeys defaults < commonOptions < per-definition options
+*
+* Definitions with an empty `sequence` are skipped. Disabled sequences (`enabled: false`)
+* remain registered so they stay visible in devtools; the core manager suppresses execution.
+*
+* @param sequences - Array of sequence definitions, or getter returning them
+* @param commonOptions - Shared options for all sequences, or getter
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class VimComponent {
+*   constructor() {
+*     injectHotkeySequences([
+*       { sequence: ['G', 'G'], callback: () => this.goTop() },
+*       { sequence: ['D', 'D'], callback: () => this.deleteLine() },
+*     ])
+*   }
+* }
+* ```
+*/
+function injectHotkeySequences(sequences, commonOptions = {}) {
+	const defaultOptions = require_hotkeys_provider.injectDefaultHotkeysOptions();
+	const manager = (0, _tanstack_hotkeys.getSequenceManager)();
+	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
+	const registrations = /* @__PURE__ */ new Map();
+	destroyRef.onDestroy(() => {
+		for (const { handle } of registrations.values()) if (handle.isActive) handle.unregister();
+		registrations.clear();
+	});
+	(0, _angular_core.effect)(() => {
+		const resolvedSequences = typeof sequences === "function" ? sequences() : sequences;
+		const resolvedCommonOptions = typeof commonOptions === "function" ? commonOptions() : commonOptions;
+		const nextKeys = /* @__PURE__ */ new Set();
+		const prepared = [];
+		for (let i = 0; i < resolvedSequences.length; i++) {
+			const def = resolvedSequences[i];
+			const resolvedSequence = typeof def.sequence === "function" ? def.sequence() : def.sequence;
+			const resolvedDefOptions = typeof def.options === "function" ? def.options() : def.options ?? {};
+			const { enabled = true, ...sequenceOpts } = {
+				...defaultOptions.hotkeySequence,
+				...resolvedCommonOptions,
+				...resolvedDefOptions
+			};
+			if (resolvedSequence.length === 0) continue;
+			const resolvedTarget = "target" in sequenceOpts ? sequenceOpts.target ?? null : typeof document !== "undefined" ? document : null;
+			if (!resolvedTarget) continue;
+			const registrationKey = `${i}:${(0, _tanstack_hotkeys.formatHotkeySequence)(resolvedSequence)}`;
+			nextKeys.add(registrationKey);
+			prepared.push({
+				registrationKey,
+				def,
+				resolvedSequence,
+				enabled,
+				sequenceOpts,
+				resolvedTarget
+			});
+		}
+		for (const [key, record] of [...registrations.entries()]) if (!nextKeys.has(key)) {
+			if (record.handle.isActive) record.handle.unregister();
+			registrations.delete(key);
+		}
+		for (const p of prepared) {
+			const existing = registrations.get(p.registrationKey);
+			if (existing?.handle.isActive && existing.target === p.resolvedTarget) {
+				existing.handle.callback = p.def.callback;
+				const { target: _target, ...optionsWithoutTarget } = p.sequenceOpts;
+				existing.handle.setOptions({
+					...optionsWithoutTarget,
+					enabled: p.enabled
+				});
+				continue;
+			}
+			if (existing) {
+				if (existing.handle.isActive) existing.handle.unregister();
+				registrations.delete(p.registrationKey);
+			}
+			const handle = manager.register(p.resolvedSequence, p.def.callback, {
+				...p.sequenceOpts,
+				enabled: p.enabled,
+				target: p.resolvedTarget
+			});
+			registrations.set(p.registrationKey, {
+				handle,
+				target: p.resolvedTarget
+			});
+		}
+	});
+}
+
+//#endregion
+exports.injectHotkeySequences = injectHotkeySequences;
+//# sourceMappingURL=injectHotkeySequences.cjs.map

package/dist/injectHotkeySequences.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectHotkeySequences.cjs","names":["injectDefaultHotkeysOptions","DestroyRef"],"sources":["../src/injectHotkeySequences.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type { InjectHotkeySequenceOptions } from './injectHotkeySequence'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\n/**\n * A single sequence definition for use with `injectHotkeySequences`.\n */\nexport interface InjectHotkeySequenceDefinition {\n  /** Array of hotkey strings that form the sequence */\n  sequence: HotkeySequence | (() => 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?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions)\n}\n\n/**\n * Angular inject-based API for registering multiple keyboard shortcut sequences at once (Vim-style).\n *\n * Uses the singleton SequenceManager. Call in an injection context (e.g. constructor).\n * Uses `effect()` to track reactive dependencies when definitions or options are getters.\n *\n * Options are merged in this order:\n * provideHotkeys defaults < commonOptions < per-definition options\n *\n * Definitions with an empty `sequence` are skipped. Disabled sequences (`enabled: false`)\n * remain registered so they stay visible in devtools; the core manager suppresses execution.\n *\n * @param sequences - Array of sequence definitions, or getter returning them\n * @param commonOptions - Shared options for all sequences, or getter\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class VimComponent {\n *   constructor() {\n *     injectHotkeySequences([\n *       { sequence: ['G', 'G'], callback: () => this.goTop() },\n *       { sequence: ['D', 'D'], callback: () => this.deleteLine() },\n *     ])\n *   }\n * }\n * ```\n */\nexport function injectHotkeySequences(\n  sequences:\n    | Array<InjectHotkeySequenceDefinition>\n    | (() => Array<InjectHotkeySequenceDefinition>),\n  commonOptions:\n    | InjectHotkeySequenceOptions\n    | (() => InjectHotkeySequenceOptions) = {},\n): void {\n  type RegistrationRecord = {\n    handle: SequenceRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n  const destroyRef = inject(DestroyRef)\n\n  const registrations = new Map<string, RegistrationRecord>()\n\n  destroyRef.onDestroy(() => {\n    for (const { handle } of registrations.values()) {\n      if (handle.isActive) {\n        handle.unregister()\n      }\n    }\n    registrations.clear()\n  })\n\n  effect(() => {\n    const resolvedSequences =\n      typeof sequences === 'function' ? sequences() : sequences\n    const resolvedCommonOptions =\n      typeof commonOptions === 'function' ? commonOptions() : commonOptions\n\n    const nextKeys = new Set<string>()\n    const prepared: Array<{\n      registrationKey: string\n      def: InjectHotkeySequenceDefinition\n      resolvedSequence: HotkeySequence\n      enabled: boolean\n      sequenceOpts: Omit<InjectHotkeySequenceOptions, 'enabled'>\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < resolvedSequences.length; i++) {\n      const def = resolvedSequences[i]!\n      const resolvedSequence =\n        typeof def.sequence === 'function' ? def.sequence() : def.sequence\n      const resolvedDefOptions =\n        typeof def.options === 'function' ? def.options() : (def.options ?? {})\n\n      const mergedOptions = {\n        ...defaultOptions.hotkeySequence,\n        ...resolvedCommonOptions,\n        ...resolvedDefOptions,\n      } as InjectHotkeySequenceOptions\n\n      const { enabled = true, ...sequenceOpts } = mergedOptions\n\n      if (resolvedSequence.length === 0) {\n        continue\n      }\n\n      const resolvedTarget =\n        'target' in sequenceOpts\n          ? (sequenceOpts.target ?? null)\n          : typeof document !== 'undefined'\n            ? document\n            : null\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${formatHotkeySequence(resolvedSequence)}`\n      nextKeys.add(registrationKey)\n      prepared.push({\n        registrationKey,\n        def,\n        resolvedSequence,\n        enabled,\n        sequenceOpts,\n        resolvedTarget,\n      })\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 p of prepared) {\n      const existing = registrations.get(p.registrationKey)\n      if (existing?.handle.isActive && existing.target === p.resolvedTarget) {\n        existing.handle.callback = p.def.callback\n        const { target: _target, ...optionsWithoutTarget } = p.sequenceOpts\n        existing.handle.setOptions({\n          ...optionsWithoutTarget,\n          enabled: p.enabled,\n        })\n        continue\n      }\n\n      if (existing) {\n        if (existing.handle.isActive) {\n          existing.handle.unregister()\n        }\n        registrations.delete(p.registrationKey)\n      }\n\n      const handle = manager.register(p.resolvedSequence, p.def.callback, {\n        ...p.sequenceOpts,\n        enabled: p.enabled,\n        target: p.resolvedTarget,\n      })\n      registrations.set(p.registrationKey, {\n        handle,\n        target: p.resolvedTarget,\n      })\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,sBACd,WAGA,gBAE0C,EAAE,EACtC;CAMN,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,qDAA8B;CACpC,MAAM,uCAAoBC,yBAAW;CAErC,MAAM,gCAAgB,IAAI,KAAiC;AAE3D,YAAW,gBAAgB;AACzB,OAAK,MAAM,EAAE,YAAY,cAAc,QAAQ,CAC7C,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,gBAAc,OAAO;GACrB;AAEF,iCAAa;EACX,MAAM,oBACJ,OAAO,cAAc,aAAa,WAAW,GAAG;EAClD,MAAM,wBACJ,OAAO,kBAAkB,aAAa,eAAe,GAAG;EAE1D,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAOD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,kBAAkB,QAAQ,KAAK;GACjD,MAAM,MAAM,kBAAkB;GAC9B,MAAM,mBACJ,OAAO,IAAI,aAAa,aAAa,IAAI,UAAU,GAAG,IAAI;GAC5D,MAAM,qBACJ,OAAO,IAAI,YAAY,aAAa,IAAI,SAAS,GAAI,IAAI,WAAW,EAAE;GAQxE,MAAM,EAAE,UAAU,MAAM,GAAG,iBANL;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;AAID,OAAI,iBAAiB,WAAW,EAC9B;GAGF,MAAM,iBACJ,YAAY,eACP,aAAa,UAAU,OACxB,OAAO,aAAa,cAClB,WACA;AAER,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,+CAAwB,iBAAiB;AACtE,YAAS,IAAI,gBAAgB;AAC7B,YAAS,KAAK;IACZ;IACA;IACA;IACA;IACA;IACA;IACD,CAAC;;AAGJ,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,KAAK,UAAU;GACxB,MAAM,WAAW,cAAc,IAAI,EAAE,gBAAgB;AACrD,OAAI,UAAU,OAAO,YAAY,SAAS,WAAW,EAAE,gBAAgB;AACrE,aAAS,OAAO,WAAW,EAAE,IAAI;IACjC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;AACvD,aAAS,OAAO,WAAW;KACzB,GAAG;KACH,SAAS,EAAE;KACZ,CAAC;AACF;;AAGF,OAAI,UAAU;AACZ,QAAI,SAAS,OAAO,SAClB,UAAS,OAAO,YAAY;AAE9B,kBAAc,OAAO,EAAE,gBAAgB;;GAGzC,MAAM,SAAS,QAAQ,SAAS,EAAE,kBAAkB,EAAE,IAAI,UAAU;IAClE,GAAG,EAAE;IACL,SAAS,EAAE;IACX,QAAQ,EAAE;IACX,CAAC;AACF,iBAAc,IAAI,EAAE,iBAAiB;IACnC;IACA,QAAQ,EAAE;IACX,CAAC;;GAEJ"}

package/dist/injectHotkeySequences.d.cts

@@ -0,0 +1,47 @@
+import { InjectHotkeySequenceOptions } from "./injectHotkeySequence.cjs";
+import { HotkeyCallback, HotkeySequence } from "@tanstack/hotkeys";
+
+//#region src/injectHotkeySequences.d.ts
+/**
+ * A single sequence definition for use with `injectHotkeySequences`.
+ */
+interface InjectHotkeySequenceDefinition {
+  /** Array of hotkey strings that form the sequence */
+  sequence: HotkeySequence | (() => HotkeySequence);
+  /** The function to call when the sequence is completed */
+  callback: HotkeyCallback;
+  /** Per-sequence options (merged on top of commonOptions) */
+  options?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions);
+}
+/**
+ * Angular inject-based API for registering multiple keyboard shortcut sequences at once (Vim-style).
+ *
+ * Uses the singleton SequenceManager. Call in an injection context (e.g. constructor).
+ * Uses `effect()` to track reactive dependencies when definitions or options are getters.
+ *
+ * Options are merged in this order:
+ * provideHotkeys defaults < commonOptions < per-definition options
+ *
+ * Definitions with an empty `sequence` are skipped. Disabled sequences (`enabled: false`)
+ * remain registered so they stay visible in devtools; the core manager suppresses execution.
+ *
+ * @param sequences - Array of sequence definitions, or getter returning them
+ * @param commonOptions - Shared options for all sequences, or getter
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class VimComponent {
+ *   constructor() {
+ *     injectHotkeySequences([
+ *       { sequence: ['G', 'G'], callback: () => this.goTop() },
+ *       { sequence: ['D', 'D'], callback: () => this.deleteLine() },
+ *     ])
+ *   }
+ * }
+ * ```
+ */
+declare function injectHotkeySequences(sequences: Array<InjectHotkeySequenceDefinition> | (() => Array<InjectHotkeySequenceDefinition>), commonOptions?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions)): void;
+//#endregion
+export { InjectHotkeySequenceDefinition, injectHotkeySequences };
+//# sourceMappingURL=injectHotkeySequences.d.cts.map

package/dist/injectHotkeySequences.d.ts

@@ -0,0 +1,47 @@
+import { InjectHotkeySequenceOptions } from "./injectHotkeySequence.js";
+import { HotkeyCallback, HotkeySequence } from "@tanstack/hotkeys";
+
+//#region src/injectHotkeySequences.d.ts
+/**
+ * A single sequence definition for use with `injectHotkeySequences`.
+ */
+interface InjectHotkeySequenceDefinition {
+  /** Array of hotkey strings that form the sequence */
+  sequence: HotkeySequence | (() => HotkeySequence);
+  /** The function to call when the sequence is completed */
+  callback: HotkeyCallback;
+  /** Per-sequence options (merged on top of commonOptions) */
+  options?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions);
+}
+/**
+ * Angular inject-based API for registering multiple keyboard shortcut sequences at once (Vim-style).
+ *
+ * Uses the singleton SequenceManager. Call in an injection context (e.g. constructor).
+ * Uses `effect()` to track reactive dependencies when definitions or options are getters.
+ *
+ * Options are merged in this order:
+ * provideHotkeys defaults < commonOptions < per-definition options
+ *
+ * Definitions with an empty `sequence` are skipped. Disabled sequences (`enabled: false`)
+ * remain registered so they stay visible in devtools; the core manager suppresses execution.
+ *
+ * @param sequences - Array of sequence definitions, or getter returning them
+ * @param commonOptions - Shared options for all sequences, or getter
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class VimComponent {
+ *   constructor() {
+ *     injectHotkeySequences([
+ *       { sequence: ['G', 'G'], callback: () => this.goTop() },
+ *       { sequence: ['D', 'D'], callback: () => this.deleteLine() },
+ *     ])
+ *   }
+ * }
+ * ```
+ */
+declare function injectHotkeySequences(sequences: Array<InjectHotkeySequenceDefinition> | (() => Array<InjectHotkeySequenceDefinition>), commonOptions?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions)): void;
+//#endregion
+export { InjectHotkeySequenceDefinition, injectHotkeySequences };
+//# sourceMappingURL=injectHotkeySequences.d.ts.map

package/dist/injectHotkeySequences.js

@@ -0,0 +1,105 @@
+import { injectDefaultHotkeysOptions } from "./hotkeys-provider.js";
+import { formatHotkeySequence, getSequenceManager } from "@tanstack/hotkeys";
+import { DestroyRef, effect, inject } from "@angular/core";
+
+//#region src/injectHotkeySequences.ts
+/**
+* Angular inject-based API for registering multiple keyboard shortcut sequences at once (Vim-style).
+*
+* Uses the singleton SequenceManager. Call in an injection context (e.g. constructor).
+* Uses `effect()` to track reactive dependencies when definitions or options are getters.
+*
+* Options are merged in this order:
+* provideHotkeys defaults < commonOptions < per-definition options
+*
+* Definitions with an empty `sequence` are skipped. Disabled sequences (`enabled: false`)
+* remain registered so they stay visible in devtools; the core manager suppresses execution.
+*
+* @param sequences - Array of sequence definitions, or getter returning them
+* @param commonOptions - Shared options for all sequences, or getter
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class VimComponent {
+*   constructor() {
+*     injectHotkeySequences([
+*       { sequence: ['G', 'G'], callback: () => this.goTop() },
+*       { sequence: ['D', 'D'], callback: () => this.deleteLine() },
+*     ])
+*   }
+* }
+* ```
+*/
+function injectHotkeySequences(sequences, commonOptions = {}) {
+	const defaultOptions = injectDefaultHotkeysOptions();
+	const manager = getSequenceManager();
+	const destroyRef = inject(DestroyRef);
+	const registrations = /* @__PURE__ */ new Map();
+	destroyRef.onDestroy(() => {
+		for (const { handle } of registrations.values()) if (handle.isActive) handle.unregister();
+		registrations.clear();
+	});
+	effect(() => {
+		const resolvedSequences = typeof sequences === "function" ? sequences() : sequences;
+		const resolvedCommonOptions = typeof commonOptions === "function" ? commonOptions() : commonOptions;
+		const nextKeys = /* @__PURE__ */ new Set();
+		const prepared = [];
+		for (let i = 0; i < resolvedSequences.length; i++) {
+			const def = resolvedSequences[i];
+			const resolvedSequence = typeof def.sequence === "function" ? def.sequence() : def.sequence;
+			const resolvedDefOptions = typeof def.options === "function" ? def.options() : def.options ?? {};
+			const { enabled = true, ...sequenceOpts } = {
+				...defaultOptions.hotkeySequence,
+				...resolvedCommonOptions,
+				...resolvedDefOptions
+			};
+			if (resolvedSequence.length === 0) continue;
+			const resolvedTarget = "target" in sequenceOpts ? sequenceOpts.target ?? null : typeof document !== "undefined" ? document : null;
+			if (!resolvedTarget) continue;
+			const registrationKey = `${i}:${formatHotkeySequence(resolvedSequence)}`;
+			nextKeys.add(registrationKey);
+			prepared.push({
+				registrationKey,
+				def,
+				resolvedSequence,
+				enabled,
+				sequenceOpts,
+				resolvedTarget
+			});
+		}
+		for (const [key, record] of [...registrations.entries()]) if (!nextKeys.has(key)) {
+			if (record.handle.isActive) record.handle.unregister();
+			registrations.delete(key);
+		}
+		for (const p of prepared) {
+			const existing = registrations.get(p.registrationKey);
+			if (existing?.handle.isActive && existing.target === p.resolvedTarget) {
+				existing.handle.callback = p.def.callback;
+				const { target: _target, ...optionsWithoutTarget } = p.sequenceOpts;
+				existing.handle.setOptions({
+					...optionsWithoutTarget,
+					enabled: p.enabled
+				});
+				continue;
+			}
+			if (existing) {
+				if (existing.handle.isActive) existing.handle.unregister();
+				registrations.delete(p.registrationKey);
+			}
+			const handle = manager.register(p.resolvedSequence, p.def.callback, {
+				...p.sequenceOpts,
+				enabled: p.enabled,
+				target: p.resolvedTarget
+			});
+			registrations.set(p.registrationKey, {
+				handle,
+				target: p.resolvedTarget
+			});
+		}
+	});
+}
+
+//#endregion
+export { injectHotkeySequences };
+//# sourceMappingURL=injectHotkeySequences.js.map

package/dist/injectHotkeySequences.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectHotkeySequences.js","names":[],"sources":["../src/injectHotkeySequences.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type { InjectHotkeySequenceOptions } from './injectHotkeySequence'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\n/**\n * A single sequence definition for use with `injectHotkeySequences`.\n */\nexport interface InjectHotkeySequenceDefinition {\n  /** Array of hotkey strings that form the sequence */\n  sequence: HotkeySequence | (() => 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?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions)\n}\n\n/**\n * Angular inject-based API for registering multiple keyboard shortcut sequences at once (Vim-style).\n *\n * Uses the singleton SequenceManager. Call in an injection context (e.g. constructor).\n * Uses `effect()` to track reactive dependencies when definitions or options are getters.\n *\n * Options are merged in this order:\n * provideHotkeys defaults < commonOptions < per-definition options\n *\n * Definitions with an empty `sequence` are skipped. Disabled sequences (`enabled: false`)\n * remain registered so they stay visible in devtools; the core manager suppresses execution.\n *\n * @param sequences - Array of sequence definitions, or getter returning them\n * @param commonOptions - Shared options for all sequences, or getter\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class VimComponent {\n *   constructor() {\n *     injectHotkeySequences([\n *       { sequence: ['G', 'G'], callback: () => this.goTop() },\n *       { sequence: ['D', 'D'], callback: () => this.deleteLine() },\n *     ])\n *   }\n * }\n * ```\n */\nexport function injectHotkeySequences(\n  sequences:\n    | Array<InjectHotkeySequenceDefinition>\n    | (() => Array<InjectHotkeySequenceDefinition>),\n  commonOptions:\n    | InjectHotkeySequenceOptions\n    | (() => InjectHotkeySequenceOptions) = {},\n): void {\n  type RegistrationRecord = {\n    handle: SequenceRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n  const destroyRef = inject(DestroyRef)\n\n  const registrations = new Map<string, RegistrationRecord>()\n\n  destroyRef.onDestroy(() => {\n    for (const { handle } of registrations.values()) {\n      if (handle.isActive) {\n        handle.unregister()\n      }\n    }\n    registrations.clear()\n  })\n\n  effect(() => {\n    const resolvedSequences =\n      typeof sequences === 'function' ? sequences() : sequences\n    const resolvedCommonOptions =\n      typeof commonOptions === 'function' ? commonOptions() : commonOptions\n\n    const nextKeys = new Set<string>()\n    const prepared: Array<{\n      registrationKey: string\n      def: InjectHotkeySequenceDefinition\n      resolvedSequence: HotkeySequence\n      enabled: boolean\n      sequenceOpts: Omit<InjectHotkeySequenceOptions, 'enabled'>\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < resolvedSequences.length; i++) {\n      const def = resolvedSequences[i]!\n      const resolvedSequence =\n        typeof def.sequence === 'function' ? def.sequence() : def.sequence\n      const resolvedDefOptions =\n        typeof def.options === 'function' ? def.options() : (def.options ?? {})\n\n      const mergedOptions = {\n        ...defaultOptions.hotkeySequence,\n        ...resolvedCommonOptions,\n        ...resolvedDefOptions,\n      } as InjectHotkeySequenceOptions\n\n      const { enabled = true, ...sequenceOpts } = mergedOptions\n\n      if (resolvedSequence.length === 0) {\n        continue\n      }\n\n      const resolvedTarget =\n        'target' in sequenceOpts\n          ? (sequenceOpts.target ?? null)\n          : typeof document !== 'undefined'\n            ? document\n            : null\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${formatHotkeySequence(resolvedSequence)}`\n      nextKeys.add(registrationKey)\n      prepared.push({\n        registrationKey,\n        def,\n        resolvedSequence,\n        enabled,\n        sequenceOpts,\n        resolvedTarget,\n      })\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 p of prepared) {\n      const existing = registrations.get(p.registrationKey)\n      if (existing?.handle.isActive && existing.target === p.resolvedTarget) {\n        existing.handle.callback = p.def.callback\n        const { target: _target, ...optionsWithoutTarget } = p.sequenceOpts\n        existing.handle.setOptions({\n          ...optionsWithoutTarget,\n          enabled: p.enabled,\n        })\n        continue\n      }\n\n      if (existing) {\n        if (existing.handle.isActive) {\n          existing.handle.unregister()\n        }\n        registrations.delete(p.registrationKey)\n      }\n\n      const handle = manager.register(p.resolvedSequence, p.def.callback, {\n        ...p.sequenceOpts,\n        enabled: p.enabled,\n        target: p.resolvedTarget,\n      })\n      registrations.set(p.registrationKey, {\n        handle,\n        target: p.resolvedTarget,\n      })\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,sBACd,WAGA,gBAE0C,EAAE,EACtC;CAMN,MAAM,iBAAiB,6BAA6B;CACpD,MAAM,UAAU,oBAAoB;CACpC,MAAM,aAAa,OAAO,WAAW;CAErC,MAAM,gCAAgB,IAAI,KAAiC;AAE3D,YAAW,gBAAgB;AACzB,OAAK,MAAM,EAAE,YAAY,cAAc,QAAQ,CAC7C,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,gBAAc,OAAO;GACrB;AAEF,cAAa;EACX,MAAM,oBACJ,OAAO,cAAc,aAAa,WAAW,GAAG;EAClD,MAAM,wBACJ,OAAO,kBAAkB,aAAa,eAAe,GAAG;EAE1D,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAOD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,kBAAkB,QAAQ,KAAK;GACjD,MAAM,MAAM,kBAAkB;GAC9B,MAAM,mBACJ,OAAO,IAAI,aAAa,aAAa,IAAI,UAAU,GAAG,IAAI;GAC5D,MAAM,qBACJ,OAAO,IAAI,YAAY,aAAa,IAAI,SAAS,GAAI,IAAI,WAAW,EAAE;GAQxE,MAAM,EAAE,UAAU,MAAM,GAAG,iBANL;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;AAID,OAAI,iBAAiB,WAAW,EAC9B;GAGF,MAAM,iBACJ,YAAY,eACP,aAAa,UAAU,OACxB,OAAO,aAAa,cAClB,WACA;AAER,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,GAAG,qBAAqB,iBAAiB;AACtE,YAAS,IAAI,gBAAgB;AAC7B,YAAS,KAAK;IACZ;IACA;IACA;IACA;IACA;IACA;IACD,CAAC;;AAGJ,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,KAAK,UAAU;GACxB,MAAM,WAAW,cAAc,IAAI,EAAE,gBAAgB;AACrD,OAAI,UAAU,OAAO,YAAY,SAAS,WAAW,EAAE,gBAAgB;AACrE,aAAS,OAAO,WAAW,EAAE,IAAI;IACjC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;AACvD,aAAS,OAAO,WAAW;KACzB,GAAG;KACH,SAAS,EAAE;KACZ,CAAC;AACF;;AAGF,OAAI,UAAU;AACZ,QAAI,SAAS,OAAO,SAClB,UAAS,OAAO,YAAY;AAE9B,kBAAc,OAAO,EAAE,gBAAgB;;GAGzC,MAAM,SAAS,QAAQ,SAAS,EAAE,kBAAkB,EAAE,IAAI,UAAU;IAClE,GAAG,EAAE;IACL,SAAS,EAAE;IACX,QAAQ,EAAE;IACX,CAAC;AACF,iBAAc,IAAI,EAAE,iBAAiB;IACnC;IACA,QAAQ,EAAE;IACX,CAAC;;GAEJ"}

package/package.json

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

package/src/index.ts

@@ -8,6 +8,7 @@ export * from './hotkeys-provider'
 export * from './injectHotkey'
 export * from './injectHotkeys'
 export * from './injectHotkeySequence'
+export * from './injectHotkeySequences'
 export * from './injectHeldKeys'
 export * from './injectHeldKeyCodes'
 export * from './injectKeyHold'

package/src/injectHotkey.ts

@@ -1,4 +1,4 @@
-import { effect } from '@angular/core'
+import { DestroyRef, effect, inject } from '@angular/core'
 import {
   detectPlatform,
   formatHotkey,
@@ -10,6 +10,7 @@ import type {
   Hotkey,
   HotkeyCallback,
   HotkeyOptions,
+  HotkeyRegistrationHandle,
   RegisterableHotkey,
 } from '@tanstack/hotkeys'
 
@@ -34,6 +35,8 @@ export 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
@@ -87,8 +90,22 @@ export function injectHotkey(
 ): void {
   const defaultOptions = injectDefaultHotkeysOptions()
   const manager = getHotkeyManager()
+  const destroyRef = inject(DestroyRef)
 
-  effect((onCleanup) => {
+  let registration: HotkeyRegistrationHandle | null = null
+  let lastHotkeyString: Hotkey | null = null
+  let lastTarget: HTMLElement | Document | Window | null = null
+
+  destroyRef.onDestroy(() => {
+    if (registration?.isActive) {
+      registration.unregister()
+      registration = null
+    }
+    lastHotkeyString = null
+    lastTarget = null
+  })
+
+  effect(() => {
     // Resolve reactive values
     const resolvedHotkey = typeof hotkey === 'function' ? hotkey() : hotkey
     const resolvedOptions = typeof options === 'function' ? options() : options
@@ -117,29 +134,44 @@ export function injectHotkey(
           : null
 
     if (!resolvedTarget) {
+      if (registration?.isActive) {
+        registration.unregister()
+        registration = null
+      }
+      lastHotkeyString = null
+      lastTarget = null
       return
     }
 
     // Extract options without target (target is handled separately)
     const { target: _target, ...optionsWithoutTarget } = mergedOptions
 
-    // Register the hotkey
-    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,
     })
 
-    // Update callback and options on every effect run
     if (registration.isActive) {
       registration.callback = callback
       registration.setOptions(optionsWithoutTarget)
     }
 
-    // Cleanup on disposal
-    onCleanup(() => {
-      if (registration.isActive) {
-        registration.unregister()
-      }
-    })
+    lastHotkeyString = hotkeyString
+    lastTarget = resolvedTarget
   })
 }

package/src/injectHotkeySequence.ts

@@ -1,18 +1,27 @@
-import { effect } from '@angular/core'
-import { getSequenceManager } from '@tanstack/hotkeys'
+import { DestroyRef, effect, inject } from '@angular/core'
+import { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'
 import { injectDefaultHotkeysOptions } from './hotkeys-provider'
 import type {
   HotkeyCallback,
   HotkeySequence,
   SequenceOptions,
+  SequenceRegistrationHandle,
 } from '@tanstack/hotkeys'
 
+type SequenceTarget = Document | HTMLElement | Window
+
 export interface InjectHotkeySequenceOptions extends Omit<
   SequenceOptions,
-  'enabled'
+  '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
 }
 
 /**
@@ -28,7 +37,8 @@ export interface InjectHotkeySequenceOptions extends Omit<
  *
  * @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
@@ -53,8 +63,23 @@ export function injectHotkeySequence(
     | (() => InjectHotkeySequenceOptions) = {},
 ): void {
   const defaultOptions = injectDefaultHotkeysOptions()
+  const manager = getSequenceManager()
+  const destroyRef = inject(DestroyRef)
+
+  let handle: SequenceRegistrationHandle | null = null
+  let lastSequenceKey: string | null = null
+  let lastTarget: SequenceTarget | null = null
 
-  effect((onCleanup) => {
+  destroyRef.onDestroy(() => {
+    if (handle?.isActive) {
+      handle.unregister()
+      handle = null
+    }
+    lastSequenceKey = null
+    lastTarget = null
+  })
+
+  effect(() => {
     // Resolve reactive values
     const resolvedSequence =
       typeof sequence === 'function' ? sequence() : sequence
@@ -67,27 +92,49 @@ export function injectHotkeySequence(
 
     const { enabled = true, ...sequenceOptions } = mergedOptions
 
-    if (!enabled || resolvedSequence.length === 0) {
+    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 manager = getSequenceManager()
+    const sequenceKey = formatHotkeySequence(resolvedSequence)
 
-    // Pass through options; default target to document when not provided
-    const registerOptions: SequenceOptions = {
+    const registerPayload: SequenceOptions = {
       ...sequenceOptions,
-      enabled: true,
-      target:
-        sequenceOptions.target ??
-        (typeof document !== 'undefined' ? document : undefined),
+      enabled,
+      target: resolvedTarget,
     }
+    const { target: _t, ...optionsWithoutTarget } = registerPayload
 
-    const handle = manager.register(resolvedSequence, callback, registerOptions)
+    if (
+      handle?.isActive &&
+      lastSequenceKey === sequenceKey &&
+      lastTarget === resolvedTarget
+    ) {
+      handle.callback = callback
+      handle.setOptions(optionsWithoutTarget)
+      return
+    }
 
-    onCleanup(() => {
-      if (handle.isActive) {
-        handle.unregister()
-      }
-    })
+    if (handle?.isActive) {
+      handle.unregister()
+      handle = null
+    }
+
+    handle = manager.register(resolvedSequence, callback, registerPayload)
+    lastSequenceKey = sequenceKey
+    lastTarget = resolvedTarget
   })
 }