@tanstack/ember-hotkeys 0.2.0 → 0.3.1

package/dist/bindings.js

@@ -0,0 +1,56 @@
+import { getHotkeyManager, isAppHotkey, isHotkeySequence } from "@tanstack/hotkeys";
+import { isDestroyed, isDestroying, registerDestructor } from "@ember/destroyable";
+import { scheduleOnce } from "@ember/runloop";
+import { createHotkeyBindings, prepareHotkeyDefinitions, subscribePublishedAppHotkeys } from "@tanstack/hotkeys/adapter";
+
+//#region src/bindings.ts
+/** Copies a hotkey so tracked getters are read while Ember tracks the caller. */
+function copyHotkey(hotkey) {
+	if (typeof hotkey === "string" || isAppHotkey(hotkey)) return hotkey;
+	if (isHotkeySequence(hotkey)) return [...hotkey];
+	return { ...hotkey };
+}
+/**
+* Registrations owned by a helper or modifier. `set` records the latest
+* definitions while Ember tracks the caller; registration changes publish
+* after rendering, and again when app hotkeys or custom hotkeys change.
+*/
+function createOwnedBindings(owner) {
+	const bindings = createHotkeyBindings();
+	const state = {
+		definitions: [],
+		commonOptions: {},
+		element: void 0
+	};
+	function update() {
+		if (isDestroying(owner) || isDestroyed(owner)) return;
+		const { definitions, commonOptions, element } = state;
+		bindings.update(prepareHotkeyDefinitions(definitions, {
+			appHotkeysStore: getHotkeyManager().appHotkeys.state,
+			commonOptions: element ? {
+				...commonOptions,
+				target: element
+			} : commonOptions,
+			resolveTarget: element ? () => element : (target) => target
+		}));
+	}
+	const schedule = () => scheduleOnce("afterRender", state, update);
+	const unsubscribe = subscribePublishedAppHotkeys(schedule);
+	registerDestructor(owner, () => {
+		unsubscribe();
+		bindings.destroy();
+	});
+	return { set(definitions, commonOptions, element) {
+		state.definitions = definitions.map((definition) => ({
+			...definition,
+			hotkey: copyHotkey(definition.hotkey),
+			options: { ...definition.options }
+		}));
+		state.commonOptions = { ...commonOptions };
+		state.element = element;
+		schedule();
+	} };
+}
+
+//#endregion
+export { createOwnedBindings };

package/dist/createHotkeysScope.d.ts

@@ -1,11 +1,8 @@
+import { DefaultHotkeysOptions } from "./types.js";
 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
@@ -15,10 +12,7 @@ export interface EmberHotkeysScope {
   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.

package/dist/createHotkeysScope.js

@@ -1,10 +1,7 @@
 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";
 
@@ -47,30 +44,10 @@ function createHotkeysScope(defaultOptions = {}) {
 				});
 			}
 		},
-		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, () => ({
+		useHotkeyRecorder: ((owner, options) => useHotkeyRecorder(owner, () => ({
 			...read(defaultOptions).hotkeyRecorder,
 			...read(options)
-		})),
-		useHotkeySequenceRecorder: (owner, options) => useHotkeySequenceRecorder(owner, () => ({
-			...read(defaultOptions).hotkeySequenceRecorder,
-			...read(options)
-		}))
+		})))
 	};
 }
 

package/dist/index.d.ts

@@ -1,19 +1,16 @@
+import { DefaultHotkeysOptions, EmberAppHotkeyList, EmberCustomHotkeys, EmberHotkeyCommonOptions, EmberHotkeyDefinition, EmberHotkeyRecorder, EmberHotkeyState, EmberHotkeyTarget, HotkeyRegistrationsResult } from "./types.js";
 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 { useAppHotkeyList, useAppHotkeys, useCustomHotkeys } from "./useAppHotkeys.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 };
