@tanstack/angular-hotkeys 0.13.0 → 0.14.1

package/dist/injectHotkeyRecorder.js

@@ -3,48 +3,19 @@ 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(),
-*     )
-*   }
-* }
-* ```
-*/
 function injectHotkeyRecorder(options) {
 	const defaultOptions = injectDefaultHotkeysOptions();
 	const destroyRef = inject(DestroyRef);
 	const recorderSignal = computed(() => untracked(() => {
 		const resolvedOptions = typeof options === "function" ? options() : options;
-		const mergedOptions = {
+		return new HotkeyRecorder({
 			...defaultOptions.hotkeyRecorder,
 			...resolvedOptions
-		};
-		return new HotkeyRecorder(mergedOptions);
+		});
 	}));
 	const recorderStore = computed(() => untracked(() => recorderSignal().store));
 	const isRecording = injectLazyStore(recorderStore, (state) => state.isRecording);
+	const steps = injectLazyStore(recorderStore, (state) => state.steps);
 	const recordedHotkey = injectLazyStore(recorderStore, (state) => state.recordedHotkey);
 	effect(() => {
 		const resolved = typeof options === "function" ? options() : options;
@@ -58,10 +29,12 @@ function injectHotkeyRecorder(options) {
 	});
 	return {
 		isRecording,
+		steps,
 		recordedHotkey,
 		startRecording: () => recorderSignal().start(),
 		stopRecording: () => recorderSignal().stop(),
-		cancelRecording: () => recorderSignal().cancel()
+		cancelRecording: () => recorderSignal().cancel(),
+		commitRecording: () => recorderSignal().commit()
 	};
 }
 function injectLazyStore(storeSignal, selector) {

package/dist/injectHotkeyRegistrations.d.ts

@@ -1,26 +1,28 @@
-import { HotkeyRegistrationView, SequenceRegistrationView } from "@tanstack/hotkeys";
+import { HotkeyRegistrationView } from "@tanstack/hotkeys";
 import { Signal } from "@angular/core";
 //#region src/injectHotkeyRegistrations.d.ts
 /**
- * Return type for injectHotkeyRegistrations.
- */
-export interface HotkeyRegistrationsResult {
-  /** Signal for all registered hotkeys (public view, no callbacks) */
-  hotkeys: Signal<Array<HotkeyRegistrationView>>;
-  /** Signal for all registered sequences */
-  sequences: Signal<Array<SequenceRegistrationView>>;
-}
-/**
- * Angular injectable that reactively reads all hotkey and sequence registrations
- * from the singleton managers.
+ * Angular inject-based API that reactively reads every hotkey registration,
+ * chords and sequences, from the singleton HotkeyManager. Narrow each view
+ * with `kind`.
  *
- * This is a standalone injectable that does NOT require the HotkeysProvider.
- * It subscribes to both HotkeyManager and SequenceManager stores and
- * triggers change detection when registrations change.
+ * This does NOT require `provideHotkeys`.
  *
- * Must be called in an injection context (constructor, factory, or `inject()`).
+ * @returns A signal of all registrations, without callbacks
  *
- * @returns Object with `hotkeys` and `sequences` signals
+ * @example
+ * ```ts
+ * @Component({
+ *   template: `
+ *     @for (reg of registrations(); track reg.id) {
+ *       <li>{{ reg.options.meta?.name }}</li>
+ *     }
+ *   `,
+ * })
+ * export class ShortcutPalette {
+ *   registrations = injectHotkeyRegistrations()
+ * }
+ * ```
  */
-export declare function injectHotkeyRegistrations(): HotkeyRegistrationsResult;
+export declare function injectHotkeyRegistrations(): Signal<Array<HotkeyRegistrationView>>;
 //#endregion

package/dist/injectHotkeyRegistrations.js

@@ -1,26 +1,32 @@
-import { getHotkeyManager, getSequenceManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
+import { getHotkeyManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
 import { injectSelector } from "@tanstack/angular-store";
 
 //#region src/injectHotkeyRegistrations.ts
 /**
-* Angular injectable that reactively reads all hotkey and sequence registrations
-* from the singleton managers.
+* Angular inject-based API that reactively reads every hotkey registration,
+* chords and sequences, from the singleton HotkeyManager. Narrow each view
+* with `kind`.
 *
-* This is a standalone injectable that does NOT require the HotkeysProvider.
-* It subscribes to both HotkeyManager and SequenceManager stores and
-* triggers change detection when registrations change.
+* This does NOT require `provideHotkeys`.
 *
-* Must be called in an injection context (constructor, factory, or `inject()`).
+* @returns A signal of all registrations, without callbacks
 *
-* @returns Object with `hotkeys` and `sequences` signals
+* @example
+* ```ts
+* @Component({
+*   template: `
+*     @for (reg of registrations(); track reg.id) {
+*       <li>{{ reg.options.meta?.name }}</li>
+*     }
+*   `,
+* })
+* export class ShortcutPalette {
+*   registrations = injectHotkeyRegistrations()
+* }
+* ```
 */
 function injectHotkeyRegistrations() {
-	const hotkeyManager = getHotkeyManager();
-	const sequenceManager = getSequenceManager();
-	return {
-		hotkeys: injectSelector(hotkeyManager.registrations, (state) => Array.from(state.values()).map(toHotkeyRegistrationView)),
-		sequences: injectSelector(sequenceManager.registrations, (state) => Array.from(state.values()))
-	};
+	return injectSelector(getHotkeyManager().registrations, (state) => Array.from(state.values()).map(toHotkeyRegistrationView));
 }
 
 //#endregion

package/dist/injectHotkeys.d.ts

@@ -1,63 +1,27 @@
-import { InjectHotkeyOptions } from "./injectHotkey.js";
-import { HotkeyCallback, RegisterableHotkey } from "@tanstack/hotkeys";
+import { InjectHotkeyCommonOptions, InjectHotkeyTarget } from "./injectHotkey.js";
+import { AdapterHotkeyDefinition } from "@tanstack/hotkeys/adapter";
 //#region src/injectHotkeys.d.ts
 /**
- * A single hotkey definition for use with `injectHotkeys`.
+ * One hotkey for `injectHotkeys`. Chords accept `requireReset`; sequences
+ * accept `timeout`; hotkeys of unknown kind accept only shared options.
  */
-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);
-}
+export type InjectHotkeyDefinition = AdapterHotkeyDefinition<InjectHotkeyTarget>;
 /**
- * Angular inject-based API for registering multiple keyboard hotkeys at once.
+ * Angular inject-based API for registering several hotkeys at once: chords,
+ * sequences, and app hotkeys. Pass a getter for a reactive list.
  *
- * 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() },
- *     ])
- *   }
- * }
- * ```
+ * Options merge in this order: provider defaults, app hotkey declaration,
+ * commonOptions, per-hotkey options. Each option applies only to the kinds
+ * that support it. Unbound app hotkeys and empty sequences register nothing.
+ * A `null` target skips registration until it is set.
  *
  * @example
  * ```ts
- * @Component({ ... })
- * export class DynamicShortcuts {
- *   shortcuts = signal([...])
- *
- *   constructor() {
- *     injectHotkeys(
- *       () => this.shortcuts().map((s) => ({
- *         hotkey: s.key,
- *         callback: s.action,
- *       })),
- *     )
- *   }
- * }
+ * injectHotkeys([
+ *   { hotkey: 'Mod+S', callback: () => this.save() },
+ *   { hotkey: ['G', 'G'], callback: () => this.scrollToTop(), options: { timeout: 500 } },
+ * ])
  * ```
  */
