@tanstack/solid-hotkeys 0.6.0 → 0.8.0

package/README.md

@@ -37,7 +37,7 @@
 # TanStack Hotkeys
 
 > [!NOTE]
-> TanStack Hotkeys is pre-alpha (prototyping phase). We are actively developing the library and are open to feedback and contributions.
+> TanStack Hotkeys is alpha. We are actively developing the library and are open to feedback and contributions.
 
 Type-safe keyboard shortcuts for the web. Template-string bindings, parsed objects, a cross-platform `Mod` key, a singleton Hotkey Manager, and utilities for cheatsheet UIs—built to stay SSR-friendly.
 

package/dist/createHotkey.cjs

@@ -62,6 +62,16 @@ function createHotkey(hotkey, callback, options = {}) {
 	const defaultOptions = require_HotkeysProvider.useDefaultHotkeysOptions();
 	const manager = (0, _tanstack_hotkeys.getHotkeyManager)();
 	let registration = null;
+	let lastHotkeyString = null;
+	let lastTarget = null;
+	(0, solid_js.onCleanup)(() => {
+		if (registration?.isActive) {
+			registration.unregister();
+			registration = null;
+		}
+		lastHotkeyString = null;
+		lastTarget = null;
+	});
 	(0, solid_js.createEffect)(() => {
 		const resolvedHotkey = typeof hotkey === "function" ? hotkey() : hotkey;
 		const resolvedOptions = typeof options === "function" ? options() : options;
@@ -69,15 +79,27 @@ function createHotkey(hotkey, callback, options = {}) {
 			...defaultOptions.hotkey,
 			...resolvedOptions
 		};
-		const platform = mergedOptions.platform ?? (0, _tanstack_hotkeys.detectPlatform)();
-		const hotkeyString = typeof resolvedHotkey === "string" ? resolvedHotkey : (0, _tanstack_hotkeys.formatHotkey)((0, _tanstack_hotkeys.rawHotkeyToParsedHotkey)(resolvedHotkey, platform));
+		const hotkeyString = (0, _tanstack_hotkeys.normalizeRegisterableHotkey)(resolvedHotkey, mergedOptions.platform ?? (0, _tanstack_hotkeys.detectPlatform)());
 		const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
-		if (!resolvedTarget) return;
+		if (!resolvedTarget) {
+			if (registration?.isActive) {
+				registration.unregister();
+				registration = null;
+			}
+			lastHotkeyString = null;
+			lastTarget = null;
+			return;
+		}
+		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
+		if (registration?.isActive && lastHotkeyString === hotkeyString && lastTarget === resolvedTarget) {
+			registration.callback = callback;
+			registration.setOptions(optionsWithoutTarget);
+			return;
+		}
 		if (registration?.isActive) {
 			registration.unregister();
 			registration = null;
 		}
-		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
 		registration = manager.register(hotkeyString, callback, {
 			...optionsWithoutTarget,
 			target: resolvedTarget
@@ -86,12 +108,8 @@ function createHotkey(hotkey, callback, options = {}) {
 			registration.callback = callback;
 			registration.setOptions(optionsWithoutTarget);
 		}
-		(0, solid_js.onCleanup)(() => {
-			if (registration?.isActive) {
-				registration.unregister();
-				registration = null;
-			}
-		});
+		lastHotkeyString = hotkeyString;
+		lastTarget = resolvedTarget;
 	});
 }
 

package/dist/createHotkey.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createHotkey.cjs","names":["useDefaultHotkeysOptions"],"sources":["../src/createHotkey.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport {\n  detectPlatform,\n  formatHotkey,\n  getHotkeyManager,\n  rawHotkeyToParsedHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\nexport interface CreateHotkeyOptions extends Omit<HotkeyOptions, 'target'> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor (for reactive targets that become\n   * available after mount), or null. Defaults to document.\n   * When using scoped targets, pass an accessor: () => ({ target: elementSignal() })\n   * so the hotkey waits for the element to be attached before registering.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * SolidJS primitive for registering a keyboard hotkey.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * The callback receives both the keyboard event and a context object\n * containing the hotkey string and parsed hotkey.\n *\n * This primitive automatically tracks reactive dependencies and updates\n * the registration when options or the callback change.\n *\n * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior\n *\n * @example\n * ```tsx\n * function SaveButton() {\n *   const [count, setCount] = createSignal(0)\n *\n *   // Callback always has access to latest count value\n *   createHotkey('Mod+S', (event, { hotkey }) => {\n *     console.log(`Save triggered, count is ${count()}`)\n *     handleSave()\n *   })\n *\n *   return <button onClick={() => setCount(c => c + 1)}>Count: {count()}</button>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Modal(props) {\n *   // enabled option is reactive\n *   createHotkey('Escape', () => {\n *     props.onClose()\n *   }, () => ({ enabled: props.isOpen }))\n *\n *   return <Show when={props.isOpen}>\n *     <div class=\"modal\">...</div>\n *   </Show>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Editor() {\n *   const [editorRef, setEditorRef] = createSignal<HTMLDivElement | null>(null)\n *\n *   // Scoped to a specific element - use accessor so hotkey waits for ref\n *   createHotkey('Mod+S', save, () => ({ target: editorRef() }))\n *\n *   return <div ref={setEditorRef}>...</div>\n * }\n * ```\n */\nexport function createHotkey(\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey),\n  callback: HotkeyCallback,\n  options: CreateHotkeyOptions | (() => CreateHotkeyOptions) = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  let registration: HotkeyRegistrationHandle | null = null\n\n  createEffect(() => {\n    // Resolve reactive values\n    const resolvedHotkey = typeof hotkey === 'function' ? hotkey() : hotkey\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkey,\n      ...resolvedOptions,\n    } as CreateHotkeyOptions\n\n    // Normalize to hotkey string\n    const platform = mergedOptions.platform ?? detectPlatform()\n    const hotkeyString: Hotkey =\n      typeof resolvedHotkey === 'string'\n        ? resolvedHotkey\n        : (formatHotkey(\n            rawHotkeyToParsedHotkey(resolvedHotkey, platform),\n          ) as Hotkey)\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches React's ref handling.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (!resolvedTarget) {\n      return\n    }\n\n    // Unregister previous registration if it exists\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n\n    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    // Register the hotkey\n    registration = manager.register(hotkeyString, callback, {\n      ...optionsWithoutTarget,\n      target: resolvedTarget,\n    })\n\n    // Update callback and options on every effect run\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    // Cleanup on disposal\n    onCleanup(() => {\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n    })\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,SAAgB,aACd,QACA,UACA,UAA6D,EAAE,EACzD;CACN,MAAM,iBAAiBA,kDAA0B;CACjD,MAAM,mDAA4B;CAElC,IAAI,eAAgD;AAEpD,kCAAmB;EAEjB,MAAM,iBAAiB,OAAO,WAAW,aAAa,QAAQ,GAAG;EACjE,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAGD,MAAM,WAAW,cAAc,mDAA4B;EAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,oGAE0B,gBAAgB,SAAS,CAClD;EAIP,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,eACH;AAIF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;EAIjB,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAGrD,iBAAe,QAAQ,SAAS,cAAc,UAAU;GACtD,GAAG;GACH,QAAQ;GACT,CAAC;AAGF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAI/C,gCAAgB;AACd,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;IAEjB;GACF"}
+{"version":3,"file":"createHotkey.cjs","names":["useDefaultHotkeysOptions"],"sources":["../src/createHotkey.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport {\n  detectPlatform,\n  getHotkeyManager,\n  normalizeRegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\nexport interface CreateHotkeyOptions extends Omit<HotkeyOptions, 'target'> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor (for reactive targets that become\n   * available after mount), or null. Defaults to document.\n   * When using scoped targets, pass an accessor: () => ({ target: elementSignal() })\n   * so the hotkey waits for the element to be attached before registering.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * SolidJS primitive for registering a keyboard hotkey.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * The callback receives both the keyboard event and a context object\n * containing the hotkey string and parsed hotkey.\n *\n * This primitive automatically tracks reactive dependencies and updates\n * the registration when options or the callback change.\n *\n * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior\n *\n * @example\n * ```tsx\n * function SaveButton() {\n *   const [count, setCount] = createSignal(0)\n *\n *   // Callback always has access to latest count value\n *   createHotkey('Mod+S', (event, { hotkey }) => {\n *     console.log(`Save triggered, count is ${count()}`)\n *     handleSave()\n *   })\n *\n *   return <button onClick={() => setCount(c => c + 1)}>Count: {count()}</button>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Modal(props) {\n *   // enabled option is reactive\n *   createHotkey('Escape', () => {\n *     props.onClose()\n *   }, () => ({ enabled: props.isOpen }))\n *\n *   return <Show when={props.isOpen}>\n *     <div class=\"modal\">...</div>\n *   </Show>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Editor() {\n *   const [editorRef, setEditorRef] = createSignal<HTMLDivElement | null>(null)\n *\n *   // Scoped to a specific element - use accessor so hotkey waits for ref\n *   createHotkey('Mod+S', save, () => ({ target: editorRef() }))\n *\n *   return <div ref={setEditorRef}>...</div>\n * }\n * ```\n */\nexport function createHotkey(\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey),\n  callback: HotkeyCallback,\n  options: CreateHotkeyOptions | (() => CreateHotkeyOptions) = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  let registration: HotkeyRegistrationHandle | null = null\n  let lastHotkeyString: Hotkey | null = null\n  let lastTarget: HTMLElement | Document | Window | null = null\n\n  onCleanup(() => {\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n    lastHotkeyString = null\n    lastTarget = null\n  })\n\n  createEffect(() => {\n    // Resolve reactive values\n    const resolvedHotkey = typeof hotkey === 'function' ? hotkey() : hotkey\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkey,\n      ...resolvedOptions,\n    } as CreateHotkeyOptions\n\n    // Normalize to hotkey string\n    const platform = mergedOptions.platform ?? detectPlatform()\n    const hotkeyString = normalizeRegisterableHotkey(resolvedHotkey, platform)\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches React's ref handling.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (!resolvedTarget) {\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n      lastHotkeyString = null\n      lastTarget = null\n      return\n    }\n\n    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    if (\n      registration?.isActive &&\n      lastHotkeyString === hotkeyString &&\n      lastTarget === resolvedTarget\n    ) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n      return\n    }\n\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n\n    registration = manager.register(hotkeyString, callback, {\n      ...optionsWithoutTarget,\n      target: resolvedTarget,\n    })\n\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    lastHotkeyString = hotkeyString\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiFA,SAAgB,aACd,QACA,UACA,UAA6D,EAAE,EACzD;CACN,MAAM,iBAAiBA,kDAA0B;CACjD,MAAM,mDAA4B;CAElC,IAAI,eAAgD;CACpD,IAAI,mBAAkC;CACtC,IAAI,aAAqD;AAEzD,+BAAgB;AACd,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAEjB,qBAAmB;AACnB,eAAa;GACb;AAEF,kCAAmB;EAEjB,MAAM,iBAAiB,OAAO,WAAW,aAAa,QAAQ,GAAG;EACjE,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAID,MAAM,kEAA2C,gBADhC,cAAc,mDAA4B,CACe;EAI1E,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,gBAAgB;AACnB,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,sBAAmB;AACnB,gBAAa;AACb;;EAIF,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,MACE,cAAc,YACd,qBAAqB,gBACrB,eAAe,gBACf;AACA,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;AAC7C;;AAGF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAGjB,iBAAe,QAAQ,SAAS,cAAc,UAAU;GACtD,GAAG;GACH,QAAQ;GACT,CAAC;AAEF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAG/C,qBAAmB;AACnB,eAAa;GACb"}

package/dist/createHotkey.js

@@ -1,5 +1,5 @@
 import { useDefaultHotkeysOptions } from "./HotkeysProvider.js";
-import { detectPlatform, formatHotkey, getHotkeyManager, rawHotkeyToParsedHotkey } from "@tanstack/hotkeys";
+import { detectPlatform, getHotkeyManager, normalizeRegisterableHotkey } from "@tanstack/hotkeys";
 import { createEffect, onCleanup } from "solid-js";
 
 //#region src/createHotkey.ts
@@ -62,6 +62,16 @@ function createHotkey(hotkey, callback, options = {}) {
 	const defaultOptions = useDefaultHotkeysOptions();
 	const manager = getHotkeyManager();
 	let registration = null;
+	let lastHotkeyString = null;
+	let lastTarget = null;
+	onCleanup(() => {
+		if (registration?.isActive) {
+			registration.unregister();
+			registration = null;
+		}
+		lastHotkeyString = null;
+		lastTarget = null;
+	});
 	createEffect(() => {
 		const resolvedHotkey = typeof hotkey === "function" ? hotkey() : hotkey;
 		const resolvedOptions = typeof options === "function" ? options() : options;
@@ -69,15 +79,27 @@ function createHotkey(hotkey, callback, options = {}) {
 			...defaultOptions.hotkey,
 			...resolvedOptions
 		};
-		const platform = mergedOptions.platform ?? detectPlatform();
-		const hotkeyString = typeof resolvedHotkey === "string" ? resolvedHotkey : formatHotkey(rawHotkeyToParsedHotkey(resolvedHotkey, platform));
+		const hotkeyString = normalizeRegisterableHotkey(resolvedHotkey, mergedOptions.platform ?? detectPlatform());
 		const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
-		if (!resolvedTarget) return;
+		if (!resolvedTarget) {
+			if (registration?.isActive) {
+				registration.unregister();
+				registration = null;
+			}
+			lastHotkeyString = null;
+			lastTarget = null;
+			return;
+		}
+		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
+		if (registration?.isActive && lastHotkeyString === hotkeyString && lastTarget === resolvedTarget) {
+			registration.callback = callback;
+			registration.setOptions(optionsWithoutTarget);
+			return;
+		}
 		if (registration?.isActive) {
 			registration.unregister();
 			registration = null;
 		}
-		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
 		registration = manager.register(hotkeyString, callback, {
 			...optionsWithoutTarget,
 			target: resolvedTarget
@@ -86,12 +108,8 @@ function createHotkey(hotkey, callback, options = {}) {
 			registration.callback = callback;
 			registration.setOptions(optionsWithoutTarget);
 		}
-		onCleanup(() => {
-			if (registration?.isActive) {
-				registration.unregister();
-				registration = null;
-			}
-		});
+		lastHotkeyString = hotkeyString;
+		lastTarget = resolvedTarget;
 	});
 }
 

package/dist/createHotkey.js.map

@@ -1 +1 @@
-{"version":3,"file":"createHotkey.js","names":[],"sources":["../src/createHotkey.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport {\n  detectPlatform,\n  formatHotkey,\n  getHotkeyManager,\n  rawHotkeyToParsedHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\nexport interface CreateHotkeyOptions extends Omit<HotkeyOptions, 'target'> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor (for reactive targets that become\n   * available after mount), or null. Defaults to document.\n   * When using scoped targets, pass an accessor: () => ({ target: elementSignal() })\n   * so the hotkey waits for the element to be attached before registering.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * SolidJS primitive for registering a keyboard hotkey.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * The callback receives both the keyboard event and a context object\n * containing the hotkey string and parsed hotkey.\n *\n * This primitive automatically tracks reactive dependencies and updates\n * the registration when options or the callback change.\n *\n * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior\n *\n * @example\n * ```tsx\n * function SaveButton() {\n *   const [count, setCount] = createSignal(0)\n *\n *   // Callback always has access to latest count value\n *   createHotkey('Mod+S', (event, { hotkey }) => {\n *     console.log(`Save triggered, count is ${count()}`)\n *     handleSave()\n *   })\n *\n *   return <button onClick={() => setCount(c => c + 1)}>Count: {count()}</button>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Modal(props) {\n *   // enabled option is reactive\n *   createHotkey('Escape', () => {\n *     props.onClose()\n *   }, () => ({ enabled: props.isOpen }))\n *\n *   return <Show when={props.isOpen}>\n *     <div class=\"modal\">...</div>\n *   </Show>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Editor() {\n *   const [editorRef, setEditorRef] = createSignal<HTMLDivElement | null>(null)\n *\n *   // Scoped to a specific element - use accessor so hotkey waits for ref\n *   createHotkey('Mod+S', save, () => ({ target: editorRef() }))\n *\n *   return <div ref={setEditorRef}>...</div>\n * }\n * ```\n */\nexport function createHotkey(\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey),\n  callback: HotkeyCallback,\n  options: CreateHotkeyOptions | (() => CreateHotkeyOptions) = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  let registration: HotkeyRegistrationHandle | null = null\n\n  createEffect(() => {\n    // Resolve reactive values\n    const resolvedHotkey = typeof hotkey === 'function' ? hotkey() : hotkey\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkey,\n      ...resolvedOptions,\n    } as CreateHotkeyOptions\n\n    // Normalize to hotkey string\n    const platform = mergedOptions.platform ?? detectPlatform()\n    const hotkeyString: Hotkey =\n      typeof resolvedHotkey === 'string'\n        ? resolvedHotkey\n        : (formatHotkey(\n            rawHotkeyToParsedHotkey(resolvedHotkey, platform),\n          ) as Hotkey)\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches React's ref handling.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (!resolvedTarget) {\n      return\n    }\n\n    // Unregister previous registration if it exists\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n\n    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    // Register the hotkey\n    registration = manager.register(hotkeyString, callback, {\n      ...optionsWithoutTarget,\n      target: resolvedTarget,\n    })\n\n    // Update callback and options on every effect run\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    // Cleanup on disposal\n    onCleanup(() => {\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n    })\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,SAAgB,aACd,QACA,UACA,UAA6D,EAAE,EACzD;CACN,MAAM,iBAAiB,0BAA0B;CACjD,MAAM,UAAU,kBAAkB;CAElC,IAAI,eAAgD;AAEpD,oBAAmB;EAEjB,MAAM,iBAAiB,OAAO,WAAW,aAAa,QAAQ,GAAG;EACjE,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAGD,MAAM,WAAW,cAAc,YAAY,gBAAgB;EAC3D,MAAM,eACJ,OAAO,mBAAmB,WACtB,iBACC,aACC,wBAAwB,gBAAgB,SAAS,CAClD;EAIP,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,eACH;AAIF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;EAIjB,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAGrD,iBAAe,QAAQ,SAAS,cAAc,UAAU;GACtD,GAAG;GACH,QAAQ;GACT,CAAC;AAGF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAI/C,kBAAgB;AACd,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;IAEjB;GACF"}
+{"version":3,"file":"createHotkey.js","names":[],"sources":["../src/createHotkey.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport {\n  detectPlatform,\n  getHotkeyManager,\n  normalizeRegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyOptions,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\nexport interface CreateHotkeyOptions extends Omit<HotkeyOptions, 'target'> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor (for reactive targets that become\n   * available after mount), or null. Defaults to document.\n   * When using scoped targets, pass an accessor: () => ({ target: elementSignal() })\n   * so the hotkey waits for the element to be attached before registering.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * SolidJS primitive for registering a keyboard hotkey.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * The callback receives both the keyboard event and a context object\n * containing the hotkey string and parsed hotkey.\n *\n * This primitive automatically tracks reactive dependencies and updates\n * the registration when options or the callback change.\n *\n * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)\n * @param callback - The function to call when the hotkey is pressed\n * @param options - Options for the hotkey behavior\n *\n * @example\n * ```tsx\n * function SaveButton() {\n *   const [count, setCount] = createSignal(0)\n *\n *   // Callback always has access to latest count value\n *   createHotkey('Mod+S', (event, { hotkey }) => {\n *     console.log(`Save triggered, count is ${count()}`)\n *     handleSave()\n *   })\n *\n *   return <button onClick={() => setCount(c => c + 1)}>Count: {count()}</button>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Modal(props) {\n *   // enabled option is reactive\n *   createHotkey('Escape', () => {\n *     props.onClose()\n *   }, () => ({ enabled: props.isOpen }))\n *\n *   return <Show when={props.isOpen}>\n *     <div class=\"modal\">...</div>\n *   </Show>\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Editor() {\n *   const [editorRef, setEditorRef] = createSignal<HTMLDivElement | null>(null)\n *\n *   // Scoped to a specific element - use accessor so hotkey waits for ref\n *   createHotkey('Mod+S', save, () => ({ target: editorRef() }))\n *\n *   return <div ref={setEditorRef}>...</div>\n * }\n * ```\n */\nexport function createHotkey(\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey),\n  callback: HotkeyCallback,\n  options: CreateHotkeyOptions | (() => CreateHotkeyOptions) = {},\n): void {\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  let registration: HotkeyRegistrationHandle | null = null\n  let lastHotkeyString: Hotkey | null = null\n  let lastTarget: HTMLElement | Document | Window | null = null\n\n  onCleanup(() => {\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n    lastHotkeyString = null\n    lastTarget = null\n  })\n\n  createEffect(() => {\n    // Resolve reactive values\n    const resolvedHotkey = typeof hotkey === 'function' ? hotkey() : hotkey\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkey,\n      ...resolvedOptions,\n    } as CreateHotkeyOptions\n\n    // Normalize to hotkey string\n    const platform = mergedOptions.platform ?? detectPlatform()\n    const hotkeyString = normalizeRegisterableHotkey(resolvedHotkey, platform)\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches React's ref handling.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (!resolvedTarget) {\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n      lastHotkeyString = null\n      lastTarget = null\n      return\n    }\n\n    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    if (\n      registration?.isActive &&\n      lastHotkeyString === hotkeyString &&\n      lastTarget === resolvedTarget\n    ) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n      return\n    }\n\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n\n    registration = manager.register(hotkeyString, callback, {\n      ...optionsWithoutTarget,\n      target: resolvedTarget,\n    })\n\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    lastHotkeyString = hotkeyString\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiFA,SAAgB,aACd,QACA,UACA,UAA6D,EAAE,EACzD;CACN,MAAM,iBAAiB,0BAA0B;CACjD,MAAM,UAAU,kBAAkB;CAElC,IAAI,eAAgD;CACpD,IAAI,mBAAkC;CACtC,IAAI,aAAqD;AAEzD,iBAAgB;AACd,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAEjB,qBAAmB;AACnB,eAAa;GACb;AAEF,oBAAmB;EAEjB,MAAM,iBAAiB,OAAO,WAAW,aAAa,QAAQ,GAAG;EACjE,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAID,MAAM,eAAe,4BAA4B,gBADhC,cAAc,YAAY,gBAAgB,CACe;EAI1E,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,gBAAgB;AACnB,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,sBAAmB;AACnB,gBAAa;AACb;;EAIF,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,MACE,cAAc,YACd,qBAAqB,gBACrB,eAAe,gBACf;AACA,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;AAC7C;;AAGF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAGjB,iBAAe,QAAQ,SAAS,cAAc,UAAU;GACtD,GAAG;GACH,QAAQ;GACT,CAAC;AAEF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAG/C,qBAAmB;AACnB,eAAa;GACb"}

package/dist/createHotkeySequence.cjs

@@ -49,6 +49,16 @@ function createHotkeySequence(sequence, callback, options = {}) {
 	const defaultOptions = require_HotkeysProvider.useDefaultHotkeysOptions();
 	const manager = (0, _tanstack_hotkeys.getSequenceManager)();
 	let registration = null;
+	let lastSequenceKey = null;
+	let lastTarget = null;
+	(0, solid_js.onCleanup)(() => {
+		if (registration?.isActive) {
+			registration.unregister();
+			registration = null;
+		}
+		lastSequenceKey = null;
+		lastTarget = null;
+	});
 	(0, solid_js.createEffect)(() => {
 		const resolvedSequence = typeof sequence === "function" ? sequence() : sequence;
 		const resolvedOptions = typeof options === "function" ? options() : options;
@@ -57,9 +67,22 @@ function createHotkeySequence(sequence, callback, options = {}) {
 			...resolvedOptions
 		};
 		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-		if (resolvedSequence.length === 0) return;
 		const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
-		if (!resolvedTarget) return;
+		if (resolvedSequence.length === 0 || !resolvedTarget) {
+			if (registration?.isActive) {
+				registration.unregister();
+				registration = null;
+			}
+			lastSequenceKey = null;
+			lastTarget = null;
+			return;
+		}
+		const sequenceKey = (0, _tanstack_hotkeys.formatHotkeySequence)(resolvedSequence);
+		if (registration?.isActive && lastSequenceKey === sequenceKey && lastTarget === resolvedTarget) {
+			registration.callback = callback;
+			registration.setOptions(optionsWithoutTarget);
+			return;
+		}
 		if (registration?.isActive) {
 			registration.unregister();
 			registration = null;
@@ -72,12 +95,8 @@ function createHotkeySequence(sequence, callback, options = {}) {
 			registration.callback = callback;
 			registration.setOptions(optionsWithoutTarget);
 		}
-		(0, solid_js.onCleanup)(() => {
-			if (registration?.isActive) {
-				registration.unregister();
-				registration = null;
-			}
-		});
+		lastSequenceKey = sequenceKey;
+		lastTarget = resolvedTarget;
 	});
 }
 

package/dist/createHotkeySequence.cjs.map

@@ -1 +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  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\nexport interface CreateHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'target'\n> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor, or null. Defaults to document.\n   */\n  target?: HTMLElement | Document | Window | null\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 * Each step may include modifiers. You can chain the same modifier across\n * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,\n * Control, Alt, or Meta pressed alone) are ignored while matching—they do not\n * advance the sequence or reset progress.\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 *   // Same modifier on consecutive steps (bare Shift between chords is ignored)\n *   createHotkeySequence(['Shift+R', 'Shift+T'], () => {\n *     nextAction()\n *   })\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  const manager = getSequenceManager()\n\n  let registration: SequenceRegistrationHandle | null = null\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    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    if (resolvedSequence.length === 0) {\n      return\n    }\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches createHotkey.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (!resolvedTarget) {\n      return\n    }\n\n    // Unregister previous registration if it exists\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n\n    // Register the sequence\n    registration = manager.register(resolvedSequence, callback, {\n      ...mergedOptions,\n      target: resolvedTarget,\n    })\n\n    // Sync callback and options on every effect run\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    // Cleanup on disposal\n    onCleanup(() => {\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n    })\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiBA,kDAA0B;CACjD,MAAM,qDAA8B;CAEpC,IAAI,eAAkD;AAEtD,kCAAmB;EAEjB,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAGD,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,MAAI,iBAAiB,WAAW,EAC9B;EAKF,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,eACH;AAIF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAIjB,iBAAe,QAAQ,SAAS,kBAAkB,UAAU;GAC1D,GAAG;GACH,QAAQ;GACT,CAAC;AAGF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAI/C,gCAAgB;AACd,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;IAEjB;GACF"}
+{"version":3,"file":"createHotkeySequence.cjs","names":["useDefaultHotkeysOptions"],"sources":["../src/createHotkeySequence.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\nexport interface CreateHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'target'\n> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor, or null. Defaults to document.\n   */\n  target?: HTMLElement | Document | Window | null\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 * Each step may include modifiers. You can chain the same modifier across\n * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,\n * Control, Alt, or Meta pressed alone) are ignored while matching—they do not\n * advance the sequence or reset progress.\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 *   // Same modifier on consecutive steps (bare Shift between chords is ignored)\n *   createHotkeySequence(['Shift+R', 'Shift+T'], () => {\n *     nextAction()\n *   })\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  const manager = getSequenceManager()\n\n  let registration: SequenceRegistrationHandle | null = null\n  let lastSequenceKey: string | null = null\n  let lastTarget: HTMLElement | Document | Window | null = null\n\n  onCleanup(() => {\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n    lastSequenceKey = null\n    lastTarget = null\n  })\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    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches createHotkey.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (resolvedSequence.length === 0 || !resolvedTarget) {\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n      lastSequenceKey = null\n      lastTarget = null\n      return\n    }\n\n    const sequenceKey = formatHotkeySequence(resolvedSequence)\n\n    if (\n      registration?.isActive &&\n      lastSequenceKey === sequenceKey &&\n      lastTarget === resolvedTarget\n    ) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n      return\n    }\n\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n\n    registration = manager.register(resolvedSequence, callback, {\n      ...mergedOptions,\n      target: resolvedTarget,\n    })\n\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    lastSequenceKey = sequenceKey\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiBA,kDAA0B;CACjD,MAAM,qDAA8B;CAEpC,IAAI,eAAkD;CACtD,IAAI,kBAAiC;CACrC,IAAI,aAAqD;AAEzD,+BAAgB;AACd,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAEjB,oBAAkB;AAClB,eAAa;GACb;AAEF,kCAAmB;EAEjB,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAGD,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;EAIrD,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,iBAAiB,WAAW,KAAK,CAAC,gBAAgB;AACpD,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,qBAAkB;AAClB,gBAAa;AACb;;EAGF,MAAM,0DAAmC,iBAAiB;AAE1D,MACE,cAAc,YACd,oBAAoB,eACpB,eAAe,gBACf;AACA,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;AAC7C;;AAGF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAGjB,iBAAe,QAAQ,SAAS,kBAAkB,UAAU;GAC1D,GAAG;GACH,QAAQ;GACT,CAAC;AAEF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAG/C,oBAAkB;AAClB,eAAa;GACb"}

package/dist/createHotkeySequence.js

@@ -1,5 +1,5 @@
 import { useDefaultHotkeysOptions } from "./HotkeysProvider.js";
-import { getSequenceManager } from "@tanstack/hotkeys";
+import { formatHotkeySequence, getSequenceManager } from "@tanstack/hotkeys";
 import { createEffect, onCleanup } from "solid-js";
 
 //#region src/createHotkeySequence.ts
@@ -49,6 +49,16 @@ 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;
@@ -57,9 +67,22 @@ function createHotkeySequence(sequence, callback, options = {}) {
 			...resolvedOptions
 		};
 		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-		if (resolvedSequence.length === 0) return;
 		const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
-		if (!resolvedTarget) return;
+		if (resolvedSequence.length === 0 || !resolvedTarget) {
+			if (registration?.isActive) {
+				registration.unregister();
+				registration = null;
+			}
+			lastSequenceKey = null;
+			lastTarget = null;
+			return;
+		}
+		const sequenceKey = formatHotkeySequence(resolvedSequence);
+		if (registration?.isActive && lastSequenceKey === sequenceKey && lastTarget === resolvedTarget) {
+			registration.callback = callback;
+			registration.setOptions(optionsWithoutTarget);
+			return;
+		}
 		if (registration?.isActive) {
 			registration.unregister();
 			registration = null;
@@ -72,12 +95,8 @@ function createHotkeySequence(sequence, callback, options = {}) {
 			registration.callback = callback;
 			registration.setOptions(optionsWithoutTarget);
 		}
-		onCleanup(() => {
-			if (registration?.isActive) {
-				registration.unregister();
-				registration = null;
-			}
-		});
+		lastSequenceKey = sequenceKey;
+		lastTarget = resolvedTarget;
 	});
 }
 

package/dist/createHotkeySequence.js.map

@@ -1 +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  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\nexport interface CreateHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'target'\n> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor, or null. Defaults to document.\n   */\n  target?: HTMLElement | Document | Window | null\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 * Each step may include modifiers. You can chain the same modifier across\n * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,\n * Control, Alt, or Meta pressed alone) are ignored while matching—they do not\n * advance the sequence or reset progress.\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 *   // Same modifier on consecutive steps (bare Shift between chords is ignored)\n *   createHotkeySequence(['Shift+R', 'Shift+T'], () => {\n *     nextAction()\n *   })\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  const manager = getSequenceManager()\n\n  let registration: SequenceRegistrationHandle | null = null\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    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    if (resolvedSequence.length === 0) {\n      return\n    }\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches createHotkey.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (!resolvedTarget) {\n      return\n    }\n\n    // Unregister previous registration if it exists\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n\n    // Register the sequence\n    registration = manager.register(resolvedSequence, callback, {\n      ...mergedOptions,\n      target: resolvedTarget,\n    })\n\n    // Sync callback and options on every effect run\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    // Cleanup on disposal\n    onCleanup(() => {\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n    })\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiB,0BAA0B;CACjD,MAAM,UAAU,oBAAoB;CAEpC,IAAI,eAAkD;AAEtD,oBAAmB;EAEjB,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAGD,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,MAAI,iBAAiB,WAAW,EAC9B;EAKF,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,CAAC,eACH;AAIF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAIjB,iBAAe,QAAQ,SAAS,kBAAkB,UAAU;GAC1D,GAAG;GACH,QAAQ;GACT,CAAC;AAGF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAI/C,kBAAgB;AACd,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;IAEjB;GACF"}
+{"version":3,"file":"createHotkeySequence.js","names":[],"sources":["../src/createHotkeySequence.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\nexport interface CreateHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'target'\n> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor, or null. Defaults to document.\n   */\n  target?: HTMLElement | Document | Window | null\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 * Each step may include modifiers. You can chain the same modifier across\n * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,\n * Control, Alt, or Meta pressed alone) are ignored while matching—they do not\n * advance the sequence or reset progress.\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 *   // Same modifier on consecutive steps (bare Shift between chords is ignored)\n *   createHotkeySequence(['Shift+R', 'Shift+T'], () => {\n *     nextAction()\n *   })\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  const manager = getSequenceManager()\n\n  let registration: SequenceRegistrationHandle | null = null\n  let lastSequenceKey: string | null = null\n  let lastTarget: HTMLElement | Document | Window | null = null\n\n  onCleanup(() => {\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n    lastSequenceKey = null\n    lastTarget = null\n  })\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    // Extract options without target (target is handled separately)\n    const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n    // Resolve target: when explicitly provided (even as null), use it and skip if null.\n    // When not provided, default to document. Matches createHotkey.\n    const resolvedTarget =\n      'target' in mergedOptions\n        ? (mergedOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (resolvedSequence.length === 0 || !resolvedTarget) {\n      if (registration?.isActive) {\n        registration.unregister()\n        registration = null\n      }\n      lastSequenceKey = null\n      lastTarget = null\n      return\n    }\n\n    const sequenceKey = formatHotkeySequence(resolvedSequence)\n\n    if (\n      registration?.isActive &&\n      lastSequenceKey === sequenceKey &&\n      lastTarget === resolvedTarget\n    ) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n      return\n    }\n\n    if (registration?.isActive) {\n      registration.unregister()\n      registration = null\n    }\n\n    registration = manager.register(resolvedSequence, callback, {\n      ...mergedOptions,\n      target: resolvedTarget,\n    })\n\n    if (registration.isActive) {\n      registration.callback = callback\n      registration.setOptions(optionsWithoutTarget)\n    }\n\n    lastSequenceKey = sequenceKey\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiB,0BAA0B;CACjD,MAAM,UAAU,oBAAoB;CAEpC,IAAI,eAAkD;CACtD,IAAI,kBAAiC;CACrC,IAAI,aAAqD;AAEzD,iBAAgB;AACd,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAEjB,oBAAkB;AAClB,eAAa;GACb;AAEF,oBAAmB;EAEjB,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAEpE,MAAM,gBAAgB;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAGD,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;EAIrD,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,MAAI,iBAAiB,WAAW,KAAK,CAAC,gBAAgB;AACpD,OAAI,cAAc,UAAU;AAC1B,iBAAa,YAAY;AACzB,mBAAe;;AAEjB,qBAAkB;AAClB,gBAAa;AACb;;EAGF,MAAM,cAAc,qBAAqB,iBAAiB;AAE1D,MACE,cAAc,YACd,oBAAoB,eACpB,eAAe,gBACf;AACA,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;AAC7C;;AAGF,MAAI,cAAc,UAAU;AAC1B,gBAAa,YAAY;AACzB,kBAAe;;AAGjB,iBAAe,QAAQ,SAAS,kBAAkB,UAAU;GAC1D,GAAG;GACH,QAAQ;GACT,CAAC;AAEF,MAAI,aAAa,UAAU;AACzB,gBAAa,WAAW;AACxB,gBAAa,WAAW,qBAAqB;;AAG/C,oBAAkB;AAClB,eAAa;GACb"}

package/dist/createHotkeySequences.cjs

@@ -0,0 +1,110 @@
+const require_HotkeysProvider = require('./HotkeysProvider.cjs');
+let _tanstack_hotkeys = require("@tanstack/hotkeys");
+let solid_js = require("solid-js");
+
+//#region src/createHotkeySequences.ts
+/**
+* SolidJS primitive for registering multiple keyboard shortcut sequences at once (Vim-style).
+*
+* Uses the singleton SequenceManager. Accepts a dynamic array of definitions, or accessors,
+* so you can react to variable-length lists.
+*
+* Options are merged in this order:
+* HotkeysProvider defaults < commonOptions < per-definition options
+*
+* Definitions with an empty `sequence` are skipped (no registration).
+*
+* @param sequences - Array of sequence definitions, or accessor returning them
+* @param commonOptions - Shared options for all sequences, or accessor
+*
+* @example
+* ```tsx
+* function VimPalette() {
+*   createHotkeySequences([
+*     { sequence: ['G', 'G'], callback: () => scrollToTop() },
+*     { sequence: ['D', 'D'], callback: () => deleteLine() },
+*   ])
+* }
+* ```
+*
+* @example
+* ```tsx
+* function Dynamic(props) {
+*   createHotkeySequences(
+*     () => props.items.map((item) => ({
+*       sequence: item.chords,
+*       callback: item.action,
+*       options: { enabled: item.enabled },
+*     })),
+*     { preventDefault: true },
+*   )
+* }
+* ```
+*/
+function createHotkeySequences(sequences, commonOptions = {}) {
+	const defaultOptions = require_HotkeysProvider.useDefaultHotkeysOptions();
+	const manager = (0, _tanstack_hotkeys.getSequenceManager)();
+	const registrations = /* @__PURE__ */ new Map();
+	(0, solid_js.onCleanup)(() => {
+		for (const { handle } of registrations.values()) if (handle.isActive) handle.unregister();
+		registrations.clear();
+	});
+	(0, solid_js.createEffect)(() => {
+		const resolved = typeof sequences === "function" ? sequences() : sequences;
+		const resolvedCommonOptions = typeof commonOptions === "function" ? commonOptions() : commonOptions;
+		const nextKeys = /* @__PURE__ */ new Set();
+		const prepared = [];
+		for (let i = 0; i < resolved.length; i++) {
+			const def = resolved[i];
+			const resolvedDefOptions = def.options ?? {};
+			const mergedOptions = {
+				...defaultOptions.hotkeySequence,
+				...resolvedCommonOptions,
+				...resolvedDefOptions
+			};
+			if (def.sequence.length === 0) continue;
+			const sequenceString = (0, _tanstack_hotkeys.formatHotkeySequence)(def.sequence);
+			const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
+			if (!resolvedTarget) continue;
+			const registrationKey = `${i}:${sequenceString}`;
+			nextKeys.add(registrationKey);
+			prepared.push({
+				registrationKey,
+				def,
+				mergedOptions,
+				sequenceString,
+				resolvedTarget
+			});
+		}
+		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.def.sequence, p.def.callback, {
+				...optionsWithoutTarget,
+				target: p.resolvedTarget
+			});
+			registrations.set(p.registrationKey, {
+				handle,
+				target: p.resolvedTarget
+			});
+		}
+	});
+}
+
+//#endregion
+exports.createHotkeySequences = createHotkeySequences;
+//# sourceMappingURL=createHotkeySequences.cjs.map

package/dist/createHotkeySequences.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHotkeySequences.cjs","names":["useDefaultHotkeysOptions"],"sources":["../src/createHotkeySequences.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type { CreateHotkeySequenceOptions } from './createHotkeySequence'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\n/**\n * A single sequence definition for use with `createHotkeySequences`.\n */\nexport interface CreateHotkeySequenceDefinition {\n  /** Array of hotkey strings that form the sequence */\n  sequence: HotkeySequence\n  /** The function to call when the sequence is completed */\n  callback: HotkeyCallback\n  /** Per-sequence options (merged on top of commonOptions) */\n  options?: CreateHotkeySequenceOptions\n}\n\n/**\n * SolidJS primitive for registering multiple keyboard shortcut sequences at once (Vim-style).\n *\n * Uses the singleton SequenceManager. Accepts a dynamic array of definitions, or accessors,\n * so you can react to variable-length lists.\n *\n * Options are merged in this order:\n * HotkeysProvider defaults < commonOptions < per-definition options\n *\n * Definitions with an empty `sequence` are skipped (no registration).\n *\n * @param sequences - Array of sequence definitions, or accessor returning them\n * @param commonOptions - Shared options for all sequences, or accessor\n *\n * @example\n * ```tsx\n * function VimPalette() {\n *   createHotkeySequences([\n *     { sequence: ['G', 'G'], callback: () => scrollToTop() },\n *     { sequence: ['D', 'D'], callback: () => deleteLine() },\n *   ])\n * }\n * ```\n *\n * @example\n * ```tsx\n * function Dynamic(props) {\n *   createHotkeySequences(\n *     () => props.items.map((item) => ({\n *       sequence: item.chords,\n *       callback: item.action,\n *       options: { enabled: item.enabled },\n *     })),\n *     { preventDefault: true },\n *   )\n * }\n * ```\n */\nexport function createHotkeySequences(\n  sequences:\n    | Array<CreateHotkeySequenceDefinition>\n    | (() => Array<CreateHotkeySequenceDefinition>),\n  commonOptions:\n    | CreateHotkeySequenceOptions\n    | (() => CreateHotkeySequenceOptions) = {},\n): void {\n  type RegistrationRecord = {\n    handle: SequenceRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n\n  const registrations = new Map<string, RegistrationRecord>()\n\n  onCleanup(() => {\n    for (const { handle } of registrations.values()) {\n      if (handle.isActive) {\n        handle.unregister()\n      }\n    }\n    registrations.clear()\n  })\n\n  createEffect(() => {\n    const resolved = typeof sequences === 'function' ? sequences() : sequences\n    const resolvedCommonOptions =\n      typeof commonOptions === 'function' ? commonOptions() : commonOptions\n\n    const nextKeys = new Set<string>()\n    const prepared: Array<{\n      registrationKey: string\n      def: CreateHotkeySequenceDefinition\n      mergedOptions: CreateHotkeySequenceOptions\n      sequenceString: string\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < resolved.length; i++) {\n      const def = resolved[i]!\n      const resolvedDefOptions = def.options ?? {}\n\n      const mergedOptions = {\n        ...defaultOptions.hotkeySequence,\n        ...resolvedCommonOptions,\n        ...resolvedDefOptions,\n      } as CreateHotkeySequenceOptions\n\n      if (def.sequence.length === 0) {\n        continue\n      }\n\n      const sequenceString = formatHotkeySequence(def.sequence)\n\n      const resolvedTarget =\n        'target' in mergedOptions\n          ? (mergedOptions.target ?? null)\n          : typeof document !== 'undefined'\n            ? document\n            : null\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${sequenceString}`\n      nextKeys.add(registrationKey)\n      prepared.push({\n        registrationKey,\n        def,\n        mergedOptions,\n        sequenceString,\n        resolvedTarget,\n      })\n    }\n\n    for (const [key, record] of [...registrations.entries()]) {\n      if (!nextKeys.has(key)) {\n        if (record.handle.isActive) {\n          record.handle.unregister()\n        }\n        registrations.delete(key)\n      }\n    }\n\n    for (const p of prepared) {\n      const existing = registrations.get(p.registrationKey)\n      if (existing?.handle.isActive && existing.target === p.resolvedTarget) {\n        existing.handle.callback = p.def.callback\n        const { target: _target, ...optionsWithoutTarget } = p.mergedOptions\n        existing.handle.setOptions(optionsWithoutTarget)\n        continue\n      }\n\n      if (existing) {\n        if (existing.handle.isActive) {\n          existing.handle.unregister()\n        }\n        registrations.delete(p.registrationKey)\n      }\n\n      const { target: _target, ...optionsWithoutTarget } = p.mergedOptions\n      const handle = manager.register(p.def.sequence, p.def.callback, {\n        ...optionsWithoutTarget,\n        target: p.resolvedTarget,\n      })\n      registrations.set(p.registrationKey, {\n        handle,\n        target: p.resolvedTarget,\n      })\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,SAAgB,sBACd,WAGA,gBAE0C,EAAE,EACtC;CAMN,MAAM,iBAAiBA,kDAA0B;CACjD,MAAM,qDAA8B;CAEpC,MAAM,gCAAgB,IAAI,KAAiC;AAE3D,+BAAgB;AACd,OAAK,MAAM,EAAE,YAAY,cAAc,QAAQ,CAC7C,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,gBAAc,OAAO;GACrB;AAEF,kCAAmB;EACjB,MAAM,WAAW,OAAO,cAAc,aAAa,WAAW,GAAG;EACjE,MAAM,wBACJ,OAAO,kBAAkB,aAAa,eAAe,GAAG;EAE1D,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAMD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;GACxC,MAAM,MAAM,SAAS;GACrB,MAAM,qBAAqB,IAAI,WAAW,EAAE;GAE5C,MAAM,gBAAgB;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;AAED,OAAI,IAAI,SAAS,WAAW,EAC1B;GAGF,MAAM,6DAAsC,IAAI,SAAS;GAEzD,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,GAAG;AAChC,YAAS,IAAI,gBAAgB;AAC7B,YAAS,KAAK;IACZ;IACA;IACA;IACA;IACA;IACD,CAAC;;AAGJ,OAAK,MAAM,CAAC,KAAK,WAAW,CAAC,GAAG,cAAc,SAAS,CAAC,CACtD,KAAI,CAAC,SAAS,IAAI,IAAI,EAAE;AACtB,OAAI,OAAO,OAAO,SAChB,QAAO,OAAO,YAAY;AAE5B,iBAAc,OAAO,IAAI;;AAI7B,OAAK,MAAM,KAAK,UAAU;GACxB,MAAM,WAAW,cAAc,IAAI,EAAE,gBAAgB;AACrD,OAAI,UAAU,OAAO,YAAY,SAAS,WAAW,EAAE,gBAAgB;AACrE,aAAS,OAAO,WAAW,EAAE,IAAI;IACjC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;AACvD,aAAS,OAAO,WAAW,qBAAqB;AAChD;;AAGF,OAAI,UAAU;AACZ,QAAI,SAAS,OAAO,SAClB,UAAS,OAAO,YAAY;AAE9B,kBAAc,OAAO,EAAE,gBAAgB;;GAGzC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;GACvD,MAAM,SAAS,QAAQ,SAAS,EAAE,IAAI,UAAU,EAAE,IAAI,UAAU;IAC9D,GAAG;IACH,QAAQ,EAAE;IACX,CAAC;AACF,iBAAc,IAAI,EAAE,iBAAiB;IACnC;IACA,QAAQ,EAAE;IACX,CAAC;;GAEJ"}

package/dist/createHotkeySequences.d.cts

@@ -0,0 +1,57 @@
+import { CreateHotkeySequenceOptions } from "./createHotkeySequence.cjs";
+import { HotkeyCallback, HotkeySequence } from "@tanstack/hotkeys";
+
+//#region src/createHotkeySequences.d.ts
+/**
+ * A single sequence definition for use with `createHotkeySequences`.
+ */
+interface CreateHotkeySequenceDefinition {
+  /** Array of hotkey strings that form the sequence */
+  sequence: HotkeySequence;
+  /** The function to call when the sequence is completed */
+  callback: HotkeyCallback;
+  /** Per-sequence options (merged on top of commonOptions) */
+  options?: CreateHotkeySequenceOptions;
+}
+/**
+ * SolidJS primitive for registering multiple keyboard shortcut sequences at once (Vim-style).
+ *
+ * Uses the singleton SequenceManager. Accepts a dynamic array of definitions, or accessors,
+ * so you can react to variable-length lists.
+ *
+ * Options are merged in this order:
+ * HotkeysProvider defaults < commonOptions < per-definition options
+ *
+ * Definitions with an empty `sequence` are skipped (no registration).
+ *
+ * @param sequences - Array of sequence definitions, or accessor returning them
+ * @param commonOptions - Shared options for all sequences, or accessor
+ *
+ * @example
+ * ```tsx
+ * function VimPalette() {
+ *   createHotkeySequences([
+ *     { sequence: ['G', 'G'], callback: () => scrollToTop() },
+ *     { sequence: ['D', 'D'], callback: () => deleteLine() },
+ *   ])
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function Dynamic(props) {
+ *   createHotkeySequences(
+ *     () => props.items.map((item) => ({
+ *       sequence: item.chords,
+ *       callback: item.action,
+ *       options: { enabled: item.enabled },
+ *     })),
+ *     { preventDefault: true },
+ *   )
+ * }
+ * ```
+ */
+declare function createHotkeySequences(sequences: Array<CreateHotkeySequenceDefinition> | (() => Array<CreateHotkeySequenceDefinition>), commonOptions?: CreateHotkeySequenceOptions | (() => CreateHotkeySequenceOptions)): void;
+//#endregion
+export { CreateHotkeySequenceDefinition, createHotkeySequences };
+//# sourceMappingURL=createHotkeySequences.d.cts.map

package/dist/createHotkeySequences.d.ts

@@ -0,0 +1,57 @@
+import { CreateHotkeySequenceOptions } from "./createHotkeySequence.js";
+import { HotkeyCallback, HotkeySequence } from "@tanstack/hotkeys";
+
+//#region src/createHotkeySequences.d.ts
+/**
+ * A single sequence definition for use with `createHotkeySequences`.
+ */
+interface CreateHotkeySequenceDefinition {
+  /** Array of hotkey strings that form the sequence */
+  sequence: HotkeySequence;
+  /** The function to call when the sequence is completed */
+  callback: HotkeyCallback;
+  /** Per-sequence options (merged on top of commonOptions) */
+  options?: CreateHotkeySequenceOptions;
+}
+/**
+ * SolidJS primitive for registering multiple keyboard shortcut sequences at once (Vim-style).
+ *
+ * Uses the singleton SequenceManager. Accepts a dynamic array of definitions, or accessors,
+ * so you can react to variable-length lists.
+ *
+ * Options are merged in this order:
+ * HotkeysProvider defaults < commonOptions < per-definition options
+ *
+ * Definitions with an empty `sequence` are skipped (no registration).
+ *
+ * @param sequences - Array of sequence definitions, or accessor returning them
+ * @param commonOptions - Shared options for all sequences, or accessor
+ *
+ * @example
+ * ```tsx
+ * function VimPalette() {
+ *   createHotkeySequences([
+ *     { sequence: ['G', 'G'], callback: () => scrollToTop() },
+ *     { sequence: ['D', 'D'], callback: () => deleteLine() },
+ *   ])
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function Dynamic(props) {
+ *   createHotkeySequences(
+ *     () => props.items.map((item) => ({
+ *       sequence: item.chords,
+ *       callback: item.action,
+ *       options: { enabled: item.enabled },
+ *     })),
+ *     { preventDefault: true },
+ *   )
+ * }
+ * ```
+ */
+declare function createHotkeySequences(sequences: Array<CreateHotkeySequenceDefinition> | (() => Array<CreateHotkeySequenceDefinition>), commonOptions?: CreateHotkeySequenceOptions | (() => CreateHotkeySequenceOptions)): void;
+//#endregion
+export { CreateHotkeySequenceDefinition, createHotkeySequences };
+//# sourceMappingURL=createHotkeySequences.d.ts.map