+export { DefaultHotkeysOptions, type ElementHotkeyOptions, EmberAppHotkeyList, EmberCustomHotkeys, EmberHotkeyCommonOptions, EmberHotkeyDefinition, EmberHotkeyRecorder, EmberHotkeyState, EmberHotkeyTarget, EmberHotkeysScope, HotkeyRegistrationsResult, type MaybeGetter, createHotkeysScope, OnHotkey as onHotkey, OnHotkeys as onHotkeys, useAppHotkeyList, useAppHotkeys, useCustomHotkeys, useHeldKeyCodes, useHeldKeys, UseHotkey as useHotkey, useHotkeyHint, useHotkeyRecorder, useHotkeyRegistrations, UseHotkeys as useHotkeys, useKeyHold };

package/dist/index.js

@@ -1,18 +1,16 @@
 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 { useAppHotkeyList, useAppHotkeys, useCustomHotkeys } from "./useAppHotkeys.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 };
+export { createHotkeysScope, OnHotkey as onHotkey, OnHotkeys as onHotkeys, useAppHotkeyList, useAppHotkeys, useCustomHotkeys, useHeldKeyCodes, useHeldKeys, UseHotkey as useHotkey, useHotkeyHint, useHotkeyRecorder, useHotkeyRegistrations, UseHotkeys as useHotkeys, useKeyHold };

package/dist/onHotkey.d.ts

@@ -1,19 +1,16 @@
 import { ElementHotkeyOptions } from "./onHotkeys.js";
-import { HotkeyCallback, RegisterableHotkey } from "@tanstack/hotkeys";
+import { AppHotkey, 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. */
+/** Attaches a hotkey (chord, sequence, or app hotkey) to the element that owns the modifier. */
 export declare class OnHotkey extends Modifier<{
   Element: HTMLElement;
   Args: {
-    Positional: [RegisterableHotkey, HotkeyCallback];
+    Positional: [RegisterableHotkey | AppHotkey, HotkeyCallback];
     Named: ElementHotkeyOptions;
   };
 }> {
   private bindings;
-  private definition;
-  private cleanup;
-  modify(element: HTMLElement, [hotkey, callback]: [RegisterableHotkey, HotkeyCallback], options: ElementHotkeyOptions): void;
-  private update;
+  modify(element: HTMLElement, [hotkey, callback]: [RegisterableHotkey | AppHotkey, HotkeyCallback], options: ElementHotkeyOptions): void;
 }
 //#endregion

package/dist/onHotkey.js

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

package/dist/onHotkeys.d.ts

@@ -1,22 +1,17 @@
-import { HotkeyOptions } from "@tanstack/hotkeys";
-import { HotkeyDefinition } from "@tanstack/hotkeys/adapter";
+import { EmberHotkeyCommonOptions, EmberHotkeyDefinition } from "./types.js";
 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 type ElementHotkeyOptions = Omit<EmberHotkeyCommonOptions, 'target'>;
+/** Attach a reactive list of hotkeys directly to an element. */
 export declare class OnHotkeys extends Modifier<{
   Element: HTMLElement;
   Args: {
-    Positional: [Array<HotkeyDefinition>];
+    Positional: [ReadonlyArray<EmberHotkeyDefinition>];
     Named: ElementHotkeyOptions;
   };
 }> {
   private bindings;
-  private definitions;
-  private options;
-  private cleanup;
-  modify(element: HTMLElement, [definitions]: [Array<HotkeyDefinition>], options: ElementHotkeyOptions): void;
-  private update;
+  modify(element: HTMLElement, [definitions]: [ReadonlyArray<EmberHotkeyDefinition>], options: ElementHotkeyOptions): void;
 }
 //#endregion

package/dist/onHotkeys.js

@@ -1,33 +1,12 @@
-import { isDestroyed, isDestroying, registerDestructor } from "@ember/destroyable";
-import { scheduleOnce } from "@ember/runloop";
-import { createHotkeyBindings } from "@tanstack/hotkeys/adapter";
+import { createOwnedBindings } from "./bindings.js";
 import Modifier from "ember-modifier";
 
 //#region src/onHotkeys.ts
-/** Attach a reactive list of shortcuts directly to an element. */
+/** Attach a reactive list of hotkeys directly to an element. */
 var OnHotkeys = class extends Modifier {
-	bindings = createHotkeyBindings();
-	definitions = [];
-	options = {};
-	cleanup = registerDestructor(this, () => this.bindings.destroy());
+	bindings = createOwnedBindings(this);
 	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);
+		this.bindings.set(definitions, options, element);
 	}
 };
 

