@tanstack/alpine-hotkeys 0.2.0 → 0.3.1

package/dist/createAppHotkeys.js

@@ -0,0 +1,33 @@
+import { createHotkeyRegistrations } from "./createHotkeyRegistrations.js";
+
+//#region src/createAppHotkeys.ts
+function requireStore(scope) {
+	const store = scope.appHotkeys();
+	if (!store) throw new Error("App hotkeys require provideAppHotkeys()");
+	return store;
+}
+function createAppHotkeys(scope) {
+	return { get value() {
+		return requireStore(scope).appHotkeys;
+	} };
+}
+function createAppHotkeyList(scope) {
+	const registrations = createHotkeyRegistrations(scope);
+	return { get value() {
+		return requireStore(scope).getList(registrations.hotkeys);
+	} };
+}
+function createCustomHotkeys(scope) {
+	return {
+		get value() {
+			return requireStore(scope).customHotkeys;
+		},
+		setCustomHotkey: (id, hotkey) => requireStore(scope).setCustomHotkey(id, hotkey),
+		resetCustomHotkey: (id) => requireStore(scope).resetCustomHotkey(id),
+		resetCustomHotkeys: () => requireStore(scope).resetCustomHotkeys(),
+		findConflicts: (id, hotkey) => requireStore(scope).findConflicts(id, hotkey)
+	};
+}
+
+//#endregion
+export { createAppHotkeyList, createAppHotkeys, createCustomHotkeys };

package/dist/createHotkey.js

@@ -5,8 +5,9 @@ import { createHotkeys } from "./createHotkeys.js";
 function createHotkey(scope, hotkey, callback, options = {}) {
 	createHotkeys(scope, () => [{
 		hotkey: read(hotkey),
-		callback
-	}], options);
+		callback,
+		options: read(options)
+	}]);
 }
 
 //#endregion

package/dist/createHotkeyHint.js

@@ -1,9 +1,13 @@
 import { read } from "./scope.js";
-import { getKeyStateTracker, matchesHeldModifiers } from "@tanstack/hotkeys";
+import { getKeyStateTracker, isAppHotkey, matchesHeldModifiers, resolveAppHotkey } from "@tanstack/hotkeys";
 
 //#region src/createHotkeyHint.ts
 function createHotkeyHint(scope, hotkey, options = {}) {
-	return scope.select(getKeyStateTracker().store, (state) => matchesHeldModifiers(read(hotkey), state.heldKeys, read(options)));
+	return scope.select(getKeyStateTracker().store, (state) => {
+		const value = read(hotkey);
+		const resolved = isAppHotkey(value) ? resolveAppHotkey(value, scope.appHotkeys()).hotkey : value;
+		return resolved !== null && matchesHeldModifiers(resolved, state.heldKeys, read(options));
+	});
 }
 
 //#endregion

package/dist/createHotkeyRecorder.js

@@ -14,6 +14,9 @@ function createHotkeyRecorder(scope, options) {
 		get isRecording() {
 			return state.value.isRecording;
 		},
+		get steps() {
+			return state.value.steps;
+		},
 		get recordedHotkey() {
 			return state.value.recordedHotkey;
 		},
@@ -21,7 +24,8 @@ function createHotkeyRecorder(scope, options) {
 			if (!scope.destroyed) instance.start();
 		},
 		stopRecording: () => instance.stop(),
-		cancelRecording: () => instance.cancel()
+		cancelRecording: () => instance.cancel(),
+		commitRecording: () => instance.commit()
 	};
 }
 

package/dist/createHotkeyRegistrations.js

