@tanstack/solid-hotkeys 0.12.1 → 0.14.0

package/dist/createHotkeyRecorder.js

@@ -1,76 +1,33 @@
-import { useDefaultHotkeysOptions } from "./HotkeysProvider.js";
+import { useDefaultHotkeysOptionsSource } from "./defaultOptions.js";
 import { HotkeyRecorder } from "@tanstack/hotkeys";
 import { createEffect, onCleanup } from "solid-js";
 import { useSelector } from "@tanstack/solid-store";
 
 //#region src/createHotkeyRecorder.ts
-/**
-* SolidJS primitive for recording keyboard shortcuts.
-*
-* This primitive provides a thin wrapper around the framework-agnostic `HotkeyRecorder`
-* class, managing all the complexity of capturing keyboard events, converting them
-* to hotkey strings, and handling edge cases like Escape to cancel or Backspace/Delete
-* to clear.
-*
-* This primitive uses `useSelector` from `@tanstack/solid-store` to subscribe
-* to the recorder's store state (same pattern as useHotkeyRecorder in React).
-*
-* @param options - Configuration options for the recorder (or accessor function)
-* @returns An object with recording state signals and control functions
-*
-* @example
-* ```tsx
-* function ShortcutSettings() {
-*   const [shortcut, setShortcut] = createSignal<Hotkey>('Mod+S')
-*
-*   const recorder = createHotkeyRecorder({
-*     onRecord: (hotkey) => {
-*       setShortcut(hotkey)
-*     },
-*     onCancel: () => {
-*       console.log('Recording cancelled')
-*     },
-*   })
-*
-*   return (
-*     <div>
-*       <button onClick={recorder.startRecording}>
-*         {recorder.isRecording() ? 'Recording...' : 'Edit Shortcut'}
-*       </button>
-*       <Show when={recorder.recordedHotkey()}>
-*         <div>Recording: {recorder.recordedHotkey()}</div>
-*       </Show>
-*     </div>
-*   )
-* }
-* ```
-*/
 function createHotkeyRecorder(options) {
-	const defaultOptions = useDefaultHotkeysOptions();
-	const resolvedOptions = typeof options === "function" ? options() : options;
-	const mergedOptions = {
-		...defaultOptions.hotkeyRecorder,
-		...resolvedOptions
-	};
-	const recorder = new HotkeyRecorder(mergedOptions);
+	const defaultOptions = useDefaultHotkeysOptionsSource();
+	const resolve = () => ({
+		...defaultOptions().hotkeyRecorder,
+		...typeof options === "function" ? options() : options
+	});
+	const recorder = new HotkeyRecorder(resolve());
 	const isRecording = useSelector(recorder.store, (state) => state.isRecording);
+	const steps = useSelector(recorder.store, (state) => state.steps);
 	const recordedHotkey = useSelector(recorder.store, (state) => state.recordedHotkey);
 	createEffect(() => {
-		const resolved = typeof options === "function" ? options() : options;
-		recorder.setOptions({
-			...defaultOptions.hotkeyRecorder,
-			...resolved
-		});
+		recorder.setOptions(resolve());
 	});
 	onCleanup(() => {
 		recorder.destroy();
 	});
 	return {
 		isRecording,
+		steps,
 		recordedHotkey,
 		startRecording: () => recorder.start(),
 		stopRecording: () => recorder.stop(),
-		cancelRecording: () => recorder.cancel()
+		cancelRecording: () => recorder.cancel(),
+		commitRecording: () => recorder.commit()
 	};
 }
 

package/dist/createHotkeyRegistrations.d.ts