package/dist/types.d.ts

@@ -1,49 +1,61 @@
-import { Hotkey, HotkeyOptions, HotkeyRecorderOptions, HotkeyRegistrationView, HotkeySequence, HotkeySequenceRecorderOptions, SequenceOptions, SequenceRegistrationView } from "@tanstack/hotkeys";
+import { AppHotkey, AppHotkeyListItem, CustomHotkeys, Hotkey, HotkeyChordRecorderOptions, HotkeyRegistrationView, HotkeySequence, HotkeySequenceRecorderOptions, RegisteredAppHotkeys, Target } from "@tanstack/hotkeys";
+import { AdapterCommonOptions, AdapterHotkeyDefinition } from "@tanstack/hotkeys/adapter";
 //#region src/types.d.ts
 /** A reactive value. Read `.value` where the framework tracks dependencies. */
 export interface EmberHotkeyState<T> {
   readonly value: T;
 }
+/** The element to listen on. A `null` target skips registration until it is set. */
+export type EmberHotkeyTarget = Target | null;
+/** One hotkey for `useHotkeys` and `onHotkeys`: a chord, a sequence, or an app hotkey. */
+export type EmberHotkeyDefinition = AdapterHotkeyDefinition<EmberHotkeyTarget>;
+/** Options for every kind; each applies to the kinds that support it. */
+export type EmberHotkeyCommonOptions = AdapterCommonOptions<EmberHotkeyTarget>;
 /** Recording state and controls owned by the containing component. */
