@tanstack/ember-hotkeys 0.1.0

package/README.md

@@ -0,0 +1,140 @@
+<div align="center">
+  <picture>
+    <source
+      media="(prefers-color-scheme: dark)"
+      srcset="https://tanstack.com/api/readme/hotkeys.png?theme=dark"
+    />
+    <source
+      media="(prefers-color-scheme: light)"
+      srcset="https://tanstack.com/api/readme/hotkeys.png"
+    />
+    <img
+      src="https://tanstack.com/api/readme/hotkeys.png"
+      alt="TanStack Hotkeys"
+      width="900"
+    />
+  </picture>
+</div>
+
+<br />
+
+<div align="center">
+	<a href="https://www.npmjs.com/package/@tanstack/hotkeys" target="\_parent">
+	  <img alt="" src="https://img.shields.io/npm/dm/@tanstack/hotkeys.svg" alt="npm downloads" />
+	</a>
+	<a href="https://github.com/TanStack/hotkeys" target="\_parent">
+	  <img alt="" src="https://img.shields.io/github/stars/TanStack/hotkeys.svg?style=social&label=Star" alt="GitHub stars" />
+	</a>
+	<a href="https://bundlephobia.com/result?p=@tanstack/react-hotkeys@latest" target="\_parent">
+	  <img alt="" src="https://badgen.net/bundlephobia/minzip/@tanstack/react-hotkeys@latest" alt="Bundle size" />
+	</a>
+</div>
+
+<div align="center">
+	<a href="#badge">
+	  <img alt="semantic-release" src="https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg">
+	</a>
+	<a href="#badge">
+	  <img src="https://img.shields.io/github/v/release/tanstack/hotkeys" alt="Release"/>
+	</a>
+	<a href="https://twitter.com/tan_stack">
+	  <img src="https://img.shields.io/twitter/follow/tan_stack.svg?style=social" alt="Follow @TanStack"/>
+	</a>
+</div>
+
+<div align="center">
+
+### [Become a Sponsor!](https://github.com/sponsors/tannerlinsley/)
+
+</div>
+
+# TanStack Hotkeys
+
+> [!NOTE]
+> TanStack Hotkeys is alpha. We are actively developing the library and are open to feedback and contributions.
+
+Type-safe keyboard shortcuts for the web. Template-string bindings, parsed objects, a cross-platform `Mod` key, a singleton Hotkey Manager, and utilities for cheatsheet UIs—built to stay SSR-friendly.
+
+- Type-safe bindings — template strings (`Mod+Shift+S`, `Escape`) or parsed objects for full control
+- Flexible options — `keydown`/`keyup`, `preventDefault`, `stopPropagation`, conditional enabled, `requireReset`
+- Cross-platform Mod — maps to Cmd on macOS and Ctrl on Windows/Linux
+- Batteries included — validation + matching, sequences (Vim-style), key-state tracking, recorder UI helpers, framework adapters, and devtools
+
+### <a href="https://tanstack.com/hotkeys">Read the docs →</a>
+
+<br />
+
+> [!NOTE]
+> You may know **TanStack Hotkeys** by our adapter names, too!
+>
+> - [**Alpine Hotkeys**](https://tanstack.com/hotkeys/latest/docs/framework/alpine/quick-start)
+> - [**Ember Hotkeys**](https://tanstack.com/hotkeys/latest/docs/framework/ember/quick-start)
+> - [**Octane Hotkeys**](https://tanstack.com/hotkeys/latest/docs/framework/octane/quick-start)
+> - [**React Hotkeys**](https://tanstack.com/hotkeys/latest/docs/framework/react/react-hotkeys)
+> - [**Preact Hotkeys**](https://tanstack.com/hotkeys/latest/docs/framework/preact/preact-hotkeys)
+> - [**Solid Hotkeys**](https://tanstack.com/hotkeys/latest/docs/framework/solid/reference)
+> - [**Angular Hotkeys**](https://tanstack.com/hotkeys/latest/docs/framework/angular/reference)
+> - [**Vue Hotkeys**](https://tanstack.com/hotkeys/latest/docs/framework/vue/reference)
+> - [**Lit Hotkeys**](https://tanstack.com/hotkeys/latest/docs/framework/lit/reference)
+> - [**Svelte Hotkeys**](https://tanstack.com/hotkeys/latest/docs/framework/svelte/reference)
+
+## Get Involved
+
+- We welcome issues and pull requests!
+- Participate in [GitHub discussions](https://github.com/TanStack/hotkeys/discussions)
+- Chat with the community on [Discord](https://discord.com/invite/WrRKjPJ)
+- See [CONTRIBUTING.md](./CONTRIBUTING.md) for setup instructions
+
+## Partners
+
+<div align="center">
+
+<table align="center">
+  <tr>
+    <td>
+      <a href="https://www.coderabbit.ai/?via=tanstack&dub_id=aCcEEdAOqqutX6OS" >
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="https://tanstack.com/assets/coderabbit-dark-D643Zkrv.svg" height="40" />
+          <source media="(prefers-color-scheme: light)" srcset="https://tanstack.com/assets/coderabbit-light-CIzGLYU_.svg" height="40" />
+          <img src="https://tanstack.com/assets/coderabbit-light-DVMJ2jHi.svg" height="40" alt="CodeRabbit" />
+        </picture>
+      </a>
+    </td>
+    <td>
+      <a href="https://www.cloudflare.com?utm_source=tanstack">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="https://tanstack.com/assets/cloudflare-white-Co-Tyjbl.svg" height="60" />
+          <source media="(prefers-color-scheme: light)" srcset="https://tanstack.com/assets/cloudflare-black-6Ojsn8yh.svg" height="60" />
+          <img src="https://tanstack.com/assets/cloudflare-black-CPufaW0B.svg" height="60" alt="Cloudflare" />
+        </picture>
+      </a>
+    </td>
+  </tr>
+</table>
+
+<div align="center">
+<img src="media/partner_logo.svg" alt="Keys & you?" height="65">
+<p>
+We're looking for TanStack Hotkeys Partners to join our mission! Partner with us to push the boundaries of TanStack Hotkeys and build amazing things together.
+</p>
+<a href="mailto:partners@tanstack.com?subject=TanStack Hotkeys Partnership"><b>LET'S CHAT</b></a>
+</div>
+
+</div>
+
+## Explore the TanStack Ecosystem
+
+- <a href="https://github.com/tanstack/config"><b>TanStack Config</b></a> – Tooling for JS/TS packages
+- <a href="https://github.com/tanstack/db"><b>TanStack DB</b></a> – Reactive sync client store
+- <a href="https://github.com/tanstack/devtools"><b>TanStack DevTools</b></a> – Unified devtools panel
+- <a href="https://github.com/tanstack/form"><b>TanStack Form</b></a> – Type‑safe form state
+- <a href="https://github.com/tanstack/hotkeys"><b>TanStack Hotkeys</b></a> – Type‑safe keyboard shortcuts
+- <a href="https://github.com/tanstack/query"><b>TanStack Query</b></a> – Async state & caching
+- <a href="https://github.com/tanstack/ranger"><b>TanStack Ranger</b></a> – Range & slider primitives
+- <a href="https://github.com/tanstack/router"><b>TanStack Router</b></a> – Type‑safe routing, caching & URL state
+- <a href="https://github.com/tanstack/start"><b>TanStack Start</b></a> – Full‑stack SSR & streaming
+- <a href="https://github.com/tanstack/store"><b>TanStack Store</b></a> – Reactive data store
+- <a href="https://github.com/tanstack/table"><b>TanStack Table</b></a> – Headless datagrids
+- <a href="https://github.com/tanstack/virtual"><b>TanStack Virtual</b></a> – Virtualized rendering
+
+… and more at <a href="https://tanstack.com"><b>TanStack.com »</b></a>

package/addon-main.cjs

@@ -0,0 +1,4 @@
+'use strict'
+
+const { addonV1Shim } = require('@embroider/addon-shim')
+module.exports = addonV1Shim(__dirname)

package/dist/createHotkeysScope.d.ts

@@ -0,0 +1,28 @@
+import { UseHotkey } from "./useHotkey.js";
+import { UseHotkeys } from "./useHotkeys.js";
+import { UseHotkeySequence } from "./useHotkeySequence.js";
+import { UseHotkeySequences } from "./useHotkeySequences.js";
+import { MaybeGetter } from "./utils.js";
+import { DefaultHotkeysOptions } from "./types.js";
+import { useHotkeyRecorder } from "./useHotkeyRecorder.js";
+import { useHotkeySequenceRecorder } from "./useHotkeySequenceRecorder.js";
+import { OnHotkeys } from "./onHotkeys.js";
+import { OnHotkey } from "./onHotkey.js";
+//#region src/createHotkeysScope.d.ts
+/** Helpers, modifiers, and recorder factories with shared defaults. Owners retain their own cleanup. */
+export interface EmberHotkeysScope {
+  onHotkey: typeof OnHotkey;
+  onHotkeys: typeof OnHotkeys;
+  useHotkey: typeof UseHotkey;
+  useHotkeys: typeof UseHotkeys;
+  useHotkeySequence: typeof UseHotkeySequence;
+  useHotkeySequences: typeof UseHotkeySequences;
+  useHotkeyRecorder: typeof useHotkeyRecorder;
+  useHotkeySequenceRecorder: typeof useHotkeySequenceRecorder;
+}
+/**
+ * Creates contextual helpers, modifiers, and recorders with shared, optionally reactive defaults.
+ * Pass the scope to child components through arguments to share configuration.
+ */
+export declare function createHotkeysScope(defaultOptions?: MaybeGetter<DefaultHotkeysOptions>): EmberHotkeysScope;
+//#endregion

package/dist/createHotkeysScope.js

@@ -0,0 +1,78 @@
+import { UseHotkey } from "./useHotkey.js";
+import { UseHotkeys } from "./useHotkeys.js";
+import { UseHotkeySequence } from "./useHotkeySequence.js";
+import { UseHotkeySequences } from "./useHotkeySequences.js";
+import { read } from "./utils.js";
+import { useHotkeyRecorder } from "./useHotkeyRecorder.js";
+import { useHotkeySequenceRecorder } from "./useHotkeySequenceRecorder.js";
+import { OnHotkey } from "./onHotkey.js";
+import { OnHotkeys } from "./onHotkeys.js";
+
+//#region src/createHotkeysScope.ts
+/**
+* Creates contextual helpers, modifiers, and recorders with shared, optionally reactive defaults.
+* Pass the scope to child components through arguments to share configuration.
+*/
+function createHotkeysScope(defaultOptions = {}) {
+	return {
+		onHotkey: class extends OnHotkey {
+			modify(...[element, args, options]) {
+				super.modify(element, args, {
+					...read(defaultOptions).hotkey,
+					...options
+				});
+			}
+		},
+		onHotkeys: class extends OnHotkeys {
+			modify(...[element, args, options]) {
+				super.modify(element, args, {
+					...read(defaultOptions).hotkey,
+					...options
+				});
+			}
+		},
+		useHotkey: class extends UseHotkey {
+			compute(...[args, options]) {
+				super.compute(args, {
+					...read(defaultOptions).hotkey,
+					...options
+				});
+			}
+		},
+		useHotkeys: class extends UseHotkeys {
+			compute(...[args, options]) {
+				super.compute(args, {
+					...read(defaultOptions).hotkey,
+					...options
+				});
+			}
+		},
+		useHotkeySequence: class extends UseHotkeySequence {
+			compute(...[args, options]) {
+				super.compute(args, {
+					...read(defaultOptions).hotkeySequence,
+					...options
+				});
+			}
+		},
+		useHotkeySequences: class extends UseHotkeySequences {
+			compute(...[args, options]) {
+				super.compute(args, {
+					...read(defaultOptions).hotkeySequence,
+					...options
+				});
+			}
+		},
+		useHotkeyRecorder: (owner, options) => useHotkeyRecorder(owner, () => ({
+			...read(defaultOptions).hotkeyRecorder,
+			...read(options)
+		})),
+		useHotkeySequenceRecorder: (owner, options) => useHotkeySequenceRecorder(owner, () => ({
+			...read(defaultOptions).hotkeySequenceRecorder,
+			...read(options)
+		}))
+	};
+}
+
+//#endregion
+export { createHotkeysScope };

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { UseHotkey } from "./useHotkey.js";
+import { UseHotkeys } from "./useHotkeys.js";
+import { UseHotkeySequence } from "./useHotkeySequence.js";
+import { UseHotkeySequences } from "./useHotkeySequences.js";
+import { MaybeGetter } from "./utils.js";
+import { DefaultHotkeysOptions, EmberHotkeyRecorder, EmberHotkeySequenceRecorder, EmberHotkeyState, HotkeyRegistrationsResult } from "./types.js";
+import { useHeldKeys } from "./useHeldKeys.js";
+import { useHeldKeyCodes } from "./useHeldKeyCodes.js";
+import { useKeyHold } from "./useKeyHold.js";
+import { useHotkeyHint } from "./useHotkeyHint.js";
+import { useHotkeyRegistrations } from "./useHotkeyRegistrations.js";
+import { useHotkeyRecorder } from "./useHotkeyRecorder.js";
+import { useHotkeySequenceRecorder } from "./useHotkeySequenceRecorder.js";
+import { ElementHotkeyOptions, OnHotkeys } from "./onHotkeys.js";
+import { OnHotkey } from "./onHotkey.js";
+import { EmberHotkeysScope, createHotkeysScope } from "./createHotkeysScope.js";
+import { HotkeyDefinition, HotkeySequenceDefinition } from "@tanstack/hotkeys/adapter";
+export * from "@tanstack/hotkeys";
+export { DefaultHotkeysOptions, type ElementHotkeyOptions, EmberHotkeyRecorder, EmberHotkeySequenceRecorder, EmberHotkeyState, EmberHotkeysScope, type HotkeyDefinition, HotkeyRegistrationsResult, type HotkeySequenceDefinition, type MaybeGetter, createHotkeysScope, OnHotkey as onHotkey, OnHotkeys as onHotkeys, useHeldKeyCodes, useHeldKeys, UseHotkey as useHotkey, useHotkeyHint, useHotkeyRecorder, useHotkeyRegistrations, UseHotkeySequence as useHotkeySequence, useHotkeySequenceRecorder, UseHotkeySequences as useHotkeySequences, UseHotkeys as useHotkeys, useKeyHold };

package/dist/index.js

@@ -0,0 +1,18 @@
+import { UseHotkey } from "./useHotkey.js";
+import { UseHotkeys } from "./useHotkeys.js";
+import { UseHotkeySequence } from "./useHotkeySequence.js";
+import { UseHotkeySequences } from "./useHotkeySequences.js";
+import { useHeldKeys } from "./useHeldKeys.js";
+import { useHeldKeyCodes } from "./useHeldKeyCodes.js";
+import { useKeyHold } from "./useKeyHold.js";
+import { useHotkeyHint } from "./useHotkeyHint.js";
+import { useHotkeyRegistrations } from "./useHotkeyRegistrations.js";
+import { useHotkeyRecorder } from "./useHotkeyRecorder.js";
+import { useHotkeySequenceRecorder } from "./useHotkeySequenceRecorder.js";
+import { OnHotkey } from "./onHotkey.js";
+import { OnHotkeys } from "./onHotkeys.js";
+import { createHotkeysScope } from "./createHotkeysScope.js";
+
+export * from "@tanstack/hotkeys"
+
+export { createHotkeysScope, OnHotkey as onHotkey, OnHotkeys as onHotkeys, useHeldKeyCodes, useHeldKeys, UseHotkey as useHotkey, useHotkeyHint, useHotkeyRecorder, useHotkeyRegistrations, UseHotkeySequence as useHotkeySequence, useHotkeySequenceRecorder, UseHotkeySequences as useHotkeySequences, UseHotkeys as useHotkeys, useKeyHold };

package/dist/onHotkey.d.ts

@@ -0,0 +1,19 @@
+import { ElementHotkeyOptions } from "./onHotkeys.js";
+import { HotkeyCallback, RegisterableHotkey } from "@tanstack/hotkeys";
+import Modifier from "ember-modifier";
+//#region src/onHotkey.d.ts
+/** Attaches a shortcut to the element that owns the modifier. */
+export declare class OnHotkey extends Modifier<{
+  Element: HTMLElement;
+  Args: {
+    Positional: [RegisterableHotkey, HotkeyCallback];
+    Named: ElementHotkeyOptions;
+  };
+}> {
+  private bindings;
+  private definition;
+  private cleanup;
+  modify(element: HTMLElement, [hotkey, callback]: [RegisterableHotkey, HotkeyCallback], options: ElementHotkeyOptions): void;
+  private update;
+}
+//#endregion

package/dist/onHotkey.js

@@ -0,0 +1,30 @@
+import { isDestroyed, isDestroying, registerDestructor } from "@ember/destroyable";
+import { scheduleOnce } from "@ember/runloop";
+import { createHotkeyBindings } from "@tanstack/hotkeys/adapter";
+import Modifier from "ember-modifier";
+
+//#region src/onHotkey.ts
+/** Attaches a shortcut to the element that owns the modifier. */
+var OnHotkey = class extends Modifier {
+	bindings = createHotkeyBindings();
+	definition;
+	cleanup = registerDestructor(this, () => this.bindings.destroy());
+	modify(element, [hotkey, callback], options) {
+		this.cleanup;
+		this.definition = {
+			hotkey: typeof hotkey === "string" ? hotkey : { ...hotkey },
+			callback,
+			options: {
+				...options,
+				target: element
+			}
+		};
+		scheduleOnce("afterRender", this, this.update);
+	}
+	update() {
+		if (this.definition && !isDestroying(this) && !isDestroyed(this)) this.bindings.update([this.definition]);
+	}
+};
+
+//#endregion
+export { OnHotkey };

package/dist/onHotkeys.d.ts

@@ -0,0 +1,22 @@
+import { HotkeyOptions } from "@tanstack/hotkeys";
+import { HotkeyDefinition } from "@tanstack/hotkeys/adapter";
+import Modifier from "ember-modifier";
+//#region src/onHotkeys.d.ts
+/** Options for a modifier whose target is always its containing element. */
+export type ElementHotkeyOptions = Omit<HotkeyOptions, 'target'>;
+/** Attach a reactive list of shortcuts directly to an element. */
+export declare class OnHotkeys extends Modifier<{
+  Element: HTMLElement;
+  Args: {
+    Positional: [Array<HotkeyDefinition>];
+    Named: ElementHotkeyOptions;
+  };
+}> {
+  private bindings;
+  private definitions;
+  private options;
+  private cleanup;
+  modify(element: HTMLElement, [definitions]: [Array<HotkeyDefinition>], options: ElementHotkeyOptions): void;
+  private update;
+}
+//#endregion

package/dist/onHotkeys.js

@@ -0,0 +1,35 @@
+import { isDestroyed, isDestroying, registerDestructor } from "@ember/destroyable";
+import { scheduleOnce } from "@ember/runloop";
+import { createHotkeyBindings } from "@tanstack/hotkeys/adapter";
+import Modifier from "ember-modifier";
+
+//#region src/onHotkeys.ts
+/** Attach a reactive list of shortcuts directly to an element. */
+var OnHotkeys = class extends Modifier {
+	bindings = createHotkeyBindings();
+	definitions = [];
+	options = {};
+	cleanup = registerDestructor(this, () => this.bindings.destroy());
+	modify(element, [definitions], options) {
+		this.cleanup;
+		this.definitions = definitions.map((definition) => ({
+			...definition,
+			hotkey: typeof definition.hotkey === "string" ? definition.hotkey : { ...definition.hotkey },
+			options: {
+				...definition.options,
+				target: element
+			}
+		}));
+		this.options = {
+			...options,
+			target: element
+		};
+		scheduleOnce("afterRender", this, this.update);
+	}
+	update() {
+		if (!isDestroying(this) && !isDestroyed(this)) this.bindings.update(this.definitions, this.options);
+	}
+};
+
+//#endregion
+export { OnHotkeys };

package/dist/types.d.ts

@@ -0,0 +1,49 @@
+import { Hotkey, HotkeyOptions, HotkeyRecorderOptions, HotkeyRegistrationView, HotkeySequence, HotkeySequenceRecorderOptions, SequenceOptions, SequenceRegistrationView } from "@tanstack/hotkeys";
+//#region src/types.d.ts
+/** A reactive value. Read `.value` where the framework tracks dependencies. */
+export interface EmberHotkeyState<T> {
+  readonly value: T;
+}
+/** Recording state and controls owned by the containing component. */
+export interface EmberHotkeyRecorder {
+  /** Whether the recorder is listening for a shortcut. */
+  readonly isRecording: boolean;
+  /** The last recorded binding, including brackets for physical codes. */
+  readonly recordedHotkey: Hotkey | null;
+  /** Start a new recording session. */
+  startRecording: () => void;
+  /** Stop and clear recorder state without calling onRecord or onCancel. */
+  stopRecording: () => void;
+  /** Stop, clear recorder state, and call onCancel. */
+  cancelRecording: () => void;
+}
+/** Sequence recording state and controls. */
+export interface EmberHotkeySequenceRecorder {
+  /** Whether the recorder is listening for chords. */
+  readonly isRecording: boolean;
+  /** Chords captured in the current session. */
+  readonly steps: HotkeySequence;
+  /** The last committed sequence. */
+  readonly recordedSequence: HotkeySequence | null;
+  /** Start a new recording session. */
+  startRecording: () => void;
+  /** Stop without committing or calling onCancel. */
+  stopRecording: () => void;
+  /** Discard the current session and call onCancel. */
+  cancelRecording: () => void;
+  /** Commit the current steps. Does nothing when no steps are recorded. */
+  commitRecording: () => void;
+}
+/** Live registration views from the shared hotkey and sequence managers. */
+export interface HotkeyRegistrationsResult {
+  readonly hotkeys: Array<HotkeyRegistrationView>;
+  readonly sequences: Array<SequenceRegistrationView>;
+}
+/** Shared defaults; call-specific options take precedence. */
+export interface DefaultHotkeysOptions {
+  hotkey?: HotkeyOptions;
+  hotkeySequence?: SequenceOptions;
+  hotkeyRecorder?: Partial<HotkeyRecorderOptions>;
+  hotkeySequenceRecorder?: Partial<HotkeySequenceRecorderOptions>;
+}
+//#endregion

package/dist/useHeldKeyCodes.d.ts

@@ -0,0 +1,5 @@
+import { EmberHotkeyState } from "./types.js";
+//#region src/useHeldKeyCodes.d.ts
+/** Reads physical key codes through Ember autotracking. */
+export declare function useHeldKeyCodes(owner: object): EmberHotkeyState<Record<string, string>>;
+//#endregion

package/dist/useHeldKeyCodes.js

@@ -0,0 +1,11 @@
+import { select } from "./utils.js";
+import { getKeyStateTracker } from "@tanstack/hotkeys";
+
+//#region src/useHeldKeyCodes.ts
+/** Reads physical key codes through Ember autotracking. */
+function useHeldKeyCodes(owner) {
+	return select(owner, getKeyStateTracker().store, (state) => state.heldCodes);
+}
+
+//#endregion
+export { useHeldKeyCodes };

package/dist/useHeldKeys.d.ts

@@ -0,0 +1,5 @@
+import { EmberHotkeyState } from "./types.js";
+//#region src/useHeldKeys.d.ts
+/** Pass the containing component as owner to release the subscription on destruction. */
+export declare function useHeldKeys(owner: object): EmberHotkeyState<Array<string>>;
+//#endregion

package/dist/useHeldKeys.js

@@ -0,0 +1,11 @@
+import { select } from "./utils.js";
+import { getKeyStateTracker } from "@tanstack/hotkeys";
+
+//#region src/useHeldKeys.ts
+/** Pass the containing component as owner to release the subscription on destruction. */
+function useHeldKeys(owner) {
+	return select(owner, getKeyStateTracker().store, (state) => state.heldKeys);
+}
+
+//#endregion
+export { useHeldKeys };

package/dist/useHotkey.d.ts

@@ -0,0 +1,18 @@
+import { HotkeyCallback, HotkeyOptions, RegisterableHotkey } from "@tanstack/hotkeys";
+import Helper from "@ember/component/helper";
+//#region src/useHotkey.d.ts
+/** Use {{useHotkey "Mod+S" this.save enabled=this.enabled}} in a template. */
+export declare class UseHotkey extends Helper<{
+  Args: {
+    Positional: [RegisterableHotkey, HotkeyCallback];
+    Named: HotkeyOptions;
+  };
+  Return: void;
+}> {
+  private bindings;
+  private definition;
+  private cleanup;
+  compute([hotkey, callback]: [RegisterableHotkey, HotkeyCallback], options: HotkeyOptions): void;
+  private update;
+}
+//#endregion

package/dist/useHotkey.js

@@ -0,0 +1,27 @@
+import Helper from "@ember/component/helper";
+import { isDestroyed, isDestroying, registerDestructor } from "@ember/destroyable";
+import { scheduleOnce } from "@ember/runloop";
+import { createHotkeyBindings } from "@tanstack/hotkeys/adapter";
+
+//#region src/useHotkey.ts
+/** Use {{useHotkey "Mod+S" this.save enabled=this.enabled}} in a template. */
+var UseHotkey = class extends Helper {
+	bindings = createHotkeyBindings();
+	definition;
+	cleanup = registerDestructor(this, () => this.bindings.destroy());
+	compute([hotkey, callback], options) {
+		this.cleanup;
+		this.definition = {
+			hotkey: typeof hotkey === "string" ? hotkey : { ...hotkey },
+			callback,
+			options: { ...options }
+		};
+		scheduleOnce("afterRender", this, this.update);
+	}
+	update() {
+		if (this.definition && !isDestroying(this) && !isDestroyed(this)) this.bindings.update([this.definition]);
+	}
+};
+
+//#endregion
+export { UseHotkey };

package/dist/useHotkeyHint.d.ts

@@ -0,0 +1,7 @@
+import { MaybeGetter } from "./utils.js";
+import { EmberHotkeyState } from "./types.js";
+import { HeldModifierOptions, RegisterableHotkey } from "@tanstack/hotkeys";
+//#region src/useHotkeyHint.d.ts
+/** Recomputes for held modifiers and tracked changes to the binding or options. */
+export declare function useHotkeyHint(owner: object, hotkey: MaybeGetter<RegisterableHotkey>, options?: MaybeGetter<HeldModifierOptions>): EmberHotkeyState<boolean>;
+//#endregion

package/dist/useHotkeyHint.js

@@ -0,0 +1,11 @@
+import { read, select } from "./utils.js";
+import { getKeyStateTracker, matchesHeldModifiers } from "@tanstack/hotkeys";
+
+//#region src/useHotkeyHint.ts
+/** Recomputes for held modifiers and tracked changes to the binding or options. */
+function useHotkeyHint(owner, hotkey, options = {}) {
+	return select(owner, getKeyStateTracker().store, (state) => matchesHeldModifiers(read(hotkey), state.heldKeys, read(options)));
+}
+
+//#endregion
+export { useHotkeyHint };

package/dist/useHotkeyRecorder.d.ts

@@ -0,0 +1,7 @@
+import { MaybeGetter } from "./utils.js";
+import { EmberHotkeyRecorder } from "./types.js";
+import { HotkeyRecorderOptions } from "@tanstack/hotkeys";
+//#region src/useHotkeyRecorder.d.ts
+/** Creates an owned recorder with autotracked state and current callback options. */
+export declare function useHotkeyRecorder(owner: object, options: MaybeGetter<HotkeyRecorderOptions>): EmberHotkeyRecorder;
+//#endregion

package/dist/useHotkeyRecorder.js

@@ -0,0 +1,28 @@
+import { read, select } from "./utils.js";
+import { HotkeyRecorder } from "@tanstack/hotkeys";
+import { isDestroyed, isDestroying, registerDestructor } from "@ember/destroyable";
+
+//#region src/useHotkeyRecorder.ts
+/** Creates an owned recorder with autotracked state and current callback options. */
+function useHotkeyRecorder(owner, options) {
+	const recorder = new HotkeyRecorder(() => read(options));
+	const state = select(owner, recorder.store, (value) => value);
+	registerDestructor(owner, () => recorder.destroy());
+	return {
+		get isRecording() {
+			return state.value.isRecording;
+		},
+		get recordedHotkey() {
+			return state.value.recordedHotkey;
+		},
+		startRecording() {
+			if (isDestroying(owner) || isDestroyed(owner)) return;
+			recorder.start();
+		},
+		stopRecording: () => recorder.stop(),
+		cancelRecording: () => recorder.cancel()
+	};
+}
+
+//#endregion
+export { useHotkeyRecorder };

package/dist/useHotkeyRegistrations.d.ts

@@ -0,0 +1,5 @@
+import { HotkeyRegistrationsResult } from "./types.js";
+//#region src/useHotkeyRegistrations.d.ts
+/** Reads public snapshots of hotkey and sequence registrations. */
+export declare function useHotkeyRegistrations(owner: object): HotkeyRegistrationsResult;
+//#endregion

package/dist/useHotkeyRegistrations.js

@@ -0,0 +1,20 @@
+import { select } from "./utils.js";
+import { getHotkeyManager, getSequenceManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
+
+//#region src/useHotkeyRegistrations.ts
+/** Reads public snapshots of hotkey and sequence registrations. */
+function useHotkeyRegistrations(owner) {
+	const hotkeys = select(owner, getHotkeyManager().registrations, (state) => Array.from(state.values()).map(toHotkeyRegistrationView));
+	const sequences = select(owner, getSequenceManager().registrations, (state) => Array.from(state.values()));
+	return {
+		get hotkeys() {
+			return hotkeys.value;
+		},
+		get sequences() {
+			return sequences.value;
+		}
+	};
+}
+
+//#endregion
+export { useHotkeyRegistrations };

package/dist/useHotkeySequence.d.ts

@@ -0,0 +1,18 @@
+import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
+import Helper from "@ember/component/helper";
+//#region src/useHotkeySequence.d.ts
+/** Use {{useHotkeySequence this.sequence this.run}} in a template. */
+export declare class UseHotkeySequence extends Helper<{
+  Args: {
+    Positional: [HotkeySequence, HotkeyCallback];
+    Named: SequenceOptions;
+  };
+  Return: void;
+}> {
+  private bindings;
+  private definition;
+  private cleanup;
+  compute([sequence, callback]: [HotkeySequence, HotkeyCallback], options: SequenceOptions): void;
+  private update;
+}
+//#endregion

package/dist/useHotkeySequence.js

@@ -0,0 +1,27 @@
+import Helper from "@ember/component/helper";
+import { isDestroyed, isDestroying, registerDestructor } from "@ember/destroyable";
+import { scheduleOnce } from "@ember/runloop";
+import { createHotkeySequenceBindings } from "@tanstack/hotkeys/adapter";
+
+//#region src/useHotkeySequence.ts
+/** Use {{useHotkeySequence this.sequence this.run}} in a template. */
+var UseHotkeySequence = class extends Helper {
+	bindings = createHotkeySequenceBindings();
+	definition;
+	cleanup = registerDestructor(this, () => this.bindings.destroy());
+	compute([sequence, callback], options) {
+		this.cleanup;
+		this.definition = {
+			sequence: [...sequence],
+			callback,
+			options: { ...options }
+		};
+		scheduleOnce("afterRender", this, this.update);
+	}
+	update() {
+		if (this.definition && !isDestroying(this) && !isDestroyed(this)) this.bindings.update([this.definition]);
+	}
+};
+
+//#endregion
+export { UseHotkeySequence };

package/dist/useHotkeySequenceRecorder.d.ts

@@ -0,0 +1,7 @@
+import { MaybeGetter } from "./utils.js";
+import { EmberHotkeySequenceRecorder } from "./types.js";
+import { HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
+//#region src/useHotkeySequenceRecorder.d.ts
+/** Creates an owned sequence recorder with explicit commit and cancel controls. */
+export declare function useHotkeySequenceRecorder(owner: object, options: MaybeGetter<HotkeySequenceRecorderOptions>): EmberHotkeySequenceRecorder;
+//#endregion

package/dist/useHotkeySequenceRecorder.js

@@ -0,0 +1,32 @@
+import { read, select } from "./utils.js";
+import { HotkeySequenceRecorder } from "@tanstack/hotkeys";
+import { isDestroyed, isDestroying, registerDestructor } from "@ember/destroyable";
+
+//#region src/useHotkeySequenceRecorder.ts
+/** Creates an owned sequence recorder with explicit commit and cancel controls. */
+function useHotkeySequenceRecorder(owner, options) {
+	const recorder = new HotkeySequenceRecorder(() => read(options));
+	const state = select(owner, recorder.store, (value) => value);
+	registerDestructor(owner, () => recorder.destroy());
+	return {
+		get isRecording() {
+			return state.value.isRecording;
+		},
+		get steps() {
+			return state.value.steps;
+		},
+		get recordedSequence() {
+			return state.value.recordedSequence;
+		},
+		startRecording() {
+			if (isDestroying(owner) || isDestroyed(owner)) return;
+			recorder.start();
+		},
+		stopRecording: () => recorder.stop(),
+		cancelRecording: () => recorder.cancel(),
+		commitRecording: () => recorder.commit()
+	};
+}
+
+//#endregion
+export { useHotkeySequenceRecorder };

package/dist/useHotkeySequences.d.ts

@@ -0,0 +1,20 @@
+import { SequenceOptions } from "@tanstack/hotkeys";
+import Helper from "@ember/component/helper";
+import { HotkeySequenceDefinition } from "@tanstack/hotkeys/adapter";
+//#region src/useHotkeySequences.d.ts
+/** Registers a reactive list of sequences with the helper's template lifecycle. */
+export declare class UseHotkeySequences extends Helper<{
+  Args: {
+    Positional: [Array<HotkeySequenceDefinition>];
+    Named: SequenceOptions;
+  };
+  Return: void;
+}> {
+  private bindings;
+  private definitions;
+  private options;
+  private cleanup;
+  compute([definitions]: [Array<HotkeySequenceDefinition>], options: SequenceOptions): void;
+  private update;
+}
+//#endregion

package/dist/useHotkeySequences.js

@@ -0,0 +1,29 @@
+import Helper from "@ember/component/helper";
+import { isDestroyed, isDestroying, registerDestructor } from "@ember/destroyable";
+import { scheduleOnce } from "@ember/runloop";
+import { createHotkeySequenceBindings } from "@tanstack/hotkeys/adapter";
+
+//#region src/useHotkeySequences.ts
+/** Registers a reactive list of sequences with the helper's template lifecycle. */
+var UseHotkeySequences = class extends Helper {
+	bindings = createHotkeySequenceBindings();
+	definitions = [];
+	options = {};
+	cleanup = registerDestructor(this, () => this.bindings.destroy());
+	compute([definitions], options) {
+		this.cleanup;
+		this.definitions = definitions.map((definition) => ({
+			...definition,
+			sequence: [...definition.sequence],
+			options: { ...definition.options }
+		}));
+		this.options = { ...options };
+		scheduleOnce("afterRender", this, this.update);
+	}
+	update() {
+		if (!isDestroying(this) && !isDestroyed(this)) this.bindings.update(this.definitions, this.options);
+	}
+};
+
+//#endregion
+export { UseHotkeySequences };

package/dist/useHotkeys.d.ts

@@ -0,0 +1,20 @@
+import { HotkeyOptions } from "@tanstack/hotkeys";
+import Helper from "@ember/component/helper";
+import { HotkeyDefinition } from "@tanstack/hotkeys/adapter";
+//#region src/useHotkeys.d.ts
+/** Registers a reactive list of shortcuts with the helper's template lifecycle. */
+export declare class UseHotkeys extends Helper<{
+  Args: {
+    Positional: [Array<HotkeyDefinition>];
+    Named: HotkeyOptions;
+  };
+  Return: void;
+}> {
+  private bindings;
+  private definitions;
+  private options;
+  private cleanup;
+  compute([definitions]: [Array<HotkeyDefinition>], options: HotkeyOptions): void;
+  private update;
+}
+//#endregion

package/dist/useHotkeys.js

@@ -0,0 +1,29 @@
+import Helper from "@ember/component/helper";
+import { isDestroyed, isDestroying, registerDestructor } from "@ember/destroyable";
+import { scheduleOnce } from "@ember/runloop";
+import { createHotkeyBindings } from "@tanstack/hotkeys/adapter";
+
+//#region src/useHotkeys.ts
+/** Registers a reactive list of shortcuts with the helper's template lifecycle. */
+var UseHotkeys = class extends Helper {
+	bindings = createHotkeyBindings();
+	definitions = [];
+	options = {};
+	cleanup = registerDestructor(this, () => this.bindings.destroy());
+	compute([definitions], options) {
+		this.cleanup;
+		this.definitions = definitions.map((definition) => ({
+			...definition,
+			hotkey: typeof definition.hotkey === "string" ? definition.hotkey : { ...definition.hotkey },
+			options: { ...definition.options }
+		}));
+		this.options = { ...options };
+		scheduleOnce("afterRender", this, this.update);
+	}
+	update() {
+		if (!isDestroying(this) && !isDestroyed(this)) this.bindings.update(this.definitions, this.options);
+	}
+};
+
+//#endregion
+export { UseHotkeys };

package/dist/useKeyHold.d.ts

@@ -0,0 +1,7 @@
+import { MaybeGetter } from "./utils.js";
+import { EmberHotkeyState } from "./types.js";
+import { IndividualKey } from "@tanstack/hotkeys";
+//#region src/useKeyHold.d.ts
+/** Getter arguments can read changing tracked component properties. */
+export declare function useKeyHold(owner: object, key: MaybeGetter<IndividualKey>): EmberHotkeyState<boolean>;
+//#endregion

package/dist/useKeyHold.js

@@ -0,0 +1,11 @@
+import { read, select } from "./utils.js";
+import { getKeyStateTracker } from "@tanstack/hotkeys";
+
+//#region src/useKeyHold.ts
+/** Getter arguments can read changing tracked component properties. */
+function useKeyHold(owner, key) {
+	return select(owner, getKeyStateTracker().store, (state) => state.heldKeys.includes(read(key)));
+}
+
+//#endregion
+export { useKeyHold };

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+import "@tanstack/store";
+//#region src/utils.d.ts
+export type MaybeGetter<T> = T | (() => T);
+//#endregion

package/dist/utils.js

@@ -0,0 +1,20 @@
+import { registerDestructor } from "@ember/destroyable";
+import { trackedObject } from "@ember/reactive/collections";
+
+//#region src/utils.ts
+function read(value) {
+	return typeof value === "function" ? value() : value;
+}
+function select(owner, store, selector) {
+	const state = trackedObject({ snapshot: store.state });
+	const subscription = store.subscribe(() => {
+		state.snapshot = store.state;
+	});
+	registerDestructor(owner, () => subscription.unsubscribe());
+	return { get value() {
+		return selector(state.snapshot);
+	} };
+}
+
+//#endregion
+export { read, select };

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@tanstack/ember-hotkeys",
+  "version": "0.1.0",
+  "description": "Ember adapter for TanStack Hotkeys",
+  "author": "Tanner Linsley",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/hotkeys.git",
+    "directory": "packages/ember-hotkeys"
+  },
+  "homepage": "https://tanstack.com/hotkeys",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "keywords": [
+    "ember",
+    "tanstack",
+    "hotkeys"
+  ],
+  "scripts": {
+    "clean": "premove ./build ./dist ./dist-tests",
+    "lint": "eslint ./src",
+    "lint:fix": "eslint ./src --fix",
+    "test:eslint": "eslint ./src",
+    "test:lib": "vite build --mode=development --out-dir dist-tests && testem --file testem.cjs ci --port 0",
+    "test:lib:dev": "pnpm test:lib --watch",
+    "test:types": "ember-tsc --noEmit",
+    "build": "tsdown",
+    "test:build": "publint --strict && node ../../scripts/verify-package.ts"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json",
+    "./addon-main.js": "./addon-main.cjs"
+  },
+  "sideEffects": [
+    "./tests/**"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "addon-main.cjs"
+  ],
+  "dependencies": {
+    "@embroider/addon-shim": "^1.10.3",
+    "@tanstack/hotkeys": "workspace:*",
+    "@tanstack/store": "^0.11.2",
+    "ember-modifier": "4.2.2"
+  },
+  "devDependencies": {
+    "@babel/core": "7.29.7",
+    "@babel/plugin-transform-typescript": "7.29.9",
+    "@ember/app-tsconfig": "2.1.0",
+    "@ember/test-helpers": "^5.7.0",
+    "@embroider/core": "4.6.7",
+    "@embroider/macros": "1.21.1",
+    "@embroider/vite": "^1.7.13",
+    "@glimmer/component": "2.1.1",
+    "@glint/ember-tsc": "1.11.6",
+    "@glint/template": "1.9.0",
+    "@glint/tsserver-plugin": "2.7.9",
+    "@rollup/plugin-babel": "7.1.0",
+    "@types/qunit": "^2.19.14",
+    "babel-plugin-ember-template-compilation": "4.0.0",
+    "decorator-transforms": "2.4.0",
+    "ember-qunit": "^9.2.0",
+    "ember-source": "7.3.0",
+    "ember-strict-application-resolver": "0.1.1",
+    "qunit": "^3.0.0",
+    "qunit-dom": "^3.6.0",
+    "testem": "^3.21.3",
+    "vite": "^8.3.2"
+  },
+  "peerDependencies": {
+    "ember-source": ">=6.8.0"
+  },
+  "ember-addon": {
+    "version": 2,
+    "type": "addon",
+    "main": "addon-main.cjs"
+  },
+  "nx": {
+    "targets": {
+      "test:lib": {
+        "dependsOn": [
+          "build",
+          "^build"
+        ]
+      }
+    }
+  }
+}