@tanstack/angular-hotkeys 0.3.3

package/dist/injectHotkey.cjs.map

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

package/dist/injectHotkey.d.cts

@@ -0,0 +1,73 @@
+import { HotkeyCallback, HotkeyOptions, RegisterableHotkey } from "@tanstack/hotkeys";
+
+//#region src/injectHotkey.d.ts
+interface InjectHotkeyOptions extends Omit<HotkeyOptions, 'target'> {
+  /**
+   * The DOM element to attach the event listener to.
+   * Can be a direct DOM element, an accessor (for reactive targets that become
+   * available after mount), or null. Defaults to document.
+   * When using scoped targets, pass an accessor: () => ({ target: elementSignal() })
+   * so the hotkey waits for the element to be attached before registering.
+   */
+  target?: HTMLElement | Document | Window | null;
+}
+/**
+ * Angular inject-based API for registering a keyboard hotkey.
+ *
+ * Uses the singleton HotkeyManager for efficient event handling.
+ * The callback receives both the keyboard event and a context object
+ * containing the hotkey string and parsed hotkey.
+ *
+ * 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.
+ *
+ * @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function
+ * @param callback - The function to call when the hotkey is pressed
+ * @param options - Options for the hotkey behavior, or getter for reactive options
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class SaveButtonComponent {
+ *   private readonly saveCount = signal(0)
+ *
+ *   constructor() {
+ *     injectHotkey('Mod+S', (event, { hotkey }) => {
+ *       event.preventDefault()
+ *       this.saveCount.update(c => c + 1)
+ *     })
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class ModalComponent {
+ *   isOpen = signal(true)
+ *
+ *   constructor() {
+ *     injectHotkey('Escape', () => this.close(), () => ({ enabled: this.isOpen() }))
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class EditorComponent {
+ *   private readonly editorRef = viewChild<ElementRef<HTMLDivElement>>('editorRef')
+ *
+ *   constructor() {
+ *     injectHotkey('Mod+B', () => this.toggleBold(), () => ({
+ *       target: this.editorRef()?.nativeElement ?? null,
+ *     }))
+ *   }
+ * }
+ * ```
+ */
+declare function injectHotkey(hotkey: RegisterableHotkey | (() => RegisterableHotkey), callback: HotkeyCallback, options?: InjectHotkeyOptions | (() => InjectHotkeyOptions)): void;
+//#endregion
+export { InjectHotkeyOptions, injectHotkey };
+//# sourceMappingURL=injectHotkey.d.cts.map

package/dist/injectHotkey.d.ts

@@ -0,0 +1,73 @@
+import { HotkeyCallback, HotkeyOptions, RegisterableHotkey } from "@tanstack/hotkeys";
+
+//#region src/injectHotkey.d.ts
+interface InjectHotkeyOptions extends Omit<HotkeyOptions, 'target'> {
+  /**
+   * The DOM element to attach the event listener to.
+   * Can be a direct DOM element, an accessor (for reactive targets that become
+   * available after mount), or null. Defaults to document.
+   * When using scoped targets, pass an accessor: () => ({ target: elementSignal() })
+   * so the hotkey waits for the element to be attached before registering.
+   */
+  target?: HTMLElement | Document | Window | null;
+}
+/**
+ * Angular inject-based API for registering a keyboard hotkey.
+ *
+ * Uses the singleton HotkeyManager for efficient event handling.
+ * The callback receives both the keyboard event and a context object
+ * containing the hotkey string and parsed hotkey.
+ *
+ * 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.
+ *
+ * @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function
+ * @param callback - The function to call when the hotkey is pressed
+ * @param options - Options for the hotkey behavior, or getter for reactive options
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class SaveButtonComponent {
+ *   private readonly saveCount = signal(0)
+ *
+ *   constructor() {
+ *     injectHotkey('Mod+S', (event, { hotkey }) => {
+ *       event.preventDefault()
+ *       this.saveCount.update(c => c + 1)
+ *     })
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class ModalComponent {
+ *   isOpen = signal(true)
+ *
+ *   constructor() {
+ *     injectHotkey('Escape', () => this.close(), () => ({ enabled: this.isOpen() }))
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class EditorComponent {
+ *   private readonly editorRef = viewChild<ElementRef<HTMLDivElement>>('editorRef')
+ *
+ *   constructor() {
+ *     injectHotkey('Mod+B', () => this.toggleBold(), () => ({
+ *       target: this.editorRef()?.nativeElement ?? null,
+ *     }))
+ *   }
+ * }
+ * ```
+ */
+declare function injectHotkey(hotkey: RegisterableHotkey | (() => RegisterableHotkey), callback: HotkeyCallback, options?: InjectHotkeyOptions | (() => InjectHotkeyOptions)): void;
+//#endregion
+export { InjectHotkeyOptions, injectHotkey };
+//# sourceMappingURL=injectHotkey.d.ts.map