-export interface EmberHotkeyRecorder {
+export interface EmberHotkeyRecorder<THotkey extends Hotkey = Hotkey> {
   /** Whether the recorder is listening for a shortcut. */
   readonly isRecording: boolean;
-  /** The last recorded binding, including brackets for physical codes. */
-  readonly recordedHotkey: Hotkey | null;
+  /** Chords captured so far in a multi-step recording. */
+  readonly steps: HotkeySequence;
+  /** The last committed hotkey, including brackets for physical codes. */
+  readonly recordedHotkey: THotkey | 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. */
+  /** Commit the current steps (multi-step recordings). */
   commitRecording: () => void;
 }
-/** Live registration views from the shared hotkey and sequence managers. */
+/** Live registration views from the shared hotkey manager. */
 export interface HotkeyRegistrationsResult {
+  /** Every registration, chords and sequences. Narrow each view with `kind`. */
   readonly hotkeys: Array<HotkeyRegistrationView>;
-  readonly sequences: Array<SequenceRegistrationView>;
+}
+/** Every app hotkey with its live status. */
+export type EmberAppHotkeyList = EmberHotkeyState<Array<AppHotkeyListItem<RegisteredAppHotkeys[keyof RegisteredAppHotkeys]>>>;
+/** Custom hotkey state and actions. */
+export interface EmberCustomHotkeys {
+  /** The user's hotkeys that differ from the defaults. */
+  readonly value: CustomHotkeys;
+  /**
+   * Sets the user's hotkey for an app hotkey. `null` unbinds it.
+   * Returns conflicting app hotkeys; when any exist, nothing changes.
+   */
+  setCustomHotkey: (id: keyof RegisteredAppHotkeys & string, hotkey: Hotkey | null) => Array<AppHotkey>;
+  /** Restores the default hotkey for an app hotkey. */
+  resetCustomHotkey: (id: keyof RegisteredAppHotkeys & string) => void;
+  /** Restores every default hotkey. */
+  resetCustomHotkeys: () => void;
+  /** Other app hotkeys that would collide if `id` used `hotkey`. */
+  findConflicts: (id: keyof RegisteredAppHotkeys & string, hotkey: Hotkey) => Array<AppHotkey>;
 }
 /** Shared defaults; call-specific options take precedence. */
 export interface DefaultHotkeysOptions {
-  hotkey?: HotkeyOptions;
-  hotkeySequence?: SequenceOptions;
-  hotkeyRecorder?: Partial<HotkeyRecorderOptions>;
-  hotkeySequenceRecorder?: Partial<HotkeySequenceRecorderOptions>;
+  /** Defaults for every hotkey. `requireReset` applies to chords and `timeout` to sequences. */
+  hotkey?: EmberHotkeyCommonOptions;
+  /** Defaults for every recorder. */
+  hotkeyRecorder?: Partial<Omit<HotkeyChordRecorderOptions & HotkeySequenceRecorderOptions, 'maxSteps' | 'onRecord' | 'validate'>>;
 }
 //#endregion

package/dist/useAppHotkeys.d.ts

@@ -0,0 +1,18 @@
+import { EmberAppHotkeyList, EmberCustomHotkeys, EmberHotkeyState } from "./types.js";
+import { RegisteredAppHotkeys } from "@tanstack/hotkeys";
+//#region src/useAppHotkeys.d.ts
+/** Reads the effective app hotkeys from `provideAppHotkeys`, typed by `Register`. */
+export declare function useAppHotkeys(owner: object): EmberHotkeyState<RegisteredAppHotkeys>;
+/**
+ * Lists every app hotkey with its live status, for cheat sheets and settings
+ * screens. App hotkeys whose components have not rendered are `'inactive'`;
+ * those without a hotkey are `'unbound'`.
+ */
+export declare function useAppHotkeyList(owner: object): EmberAppHotkeyList;
+/**
+ * Reads and changes the user's custom hotkeys. Changes apply to every
+ * registered app hotkey immediately and are passed to
+ * `onCustomHotkeysChange`, ready to save.
+ */
+export declare function useCustomHotkeys(owner: object): EmberCustomHotkeys;
+//#endregion

package/dist/useAppHotkeys.js

@@ -0,0 +1,48 @@
+import { trackPublishedAppHotkeys } from "./utils.js";
+import { useHotkeyRegistrations } from "./useHotkeyRegistrations.js";
+
+//#region src/useAppHotkeys.ts
+function requireStore(store) {
+	const current = store();
+	if (!current) throw new Error("App hotkeys require provideAppHotkeys()");
+	return current;
+}
+/** Reads the effective app hotkeys from `provideAppHotkeys`, typed by `Register`. */
+function useAppHotkeys(owner) {
+	const store = trackPublishedAppHotkeys(owner);
+	return { get value() {
+		return requireStore(store).appHotkeys;
+	} };
+}
+/**
+* Lists every app hotkey with its live status, for cheat sheets and settings
+* screens. App hotkeys whose components have not rendered are `'inactive'`;
+* those without a hotkey are `'unbound'`.
+*/
+function useAppHotkeyList(owner) {
+	const store = trackPublishedAppHotkeys(owner);
+	const registrations = useHotkeyRegistrations(owner);
+	return { get value() {
+		return requireStore(store).getList(registrations.hotkeys);
+	} };
+}
+/**
+* Reads and changes the user's custom hotkeys. Changes apply to every
+* registered app hotkey immediately and are passed to
+* `onCustomHotkeysChange`, ready to save.
+*/
+function useCustomHotkeys(owner) {
+	const store = trackPublishedAppHotkeys(owner);
+	return {
+		get value() {
+			return requireStore(store).customHotkeys;
+		},
+		setCustomHotkey: (id, hotkey) => requireStore(store).setCustomHotkey(id, hotkey),
+		resetCustomHotkey: (id) => requireStore(store).resetCustomHotkey(id),
+		resetCustomHotkeys: () => requireStore(store).resetCustomHotkeys(),
+		findConflicts: (id, hotkey) => requireStore(store).findConflicts(id, hotkey)
+	};
+}
+
+//#endregion
+export { useAppHotkeyList, useAppHotkeys, useCustomHotkeys };

package/dist/useHotkey.d.ts

@@ -1,18 +1,21 @@
-import { HotkeyCallback, HotkeyOptions, RegisterableHotkey } from "@tanstack/hotkeys";
+import { EmberHotkeyCommonOptions } from "./types.js";
+import { AppHotkey, HotkeyCallback, 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. */
+/**
+ * Registers a hotkey for the helper's template lifecycle: a chord such as
+ * `"Mod+S"`, a sequence such as `(array "G" "G")`, or an app hotkey.
+ *
+ * Use `{{useHotkey "Mod+S" this.save enabled=this.enabled}}` in a template.
+ */
 export declare class UseHotkey extends Helper<{
   Args: {
-    Positional: [RegisterableHotkey, HotkeyCallback];
-    Named: HotkeyOptions;
+    Positional: [RegisterableHotkey | AppHotkey, HotkeyCallback];
+    Named: EmberHotkeyCommonOptions;
   };
   Return: void;
 }> {
   private bindings;
-  private definition;
-  private cleanup;
-  compute([hotkey, callback]: [RegisterableHotkey, HotkeyCallback], options: HotkeyOptions): void;
-  private update;
+  compute([hotkey, callback]: [RegisterableHotkey | AppHotkey, HotkeyCallback], options: EmberHotkeyCommonOptions): void;
 }
 //#endregion

package/dist/useHotkey.js

@@ -1,25 +1,21 @@
+import { createOwnedBindings } from "./bindings.js";
 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. */
+/**
+* Registers a hotkey for the helper's template lifecycle: a chord such as
+* `"Mod+S"`, a sequence such as `(array "G" "G")`, or an app hotkey.
+*
+* 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());
+	bindings = createOwnedBindings(this);
 	compute([hotkey, callback], options) {
-		this.cleanup;
-		this.definition = {
-			hotkey: typeof hotkey === "string" ? hotkey : { ...hotkey },
+		this.bindings.set([{
+			hotkey,
 			callback,
-			options: { ...options }
-		};
-		scheduleOnce("afterRender", this, this.update);
-	}
-	update() {
-		if (this.definition && !isDestroying(this) && !isDestroyed(this)) this.bindings.update([this.definition]);
+			options
+		}], {});
 	}
 };
 

package/dist/useHotkeyHint.d.ts

@@ -1,7 +1,11 @@
-import { MaybeGetter } from "./utils.js";
 import { EmberHotkeyState } from "./types.js";
-import { HeldModifierOptions, RegisterableHotkey } from "@tanstack/hotkeys";
+import { MaybeGetter } from "./utils.js";
+import { AppHotkey, 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>;
+/**
+ * Recomputes for held modifiers and tracked changes to the hotkey or options.
+ * A sequence reveals its hint from its first step, and an app hotkey uses its
+ * effective hotkey (false while unbound).
+ */
+export declare function useHotkeyHint(owner: object, hotkey: MaybeGetter<RegisterableHotkey | AppHotkey>, options?: MaybeGetter<HeldModifierOptions>): EmberHotkeyState<boolean>;
 //#endregion

package/dist/useHotkeyHint.js

@@ -1,10 +1,19 @@
-import { read, select } from "./utils.js";
-import { getKeyStateTracker, matchesHeldModifiers } from "@tanstack/hotkeys";
+import { read, select, trackPublishedAppHotkeys } from "./utils.js";
+import { getKeyStateTracker, isAppHotkey, matchesHeldModifiers, resolveAppHotkey } from "@tanstack/hotkeys";
 
 //#region src/useHotkeyHint.ts
-/** Recomputes for held modifiers and tracked changes to the binding or options. */
+/**
+* Recomputes for held modifiers and tracked changes to the hotkey or options.
+* A sequence reveals its hint from its first step, and an app hotkey uses its
+* effective hotkey (false while unbound).
+*/
 function useHotkeyHint(owner, hotkey, options = {}) {
-	return select(owner, getKeyStateTracker().store, (state) => matchesHeldModifiers(read(hotkey), state.heldKeys, read(options)));
+	const appHotkeys = trackPublishedAppHotkeys(owner);
+	return select(owner, getKeyStateTracker().store, (state) => {
+		const value = read(hotkey);
+		const resolved = isAppHotkey(value) ? resolveAppHotkey(value, appHotkeys()).hotkey : value;
+		return resolved !== null && matchesHeldModifiers(resolved, state.heldKeys, read(options));
+	});
 }
 
 //#endregion

package/dist/useHotkeyRecorder.d.ts

@@ -1,7 +1,16 @@
-import { MaybeGetter } from "./utils.js";
 import { EmberHotkeyRecorder } from "./types.js";
-import { HotkeyRecorderOptions } from "@tanstack/hotkeys";
+import { HotkeyChord, HotkeyChordRecorderOptions, HotkeyRecorderOptions, HotkeySequenceRecorderOptions } 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;
+/**
+ * Creates an owned recorder with autotracked state and current callback
+ * options. With the default `maxSteps: 1`, the first valid chord is recorded.
+ * With a larger `maxSteps`, each chord adds a step; the recording commits on
+ * Enter (unless `commitKeys: 'none'`), after `idleTimeoutMs`, or at
+ * `maxSteps`, and `onRecord` receives a chord (one step) or a sequence.
+ */
+export declare function useHotkeyRecorder(owner: object, options: HotkeyChordRecorderOptions): EmberHotkeyRecorder<HotkeyChord>;
+export declare function useHotkeyRecorder(owner: object, options: HotkeySequenceRecorderOptions): EmberHotkeyRecorder;
+export declare function useHotkeyRecorder(owner: object, options: () => HotkeySequenceRecorderOptions): EmberHotkeyRecorder;
+export declare function useHotkeyRecorder(owner: object, options: () => HotkeyChordRecorderOptions): EmberHotkeyRecorder<HotkeyChord>;
+export declare function useHotkeyRecorder(owner: object, options: () => HotkeyRecorderOptions): EmberHotkeyRecorder;
 //#endregion

package/dist/useHotkeyRecorder.js

@@ -3,7 +3,6 @@ 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);
@@ -12,6 +11,9 @@ function useHotkeyRecorder(owner, options) {
 		get isRecording() {
 			return state.value.isRecording;
 		},
+		get steps() {
+			return state.value.steps;
+		},
 		get recordedHotkey() {
 			return state.value.recordedHotkey;
 		},
@@ -20,7 +22,8 @@ function useHotkeyRecorder(owner, options) {
 			recorder.start();
 		},
 		stopRecording: () => recorder.stop(),
-		cancelRecording: () => recorder.cancel()
+		cancelRecording: () => recorder.cancel(),
+		commitRecording: () => recorder.commit()
 	};
 }
 