-export declare function injectHotkeys(hotkeys: Array<InjectHotkeyDefinition> | (() => Array<InjectHotkeyDefinition>), commonOptions?: InjectHotkeyOptions | (() => InjectHotkeyOptions)): void;
+export declare function injectHotkeys(hotkeys: ReadonlyArray<InjectHotkeyDefinition> | (() => ReadonlyArray<InjectHotkeyDefinition>), commonOptions?: InjectHotkeyCommonOptions | (() => InjectHotkeyCommonOptions)): void;
 //#endregion

package/dist/injectHotkeys.js

@@ -1,118 +1,38 @@
-import { injectDefaultHotkeysOptions } from "./hotkeys-provider.js";
-import { detectPlatform, getHotkeyManager, normalizeRegisterableHotkey } from "@tanstack/hotkeys";
-import { DestroyRef, effect, inject } from "@angular/core";
+import { injectHotkeysContext } from "./hotkeys-provider.js";
+import { DestroyRef, effect, inject, untracked } from "@angular/core";
+import { createHotkeyBindings, prepareHotkeyDefinitions } from "@tanstack/hotkeys/adapter";
 
 //#region src/injectHotkeys.ts
 /**
-* Angular inject-based API for registering multiple keyboard hotkeys at once.
+* Angular inject-based API for registering several hotkeys at once: chords,
+* sequences, and app hotkeys. Pass a getter for a reactive list.
 *
-* 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
+* Options merge in this order: provider defaults, app hotkey declaration,
+* commonOptions, per-hotkey options. Each option applies only to the kinds
+* that support it. Unbound app hotkeys and empty sequences register nothing.
+* A `null` target skips registration until it is set.
 *
 * @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,
-*       })),
-*     )
-*   }
-* }
+* injectHotkeys([
+*   { hotkey: 'Mod+S', callback: () => this.save() },
+*   { hotkey: ['G', 'G'], callback: () => this.scrollToTop(), options: { timeout: 500 } },
+* ])
 * ```
 */
 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();
