@tanstack/angular-hotkeys 0.10.0 → 0.12.0

package/dist/index.d.cts

@@ -1,13 +0,0 @@
-import { InjectHotkeyOptions, injectHotkey } from "./injectHotkey.cjs";
-import { InjectHotkeySequenceOptions, injectHotkeySequence } from "./injectHotkeySequence.cjs";
-import { HOTKEYS_INJECTION_TOKEN, HotkeysContextValue, HotkeysProviderOptions, injectDefaultHotkeysOptions, injectHotkeysContext, provideHotkeys } from "./hotkeys-provider.cjs";
-import { InjectHotkeyDefinition, injectHotkeys } from "./injectHotkeys.cjs";
-import { InjectHotkeySequenceDefinition, injectHotkeySequences } from "./injectHotkeySequences.cjs";
-import { injectHeldKeys } from "./injectHeldKeys.cjs";
-import { injectHeldKeyCodes } from "./injectHeldKeyCodes.cjs";
-import { injectKeyHold } from "./injectKeyHold.cjs";
-import { AngularHotkeyRecorder, injectHotkeyRecorder } from "./injectHotkeyRecorder.cjs";
-import { HotkeyRegistrationsResult, injectHotkeyRegistrations } from "./injectHotkeyRegistrations.cjs";
-import { AngularHotkeySequenceRecorder, injectHotkeySequenceRecorder } from "./injectHotkeySequenceRecorder.cjs";
-export * from "@tanstack/hotkeys";
-export { AngularHotkeyRecorder, AngularHotkeySequenceRecorder, HOTKEYS_INJECTION_TOKEN, HotkeyRegistrationsResult, HotkeysContextValue, HotkeysProviderOptions, InjectHotkeyDefinition, InjectHotkeyOptions, InjectHotkeySequenceDefinition, InjectHotkeySequenceOptions, injectDefaultHotkeysOptions, injectHeldKeyCodes, injectHeldKeys, injectHotkey, injectHotkeyRecorder, injectHotkeyRegistrations, injectHotkeySequence, injectHotkeySequenceRecorder, injectHotkeySequences, injectHotkeys, injectHotkeysContext, injectKeyHold, provideHotkeys };

package/dist/injectHeldKeyCodes.cjs

@@ -1,34 +0,0 @@
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _tanstack_angular_store = require("@tanstack/angular-store");
-
-//#region src/injectHeldKeyCodes.ts
-/**
-* Angular inject-based API that returns a signal of a map from held key names to their physical `event.code` values.
-*
-* Useful for debugging which physical key was pressed (e.g. distinguishing
-* left vs right Shift via "ShiftLeft" / "ShiftRight").
-*
-* @returns Signal of record mapping normalized key names to their `event.code` values
-*
-* @example
-* ```ts
-* @Component({
-*   template: `
-*     @for (key of heldKeys(); track key) {
-*       <kbd>{{ key }} <small>{{ heldCodes()[key] }}</small></kbd>
-*     }
-*   `,
-* })
-* export class KeyDebugComponent {
-*   heldKeys = injectHeldKeys()
-*   heldCodes = injectHeldKeyCodes()
-* }
-* ```
-*/
-function injectHeldKeyCodes() {
-	return (0, _tanstack_angular_store.injectSelector)((0, _tanstack_hotkeys.getKeyStateTracker)().store, (state) => state.heldCodes);
-}
-
-//#endregion
-exports.injectHeldKeyCodes = injectHeldKeyCodes;
-//# sourceMappingURL=injectHeldKeyCodes.cjs.map