package/dist/useHotkeyRegistrations.d.ts

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

package/dist/useHotkeyRegistrations.js

@@ -1,19 +1,13 @@
 import { select } from "./utils.js";
-import { getHotkeyManager, getSequenceManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
+import { getHotkeyManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
 
 //#region src/useHotkeyRegistrations.ts
-/** Reads public snapshots of hotkey and sequence registrations. */
+/** Reads public snapshots of every registration, chords and sequences. */
 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;
-		}
-	};
+	return { get hotkeys() {
+		return hotkeys.value;
+	} };
 }
 
 //#endregion

package/dist/useHotkeys.d.ts

@@ -1,20 +1,15 @@
-import { HotkeyOptions } from "@tanstack/hotkeys";
+import { EmberHotkeyCommonOptions, EmberHotkeyDefinition } from "./types.js";
 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. */
+/** Registers a reactive list of hotkeys with the helper's template lifecycle. */
 export declare class UseHotkeys extends Helper<{
   Args: {
-    Positional: [Array<HotkeyDefinition>];
-    Named: HotkeyOptions;
+    Positional: [ReadonlyArray<EmberHotkeyDefinition>];
+    Named: EmberHotkeyCommonOptions;
   };
   Return: void;
 }> {
   private bindings;
-  private definitions;
-  private options;
-  private cleanup;
-  compute([definitions]: [Array<HotkeyDefinition>], options: HotkeyOptions): void;
-  private update;
+  compute([definitions]: [ReadonlyArray<EmberHotkeyDefinition>], options: EmberHotkeyCommonOptions): void;
 }
 //#endregion

