@tanstack/angular-hotkeys 0.5.1 → 0.7.0

package/dist/injectHotkeySequence.js.map

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

package/dist/injectHotkeySequenceRecorder.cjs

@@ -0,0 +1,58 @@
+const require_hotkeys_provider = require('./hotkeys-provider.cjs');
+let _tanstack_hotkeys = require("@tanstack/hotkeys");
+let _angular_core = require("@angular/core");
+
+//#region src/injectHotkeySequenceRecorder.ts
+/**
+* Angular inject-based API for recording multi-chord sequences.
+*/
+function injectHotkeySequenceRecorder(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.HotkeySequenceRecorder({
+			...defaultOptions.hotkeySequenceRecorder,
+			...resolvedOptions
+		});
+	}));
+	const recorderStore = (0, _angular_core.computed)(() => (0, _angular_core.untracked)(() => recorderSignal().store));
+	const isRecording = injectLazyStore(recorderStore, (state) => state.isRecording);
+	const steps = injectLazyStore(recorderStore, (state) => state.steps);
+	const recordedSequence = injectLazyStore(recorderStore, (state) => state.recordedSequence);
+	(0, _angular_core.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 = (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.injectHotkeySequenceRecorder = injectHotkeySequenceRecorder;
+//# sourceMappingURL=injectHotkeySequenceRecorder.cjs.map

package/dist/injectHotkeySequenceRecorder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectHotkeySequenceRecorder.cjs","names":["injectDefaultHotkeysOptions","DestroyRef","HotkeySequenceRecorder"],"sources":["../src/injectHotkeySequenceRecorder.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  effect,\n  inject,\n  linkedSignal,\n  untracked,\n} from '@angular/core'\nimport { HotkeySequenceRecorder } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type { Atom, ReadonlyAtom } from '@tanstack/angular-store'\nimport type { Signal } from '@angular/core'\nimport type {\n  HotkeySequence,\n  HotkeySequenceRecorderOptions,\n} from '@tanstack/hotkeys'\n\nexport interface AngularHotkeySequenceRecorder {\n  readonly isRecording: () => boolean\n  readonly steps: () => HotkeySequence\n  readonly recordedSequence: () => HotkeySequence | null\n  readonly startRecording: () => void\n  readonly stopRecording: () => void\n  readonly cancelRecording: () => void\n  readonly commitRecording: () => void\n}\n\n/**\n * Angular inject-based API for recording multi-chord sequences.\n */\nexport function injectHotkeySequenceRecorder(\n  options:\n    | HotkeySequenceRecorderOptions\n    | (() => HotkeySequenceRecorderOptions),\n): AngularHotkeySequenceRecorder {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const destroyRef = inject(DestroyRef)\n\n  const recorderSignal = computed(() =>\n    untracked(() => {\n      const resolvedOptions =\n        typeof options === 'function' ? options() : options\n\n      const mergedOptions = {\n        ...defaultOptions.hotkeySequenceRecorder,\n        ...resolvedOptions,\n      } as HotkeySequenceRecorderOptions\n\n      return new HotkeySequenceRecorder(mergedOptions)\n    }),\n  )\n\n  const recorderStore = computed(() => untracked(() => recorderSignal().store))\n  const isRecording = injectLazyStore(\n    recorderStore,\n    (state) => state.isRecording,\n  )\n  const steps = injectLazyStore(recorderStore, (state) => state.steps)\n  const recordedSequence = injectLazyStore(\n    recorderStore,\n    (state) => state.recordedSequence,\n  )\n\n  effect(() => {\n    const resolved = typeof options === 'function' ? options() : options\n    recorderSignal().setOptions({\n      ...defaultOptions.hotkeySequenceRecorder,\n      ...resolved,\n    } as HotkeySequenceRecorderOptions)\n  })\n\n  destroyRef.onDestroy(() => {\n    recorderSignal().destroy()\n  })\n\n  return {\n    isRecording,\n    steps,\n    recordedSequence,\n    startRecording: () => recorderSignal().start(),\n    stopRecording: () => recorderSignal().stop(),\n    cancelRecording: () => recorderSignal().cancel(),\n    commitRecording: () => recorderSignal().commit(),\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":";;;;;;;;AA8BA,SAAgB,6BACd,SAG+B;CAC/B,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,uCAAoBC,yBAAW;CAErC,MAAM,sFACY;EACd,MAAM,kBACJ,OAAO,YAAY,aAAa,SAAS,GAAG;AAO9C,SAAO,IAAIC,yCALW;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ,CAE+C;GAChD,CACH;CAED,MAAM,qFAA+C,gBAAgB,CAAC,MAAM,CAAC;CAC7E,MAAM,cAAc,gBAClB,gBACC,UAAU,MAAM,YAClB;CACD,MAAM,QAAQ,gBAAgB,gBAAgB,UAAU,MAAM,MAAM;CACpE,MAAM,mBAAmB,gBACvB,gBACC,UAAU,MAAM,iBAClB;AAED,iCAAa;EACX,MAAM,WAAW,OAAO,YAAY,aAAa,SAAS,GAAG;AAC7D,kBAAgB,CAAC,WAAW;GAC1B,GAAG,eAAe;GAClB,GAAG;GACJ,CAAkC;GACnC;AAEF,YAAW,gBAAgB;AACzB,kBAAgB,CAAC,SAAS;GAC1B;AAEF,QAAO;EACL;EACA;EACA;EACA,sBAAsB,gBAAgB,CAAC,OAAO;EAC9C,qBAAqB,gBAAgB,CAAC,MAAM;EAC5C,uBAAuB,gBAAgB,CAAC,QAAQ;EAChD,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/injectHotkeySequenceRecorder.d.cts

@@ -0,0 +1,19 @@
+import { HotkeySequence, HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
+
+//#region src/injectHotkeySequenceRecorder.d.ts
+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.
+ */
+declare function injectHotkeySequenceRecorder(options: HotkeySequenceRecorderOptions | (() => HotkeySequenceRecorderOptions)): AngularHotkeySequenceRecorder;
+//#endregion
+export { AngularHotkeySequenceRecorder, injectHotkeySequenceRecorder };
+//# sourceMappingURL=injectHotkeySequenceRecorder.d.cts.map

package/dist/injectHotkeySequenceRecorder.d.ts

@@ -0,0 +1,19 @@
+import { HotkeySequence, HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
+
+//#region src/injectHotkeySequenceRecorder.d.ts
+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.
+ */
+declare function injectHotkeySequenceRecorder(options: HotkeySequenceRecorderOptions | (() => HotkeySequenceRecorderOptions)): AngularHotkeySequenceRecorder;
+//#endregion
+export { AngularHotkeySequenceRecorder, injectHotkeySequenceRecorder };
+//# sourceMappingURL=injectHotkeySequenceRecorder.d.ts.map

package/dist/injectHotkeySequenceRecorder.js

@@ -0,0 +1,58 @@
+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;
+		return new HotkeySequenceRecorder({
+			...defaultOptions.hotkeySequenceRecorder,
+			...resolvedOptions
+		});
+	}));
+	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 };
+//# sourceMappingURL=injectHotkeySequenceRecorder.js.map

package/dist/injectHotkeySequenceRecorder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectHotkeySequenceRecorder.js","names":[],"sources":["../src/injectHotkeySequenceRecorder.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  effect,\n  inject,\n  linkedSignal,\n  untracked,\n} from '@angular/core'\nimport { HotkeySequenceRecorder } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type { Atom, ReadonlyAtom } from '@tanstack/angular-store'\nimport type { Signal } from '@angular/core'\nimport type {\n  HotkeySequence,\n  HotkeySequenceRecorderOptions,\n} from '@tanstack/hotkeys'\n\nexport interface AngularHotkeySequenceRecorder {\n  readonly isRecording: () => boolean\n  readonly steps: () => HotkeySequence\n  readonly recordedSequence: () => HotkeySequence | null\n  readonly startRecording: () => void\n  readonly stopRecording: () => void\n  readonly cancelRecording: () => void\n  readonly commitRecording: () => void\n}\n\n/**\n * Angular inject-based API for recording multi-chord sequences.\n */\nexport function injectHotkeySequenceRecorder(\n  options:\n    | HotkeySequenceRecorderOptions\n    | (() => HotkeySequenceRecorderOptions),\n): AngularHotkeySequenceRecorder {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const destroyRef = inject(DestroyRef)\n\n  const recorderSignal = computed(() =>\n    untracked(() => {\n      const resolvedOptions =\n        typeof options === 'function' ? options() : options\n\n      const mergedOptions = {\n        ...defaultOptions.hotkeySequenceRecorder,\n        ...resolvedOptions,\n      } as HotkeySequenceRecorderOptions\n\n      return new HotkeySequenceRecorder(mergedOptions)\n    }),\n  )\n\n  const recorderStore = computed(() => untracked(() => recorderSignal().store))\n  const isRecording = injectLazyStore(\n    recorderStore,\n    (state) => state.isRecording,\n  )\n  const steps = injectLazyStore(recorderStore, (state) => state.steps)\n  const recordedSequence = injectLazyStore(\n    recorderStore,\n    (state) => state.recordedSequence,\n  )\n\n  effect(() => {\n    const resolved = typeof options === 'function' ? options() : options\n    recorderSignal().setOptions({\n      ...defaultOptions.hotkeySequenceRecorder,\n      ...resolved,\n    } as HotkeySequenceRecorderOptions)\n  })\n\n  destroyRef.onDestroy(() => {\n    recorderSignal().destroy()\n  })\n\n  return {\n    isRecording,\n    steps,\n    recordedSequence,\n    startRecording: () => recorderSignal().start(),\n    stopRecording: () => recorderSignal().stop(),\n    cancelRecording: () => recorderSignal().cancel(),\n    commitRecording: () => recorderSignal().commit(),\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":";;;;;;;;AA8BA,SAAgB,6BACd,SAG+B;CAC/B,MAAM,iBAAiB,6BAA6B;CACpD,MAAM,aAAa,OAAO,WAAW;CAErC,MAAM,iBAAiB,eACrB,gBAAgB;EACd,MAAM,kBACJ,OAAO,YAAY,aAAa,SAAS,GAAG;AAO9C,SAAO,IAAI,uBALW;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ,CAE+C;GAChD,CACH;CAED,MAAM,gBAAgB,eAAe,gBAAgB,gBAAgB,CAAC,MAAM,CAAC;CAC7E,MAAM,cAAc,gBAClB,gBACC,UAAU,MAAM,YAClB;CACD,MAAM,QAAQ,gBAAgB,gBAAgB,UAAU,MAAM,MAAM;CACpE,MAAM,mBAAmB,gBACvB,gBACC,UAAU,MAAM,iBAClB;AAED,cAAa;EACX,MAAM,WAAW,OAAO,YAAY,aAAa,SAAS,GAAG;AAC7D,kBAAgB,CAAC,WAAW;GAC1B,GAAG,eAAe;GAClB,GAAG;GACJ,CAAkC;GACnC;AAEF,YAAW,gBAAgB;AACzB,kBAAgB,CAAC,SAAS;GAC1B;AAEF,QAAO;EACL;EACA;EACA;EACA,sBAAsB,gBAAgB,CAAC,OAAO;EAC9C,qBAAqB,gBAAgB,CAAC,MAAM;EAC5C,uBAAuB,gBAAgB,CAAC,QAAQ;EAChD,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/injectHotkeySequences.cjs

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

package/dist/injectHotkeySequences.cjs.map

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

package/dist/injectHotkeySequences.d.cts

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

package/dist/injectHotkeySequences.d.ts

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

package/dist/injectHotkeySequences.js

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

package/dist/injectHotkeySequences.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/angular-hotkeys",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Angular adapter for TanStack Hotkeys",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -42,7 +42,7 @@
   ],
   "dependencies": {
     "@tanstack/angular-store": "^0.9.2",
-    "@tanstack/hotkeys": "0.4.3"
+    "@tanstack/hotkeys": "0.5.0"
   },
   "peerDependencies": {
     "@angular/common": ">=19.0.0",

package/src/hotkeys-provider.ts

@@ -1,5 +1,8 @@
 import { InjectionToken, inject } from '@angular/core'
-import type { HotkeyRecorderOptions } from '@tanstack/hotkeys'
+import type {
+  HotkeyRecorderOptions,
+  HotkeySequenceRecorderOptions,
+} from '@tanstack/hotkeys'
 import type { InjectHotkeyOptions } from './injectHotkey'
 import type { InjectHotkeySequenceOptions } from './injectHotkeySequence'
 import type { StaticProvider } from '@angular/core'
@@ -7,6 +10,7 @@ import type { StaticProvider } from '@angular/core'
 export interface HotkeysProviderOptions {
   hotkey?: Partial<InjectHotkeyOptions>
   hotkeyRecorder?: Partial<HotkeyRecorderOptions>
+  hotkeySequenceRecorder?: Partial<HotkeySequenceRecorderOptions>
   hotkeySequence?: Partial<InjectHotkeySequenceOptions>
 }
 

package/src/index.ts

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