package/dist/injectHotkey.js

@@ -0,0 +1,93 @@
+import { injectDefaultHotkeysOptions } from "./hotkeys-provider.js";
+import { detectPlatform, formatHotkey, getHotkeyManager, rawHotkeyToParsedHotkey } from "@tanstack/hotkeys";
+import { effect } from "@angular/core";
+
+//#region src/injectHotkey.ts
+/**
+* Angular inject-based API for registering a keyboard hotkey.
+*
+* Uses the singleton HotkeyManager for efficient event handling.
+* The callback receives both the keyboard event and a context object
+* containing the hotkey string and parsed hotkey.
+*
+* 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.
+*
+* @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function
+* @param callback - The function to call when the hotkey is pressed
+* @param options - Options for the hotkey behavior, or getter for reactive options
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class SaveButtonComponent {
+*   private readonly saveCount = signal(0)
+*
+*   constructor() {
+*     injectHotkey('Mod+S', (event, { hotkey }) => {
+*       event.preventDefault()
+*       this.saveCount.update(c => c + 1)
+*     })
+*   }
+* }
+* ```
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class ModalComponent {
+*   isOpen = signal(true)
+*
+*   constructor() {
+*     injectHotkey('Escape', () => this.close(), () => ({ enabled: this.isOpen() }))
+*   }
+* }
+* ```
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class EditorComponent {
+*   private readonly editorRef = viewChild<ElementRef<HTMLDivElement>>('editorRef')
+*
+*   constructor() {
+*     injectHotkey('Mod+B', () => this.toggleBold(), () => ({
+*       target: this.editorRef()?.nativeElement ?? null,
+*     }))
+*   }
+* }
+* ```
+*/
+function injectHotkey(hotkey, callback, options = {}) {
+	const defaultOptions = injectDefaultHotkeysOptions();
+	const manager = getHotkeyManager();
+	effect((onCleanup) => {
+		const resolvedHotkey = typeof hotkey === "function" ? hotkey() : hotkey;
+		const resolvedOptions = typeof options === "function" ? options() : options;
+		const mergedOptions = {
+			...defaultOptions.hotkey,
+			...resolvedOptions
+		};
+		const platform = mergedOptions.platform ?? detectPlatform();
+		const hotkeyString = typeof resolvedHotkey === "string" ? resolvedHotkey : formatHotkey(rawHotkeyToParsedHotkey(resolvedHotkey, platform));
+		const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
+		if (!resolvedTarget) return;
+		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
+		const registration = manager.register(hotkeyString, callback, {
+			...optionsWithoutTarget,
+			target: resolvedTarget
+		});
+		if (registration.isActive) {
+			registration.callback = callback;
+			registration.setOptions(optionsWithoutTarget);
+		}
+		onCleanup(() => {
+			if (registration.isActive) registration.unregister();
+		});
+	});
+}
+
+//#endregion
+export { injectHotkey };
+//# sourceMappingURL=injectHotkey.js.map

package/dist/injectHotkey.js.map

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

package/dist/injectHotkeyRecorder.cjs

