@tanstack/angular-hotkeys 0.4.2 → 0.5.1

package/dist/index.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 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_injectHeldKeys = require('./injectHeldKeys.cjs');
 const require_injectHeldKeyCodes = require('./injectHeldKeyCodes.cjs');
@@ -14,6 +15,7 @@ exports.injectHeldKeys = require_injectHeldKeys.injectHeldKeys;
 exports.injectHotkey = require_injectHotkey.injectHotkey;
 exports.injectHotkeyRecorder = require_injectHotkeyRecorder.injectHotkeyRecorder;
 exports.injectHotkeySequence = require_injectHotkeySequence.injectHotkeySequence;
+exports.injectHotkeys = require_injectHotkeys.injectHotkeys;
 exports.injectHotkeysContext = require_hotkeys_provider.injectHotkeysContext;
 exports.injectKeyHold = require_injectKeyHold.injectKeyHold;
 exports.provideHotkeys = require_hotkeys_provider.provideHotkeys;

package/dist/index.d.cts

@@ -1,9 +1,10 @@
 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 { injectHeldKeys } from "./injectHeldKeys.cjs";
 import { injectHeldKeyCodes } from "./injectHeldKeyCodes.cjs";
 import { injectKeyHold } from "./injectKeyHold.cjs";
 import { AngularHotkeyRecorder, injectHotkeyRecorder } from "./injectHotkeyRecorder.cjs";
 export * from "@tanstack/hotkeys";
-export { AngularHotkeyRecorder, HOTKEYS_INJECTION_TOKEN, HotkeysContextValue, HotkeysProviderOptions, InjectHotkeyOptions, InjectHotkeySequenceOptions, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeysContext, injectKeyHold, provideHotkeys };
+export { AngularHotkeyRecorder, HOTKEYS_INJECTION_TOKEN, HotkeysContextValue, HotkeysProviderOptions, InjectHotkeyDefinition, InjectHotkeyOptions, InjectHotkeySequenceOptions, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeys, injectHotkeysContext, injectKeyHold, provideHotkeys };

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 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 { injectHeldKeys } from "./injectHeldKeys.js";
 import { injectHeldKeyCodes } from "./injectHeldKeyCodes.js";
 import { injectKeyHold } from "./injectKeyHold.js";
 import { AngularHotkeyRecorder, injectHotkeyRecorder } from "./injectHotkeyRecorder.js";
 export * from "@tanstack/hotkeys";
-export { AngularHotkeyRecorder, HOTKEYS_INJECTION_TOKEN, HotkeysContextValue, HotkeysProviderOptions, InjectHotkeyOptions, InjectHotkeySequenceOptions, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeysContext, injectKeyHold, provideHotkeys };
+export { AngularHotkeyRecorder, HOTKEYS_INJECTION_TOKEN, HotkeysContextValue, HotkeysProviderOptions, InjectHotkeyDefinition, InjectHotkeyOptions, InjectHotkeySequenceOptions, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeys, injectHotkeysContext, injectKeyHold, provideHotkeys };

package/dist/index.js

@@ -1,5 +1,6 @@
 import { HOTKEYS_INJECTION_TOKEN, injectDefaultHotkeysOptions, injectHotkeysContext, provideHotkeys } from "./hotkeys-provider.js";
 import { injectHotkey } from "./injectHotkey.js";
+import { injectHotkeys } from "./injectHotkeys.js";
 import { injectHotkeySequence } from "./injectHotkeySequence.js";
 import { injectHeldKeys } from "./injectHeldKeys.js";
 import { injectHeldKeyCodes } from "./injectHeldKeyCodes.js";
@@ -8,4 +9,4 @@ import { injectHotkeyRecorder } from "./injectHotkeyRecorder.js";
 
 export * from "@tanstack/hotkeys"
 
-export { HOTKEYS_INJECTION_TOKEN, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeysContext, injectKeyHold, provideHotkeys };
+export { HOTKEYS_INJECTION_TOKEN, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeySequence, injectHotkeys, injectHotkeysContext, injectKeyHold, provideHotkeys };

package/dist/injectHotkeySequence.cjs

@@ -9,6 +9,11 @@ let _angular_core = require("@angular/core");
 * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger
 * when the full sequence is pressed within a timeout.
 *
+* Each step may include modifiers. You can chain the same modifier across
+* steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
+* Control, Alt, or Meta pressed alone) are ignored while matching—they do not
+* advance the sequence or reset progress.
+*
 * @param sequence - Array of hotkey strings that form the sequence (or getter function)
 * @param callback - Function to call when the sequence is completed
 * @param options - Options for the sequence behavior (or getter function)
@@ -23,6 +28,7 @@ let _angular_core = require("@angular/core");
 *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))
 *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))
 *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })
+*     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))
 *   }
 * }
 * ```

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 * @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 *   }\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,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"],"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"}

package/dist/injectHotkeySequence.d.cts

@@ -11,6 +11,11 @@ interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled'> {
  * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger
  * when the full sequence is pressed within a timeout.
  *
+ * Each step may include modifiers. You can chain the same modifier across
+ * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
+ * Control, Alt, or Meta pressed alone) are ignored while matching—they do not
+ * advance the sequence or reset progress.
+ *
  * @param sequence - Array of hotkey strings that form the sequence (or getter function)
  * @param callback - Function to call when the sequence is completed
  * @param options - Options for the sequence behavior (or getter function)
@@ -25,6 +30,7 @@ interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled'> {
  *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))
  *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))
  *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })
+ *     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))
  *   }
  * }
  * ```

package/dist/injectHotkeySequence.d.ts

@@ -11,6 +11,11 @@ interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled'> {
  * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger
  * when the full sequence is pressed within a timeout.
  *
+ * Each step may include modifiers. You can chain the same modifier across
+ * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
+ * Control, Alt, or Meta pressed alone) are ignored while matching—they do not
+ * advance the sequence or reset progress.
+ *
  * @param sequence - Array of hotkey strings that form the sequence (or getter function)
  * @param callback - Function to call when the sequence is completed
  * @param options - Options for the sequence behavior (or getter function)
@@ -25,6 +30,7 @@ interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled'> {
  *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))
  *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))
  *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })
+ *     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))
  *   }
  * }
  * ```

package/dist/injectHotkeySequence.js

@@ -9,6 +9,11 @@ import { effect } from "@angular/core";
 * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger
 * when the full sequence is pressed within a timeout.
 *
+* Each step may include modifiers. You can chain the same modifier across
+* steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
+* Control, Alt, or Meta pressed alone) are ignored while matching—they do not
+* advance the sequence or reset progress.
+*
 * @param sequence - Array of hotkey strings that form the sequence (or getter function)
 * @param callback - Function to call when the sequence is completed
 * @param options - Options for the sequence behavior (or getter function)
@@ -23,6 +28,7 @@ import { effect } from "@angular/core";
 *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))
 *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))
 *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })
+*     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))
 *   }
 * }
 * ```

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 * @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 *   }\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,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 { 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"}

package/dist/injectHotkeys.cjs

@@ -0,0 +1,121 @@
+const require_hotkeys_provider = require('./hotkeys-provider.cjs');
+let _tanstack_hotkeys = require("@tanstack/hotkeys");
+let _angular_core = require("@angular/core");
+
+//#region src/injectHotkeys.ts
+/**
+* Angular inject-based API for registering multiple keyboard hotkeys at once.
+*
+* Uses the singleton HotkeyManager for efficient event handling.
+* Accepts a dynamic array of hotkey definitions.
+*
+* Call in an injection context (e.g. constructor or field initializer).
+* Uses effect() to track reactive dependencies and update registrations
+* when options or the callback change.
+*
+* Options are merged in this order:
+* provideHotkeys defaults < commonOptions < per-definition options
+*
+* @param hotkeys - Array of hotkey definitions, or getter returning them
+* @param commonOptions - Shared options for all hotkeys, or getter
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class EditorComponent {
+*   constructor() {
+*     injectHotkeys([
+*       { hotkey: 'Mod+S', callback: () => this.save() },
+*       { hotkey: 'Mod+Z', callback: () => this.undo() },
+*       { hotkey: 'Escape', callback: () => this.close() },
+*     ])
+*   }
+* }
+* ```
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class DynamicShortcuts {
+*   shortcuts = signal([...])
+*
+*   constructor() {
+*     injectHotkeys(
+*       () => this.shortcuts().map((s) => ({
+*         hotkey: s.key,
+*         callback: s.action,
+*       })),
+*     )
+*   }
+* }
+* ```
+*/
+function injectHotkeys(hotkeys, commonOptions = {}) {
+	const defaultOptions = require_hotkeys_provider.injectDefaultHotkeysOptions();
+	const manager = (0, _tanstack_hotkeys.getHotkeyManager)();
+	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 resolvedHotkeys = typeof hotkeys === "function" ? hotkeys() : hotkeys;
+		const resolvedCommonOptions = typeof commonOptions === "function" ? commonOptions() : commonOptions;
+		const nextKeys = /* @__PURE__ */ new Set();
+		const prepared = [];
+		for (let i = 0; i < resolvedHotkeys.length; i++) {
+			const def = resolvedHotkeys[i];
+			const resolvedHotkey = typeof def.hotkey === "function" ? def.hotkey() : def.hotkey;
+			const resolvedDefOptions = typeof def.options === "function" ? def.options() : def.options ?? {};
+			const mergedOptions = {
+				...defaultOptions.hotkey,
+				...resolvedCommonOptions,
+				...resolvedDefOptions
+			};
+			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) continue;
+			const registrationKey = `${i}:${hotkeyString}`;
+			nextKeys.add(registrationKey);
+			prepared.push({
+				registrationKey,
+				def,
+				mergedOptions,
+				hotkeyString,
+				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.mergedOptions;
+				existing.handle.setOptions(optionsWithoutTarget);
+				continue;
+			}
+			if (existing) {
+				if (existing.handle.isActive) existing.handle.unregister();
+				registrations.delete(p.registrationKey);
+			}
+			const { target: _target, ...optionsWithoutTarget } = p.mergedOptions;
+			const handle = manager.register(p.hotkeyString, p.def.callback, {
+				...optionsWithoutTarget,
+				target: p.resolvedTarget
+			});
+			registrations.set(p.registrationKey, {
+				handle,
+				target: p.resolvedTarget
+			});
+		}
+	});
+}
+
+//#endregion
+exports.injectHotkeys = injectHotkeys;
+//# sourceMappingURL=injectHotkeys.cjs.map

