@tanstack/solid-hotkeys 0.0.1

package/dist/createHotkeyRecorder.js

@@ -0,0 +1,78 @@
+import { useDefaultHotkeysOptions } from "./HotkeysProvider.js";
+import { HotkeyRecorder } from "@tanstack/hotkeys";
+import { createEffect, onCleanup } from "solid-js";
+import { useStore } 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 `useStore` 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 recorder = new HotkeyRecorder({
+		...defaultOptions.hotkeyRecorder,
+		...resolvedOptions
+	});
+	const isRecording = useStore(recorder.store, (state) => state.isRecording);
+	const recordedHotkey = useStore(recorder.store, (state) => state.recordedHotkey);
+	createEffect(() => {
+		const resolved = typeof options === "function" ? options() : options;
+		recorder.setOptions({
+			...defaultOptions.hotkeyRecorder,
+			...resolved
+		});
+	});
+	onCleanup(() => {
+		recorder.destroy();
+	});
+	return {
+		isRecording,
+		recordedHotkey,
+		startRecording: () => recorder.start(),
+		stopRecording: () => recorder.stop(),
+		cancelRecording: () => recorder.cancel()
+	};
+}
+
+//#endregion
+export { createHotkeyRecorder };
+//# sourceMappingURL=createHotkeyRecorder.js.map