@@ -0,0 +1,82 @@
+const require_hotkeys_provider = require('./hotkeys-provider.cjs');
+let _tanstack_hotkeys = require("@tanstack/hotkeys");
+let _angular_core = require("@angular/core");
+
+//#region src/injectHotkeyRecorder.ts
+/**
+* Angular inject-based API for recording keyboard shortcuts.
+*
+* Thin wrapper around the framework-agnostic HotkeyRecorder class: captures
+* keyboard events, converts them to hotkey strings, and handles Escape to
+* cancel or Backspace/Delete to clear.
+*
+* @param options - Configuration options for the recorder (or getter)
+* @returns Object with recording state signals and control functions
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class ShortcutSettingsComponent {
+*   shortcut = signal<Hotkey>('Mod+S')
+*   recorder = injectHotkeyRecorder({
+*     onRecord: (hotkey) => this.shortcut.set(hotkey),
+*     onCancel: () => console.log('Recording cancelled'),
+*   })
+*
+*   constructor() {
+*     injectHotkey(
+*       () => this.shortcut(),
+*       () => this.handleSave(),
+*       () => ({ enabled: !this.recorder.isRecording() }),
+*     )
+*   }
+* }
+* ```
+*/
+function injectHotkeyRecorder(options) {
+	const defaultOptions = require_hotkeys_provider.injectDefaultHotkeysOptions();
+	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
+	const recorderSignal = (0, _angular_core.computed)(() => (0, _angular_core.untracked)(() => {
+		const resolvedOptions = typeof options === "function" ? options() : options;
+		return new _tanstack_hotkeys.HotkeyRecorder({
+			...defaultOptions.hotkeyRecorder,
+			...resolvedOptions
+		});
+	}));
+	const recorderStore = (0, _angular_core.computed)(() => (0, _angular_core.untracked)(() => recorderSignal().store));
+	const isRecording = injectLazyStore(recorderStore, (state) => state.isRecording);
+	const recordedHotkey = injectLazyStore(recorderStore, (state) => state.recordedHotkey);
+	(0, _angular_core.effect)(() => {
+		const resolved = typeof options === "function" ? options() : options;
+		recorderSignal().setOptions({
+			...defaultOptions.hotkeyRecorder,
+			...resolved
+		});
+	});
+	destroyRef.onDestroy(() => {
+		recorderSignal().destroy();
+	});
+	return {
+		isRecording,
+		recordedHotkey,
+		startRecording: () => recorderSignal().start(),
+		stopRecording: () => recorderSignal().stop(),
+		cancelRecording: () => recorderSignal().cancel()
+	};
+}
+function injectLazyStore(storeSignal, selector) {
+	const slice = (0, _angular_core.linkedSignal)(() => selector(storeSignal().get()));
+	(0, _angular_core.effect)((onCleanup) => {
+		const currentStore = storeSignal();
+		slice.set(selector(currentStore.get()));
+		const { unsubscribe } = currentStore.subscribe((s) => {
+			slice.set(selector(s));
+		});
+		onCleanup(() => unsubscribe());
+	});
+	return slice.asReadonly();
+}
+
+//#endregion
+exports.injectHotkeyRecorder = injectHotkeyRecorder;
+//# sourceMappingURL=injectHotkeyRecorder.cjs.map