@@ -1,23 +1,20 @@
-import { HotkeyRegistrationView, SequenceRegistrationView } from "@tanstack/hotkeys";
+import { HotkeyRegistrationView } from "@tanstack/hotkeys";
 //#region src/createHotkeyRegistrations.d.ts
 /**
- * Return type for createHotkeyRegistrations.
- */
-export interface HotkeyRegistrationsResult {
-  /** Accessor for all registered hotkeys (public view, no callbacks) */
-  hotkeys: () => Array<HotkeyRegistrationView>;
-  /** Accessor for all registered sequences */
-  sequences: () => Array<SequenceRegistrationView>;
-}
-/**
- * Solid primitive that reactively reads all hotkey and sequence registrations
- * from the singleton managers.
+ * Solid primitive that reactively reads every hotkey registration, chords and
+ * sequences, from the singleton HotkeyManager. Narrow each view with `kind`.
+ *
+ * This primitive does NOT require the HotkeysProvider.
  *
- * This is a standalone primitive that does NOT require the HotkeysProvider.
- * It subscribes to both HotkeyManager and SequenceManager stores and
- * triggers reactivity when registrations change.
+ * @returns An accessor for all registrations, without callbacks
  *
- * @returns Object with `hotkeys` and `sequences` signal accessors
+ * @example
+ * ```tsx
+ * const registrations = createHotkeyRegistrations()
+ * <For each={registrations()}>
+ *   {(reg) => <li>{reg.options.meta?.name}: {formatForDisplay(reg.hotkey)}</li>}
+ * </For>
+ * ```
  */
-export declare function createHotkeyRegistrations(): HotkeyRegistrationsResult;
+export declare function createHotkeyRegistrations(): () => Array<HotkeyRegistrationView>;
 //#endregion

package/dist/createHotkeyRegistrations.js