package/dist/injectHeldKeyCodes.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHeldKeyCodes.cjs","names":[],"sources":["../src/injectHeldKeyCodes.ts"],"sourcesContent":["import { getKeyStateTracker } from '@tanstack/hotkeys'\nimport { injectSelector } from '@tanstack/angular-store'\nimport type { Signal } from '@angular/core'\n\n/**\n * Angular inject-based API that returns a signal of a map from held key names to their physical `event.code` values.\n *\n * Useful for debugging which physical key was pressed (e.g. distinguishing\n * left vs right Shift via \"ShiftLeft\" / \"ShiftRight\").\n *\n * @returns Signal of record mapping normalized key names to their `event.code` values\n *\n * @example\n * ```ts\n * @Component({\n *   template: `\n *     @for (key of heldKeys(); track key) {\n *       <kbd>{{ key }} <small>{{ heldCodes()[key] }}</small></kbd>\n *     }\n *   `,\n * })\n * export class KeyDebugComponent {\n *   heldKeys = injectHeldKeys()\n *   heldCodes = injectHeldKeyCodes()\n * }\n * ```\n */\nexport function injectHeldKeyCodes(): Signal<Record<string, string>> {\n  const tracker = getKeyStateTracker()\n  return injectSelector(tracker.store, (state) => state.heldCodes)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,qBAAqD;AAEnE,+FADoC,CACN,QAAQ,UAAU,MAAM,UAAU"}

package/dist/injectHeldKeyCodes.d.cts

@@ -1,30 +0,0 @@
-import { Signal } from "@angular/core";
-
-//#region src/injectHeldKeyCodes.d.ts
-/**
- * Angular inject-based API that returns a signal of a map from held key names to their physical `event.code` values.
- *
- * Useful for debugging which physical key was pressed (e.g. distinguishing
- * left vs right Shift via "ShiftLeft" / "ShiftRight").
- *
- * @returns Signal of record mapping normalized key names to their `event.code` values
- *
- * @example
- * ```ts
- * @Component({
- *   template: `
- *     @for (key of heldKeys(); track key) {
- *       <kbd>{{ key }} <small>{{ heldCodes()[key] }}</small></kbd>
- *     }
- *   `,
- * })
- * export class KeyDebugComponent {
- *   heldKeys = injectHeldKeys()
- *   heldCodes = injectHeldKeyCodes()
- * }
- * ```
- */
-declare function injectHeldKeyCodes(): Signal<Record<string, string>>;
-//#endregion
-export { injectHeldKeyCodes };
-//# sourceMappingURL=injectHeldKeyCodes.d.cts.map

package/dist/injectHeldKeyCodes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHeldKeyCodes.js","names":[],"sources":["../src/injectHeldKeyCodes.ts"],"sourcesContent":["import { getKeyStateTracker } from '@tanstack/hotkeys'\nimport { injectSelector } from '@tanstack/angular-store'\nimport type { Signal } from '@angular/core'\n\n/**\n * Angular inject-based API that returns a signal of a map from held key names to their physical `event.code` values.\n *\n * Useful for debugging which physical key was pressed (e.g. distinguishing\n * left vs right Shift via \"ShiftLeft\" / \"ShiftRight\").\n *\n * @returns Signal of record mapping normalized key names to their `event.code` values\n *\n * @example\n * ```ts\n * @Component({\n *   template: `\n *     @for (key of heldKeys(); track key) {\n *       <kbd>{{ key }} <small>{{ heldCodes()[key] }}</small></kbd>\n *     }\n *   `,\n * })\n * export class KeyDebugComponent {\n *   heldKeys = injectHeldKeys()\n *   heldCodes = injectHeldKeyCodes()\n * }\n * ```\n */\nexport function injectHeldKeyCodes(): Signal<Record<string, string>> {\n  const tracker = getKeyStateTracker()\n  return injectSelector(tracker.store, (state) => state.heldCodes)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,qBAAqD;AAEnE,QAAO,eADS,oBAAoB,CACN,QAAQ,UAAU,MAAM,UAAU"}

package/dist/injectHeldKeys.cjs

@@ -1,29 +0,0 @@
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _tanstack_angular_store = require("@tanstack/angular-store");
-
-//#region src/injectHeldKeys.ts
-/**
-* Angular inject-based API that returns a signal of currently held keyboard keys.
-*
-* Subscribes to the global KeyStateTracker and updates whenever keys are
-* pressed or released.
-*
-* @returns Signal of array of currently held key names
-*
-* @example
-* ```ts
-* @Component({
-*   template: `<div>Currently pressed: {{ heldKeys().join(' + ') || 'None' }}</div>`,
-* })
-* export class KeyDisplayComponent {
-*   heldKeys = injectHeldKeys()
-* }
-* ```
-*/
-function injectHeldKeys() {
-	return (0, _tanstack_angular_store.injectSelector)((0, _tanstack_hotkeys.getKeyStateTracker)().store, (state) => state.heldKeys);
-}
-
-//#endregion
-exports.injectHeldKeys = injectHeldKeys;
-//# sourceMappingURL=injectHeldKeys.cjs.map

package/dist/injectHeldKeys.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHeldKeys.cjs","names":[],"sources":["../src/injectHeldKeys.ts"],"sourcesContent":["import { getKeyStateTracker } from '@tanstack/hotkeys'\nimport { injectSelector } from '@tanstack/angular-store'\nimport type { Signal } from '@angular/core'\n\n/**\n * Angular inject-based API that returns a signal of currently held keyboard keys.\n *\n * Subscribes to the global KeyStateTracker and updates whenever keys are\n * pressed or released.\n *\n * @returns Signal of array of currently held key names\n *\n * @example\n * ```ts\n * @Component({\n *   template: `<div>Currently pressed: {{ heldKeys().join(' + ') || 'None' }}</div>`,\n * })\n * export class KeyDisplayComponent {\n *   heldKeys = injectHeldKeys()\n * }\n * ```\n */\nexport function injectHeldKeys(): Signal<Array<string>> {\n  const tracker = getKeyStateTracker()\n  return injectSelector(tracker.store, (state) => state.heldKeys)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,iBAAwC;AAEtD,+FADoC,CACN,QAAQ,UAAU,MAAM,SAAS"}

package/dist/injectHeldKeys.d.cts

@@ -1,25 +0,0 @@
-import { Signal } from "@angular/core";
-
-//#region src/injectHeldKeys.d.ts
-/**
- * Angular inject-based API that returns a signal of currently held keyboard keys.
- *
- * Subscribes to the global KeyStateTracker and updates whenever keys are
- * pressed or released.
- *
- * @returns Signal of array of currently held key names
- *
- * @example
- * ```ts
- * @Component({
- *   template: `<div>Currently pressed: {{ heldKeys().join(' + ') || 'None' }}</div>`,
- * })
- * export class KeyDisplayComponent {
- *   heldKeys = injectHeldKeys()
- * }
- * ```
- */
-declare function injectHeldKeys(): Signal<Array<string>>;
-//#endregion
-export { injectHeldKeys };
-//# sourceMappingURL=injectHeldKeys.d.cts.map

package/dist/injectHeldKeys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHeldKeys.js","names":[],"sources":["../src/injectHeldKeys.ts"],"sourcesContent":["import { getKeyStateTracker } from '@tanstack/hotkeys'\nimport { injectSelector } from '@tanstack/angular-store'\nimport type { Signal } from '@angular/core'\n\n/**\n * Angular inject-based API that returns a signal of currently held keyboard keys.\n *\n * Subscribes to the global KeyStateTracker and updates whenever keys are\n * pressed or released.\n *\n * @returns Signal of array of currently held key names\n *\n * @example\n * ```ts\n * @Component({\n *   template: `<div>Currently pressed: {{ heldKeys().join(' + ') || 'None' }}</div>`,\n * })\n * export class KeyDisplayComponent {\n *   heldKeys = injectHeldKeys()\n * }\n * ```\n */\nexport function injectHeldKeys(): Signal<Array<string>> {\n  const tracker = getKeyStateTracker()\n  return injectSelector(tracker.store, (state) => state.heldKeys)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,iBAAwC;AAEtD,QAAO,eADS,oBAAoB,CACN,QAAQ,UAAU,MAAM,SAAS"}

package/dist/injectHotkey.cjs

@@ -1,122 +0,0 @@
-const require_hotkeys_provider = require('./hotkeys-provider.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _angular_core = require("@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.
-* `enabled: false` keeps the registration (visible in devtools) and only suppresses firing; the same
-* handle is updated instead of unregistering and re-registering when identity is unchanged.
-*
-* @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function
-* @param callback - The function to call when the hotkey is pressed
-* @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 = require_hotkeys_provider.injectDefaultHotkeysOptions();
-	const manager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
-	let registration = null;
-	let lastHotkeyString = null;
-	let lastTarget = null;
-	destroyRef.onDestroy(() => {
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
-		}
-		lastHotkeyString = null;
-		lastTarget = null;
-	});
-	(0, _angular_core.effect)(() => {
-		const resolvedHotkey = typeof hotkey === "function" ? hotkey() : hotkey;
-		const resolvedOptions = typeof options === "function" ? options() : options;
-		const mergedOptions = {
-			...defaultOptions.hotkey,
-			...resolvedOptions
-		};
-		const hotkeyString = (0, _tanstack_hotkeys.normalizeRegisterableHotkey)(resolvedHotkey, mergedOptions.platform ?? (0, _tanstack_hotkeys.detectPlatform)());
-		const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
-		if (!resolvedTarget) {
-			if (registration?.isActive) {
-				registration.unregister();
-				registration = null;
-			}
-			lastHotkeyString = null;
-			lastTarget = null;
-			return;
-		}
-		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-		if (registration?.isActive && lastHotkeyString === hotkeyString && lastTarget === resolvedTarget) {
-			registration.callback = callback;
-			registration.setOptions(optionsWithoutTarget);
-			return;
-		}
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
-		}
-		registration = manager.register(hotkeyString, callback, {
-			...optionsWithoutTarget,
-			target: resolvedTarget
-		});
-		if (registration.isActive) {
-			registration.callback = callback;
-			registration.setOptions(optionsWithoutTarget);
-		}
-		lastHotkeyString = hotkeyString;
-		lastTarget = resolvedTarget;
-	});
-}
-
-//#endregion
-exports.injectHotkey = injectHotkey;
-//# sourceMappingURL=injectHotkey.cjs.map

package/dist/injectHotkey.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHotkey.cjs","names":["injectDefaultHotkeysOptions","DestroyRef"],"sources":["../src/injectHotkey.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport {\n  detectPlatform,\n  getHotkeyManager,\n  normalizeRegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\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 * `enabled: false` keeps the registration (visible in devtools) and only suppresses firing; the same\n * handle is updated instead of unregistering and re-registering when identity is unchanged.\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  const destroyRef = inject(DestroyRef)\n\n  let registration: HotkeyRegistrationHandle | null = null\n  let lastHotkeyString: Hotkey | null = null\n  let lastTarget: HTMLElement | Document | Window | null = null\n\n  destroyRef.onDestroy(() => {\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n    lastHotkeyString = null\n    lastTarget = null\n  })\n\n  effect(() => {\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 = normalizeRegisterableHotkey(resolvedHotkey, platform)\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      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n      lastHotkeyString = null\n      lastTarget = null\n      return\n    }\n\n    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    if (\n      registration?.isActive &&\n      lastHotkeyString === hotkeyString &&\n      lastTarget === resolvedTarget\n    ) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n      return\n    }\n\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n\n    registration = manager.register(hotkeyString, callback, {\n      ...optionsWithoutTarget,\n      target: resolvedTarget,\n    })\n\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    lastHotkeyString = hotkeyString\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFA,SAAgB,aACd,QACA,UACA,UAA6D,EAAE,EACzD;CACN,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,mDAA4B;CAClC,MAAM,uCAAoBC,yBAAW;CAErC,IAAI,eAAgD;CACpD,IAAI,mBAAkC;CACtC,IAAI,aAAqD;AAEzD,YAAW,gBAAgB;AACzB,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAEjB,qBAAmB;AACnB,eAAa;GACb;AAEF,iCAAa;EAEX,MAAM,iBAAiB,OAAO,WAAW,aAAa,QAAQ,GAAG;EACjE,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAID,MAAM,kEAA2C,gBADhC,cAAc,mDAA4B,CACe;EAI1E,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,gBAAgB;AACnB,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,sBAAmB;AACnB,gBAAa;AACb;;EAIF,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,MACE,cAAc,YACd,qBAAqB,gBACrB,eAAe,gBACf;AACA,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;AAC7C;;AAGF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAGjB,iBAAe,QAAQ,SAAS,cAAc,UAAU;GACtD,GAAG;GACH,QAAQ;GACT,CAAC;AAEF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAG/C,qBAAmB;AACnB,eAAa;GACb"}

package/dist/injectHotkey.d.cts

@@ -1,75 +0,0 @@
-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.
- * `enabled: false` keeps the registration (visible in devtools) and only suppresses firing; the same
- * handle is updated instead of unregistering and re-registering when identity is unchanged.
- *
- * @param hotkey - The hotkey string (e.g. 'Mod+S', 'Escape') or getter function
- * @param callback - The function to call when the hotkey is pressed
- * @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.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHotkey.js","names":[],"sources":["../src/injectHotkey.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport {\n  detectPlatform,\n  getHotkeyManager,\n  normalizeRegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\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 * `enabled: false` keeps the registration (visible in devtools) and only suppresses firing; the same\n * handle is updated instead of unregistering and re-registering when identity is unchanged.\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  const destroyRef = inject(DestroyRef)\n\n  let registration: HotkeyRegistrationHandle | null = null\n  let lastHotkeyString: Hotkey | null = null\n  let lastTarget: HTMLElement | Document | Window | null = null\n\n  destroyRef.onDestroy(() => {\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n    lastHotkeyString = null\n    lastTarget = null\n  })\n\n  effect(() => {\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 = normalizeRegisterableHotkey(resolvedHotkey, platform)\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      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n      lastHotkeyString = null\n      lastTarget = null\n      return\n    }\n\n    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    if (\n      registration?.isActive &&\n      lastHotkeyString === hotkeyString &&\n      lastTarget === resolvedTarget\n    ) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n      return\n    }\n\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n\n    registration = manager.register(hotkeyString, callback, {\n      ...optionsWithoutTarget,\n      target: resolvedTarget,\n    })\n\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    lastHotkeyString = hotkeyString\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFA,SAAgB,aACd,QACA,UACA,UAA6D,EAAE,EACzD;CACN,MAAM,iBAAiB,6BAA6B;CACpD,MAAM,UAAU,kBAAkB;CAClC,MAAM,aAAa,OAAO,WAAW;CAErC,IAAI,eAAgD;CACpD,IAAI,mBAAkC;CACtC,IAAI,aAAqD;AAEzD,YAAW,gBAAgB;AACzB,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAEjB,qBAAmB;AACnB,eAAa;GACb;AAEF,cAAa;EAEX,MAAM,iBAAiB,OAAO,WAAW,aAAa,QAAQ,GAAG;EACjE,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAID,MAAM,eAAe,4BAA4B,gBADhC,cAAc,YAAY,gBAAgB,CACe;EAI1E,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,gBAAgB;AACnB,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,sBAAmB;AACnB,gBAAa;AACb;;EAIF,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,MACE,cAAc,YACd,qBAAqB,gBACrB,eAAe,gBACf;AACA,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;AAC7C;;AAGF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAGjB,iBAAe,QAAQ,SAAS,cAAc,UAAU;GACtD,GAAG;GACH,QAAQ;GACT,CAAC;AAEF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAG/C,qBAAmB;AACnB,eAAa;GACb"}

package/dist/injectHotkeyRecorder.cjs

@@ -1,82 +0,0 @@
-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

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

@@ -1,49 +0,0 @@
-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.js.map

@@ -1 +0,0 @@
-{"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/injectHotkeyRegistrations.cjs

@@ -1,28 +0,0 @@
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _tanstack_angular_store = require("@tanstack/angular-store");
-
-//#region src/injectHotkeyRegistrations.ts
-/**
-* Angular injectable that reactively reads all hotkey and sequence registrations
-* from the singleton managers.
-*
-* 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.
-*
-* Must be called in an injection context (constructor, factory, or `inject()`).
-*
-* @returns Object with `hotkeys` and `sequences` signals
-*/
-function injectHotkeyRegistrations() {
-	const hotkeyManager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	const sequenceManager = (0, _tanstack_hotkeys.getSequenceManager)();
-	return {
-		hotkeys: (0, _tanstack_angular_store.injectSelector)(hotkeyManager.registrations, (state) => Array.from(state.values()).map(_tanstack_hotkeys.toHotkeyRegistrationView)),
-		sequences: (0, _tanstack_angular_store.injectSelector)(sequenceManager.registrations, (state) => Array.from(state.values()))
-	};
-}
-
-//#endregion
-exports.injectHotkeyRegistrations = injectHotkeyRegistrations;
-//# sourceMappingURL=injectHotkeyRegistrations.cjs.map

package/dist/injectHotkeyRegistrations.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHotkeyRegistrations.cjs","names":["toHotkeyRegistrationView"],"sources":["../src/injectHotkeyRegistrations.ts"],"sourcesContent":["import { injectSelector } from '@tanstack/angular-store'\nimport {\n  getHotkeyManager,\n  getSequenceManager,\n  toHotkeyRegistrationView,\n} from '@tanstack/hotkeys'\nimport type {\n  HotkeyRegistrationView,\n  SequenceRegistrationView,\n} from '@tanstack/hotkeys'\nimport type { Signal } from '@angular/core'\n\n/**\n * Return type for injectHotkeyRegistrations.\n */\nexport interface HotkeyRegistrationsResult {\n  /** Signal for all registered hotkeys (public view, no callbacks) */\n  hotkeys: Signal<Array<HotkeyRegistrationView>>\n  /** Signal for all registered sequences */\n  sequences: Signal<Array<SequenceRegistrationView>>\n}\n\n/**\n * Angular injectable that reactively reads all hotkey and sequence registrations\n * from the singleton managers.\n *\n * This is a standalone injectable that does NOT require the HotkeysProvider.\n * It subscribes to both HotkeyManager and SequenceManager stores and\n * triggers change detection when registrations change.\n *\n * Must be called in an injection context (constructor, factory, or `inject()`).\n *\n * @returns Object with `hotkeys` and `sequences` signals\n */\nexport function injectHotkeyRegistrations(): HotkeyRegistrationsResult {\n  const hotkeyManager = getHotkeyManager()\n  const sequenceManager = getSequenceManager()\n\n  const hotkeys = injectSelector(hotkeyManager.registrations, (state) =>\n    Array.from(state.values()).map(toHotkeyRegistrationView),\n  )\n\n  const sequences = injectSelector(sequenceManager.registrations, (state) =>\n    Array.from(state.values()),\n  )\n\n  return { hotkeys, sequences }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkCA,SAAgB,4BAAuD;CACrE,MAAM,yDAAkC;CACxC,MAAM,6DAAsC;AAU5C,QAAO;EAAE,qDARsB,cAAc,gBAAgB,UAC3D,MAAM,KAAK,MAAM,QAAQ,CAAC,CAAC,IAAIA,2CAAyB,CACzD;EAMiB,uDAJe,gBAAgB,gBAAgB,UAC/D,MAAM,KAAK,MAAM,QAAQ,CAAC,CAC3B;EAE4B"}

package/dist/injectHotkeyRegistrations.d.cts

@@ -1,29 +0,0 @@
-import { HotkeyRegistrationView, SequenceRegistrationView } from "@tanstack/hotkeys";
-import { Signal } from "@angular/core";
-
-//#region src/injectHotkeyRegistrations.d.ts
-/**
- * Return type for injectHotkeyRegistrations.
- */
-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.
- *
- * 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.
- *
- * Must be called in an injection context (constructor, factory, or `inject()`).
- *
- * @returns Object with `hotkeys` and `sequences` signals
- */
-declare function injectHotkeyRegistrations(): HotkeyRegistrationsResult;
-//#endregion
-export { HotkeyRegistrationsResult, injectHotkeyRegistrations };
-//# sourceMappingURL=injectHotkeyRegistrations.d.cts.map

package/dist/injectHotkeyRegistrations.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHotkeyRegistrations.js","names":[],"sources":["../src/injectHotkeyRegistrations.ts"],"sourcesContent":["import { injectSelector } from '@tanstack/angular-store'\nimport {\n  getHotkeyManager,\n  getSequenceManager,\n  toHotkeyRegistrationView,\n} from '@tanstack/hotkeys'\nimport type {\n  HotkeyRegistrationView,\n  SequenceRegistrationView,\n} from '@tanstack/hotkeys'\nimport type { Signal } from '@angular/core'\n\n/**\n * Return type for injectHotkeyRegistrations.\n */\nexport interface HotkeyRegistrationsResult {\n  /** Signal for all registered hotkeys (public view, no callbacks) */\n  hotkeys: Signal<Array<HotkeyRegistrationView>>\n  /** Signal for all registered sequences */\n  sequences: Signal<Array<SequenceRegistrationView>>\n}\n\n/**\n * Angular injectable that reactively reads all hotkey and sequence registrations\n * from the singleton managers.\n *\n * This is a standalone injectable that does NOT require the HotkeysProvider.\n * It subscribes to both HotkeyManager and SequenceManager stores and\n * triggers change detection when registrations change.\n *\n * Must be called in an injection context (constructor, factory, or `inject()`).\n *\n * @returns Object with `hotkeys` and `sequences` signals\n */\nexport function injectHotkeyRegistrations(): HotkeyRegistrationsResult {\n  const hotkeyManager = getHotkeyManager()\n  const sequenceManager = getSequenceManager()\n\n  const hotkeys = injectSelector(hotkeyManager.registrations, (state) =>\n    Array.from(state.values()).map(toHotkeyRegistrationView),\n  )\n\n  const sequences = injectSelector(sequenceManager.registrations, (state) =>\n    Array.from(state.values()),\n  )\n\n  return { hotkeys, sequences }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkCA,SAAgB,4BAAuD;CACrE,MAAM,gBAAgB,kBAAkB;CACxC,MAAM,kBAAkB,oBAAoB;AAU5C,QAAO;EAAE,SARO,eAAe,cAAc,gBAAgB,UAC3D,MAAM,KAAK,MAAM,QAAQ,CAAC,CAAC,IAAI,yBAAyB,CACzD;EAMiB,WAJA,eAAe,gBAAgB,gBAAgB,UAC/D,MAAM,KAAK,MAAM,QAAQ,CAAC,CAC3B;EAE4B"}