-	});
+	const context = injectHotkeysContext();
+	const bindings = createHotkeyBindings();
+	inject(DestroyRef).onDestroy(() => bindings.destroy());
 	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 = normalizeRegisterableHotkey(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
-			});
-		}
+		context.appHotkeysState();
+		const definitions = prepareHotkeyDefinitions(typeof hotkeys === "function" ? hotkeys() : hotkeys, {
+			appHotkeysStore: context.appHotkeysStore,
+			defaults: context.defaultOptions.hotkey,
+			commonOptions: typeof commonOptions === "function" ? commonOptions() : commonOptions,
+			resolveTarget: (target) => target
+		});
+		untracked(() => bindings.update(definitions));
 	});
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/angular-hotkeys",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "description": "Angular adapter for TanStack Hotkeys",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -36,7 +36,7 @@
   ],
   "dependencies": {
     "@tanstack/angular-store": "^0.11.2",
-    "@tanstack/hotkeys": "0.11.0"
+    "@tanstack/hotkeys": "0.12.1"
   },
   "peerDependencies": {
     "@angular/common": ">=19.0.0",

package/dist/injectHotkeySequence.d.ts

@@ -1,45 +0,0 @@
-import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
-//#region src/injectHotkeySequence.d.ts
-export interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled' | 'target'> {
-  /** Whether the sequence is enabled. Defaults to true. */
-  enabled?: boolean;
-  /**
-   * The DOM element to attach the event listener to.
-   * Can be a direct DOM element, an accessor target, or null.
-   * Defaults to document when omitted.
-   */
-  target?: HTMLElement | Document | Window | null;
-}
-/**
- * Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).
- *
- * 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). `enabled: false` still registers
- *   the sequence (visible in devtools); only execution is suppressed.
- *
- * @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 })
- *     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))
- *   }
- * }
- * ```
- */
-export declare function injectHotkeySequence(sequence: HotkeySequence | (() => HotkeySequence), callback: HotkeyCallback, options?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions)): void;
-//#endregion

package/dist/injectHotkeySequence.js

