@tanstack/solid-hotkeys 0.5.1 → 0.7.0

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

package/dist/createHotkeySequences.js

@@ -0,0 +1,110 @@
+import { useDefaultHotkeysOptions } from "./HotkeysProvider.js";
+import { formatHotkeySequence, getSequenceManager } from "@tanstack/hotkeys";
+import { createEffect, onCleanup } from "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 = useDefaultHotkeysOptions();
+	const manager = getSequenceManager();
+	const registrations = /* @__PURE__ */ new Map();
+	onCleanup(() => {
+		for (const { handle } of registrations.values()) if (handle.isActive) handle.unregister();
+		registrations.clear();
+	});
+	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 = 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
+export { createHotkeySequences };
+//# sourceMappingURL=createHotkeySequences.js.map

package/dist/createHotkeySequences.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHotkeySequences.js","names":[],"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,iBAAiB,0BAA0B;CACjD,MAAM,UAAU,oBAAoB;CAEpC,MAAM,gCAAgB,IAAI,KAAiC;AAE3D,iBAAgB;AACd,OAAK,MAAM,EAAE,YAAY,cAAc,QAAQ,CAC7C,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,gBAAc,OAAO;GACrB;AAEF,oBAAmB;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,iBAAiB,qBAAqB,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/index.cjs

@@ -6,7 +6,9 @@ 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_createHotkeySequences = require('./createHotkeySequences.cjs');
 const require_createHotkeyRecorder = require('./createHotkeyRecorder.cjs');
+const require_createHotkeySequenceRecorder = require('./createHotkeySequenceRecorder.cjs');
 
 exports.HotkeysProvider = require_HotkeysProvider.HotkeysProvider;
 exports.createHeldKeyCodes = require_createHeldKeyCodes.createHeldKeyCodes;
@@ -14,6 +16,8 @@ exports.createHeldKeys = require_createHeldKeys.createHeldKeys;
 exports.createHotkey = require_createHotkey.createHotkey;
 exports.createHotkeyRecorder = require_createHotkeyRecorder.createHotkeyRecorder;
 exports.createHotkeySequence = require_createHotkeySequence.createHotkeySequence;
+exports.createHotkeySequenceRecorder = require_createHotkeySequenceRecorder.createHotkeySequenceRecorder;
+exports.createHotkeySequences = require_createHotkeySequences.createHotkeySequences;
 exports.createHotkeys = require_createHotkeys.createHotkeys;
 exports.createKeyHold = require_createKeyHold.createKeyHold;
 exports.useDefaultHotkeysOptions = require_HotkeysProvider.useDefaultHotkeysOptions;

package/dist/index.d.cts

@@ -5,6 +5,8 @@ import { CreateHotkeyDefinition, createHotkeys } from "./createHotkeys.cjs";
 import { createHeldKeys } from "./createHeldKeys.cjs";
 import { createHeldKeyCodes } from "./createHeldKeyCodes.cjs";
 import { createKeyHold } from "./createKeyHold.cjs";
+import { CreateHotkeySequenceDefinition, createHotkeySequences } from "./createHotkeySequences.cjs";
 import { SolidHotkeyRecorder, createHotkeyRecorder } from "./createHotkeyRecorder.cjs";
+import { SolidHotkeySequenceRecorder, createHotkeySequenceRecorder } from "./createHotkeySequenceRecorder.cjs";
 export * from "@tanstack/hotkeys";
-export { CreateHotkeyDefinition, CreateHotkeyOptions, CreateHotkeySequenceOptions, HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, SolidHotkeyRecorder, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyRecorder, createHotkeySequence, createHotkeys, createKeyHold, useDefaultHotkeysOptions, useHotkeysContext };
+export { CreateHotkeyDefinition, CreateHotkeyOptions, CreateHotkeySequenceDefinition, CreateHotkeySequenceOptions, HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, SolidHotkeyRecorder, SolidHotkeySequenceRecorder, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyRecorder, createHotkeySequence, createHotkeySequenceRecorder, createHotkeySequences, createHotkeys, createKeyHold, useDefaultHotkeysOptions, useHotkeysContext };