@@ -1,17 +1,11 @@
-import { getHotkeyManager, getSequenceManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
+import { getHotkeyManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
 
 //#region src/createHotkeyRegistrations.ts
 function createHotkeyRegistrations(scope) {
-	const hotkeyState = scope.select(getHotkeyManager().registrations, (state) => Array.from(state.values()).map(toHotkeyRegistrationView));
-	const sequenceState = scope.select(getSequenceManager().registrations, (state) => Array.from(state.values()));
-	return {
-		get hotkeys() {
-			return hotkeyState.value;
-		},
-		get sequences() {
-			return sequenceState.value;
-		}
-	};
+	const state = scope.select(getHotkeyManager().registrations, (value) => Array.from(value.values()).map(toHotkeyRegistrationView));
+	return { get hotkeys() {
+		return state.value;
+	} };
 }
 
 //#endregion

package/dist/createHotkeys.js

@@ -1,15 +1,17 @@
 import { read } from "./scope.js";
-import { createHotkeyBindings } from "@tanstack/hotkeys/adapter";
+import { createHotkeyBindings, prepareHotkeyDefinitions } from "@tanstack/hotkeys/adapter";
 
 //#region src/createHotkeys.ts
 function createHotkeys(scope, definitions, options = {}) {
 	scope.assertActive();
 	const bindings = createHotkeyBindings();
 	scope.addCleanup(bindings.destroy);
-	scope.effect(() => bindings.update(read(definitions), {
-		...scope.defaultOptions().hotkey,
-		...read(options)
-	}));
+	scope.effect(() => bindings.update(prepareHotkeyDefinitions(read(definitions), {
+		appHotkeysStore: scope.appHotkeys(),
+		defaults: scope.defaultOptions().hotkey,
+		commonOptions: read(options),
+		resolveTarget: (target) => target
+	})));
 }
 
 //#endregion

package/dist/createHotkeysScope.d.ts

@@ -1,6 +1,10 @@
 import { AlpineHotkeys, DefaultHotkeysOptions, MaybeGetter } from "./types.js";
 //#region src/createHotkeysScope.d.ts
-/** Owns Alpine effects and Store subscriptions, with optional shared defaults. Call destroy from x-data's destroy hook. */
+/**
+ * Owns Alpine effects and Store subscriptions, with optional shared defaults.
+ * App hotkeys come from `provideAppHotkeys`. Call destroy from x-data's
+ * destroy hook.
+ */
 export declare function createHotkeysScope(defaultOptions?: MaybeGetter<DefaultHotkeysOptions>): AlpineHotkeys;
 //#endregion
 export type { AlpineHotkeys, DefaultHotkeysOptions, MaybeGetter };

package/dist/createHotkeysScope.js

@@ -1,32 +1,34 @@
 import { createScope } from "./scope.js";
 import { createHotkeys } from "./createHotkeys.js";
 import { createHotkey } from "./createHotkey.js";
-import { createHotkeySequences } from "./createHotkeySequences.js";
-import { createHotkeySequence } from "./createHotkeySequence.js";
 import { createHeldKeys } from "./createHeldKeys.js";
 import { createHeldKeyCodes } from "./createHeldKeyCodes.js";
 import { createKeyHold } from "./createKeyHold.js";
 import { createHotkeyHint } from "./createHotkeyHint.js";
 import { createHotkeyRegistrations } from "./createHotkeyRegistrations.js";
 import { createHotkeyRecorder } from "./createHotkeyRecorder.js";
-import { createHotkeySequenceRecorder } from "./createHotkeySequenceRecorder.js";
+import { createAppHotkeyList, createAppHotkeys, createCustomHotkeys } from "./createAppHotkeys.js";
 
 //#region src/createHotkeysScope.ts
-/** Owns Alpine effects and Store subscriptions, with optional shared defaults. Call destroy from x-data's destroy hook. */
+/**
+* Owns Alpine effects and Store subscriptions, with optional shared defaults.
+* App hotkeys come from `provideAppHotkeys`. Call destroy from x-data's
+* destroy hook.
+*/
 function createHotkeysScope(defaultOptions = {}) {
 	const scope = createScope(defaultOptions);
 	return {
 		createHotkey: (...args) => createHotkey(scope, ...args),
 		createHotkeys: (...args) => createHotkeys(scope, ...args),
-		createHotkeySequence: (...args) => createHotkeySequence(scope, ...args),
-		createHotkeySequences: (...args) => createHotkeySequences(scope, ...args),
 		createHeldKeys: (...args) => createHeldKeys(scope, ...args),
 		createHeldKeyCodes: (...args) => createHeldKeyCodes(scope, ...args),
 		createKeyHold: (...args) => createKeyHold(scope, ...args),
 		createHotkeyHint: (...args) => createHotkeyHint(scope, ...args),
 		createHotkeyRegistrations: (...args) => createHotkeyRegistrations(scope, ...args),
-		createHotkeyRecorder: (...args) => createHotkeyRecorder(scope, ...args),
-		createHotkeySequenceRecorder: (...args) => createHotkeySequenceRecorder(scope, ...args),
+		createHotkeyRecorder: ((options) => createHotkeyRecorder(scope, options)),
+		createAppHotkeys: () => createAppHotkeys(scope),
+		createAppHotkeyList: () => createAppHotkeyList(scope),
+		createCustomHotkeys: () => createCustomHotkeys(scope),
 		destroy: scope.destroy
 	};
 }

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-import { AlpineHotkeyRecorder, AlpineHotkeySequenceRecorder, AlpineHotkeyState, AlpineHotkeys, DefaultHotkeysOptions, HotkeyRegistrationsResult, MaybeGetter } from "./types.js";
+import { AlpineAppHotkeyOptions, AlpineCreateHotkey, AlpineCreateHotkeyRecorder, AlpineCustomHotkeys, AlpineHotkeyCommonOptions, AlpineHotkeyDefinition, AlpineHotkeyOptionsFor, AlpineHotkeyRecorder, AlpineHotkeyState, AlpineHotkeyTarget, AlpineHotkeys, DefaultHotkeysOptions, HotkeyRegistrationsResult, MaybeGetter } from "./types.js";
 import { createHotkeysScope } from "./createHotkeysScope.js";
 import { hotkeysPlugin } from "./hotkeysPlugin.js";
-import { HotkeyDefinition, HotkeySequenceDefinition } from "@tanstack/hotkeys/adapter";
 export * from "@tanstack/hotkeys";
-export { AlpineHotkeyRecorder, AlpineHotkeySequenceRecorder, AlpineHotkeyState, AlpineHotkeys, DefaultHotkeysOptions, type HotkeyDefinition, HotkeyRegistrationsResult, type HotkeySequenceDefinition, MaybeGetter, createHotkeysScope, hotkeysPlugin };
+export { AlpineAppHotkeyOptions, AlpineCreateHotkey, AlpineCreateHotkeyRecorder, AlpineCustomHotkeys, AlpineHotkeyCommonOptions, AlpineHotkeyDefinition, AlpineHotkeyOptionsFor, AlpineHotkeyRecorder, AlpineHotkeyState, AlpineHotkeyTarget, AlpineHotkeys, DefaultHotkeysOptions, HotkeyRegistrationsResult, MaybeGetter, createHotkeysScope, hotkeysPlugin };

package/dist/scope.js

@@ -1,4 +1,6 @@
+import { getHotkeyManager } from "@tanstack/hotkeys";
 import Alpine from "alpinejs";
+import { subscribePublishedAppHotkeys } from "@tanstack/hotkeys/adapter";
 
 //#region src/scope.ts
 function read(value) {
@@ -28,10 +30,25 @@ function createScope(defaultOptions) {
 			return selector(state.snapshot);
 		} };
 	}
+	let appHotkeysState;
+	/**
+	* Returns the store published by `provideAppHotkeys`. Reading it inside an
+	* effect or reactive getter tracks app hotkey and custom hotkey changes.
+	*/
+	function appHotkeys() {
+		if (!appHotkeysState) {
+			const state = Alpine.reactive({ version: 0 });
+			appHotkeysState = state;
+			cleanups.add(subscribePublishedAppHotkeys(() => state.version++));
+		}
+		appHotkeysState.version;
+		return getHotkeyManager().appHotkeys.state;
+	}
 	return {
 		assertActive,
 		effect,
 		select,
+		appHotkeys,
 		defaultOptions: () => read(defaultOptions),
 		addCleanup: (cleanup) => cleanups.add(cleanup),
 		get destroyed() {

package/dist/types.d.ts

@@ -1,79 +1,108 @@
-import { HeldModifierOptions, Hotkey, HotkeyCallback, HotkeyOptions, HotkeyRecorderOptions, HotkeyRegistrationView, HotkeySequence, HotkeySequenceRecorderOptions, IndividualKey, RegisterableHotkey, SequenceOptions, SequenceRegistrationView } from "@tanstack/hotkeys";
-import { HotkeyDefinition, HotkeySequenceDefinition } from "@tanstack/hotkeys/adapter";
+import { AppHotkey, AppHotkeyListItem, CustomHotkeys, HeldModifierOptions, Hotkey, HotkeyCallback, HotkeyChord, HotkeyChordRecorderOptions, HotkeyRecorderOptions, HotkeyRegistrationView, HotkeySequence, HotkeySequenceRecorderOptions, IndividualKey, RegisterableHotkey, RegisteredAppHotkeys, Target } from "@tanstack/hotkeys";
+import { AdapterAppHotkeyOptions, AdapterCommonOptions, AdapterHotkeyDefinition, AdapterOptionsFor } from "@tanstack/hotkeys/adapter";
 //#region src/types.d.ts
 /** A reactive value. Read `.value` where the framework tracks dependencies. */
 export interface AlpineHotkeyState<T> {
   readonly value: T;
 }
+/** The element to listen on. A `null` target skips registration until it is set. */
+export type AlpineHotkeyTarget = Target | null;
+/** One hotkey for `createHotkeys`: a chord, a sequence, or an app hotkey. */
+export type AlpineHotkeyDefinition = AdapterHotkeyDefinition<AlpineHotkeyTarget>;
+/** Options for every kind; each applies to the kinds that support it. */
+export type AlpineHotkeyCommonOptions = AdapterCommonOptions<AlpineHotkeyTarget>;
+/** The options type for a hotkey: chord options for chords, sequence options for sequences. */
+export type AlpineHotkeyOptionsFor<T extends RegisterableHotkey> = AdapterOptionsFor<T, AlpineHotkeyTarget>;
+/** Call-site options for an app hotkey, typed by its declared default kind. */
+export type AlpineAppHotkeyOptions<T extends AppHotkey = AppHotkey> = AdapterAppHotkeyOptions<T, AlpineHotkeyTarget>;
 /** Recording state and controls owned by the containing scope. */
-export interface AlpineHotkeyRecorder {
+export interface AlpineHotkeyRecorder<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 AlpineHotkeySequenceRecorder {
-  /** 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>;
+}
+/** Custom hotkey state and actions. */
+export interface AlpineCustomHotkeys {
+  /** 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>;
 }
 /** A value or a getter evaluated within an Alpine effect or reactive read. */
 export type MaybeGetter<T> = T | (() => T);
+/** Registers a hotkey: a chord, a sequence, or an app hotkey. */
+export interface AlpineCreateHotkey {
+  <T extends AppHotkey>(hotkey: MaybeGetter<T>, callback: HotkeyCallback, options?: MaybeGetter<AlpineAppHotkeyOptions<T>>): void;
+  <T extends RegisterableHotkey>(hotkey: MaybeGetter<T>, callback: HotkeyCallback, options?: MaybeGetter<AlpineHotkeyOptionsFor<T>>): void;
+}
+/** Creates a recorder; `maxSteps` (default 1) selects chords or sequences. */
+export interface AlpineCreateHotkeyRecorder {
+  (options: HotkeyChordRecorderOptions): AlpineHotkeyRecorder<HotkeyChord>;
+  (options: HotkeySequenceRecorderOptions): AlpineHotkeyRecorder;
+  (options: () => HotkeySequenceRecorderOptions): AlpineHotkeyRecorder;
+  (options: () => HotkeyChordRecorderOptions): AlpineHotkeyRecorder<HotkeyChord>;
+  (options: () => HotkeyRecorderOptions): AlpineHotkeyRecorder;
+}
 /** Registrations, recorders, and reactive state owned by one Alpine component. */
 export interface AlpineHotkeys {
-  /** Register one shortcut. Getters track changing bindings and options. */
-  createHotkey: (hotkey: MaybeGetter<RegisterableHotkey>, callback: HotkeyCallback, options?: MaybeGetter<HotkeyOptions>) => void;
-  /** Reconcile a list of shortcuts. Definition options override common options. */
-  createHotkeys: (definitions: MaybeGetter<Array<HotkeyDefinition>>, options?: MaybeGetter<HotkeyOptions>) => void;
-  /** Register consecutive chords with an optional timeout and element target. */
-  createHotkeySequence: (sequence: MaybeGetter<HotkeySequence>, callback: HotkeyCallback, options?: MaybeGetter<SequenceOptions>) => void;
-  /** Reconcile a changing list of sequences. */
-  createHotkeySequences: (definitions: MaybeGetter<Array<HotkeySequenceDefinition>>, options?: MaybeGetter<SequenceOptions>) => void;
+  /**
+   * Register one hotkey: a chord such as `'Mod+S'`, a sequence such as
+   * `['G', 'G']`, or an app hotkey. Getters track changing hotkeys and options.
+   */
+  createHotkey: AlpineCreateHotkey;
+  /** Reconcile a list of hotkeys. Definition options override common options. */
+  createHotkeys: (definitions: MaybeGetter<ReadonlyArray<AlpineHotkeyDefinition>>, options?: MaybeGetter<AlpineHotkeyCommonOptions>) => void;
   /** Read held logical key names through `.value`. */
   createHeldKeys: () => AlpineHotkeyState<Array<string>>;
   /** Read the mapping of held logical names to physical codes through `.value`. */
   createHeldKeyCodes: () => AlpineHotkeyState<Record<string, string>>;
   /** Read whether a key is held through `.value`. */
   createKeyHold: (key: MaybeGetter<IndividualKey>) => AlpineHotkeyState<boolean>;
-  /** Read whether held modifiers reveal a binding through `.value`. */
-  createHotkeyHint: (hotkey: MaybeGetter<RegisterableHotkey>, options?: MaybeGetter<HeldModifierOptions>) => AlpineHotkeyState<boolean>;
-  /** Read live hotkey and sequence registrations, including disabled entries. */
+  /** Read whether held modifiers reveal a hotkey through `.value`. */
+  createHotkeyHint: (hotkey: MaybeGetter<RegisterableHotkey | AppHotkey>, options?: MaybeGetter<HeldModifierOptions>) => AlpineHotkeyState<boolean>;
+  /** Read live registrations, including disabled entries. */
   createHotkeyRegistrations: () => HotkeyRegistrationsResult;
   /** Create a recorder whose options can follow Alpine state. */
-  createHotkeyRecorder: (options: MaybeGetter<HotkeyRecorderOptions>) => AlpineHotkeyRecorder;
-  /** Create a sequence recorder with live steps and explicit commit controls. */
-  createHotkeySequenceRecorder: (options: MaybeGetter<HotkeySequenceRecorderOptions>) => AlpineHotkeySequenceRecorder;
+  createHotkeyRecorder: AlpineCreateHotkeyRecorder;
+  /** Read the effective app hotkeys from `provideAppHotkeys` through `.value`. */
+  createAppHotkeys: () => AlpineHotkeyState<RegisteredAppHotkeys>;
+  /** Read every app hotkey with its live status through `.value`. */
+  createAppHotkeyList: () => AlpineHotkeyState<Array<AppHotkeyListItem<RegisteredAppHotkeys[keyof RegisteredAppHotkeys]>>>;
+  /** Read and change the user's custom hotkeys. */
+  createCustomHotkeys: () => AlpineCustomHotkeys;
   /** Release every registration, subscription, effect, and recorder. Idempotent. */
   destroy: () => void;
 }
 /** 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?: AlpineHotkeyCommonOptions;
+  /** Defaults for every recorder. */
+  hotkeyRecorder?: Partial<Omit<HotkeyChordRecorderOptions & HotkeySequenceRecorderOptions, 'maxSteps' | 'onRecord' | 'validate'>>;
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/alpine-hotkeys",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Alpine adapter for TanStack Hotkeys",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "dist"
   ],
   "dependencies": {
-    "@tanstack/hotkeys": "0.11.0",
+    "@tanstack/hotkeys": "0.12.1",
     "@tanstack/store": "^0.11.2"
   },
   "devDependencies": {

package/dist/createHotkeySequence.js

@@ -1,13 +0,0 @@
-import { read } from "./scope.js";
-import { createHotkeySequences } from "./createHotkeySequences.js";
-
-//#region src/createHotkeySequence.ts
-function createHotkeySequence(scope, sequence, callback, options = {}) {
-	createHotkeySequences(scope, () => [{
-		sequence: read(sequence),
-		callback
-	}], options);
-}
-
-//#endregion
-export { createHotkeySequence };

package/dist/createHotkeySequenceRecorder.js

@@ -1,33 +0,0 @@
-import { read } from "./scope.js";
-import { HotkeySequenceRecorder } from "@tanstack/hotkeys";
-
-//#region src/createHotkeySequenceRecorder.ts
-function createHotkeySequenceRecorder(scope, options) {
-	scope.assertActive();
-	const instance = new HotkeySequenceRecorder(() => ({
-		...scope.defaultOptions().hotkeySequenceRecorder,
-		...read(options)
-	}));
-	const state = scope.select(instance.store, (value) => value);
-	scope.addCleanup(() => instance.destroy());
-	return {
-		get isRecording() {
-			return state.value.isRecording;
-		},
-		get steps() {
-			return state.value.steps;
-		},
-		get recordedSequence() {
-			return state.value.recordedSequence;
-		},
-		startRecording: () => {
-			if (!scope.destroyed) instance.start();
-		},
-		stopRecording: () => instance.stop(),
-		cancelRecording: () => instance.cancel(),
-		commitRecording: () => instance.commit()
-	};
-}
-
-//#endregion
-export { createHotkeySequenceRecorder };

package/dist/createHotkeySequences.js

@@ -1,16 +0,0 @@
-import { read } from "./scope.js";
-import { createHotkeySequenceBindings } from "@tanstack/hotkeys/adapter";
-
-//#region src/createHotkeySequences.ts
-function createHotkeySequences(scope, definitions, options = {}) {
-	scope.assertActive();
-	const bindings = createHotkeySequenceBindings();
-	scope.addCleanup(bindings.destroy);
-	scope.effect(() => bindings.update(read(definitions), {
-		...scope.defaultOptions().hotkeySequence,
-		...read(options)
-	}));
-}
-
-//#endregion
-export { createHotkeySequences };