package/dist/injectHotkeyRecorder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectHotkeyRecorder.cjs","names":["injectDefaultHotkeysOptions","DestroyRef","HotkeyRecorder"],"sources":["../src/injectHotkeyRecorder.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  effect,\n  inject,\n  linkedSignal,\n  untracked,\n} from '@angular/core'\nimport { HotkeyRecorder } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type { Atom, ReadonlyAtom } from '@tanstack/angular-store'\nimport type { Signal } from '@angular/core'\nimport type { Hotkey, HotkeyRecorderOptions } from '@tanstack/hotkeys'\n\nexport interface AngularHotkeyRecorder {\n  /** Whether recording is currently active */\n  readonly isRecording: () => boolean\n  /** The currently recorded hotkey (for live preview) */\n  readonly recordedHotkey: () => Hotkey | null\n  /** Start recording a new hotkey */\n  readonly startRecording: () => void\n  /** Stop recording (same as cancel) */\n  readonly stopRecording: () => void\n  /** Cancel recording without saving */\n  readonly cancelRecording: () => void\n}\n\n/**\n * Angular inject-based API for recording keyboard shortcuts.\n *\n * Thin wrapper around the framework-agnostic HotkeyRecorder class: captures\n * keyboard events, converts them to hotkey strings, and handles Escape to\n * cancel or Backspace/Delete to clear.\n *\n * @param options - Configuration options for the recorder (or getter)\n * @returns Object with recording state signals and control functions\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class ShortcutSettingsComponent {\n *   shortcut = signal<Hotkey>('Mod+S')\n *   recorder = injectHotkeyRecorder({\n *     onRecord: (hotkey) => this.shortcut.set(hotkey),\n *     onCancel: () => console.log('Recording cancelled'),\n *   })\n *\n *   constructor() {\n *     injectHotkey(\n *       () => this.shortcut(),\n *       () => this.handleSave(),\n *       () => ({ enabled: !this.recorder.isRecording() }),\n *     )\n *   }\n * }\n * ```\n */\nexport function injectHotkeyRecorder(\n  options: HotkeyRecorderOptions | (() => HotkeyRecorderOptions),\n): AngularHotkeyRecorder {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const destroyRef = inject(DestroyRef)\n\n  // Stable signal to lazy initialize the recorder\n  const recorderSignal = computed(() =>\n    untracked(() => {\n      const resolvedOptions =\n        typeof options === 'function' ? options() : options\n\n      const mergedOptions = {\n        ...defaultOptions.hotkeyRecorder,\n        ...resolvedOptions,\n      } as HotkeyRecorderOptions\n\n      return new HotkeyRecorder(mergedOptions)\n    }),\n  )\n\n  // Subscribe to recorder state\n  const recorderStore = computed(() => untracked(() => recorderSignal().store))\n  const isRecording = injectLazyStore(\n    recorderStore,\n    (state) => state.isRecording,\n  )\n  const recordedHotkey = injectLazyStore(\n    recorderStore,\n    (state) => state.recordedHotkey,\n  )\n\n  // Sync options on every effect run (matches React's sync on render)\n  effect(() => {\n    const resolved = typeof options === 'function' ? options() : options\n    recorderSignal().setOptions({\n      ...defaultOptions.hotkeyRecorder,\n      ...resolved,\n    } as HotkeyRecorderOptions)\n  })\n\n  destroyRef.onDestroy(() => {\n    recorderSignal().destroy()\n  })\n\n  return {\n    isRecording,\n    recordedHotkey,\n    startRecording: () => recorderSignal().start(),\n    stopRecording: () => recorderSignal().stop(),\n    cancelRecording: () => recorderSignal().cancel(),\n  }\n}\n\nfunction injectLazyStore<TState, TSelected = NoInfer<TState>>(\n  storeSignal: Signal<Atom<TState> | ReadonlyAtom<TState>>,\n  selector: (state: NoInfer<TState>) => TSelected,\n): Signal<TSelected> {\n  const slice = linkedSignal(() => selector(storeSignal().get()))\n\n  effect((onCleanup) => {\n    const currentStore = storeSignal()\n    slice.set(selector(currentStore.get()))\n    const { unsubscribe } = currentStore.subscribe((s) => {\n      slice.set(selector(s))\n    })\n    onCleanup(() => unsubscribe())\n  })\n\n  return slice.asReadonly()\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,qBACd,SACuB;CACvB,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,uCAAoBC,yBAAW;CAGrC,MAAM,sFACY;EACd,MAAM,kBACJ,OAAO,YAAY,aAAa,SAAS,GAAG;AAO9C,SAAO,IAAIC,iCALW;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ,CAEuC;GACxC,CACH;CAGD,MAAM,qFAA+C,gBAAgB,CAAC,MAAM,CAAC;CAC7E,MAAM,cAAc,gBAClB,gBACC,UAAU,MAAM,YAClB;CACD,MAAM,iBAAiB,gBACrB,gBACC,UAAU,MAAM,eAClB;AAGD,iCAAa;EACX,MAAM,WAAW,OAAO,YAAY,aAAa,SAAS,GAAG;AAC7D,kBAAgB,CAAC,WAAW;GAC1B,GAAG,eAAe;GAClB,GAAG;GACJ,CAA0B;GAC3B;AAEF,YAAW,gBAAgB;AACzB,kBAAgB,CAAC,SAAS;GAC1B;AAEF,QAAO;EACL;EACA;EACA,sBAAsB,gBAAgB,CAAC,OAAO;EAC9C,qBAAqB,gBAAgB,CAAC,MAAM;EAC5C,uBAAuB,gBAAgB,CAAC,QAAQ;EACjD;;AAGH,SAAS,gBACP,aACA,UACmB;CACnB,MAAM,8CAA2B,SAAS,aAAa,CAAC,KAAK,CAAC,CAAC;AAE/D,4BAAQ,cAAc;EACpB,MAAM,eAAe,aAAa;AAClC,QAAM,IAAI,SAAS,aAAa,KAAK,CAAC,CAAC;EACvC,MAAM,EAAE,gBAAgB,aAAa,WAAW,MAAM;AACpD,SAAM,IAAI,SAAS,EAAE,CAAC;IACtB;AACF,kBAAgB,aAAa,CAAC;GAC9B;AAEF,QAAO,MAAM,YAAY"}

package/dist/injectHotkeyRecorder.d.cts

@@ -0,0 +1,49 @@
+import { Hotkey, HotkeyRecorderOptions } from "@tanstack/hotkeys";
+
+//#region src/injectHotkeyRecorder.d.ts
+interface AngularHotkeyRecorder {
+  /** Whether recording is currently active */
+  readonly isRecording: () => boolean;
+  /** The currently recorded hotkey (for live preview) */
+  readonly recordedHotkey: () => Hotkey | null;
+  /** Start recording a new hotkey */
+  readonly startRecording: () => void;
+  /** Stop recording (same as cancel) */
+  readonly stopRecording: () => void;
+  /** Cancel recording without saving */
+  readonly cancelRecording: () => void;
+}
+/**
+ * Angular inject-based API for recording keyboard shortcuts.
+ *
+ * Thin wrapper around the framework-agnostic HotkeyRecorder class: captures
+ * keyboard events, converts them to hotkey strings, and handles Escape to
+ * cancel or Backspace/Delete to clear.
+ *
+ * @param options - Configuration options for the recorder (or getter)
+ * @returns Object with recording state signals and control functions
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class ShortcutSettingsComponent {
+ *   shortcut = signal<Hotkey>('Mod+S')
+ *   recorder = injectHotkeyRecorder({
+ *     onRecord: (hotkey) => this.shortcut.set(hotkey),
+ *     onCancel: () => console.log('Recording cancelled'),
+ *   })
+ *
+ *   constructor() {
+ *     injectHotkey(
+ *       () => this.shortcut(),
+ *       () => this.handleSave(),
+ *       () => ({ enabled: !this.recorder.isRecording() }),
+ *     )
+ *   }
+ * }
+ * ```
+ */
+declare function injectHotkeyRecorder(options: HotkeyRecorderOptions | (() => HotkeyRecorderOptions)): AngularHotkeyRecorder;
+//#endregion
+export { AngularHotkeyRecorder, injectHotkeyRecorder };
+//# sourceMappingURL=injectHotkeyRecorder.d.cts.map

package/dist/injectHotkeyRecorder.d.ts

@@ -0,0 +1,49 @@
+import { Hotkey, HotkeyRecorderOptions } from "@tanstack/hotkeys";
+
+//#region src/injectHotkeyRecorder.d.ts
+interface AngularHotkeyRecorder {
+  /** Whether recording is currently active */
+  readonly isRecording: () => boolean;
+  /** The currently recorded hotkey (for live preview) */
+  readonly recordedHotkey: () => Hotkey | null;
+  /** Start recording a new hotkey */
+  readonly startRecording: () => void;
+  /** Stop recording (same as cancel) */
+  readonly stopRecording: () => void;
+  /** Cancel recording without saving */
+  readonly cancelRecording: () => void;
+}
+/**
+ * Angular inject-based API for recording keyboard shortcuts.
+ *
+ * Thin wrapper around the framework-agnostic HotkeyRecorder class: captures
+ * keyboard events, converts them to hotkey strings, and handles Escape to
+ * cancel or Backspace/Delete to clear.
+ *
+ * @param options - Configuration options for the recorder (or getter)
+ * @returns Object with recording state signals and control functions
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class ShortcutSettingsComponent {
+ *   shortcut = signal<Hotkey>('Mod+S')
+ *   recorder = injectHotkeyRecorder({
+ *     onRecord: (hotkey) => this.shortcut.set(hotkey),
+ *     onCancel: () => console.log('Recording cancelled'),
+ *   })
+ *
+ *   constructor() {
+ *     injectHotkey(
+ *       () => this.shortcut(),
+ *       () => this.handleSave(),
+ *       () => ({ enabled: !this.recorder.isRecording() }),
+ *     )
+ *   }
+ * }
+ * ```
+ */
+declare function injectHotkeyRecorder(options: HotkeyRecorderOptions | (() => HotkeyRecorderOptions)): AngularHotkeyRecorder;
+//#endregion
+export { AngularHotkeyRecorder, injectHotkeyRecorder };
+//# sourceMappingURL=injectHotkeyRecorder.d.ts.map

package/dist/injectHotkeyRecorder.js

@@ -0,0 +1,82 @@
+import { injectDefaultHotkeysOptions } from "./hotkeys-provider.js";
+import { HotkeyRecorder } from "@tanstack/hotkeys";
+import { DestroyRef, computed, effect, inject, linkedSignal, untracked } from "@angular/core";
+
+//#region src/injectHotkeyRecorder.ts
+/**
+* Angular inject-based API for recording keyboard shortcuts.
+*
+* Thin wrapper around the framework-agnostic HotkeyRecorder class: captures
+* keyboard events, converts them to hotkey strings, and handles Escape to
+* cancel or Backspace/Delete to clear.
+*
+* @param options - Configuration options for the recorder (or getter)
+* @returns Object with recording state signals and control functions
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class ShortcutSettingsComponent {
+*   shortcut = signal<Hotkey>('Mod+S')
+*   recorder = injectHotkeyRecorder({
+*     onRecord: (hotkey) => this.shortcut.set(hotkey),
+*     onCancel: () => console.log('Recording cancelled'),
+*   })
+*
+*   constructor() {
+*     injectHotkey(
+*       () => this.shortcut(),
+*       () => this.handleSave(),
+*       () => ({ enabled: !this.recorder.isRecording() }),
+*     )
+*   }
+* }
+* ```
+*/
+function injectHotkeyRecorder(options) {
+	const defaultOptions = injectDefaultHotkeysOptions();
+	const destroyRef = inject(DestroyRef);
+	const recorderSignal = computed(() => untracked(() => {
+		const resolvedOptions = typeof options === "function" ? options() : options;
+		return new HotkeyRecorder({
+			...defaultOptions.hotkeyRecorder,
+			...resolvedOptions
+		});
+	}));
+	const recorderStore = computed(() => untracked(() => recorderSignal().store));
+	const isRecording = injectLazyStore(recorderStore, (state) => state.isRecording);
+	const recordedHotkey = injectLazyStore(recorderStore, (state) => state.recordedHotkey);
+	effect(() => {
+		const resolved = typeof options === "function" ? options() : options;
+		recorderSignal().setOptions({
+			...defaultOptions.hotkeyRecorder,
+			...resolved
+		});
+	});
+	destroyRef.onDestroy(() => {
+		recorderSignal().destroy();
+	});
+	return {
+		isRecording,
+		recordedHotkey,
+		startRecording: () => recorderSignal().start(),
+		stopRecording: () => recorderSignal().stop(),
+		cancelRecording: () => recorderSignal().cancel()
+	};
+}
+function injectLazyStore(storeSignal, selector) {
+	const slice = linkedSignal(() => selector(storeSignal().get()));
+	effect((onCleanup) => {
+		const currentStore = storeSignal();
+		slice.set(selector(currentStore.get()));
+		const { unsubscribe } = currentStore.subscribe((s) => {
+			slice.set(selector(s));
+		});
+		onCleanup(() => unsubscribe());
+	});
+	return slice.asReadonly();
+}
+
+//#endregion
+export { injectHotkeyRecorder };
+//# sourceMappingURL=injectHotkeyRecorder.js.map

package/dist/injectHotkeyRecorder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectHotkeyRecorder.js","names":[],"sources":["../src/injectHotkeyRecorder.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  effect,\n  inject,\n  linkedSignal,\n  untracked,\n} from '@angular/core'\nimport { HotkeyRecorder } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type { Atom, ReadonlyAtom } from '@tanstack/angular-store'\nimport type { Signal } from '@angular/core'\nimport type { Hotkey, HotkeyRecorderOptions } from '@tanstack/hotkeys'\n\nexport interface AngularHotkeyRecorder {\n  /** Whether recording is currently active */\n  readonly isRecording: () => boolean\n  /** The currently recorded hotkey (for live preview) */\n  readonly recordedHotkey: () => Hotkey | null\n  /** Start recording a new hotkey */\n  readonly startRecording: () => void\n  /** Stop recording (same as cancel) */\n  readonly stopRecording: () => void\n  /** Cancel recording without saving */\n  readonly cancelRecording: () => void\n}\n\n/**\n * Angular inject-based API for recording keyboard shortcuts.\n *\n * Thin wrapper around the framework-agnostic HotkeyRecorder class: captures\n * keyboard events, converts them to hotkey strings, and handles Escape to\n * cancel or Backspace/Delete to clear.\n *\n * @param options - Configuration options for the recorder (or getter)\n * @returns Object with recording state signals and control functions\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class ShortcutSettingsComponent {\n *   shortcut = signal<Hotkey>('Mod+S')\n *   recorder = injectHotkeyRecorder({\n *     onRecord: (hotkey) => this.shortcut.set(hotkey),\n *     onCancel: () => console.log('Recording cancelled'),\n *   })\n *\n *   constructor() {\n *     injectHotkey(\n *       () => this.shortcut(),\n *       () => this.handleSave(),\n *       () => ({ enabled: !this.recorder.isRecording() }),\n *     )\n *   }\n * }\n * ```\n */\nexport function injectHotkeyRecorder(\n  options: HotkeyRecorderOptions | (() => HotkeyRecorderOptions),\n): AngularHotkeyRecorder {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const destroyRef = inject(DestroyRef)\n\n  // Stable signal to lazy initialize the recorder\n  const recorderSignal = computed(() =>\n    untracked(() => {\n      const resolvedOptions =\n        typeof options === 'function' ? options() : options\n\n      const mergedOptions = {\n        ...defaultOptions.hotkeyRecorder,\n        ...resolvedOptions,\n      } as HotkeyRecorderOptions\n\n      return new HotkeyRecorder(mergedOptions)\n    }),\n  )\n\n  // Subscribe to recorder state\n  const recorderStore = computed(() => untracked(() => recorderSignal().store))\n  const isRecording = injectLazyStore(\n    recorderStore,\n    (state) => state.isRecording,\n  )\n  const recordedHotkey = injectLazyStore(\n    recorderStore,\n    (state) => state.recordedHotkey,\n  )\n\n  // Sync options on every effect run (matches React's sync on render)\n  effect(() => {\n    const resolved = typeof options === 'function' ? options() : options\n    recorderSignal().setOptions({\n      ...defaultOptions.hotkeyRecorder,\n      ...resolved,\n    } as HotkeyRecorderOptions)\n  })\n\n  destroyRef.onDestroy(() => {\n    recorderSignal().destroy()\n  })\n\n  return {\n    isRecording,\n    recordedHotkey,\n    startRecording: () => recorderSignal().start(),\n    stopRecording: () => recorderSignal().stop(),\n    cancelRecording: () => recorderSignal().cancel(),\n  }\n}\n\nfunction injectLazyStore<TState, TSelected = NoInfer<TState>>(\n  storeSignal: Signal<Atom<TState> | ReadonlyAtom<TState>>,\n  selector: (state: NoInfer<TState>) => TSelected,\n): Signal<TSelected> {\n  const slice = linkedSignal(() => selector(storeSignal().get()))\n\n  effect((onCleanup) => {\n    const currentStore = storeSignal()\n    slice.set(selector(currentStore.get()))\n    const { unsubscribe } = currentStore.subscribe((s) => {\n      slice.set(selector(s))\n    })\n    onCleanup(() => unsubscribe())\n  })\n\n  return slice.asReadonly()\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,qBACd,SACuB;CACvB,MAAM,iBAAiB,6BAA6B;CACpD,MAAM,aAAa,OAAO,WAAW;CAGrC,MAAM,iBAAiB,eACrB,gBAAgB;EACd,MAAM,kBACJ,OAAO,YAAY,aAAa,SAAS,GAAG;AAO9C,SAAO,IAAI,eALW;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ,CAEuC;GACxC,CACH;CAGD,MAAM,gBAAgB,eAAe,gBAAgB,gBAAgB,CAAC,MAAM,CAAC;CAC7E,MAAM,cAAc,gBAClB,gBACC,UAAU,MAAM,YAClB;CACD,MAAM,iBAAiB,gBACrB,gBACC,UAAU,MAAM,eAClB;AAGD,cAAa;EACX,MAAM,WAAW,OAAO,YAAY,aAAa,SAAS,GAAG;AAC7D,kBAAgB,CAAC,WAAW;GAC1B,GAAG,eAAe;GAClB,GAAG;GACJ,CAA0B;GAC3B;AAEF,YAAW,gBAAgB;AACzB,kBAAgB,CAAC,SAAS;GAC1B;AAEF,QAAO;EACL;EACA;EACA,sBAAsB,gBAAgB,CAAC,OAAO;EAC9C,qBAAqB,gBAAgB,CAAC,MAAM;EAC5C,uBAAuB,gBAAgB,CAAC,QAAQ;EACjD;;AAGH,SAAS,gBACP,aACA,UACmB;CACnB,MAAM,QAAQ,mBAAmB,SAAS,aAAa,CAAC,KAAK,CAAC,CAAC;AAE/D,SAAQ,cAAc;EACpB,MAAM,eAAe,aAAa;AAClC,QAAM,IAAI,SAAS,aAAa,KAAK,CAAC,CAAC;EACvC,MAAM,EAAE,gBAAgB,aAAa,WAAW,MAAM;AACpD,SAAM,IAAI,SAAS,EAAE,CAAC;IACtB;AACF,kBAAgB,aAAa,CAAC;GAC9B;AAEF,QAAO,MAAM,YAAY"}

package/dist/injectHotkeySequence.cjs

@@ -0,0 +1,55 @@
+const require_hotkeys_provider = require('./hotkeys-provider.cjs');
+let _tanstack_hotkeys = require("@tanstack/hotkeys");
+let _angular_core = require("@angular/core");
+
+//#region src/injectHotkeySequence.ts
+/**
+* Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).
+*
+* Allows you to register multi-key sequences like 'g g' or 'd d' that trigger
+* when the full sequence is pressed within a timeout.
+*
+* @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)
+*
+* @example
+* ```ts
+* @Component({ ... })
+* export class VimEditorComponent {
+*   lastSequence = signal<string | null>(null)
+*
+*   constructor() {
+*     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 })
+*   }
+* }
+* ```
+*/
+function injectHotkeySequence(sequence, callback, options = {}) {
+	const defaultOptions = require_hotkeys_provider.injectDefaultHotkeysOptions();
+	(0, _angular_core.effect)((onCleanup) => {
+		const resolvedSequence = typeof sequence === "function" ? sequence() : sequence;
+		const resolvedOptions = typeof options === "function" ? options() : options;
+		const { enabled = true, ...sequenceOptions } = {
+			...defaultOptions.hotkeySequence,
+			...resolvedOptions
+		};
+		if (!enabled || resolvedSequence.length === 0) return;
+		const manager = (0, _tanstack_hotkeys.getSequenceManager)();
+		const registerOptions = {
+			...sequenceOptions,
+			enabled: true,
+			target: sequenceOptions.target ?? (typeof document !== "undefined" ? document : void 0)
+		};
+		const handle = manager.register(resolvedSequence, callback, registerOptions);
+		onCleanup(() => {
+			if (handle.isActive) handle.unregister();
+		});
+	});
+}
+
+//#endregion
+exports.injectHotkeySequence = injectHotkeySequence;
+//# sourceMappingURL=injectHotkeySequence.cjs.map

package/dist/injectHotkeySequence.cjs.map

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

package/dist/injectHotkeySequence.d.cts

@@ -0,0 +1,35 @@
+import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
+
+//#region src/injectHotkeySequence.d.ts
+interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled'> {
+  /** Whether the sequence is enabled. Defaults to true. */
+  enabled?: boolean;
+}
+/**
+ * Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).
+ *
+ * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger
+ * when the full sequence is pressed within a timeout.
+ *
+ * @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)
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class VimEditorComponent {
+ *   lastSequence = signal<string | null>(null)
+ *
+ *   constructor() {
+ *     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 })
+ *   }
+ * }
+ * ```
+ */
+declare function injectHotkeySequence(sequence: HotkeySequence | (() => HotkeySequence), callback: HotkeyCallback, options?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions)): void;
+//#endregion
+export { InjectHotkeySequenceOptions, injectHotkeySequence };
+//# sourceMappingURL=injectHotkeySequence.d.cts.map