package/dist/injectHotkeys.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectHotkeys.cjs","names":["injectDefaultHotkeysOptions","DestroyRef"],"sources":["../src/injectHotkeys.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 { InjectHotkeyOptions } from './injectHotkey'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\n/**\n * A single hotkey definition for use with `injectHotkeys`.\n */\nexport interface InjectHotkeyDefinition {\n  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey)\n  /** The function to call when the hotkey is pressed */\n  callback: HotkeyCallback\n  /** Per-hotkey options (merged on top of commonOptions) */\n  options?: InjectHotkeyOptions | (() => InjectHotkeyOptions)\n}\n\n/**\n * Angular inject-based API for registering multiple keyboard hotkeys at once.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * Accepts a dynamic array of hotkey definitions.\n *\n * Call in an injection context (e.g. constructor or field initializer).\n * Uses effect() to track reactive dependencies and update registrations\n * when options or the callback change.\n *\n * Options are merged in this order:\n * provideHotkeys defaults < commonOptions < per-definition options\n *\n * @param hotkeys - Array of hotkey definitions, or getter returning them\n * @param commonOptions - Shared options for all hotkeys, or getter\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class EditorComponent {\n *   constructor() {\n *     injectHotkeys([\n *       { hotkey: 'Mod+S', callback: () => this.save() },\n *       { hotkey: 'Mod+Z', callback: () => this.undo() },\n *       { hotkey: 'Escape', callback: () => this.close() },\n *     ])\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class DynamicShortcuts {\n *   shortcuts = signal([...])\n *\n *   constructor() {\n *     injectHotkeys(\n *       () => this.shortcuts().map((s) => ({\n *         hotkey: s.key,\n *         callback: s.action,\n *       })),\n *     )\n *   }\n * }\n * ```\n */\nexport function injectHotkeys(\n  hotkeys:\n    | Array<InjectHotkeyDefinition>\n    | (() => Array<InjectHotkeyDefinition>),\n  commonOptions: InjectHotkeyOptions | (() => InjectHotkeyOptions) = {},\n): void {\n  type RegistrationRecord = {\n    handle: HotkeyRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\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 resolvedHotkeys = typeof hotkeys === 'function' ? hotkeys() : hotkeys\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: InjectHotkeyDefinition\n      mergedOptions: InjectHotkeyOptions\n      hotkeyString: Hotkey\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < resolvedHotkeys.length; i++) {\n      const def = resolvedHotkeys[i]!\n      const resolvedHotkey =\n        typeof def.hotkey === 'function' ? def.hotkey() : def.hotkey\n      const resolvedDefOptions =\n        typeof def.options === 'function' ? def.options() : (def.options ?? {})\n\n      const mergedOptions = {\n        ...defaultOptions.hotkey,\n        ...resolvedCommonOptions,\n        ...resolvedDefOptions,\n      } as InjectHotkeyOptions\n\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      const resolvedTarget =\n        'target' in mergedOptions\n          ? (mergedOptions.target ?? null)\n          : typeof document !== 'undefined'\n            ? document\n            : null\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${hotkeyString}`\n      nextKeys.add(registrationKey)\n      prepared.push({\n        registrationKey,\n        def,\n        mergedOptions,\n        hotkeyString,\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.mergedOptions\n        existing.handle.setOptions(optionsWithoutTarget)\n        continue\n      }\n\n      if (existing) {\n        if (existing.handle.isActive) {\n          existing.handle.unregister()\n        }\n        registrations.delete(p.registrationKey)\n      }\n\n      const { target: _target, ...optionsWithoutTarget } = p.mergedOptions\n      const handle = manager.register(p.hotkeyString, p.def.callback, {\n        ...optionsWithoutTarget,\n        target: p.resolvedTarget,\n      })\n      registrations.set(p.registrationKey, {\n        handle,\n        target: p.resolvedTarget,\n      })\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAgB,cACd,SAGA,gBAAmE,EAAE,EAC/D;CAMN,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,mDAA4B;CAClC,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,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EACpE,MAAM,wBACJ,OAAO,kBAAkB,aAAa,eAAe,GAAG;EAE1D,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAMD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK;GAC/C,MAAM,MAAM,gBAAgB;GAC5B,MAAM,iBACJ,OAAO,IAAI,WAAW,aAAa,IAAI,QAAQ,GAAG,IAAI;GACxD,MAAM,qBACJ,OAAO,IAAI,YAAY,aAAa,IAAI,SAAS,GAAI,IAAI,WAAW,EAAE;GAExE,MAAM,gBAAgB;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;GAED,MAAM,WAAW,cAAc,mDAA4B;GAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,oGAE0B,gBAAgB,SAAS,CAClD;GAEP,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,GAAG;AAChC,YAAS,IAAI,gBAAgB;AAC7B,YAAS,KAAK;IACZ;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,qBAAqB;AAChD;;AAGF,OAAI,UAAU;AACZ,QAAI,SAAS,OAAO,SAClB,UAAS,OAAO,YAAY;AAE9B,kBAAc,OAAO,EAAE,gBAAgB;;GAGzC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;GACvD,MAAM,SAAS,QAAQ,SAAS,EAAE,cAAc,EAAE,IAAI,UAAU;IAC9D,GAAG;IACH,QAAQ,EAAE;IACX,CAAC;AACF,iBAAc,IAAI,EAAE,iBAAiB;IACnC;IACA,QAAQ,EAAE;IACX,CAAC;;GAEJ"}

package/dist/injectHotkeys.d.cts

@@ -0,0 +1,66 @@
+import { InjectHotkeyOptions } from "./injectHotkey.cjs";
+import { HotkeyCallback, RegisterableHotkey } from "@tanstack/hotkeys";
+
+//#region src/injectHotkeys.d.ts
+/**
+ * A single hotkey definition for use with `injectHotkeys`.
+ */
+interface InjectHotkeyDefinition {
+  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */
+  hotkey: RegisterableHotkey | (() => RegisterableHotkey);
+  /** The function to call when the hotkey is pressed */
+  callback: HotkeyCallback;
+  /** Per-hotkey options (merged on top of commonOptions) */
+  options?: InjectHotkeyOptions | (() => InjectHotkeyOptions);
+}
+/**
+ * Angular inject-based API for registering multiple keyboard hotkeys at once.
+ *
+ * Uses the singleton HotkeyManager for efficient event handling.
+ * Accepts a dynamic array of hotkey definitions.
+ *
+ * Call in an injection context (e.g. constructor or field initializer).
+ * Uses effect() to track reactive dependencies and update registrations
+ * when options or the callback change.
+ *
+ * Options are merged in this order:
+ * provideHotkeys defaults < commonOptions < per-definition options
+ *
+ * @param hotkeys - Array of hotkey definitions, or getter returning them
+ * @param commonOptions - Shared options for all hotkeys, or getter
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class EditorComponent {
+ *   constructor() {
+ *     injectHotkeys([
+ *       { hotkey: 'Mod+S', callback: () => this.save() },
+ *       { hotkey: 'Mod+Z', callback: () => this.undo() },
+ *       { hotkey: 'Escape', callback: () => this.close() },
+ *     ])
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class DynamicShortcuts {
+ *   shortcuts = signal([...])
+ *
+ *   constructor() {
+ *     injectHotkeys(
+ *       () => this.shortcuts().map((s) => ({
+ *         hotkey: s.key,
+ *         callback: s.action,
+ *       })),
+ *     )
+ *   }
+ * }
+ * ```
+ */
+declare function injectHotkeys(hotkeys: Array<InjectHotkeyDefinition> | (() => Array<InjectHotkeyDefinition>), commonOptions?: InjectHotkeyOptions | (() => InjectHotkeyOptions)): void;
+//#endregion
+export { InjectHotkeyDefinition, injectHotkeys };
+//# sourceMappingURL=injectHotkeys.d.cts.map

package/dist/injectHotkeys.d.ts

@@ -0,0 +1,66 @@
+import { InjectHotkeyOptions } from "./injectHotkey.js";
+import { HotkeyCallback, RegisterableHotkey } from "@tanstack/hotkeys";
+
+//#region src/injectHotkeys.d.ts
+/**
+ * A single hotkey definition for use with `injectHotkeys`.
+ */
+interface InjectHotkeyDefinition {
+  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */
+  hotkey: RegisterableHotkey | (() => RegisterableHotkey);
+  /** The function to call when the hotkey is pressed */
+  callback: HotkeyCallback;
+  /** Per-hotkey options (merged on top of commonOptions) */
+  options?: InjectHotkeyOptions | (() => InjectHotkeyOptions);
+}
+/**
+ * Angular inject-based API for registering multiple keyboard hotkeys at once.
+ *
+ * Uses the singleton HotkeyManager for efficient event handling.
+ * Accepts a dynamic array of hotkey definitions.
+ *
+ * Call in an injection context (e.g. constructor or field initializer).
+ * Uses effect() to track reactive dependencies and update registrations
+ * when options or the callback change.
+ *
+ * Options are merged in this order:
+ * provideHotkeys defaults < commonOptions < per-definition options
+ *
+ * @param hotkeys - Array of hotkey definitions, or getter returning them
+ * @param commonOptions - Shared options for all hotkeys, or getter
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class EditorComponent {
+ *   constructor() {
+ *     injectHotkeys([
+ *       { hotkey: 'Mod+S', callback: () => this.save() },
+ *       { hotkey: 'Mod+Z', callback: () => this.undo() },
+ *       { hotkey: 'Escape', callback: () => this.close() },
+ *     ])
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class DynamicShortcuts {
+ *   shortcuts = signal([...])
+ *
+ *   constructor() {
+ *     injectHotkeys(
+ *       () => this.shortcuts().map((s) => ({
+ *         hotkey: s.key,
+ *         callback: s.action,
+ *       })),
+ *     )
+ *   }
+ * }
+ * ```
+ */
+declare function injectHotkeys(hotkeys: Array<InjectHotkeyDefinition> | (() => Array<InjectHotkeyDefinition>), commonOptions?: InjectHotkeyOptions | (() => InjectHotkeyOptions)): void;
+//#endregion
+export { InjectHotkeyDefinition, injectHotkeys };
+//# sourceMappingURL=injectHotkeys.d.ts.map

package/dist/injectHotkeys.js

@@ -0,0 +1,121 @@
+import { injectDefaultHotkeysOptions } from "./hotkeys-provider.js";
+import { detectPlatform, formatHotkey, getHotkeyManager, rawHotkeyToParsedHotkey } from "@tanstack/hotkeys";
+import { DestroyRef, effect, inject } from "@angular/core";
+
+//#region src/injectHotkeys.ts
+/**
+* Angular inject-based API for registering multiple keyboard hotkeys at once.
+*
+* Uses the singleton HotkeyManager for efficient event handling.
+* Accepts a dynamic array of hotkey definitions.
+*
+* Call in an injection context (e.g. constructor or field initializer).
+* Uses effect() to track reactive dependencies and update registrations
+* when options or the callback change.
+*
+* Options are merged in this order:
+* provideHotkeys defaults < commonOptions < per-definition options
+*
+* @param hotkeys - Array of hotkey definitions, or getter returning them
+* @param commonOptions - Shared options for all hotkeys, or getter
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class EditorComponent {
+*   constructor() {
+*     injectHotkeys([
+*       { hotkey: 'Mod+S', callback: () => this.save() },
+*       { hotkey: 'Mod+Z', callback: () => this.undo() },
+*       { hotkey: 'Escape', callback: () => this.close() },
+*     ])
+*   }
+* }
+* ```
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class DynamicShortcuts {
+*   shortcuts = signal([...])
+*
+*   constructor() {
+*     injectHotkeys(
+*       () => this.shortcuts().map((s) => ({
+*         hotkey: s.key,
+*         callback: s.action,
+*       })),
+*     )
+*   }
+* }
+* ```
+*/
+function injectHotkeys(hotkeys, commonOptions = {}) {
+	const defaultOptions = injectDefaultHotkeysOptions();
+	const manager = getHotkeyManager();
+	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 resolvedHotkeys = typeof hotkeys === "function" ? hotkeys() : hotkeys;
+		const resolvedCommonOptions = typeof commonOptions === "function" ? commonOptions() : commonOptions;
+		const nextKeys = /* @__PURE__ */ new Set();
+		const prepared = [];
+		for (let i = 0; i < resolvedHotkeys.length; i++) {
+			const def = resolvedHotkeys[i];
+			const resolvedHotkey = typeof def.hotkey === "function" ? def.hotkey() : def.hotkey;
+			const resolvedDefOptions = typeof def.options === "function" ? def.options() : def.options ?? {};
+			const mergedOptions = {
+				...defaultOptions.hotkey,
+				...resolvedCommonOptions,
+				...resolvedDefOptions
+			};
+			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) continue;
+			const registrationKey = `${i}:${hotkeyString}`;
+			nextKeys.add(registrationKey);
+			prepared.push({
+				registrationKey,
+				def,
+				mergedOptions,
+				hotkeyString,
+				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.mergedOptions;
+				existing.handle.setOptions(optionsWithoutTarget);
+				continue;
+			}
+			if (existing) {
+				if (existing.handle.isActive) existing.handle.unregister();
+				registrations.delete(p.registrationKey);
+			}
+			const { target: _target, ...optionsWithoutTarget } = p.mergedOptions;
+			const handle = manager.register(p.hotkeyString, p.def.callback, {
+				...optionsWithoutTarget,
+				target: p.resolvedTarget
+			});
+			registrations.set(p.registrationKey, {
+				handle,
+				target: p.resolvedTarget
+			});
+		}
+	});
+}
+
+//#endregion
+export { injectHotkeys };
+//# sourceMappingURL=injectHotkeys.js.map