package/dist/index.d.ts

@@ -5,6 +5,8 @@ import { CreateHotkeyDefinition, createHotkeys } from "./createHotkeys.js";
 import { createHeldKeys } from "./createHeldKeys.js";
 import { createHeldKeyCodes } from "./createHeldKeyCodes.js";
 import { createKeyHold } from "./createKeyHold.js";
+import { CreateHotkeySequenceDefinition, createHotkeySequences } from "./createHotkeySequences.js";
 import { SolidHotkeyRecorder, createHotkeyRecorder } from "./createHotkeyRecorder.js";
+import { SolidHotkeySequenceRecorder, createHotkeySequenceRecorder } from "./createHotkeySequenceRecorder.js";
 export * from "@tanstack/hotkeys";
-export { CreateHotkeyDefinition, CreateHotkeyOptions, CreateHotkeySequenceOptions, HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, SolidHotkeyRecorder, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyRecorder, createHotkeySequence, createHotkeys, createKeyHold, useDefaultHotkeysOptions, useHotkeysContext };
+export { CreateHotkeyDefinition, CreateHotkeyOptions, CreateHotkeySequenceDefinition, CreateHotkeySequenceOptions, HotkeysProvider, HotkeysProviderOptions, HotkeysProviderProps, SolidHotkeyRecorder, SolidHotkeySequenceRecorder, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyRecorder, createHotkeySequence, createHotkeySequenceRecorder, createHotkeySequences, createHotkeys, createKeyHold, useDefaultHotkeysOptions, useHotkeysContext };

package/dist/index.js

@@ -5,8 +5,10 @@ import { createHeldKeys } from "./createHeldKeys.js";
 import { createHeldKeyCodes } from "./createHeldKeyCodes.js";
 import { createKeyHold } from "./createKeyHold.js";
 import { createHotkeySequence } from "./createHotkeySequence.js";
+import { createHotkeySequences } from "./createHotkeySequences.js";
 import { createHotkeyRecorder } from "./createHotkeyRecorder.js";
+import { createHotkeySequenceRecorder } from "./createHotkeySequenceRecorder.js";
 
 export * from "@tanstack/hotkeys"
 
-export { HotkeysProvider, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyRecorder, createHotkeySequence, createHotkeys, createKeyHold, useDefaultHotkeysOptions, useHotkeysContext };
+export { HotkeysProvider, createHeldKeyCodes, createHeldKeys, createHotkey, createHotkeyRecorder, createHotkeySequence, createHotkeySequenceRecorder, createHotkeySequences, createHotkeys, createKeyHold, useDefaultHotkeysOptions, useHotkeysContext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-hotkeys",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "SolidJS adapter for TanStack Hotkeys",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -43,7 +43,7 @@
   ],
   "dependencies": {
     "@tanstack/solid-store": "^0.9.2",
-    "@tanstack/hotkeys": "0.4.3"
+    "@tanstack/hotkeys": "0.5.0"
   },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.10",

package/src/HotkeysProvider.tsx

@@ -1,12 +1,16 @@
 import { createContext, useContext } from 'solid-js'
 import type { JSX, ParentComponent } from 'solid-js'
-import type { HotkeyRecorderOptions } from '@tanstack/hotkeys'
+import type {
+  HotkeyRecorderOptions,
+  HotkeySequenceRecorderOptions,
+} from '@tanstack/hotkeys'
 import type { CreateHotkeyOptions } from './createHotkey'
 import type { CreateHotkeySequenceOptions } from './createHotkeySequence'
 
 export interface HotkeysProviderOptions {
   hotkey?: Partial<CreateHotkeyOptions>
   hotkeyRecorder?: Partial<HotkeyRecorderOptions>
+  hotkeySequenceRecorder?: Partial<HotkeySequenceRecorderOptions>
   hotkeySequence?: Partial<CreateHotkeySequenceOptions>
 }
 

package/src/createHotkey.ts