package/dist/createHotkeyRecorder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHotkeyRecorder.js","names":[],"sources":["../src/createHotkeyRecorder.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport { useStore } from '@tanstack/solid-store'\nimport { HotkeyRecorder } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type { Hotkey, HotkeyRecorderOptions } from '@tanstack/hotkeys'\n\nexport interface SolidHotkeyRecorder {\n  /** Whether recording is currently active */\n  isRecording: () => boolean\n  /** The currently recorded hotkey (for live preview) */\n  recordedHotkey: () => Hotkey | null\n  /** Start recording a new hotkey */\n  startRecording: () => void\n  /** Stop recording (same as cancel) */\n  stopRecording: () => void\n  /** Cancel recording without saving */\n  cancelRecording: () => void\n}\n\n/**\n * SolidJS primitive for recording keyboard shortcuts.\n *\n * This primitive provides a thin wrapper around the framework-agnostic `HotkeyRecorder`\n * class, managing all the complexity of capturing keyboard events, converting them\n * to hotkey strings, and handling edge cases like Escape to cancel or Backspace/Delete\n * to clear.\n *\n * This primitive uses `useStore` from `@tanstack/solid-store` to subscribe\n * to the recorder's store state (same pattern as useHotkeyRecorder in React).\n *\n * @param options - Configuration options for the recorder (or accessor function)\n * @returns An object with recording state signals and control functions\n *\n * @example\n * ```tsx\n * function ShortcutSettings() {\n *   const [shortcut, setShortcut] = createSignal<Hotkey>('Mod+S')\n *\n *   const recorder = createHotkeyRecorder({\n *     onRecord: (hotkey) => {\n *       setShortcut(hotkey)\n *     },\n *     onCancel: () => {\n *       console.log('Recording cancelled')\n *     },\n *   })\n *\n *   return (\n *     <div>\n *       <button onClick={recorder.startRecording}>\n *         {recorder.isRecording() ? 'Recording...' : 'Edit Shortcut'}\n *       </button>\n *       <Show when={recorder.recordedHotkey()}>\n *         <div>Recording: {recorder.recordedHotkey()}</div>\n *       </Show>\n *     </div>\n *   )\n * }\n * ```\n */\nexport function createHotkeyRecorder(\n  options: HotkeyRecorderOptions | (() => HotkeyRecorderOptions),\n): SolidHotkeyRecorder {\n  const defaultOptions = useDefaultHotkeysOptions()\n\n  const resolvedOptions = typeof options === 'function' ? options() : options\n  const mergedOptions = {\n    ...defaultOptions.hotkeyRecorder,\n    ...resolvedOptions,\n  } as HotkeyRecorderOptions\n\n  // Create recorder once synchronously (matches React's useRef pattern)\n  const recorder = new HotkeyRecorder(mergedOptions)\n\n  // Subscribe to recorder state using useStore (same pattern as useHotkeyRecorder)\n  const isRecording = useStore(recorder.store, (state) => state.isRecording)\n  const recordedHotkey = useStore(\n    recorder.store,\n    (state) => state.recordedHotkey,\n  )\n\n  // Sync options on every effect run (matches React's sync on render)\n  createEffect(() => {\n    const resolved = typeof options === 'function' ? options() : options\n    recorder.setOptions({\n      ...defaultOptions.hotkeyRecorder,\n      ...resolved,\n    } as HotkeyRecorderOptions)\n  })\n\n  // Cleanup on unmount\n  onCleanup(() => {\n    recorder.destroy()\n  })\n\n  return {\n    isRecording,\n    recordedHotkey,\n    startRecording: () => recorder.start(),\n    stopRecording: () => recorder.stop(),\n    cancelRecording: () => recorder.cancel(),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,SAAgB,qBACd,SACqB;CACrB,MAAM,iBAAiB,0BAA0B;CAEjD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;CAOpE,MAAM,WAAW,IAAI,eANC;EACpB,GAAG,eAAe;EAClB,GAAG;EACJ,CAGiD;CAGlD,MAAM,cAAc,SAAS,SAAS,QAAQ,UAAU,MAAM,YAAY;CAC1E,MAAM,iBAAiB,SACrB,SAAS,QACR,UAAU,MAAM,eAClB;AAGD,oBAAmB;EACjB,MAAM,WAAW,OAAO,YAAY,aAAa,SAAS,GAAG;AAC7D,WAAS,WAAW;GAClB,GAAG,eAAe;GAClB,GAAG;GACJ,CAA0B;GAC3B;AAGF,iBAAgB;AACd,WAAS,SAAS;GAClB;AAEF,QAAO;EACL;EACA;EACA,sBAAsB,SAAS,OAAO;EACtC,qBAAqB,SAAS,MAAM;EACpC,uBAAuB,SAAS,QAAQ;EACzC"}

package/dist/createHotkeySequence.cjs

@@ -0,0 +1,58 @@
+const require_HotkeysProvider = require('./HotkeysProvider.cjs');
+let _tanstack_hotkeys = require("@tanstack/hotkeys");
+let solid_js = require("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.
+*
+* @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 })
+*
+*   return <div>...</div>
+* }
+* ```
+*/
+function createHotkeySequence(sequence, callback, options = {}) {
+	const defaultOptions = require_HotkeysProvider.useDefaultHotkeysOptions();
+	(0, solid_js.createEffect)(() => {
+		const resolvedSequence = typeof sequence === "function" ? sequence() : sequence;
+		const resolvedOptions = typeof options === "function" ? options() : options;
+		const { enabled = true, ...sequenceOptions } = {
+			...defaultOptions.hotkeySequence,
+			...resolvedOptions
+		};
+		if (!enabled || resolvedSequence.length === 0) return;
+		const manager = (0, _tanstack_hotkeys.getSequenceManager)();
+		const registerOptions = { enabled: true };
+		if (sequenceOptions.timeout !== void 0) registerOptions.timeout = sequenceOptions.timeout;
+		if (sequenceOptions.platform !== void 0) registerOptions.platform = sequenceOptions.platform;
+		(0, solid_js.onCleanup)(manager.register(resolvedSequence, callback, registerOptions));
+	});
+}
+
+//#endregion
+exports.createHotkeySequence = createHotkeySequence;
+//# sourceMappingURL=createHotkeySequence.cjs.map

package/dist/createHotkeySequence.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHotkeySequence.cjs","names":["useDefaultHotkeysOptions"],"sources":["../src/createHotkeySequence.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport { getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n} from '@tanstack/hotkeys'\n\nexport interface CreateHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'enabled'\n> {\n  /** Whether the sequence is enabled. Defaults to true. */\n  enabled?: boolean\n}\n\n/**\n * SolidJS primitive for registering a keyboard shortcut sequence (Vim-style).\n *\n * This primitive allows you to register multi-key sequences like 'g g' or 'd d'\n * that trigger when the full sequence is pressed within a timeout.\n *\n * @param sequence - Array of hotkey strings that form the sequence (or accessor function)\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior (or accessor function)\n *\n * @example\n * ```tsx\n * function VimEditor() {\n *   // 'g g' to go to top\n *   createHotkeySequence(['G', 'G'], () => {\n *     scrollToTop()\n *   })\n *\n *   // 'd d' to delete line\n *   createHotkeySequence(['D', 'D'], () => {\n *     deleteLine()\n *   })\n *\n *   // 'd i w' to delete inner word\n *   createHotkeySequence(['D', 'I', 'W'], () => {\n *     deleteInnerWord()\n *   }, { timeout: 500 })\n *\n *   return <div>...</div>\n * }\n * ```\n */\nexport function createHotkeySequence(\n  sequence: HotkeySequence | (() => HotkeySequence),\n  callback: HotkeyCallback,\n  options:\n    | CreateHotkeySequenceOptions\n    | (() => CreateHotkeySequenceOptions) = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n\n  createEffect(() => {\n    // Resolve reactive values\n    const resolvedSequence =\n      typeof sequence === 'function' ? sequence() : sequence\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkeySequence,\n      ...resolvedOptions,\n    } as CreateHotkeySequenceOptions\n\n    const { enabled = true, ...sequenceOptions } = mergedOptions\n\n    if (!enabled || resolvedSequence.length === 0) {\n      return\n    }\n\n    const manager = getSequenceManager()\n\n    // Build options object conditionally to avoid overwriting manager defaults with undefined\n    const registerOptions: SequenceOptions = { enabled: true }\n    if (sequenceOptions.timeout !== undefined)\n      registerOptions.timeout = sequenceOptions.timeout\n    if (sequenceOptions.platform !== undefined)\n      registerOptions.platform = sequenceOptions.platform\n\n    const unregister = manager.register(\n      resolvedSequence,\n      callback,\n      registerOptions,\n    )\n\n    onCleanup(unregister)\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiBA,kDAA0B;AAEjD,kCAAmB;EAEjB,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAOpE,MAAM,EAAE,UAAU,MAAM,GAAG,oBALL;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;AAID,MAAI,CAAC,WAAW,iBAAiB,WAAW,EAC1C;EAGF,MAAM,qDAA8B;EAGpC,MAAM,kBAAmC,EAAE,SAAS,MAAM;AAC1D,MAAI,gBAAgB,YAAY,OAC9B,iBAAgB,UAAU,gBAAgB;AAC5C,MAAI,gBAAgB,aAAa,OAC/B,iBAAgB,WAAW,gBAAgB;AAQ7C,0BANmB,QAAQ,SACzB,kBACA,UACA,gBACD,CAEoB;GACrB"}

package/dist/createHotkeySequence.d.cts

@@ -0,0 +1,43 @@
+import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
+
+//#region src/createHotkeySequence.d.ts
+interface CreateHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled'> {
+  /** Whether the sequence is enabled. Defaults to true. */
+  enabled?: boolean;
+}
+/**
+ * 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.
+ *
+ * @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 })
+ *
+ *   return <div>...</div>
+ * }
+ * ```
+ */
+declare function createHotkeySequence(sequence: HotkeySequence | (() => HotkeySequence), callback: HotkeyCallback, options?: CreateHotkeySequenceOptions | (() => CreateHotkeySequenceOptions)): void;
+//#endregion
+export { CreateHotkeySequenceOptions, createHotkeySequence };
+//# sourceMappingURL=createHotkeySequence.d.cts.map