package/dist/injectHotkeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectHotkeys.js","names":[],"sources":["../src/injectHotkeys.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 { InjectHotkeyOptions } from './injectHotkey'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\n/**\n * A single hotkey definition for use with `injectHotkeys`.\n */\nexport interface InjectHotkeyDefinition {\n  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey)\n  /** The function to call when the hotkey is pressed */\n  callback: HotkeyCallback\n  /** Per-hotkey options (merged on top of commonOptions) */\n  options?: InjectHotkeyOptions | (() => InjectHotkeyOptions)\n}\n\n/**\n * Angular inject-based API for registering multiple keyboard hotkeys at once.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * Accepts a dynamic array of hotkey definitions.\n *\n * Call in an injection context (e.g. constructor or field initializer).\n * Uses effect() to track reactive dependencies and update registrations\n * when options or the callback change.\n *\n * Options are merged in this order:\n * provideHotkeys defaults < commonOptions < per-definition options\n *\n * @param hotkeys - Array of hotkey definitions, or getter returning them\n * @param commonOptions - Shared options for all hotkeys, or getter\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class EditorComponent {\n *   constructor() {\n *     injectHotkeys([\n *       { hotkey: 'Mod+S', callback: () => this.save() },\n *       { hotkey: 'Mod+Z', callback: () => this.undo() },\n *       { hotkey: 'Escape', callback: () => this.close() },\n *     ])\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class DynamicShortcuts {\n *   shortcuts = signal([...])\n *\n *   constructor() {\n *     injectHotkeys(\n *       () => this.shortcuts().map((s) => ({\n *         hotkey: s.key,\n *         callback: s.action,\n *       })),\n *     )\n *   }\n * }\n * ```\n */\nexport function injectHotkeys(\n  hotkeys:\n    | Array<InjectHotkeyDefinition>\n    | (() => Array<InjectHotkeyDefinition>),\n  commonOptions: InjectHotkeyOptions | (() => InjectHotkeyOptions) = {},\n): void {\n  type RegistrationRecord = {\n    handle: HotkeyRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\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 resolvedHotkeys = typeof hotkeys === 'function' ? hotkeys() : hotkeys\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: InjectHotkeyDefinition\n      mergedOptions: InjectHotkeyOptions\n      hotkeyString: Hotkey\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < resolvedHotkeys.length; i++) {\n      const def = resolvedHotkeys[i]!\n      const resolvedHotkey =\n        typeof def.hotkey === 'function' ? def.hotkey() : def.hotkey\n      const resolvedDefOptions =\n        typeof def.options === 'function' ? def.options() : (def.options ?? {})\n\n      const mergedOptions = {\n        ...defaultOptions.hotkey,\n        ...resolvedCommonOptions,\n        ...resolvedDefOptions,\n      } as InjectHotkeyOptions\n\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      const resolvedTarget =\n        'target' in mergedOptions\n          ? (mergedOptions.target ?? null)\n          : typeof document !== 'undefined'\n            ? document\n            : null\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${hotkeyString}`\n      nextKeys.add(registrationKey)\n      prepared.push({\n        registrationKey,\n        def,\n        mergedOptions,\n        hotkeyString,\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.mergedOptions\n        existing.handle.setOptions(optionsWithoutTarget)\n        continue\n      }\n\n      if (existing) {\n        if (existing.handle.isActive) {\n          existing.handle.unregister()\n        }\n        registrations.delete(p.registrationKey)\n      }\n\n      const { target: _target, ...optionsWithoutTarget } = p.mergedOptions\n      const handle = manager.register(p.hotkeyString, p.def.callback, {\n        ...optionsWithoutTarget,\n        target: p.resolvedTarget,\n      })\n      registrations.set(p.registrationKey, {\n        handle,\n        target: p.resolvedTarget,\n      })\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAgB,cACd,SAGA,gBAAmE,EAAE,EAC/D;CAMN,MAAM,iBAAiB,6BAA6B;CACpD,MAAM,UAAU,kBAAkB;CAClC,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,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EACpE,MAAM,wBACJ,OAAO,kBAAkB,aAAa,eAAe,GAAG;EAE1D,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAMD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK;GAC/C,MAAM,MAAM,gBAAgB;GAC5B,MAAM,iBACJ,OAAO,IAAI,WAAW,aAAa,IAAI,QAAQ,GAAG,IAAI;GACxD,MAAM,qBACJ,OAAO,IAAI,YAAY,aAAa,IAAI,SAAS,GAAI,IAAI,WAAW,EAAE;GAExE,MAAM,gBAAgB;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;GAED,MAAM,WAAW,cAAc,YAAY,gBAAgB;GAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,iBACC,aACC,wBAAwB,gBAAgB,SAAS,CAClD;GAEP,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,GAAG;AAChC,YAAS,IAAI,gBAAgB;AAC7B,YAAS,KAAK;IACZ;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,qBAAqB;AAChD;;AAGF,OAAI,UAAU;AACZ,QAAI,SAAS,OAAO,SAClB,UAAS,OAAO,YAAY;AAE9B,kBAAc,OAAO,EAAE,gBAAgB;;GAGzC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;GACvD,MAAM,SAAS,QAAQ,SAAS,EAAE,cAAc,EAAE,IAAI,UAAU;IAC9D,GAAG;IACH,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.4.2",
+  "version": "0.5.1",
   "description": "Angular adapter for TanStack Hotkeys",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -42,16 +42,16 @@
   ],
   "dependencies": {
     "@tanstack/angular-store": "^0.9.2",
-    "@tanstack/hotkeys": "0.4.2"
+    "@tanstack/hotkeys": "0.4.3"
   },
   "peerDependencies": {
     "@angular/common": ">=19.0.0",
     "@angular/core": ">=19.0.0"
   },
   "devDependencies": {
-    "@angular/common": "^21.2.1",
-    "@angular/core": "^21.2.1",
-    "@angular/platform-browser-dynamic": "^21.2.1",
+    "@angular/common": "^21.2.5",
+    "@angular/core": "^21.2.5",
+    "@angular/platform-browser-dynamic": "^21.2.5",
     "typescript": "5.9.3"
   },
   "scripts": {

package/src/index.ts

@@ -6,6 +6,7 @@ export * from './hotkeys-provider'
 
 // Angular-specific primitives
 export * from './injectHotkey'
+export * from './injectHotkeys'
 export * from './injectHotkeySequence'
 export * from './injectHeldKeys'
 export * from './injectHeldKeyCodes'

package/src/injectHotkeySequence.ts

@@ -21,6 +21,11 @@ export interface InjectHotkeySequenceOptions extends Omit<
  * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger
  * when the full sequence is pressed within a timeout.
  *
+ * Each step may include modifiers. You can chain the same modifier across
+ * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
+ * Control, Alt, or Meta pressed alone) are ignored while matching—they do not
+ * advance the sequence or reset progress.
+ *
  * @param sequence - Array of hotkey strings that form the sequence (or getter function)
  * @param callback - Function to call when the sequence is completed
  * @param options - Options for the sequence behavior (or getter function)
@@ -35,6 +40,7 @@ export interface InjectHotkeySequenceOptions extends Omit<
  *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))
  *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))
  *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })
+ *     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))
  *   }
  * }
  * ```

package/src/injectHotkeys.ts

@@ -0,0 +1,195 @@
+import { DestroyRef, effect, inject } from '@angular/core'
+import {
+  detectPlatform,
+  formatHotkey,
+  getHotkeyManager,
+  rawHotkeyToParsedHotkey,
+} from '@tanstack/hotkeys'
+import { injectDefaultHotkeysOptions } from './hotkeys-provider'
+import type { InjectHotkeyOptions } from './injectHotkey'
+import type {
+  Hotkey,
+  HotkeyCallback,
+  HotkeyRegistrationHandle,
+  RegisterableHotkey,
+} from '@tanstack/hotkeys'
+
+/**
+ * A single hotkey definition for use with `injectHotkeys`.
+ */
+export interface InjectHotkeyDefinition {
+  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */
+  hotkey: RegisterableHotkey | (() => RegisterableHotkey)
+  /** The function to call when the hotkey is pressed */
+  callback: HotkeyCallback
+  /** Per-hotkey options (merged on top of commonOptions) */
+  options?: InjectHotkeyOptions | (() => InjectHotkeyOptions)
+}
+
+/**
+ * Angular inject-based API for registering multiple keyboard hotkeys at once.
+ *
+ * Uses the singleton HotkeyManager for efficient event handling.
+ * Accepts a dynamic array of hotkey definitions.
+ *
+ * Call in an injection context (e.g. constructor or field initializer).
+ * Uses effect() to track reactive dependencies and update registrations
+ * when options or the callback change.
+ *
+ * Options are merged in this order:
+ * provideHotkeys defaults < commonOptions < per-definition options
+ *
+ * @param hotkeys - Array of hotkey definitions, or getter returning them
+ * @param commonOptions - Shared options for all hotkeys, or getter
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class EditorComponent {
+ *   constructor() {
+ *     injectHotkeys([
+ *       { hotkey: 'Mod+S', callback: () => this.save() },
+ *       { hotkey: 'Mod+Z', callback: () => this.undo() },
+ *       { hotkey: 'Escape', callback: () => this.close() },
+ *     ])
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class DynamicShortcuts {
+ *   shortcuts = signal([...])
+ *
+ *   constructor() {
+ *     injectHotkeys(
+ *       () => this.shortcuts().map((s) => ({
+ *         hotkey: s.key,
+ *         callback: s.action,
+ *       })),
+ *     )
+ *   }
+ * }
+ * ```
+ */
+export function injectHotkeys(
+  hotkeys:
+    | Array<InjectHotkeyDefinition>
+    | (() => Array<InjectHotkeyDefinition>),
+  commonOptions: InjectHotkeyOptions | (() => InjectHotkeyOptions) = {},
+): void {
+  type RegistrationRecord = {
+    handle: HotkeyRegistrationHandle
+    target: Document | HTMLElement | Window
+  }
+
+  const defaultOptions = injectDefaultHotkeysOptions()
+  const manager = getHotkeyManager()
+  const destroyRef = inject(DestroyRef)
+
+  const registrations = new Map<string, RegistrationRecord>()
+
+  destroyRef.onDestroy(() => {
+    for (const { handle } of registrations.values()) {
+      if (handle.isActive) {
+        handle.unregister()
+      }
+    }
+    registrations.clear()
+  })
+
+  effect(() => {
+    const resolvedHotkeys = typeof hotkeys === 'function' ? hotkeys() : hotkeys
+    const resolvedCommonOptions =
+      typeof commonOptions === 'function' ? commonOptions() : commonOptions
+
+    const nextKeys = new Set<string>()
+    const prepared: Array<{
+      registrationKey: string
+      def: InjectHotkeyDefinition
+      mergedOptions: InjectHotkeyOptions
+      hotkeyString: Hotkey
+      resolvedTarget: Document | HTMLElement | Window
+    }> = []
+
+    for (let i = 0; i < resolvedHotkeys.length; i++) {
+      const def = resolvedHotkeys[i]!
+      const resolvedHotkey =
+        typeof def.hotkey === 'function' ? def.hotkey() : def.hotkey
+      const resolvedDefOptions =
+        typeof def.options === 'function' ? def.options() : (def.options ?? {})
+
+      const mergedOptions = {
+        ...defaultOptions.hotkey,
+        ...resolvedCommonOptions,
+        ...resolvedDefOptions,
+      } as InjectHotkeyOptions
+
+      const platform = mergedOptions.platform ?? detectPlatform()
+      const hotkeyString: Hotkey =
+        typeof resolvedHotkey === 'string'
+          ? resolvedHotkey
+          : (formatHotkey(
+              rawHotkeyToParsedHotkey(resolvedHotkey, platform),
+            ) as Hotkey)
+
+      const resolvedTarget =
+        'target' in mergedOptions
+          ? (mergedOptions.target ?? null)
+          : typeof document !== 'undefined'
+            ? document
+            : null
+
+      if (!resolvedTarget) {
+        continue
+      }
+
+      const registrationKey = `${i}:${hotkeyString}`
+      nextKeys.add(registrationKey)
+      prepared.push({
+        registrationKey,
+        def,
+        mergedOptions,
+        hotkeyString,
+        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.mergedOptions
+        existing.handle.setOptions(optionsWithoutTarget)
+        continue
+      }
+
+      if (existing) {
+        if (existing.handle.isActive) {
+          existing.handle.unregister()
+        }
+        registrations.delete(p.registrationKey)
+      }
+
+      const { target: _target, ...optionsWithoutTarget } = p.mergedOptions
+      const handle = manager.register(p.hotkeyString, p.def.callback, {
+        ...optionsWithoutTarget,
+        target: p.resolvedTarget,
+      })
+      registrations.set(p.registrationKey, {
+        handle,
+        target: p.resolvedTarget,
+      })
+    }
+  })
+}