@@ -89,6 +89,17 @@ export function createHotkey(
   const manager = getHotkeyManager()
 
   let registration: HotkeyRegistrationHandle | null = null
+  let lastHotkeyString: Hotkey | null = null
+  let lastTarget: HTMLElement | Document | Window | null = null
+
+  onCleanup(() => {
+    if (registration?.isActive) {
+      registration.unregister()
+      registration = null
+    }
+    lastHotkeyString = null
+    lastTarget = null
+  })
 
   createEffect(() => {
     // Resolve reactive values
@@ -119,36 +130,44 @@ export function createHotkey(
           : null
 
     if (!resolvedTarget) {
+      if (registration?.isActive) {
+        registration.unregister()
+        registration = null
+      }
+      lastHotkeyString = null
+      lastTarget = null
+      return
+    }
+
+    // Extract options without target (target is handled separately)
+    const { target: _target, ...optionsWithoutTarget } = mergedOptions
+
+    if (
+      registration?.isActive &&
+      lastHotkeyString === hotkeyString &&
+      lastTarget === resolvedTarget
+    ) {
+      registration.callback = callback
+      registration.setOptions(optionsWithoutTarget)
       return
     }
 
-    // Unregister previous registration if it exists
     if (registration?.isActive) {
       registration.unregister()
       registration = null
     }
 
-    // Extract options without target (target is handled separately)
-    const { target: _target, ...optionsWithoutTarget } = mergedOptions
-
-    // Register the hotkey
     registration = manager.register(hotkeyString, callback, {
       ...optionsWithoutTarget,
       target: resolvedTarget,
     })
 
-    // Update callback and options on every effect run
     if (registration.isActive) {
       registration.callback = callback
       registration.setOptions(optionsWithoutTarget)
     }
 
-    // Cleanup on disposal
-    onCleanup(() => {
-      if (registration?.isActive) {
-        registration.unregister()
-        registration = null
-      }
-    })
+    lastHotkeyString = hotkeyString
+    lastTarget = resolvedTarget
   })
 }

package/src/createHotkeySequence.ts

@@ -1,5 +1,5 @@
 import { createEffect, onCleanup } from 'solid-js'
-import { getSequenceManager } from '@tanstack/hotkeys'
+import { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'
 import { useDefaultHotkeysOptions } from './HotkeysProvider'
 import type {
   HotkeyCallback,
@@ -72,6 +72,17 @@ export function createHotkeySequence(
   const manager = getSequenceManager()
 
   let registration: SequenceRegistrationHandle | null = null
+  let lastSequenceKey: string | null = null
+  let lastTarget: HTMLElement | Document | Window | null = null
+
+  onCleanup(() => {
+    if (registration?.isActive) {
+      registration.unregister()
+      registration = null
+    }
+    lastSequenceKey = null
+    lastTarget = null
+  })
 
   createEffect(() => {
     // Resolve reactive values
@@ -87,10 +98,6 @@ export function createHotkeySequence(
     // Extract options without target (target is handled separately)
     const { target: _target, ...optionsWithoutTarget } = mergedOptions
 
-    if (resolvedSequence.length === 0) {
-      return
-    }
-
     // Resolve target: when explicitly provided (even as null), use it and skip if null.
     // When not provided, default to document. Matches createHotkey.
     const resolvedTarget =
@@ -100,34 +107,44 @@ export function createHotkeySequence(
           ? document
           : null
 
-    if (!resolvedTarget) {
+    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
     }
 
-    // Unregister previous registration if it exists
     if (registration?.isActive) {
       registration.unregister()
       registration = null
     }
 
-    // Register the sequence
     registration = manager.register(resolvedSequence, callback, {
       ...mergedOptions,
       target: resolvedTarget,
     })
 
-    // Sync callback and options on every effect run
     if (registration.isActive) {
       registration.callback = callback
       registration.setOptions(optionsWithoutTarget)
     }
 
-    // Cleanup on disposal
-    onCleanup(() => {
-      if (registration?.isActive) {
-        registration.unregister()
-        registration = null
-      }
-    })
+    lastSequenceKey = sequenceKey
+    lastTarget = resolvedTarget
   })
 }