@tanstack/preact-hotkeys 0.11.0 → 0.12.1

package/dist/useHotkeySequence.cjs

@@ -1,120 +0,0 @@
-const require_HotkeysProvider = require('./HotkeysProvider.cjs');
-const require_utils = require('./utils.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let preact_hooks = require("preact/hooks");
-
-//#region src/useHotkeySequence.ts
-/**
-* Preact hook for registering a keyboard shortcut sequence (Vim-style).
-*
-* This hook allows you to register multi-key sequences like 'g g' or 'd d'
-* that trigger when the full sequence is pressed within a timeout.
-*
-* Each step may include modifiers. You can chain the same modifier across
-* steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
-* Control, Alt, or Meta pressed alone) are ignored while matching—they do not
-* advance the sequence or reset progress.
-*
-* @param sequence - Array of hotkey strings that form the sequence
-* @param callback - Function to call when the sequence is completed
-* @param options - Options for the sequence behavior. `enabled: false` keeps the registration (visible in devtools)
-*   and only suppresses firing; the hook updates the existing handle instead of unregistering.
-*
-* @example
-* ```tsx
-* function VimEditor() {
-*   // 'g g' to go to top
-*   useHotkeySequence(['G', 'G'], () => {
-*     scrollToTop()
-*   })
-*
-*   // 'd d' to delete line
-*   useHotkeySequence(['D', 'D'], () => {
-*     deleteLine()
-*   })
-*
-*   // 'd i w' to delete inner word
-*   useHotkeySequence(['D', 'I', 'W'], () => {
-*     deleteInnerWord()
-*   }, { timeout: 500 })
-*
-*   // Same modifier on consecutive steps (bare Shift between chords is ignored)
-*   useHotkeySequence(['Shift+R', 'Shift+T'], () => {
-*     nextAction()
-*   })
-*
-*   return <div>...</div>
-* }
-* ```
-*/
-function useHotkeySequence(sequence, callback, options = {}) {
-	const mergedOptions = {
-		...require_HotkeysProvider.useDefaultHotkeysOptions().hotkeySequence,
-		...options
-	};
-	const manager = (0, _tanstack_hotkeys.getSequenceManager)();
-	const registrationRef = (0, preact_hooks.useRef)(null);
-	const callbackRef = (0, preact_hooks.useRef)(callback);
-	const optionsRef = (0, preact_hooks.useRef)(mergedOptions);
-	const managerRef = (0, preact_hooks.useRef)(manager);
-	const sequenceRef = (0, preact_hooks.useRef)(sequence);
-	callbackRef.current = callback;
-	optionsRef.current = mergedOptions;
-	managerRef.current = manager;
-	sequenceRef.current = sequence;
-	const prevTargetRef = (0, preact_hooks.useRef)(null);
-	const prevSequenceRef = (0, preact_hooks.useRef)(null);
-	const hotkeySequenceString = (0, _tanstack_hotkeys.formatHotkeySequence)(sequence);
-	const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-	(0, preact_hooks.useEffect)(() => {
-		if (sequenceRef.current.length === 0) {
-			if (registrationRef.current?.isActive) {
-				registrationRef.current.unregister();
-				registrationRef.current = null;
-			}
-			prevTargetRef.current = null;
-			prevSequenceRef.current = null;
-			return;
-		}
-		const resolvedTarget = require_utils.isRef(optionsRef.current.target) ? optionsRef.current.target.current : optionsRef.current.target ?? (typeof document !== "undefined" ? document : null);
-		if (!resolvedTarget) {
-			if (registrationRef.current?.isActive) {
-				registrationRef.current.unregister();
-				registrationRef.current = null;
-			}
-			prevTargetRef.current = null;
-			prevSequenceRef.current = null;
-			return;
-		}
-		const targetChanged = prevTargetRef.current !== null && prevTargetRef.current !== resolvedTarget;
-		const sequenceChanged = prevSequenceRef.current !== null && prevSequenceRef.current !== hotkeySequenceString;
-		if (registrationRef.current?.isActive && (targetChanged || sequenceChanged)) {
-			registrationRef.current.unregister();
-			registrationRef.current = null;
-		}
-		if (!registrationRef.current || !registrationRef.current.isActive) registrationRef.current = managerRef.current.register(sequenceRef.current, (event, context) => callbackRef.current(event, context), {
-			...optionsRef.current,
-			target: resolvedTarget
-		});
-		prevTargetRef.current = resolvedTarget;
-		prevSequenceRef.current = hotkeySequenceString;
-	});
-	(0, preact_hooks.useEffect)(() => {
-		return () => {
-			if (registrationRef.current?.isActive) {
-				registrationRef.current.unregister();
-				registrationRef.current = null;
-			}
-		};
-	}, []);
-	(0, preact_hooks.useEffect)(() => {
-		if (registrationRef.current?.isActive) {
-			registrationRef.current.callback = (event, context) => callbackRef.current(event, context);
-			registrationRef.current.setOptions(optionsWithoutTarget);
-		}
-	});
-}
-
-//#endregion
-exports.useHotkeySequence = useHotkeySequence;
-//# sourceMappingURL=useHotkeySequence.cjs.map

package/dist/useHotkeySequence.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeySequence.cjs","names":["useDefaultHotkeysOptions","isRef"],"sources":["../src/useHotkeySequence.ts"],"sourcesContent":["import { useEffect, useRef } from 'preact/hooks'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport { isRef } from './utils'\nimport type { RefObject } from 'preact'\nimport type {\n  HotkeyCallback,\n  HotkeyCallbackContext,\n  HotkeySequence,\n  SequenceOptions,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\nexport interface UseHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'target'\n> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a Preact ref, direct DOM element, or null.\n   * Defaults to document.\n   */\n  target?:\n    | RefObject<HTMLElement | null>\n    | HTMLElement\n    | Document\n    | Window\n    | null\n}\n\n/**\n * Preact hook for registering a keyboard shortcut sequence (Vim-style).\n *\n * This hook 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\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior. `enabled: false` keeps the registration (visible in devtools)\n *   and only suppresses firing; the hook updates the existing handle instead of unregistering.\n *\n * @example\n * ```tsx\n * function VimEditor() {\n *   // 'g g' to go to top\n *   useHotkeySequence(['G', 'G'], () => {\n *     scrollToTop()\n *   })\n *\n *   // 'd d' to delete line\n *   useHotkeySequence(['D', 'D'], () => {\n *     deleteLine()\n *   })\n *\n *   // 'd i w' to delete inner word\n *   useHotkeySequence(['D', 'I', 'W'], () => {\n *     deleteInnerWord()\n *   }, { timeout: 500 })\n *\n *   // Same modifier on consecutive steps (bare Shift between chords is ignored)\n *   useHotkeySequence(['Shift+R', 'Shift+T'], () => {\n *     nextAction()\n *   })\n *\n *   return <div>...</div>\n * }\n * ```\n */\nexport function useHotkeySequence(\n  sequence: HotkeySequence,\n  callback: HotkeyCallback,\n  options: UseHotkeySequenceOptions = {},\n): void {\n  const mergedOptions = {\n    ...useDefaultHotkeysOptions().hotkeySequence,\n    ...options,\n  } as UseHotkeySequenceOptions\n\n  const manager = getSequenceManager()\n\n  // Stable ref for registration handle\n  const registrationRef = useRef<SequenceRegistrationHandle | null>(null)\n\n  // Refs to capture current values for use in effect without adding dependencies\n  const callbackRef = useRef(callback)\n  const optionsRef = useRef(mergedOptions)\n  const managerRef = useRef(manager)\n  const sequenceRef = useRef(sequence)\n\n  // Update refs on every render\n  callbackRef.current = callback\n  optionsRef.current = mergedOptions\n  managerRef.current = manager\n  sequenceRef.current = sequence\n\n  // Track previous target and sequence to detect changes requiring re-registration\n  const prevTargetRef = useRef<HTMLElement | Document | Window | null>(null)\n  const prevSequenceRef = useRef<string | null>(null)\n\n  // Normalize to hotkey sequence string (join with spaces)\n  const hotkeySequenceString = formatHotkeySequence(sequence)\n\n  // Extract options without target (target is handled separately)\n  const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n  useEffect(() => {\n    if (sequenceRef.current.length === 0) {\n      if (registrationRef.current?.isActive) {\n        registrationRef.current.unregister()\n        registrationRef.current = null\n      }\n      prevTargetRef.current = null\n      prevSequenceRef.current = null\n      return\n    }\n\n    // Resolve target inside the effect so refs are already attached after mount\n    const resolvedTarget = isRef(optionsRef.current.target)\n      ? optionsRef.current.target.current\n      : (optionsRef.current.target ??\n        (typeof document !== 'undefined' ? document : null))\n\n    // Skip if no valid target (SSR or ref still null)\n    if (!resolvedTarget) {\n      if (registrationRef.current?.isActive) {\n        registrationRef.current.unregister()\n        registrationRef.current = null\n      }\n      prevTargetRef.current = null\n      prevSequenceRef.current = null\n      return\n    }\n\n    // Check if we need to re-register (target or sequence changed)\n    const targetChanged =\n      prevTargetRef.current !== null && prevTargetRef.current !== resolvedTarget\n    const sequenceChanged =\n      prevSequenceRef.current !== null &&\n      prevSequenceRef.current !== hotkeySequenceString\n\n    // If we have an active registration and target/sequence changed, unregister first\n    if (\n      registrationRef.current?.isActive &&\n      (targetChanged || sequenceChanged)\n    ) {\n      registrationRef.current.unregister()\n      registrationRef.current = null\n    }\n\n    // Register if needed (no active registration)\n    if (!registrationRef.current || !registrationRef.current.isActive) {\n      registrationRef.current = managerRef.current.register(\n        sequenceRef.current,\n        (event, context) => callbackRef.current(event, context),\n        {\n          ...optionsRef.current,\n          target: resolvedTarget,\n        },\n      )\n    }\n\n    // Update tracking refs\n    prevTargetRef.current = resolvedTarget\n    prevSequenceRef.current = hotkeySequenceString\n  })\n\n  useEffect(() => {\n    // Cleanup on unmount\n    return () => {\n      if (registrationRef.current?.isActive) {\n        registrationRef.current.unregister()\n        registrationRef.current = null\n      }\n    }\n  }, [])\n\n  // Publish option changes after commit, never during render.\n  useEffect(() => {\n    if (registrationRef.current?.isActive) {\n      registrationRef.current.callback = (\n        event: KeyboardEvent,\n        context: HotkeyCallbackContext,\n      ) => callbackRef.current(event, context)\n      registrationRef.current.setOptions(optionsWithoutTarget)\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyEA,SAAgB,kBACd,UACA,UACA,UAAoC,EAAE,EAChC;CACN,MAAM,gBAAgB;EACpB,GAAGA,kDAA0B,CAAC;EAC9B,GAAG;EACJ;CAED,MAAM,qDAA8B;CAGpC,MAAM,2CAA4D,KAAK;CAGvE,MAAM,uCAAqB,SAAS;CACpC,MAAM,sCAAoB,cAAc;CACxC,MAAM,sCAAoB,QAAQ;CAClC,MAAM,uCAAqB,SAAS;AAGpC,aAAY,UAAU;AACtB,YAAW,UAAU;AACrB,YAAW,UAAU;AACrB,aAAY,UAAU;CAGtB,MAAM,yCAA+D,KAAK;CAC1E,MAAM,2CAAwC,KAAK;CAGnD,MAAM,mEAA4C,SAAS;CAG3D,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,mCAAgB;AACd,MAAI,YAAY,QAAQ,WAAW,GAAG;AACpC,OAAI,gBAAgB,SAAS,UAAU;AACrC,oBAAgB,QAAQ,YAAY;AACpC,oBAAgB,UAAU;;AAE5B,iBAAc,UAAU;AACxB,mBAAgB,UAAU;AAC1B;;EAIF,MAAM,iBAAiBC,oBAAM,WAAW,QAAQ,OAAO,GACnD,WAAW,QAAQ,OAAO,UACzB,WAAW,QAAQ,WACnB,OAAO,aAAa,cAAc,WAAW;AAGlD,MAAI,CAAC,gBAAgB;AACnB,OAAI,gBAAgB,SAAS,UAAU;AACrC,oBAAgB,QAAQ,YAAY;AACpC,oBAAgB,UAAU;;AAE5B,iBAAc,UAAU;AACxB,mBAAgB,UAAU;AAC1B;;EAIF,MAAM,gBACJ,cAAc,YAAY,QAAQ,cAAc,YAAY;EAC9D,MAAM,kBACJ,gBAAgB,YAAY,QAC5B,gBAAgB,YAAY;AAG9B,MACE,gBAAgB,SAAS,aACxB,iBAAiB,kBAClB;AACA,mBAAgB,QAAQ,YAAY;AACpC,mBAAgB,UAAU;;AAI5B,MAAI,CAAC,gBAAgB,WAAW,CAAC,gBAAgB,QAAQ,SACvD,iBAAgB,UAAU,WAAW,QAAQ,SAC3C,YAAY,UACX,OAAO,YAAY,YAAY,QAAQ,OAAO,QAAQ,EACvD;GACE,GAAG,WAAW;GACd,QAAQ;GACT,CACF;AAIH,gBAAc,UAAU;AACxB,kBAAgB,UAAU;GAC1B;AAEF,mCAAgB;AAEd,eAAa;AACX,OAAI,gBAAgB,SAAS,UAAU;AACrC,oBAAgB,QAAQ,YAAY;AACpC,oBAAgB,UAAU;;;IAG7B,EAAE,CAAC;AAGN,mCAAgB;AACd,MAAI,gBAAgB,SAAS,UAAU;AACrC,mBAAgB,QAAQ,YACtB,OACA,YACG,YAAY,QAAQ,OAAO,QAAQ;AACxC,mBAAgB,QAAQ,WAAW,qBAAqB;;GAE1D"}

package/dist/useHotkeySequence.d.cts

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

package/dist/useHotkeySequence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeySequence.js","names":[],"sources":["../src/useHotkeySequence.ts"],"sourcesContent":["import { useEffect, useRef } from 'preact/hooks'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport { isRef } from './utils'\nimport type { RefObject } from 'preact'\nimport type {\n  HotkeyCallback,\n  HotkeyCallbackContext,\n  HotkeySequence,\n  SequenceOptions,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\nexport interface UseHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'target'\n> {\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a Preact ref, direct DOM element, or null.\n   * Defaults to document.\n   */\n  target?:\n    | RefObject<HTMLElement | null>\n    | HTMLElement\n    | Document\n    | Window\n    | null\n}\n\n/**\n * Preact hook for registering a keyboard shortcut sequence (Vim-style).\n *\n * This hook 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\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior. `enabled: false` keeps the registration (visible in devtools)\n *   and only suppresses firing; the hook updates the existing handle instead of unregistering.\n *\n * @example\n * ```tsx\n * function VimEditor() {\n *   // 'g g' to go to top\n *   useHotkeySequence(['G', 'G'], () => {\n *     scrollToTop()\n *   })\n *\n *   // 'd d' to delete line\n *   useHotkeySequence(['D', 'D'], () => {\n *     deleteLine()\n *   })\n *\n *   // 'd i w' to delete inner word\n *   useHotkeySequence(['D', 'I', 'W'], () => {\n *     deleteInnerWord()\n *   }, { timeout: 500 })\n *\n *   // Same modifier on consecutive steps (bare Shift between chords is ignored)\n *   useHotkeySequence(['Shift+R', 'Shift+T'], () => {\n *     nextAction()\n *   })\n *\n *   return <div>...</div>\n * }\n * ```\n */\nexport function useHotkeySequence(\n  sequence: HotkeySequence,\n  callback: HotkeyCallback,\n  options: UseHotkeySequenceOptions = {},\n): void {\n  const mergedOptions = {\n    ...useDefaultHotkeysOptions().hotkeySequence,\n    ...options,\n  } as UseHotkeySequenceOptions\n\n  const manager = getSequenceManager()\n\n  // Stable ref for registration handle\n  const registrationRef = useRef<SequenceRegistrationHandle | null>(null)\n\n  // Refs to capture current values for use in effect without adding dependencies\n  const callbackRef = useRef(callback)\n  const optionsRef = useRef(mergedOptions)\n  const managerRef = useRef(manager)\n  const sequenceRef = useRef(sequence)\n\n  // Update refs on every render\n  callbackRef.current = callback\n  optionsRef.current = mergedOptions\n  managerRef.current = manager\n  sequenceRef.current = sequence\n\n  // Track previous target and sequence to detect changes requiring re-registration\n  const prevTargetRef = useRef<HTMLElement | Document | Window | null>(null)\n  const prevSequenceRef = useRef<string | null>(null)\n\n  // Normalize to hotkey sequence string (join with spaces)\n  const hotkeySequenceString = formatHotkeySequence(sequence)\n\n  // Extract options without target (target is handled separately)\n  const { target: _target, ...optionsWithoutTarget } = mergedOptions\n\n  useEffect(() => {\n    if (sequenceRef.current.length === 0) {\n      if (registrationRef.current?.isActive) {\n        registrationRef.current.unregister()\n        registrationRef.current = null\n      }\n      prevTargetRef.current = null\n      prevSequenceRef.current = null\n      return\n    }\n\n    // Resolve target inside the effect so refs are already attached after mount\n    const resolvedTarget = isRef(optionsRef.current.target)\n      ? optionsRef.current.target.current\n      : (optionsRef.current.target ??\n        (typeof document !== 'undefined' ? document : null))\n\n    // Skip if no valid target (SSR or ref still null)\n    if (!resolvedTarget) {\n      if (registrationRef.current?.isActive) {\n        registrationRef.current.unregister()\n        registrationRef.current = null\n      }\n      prevTargetRef.current = null\n      prevSequenceRef.current = null\n      return\n    }\n\n    // Check if we need to re-register (target or sequence changed)\n    const targetChanged =\n      prevTargetRef.current !== null && prevTargetRef.current !== resolvedTarget\n    const sequenceChanged =\n      prevSequenceRef.current !== null &&\n      prevSequenceRef.current !== hotkeySequenceString\n\n    // If we have an active registration and target/sequence changed, unregister first\n    if (\n      registrationRef.current?.isActive &&\n      (targetChanged || sequenceChanged)\n    ) {\n      registrationRef.current.unregister()\n      registrationRef.current = null\n    }\n\n    // Register if needed (no active registration)\n    if (!registrationRef.current || !registrationRef.current.isActive) {\n      registrationRef.current = managerRef.current.register(\n        sequenceRef.current,\n        (event, context) => callbackRef.current(event, context),\n        {\n          ...optionsRef.current,\n          target: resolvedTarget,\n        },\n      )\n    }\n\n    // Update tracking refs\n    prevTargetRef.current = resolvedTarget\n    prevSequenceRef.current = hotkeySequenceString\n  })\n\n  useEffect(() => {\n    // Cleanup on unmount\n    return () => {\n      if (registrationRef.current?.isActive) {\n        registrationRef.current.unregister()\n        registrationRef.current = null\n      }\n    }\n  }, [])\n\n  // Publish option changes after commit, never during render.\n  useEffect(() => {\n    if (registrationRef.current?.isActive) {\n      registrationRef.current.callback = (\n        event: KeyboardEvent,\n        context: HotkeyCallbackContext,\n      ) => callbackRef.current(event, context)\n      registrationRef.current.setOptions(optionsWithoutTarget)\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyEA,SAAgB,kBACd,UACA,UACA,UAAoC,EAAE,EAChC;CACN,MAAM,gBAAgB;EACpB,GAAG,0BAA0B,CAAC;EAC9B,GAAG;EACJ;CAED,MAAM,UAAU,oBAAoB;CAGpC,MAAM,kBAAkB,OAA0C,KAAK;CAGvE,MAAM,cAAc,OAAO,SAAS;CACpC,MAAM,aAAa,OAAO,cAAc;CACxC,MAAM,aAAa,OAAO,QAAQ;CAClC,MAAM,cAAc,OAAO,SAAS;AAGpC,aAAY,UAAU;AACtB,YAAW,UAAU;AACrB,YAAW,UAAU;AACrB,aAAY,UAAU;CAGtB,MAAM,gBAAgB,OAA+C,KAAK;CAC1E,MAAM,kBAAkB,OAAsB,KAAK;CAGnD,MAAM,uBAAuB,qBAAqB,SAAS;CAG3D,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AAErD,iBAAgB;AACd,MAAI,YAAY,QAAQ,WAAW,GAAG;AACpC,OAAI,gBAAgB,SAAS,UAAU;AACrC,oBAAgB,QAAQ,YAAY;AACpC,oBAAgB,UAAU;;AAE5B,iBAAc,UAAU;AACxB,mBAAgB,UAAU;AAC1B;;EAIF,MAAM,iBAAiB,MAAM,WAAW,QAAQ,OAAO,GACnD,WAAW,QAAQ,OAAO,UACzB,WAAW,QAAQ,WACnB,OAAO,aAAa,cAAc,WAAW;AAGlD,MAAI,CAAC,gBAAgB;AACnB,OAAI,gBAAgB,SAAS,UAAU;AACrC,oBAAgB,QAAQ,YAAY;AACpC,oBAAgB,UAAU;;AAE5B,iBAAc,UAAU;AACxB,mBAAgB,UAAU;AAC1B;;EAIF,MAAM,gBACJ,cAAc,YAAY,QAAQ,cAAc,YAAY;EAC9D,MAAM,kBACJ,gBAAgB,YAAY,QAC5B,gBAAgB,YAAY;AAG9B,MACE,gBAAgB,SAAS,aACxB,iBAAiB,kBAClB;AACA,mBAAgB,QAAQ,YAAY;AACpC,mBAAgB,UAAU;;AAI5B,MAAI,CAAC,gBAAgB,WAAW,CAAC,gBAAgB,QAAQ,SACvD,iBAAgB,UAAU,WAAW,QAAQ,SAC3C,YAAY,UACX,OAAO,YAAY,YAAY,QAAQ,OAAO,QAAQ,EACvD;GACE,GAAG,WAAW;GACd,QAAQ;GACT,CACF;AAIH,gBAAc,UAAU;AACxB,kBAAgB,UAAU;GAC1B;AAEF,iBAAgB;AAEd,eAAa;AACX,OAAI,gBAAgB,SAAS,UAAU;AACrC,oBAAgB,QAAQ,YAAY;AACpC,oBAAgB,UAAU;;;IAG7B,EAAE,CAAC;AAGN,iBAAgB;AACd,MAAI,gBAAgB,SAAS,UAAU;AACrC,mBAAgB,QAAQ,YACtB,OACA,YACG,YAAY,QAAQ,OAAO,QAAQ;AACxC,mBAAgB,QAAQ,WAAW,qBAAqB;;GAE1D"}

package/dist/useHotkeySequenceRecorder.cjs

@@ -1,39 +0,0 @@
-const require_HotkeysProvider = require('./HotkeysProvider.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let preact_hooks = require("preact/hooks");
-let _tanstack_preact_store = require("@tanstack/preact-store");
-
-//#region src/useHotkeySequenceRecorder.ts
-/**
-* Preact hook for recording multi-chord sequences (Vim-style shortcuts).
-*/
-function useHotkeySequenceRecorder(options) {
-	const mergedOptions = {
-		...require_HotkeysProvider.useDefaultHotkeysOptions().hotkeySequenceRecorder,
-		...options
-	};
-	const recorderRef = (0, preact_hooks.useRef)(null);
-	if (!recorderRef.current) recorderRef.current = new _tanstack_hotkeys.HotkeySequenceRecorder(mergedOptions);
-	recorderRef.current.setOptions(mergedOptions);
-	const isRecording = (0, _tanstack_preact_store.useSelector)(recorderRef.current.store, (state) => state.isRecording);
-	const steps = (0, _tanstack_preact_store.useSelector)(recorderRef.current.store, (state) => state.steps);
-	const recordedSequence = (0, _tanstack_preact_store.useSelector)(recorderRef.current.store, (state) => state.recordedSequence);
-	(0, preact_hooks.useEffect)(() => {
-		return () => {
-			recorderRef.current?.destroy();
-		};
-	}, []);
-	return {
-		isRecording,
-		steps,
-		recordedSequence,
-		startRecording: () => recorderRef.current?.start(),
-		stopRecording: () => recorderRef.current?.stop(),
-		cancelRecording: () => recorderRef.current?.cancel(),
-		commitRecording: () => recorderRef.current?.commit()
-	};
-}
-
-//#endregion
-exports.useHotkeySequenceRecorder = useHotkeySequenceRecorder;
-//# sourceMappingURL=useHotkeySequenceRecorder.cjs.map

package/dist/useHotkeySequenceRecorder.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeySequenceRecorder.cjs","names":["useDefaultHotkeysOptions","HotkeySequenceRecorder"],"sources":["../src/useHotkeySequenceRecorder.ts"],"sourcesContent":["import { useEffect, useRef } from 'preact/hooks'\nimport { useSelector } from '@tanstack/preact-store'\nimport { HotkeySequenceRecorder } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type {\n  HotkeySequence,\n  HotkeySequenceRecorderOptions,\n} from '@tanstack/hotkeys'\n\nexport interface PreactHotkeySequenceRecorder {\n  isRecording: boolean\n  steps: HotkeySequence\n  recordedSequence: HotkeySequence | null\n  startRecording: () => void\n  stopRecording: () => void\n  cancelRecording: () => void\n  commitRecording: () => void\n}\n\n/**\n * Preact hook for recording multi-chord sequences (Vim-style shortcuts).\n */\nexport function useHotkeySequenceRecorder(\n  options: HotkeySequenceRecorderOptions,\n): PreactHotkeySequenceRecorder {\n  const mergedOptions = {\n    ...useDefaultHotkeysOptions().hotkeySequenceRecorder,\n    ...options,\n  } as HotkeySequenceRecorderOptions\n\n  const recorderRef = useRef<HotkeySequenceRecorder | null>(null)\n\n  if (!recorderRef.current) {\n    recorderRef.current = new HotkeySequenceRecorder(mergedOptions)\n  }\n\n  recorderRef.current.setOptions(mergedOptions)\n\n  const isRecording = useSelector(\n    recorderRef.current.store,\n    (state) => state.isRecording,\n  )\n  const steps = useSelector(recorderRef.current.store, (state) => state.steps)\n  const recordedSequence = useSelector(\n    recorderRef.current.store,\n    (state) => state.recordedSequence,\n  )\n\n  useEffect(() => {\n    return () => {\n      recorderRef.current?.destroy()\n    }\n  }, [])\n\n  return {\n    isRecording,\n    steps,\n    recordedSequence,\n    startRecording: () => recorderRef.current?.start(),\n    stopRecording: () => recorderRef.current?.stop(),\n    cancelRecording: () => recorderRef.current?.cancel(),\n    commitRecording: () => recorderRef.current?.commit(),\n  }\n}\n"],"mappings":";;;;;;;;;AAsBA,SAAgB,0BACd,SAC8B;CAC9B,MAAM,gBAAgB;EACpB,GAAGA,kDAA0B,CAAC;EAC9B,GAAG;EACJ;CAED,MAAM,uCAAoD,KAAK;AAE/D,KAAI,CAAC,YAAY,QACf,aAAY,UAAU,IAAIC,yCAAuB,cAAc;AAGjE,aAAY,QAAQ,WAAW,cAAc;CAE7C,MAAM,sDACJ,YAAY,QAAQ,QACnB,UAAU,MAAM,YAClB;CACD,MAAM,gDAAoB,YAAY,QAAQ,QAAQ,UAAU,MAAM,MAAM;CAC5E,MAAM,2DACJ,YAAY,QAAQ,QACnB,UAAU,MAAM,iBAClB;AAED,mCAAgB;AACd,eAAa;AACX,eAAY,SAAS,SAAS;;IAE/B,EAAE,CAAC;AAEN,QAAO;EACL;EACA;EACA;EACA,sBAAsB,YAAY,SAAS,OAAO;EAClD,qBAAqB,YAAY,SAAS,MAAM;EAChD,uBAAuB,YAAY,SAAS,QAAQ;EACpD,uBAAuB,YAAY,SAAS,QAAQ;EACrD"}

package/dist/useHotkeySequenceRecorder.d.cts

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

package/dist/useHotkeySequenceRecorder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeySequenceRecorder.js","names":[],"sources":["../src/useHotkeySequenceRecorder.ts"],"sourcesContent":["import { useEffect, useRef } from 'preact/hooks'\nimport { useSelector } from '@tanstack/preact-store'\nimport { HotkeySequenceRecorder } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport type {\n  HotkeySequence,\n  HotkeySequenceRecorderOptions,\n} from '@tanstack/hotkeys'\n\nexport interface PreactHotkeySequenceRecorder {\n  isRecording: boolean\n  steps: HotkeySequence\n  recordedSequence: HotkeySequence | null\n  startRecording: () => void\n  stopRecording: () => void\n  cancelRecording: () => void\n  commitRecording: () => void\n}\n\n/**\n * Preact hook for recording multi-chord sequences (Vim-style shortcuts).\n */\nexport function useHotkeySequenceRecorder(\n  options: HotkeySequenceRecorderOptions,\n): PreactHotkeySequenceRecorder {\n  const mergedOptions = {\n    ...useDefaultHotkeysOptions().hotkeySequenceRecorder,\n    ...options,\n  } as HotkeySequenceRecorderOptions\n\n  const recorderRef = useRef<HotkeySequenceRecorder | null>(null)\n\n  if (!recorderRef.current) {\n    recorderRef.current = new HotkeySequenceRecorder(mergedOptions)\n  }\n\n  recorderRef.current.setOptions(mergedOptions)\n\n  const isRecording = useSelector(\n    recorderRef.current.store,\n    (state) => state.isRecording,\n  )\n  const steps = useSelector(recorderRef.current.store, (state) => state.steps)\n  const recordedSequence = useSelector(\n    recorderRef.current.store,\n    (state) => state.recordedSequence,\n  )\n\n  useEffect(() => {\n    return () => {\n      recorderRef.current?.destroy()\n    }\n  }, [])\n\n  return {\n    isRecording,\n    steps,\n    recordedSequence,\n    startRecording: () => recorderRef.current?.start(),\n    stopRecording: () => recorderRef.current?.stop(),\n    cancelRecording: () => recorderRef.current?.cancel(),\n    commitRecording: () => recorderRef.current?.commit(),\n  }\n}\n"],"mappings":";;;;;;;;;AAsBA,SAAgB,0BACd,SAC8B;CAC9B,MAAM,gBAAgB;EACpB,GAAG,0BAA0B,CAAC;EAC9B,GAAG;EACJ;CAED,MAAM,cAAc,OAAsC,KAAK;AAE/D,KAAI,CAAC,YAAY,QACf,aAAY,UAAU,IAAI,uBAAuB,cAAc;AAGjE,aAAY,QAAQ,WAAW,cAAc;CAE7C,MAAM,cAAc,YAClB,YAAY,QAAQ,QACnB,UAAU,MAAM,YAClB;CACD,MAAM,QAAQ,YAAY,YAAY,QAAQ,QAAQ,UAAU,MAAM,MAAM;CAC5E,MAAM,mBAAmB,YACvB,YAAY,QAAQ,QACnB,UAAU,MAAM,iBAClB;AAED,iBAAgB;AACd,eAAa;AACX,eAAY,SAAS,SAAS;;IAE/B,EAAE,CAAC;AAEN,QAAO;EACL;EACA;EACA;EACA,sBAAsB,YAAY,SAAS,OAAO;EAClD,qBAAqB,YAAY,SAAS,MAAM;EAChD,uBAAuB,YAAY,SAAS,QAAQ;EACpD,uBAAuB,YAAY,SAAS,QAAQ;EACrD"}

package/dist/useHotkeySequences.cjs

@@ -1,126 +0,0 @@
-const require_HotkeysProvider = require('./HotkeysProvider.cjs');
-const require_utils = require('./utils.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let preact_hooks = require("preact/hooks");
-
-//#region src/useHotkeySequences.ts
-/**
-* Preact hook for registering multiple keyboard shortcut sequences at once (Vim-style).
-*
-* Uses the singleton SequenceManager. Accepts a dynamic array of definitions so you can
-* register variable-length lists without violating the rules of hooks.
-*
-* Options are merged in this order:
-* HotkeysProvider defaults < commonOptions < per-definition options
-*
-* Callbacks and options are synced on every render to avoid stale closures.
-*
-* Definitions with an empty `sequence` are skipped (no registration).
-*
-* @param definitions - Array of sequence definitions to register
-* @param commonOptions - Shared options applied to all sequences (overridden by per-definition options).
-*   Per-row `enabled: false` still registers that sequence: `SequenceManager` suppresses execution only (the row
-*   stays in the store and appears in TanStack Hotkeys devtools). Toggling `enabled` updates the existing handle
-*   via `setOptions` (no unregister/re-register churn).
-*
-* @example
-* ```tsx
-* function VimPalette() {
-*   useHotkeySequences([
-*     { sequence: ['G', 'G'], callback: () => scrollToTop() },
-*     { sequence: ['D', 'D'], callback: () => deleteLine() },
-*     { sequence: ['C', 'I', 'W'], callback: () => changeInnerWord(), options: { timeout: 500 } },
-*   ])
-* }
-* ```
-*
-* @example
-* ```tsx
-* function DynamicSequences({ items }) {
-*   useHotkeySequences(
-*     items.map((item) => ({
-*       sequence: item.chords,
-*       callback: item.action,
-*       options: { enabled: item.enabled },
-*     })),
-*     { preventDefault: true },
-*   )
-* }
-* ```
-*/
-function useHotkeySequences(definitions, commonOptions = {}) {
-	const defaultOptions = require_HotkeysProvider.useDefaultHotkeysOptions().hotkeySequence;
-	const manager = (0, _tanstack_hotkeys.getSequenceManager)();
-	const registrationsRef = (0, preact_hooks.useRef)(/* @__PURE__ */ new Map());
-	const definitionsRef = (0, preact_hooks.useRef)(definitions);
-	const sequenceStringsRef = (0, preact_hooks.useRef)([]);
-	const commonOptionsRef = (0, preact_hooks.useRef)(commonOptions);
-	const defaultOptionsRef = (0, preact_hooks.useRef)(defaultOptions);
-	const managerRef = (0, preact_hooks.useRef)(manager);
-	const sequenceStrings = definitions.map((def) => (0, _tanstack_hotkeys.formatHotkeySequence)(def.sequence));
-	definitionsRef.current = definitions;
-	sequenceStringsRef.current = sequenceStrings;
-	commonOptionsRef.current = commonOptions;
-	defaultOptionsRef.current = defaultOptions;
-	managerRef.current = manager;
-	(0, preact_hooks.useEffect)(() => {
-		const prevRegistrations = registrationsRef.current;
-		const nextRegistrations = /* @__PURE__ */ new Map();
-		const rows = [];
-		for (let i = 0; i < definitionsRef.current.length; i++) {
-			const def = definitionsRef.current[i];
-			const seqStr = sequenceStringsRef.current[i];
-			const seq = def.sequence;
-			if (seq.length === 0) continue;
-			const mergedOptions = {
-				...defaultOptionsRef.current,
-				...commonOptionsRef.current,
-				...def.options
-			};
-			const resolvedTarget = require_utils.isRef(mergedOptions.target) ? mergedOptions.target.current : mergedOptions.target ?? (typeof document !== "undefined" ? document : null);
-			if (!resolvedTarget) continue;
-			const registrationKey = `${i}:${seqStr}`;
-			rows.push({
-				registrationKey,
-				def,
-				seq,
-				seqStr,
-				mergedOptions,
-				resolvedTarget
-			});
-		}
-		const nextKeys = new Set(rows.map((r) => r.registrationKey));
-		for (const [key, record] of prevRegistrations) if (!nextKeys.has(key) && record.handle.isActive) record.handle.unregister();
-		for (const row of rows) {
-			const { registrationKey, def, seq, mergedOptions, resolvedTarget } = row;
-			const existing = prevRegistrations.get(registrationKey);
-			if (existing?.handle.isActive && existing.target === resolvedTarget) {
-				existing.handle.callback = def.callback;
-				const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-				existing.handle.setOptions(optionsWithoutTarget);
-				nextRegistrations.set(registrationKey, existing);
-				continue;
-			}
-			if (existing?.handle.isActive) existing.handle.unregister();
-			const handle = managerRef.current.register(seq, def.callback, {
-				...mergedOptions,
-				target: resolvedTarget
-			});
-			nextRegistrations.set(registrationKey, {
-				handle,
-				target: resolvedTarget
-			});
-		}
-		registrationsRef.current = nextRegistrations;
-	});
-	(0, preact_hooks.useEffect)(() => {
-		return () => {
-			for (const { handle } of registrationsRef.current.values()) if (handle.isActive) handle.unregister();
-			registrationsRef.current = /* @__PURE__ */ new Map();
-		};
-	}, []);
-}
-
-//#endregion
-exports.useHotkeySequences = useHotkeySequences;
-//# sourceMappingURL=useHotkeySequences.cjs.map

package/dist/useHotkeySequences.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeySequences.cjs","names":["useDefaultHotkeysOptions","isRef"],"sources":["../src/useHotkeySequences.ts"],"sourcesContent":["import { useEffect, useRef } from 'preact/hooks'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport { isRef } from './utils'\nimport type { UseHotkeySequenceOptions } from './useHotkeySequence'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\n/**\n * A single sequence definition for use with `useHotkeySequences`.\n */\nexport interface UseHotkeySequenceDefinition {\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?: UseHotkeySequenceOptions\n}\n\n/**\n * Preact hook for registering multiple keyboard shortcut sequences at once (Vim-style).\n *\n * Uses the singleton SequenceManager. Accepts a dynamic array of definitions so you can\n * register variable-length lists without violating the rules of hooks.\n *\n * Options are merged in this order:\n * HotkeysProvider defaults < commonOptions < per-definition options\n *\n * Callbacks and options are synced on every render to avoid stale closures.\n *\n * Definitions with an empty `sequence` are skipped (no registration).\n *\n * @param definitions - Array of sequence definitions to register\n * @param commonOptions - Shared options applied to all sequences (overridden by per-definition options).\n *   Per-row `enabled: false` still registers that sequence: `SequenceManager` suppresses execution only (the row\n *   stays in the store and appears in TanStack Hotkeys devtools). Toggling `enabled` updates the existing handle\n *   via `setOptions` (no unregister/re-register churn).\n *\n * @example\n * ```tsx\n * function VimPalette() {\n *   useHotkeySequences([\n *     { sequence: ['G', 'G'], callback: () => scrollToTop() },\n *     { sequence: ['D', 'D'], callback: () => deleteLine() },\n *     { sequence: ['C', 'I', 'W'], callback: () => changeInnerWord(), options: { timeout: 500 } },\n *   ])\n * }\n * ```\n *\n * @example\n * ```tsx\n * function DynamicSequences({ items }) {\n *   useHotkeySequences(\n *     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 useHotkeySequences(\n  definitions: Array<UseHotkeySequenceDefinition>,\n  commonOptions: UseHotkeySequenceOptions = {},\n): void {\n  type RegistrationRecord = {\n    handle: SequenceRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = useDefaultHotkeysOptions().hotkeySequence\n  const manager = getSequenceManager()\n\n  const registrationsRef = useRef<Map<string, RegistrationRecord>>(new Map())\n  const definitionsRef = useRef(definitions)\n  const sequenceStringsRef = useRef<Array<string>>([])\n  const commonOptionsRef = useRef(commonOptions)\n  const defaultOptionsRef = useRef(defaultOptions)\n  const managerRef = useRef(manager)\n\n  const sequenceStrings = definitions.map((def) =>\n    formatHotkeySequence(def.sequence),\n  )\n\n  definitionsRef.current = definitions\n  sequenceStringsRef.current = sequenceStrings\n  commonOptionsRef.current = commonOptions\n  defaultOptionsRef.current = defaultOptions\n  managerRef.current = manager\n\n  useEffect(() => {\n    const prevRegistrations = registrationsRef.current\n    const nextRegistrations = new Map<string, RegistrationRecord>()\n\n    const rows: Array<{\n      registrationKey: string\n      def: (typeof definitionsRef.current)[number]\n      seq: HotkeySequence\n      seqStr: string\n      mergedOptions: UseHotkeySequenceOptions\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < definitionsRef.current.length; i++) {\n      const def = definitionsRef.current[i]!\n      const seqStr = sequenceStringsRef.current[i]!\n      const seq = def.sequence\n      if (seq.length === 0) {\n        continue\n      }\n\n      const mergedOptions = {\n        ...defaultOptionsRef.current,\n        ...commonOptionsRef.current,\n        ...def.options,\n      } as UseHotkeySequenceOptions\n\n      const resolvedTarget = isRef(mergedOptions.target)\n        ? mergedOptions.target.current\n        : (mergedOptions.target ??\n          (typeof document !== 'undefined' ? document : null))\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${seqStr}`\n      rows.push({\n        registrationKey,\n        def,\n        seq,\n        seqStr,\n        mergedOptions,\n        resolvedTarget,\n      })\n    }\n\n    const nextKeys = new Set(rows.map((r) => r.registrationKey))\n\n    for (const [key, record] of prevRegistrations) {\n      if (!nextKeys.has(key) && record.handle.isActive) {\n        record.handle.unregister()\n      }\n    }\n\n    for (const row of rows) {\n      const { registrationKey, def, seq, mergedOptions, resolvedTarget } = row\n\n      const existing = prevRegistrations.get(registrationKey)\n      if (existing?.handle.isActive && existing.target === resolvedTarget) {\n        // Publish callback/options only after commit, never during render.\n        existing.handle.callback = def.callback\n        const { target: _target, ...optionsWithoutTarget } = mergedOptions\n        existing.handle.setOptions(optionsWithoutTarget)\n        nextRegistrations.set(registrationKey, existing)\n        continue\n      }\n\n      if (existing?.handle.isActive) {\n        existing.handle.unregister()\n      }\n\n      const handle = managerRef.current.register(seq, def.callback, {\n        ...mergedOptions,\n        target: resolvedTarget,\n      })\n      nextRegistrations.set(registrationKey, {\n        handle,\n        target: resolvedTarget,\n      })\n    }\n\n    registrationsRef.current = nextRegistrations\n  })\n\n  useEffect(() => {\n    return () => {\n      for (const { handle } of registrationsRef.current.values()) {\n        if (handle.isActive) {\n          handle.unregister()\n        }\n      }\n      registrationsRef.current = new Map()\n    }\n  }, [])\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,SAAgB,mBACd,aACA,gBAA0C,EAAE,EACtC;CAMN,MAAM,iBAAiBA,kDAA0B,CAAC;CAClD,MAAM,qDAA8B;CAEpC,MAAM,4DAA2D,IAAI,KAAK,CAAC;CAC3E,MAAM,0CAAwB,YAAY;CAC1C,MAAM,8CAA2C,EAAE,CAAC;CACpD,MAAM,4CAA0B,cAAc;CAC9C,MAAM,6CAA2B,eAAe;CAChD,MAAM,sCAAoB,QAAQ;CAElC,MAAM,kBAAkB,YAAY,KAAK,oDAClB,IAAI,SAAS,CACnC;AAED,gBAAe,UAAU;AACzB,oBAAmB,UAAU;AAC7B,kBAAiB,UAAU;AAC3B,mBAAkB,UAAU;AAC5B,YAAW,UAAU;AAErB,mCAAgB;EACd,MAAM,oBAAoB,iBAAiB;EAC3C,MAAM,oCAAoB,IAAI,KAAiC;EAE/D,MAAM,OAOD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,eAAe,QAAQ,QAAQ,KAAK;GACtD,MAAM,MAAM,eAAe,QAAQ;GACnC,MAAM,SAAS,mBAAmB,QAAQ;GAC1C,MAAM,MAAM,IAAI;AAChB,OAAI,IAAI,WAAW,EACjB;GAGF,MAAM,gBAAgB;IACpB,GAAG,kBAAkB;IACrB,GAAG,iBAAiB;IACpB,GAAG,IAAI;IACR;GAED,MAAM,iBAAiBC,oBAAM,cAAc,OAAO,GAC9C,cAAc,OAAO,UACpB,cAAc,WACd,OAAO,aAAa,cAAc,WAAW;AAElD,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,GAAG;AAChC,QAAK,KAAK;IACR;IACA;IACA;IACA;IACA;IACA;IACD,CAAC;;EAGJ,MAAM,WAAW,IAAI,IAAI,KAAK,KAAK,MAAM,EAAE,gBAAgB,CAAC;AAE5D,OAAK,MAAM,CAAC,KAAK,WAAW,kBAC1B,KAAI,CAAC,SAAS,IAAI,IAAI,IAAI,OAAO,OAAO,SACtC,QAAO,OAAO,YAAY;AAI9B,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,EAAE,iBAAiB,KAAK,KAAK,eAAe,mBAAmB;GAErE,MAAM,WAAW,kBAAkB,IAAI,gBAAgB;AACvD,OAAI,UAAU,OAAO,YAAY,SAAS,WAAW,gBAAgB;AAEnE,aAAS,OAAO,WAAW,IAAI;IAC/B,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AACrD,aAAS,OAAO,WAAW,qBAAqB;AAChD,sBAAkB,IAAI,iBAAiB,SAAS;AAChD;;AAGF,OAAI,UAAU,OAAO,SACnB,UAAS,OAAO,YAAY;GAG9B,MAAM,SAAS,WAAW,QAAQ,SAAS,KAAK,IAAI,UAAU;IAC5D,GAAG;IACH,QAAQ;IACT,CAAC;AACF,qBAAkB,IAAI,iBAAiB;IACrC;IACA,QAAQ;IACT,CAAC;;AAGJ,mBAAiB,UAAU;GAC3B;AAEF,mCAAgB;AACd,eAAa;AACX,QAAK,MAAM,EAAE,YAAY,iBAAiB,QAAQ,QAAQ,CACxD,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,oBAAiB,0BAAU,IAAI,KAAK;;IAErC,EAAE,CAAC"}

package/dist/useHotkeySequences.d.cts

@@ -1,63 +0,0 @@
-import { UseHotkeySequenceOptions } from "./useHotkeySequence.cjs";
-import { HotkeyCallback, HotkeySequence } from "@tanstack/hotkeys";
-
-//#region src/useHotkeySequences.d.ts
-/**
- * A single sequence definition for use with `useHotkeySequences`.
- */
-interface UseHotkeySequenceDefinition {
-  /** 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?: UseHotkeySequenceOptions;
-}
-/**
- * Preact hook for registering multiple keyboard shortcut sequences at once (Vim-style).
- *
- * Uses the singleton SequenceManager. Accepts a dynamic array of definitions so you can
- * register variable-length lists without violating the rules of hooks.
- *
- * Options are merged in this order:
- * HotkeysProvider defaults < commonOptions < per-definition options
- *
- * Callbacks and options are synced on every render to avoid stale closures.
- *
- * Definitions with an empty `sequence` are skipped (no registration).
- *
- * @param definitions - Array of sequence definitions to register
- * @param commonOptions - Shared options applied to all sequences (overridden by per-definition options).
- *   Per-row `enabled: false` still registers that sequence: `SequenceManager` suppresses execution only (the row
- *   stays in the store and appears in TanStack Hotkeys devtools). Toggling `enabled` updates the existing handle
- *   via `setOptions` (no unregister/re-register churn).
- *
- * @example
- * ```tsx
- * function VimPalette() {
- *   useHotkeySequences([
- *     { sequence: ['G', 'G'], callback: () => scrollToTop() },
- *     { sequence: ['D', 'D'], callback: () => deleteLine() },
- *     { sequence: ['C', 'I', 'W'], callback: () => changeInnerWord(), options: { timeout: 500 } },
- *   ])
- * }
- * ```
- *
- * @example
- * ```tsx
- * function DynamicSequences({ items }) {
- *   useHotkeySequences(
- *     items.map((item) => ({
- *       sequence: item.chords,
- *       callback: item.action,
- *       options: { enabled: item.enabled },
- *     })),
- *     { preventDefault: true },
- *   )
- * }
- * ```
- */
-declare function useHotkeySequences(definitions: Array<UseHotkeySequenceDefinition>, commonOptions?: UseHotkeySequenceOptions): void;
-//#endregion
-export { UseHotkeySequenceDefinition, useHotkeySequences };
-//# sourceMappingURL=useHotkeySequences.d.cts.map

package/dist/useHotkeySequences.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHotkeySequences.js","names":[],"sources":["../src/useHotkeySequences.ts"],"sourcesContent":["import { useEffect, useRef } from 'preact/hooks'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { useDefaultHotkeysOptions } from './HotkeysProvider'\nimport { isRef } from './utils'\nimport type { UseHotkeySequenceOptions } from './useHotkeySequence'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\n/**\n * A single sequence definition for use with `useHotkeySequences`.\n */\nexport interface UseHotkeySequenceDefinition {\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?: UseHotkeySequenceOptions\n}\n\n/**\n * Preact hook for registering multiple keyboard shortcut sequences at once (Vim-style).\n *\n * Uses the singleton SequenceManager. Accepts a dynamic array of definitions so you can\n * register variable-length lists without violating the rules of hooks.\n *\n * Options are merged in this order:\n * HotkeysProvider defaults < commonOptions < per-definition options\n *\n * Callbacks and options are synced on every render to avoid stale closures.\n *\n * Definitions with an empty `sequence` are skipped (no registration).\n *\n * @param definitions - Array of sequence definitions to register\n * @param commonOptions - Shared options applied to all sequences (overridden by per-definition options).\n *   Per-row `enabled: false` still registers that sequence: `SequenceManager` suppresses execution only (the row\n *   stays in the store and appears in TanStack Hotkeys devtools). Toggling `enabled` updates the existing handle\n *   via `setOptions` (no unregister/re-register churn).\n *\n * @example\n * ```tsx\n * function VimPalette() {\n *   useHotkeySequences([\n *     { sequence: ['G', 'G'], callback: () => scrollToTop() },\n *     { sequence: ['D', 'D'], callback: () => deleteLine() },\n *     { sequence: ['C', 'I', 'W'], callback: () => changeInnerWord(), options: { timeout: 500 } },\n *   ])\n * }\n * ```\n *\n * @example\n * ```tsx\n * function DynamicSequences({ items }) {\n *   useHotkeySequences(\n *     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 useHotkeySequences(\n  definitions: Array<UseHotkeySequenceDefinition>,\n  commonOptions: UseHotkeySequenceOptions = {},\n): void {\n  type RegistrationRecord = {\n    handle: SequenceRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = useDefaultHotkeysOptions().hotkeySequence\n  const manager = getSequenceManager()\n\n  const registrationsRef = useRef<Map<string, RegistrationRecord>>(new Map())\n  const definitionsRef = useRef(definitions)\n  const sequenceStringsRef = useRef<Array<string>>([])\n  const commonOptionsRef = useRef(commonOptions)\n  const defaultOptionsRef = useRef(defaultOptions)\n  const managerRef = useRef(manager)\n\n  const sequenceStrings = definitions.map((def) =>\n    formatHotkeySequence(def.sequence),\n  )\n\n  definitionsRef.current = definitions\n  sequenceStringsRef.current = sequenceStrings\n  commonOptionsRef.current = commonOptions\n  defaultOptionsRef.current = defaultOptions\n  managerRef.current = manager\n\n  useEffect(() => {\n    const prevRegistrations = registrationsRef.current\n    const nextRegistrations = new Map<string, RegistrationRecord>()\n\n    const rows: Array<{\n      registrationKey: string\n      def: (typeof definitionsRef.current)[number]\n      seq: HotkeySequence\n      seqStr: string\n      mergedOptions: UseHotkeySequenceOptions\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < definitionsRef.current.length; i++) {\n      const def = definitionsRef.current[i]!\n      const seqStr = sequenceStringsRef.current[i]!\n      const seq = def.sequence\n      if (seq.length === 0) {\n        continue\n      }\n\n      const mergedOptions = {\n        ...defaultOptionsRef.current,\n        ...commonOptionsRef.current,\n        ...def.options,\n      } as UseHotkeySequenceOptions\n\n      const resolvedTarget = isRef(mergedOptions.target)\n        ? mergedOptions.target.current\n        : (mergedOptions.target ??\n          (typeof document !== 'undefined' ? document : null))\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${seqStr}`\n      rows.push({\n        registrationKey,\n        def,\n        seq,\n        seqStr,\n        mergedOptions,\n        resolvedTarget,\n      })\n    }\n\n    const nextKeys = new Set(rows.map((r) => r.registrationKey))\n\n    for (const [key, record] of prevRegistrations) {\n      if (!nextKeys.has(key) && record.handle.isActive) {\n        record.handle.unregister()\n      }\n    }\n\n    for (const row of rows) {\n      const { registrationKey, def, seq, mergedOptions, resolvedTarget } = row\n\n      const existing = prevRegistrations.get(registrationKey)\n      if (existing?.handle.isActive && existing.target === resolvedTarget) {\n        // Publish callback/options only after commit, never during render.\n        existing.handle.callback = def.callback\n        const { target: _target, ...optionsWithoutTarget } = mergedOptions\n        existing.handle.setOptions(optionsWithoutTarget)\n        nextRegistrations.set(registrationKey, existing)\n        continue\n      }\n\n      if (existing?.handle.isActive) {\n        existing.handle.unregister()\n      }\n\n      const handle = managerRef.current.register(seq, def.callback, {\n        ...mergedOptions,\n        target: resolvedTarget,\n      })\n      nextRegistrations.set(registrationKey, {\n        handle,\n        target: resolvedTarget,\n      })\n    }\n\n    registrationsRef.current = nextRegistrations\n  })\n\n  useEffect(() => {\n    return () => {\n      for (const { handle } of registrationsRef.current.values()) {\n        if (handle.isActive) {\n          handle.unregister()\n        }\n      }\n      registrationsRef.current = new Map()\n    }\n  }, [])\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,SAAgB,mBACd,aACA,gBAA0C,EAAE,EACtC;CAMN,MAAM,iBAAiB,0BAA0B,CAAC;CAClD,MAAM,UAAU,oBAAoB;CAEpC,MAAM,mBAAmB,uBAAwC,IAAI,KAAK,CAAC;CAC3E,MAAM,iBAAiB,OAAO,YAAY;CAC1C,MAAM,qBAAqB,OAAsB,EAAE,CAAC;CACpD,MAAM,mBAAmB,OAAO,cAAc;CAC9C,MAAM,oBAAoB,OAAO,eAAe;CAChD,MAAM,aAAa,OAAO,QAAQ;CAElC,MAAM,kBAAkB,YAAY,KAAK,QACvC,qBAAqB,IAAI,SAAS,CACnC;AAED,gBAAe,UAAU;AACzB,oBAAmB,UAAU;AAC7B,kBAAiB,UAAU;AAC3B,mBAAkB,UAAU;AAC5B,YAAW,UAAU;AAErB,iBAAgB;EACd,MAAM,oBAAoB,iBAAiB;EAC3C,MAAM,oCAAoB,IAAI,KAAiC;EAE/D,MAAM,OAOD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,eAAe,QAAQ,QAAQ,KAAK;GACtD,MAAM,MAAM,eAAe,QAAQ;GACnC,MAAM,SAAS,mBAAmB,QAAQ;GAC1C,MAAM,MAAM,IAAI;AAChB,OAAI,IAAI,WAAW,EACjB;GAGF,MAAM,gBAAgB;IACpB,GAAG,kBAAkB;IACrB,GAAG,iBAAiB;IACpB,GAAG,IAAI;IACR;GAED,MAAM,iBAAiB,MAAM,cAAc,OAAO,GAC9C,cAAc,OAAO,UACpB,cAAc,WACd,OAAO,aAAa,cAAc,WAAW;AAElD,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,GAAG;AAChC,QAAK,KAAK;IACR;IACA;IACA;IACA;IACA;IACA;IACD,CAAC;;EAGJ,MAAM,WAAW,IAAI,IAAI,KAAK,KAAK,MAAM,EAAE,gBAAgB,CAAC;AAE5D,OAAK,MAAM,CAAC,KAAK,WAAW,kBAC1B,KAAI,CAAC,SAAS,IAAI,IAAI,IAAI,OAAO,OAAO,SACtC,QAAO,OAAO,YAAY;AAI9B,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,EAAE,iBAAiB,KAAK,KAAK,eAAe,mBAAmB;GAErE,MAAM,WAAW,kBAAkB,IAAI,gBAAgB;AACvD,OAAI,UAAU,OAAO,YAAY,SAAS,WAAW,gBAAgB;AAEnE,aAAS,OAAO,WAAW,IAAI;IAC/B,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB;AACrD,aAAS,OAAO,WAAW,qBAAqB;AAChD,sBAAkB,IAAI,iBAAiB,SAAS;AAChD;;AAGF,OAAI,UAAU,OAAO,SACnB,UAAS,OAAO,YAAY;GAG9B,MAAM,SAAS,WAAW,QAAQ,SAAS,KAAK,IAAI,UAAU;IAC5D,GAAG;IACH,QAAQ;IACT,CAAC;AACF,qBAAkB,IAAI,iBAAiB;IACrC;IACA,QAAQ;IACT,CAAC;;AAGJ,mBAAiB,UAAU;GAC3B;AAEF,iBAAgB;AACd,eAAa;AACX,QAAK,MAAM,EAAE,YAAY,iBAAiB,QAAQ,QAAQ,CACxD,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,oBAAiB,0BAAU,IAAI,KAAK;;IAErC,EAAE,CAAC"}

package/dist/useHotkeys.cjs

@@ -1,124 +0,0 @@
-const require_HotkeysProvider = require('./HotkeysProvider.cjs');
-const require_utils = require('./utils.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let preact_hooks = require("preact/hooks");
-
-//#region src/useHotkeys.ts
-/**
-* Preact hook for registering multiple keyboard hotkeys at once.
-*
-* Uses the singleton HotkeyManager for efficient event handling.
-* Accepts a dynamic array of hotkey definitions, making it safe to use
-* with variable-length lists without violating the rules of hooks.
-*
-* Options are merged in this order:
-* HotkeysProvider defaults < commonOptions < per-definition options
-*
-* Callbacks and options are synced on every render to avoid stale closures.
-*
-* @param hotkeys - Array of hotkey definitions to register
-* @param commonOptions - Shared options applied to all hotkeys (overridden by per-definition options).
-*   Per-row `enabled: false` still registers that hotkey: `HotkeyManager` suppresses execution only (the row
-*   stays in the store and appears in TanStack Hotkeys devtools). Toggling `enabled` updates the existing handle
-*   via `setOptions` (no unregister/re-register churn).
-*
-* @example
-* ```tsx
-* function Editor() {
-*   useHotkeys([
-*     { hotkey: 'Mod+S', callback: () => save() },
-*     { hotkey: 'Mod+Z', callback: () => undo() },
-*     { hotkey: 'Escape', callback: () => close() },
-*   ])
-* }
-* ```
-*
-* @example
-* ```tsx
-* function MenuShortcuts({ items }) {
-*   // Dynamic hotkeys from data -- safe because it's a single hook call
-*   useHotkeys(
-*     items.map((item) => ({
-*       hotkey: item.shortcut,
-*       callback: item.action,
-*       options: { enabled: item.enabled },
-*     })),
-*     { preventDefault: true },
-*   )
-* }
-* ```
-*/
-function useHotkeys(hotkeys, commonOptions = {}) {
-	const defaultOptions = require_HotkeysProvider.useDefaultHotkeysOptions().hotkey;
-	const manager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	const platform = commonOptions.platform ?? defaultOptions?.platform ?? (0, _tanstack_hotkeys.detectPlatform)();
-	const registrationsRef = (0, preact_hooks.useRef)(/* @__PURE__ */ new Map());
-	const hotkeysRef = (0, preact_hooks.useRef)(hotkeys);
-	const hotkeyStringsRef = (0, preact_hooks.useRef)([]);
-	const commonOptionsRef = (0, preact_hooks.useRef)(commonOptions);
-	const defaultOptionsRef = (0, preact_hooks.useRef)(defaultOptions);
-	const managerRef = (0, preact_hooks.useRef)(manager);
-	const hotkeyStrings = hotkeys.map((def) => (0, _tanstack_hotkeys.normalizeRegisterableHotkey)(def.hotkey, platform));
-	hotkeysRef.current = hotkeys;
-	hotkeyStringsRef.current = hotkeyStrings;
-	commonOptionsRef.current = commonOptions;
-	defaultOptionsRef.current = defaultOptions;
-	managerRef.current = manager;
-	(0, preact_hooks.useEffect)(() => {
-		const prevRegistrations = registrationsRef.current;
-		const nextRegistrations = /* @__PURE__ */ new Map();
-		const rows = [];
-		for (let i = 0; i < hotkeysRef.current.length; i++) {
-			const def = hotkeysRef.current[i];
-			const hotkeyStr = hotkeyStringsRef.current[i];
-			const mergedOptions = {
-				...defaultOptionsRef.current,
-				...commonOptionsRef.current,
-				...def.options
-			};
-			const resolvedTarget = require_utils.isRef(mergedOptions.target) ? mergedOptions.target.current : mergedOptions.target ?? (typeof document !== "undefined" ? document : null);
-			if (!resolvedTarget) continue;
-			const registrationKey = `${i}:${hotkeyStr}`;
-			rows.push({
-				registrationKey,
-				def,
-				hotkeyStr,
-				mergedOptions,
-				resolvedTarget
-			});
-		}
-		const nextKeys = new Set(rows.map((r) => r.registrationKey));
-		for (const [key, record] of prevRegistrations) if (!nextKeys.has(key) && record.handle.isActive) record.handle.unregister();
-		for (const row of rows) {
-			const { registrationKey, def, hotkeyStr, mergedOptions, resolvedTarget } = row;
-			const existing = prevRegistrations.get(registrationKey);
-			if (existing?.handle.isActive && existing.target === resolvedTarget) {
-				existing.handle.callback = def.callback;
-				const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-				existing.handle.setOptions(optionsWithoutTarget);
-				nextRegistrations.set(registrationKey, existing);
-				continue;
-			}
-			if (existing?.handle.isActive) existing.handle.unregister();
-			const handle = managerRef.current.register(hotkeyStr, def.callback, {
-				...mergedOptions,
-				target: resolvedTarget
-			});
-			nextRegistrations.set(registrationKey, {
-				handle,
-				target: resolvedTarget
-			});
-		}
-		registrationsRef.current = nextRegistrations;
-	});
-	(0, preact_hooks.useEffect)(() => {
-		return () => {
-			for (const { handle } of registrationsRef.current.values()) if (handle.isActive) handle.unregister();
-			registrationsRef.current = /* @__PURE__ */ new Map();
-		};
-	}, []);
-}
-
-//#endregion
-exports.useHotkeys = useHotkeys;
-//# sourceMappingURL=useHotkeys.cjs.map