package/dist/useHotkeys.js

@@ -1,27 +1,12 @@
+import { createOwnedBindings } from "./bindings.js";
 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. */
+/** Registers a reactive list of hotkeys with the helper's template lifecycle. */
 var UseHotkeys = class extends Helper {
-	bindings = createHotkeyBindings();
-	definitions = [];
-	options = {};
-	cleanup = registerDestructor(this, () => this.bindings.destroy());
+	bindings = createOwnedBindings(this);
 	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);
+		this.bindings.set(definitions, options);
 	}
 };
 

package/dist/useKeyHold.d.ts

@@ -1,5 +1,5 @@
-import { MaybeGetter } from "./utils.js";
 import { EmberHotkeyState } from "./types.js";
+import { MaybeGetter } from "./utils.js";
 import { IndividualKey } from "@tanstack/hotkeys";
 //#region src/useKeyHold.d.ts
 /** Getter arguments can read changing tracked component properties. */

package/dist/utils.d.ts

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

package/dist/utils.js

@@ -1,4 +1,6 @@
+import { getHotkeyManager } from "@tanstack/hotkeys";
 import { registerDestructor } from "@ember/destroyable";
+import { subscribePublishedAppHotkeys } from "@tanstack/hotkeys/adapter";
 import { trackedObject } from "@ember/reactive/collections";
 
 //#region src/utils.ts
@@ -15,6 +17,20 @@ function select(owner, store, selector) {
 		return selector(state.snapshot);
 	} };
 }
+/**
+* Returns the store published by `provideAppHotkeys`. Reading it tracks app
+* hotkey and custom hotkey changes for the owner's lifetime.
+*/
+function trackPublishedAppHotkeys(owner) {
+	const state = trackedObject({ version: 0 });
+	registerDestructor(owner, subscribePublishedAppHotkeys(() => {
+		state.version++;
+	}));
+	return () => {
+		state.version;
+		return getHotkeyManager().appHotkeys.state;
+	};
+}
 
 //#endregion
-export { read, select };
+export { read, select, trackPublishedAppHotkeys };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ember-hotkeys",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Ember adapter for TanStack Hotkeys",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -38,7 +38,7 @@
   ],
   "dependencies": {
     "@embroider/addon-shim": "^1.10.3",
-    "@tanstack/hotkeys": "0.11.0",
+    "@tanstack/hotkeys": "0.12.1",
     "@tanstack/store": "^0.11.2",
     "ember-modifier": "4.2.2"
   },

package/dist/useHotkeySequence.d.ts

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

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

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

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

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

@@ -1,29 +0,0 @@
-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 };