package/dist/createHotkeySequence.d.ts

@@ -0,0 +1,43 @@
+import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
+
+//#region src/createHotkeySequence.d.ts
+interface CreateHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled'> {
+  /** Whether the sequence is enabled. Defaults to true. */
+  enabled?: boolean;
+}
+/**
+ * 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.
+ *
+ * @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 })
+ *
+ *   return <div>...</div>
+ * }
+ * ```
+ */
+declare function createHotkeySequence(sequence: HotkeySequence | (() => HotkeySequence), callback: HotkeyCallback, options?: CreateHotkeySequenceOptions | (() => CreateHotkeySequenceOptions)): void;
+//#endregion
+export { CreateHotkeySequenceOptions, createHotkeySequence };
+//# sourceMappingURL=createHotkeySequence.d.ts.map

package/dist/createHotkeySequence.js

@@ -0,0 +1,58 @@
+import { useDefaultHotkeysOptions } from "./HotkeysProvider.js";
+import { getSequenceManager } from "@tanstack/hotkeys";
+import { createEffect, onCleanup } 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.
+*
+* @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 })
+*
+*   return <div>...</div>
+* }
+* ```
+*/
+function createHotkeySequence(sequence, callback, options = {}) {
+	const defaultOptions = useDefaultHotkeysOptions();
+	createEffect(() => {
+		const resolvedSequence = typeof sequence === "function" ? sequence() : sequence;
+		const resolvedOptions = typeof options === "function" ? options() : options;
+		const { enabled = true, ...sequenceOptions } = {
+			...defaultOptions.hotkeySequence,
+			...resolvedOptions
+		};
+		if (!enabled || resolvedSequence.length === 0) return;
+		const manager = getSequenceManager();
+		const registerOptions = { enabled: true };
+		if (sequenceOptions.timeout !== void 0) registerOptions.timeout = sequenceOptions.timeout;
+		if (sequenceOptions.platform !== void 0) registerOptions.platform = sequenceOptions.platform;
+		onCleanup(manager.register(resolvedSequence, callback, registerOptions));
+	});
+}
+
+//#endregion
+export { createHotkeySequence };
+//# sourceMappingURL=createHotkeySequence.js.map

package/dist/createHotkeySequence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHotkeySequence.js","names":[],"sources":["../src/createHotkeySequence.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport { getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n} from '@tanstack/hotkeys'\n\nexport interface CreateHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'enabled'\n> {\n  /** Whether the sequence is enabled. Defaults to true. */\n  enabled?: boolean\n}\n\n/**\n * SolidJS primitive for registering a keyboard shortcut sequence (Vim-style).\n *\n * This primitive allows you to register multi-key sequences like 'g g' or 'd d'\n * that trigger when the full sequence is pressed within a timeout.\n *\n * @param sequence - Array of hotkey strings that form the sequence (or accessor function)\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior (or accessor function)\n *\n * @example\n * ```tsx\n * function VimEditor() {\n *   // 'g g' to go to top\n *   createHotkeySequence(['G', 'G'], () => {\n *     scrollToTop()\n *   })\n *\n *   // 'd d' to delete line\n *   createHotkeySequence(['D', 'D'], () => {\n *     deleteLine()\n *   })\n *\n *   // 'd i w' to delete inner word\n *   createHotkeySequence(['D', 'I', 'W'], () => {\n *     deleteInnerWord()\n *   }, { timeout: 500 })\n *\n *   return <div>...</div>\n * }\n * ```\n */\nexport function createHotkeySequence(\n  sequence: HotkeySequence | (() => HotkeySequence),\n  callback: HotkeyCallback,\n  options:\n    | CreateHotkeySequenceOptions\n    | (() => CreateHotkeySequenceOptions) = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n\n  createEffect(() => {\n    // Resolve reactive values\n    const resolvedSequence =\n      typeof sequence === 'function' ? sequence() : sequence\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkeySequence,\n      ...resolvedOptions,\n    } as CreateHotkeySequenceOptions\n\n    const { enabled = true, ...sequenceOptions } = mergedOptions\n\n    if (!enabled || resolvedSequence.length === 0) {\n      return\n    }\n\n    const manager = getSequenceManager()\n\n    // Build options object conditionally to avoid overwriting manager defaults with undefined\n    const registerOptions: SequenceOptions = { enabled: true }\n    if (sequenceOptions.timeout !== undefined)\n      registerOptions.timeout = sequenceOptions.timeout\n    if (sequenceOptions.platform !== undefined)\n      registerOptions.platform = sequenceOptions.platform\n\n    const unregister = manager.register(\n      resolvedSequence,\n      callback,\n      registerOptions,\n    )\n\n    onCleanup(unregister)\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiB,0BAA0B;AAEjD,oBAAmB;EAEjB,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAOpE,MAAM,EAAE,UAAU,MAAM,GAAG,oBALL;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;AAID,MAAI,CAAC,WAAW,iBAAiB,WAAW,EAC1C;EAGF,MAAM,UAAU,oBAAoB;EAGpC,MAAM,kBAAmC,EAAE,SAAS,MAAM;AAC1D,MAAI,gBAAgB,YAAY,OAC9B,iBAAgB,UAAU,gBAAgB;AAC5C,MAAI,gBAAgB,aAAa,OAC/B,iBAAgB,WAAW,gBAAgB;AAQ7C,YANmB,QAAQ,SACzB,kBACA,UACA,gBACD,CAEoB;GACrB"}

package/dist/createKeyHold.cjs

@@ -0,0 +1,56 @@
+let _tanstack_hotkeys = require("@tanstack/hotkeys");
+let solid_js = require("solid-js");
+let _tanstack_solid_store = require("@tanstack/solid-store");
+
+//#region src/createKeyHold.ts
+/**
+* SolidJS primitive that returns whether a specific key is currently being held.
+*
+* This primitive uses `useStore` from `@tanstack/solid-store` to subscribe
+* to the global KeyStateTracker and uses a selector to determine if the
+* specified key is held.
+*
+* @param key - The key to check (e.g., 'Shift', 'Control', 'A') - can be an accessor function
+* @returns Signal accessor that returns true if the key is currently held down
+*
+* @example
+* ```tsx
+* function ShiftIndicator() {
+*   const isShiftHeld = createKeyHold('Shift')
+*
+*   return (
+*     <div style={{ opacity: isShiftHeld() ? 1 : 0.5 }}>
+*       {isShiftHeld() ? 'Shift is pressed!' : 'Press Shift'}
+*     </div>
+*   )
+* }
+* ```
+*
+* @example
+* ```tsx
+* function ModifierIndicators() {
+*   const ctrl = createKeyHold('Control')
+*   const shift = createKeyHold('Shift')
+*   const alt = createKeyHold('Alt')
+*
+*   return (
+*     <div>
+*       <span style={{ opacity: ctrl() ? 1 : 0.3 }}>Ctrl</span>
+*       <span style={{ opacity: shift() ? 1 : 0.3 }}>Shift</span>
+*       <span style={{ opacity: alt() ? 1 : 0.3 }}>Alt</span>
+*     </div>
+*   )
+* }
+* ```
+*/
+function createKeyHold(key) {
+	const heldKeysSelector = (0, _tanstack_solid_store.useStore)((0, _tanstack_hotkeys.getKeyStateTracker)().store, (state) => state.heldKeys);
+	return (0, solid_js.createMemo)(() => {
+		const normalizedKey = (typeof key === "function" ? key() : key).toLowerCase();
+		return heldKeysSelector().some((heldKey) => heldKey.toLowerCase() === normalizedKey);
+	});
+}
+
+//#endregion
+exports.createKeyHold = createKeyHold;
+//# sourceMappingURL=createKeyHold.cjs.map

package/dist/createKeyHold.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createKeyHold.cjs","names":[],"sources":["../src/createKeyHold.ts"],"sourcesContent":["import { createMemo } from 'solid-js'\nimport { useStore } from '@tanstack/solid-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\nimport type { HeldKey } from '@tanstack/hotkeys'\n\n/**\n * SolidJS primitive that returns whether a specific key is currently being held.\n *\n * This primitive uses `useStore` from `@tanstack/solid-store` to subscribe\n * to the global KeyStateTracker and uses a selector to determine if the\n * specified key is held.\n *\n * @param key - The key to check (e.g., 'Shift', 'Control', 'A') - can be an accessor function\n * @returns Signal accessor that returns true if the key is currently held down\n *\n * @example\n * ```tsx\n * function ShiftIndicator() {\n *   const isShiftHeld = createKeyHold('Shift')\n *\n *   return (\n *     <div style={{ opacity: isShiftHeld() ? 1 : 0.5 }}>\n *       {isShiftHeld() ? 'Shift is pressed!' : 'Press Shift'}\n *     </div>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * function ModifierIndicators() {\n *   const ctrl = createKeyHold('Control')\n *   const shift = createKeyHold('Shift')\n *   const alt = createKeyHold('Alt')\n *\n *   return (\n *     <div>\n *       <span style={{ opacity: ctrl() ? 1 : 0.3 }}>Ctrl</span>\n *       <span style={{ opacity: shift() ? 1 : 0.3 }}>Shift</span>\n *       <span style={{ opacity: alt() ? 1 : 0.3 }}>Alt</span>\n *     </div>\n *   )\n * }\n * ```\n */\nexport function createKeyHold(key: HeldKey | (() => HeldKey)): () => boolean {\n  const tracker = getKeyStateTracker()\n  const heldKeysSelector = useStore(tracker.store, (state) => state.heldKeys)\n\n  return createMemo(() => {\n    const resolvedKey = typeof key === 'function' ? key() : key\n    const normalizedKey = resolvedKey.toLowerCase()\n    return heldKeysSelector().some(\n      (heldKey) => heldKey.toLowerCase() === normalizedKey,\n    )\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,cAAc,KAA+C;CAE3E,MAAM,kGAD8B,CACM,QAAQ,UAAU,MAAM,SAAS;AAE3E,uCAAwB;EAEtB,MAAM,iBADc,OAAO,QAAQ,aAAa,KAAK,GAAG,KACtB,aAAa;AAC/C,SAAO,kBAAkB,CAAC,MACvB,YAAY,QAAQ,aAAa,KAAK,cACxC;GACD"}

package/dist/createKeyHold.d.cts

@@ -0,0 +1,47 @@
+import { HeldKey } from "@tanstack/hotkeys";
+
+//#region src/createKeyHold.d.ts
+/**
+ * SolidJS primitive that returns whether a specific key is currently being held.
+ *
+ * This primitive uses `useStore` from `@tanstack/solid-store` to subscribe
+ * to the global KeyStateTracker and uses a selector to determine if the
+ * specified key is held.
+ *
+ * @param key - The key to check (e.g., 'Shift', 'Control', 'A') - can be an accessor function
+ * @returns Signal accessor that returns true if the key is currently held down
+ *
+ * @example
+ * ```tsx
+ * function ShiftIndicator() {
+ *   const isShiftHeld = createKeyHold('Shift')
+ *
+ *   return (
+ *     <div style={{ opacity: isShiftHeld() ? 1 : 0.5 }}>
+ *       {isShiftHeld() ? 'Shift is pressed!' : 'Press Shift'}
+ *     </div>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function ModifierIndicators() {
+ *   const ctrl = createKeyHold('Control')
+ *   const shift = createKeyHold('Shift')
+ *   const alt = createKeyHold('Alt')
+ *
+ *   return (
+ *     <div>
+ *       <span style={{ opacity: ctrl() ? 1 : 0.3 }}>Ctrl</span>
+ *       <span style={{ opacity: shift() ? 1 : 0.3 }}>Shift</span>
+ *       <span style={{ opacity: alt() ? 1 : 0.3 }}>Alt</span>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function createKeyHold(key: HeldKey | (() => HeldKey)): () => boolean;
+//#endregion
+export { createKeyHold };
+//# sourceMappingURL=createKeyHold.d.cts.map

package/dist/createKeyHold.d.ts

@@ -0,0 +1,47 @@
+import { HeldKey } from "@tanstack/hotkeys";
+
+//#region src/createKeyHold.d.ts
+/**
+ * SolidJS primitive that returns whether a specific key is currently being held.
+ *
+ * This primitive uses `useStore` from `@tanstack/solid-store` to subscribe
+ * to the global KeyStateTracker and uses a selector to determine if the
+ * specified key is held.
+ *
+ * @param key - The key to check (e.g., 'Shift', 'Control', 'A') - can be an accessor function
+ * @returns Signal accessor that returns true if the key is currently held down
+ *
+ * @example
+ * ```tsx
+ * function ShiftIndicator() {
+ *   const isShiftHeld = createKeyHold('Shift')
+ *
+ *   return (
+ *     <div style={{ opacity: isShiftHeld() ? 1 : 0.5 }}>
+ *       {isShiftHeld() ? 'Shift is pressed!' : 'Press Shift'}
+ *     </div>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function ModifierIndicators() {
+ *   const ctrl = createKeyHold('Control')
+ *   const shift = createKeyHold('Shift')
+ *   const alt = createKeyHold('Alt')
+ *
+ *   return (
+ *     <div>
+ *       <span style={{ opacity: ctrl() ? 1 : 0.3 }}>Ctrl</span>
+ *       <span style={{ opacity: shift() ? 1 : 0.3 }}>Shift</span>
+ *       <span style={{ opacity: alt() ? 1 : 0.3 }}>Alt</span>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function createKeyHold(key: HeldKey | (() => HeldKey)): () => boolean;
+//#endregion
+export { createKeyHold };
+//# sourceMappingURL=createKeyHold.d.ts.map

package/dist/createKeyHold.js

@@ -0,0 +1,56 @@
+import { getKeyStateTracker } from "@tanstack/hotkeys";
+import { createMemo } from "solid-js";
+import { useStore } from "@tanstack/solid-store";
+
+//#region src/createKeyHold.ts
+/**
+* SolidJS primitive that returns whether a specific key is currently being held.
+*
+* This primitive uses `useStore` from `@tanstack/solid-store` to subscribe
+* to the global KeyStateTracker and uses a selector to determine if the
+* specified key is held.
+*
+* @param key - The key to check (e.g., 'Shift', 'Control', 'A') - can be an accessor function
+* @returns Signal accessor that returns true if the key is currently held down
+*
+* @example
+* ```tsx
+* function ShiftIndicator() {
+*   const isShiftHeld = createKeyHold('Shift')
+*
+*   return (
+*     <div style={{ opacity: isShiftHeld() ? 1 : 0.5 }}>
+*       {isShiftHeld() ? 'Shift is pressed!' : 'Press Shift'}
+*     </div>
+*   )
+* }
+* ```
+*
+* @example
+* ```tsx
+* function ModifierIndicators() {
+*   const ctrl = createKeyHold('Control')
+*   const shift = createKeyHold('Shift')
+*   const alt = createKeyHold('Alt')
+*
+*   return (
+*     <div>
+*       <span style={{ opacity: ctrl() ? 1 : 0.3 }}>Ctrl</span>
+*       <span style={{ opacity: shift() ? 1 : 0.3 }}>Shift</span>
+*       <span style={{ opacity: alt() ? 1 : 0.3 }}>Alt</span>
+*     </div>
+*   )
+* }
+* ```
+*/
+function createKeyHold(key) {
+	const heldKeysSelector = useStore(getKeyStateTracker().store, (state) => state.heldKeys);
+	return createMemo(() => {
+		const normalizedKey = (typeof key === "function" ? key() : key).toLowerCase();
+		return heldKeysSelector().some((heldKey) => heldKey.toLowerCase() === normalizedKey);
+	});
+}
+
+//#endregion
+export { createKeyHold };
+//# sourceMappingURL=createKeyHold.js.map

package/dist/createKeyHold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createKeyHold.js","names":[],"sources":["../src/createKeyHold.ts"],"sourcesContent":["import { createMemo } from 'solid-js'\nimport { useStore } from '@tanstack/solid-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\nimport type { HeldKey } from '@tanstack/hotkeys'\n\n/**\n * SolidJS primitive that returns whether a specific key is currently being held.\n *\n * This primitive uses `useStore` from `@tanstack/solid-store` to subscribe\n * to the global KeyStateTracker and uses a selector to determine if the\n * specified key is held.\n *\n * @param key - The key to check (e.g., 'Shift', 'Control', 'A') - can be an accessor function\n * @returns Signal accessor that returns true if the key is currently held down\n *\n * @example\n * ```tsx\n * function ShiftIndicator() {\n *   const isShiftHeld = createKeyHold('Shift')\n *\n *   return (\n *     <div style={{ opacity: isShiftHeld() ? 1 : 0.5 }}>\n *       {isShiftHeld() ? 'Shift is pressed!' : 'Press Shift'}\n *     </div>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * function ModifierIndicators() {\n *   const ctrl = createKeyHold('Control')\n *   const shift = createKeyHold('Shift')\n *   const alt = createKeyHold('Alt')\n *\n *   return (\n *     <div>\n *       <span style={{ opacity: ctrl() ? 1 : 0.3 }}>Ctrl</span>\n *       <span style={{ opacity: shift() ? 1 : 0.3 }}>Shift</span>\n *       <span style={{ opacity: alt() ? 1 : 0.3 }}>Alt</span>\n *     </div>\n *   )\n * }\n * ```\n */\nexport function createKeyHold(key: HeldKey | (() => HeldKey)): () => boolean {\n  const tracker = getKeyStateTracker()\n  const heldKeysSelector = useStore(tracker.store, (state) => state.heldKeys)\n\n  return createMemo(() => {\n    const resolvedKey = typeof key === 'function' ? key() : key\n    const normalizedKey = resolvedKey.toLowerCase()\n    return heldKeysSelector().some(\n      (heldKey) => heldKey.toLowerCase() === normalizedKey,\n    )\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,cAAc,KAA+C;CAE3E,MAAM,mBAAmB,SADT,oBAAoB,CACM,QAAQ,UAAU,MAAM,SAAS;AAE3E,QAAO,iBAAiB;EAEtB,MAAM,iBADc,OAAO,QAAQ,aAAa,KAAK,GAAG,KACtB,aAAa;AAC/C,SAAO,kBAAkB,CAAC,MACvB,YAAY,QAAQ,aAAa,KAAK,cACxC;GACD"}

package/dist/index.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_HotkeysProvider = require('./HotkeysProvider.cjs');
+const require_createHotkey = require('./createHotkey.cjs');
+const require_createHeldKeys = require('./createHeldKeys.cjs');
+const require_createHeldKeyCodes = require('./createHeldKeyCodes.cjs');
+const require_createKeyHold = require('./createKeyHold.cjs');
+const require_createHotkeySequence = require('./createHotkeySequence.cjs');
+const require_createHotkeyRecorder = require('./createHotkeyRecorder.cjs');
+
+exports.HotkeysProvider = require_HotkeysProvider.HotkeysProvider;
+exports.createHeldKeyCodes = require_createHeldKeyCodes.createHeldKeyCodes;
+exports.createHeldKeys = require_createHeldKeys.createHeldKeys;
+exports.createHotkey = require_createHotkey.createHotkey;
+exports.createHotkeyRecorder = require_createHotkeyRecorder.createHotkeyRecorder;
+exports.createHotkeySequence = require_createHotkeySequence.createHotkeySequence;
+exports.createKeyHold = require_createKeyHold.createKeyHold;
+exports.useDefaultHotkeysOptions = require_HotkeysProvider.useDefaultHotkeysOptions;
+exports.useHotkeysContext = require_HotkeysProvider.useHotkeysContext;
+var _tanstack_hotkeys = require("@tanstack/hotkeys");
+Object.keys(_tanstack_hotkeys).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _tanstack_hotkeys[k]; }
+  });
+});