@@ -1,92 +0,0 @@
-import { injectDefaultHotkeysOptions } from "./hotkeys-provider.js";
-import { formatHotkeySequence, getSequenceManager } from "@tanstack/hotkeys";
-import { DestroyRef, effect, inject } from "@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.
-*
-* 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). `enabled: false` still registers
-*   the sequence (visible in devtools); only execution is suppressed.
-*
-* @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 })
-*     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))
-*   }
-* }
-* ```
-*/
-function injectHotkeySequence(sequence, callback, options = {}) {
-	const defaultOptions = injectDefaultHotkeysOptions();
-	const manager = getSequenceManager();
-	const destroyRef = inject(DestroyRef);
-	let handle = null;
-	let lastSequenceKey = null;
-	let lastTarget = null;
-	destroyRef.onDestroy(() => {
-		if (handle?.isActive) {
-			handle.unregister();
-			handle = null;
-		}
-		lastSequenceKey = null;
-		lastTarget = null;
-	});
-	effect(() => {
-		const resolvedSequence = typeof sequence === "function" ? sequence() : sequence;
-		const resolvedOptions = typeof options === "function" ? options() : options;
-		const { enabled = true, ...sequenceOptions } = {
-			...defaultOptions.hotkeySequence,
-			...resolvedOptions
-		};
-		const resolvedTarget = "target" in sequenceOptions ? sequenceOptions.target ?? null : typeof document !== "undefined" ? document : null;
-		if (resolvedSequence.length === 0 || !resolvedTarget) {
-			if (handle?.isActive) {
-				handle.unregister();
-				handle = null;
-			}
-			lastSequenceKey = null;
-			lastTarget = null;
-			return;
-		}
-		const sequenceKey = formatHotkeySequence(resolvedSequence);
-		const registerPayload = {
-			...sequenceOptions,
-			enabled,
-			target: resolvedTarget
-		};
-		const { target: _t, ...optionsWithoutTarget } = registerPayload;
-		if (handle?.isActive && lastSequenceKey === sequenceKey && lastTarget === resolvedTarget) {
-			handle.callback = callback;
-			handle.setOptions(optionsWithoutTarget);
-			return;
-		}
-		if (handle?.isActive) {
-			handle.unregister();
-			handle = null;
-		}
-		handle = manager.register(resolvedSequence, callback, registerPayload);
-		lastSequenceKey = sequenceKey;
-		lastTarget = resolvedTarget;
-	});
-}
-
-//#endregion
-export { injectHotkeySequence };

package/dist/injectHotkeySequenceRecorder.d.ts

@@ -1,16 +0,0 @@
-import { HotkeySequence, HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
-//#region src/injectHotkeySequenceRecorder.d.ts
-export interface AngularHotkeySequenceRecorder {
-  readonly isRecording: () => boolean;
-  readonly steps: () => HotkeySequence;
-  readonly recordedSequence: () => HotkeySequence | null;
-  readonly startRecording: () => void;
-  readonly stopRecording: () => void;
-  readonly cancelRecording: () => void;
-  readonly commitRecording: () => void;
-}
-/**
- * Angular inject-based API for recording multi-chord sequences.
- */
-export declare function injectHotkeySequenceRecorder(options: HotkeySequenceRecorderOptions | (() => HotkeySequenceRecorderOptions)): AngularHotkeySequenceRecorder;
-//#endregion

package/dist/injectHotkeySequenceRecorder.js

@@ -1,58 +0,0 @@
-import { injectDefaultHotkeysOptions } from "./hotkeys-provider.js";
-import { HotkeySequenceRecorder } from "@tanstack/hotkeys";
-import { DestroyRef, computed, effect, inject, linkedSignal, untracked } from "@angular/core";
-
-//#region src/injectHotkeySequenceRecorder.ts
-/**
-* Angular inject-based API for recording multi-chord sequences.
-*/
-function injectHotkeySequenceRecorder(options) {
-	const defaultOptions = injectDefaultHotkeysOptions();
-	const destroyRef = inject(DestroyRef);
-	const recorderSignal = computed(() => untracked(() => {
-		const resolvedOptions = typeof options === "function" ? options() : options;
-		const mergedOptions = {
-			...defaultOptions.hotkeySequenceRecorder,
-			...resolvedOptions
-		};
-		return new HotkeySequenceRecorder(mergedOptions);
-	}));
-	const recorderStore = computed(() => untracked(() => recorderSignal().store));
-	const isRecording = injectLazyStore(recorderStore, (state) => state.isRecording);
-	const steps = injectLazyStore(recorderStore, (state) => state.steps);
-	const recordedSequence = injectLazyStore(recorderStore, (state) => state.recordedSequence);
-	effect(() => {
-		const resolved = typeof options === "function" ? options() : options;
-		recorderSignal().setOptions({
-			...defaultOptions.hotkeySequenceRecorder,
-			...resolved
-		});
-	});
-	destroyRef.onDestroy(() => {
-		recorderSignal().destroy();
-	});
-	return {
-		isRecording,
-		steps,
-		recordedSequence,
-		startRecording: () => recorderSignal().start(),
-		stopRecording: () => recorderSignal().stop(),
-		cancelRecording: () => recorderSignal().cancel(),
-		commitRecording: () => recorderSignal().commit()
-	};
-}
-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 { injectHotkeySequenceRecorder };

package/dist/injectHotkeySequences.d.ts

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