@@ -1,24 +1,25 @@
-import { getHotkeyManager, getSequenceManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
+import { getHotkeyManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
 import { useSelector } from "@tanstack/solid-store";
 
 //#region src/createHotkeyRegistrations.ts
 /**
-* Solid primitive that reactively reads all hotkey and sequence registrations
-* from the singleton managers.
+* Solid primitive that reactively reads every hotkey registration, chords and
+* sequences, from the singleton HotkeyManager. Narrow each view with `kind`.
 *
-* This is a standalone primitive that does NOT require the HotkeysProvider.
-* It subscribes to both HotkeyManager and SequenceManager stores and
-* triggers reactivity when registrations change.
+* This primitive does NOT require the HotkeysProvider.
 *
-* @returns Object with `hotkeys` and `sequences` signal accessors
+* @returns An accessor for all registrations, without callbacks
+*
+* @example
+* ```tsx
+* const registrations = createHotkeyRegistrations()
+* <For each={registrations()}>
+*   {(reg) => <li>{reg.options.meta?.name}: {formatForDisplay(reg.hotkey)}</li>}
+* </For>
+* ```
 */
 function createHotkeyRegistrations() {
-	const hotkeyManager = getHotkeyManager();
-	const sequenceManager = getSequenceManager();
-	return {
-		hotkeys: useSelector(hotkeyManager.registrations, (state) => Array.from(state.values()).map(toHotkeyRegistrationView)),
-		sequences: useSelector(sequenceManager.registrations, (state) => Array.from(state.values()))
-	};
+	return useSelector(getHotkeyManager().registrations, (state) => Array.from(state.values()).map(toHotkeyRegistrationView));
 }
 
 //#endregion

package/dist/createHotkeys.d.ts

@@ -1,54 +1,27 @@
-import { CreateHotkeyOptions } from "./createHotkey.js";
-import { HotkeyCallback, RegisterableHotkey } from "@tanstack/hotkeys";
+import { CreateHotkeyCommonOptions, CreateHotkeyTarget } from "./createHotkey.js";
+import { AdapterHotkeyDefinition } from "@tanstack/hotkeys/adapter";
 //#region src/createHotkeys.d.ts
 /**
- * A single hotkey definition for use with `createHotkeys`.
+ * One hotkey for `createHotkeys`. Chords accept `requireReset`; sequences
+ * accept `timeout`; hotkeys of unknown kind accept only shared options.
  */
-export interface CreateHotkeyDefinition {
-  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */
-  hotkey: RegisterableHotkey;
-  /** The function to call when the hotkey is pressed */
-  callback: HotkeyCallback;
-  /** Per-hotkey options (merged on top of commonOptions) */
-  options?: CreateHotkeyOptions;
-}
+export type CreateHotkeyDefinition = AdapterHotkeyDefinition<CreateHotkeyTarget>;
 /**
- * SolidJS primitive for registering multiple keyboard hotkeys at once.
+ * Solid primitive for registering several hotkeys at once: chords, sequences,
+ * and app hotkeys. Pass an accessor for a reactive list.
  *
- * Uses the singleton HotkeyManager for efficient event handling.
- * Accepts a dynamic array of hotkey definitions, making it safe to use
- * with variable-length lists.
- *
- * Options are merged in this order:
- * HotkeysProvider defaults < commonOptions < per-definition options
- *
- * @param hotkeys - Array of hotkey definitions, or accessor returning them
- * @param commonOptions - Shared options applied to all hotkeys, or accessor
- *
- * @example
- * ```tsx
- * function Editor() {
- *   createHotkeys([
- *     { hotkey: 'Mod+S', callback: () => save() },
- *     { hotkey: 'Mod+Z', callback: () => undo() },
- *     { hotkey: 'Escape', callback: () => close() },
- *   ])
- * }
- * ```
+ * Options merge in this order: provider defaults, app hotkey declaration,
+ * commonOptions, per-hotkey options. Each option applies only to the kinds
+ * that support it. Unbound app hotkeys and empty sequences register nothing.
+ * A `null` target skips registration until it is set.
  *
  * @example
  * ```tsx
- * function MenuShortcuts(props) {
- *   createHotkeys(
- *     () => props.items.map((item) => ({
- *       hotkey: item.shortcut,
- *       callback: item.action,
- *       options: { enabled: item.enabled },
- *     })),
- *     { preventDefault: true },
- *   )
- * }
+ * createHotkeys([
+ *   { hotkey: 'Mod+S', callback: () => save() },
+ *   { hotkey: ['G', 'G'], callback: () => scrollToTop(), options: { timeout: 500 } },
+ * ])
  * ```
  */
-export declare function createHotkeys(hotkeys: Array<CreateHotkeyDefinition> | (() => Array<CreateHotkeyDefinition>), commonOptions?: CreateHotkeyOptions | (() => CreateHotkeyOptions)): void;
+export declare function createHotkeys(hotkeys: ReadonlyArray<CreateHotkeyDefinition> | (() => ReadonlyArray<CreateHotkeyDefinition>), commonOptions?: CreateHotkeyCommonOptions | (() => CreateHotkeyCommonOptions)): void;
 //#endregion

package/dist/createHotkeys.js

@@ -1,109 +1,39 @@
-import { useDefaultHotkeysOptions } from "./HotkeysProvider.js";
-import { detectPlatform, getHotkeyManager, normalizeRegisterableHotkey } from "@tanstack/hotkeys";
+import { useAppHotkeysStoreSource, useDefaultHotkeysOptionsSource } from "./defaultOptions.js";
 import { createEffect, onCleanup, untrack } from "solid-js";
+import { createHotkeyBindings, prepareHotkeyDefinitions } from "@tanstack/hotkeys/adapter";
 
 //#region src/createHotkeys.ts
 /**
-* SolidJS primitive for registering multiple keyboard hotkeys at once.
+* Solid primitive for registering several hotkeys at once: chords, sequences,
+* and app hotkeys. Pass an accessor for a reactive list.
 *
-* Uses the singleton HotkeyManager for efficient event handling.
-* Accepts a dynamic array of hotkey definitions, making it safe to use
-* with variable-length lists.
-*
-* Options are merged in this order:
-* HotkeysProvider defaults < commonOptions < per-definition options
-*
-* @param hotkeys - Array of hotkey definitions, or accessor returning them
-* @param commonOptions - Shared options applied to all hotkeys, or accessor
+* Options merge in this order: provider defaults, app hotkey declaration,
+* commonOptions, per-hotkey options. Each option applies only to the kinds
+* that support it. Unbound app hotkeys and empty sequences register nothing.
+* A `null` target skips registration until it is set.
 *
 * @example
 * ```tsx
-* function Editor() {
-*   createHotkeys([
-*     { hotkey: 'Mod+S', callback: () => save() },
-*     { hotkey: 'Mod+Z', callback: () => undo() },
-*     { hotkey: 'Escape', callback: () => close() },
-*   ])
-* }
-* ```
-*
-* @example
-* ```tsx
-* function MenuShortcuts(props) {
-*   createHotkeys(
-*     () => props.items.map((item) => ({
-*       hotkey: item.shortcut,
-*       callback: item.action,
-*       options: { enabled: item.enabled },
-*     })),
-*     { preventDefault: true },
-*   )
-* }
+* createHotkeys([
+*   { hotkey: 'Mod+S', callback: () => save() },
+*   { hotkey: ['G', 'G'], callback: () => scrollToTop(), options: { timeout: 500 } },
+* ])
 * ```
 */
 function createHotkeys(hotkeys, commonOptions = {}) {
-	const defaultOptions = useDefaultHotkeysOptions();
-	const manager = getHotkeyManager();
-	const registrations = /* @__PURE__ */ new Map();
-	onCleanup(() => {
-		for (const { handle } of registrations.values()) if (handle.isActive) handle.unregister();
-		registrations.clear();
-	});
+	const defaultOptions = useDefaultHotkeysOptionsSource();
+	const appHotkeys = useAppHotkeysStoreSource();
+	const bindings = createHotkeyBindings();
+	onCleanup(() => bindings.destroy());
 	createEffect(() => {
-		const resolvedHotkeys = typeof hotkeys === "function" ? hotkeys() : hotkeys;
-		const resolvedCommonOptions = typeof commonOptions === "function" ? commonOptions() : commonOptions;
-		const nextKeys = /* @__PURE__ */ new Set();
-		const prepared = [];
-		for (let i = 0; i < resolvedHotkeys.length; i++) {
-			const def = resolvedHotkeys[i];
-			const resolvedDefOptions = def.options ?? {};
-			const mergedOptions = {
-				...defaultOptions.hotkey,
-				...resolvedCommonOptions,
-				...resolvedDefOptions
-			};
-			const platform = mergedOptions.platform ?? detectPlatform();
-			const hotkeyString = normalizeRegisterableHotkey(def.hotkey, platform);
-			const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
-			if (!resolvedTarget) continue;
-			const registrationKey = `${i}:${hotkeyString}`;
-			nextKeys.add(registrationKey);
-			prepared.push({
-				registrationKey,
-				def,
-				mergedOptions,
-				hotkeyString,
-				resolvedTarget
-			});
-		}
-		untrack(() => {
-			for (const [key, record] of [...registrations.entries()]) if (!nextKeys.has(key)) {
-				if (record.handle.isActive) record.handle.unregister();
-				registrations.delete(key);
-			}
-			for (const p of prepared) {
-				const existing = registrations.get(p.registrationKey);
-				if (existing?.handle.isActive && existing.target === p.resolvedTarget) {
-					existing.handle.callback = p.def.callback;
-					const { target: _target, ...optionsWithoutTarget } = p.mergedOptions;
-					existing.handle.setOptions(optionsWithoutTarget);
-					continue;
-				}
-				if (existing) {
-					if (existing.handle.isActive) existing.handle.unregister();
-					registrations.delete(p.registrationKey);
-				}
-				const { target: _target, ...optionsWithoutTarget } = p.mergedOptions;
-				const handle = manager.register(p.hotkeyString, p.def.callback, {
-					...optionsWithoutTarget,
-					target: p.resolvedTarget
-				});
-				registrations.set(p.registrationKey, {
-					handle,
-					target: p.resolvedTarget
-				});
-			}
+		appHotkeys.state();
+		const definitions = prepareHotkeyDefinitions(typeof hotkeys === "function" ? hotkeys() : hotkeys, {
+			appHotkeysStore: appHotkeys.store,
+			defaults: defaultOptions().hotkey,
+			commonOptions: typeof commonOptions === "function" ? commonOptions() : commonOptions,
+			resolveTarget: (target) => target
 		});
+		untrack(() => bindings.update(definitions));
 	});
 }
 

package/dist/defaultOptions.js

@@ -0,0 +1,24 @@
+import { useHotkeysContext } from "./HotkeysProvider.js";
+import { Store, useSelector } from "@tanstack/solid-store";
+
+//#region src/defaultOptions.ts
+/** Captures the context once and reads current defaults inside reactive computations. */
+function useDefaultHotkeysOptionsSource() {
+	const context = useHotkeysContext();
+	return () => context?.defaultOptions ?? {};
+}
+const NO_APP_HOTKEYS = new Store(null);
+/**
+* The provider's app hotkeys store and an accessor that tracks its state, so
+* computations re-run when app hotkeys or custom hotkeys change.
+*/
+function useAppHotkeysStoreSource() {
+	const store = useHotkeysContext()?.appHotkeysStore ?? null;
+	return {
+		store,
+		state: useSelector(store?.store ?? NO_APP_HOTKEYS, (value) => value)
+	};
+}
+
+//#endregion
+export { useAppHotkeysStoreSource, useDefaultHotkeysOptionsSource };

package/dist/index.d.ts

@@ -1,14 +1,12 @@
-import { CreateHotkeyOptions, createHotkey } from "./createHotkey.js";
-import { CreateHotkeySequenceOptions, createHotkeySequence } from "./createHotkeySequence.js";
+import { CreateAppHotkeyOptions, CreateHotkeyChordOptions, CreateHotkeyCommonOptions, CreateHotkeyOptions, CreateHotkeyOptionsFor, CreateHotkeySequenceOptions, CreateHotkeyTarget, createHotkey } from "./createHotkey.js";
 import { HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, useDefaultHotkeysOptions, useHotkeysContext } from "./HotkeysProvider.js";
 import { CreateHotkeyDefinition, createHotkeys } from "./createHotkeys.js";
+import { SolidHotkeyRecorder, createHotkeyRecorder } from "./createHotkeyRecorder.js";
+import { createHotkeyRegistrations } from "./createHotkeyRegistrations.js";
+import { createHotkeyHint } from "./createHotkeyHint.js";
+import { UseCustomHotkeysResult, createAppHotkeyList, useAppHotkeys, useCustomHotkeys } from "./appHotkeys.js";
 import { createHeldKeys } from "./createHeldKeys.js";
 import { createHeldKeyCodes } from "./createHeldKeyCodes.js";
 import { createKeyHold } from "./createKeyHold.js";
-import { CreateHotkeySequenceDefinition, createHotkeySequences } from "./createHotkeySequences.js";
-import { SolidHotkeyRecorder, createHotkeyRecorder } from "./createHotkeyRecorder.js";
-import { HotkeyRegistrationsResult, createHotkeyRegistrations } from "./createHotkeyRegistrations.js";
-import { SolidHotkeySequenceRecorder, createHotkeySequenceRecorder } from "./createHotkeySequenceRecorder.js";
-import { createHotkeyHint } from "./createHotkeyHint.js";
 export * from "@tanstack/hotkeys";
-export { CreateHotkeyDefinition, CreateHotkeyOptions, CreateHotkeySequenceDefinition, CreateHotkeySequenceOptions, HotkeyRegistrationsResult, HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, SolidHotkeyRecorder, SolidHotkeySequenceRecorder, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyHint, createHotkeyRecorder, createHotkeyRegistrations, createHotkeySequence, createHotkeySequenceRecorder, createHotkeySequences, createHotkeys, createKeyHold, useDefaultHotkeysOptions, useHotkeysContext };
+export { CreateAppHotkeyOptions, CreateHotkeyChordOptions, CreateHotkeyCommonOptions, CreateHotkeyDefinition, CreateHotkeyOptions, CreateHotkeyOptionsFor, CreateHotkeySequenceOptions, CreateHotkeyTarget, HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, SolidHotkeyRecorder, UseCustomHotkeysResult, createAppHotkeyList, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyHint, createHotkeyRecorder, createHotkeyRegistrations, createHotkeys, createKeyHold, useAppHotkeys, useCustomHotkeys, useDefaultHotkeysOptions, useHotkeysContext };

package/dist/index.js

@@ -1,16 +1,14 @@
 import { HotkeysProvider, useDefaultHotkeysOptions, useHotkeysContext } from "./HotkeysProvider.js";
-import { createHotkey } from "./createHotkey.js";
 import { createHotkeys } from "./createHotkeys.js";
-import { createHeldKeys } from "./createHeldKeys.js";
-import { createHeldKeyCodes } from "./createHeldKeyCodes.js";
-import { createKeyHold } from "./createKeyHold.js";
-import { createHotkeySequence } from "./createHotkeySequence.js";
-import { createHotkeySequences } from "./createHotkeySequences.js";
+import { createHotkey } from "./createHotkey.js";
 import { createHotkeyRecorder } from "./createHotkeyRecorder.js";
 import { createHotkeyRegistrations } from "./createHotkeyRegistrations.js";
-import { createHotkeySequenceRecorder } from "./createHotkeySequenceRecorder.js";
 import { createHotkeyHint } from "./createHotkeyHint.js";
+import { createAppHotkeyList, useAppHotkeys, useCustomHotkeys } from "./appHotkeys.js";
+import { createHeldKeys } from "./createHeldKeys.js";
+import { createHeldKeyCodes } from "./createHeldKeyCodes.js";
+import { createKeyHold } from "./createKeyHold.js";
 
 export * from "@tanstack/hotkeys"
 
-export { HotkeysProvider, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyHint, createHotkeyRecorder, createHotkeyRegistrations, createHotkeySequence, createHotkeySequenceRecorder, createHotkeySequences, createHotkeys, createKeyHold, useDefaultHotkeysOptions, useHotkeysContext };
+export { HotkeysProvider, createAppHotkeyList, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyHint, createHotkeyRecorder, createHotkeyRegistrations, createHotkeys, createKeyHold, useAppHotkeys, useCustomHotkeys, useDefaultHotkeysOptions, useHotkeysContext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-hotkeys",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "description": "SolidJS adapter for TanStack Hotkeys",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -36,8 +36,8 @@
     "dist"
   ],
   "dependencies": {
-    "@tanstack/hotkeys": "0.10.1",
-    "@tanstack/solid-store": "^0.11.1"
+    "@tanstack/hotkeys": "0.12.0",
+    "@tanstack/solid-store": "^0.11.2"
   },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.10",

package/dist/createHotkeySequence.d.ts

@@ -1,53 +0,0 @@
-import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
-//#region src/createHotkeySequence.d.ts
-export interface CreateHotkeySequenceOptions extends Omit<SequenceOptions, 'target'> {
-  /**
-   * The DOM element to attach the event listener to.
-   * Can be a direct DOM element, an accessor, or null. Defaults to document.
-   */
-  target?: HTMLElement | Document | Window | null;
-}
-/**
- * SolidJS primitive for registering a keyboard shortcut sequence (Vim-style).
- *
- * This primitive allows you to register multi-key sequences like 'g g' or 'd d'
- * that trigger when the full sequence is pressed within a timeout.
- *
- * Each step may include modifiers. You can chain the same modifier across
- * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
- * Control, Alt, or Meta pressed alone) are ignored while matching—they do not
- * advance the sequence or reset progress.
- *
- * @param sequence - Array of hotkey strings that form the sequence (or accessor function)
- * @param callback - Function to call when the sequence is completed
- * @param options - Options for the sequence behavior (or accessor function)
- *
- * @example
- * ```tsx
- * function VimEditor() {
- *   // 'g g' to go to top
- *   createHotkeySequence(['G', 'G'], () => {
- *     scrollToTop()
- *   })
- *
- *   // 'd d' to delete line
- *   createHotkeySequence(['D', 'D'], () => {
- *     deleteLine()
- *   })
- *
- *   // 'd i w' to delete inner word
- *   createHotkeySequence(['D', 'I', 'W'], () => {
- *     deleteInnerWord()
- *   }, { timeout: 500 })
- *
- *   // Same modifier on consecutive steps (bare Shift between chords is ignored)
- *   createHotkeySequence(['Shift+R', 'Shift+T'], () => {
- *     nextAction()
- *   })
- *
- *   return <div>...</div>
- * }
- * ```
- */
-export declare function createHotkeySequence(sequence: HotkeySequence | (() => HotkeySequence), callback: HotkeyCallback, options?: CreateHotkeySequenceOptions | (() => CreateHotkeySequenceOptions)): void;
-//#endregion

package/dist/createHotkeySequence.js

@@ -1,106 +0,0 @@
-import { useDefaultHotkeysOptions } from "./HotkeysProvider.js";
-import { formatHotkeySequence, getSequenceManager } from "@tanstack/hotkeys";
-import { createEffect, onCleanup, untrack } from "solid-js";
-
-//#region src/createHotkeySequence.ts
-/**
-* SolidJS primitive for registering a keyboard shortcut sequence (Vim-style).
-*
-* This primitive allows you to register multi-key sequences like 'g g' or 'd d'
-* that trigger when the full sequence is pressed within a timeout.
-*
-* Each step may include modifiers. You can chain the same modifier across
-* steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
-* Control, Alt, or Meta pressed alone) are ignored while matching—they do not
-* advance the sequence or reset progress.
-*
-* @param sequence - Array of hotkey strings that form the sequence (or accessor function)
-* @param callback - Function to call when the sequence is completed
-* @param options - Options for the sequence behavior (or accessor function)
-*
-* @example
-* ```tsx
-* function VimEditor() {
-*   // 'g g' to go to top
-*   createHotkeySequence(['G', 'G'], () => {
-*     scrollToTop()
-*   })
-*
-*   // 'd d' to delete line
-*   createHotkeySequence(['D', 'D'], () => {
-*     deleteLine()
-*   })
-*
-*   // 'd i w' to delete inner word
-*   createHotkeySequence(['D', 'I', 'W'], () => {
-*     deleteInnerWord()
-*   }, { timeout: 500 })
-*
-*   // Same modifier on consecutive steps (bare Shift between chords is ignored)
-*   createHotkeySequence(['Shift+R', 'Shift+T'], () => {
-*     nextAction()
-*   })
-*
-*   return <div>...</div>
-* }
-* ```
-*/
-function createHotkeySequence(sequence, callback, options = {}) {
-	const defaultOptions = useDefaultHotkeysOptions();
-	const manager = getSequenceManager();
-	let registration = null;
-	let lastSequenceKey = null;
-	let lastTarget = null;
-	onCleanup(() => {
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
-		}
-		lastSequenceKey = null;
-		lastTarget = null;
-	});
-	createEffect(() => {
-		const resolvedSequence = typeof sequence === "function" ? sequence() : sequence;
-		const resolvedOptions = typeof options === "function" ? options() : options;
-		const mergedOptions = {
-			...defaultOptions.hotkeySequence,
-			...resolvedOptions
-		};
-		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-		const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
-		if (resolvedSequence.length === 0 || !resolvedTarget) {
-			if (registration?.isActive) {
-				registration.unregister();
-				registration = null;
-			}
-			lastSequenceKey = null;
-			lastTarget = null;
-			return;
-		}
-		const sequenceKey = formatHotkeySequence(resolvedSequence);
-		untrack(() => {
-			if (registration?.isActive && lastSequenceKey === sequenceKey && lastTarget === resolvedTarget) {
-				registration.callback = callback;
-				registration.setOptions(optionsWithoutTarget);
-				return;
-			}
-			if (registration?.isActive) {
-				registration.unregister();
-				registration = null;
-			}
-			registration = manager.register(resolvedSequence, callback, {
-				...mergedOptions,
-				target: resolvedTarget
-			});
-			if (registration.isActive) {
-				registration.callback = callback;
-				registration.setOptions(optionsWithoutTarget);
-			}
-			lastSequenceKey = sequenceKey;
-			lastTarget = resolvedTarget;
-		});
-	});
-}
-
-//#endregion
-export { createHotkeySequence };

package/dist/createHotkeySequenceRecorder.d.ts

@@ -1,16 +0,0 @@
-import { HotkeySequence, HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
-//#region src/createHotkeySequenceRecorder.d.ts
-export interface SolidHotkeySequenceRecorder {
-  isRecording: () => boolean;
-  steps: () => HotkeySequence;
-  recordedSequence: () => HotkeySequence | null;
-  startRecording: () => void;
-  stopRecording: () => void;
-  cancelRecording: () => void;
-  commitRecording: () => void;
-}
-/**
- * SolidJS primitive for recording multi-chord sequences (Vim-style shortcuts).
- */
-export declare function createHotkeySequenceRecorder(options: HotkeySequenceRecorderOptions | (() => HotkeySequenceRecorderOptions)): SolidHotkeySequenceRecorder;
-//#endregion