package/dist/index.d.cts

@@ -0,0 +1,9 @@
+import { CreateHotkeyOptions, createHotkey } from "./createHotkey.cjs";
+import { CreateHotkeySequenceOptions, createHotkeySequence } from "./createHotkeySequence.cjs";
+import { HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, useDefaultHotkeysOptions, useHotkeysContext } from "./HotkeysProvider.cjs";
+import { createHeldKeys } from "./createHeldKeys.cjs";
+import { createHeldKeyCodes } from "./createHeldKeyCodes.cjs";
+import { createKeyHold } from "./createKeyHold.cjs";
+import { SolidHotkeyRecorder, createHotkeyRecorder } from "./createHotkeyRecorder.cjs";
+export * from "@tanstack/hotkeys";
+export { CreateHotkeyOptions, CreateHotkeySequenceOptions, HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, SolidHotkeyRecorder, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyRecorder, createHotkeySequence, createKeyHold, useDefaultHotkeysOptions, useHotkeysContext };

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { CreateHotkeyOptions, createHotkey } from "./createHotkey.js";
+import { CreateHotkeySequenceOptions, createHotkeySequence } from "./createHotkeySequence.js";
+import { HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, useDefaultHotkeysOptions, useHotkeysContext } from "./HotkeysProvider.js";
+import { createHeldKeys } from "./createHeldKeys.js";
+import { createHeldKeyCodes } from "./createHeldKeyCodes.js";
+import { createKeyHold } from "./createKeyHold.js";
+import { SolidHotkeyRecorder, createHotkeyRecorder } from "./createHotkeyRecorder.js";
+export * from "@tanstack/hotkeys";
+export { CreateHotkeyOptions, CreateHotkeySequenceOptions, HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, SolidHotkeyRecorder, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyRecorder, createHotkeySequence, createKeyHold, useDefaultHotkeysOptions, useHotkeysContext };

package/dist/index.js

@@ -0,0 +1,11 @@
+import { HotkeysProvider, useDefaultHotkeysOptions, useHotkeysContext } from "./HotkeysProvider.js";
+import { createHotkey } from "./createHotkey.js";
+import { createHeldKeys } from "./createHeldKeys.js";
+import { createHeldKeyCodes } from "./createHeldKeyCodes.js";
+import { createKeyHold } from "./createKeyHold.js";
+import { createHotkeySequence } from "./createHotkeySequence.js";
+import { createHotkeyRecorder } from "./createHotkeyRecorder.js";
+
+export * from "@tanstack/hotkeys"
+
+export { HotkeysProvider, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyRecorder, createHotkeySequence, createKeyHold, useDefaultHotkeysOptions, useHotkeysContext };