@tanstack/solid-hotkeys 0.11.0 → 0.12.1

package/dist/createHeldKeys.cjs

@@ -1,33 +0,0 @@
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _tanstack_solid_store = require("@tanstack/solid-store");
-
-//#region src/createHeldKeys.ts
-/**
-* SolidJS primitive that returns a signal of currently held keyboard keys.
-*
-* This primitive uses `useSelector` from `@tanstack/solid-store` to subscribe
-* to the global KeyStateTracker and updates whenever keys are pressed
-* or released.
-*
-* @returns Signal accessor for array of currently held key names
-*
-* @example
-* ```tsx
-* function KeyDisplay() {
-*   const heldKeys = createHeldKeys()
-*
-*   return (
-*     <div>
-*       Currently pressed: {heldKeys().join(' + ') || 'None'}
-*     </div>
-*   )
-* }
-* ```
-*/
-function createHeldKeys() {
-	return (0, _tanstack_solid_store.useSelector)((0, _tanstack_hotkeys.getKeyStateTracker)().store, (state) => state.heldKeys);
-}
-
-//#endregion
-exports.createHeldKeys = createHeldKeys;
-//# sourceMappingURL=createHeldKeys.cjs.map

package/dist/createHeldKeys.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createHeldKeys.cjs","names":[],"sources":["../src/createHeldKeys.ts"],"sourcesContent":["import { useSelector } from '@tanstack/solid-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\n\n/**\n * SolidJS primitive that returns a signal of currently held keyboard keys.\n *\n * This primitive uses `useSelector` from `@tanstack/solid-store` to subscribe\n * to the global KeyStateTracker and updates whenever keys are pressed\n * or released.\n *\n * @returns Signal accessor for array of currently held key names\n *\n * @example\n * ```tsx\n * function KeyDisplay() {\n *   const heldKeys = createHeldKeys()\n *\n *   return (\n *     <div>\n *       Currently pressed: {heldKeys().join(' + ') || 'None'}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function createHeldKeys(): () => Array<string> {\n  const tracker = getKeyStateTracker()\n  return useSelector(tracker.store, (state) => state.heldKeys)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,iBAAsC;AAEpD,0FADoC,CACT,QAAQ,UAAU,MAAM,SAAS"}

package/dist/createHeldKeys.d.cts

@@ -1,27 +0,0 @@
-//#region src/createHeldKeys.d.ts
-/**
- * SolidJS primitive that returns a signal of currently held keyboard keys.
- *
- * This primitive uses `useSelector` from `@tanstack/solid-store` to subscribe
- * to the global KeyStateTracker and updates whenever keys are pressed
- * or released.
- *
- * @returns Signal accessor for array of currently held key names
- *
- * @example
- * ```tsx
- * function KeyDisplay() {
- *   const heldKeys = createHeldKeys()
- *
- *   return (
- *     <div>
- *       Currently pressed: {heldKeys().join(' + ') || 'None'}
- *     </div>
- *   )
- * }
- * ```
- */
-declare function createHeldKeys(): () => Array<string>;
-//#endregion
-export { createHeldKeys };
-//# sourceMappingURL=createHeldKeys.d.cts.map

package/dist/createHeldKeys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createHeldKeys.js","names":[],"sources":["../src/createHeldKeys.ts"],"sourcesContent":["import { useSelector } from '@tanstack/solid-store'\nimport { getKeyStateTracker } from '@tanstack/hotkeys'\n\n/**\n * SolidJS primitive that returns a signal of currently held keyboard keys.\n *\n * This primitive uses `useSelector` from `@tanstack/solid-store` to subscribe\n * to the global KeyStateTracker and updates whenever keys are pressed\n * or released.\n *\n * @returns Signal accessor for array of currently held key names\n *\n * @example\n * ```tsx\n * function KeyDisplay() {\n *   const heldKeys = createHeldKeys()\n *\n *   return (\n *     <div>\n *       Currently pressed: {heldKeys().join(' + ') || 'None'}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function createHeldKeys(): () => Array<string> {\n  const tracker = getKeyStateTracker()\n  return useSelector(tracker.store, (state) => state.heldKeys)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,iBAAsC;AAEpD,QAAO,YADS,oBAAoB,CACT,QAAQ,UAAU,MAAM,SAAS"}

package/dist/createHotkey.cjs

@@ -1,120 +0,0 @@
-const require_HotkeysProvider = require('./HotkeysProvider.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let solid_js = require("solid-js");
-
-//#region src/createHotkey.ts
-/**
-* SolidJS primitive for registering a keyboard hotkey.
-*
-* Uses the singleton HotkeyManager for efficient event handling.
-* The callback receives both the keyboard event and a context object
-* containing the hotkey string and parsed hotkey.
-*
-* This primitive automatically tracks reactive dependencies and updates
-* the registration when options or the callback change.
-*
-* @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)
-* @param callback - The function to call when the hotkey is pressed
-* @param options - Options for the hotkey behavior
-*
-* @example
-* ```tsx
-* function SaveButton() {
-*   const [count, setCount] = createSignal(0)
-*
-*   // Callback always has access to latest count value
-*   createHotkey('Mod+S', (event, { hotkey }) => {
-*     console.log(`Save triggered, count is ${count()}`)
-*     handleSave()
-*   })
-*
-*   return <button onClick={() => setCount(c => c + 1)}>Count: {count()}</button>
-* }
-* ```
-*
-* @example
-* ```tsx
-* function Modal(props) {
-*   // enabled option is reactive
-*   createHotkey('Escape', () => {
-*     props.onClose()
-*   }, () => ({ enabled: props.isOpen }))
-*
-*   return <Show when={props.isOpen}>
-*     <div class="modal">...</div>
-*   </Show>
-* }
-* ```
-*
-* @example
-* ```tsx
-* function Editor() {
-*   const [editorRef, setEditorRef] = createSignal<HTMLDivElement | null>(null)
-*
-*   // Scoped to a specific element - use accessor so hotkey waits for ref
-*   createHotkey('Mod+S', save, () => ({ target: editorRef() }))
-*
-*   return <div ref={setEditorRef}>...</div>
-* }
-* ```
-*/
-function createHotkey(hotkey, callback, options = {}) {
-	const defaultOptions = require_HotkeysProvider.useDefaultHotkeysOptions();
-	const manager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	let registration = null;
-	let lastHotkeyString = null;
-	let lastTarget = null;
-	(0, solid_js.onCleanup)(() => {
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
-		}
-		lastHotkeyString = null;
-		lastTarget = null;
-	});
-	(0, solid_js.createEffect)(() => {
-		const resolvedHotkey = typeof hotkey === "function" ? hotkey() : hotkey;
-		const resolvedOptions = typeof options === "function" ? options() : options;
-		const mergedOptions = {
-			...defaultOptions.hotkey,
-			...resolvedOptions
-		};
-		const hotkeyString = (0, _tanstack_hotkeys.normalizeRegisterableHotkey)(resolvedHotkey, mergedOptions.platform ?? (0, _tanstack_hotkeys.detectPlatform)());
-		const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
-		if (!resolvedTarget) {
-			if (registration?.isActive) {
-				registration.unregister();
-				registration = null;
-			}
-			lastHotkeyString = null;
-			lastTarget = null;
-			return;
-		}
-		const { target: _target, ...optionsWithoutTarget } = mergedOptions;
-		(0, solid_js.untrack)(() => {
-			if (registration?.isActive && lastHotkeyString === hotkeyString && lastTarget === resolvedTarget) {
-				registration.callback = callback;
-				registration.setOptions(optionsWithoutTarget);
-				return;
-			}
-			if (registration?.isActive) {
-				registration.unregister();
-				registration = null;
-			}
-			registration = manager.register(hotkeyString, callback, {
-				...optionsWithoutTarget,
-				target: resolvedTarget
-			});
-			if (registration.isActive) {
-				registration.callback = callback;
-				registration.setOptions(optionsWithoutTarget);
-			}
-			lastHotkeyString = hotkeyString;
-			lastTarget = resolvedTarget;
-		});
-	});
-}
-
-//#endregion
-exports.createHotkey = createHotkey;
-//# sourceMappingURL=createHotkey.cjs.map

package/dist/createHotkey.cjs.map

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

package/dist/createHotkey.d.cts

@@ -1,72 +0,0 @@
-import { HotkeyCallback, HotkeyOptions, RegisterableHotkey } from "@tanstack/hotkeys";
-
-//#region src/createHotkey.d.ts
-interface CreateHotkeyOptions extends Omit<HotkeyOptions, 'target'> {
-  /**
-   * The DOM element to attach the event listener to.
-   * Can be a direct DOM element, an accessor (for reactive targets that become
-   * available after mount), or null. Defaults to document.
-   * When using scoped targets, pass an accessor: () => ({ target: elementSignal() })
-   * so the hotkey waits for the element to be attached before registering.
-   */
-  target?: HTMLElement | Document | Window | null;
-}
-/**
- * SolidJS primitive for registering a keyboard hotkey.
- *
- * Uses the singleton HotkeyManager for efficient event handling.
- * The callback receives both the keyboard event and a context object
- * containing the hotkey string and parsed hotkey.
- *
- * This primitive automatically tracks reactive dependencies and updates
- * the registration when options or the callback change.
- *
- * @param hotkey - The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object (supports `mod` for cross-platform)
- * @param callback - The function to call when the hotkey is pressed
- * @param options - Options for the hotkey behavior
- *
- * @example
- * ```tsx
- * function SaveButton() {
- *   const [count, setCount] = createSignal(0)
- *
- *   // Callback always has access to latest count value
- *   createHotkey('Mod+S', (event, { hotkey }) => {
- *     console.log(`Save triggered, count is ${count()}`)
- *     handleSave()
- *   })
- *
- *   return <button onClick={() => setCount(c => c + 1)}>Count: {count()}</button>
- * }
- * ```
- *
- * @example
- * ```tsx
- * function Modal(props) {
- *   // enabled option is reactive
- *   createHotkey('Escape', () => {
- *     props.onClose()
- *   }, () => ({ enabled: props.isOpen }))
- *
- *   return <Show when={props.isOpen}>
- *     <div class="modal">...</div>
- *   </Show>
- * }
- * ```
- *
- * @example
- * ```tsx
- * function Editor() {
- *   const [editorRef, setEditorRef] = createSignal<HTMLDivElement | null>(null)
- *
- *   // Scoped to a specific element - use accessor so hotkey waits for ref
- *   createHotkey('Mod+S', save, () => ({ target: editorRef() }))
- *
- *   return <div ref={setEditorRef}>...</div>
- * }
- * ```
- */
-declare function createHotkey(hotkey: RegisterableHotkey | (() => RegisterableHotkey), callback: HotkeyCallback, options?: CreateHotkeyOptions | (() => CreateHotkeyOptions)): void;
-//#endregion
-export { CreateHotkeyOptions, createHotkey };
-//# sourceMappingURL=createHotkey.d.cts.map

package/dist/createHotkey.js.map

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

package/dist/createHotkeyHint.cjs

@@ -1,20 +0,0 @@
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let solid_js = require("solid-js");
-let _tanstack_solid_store = require("@tanstack/solid-store");
-
-//#region src/createHotkeyHint.ts
-/**
-* Returns a boolean accessor indicating whether held modifiers reveal this shortcut.
-* Pass accessors to track changing bindings and options.
-* Uses the nonempty-subset/AltGr rules of `matchesHeldModifiers`; `exact` requires
-* every modifier. Combine with the action's enabled state before showing a badge.
-* This helper does not register a shortcut or check whether its target is focused.
-*/
-function createHotkeyHint(hotkey, options = {}) {
-	const held = (0, _tanstack_solid_store.useSelector)((0, _tanstack_hotkeys.getKeyStateTracker)().store, (state) => state.heldKeys);
-	return (0, solid_js.createMemo)(() => (0, _tanstack_hotkeys.matchesHeldModifiers)(typeof hotkey === "function" ? hotkey() : hotkey, held(), typeof options === "function" ? options() : options));
-}
-
-//#endregion
-exports.createHotkeyHint = createHotkeyHint;
-//# sourceMappingURL=createHotkeyHint.cjs.map

package/dist/createHotkeyHint.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createHotkeyHint.cjs","names":[],"sources":["../src/createHotkeyHint.ts"],"sourcesContent":["import { createMemo } from 'solid-js'\nimport { useSelector } from '@tanstack/solid-store'\nimport { getKeyStateTracker, matchesHeldModifiers } from '@tanstack/hotkeys'\nimport type { HeldModifierOptions, RegisterableHotkey } from '@tanstack/hotkeys'\n\n/**\n * Returns a boolean accessor indicating whether held modifiers reveal this shortcut.\n * Pass accessors to track changing bindings and options.\n * Uses the nonempty-subset/AltGr rules of `matchesHeldModifiers`; `exact` requires\n * every modifier. Combine with the action's enabled state before showing a badge.\n * This helper does not register a shortcut or check whether its target is focused.\n */\nexport function createHotkeyHint(\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey),\n  options: HeldModifierOptions | (() => HeldModifierOptions) = {},\n): () => boolean {\n  const held = useSelector(\n    getKeyStateTracker().store,\n    (state) => state.heldKeys,\n  )\n  return createMemo(() =>\n    matchesHeldModifiers(\n      typeof hotkey === 'function' ? hotkey() : hotkey,\n      held(),\n      typeof options === 'function' ? options() : options,\n    ),\n  )\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,iBACd,QACA,UAA6D,EAAE,EAChD;CACf,MAAM,yFACgB,CAAC,QACpB,UAAU,MAAM,SAClB;AACD,mFAEI,OAAO,WAAW,aAAa,QAAQ,GAAG,QAC1C,MAAM,EACN,OAAO,YAAY,aAAa,SAAS,GAAG,QAC7C,CACF"}

package/dist/createHotkeyHint.d.cts

@@ -1,14 +0,0 @@
-import { HeldModifierOptions, RegisterableHotkey } from "@tanstack/hotkeys";
-
-//#region src/createHotkeyHint.d.ts
-/**
- * Returns a boolean accessor indicating whether held modifiers reveal this shortcut.
- * Pass accessors to track changing bindings and options.
- * Uses the nonempty-subset/AltGr rules of `matchesHeldModifiers`; `exact` requires
- * every modifier. Combine with the action's enabled state before showing a badge.
- * This helper does not register a shortcut or check whether its target is focused.
- */
-declare function createHotkeyHint(hotkey: RegisterableHotkey | (() => RegisterableHotkey), options?: HeldModifierOptions | (() => HeldModifierOptions)): () => boolean;
-//#endregion
-export { createHotkeyHint };
-//# sourceMappingURL=createHotkeyHint.d.cts.map

package/dist/createHotkeyHint.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createHotkeyHint.js","names":[],"sources":["../src/createHotkeyHint.ts"],"sourcesContent":["import { createMemo } from 'solid-js'\nimport { useSelector } from '@tanstack/solid-store'\nimport { getKeyStateTracker, matchesHeldModifiers } from '@tanstack/hotkeys'\nimport type { HeldModifierOptions, RegisterableHotkey } from '@tanstack/hotkeys'\n\n/**\n * Returns a boolean accessor indicating whether held modifiers reveal this shortcut.\n * Pass accessors to track changing bindings and options.\n * Uses the nonempty-subset/AltGr rules of `matchesHeldModifiers`; `exact` requires\n * every modifier. Combine with the action's enabled state before showing a badge.\n * This helper does not register a shortcut or check whether its target is focused.\n */\nexport function createHotkeyHint(\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey),\n  options: HeldModifierOptions | (() => HeldModifierOptions) = {},\n): () => boolean {\n  const held = useSelector(\n    getKeyStateTracker().store,\n    (state) => state.heldKeys,\n  )\n  return createMemo(() =>\n    matchesHeldModifiers(\n      typeof hotkey === 'function' ? hotkey() : hotkey,\n      held(),\n      typeof options === 'function' ? options() : options,\n    ),\n  )\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,iBACd,QACA,UAA6D,EAAE,EAChD;CACf,MAAM,OAAO,YACX,oBAAoB,CAAC,QACpB,UAAU,MAAM,SAClB;AACD,QAAO,iBACL,qBACE,OAAO,WAAW,aAAa,QAAQ,GAAG,QAC1C,MAAM,EACN,OAAO,YAAY,aAAa,SAAS,GAAG,QAC7C,CACF"}

package/dist/createHotkeyRecorder.cjs

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

package/dist/createHotkeyRecorder.cjs.map

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

package/dist/createHotkeyRecorder.d.cts

@@ -1,60 +0,0 @@
-import { Hotkey, HotkeyRecorderOptions } from "@tanstack/hotkeys";
-
-//#region src/createHotkeyRecorder.d.ts
-interface SolidHotkeyRecorder {
-  /** Whether recording is currently active */
-  isRecording: () => boolean;
-  /** The currently recorded hotkey (for live preview) */
-  recordedHotkey: () => Hotkey | null;
-  /** Start recording a new hotkey */
-  startRecording: () => void;
-  /** Stop recording (same as cancel) */
-  stopRecording: () => void;
-  /** Cancel recording without saving */
-  cancelRecording: () => void;
-}
-/**
- * SolidJS primitive for recording keyboard shortcuts.
- *
- * This primitive provides a thin wrapper around the framework-agnostic `HotkeyRecorder`
- * class, managing all the complexity of capturing keyboard events, converting them
- * to hotkey strings, and handling edge cases like Escape to cancel or Backspace/Delete
- * to clear.
- *
- * This primitive uses `useSelector` from `@tanstack/solid-store` to subscribe
- * to the recorder's store state (same pattern as useHotkeyRecorder in React).
- *
- * @param options - Configuration options for the recorder (or accessor function)
- * @returns An object with recording state signals and control functions
- *
- * @example
- * ```tsx
- * function ShortcutSettings() {
- *   const [shortcut, setShortcut] = createSignal<Hotkey>('Mod+S')
- *
- *   const recorder = createHotkeyRecorder({
- *     onRecord: (hotkey) => {
- *       setShortcut(hotkey)
- *     },
- *     onCancel: () => {
- *       console.log('Recording cancelled')
- *     },
- *   })
- *
- *   return (
- *     <div>
- *       <button onClick={recorder.startRecording}>
- *         {recorder.isRecording() ? 'Recording...' : 'Edit Shortcut'}
- *       </button>
- *       <Show when={recorder.recordedHotkey()}>
- *         <div>Recording: {recorder.recordedHotkey()}</div>
- *       </Show>
- *     </div>
- *   )
- * }
- * ```
- */
-declare function createHotkeyRecorder(options: HotkeyRecorderOptions | (() => HotkeyRecorderOptions)): SolidHotkeyRecorder;
-//#endregion
-export { SolidHotkeyRecorder, createHotkeyRecorder };
-//# sourceMappingURL=createHotkeyRecorder.d.cts.map

package/dist/createHotkeyRecorder.js.map

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

package/dist/createHotkeyRegistrations.cjs

@@ -1,26 +0,0 @@
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _tanstack_solid_store = require("@tanstack/solid-store");
-
-//#region src/createHotkeyRegistrations.ts
-/**
-* Solid primitive that reactively reads all hotkey and sequence registrations
-* from the singleton managers.
-*
-* This is a standalone primitive that does NOT require the HotkeysProvider.
-* It subscribes to both HotkeyManager and SequenceManager stores and
-* triggers reactivity when registrations change.
-*
-* @returns Object with `hotkeys` and `sequences` signal accessors
-*/
-function createHotkeyRegistrations() {
-	const hotkeyManager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	const sequenceManager = (0, _tanstack_hotkeys.getSequenceManager)();
-	return {
-		hotkeys: (0, _tanstack_solid_store.useSelector)(hotkeyManager.registrations, (state) => Array.from(state.values()).map(_tanstack_hotkeys.toHotkeyRegistrationView)),
-		sequences: (0, _tanstack_solid_store.useSelector)(sequenceManager.registrations, (state) => Array.from(state.values()))
-	};
-}
-
-//#endregion
-exports.createHotkeyRegistrations = createHotkeyRegistrations;
-//# sourceMappingURL=createHotkeyRegistrations.cjs.map

package/dist/createHotkeyRegistrations.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createHotkeyRegistrations.cjs","names":["toHotkeyRegistrationView"],"sources":["../src/createHotkeyRegistrations.ts"],"sourcesContent":["import { useSelector } from '@tanstack/solid-store'\nimport {\n  getHotkeyManager,\n  getSequenceManager,\n  toHotkeyRegistrationView,\n} from '@tanstack/hotkeys'\nimport type {\n  HotkeyRegistrationView,\n  SequenceRegistrationView,\n} from '@tanstack/hotkeys'\n\n/**\n * Return type for createHotkeyRegistrations.\n */\nexport interface HotkeyRegistrationsResult {\n  /** Accessor for all registered hotkeys (public view, no callbacks) */\n  hotkeys: () => Array<HotkeyRegistrationView>\n  /** Accessor for all registered sequences */\n  sequences: () => Array<SequenceRegistrationView>\n}\n\n/**\n * Solid primitive that reactively reads all hotkey and sequence registrations\n * from the singleton managers.\n *\n * This is a standalone primitive that does NOT require the HotkeysProvider.\n * It subscribes to both HotkeyManager and SequenceManager stores and\n * triggers reactivity when registrations change.\n *\n * @returns Object with `hotkeys` and `sequences` signal accessors\n */\nexport function createHotkeyRegistrations(): HotkeyRegistrationsResult {\n  const hotkeyManager = getHotkeyManager()\n  const sequenceManager = getSequenceManager()\n\n  const hotkeys = useSelector(hotkeyManager.registrations, (state) =>\n    Array.from(state.values()).map(toHotkeyRegistrationView),\n  )\n\n  const sequences = useSelector(sequenceManager.registrations, (state) =>\n    Array.from(state.values()),\n  )\n\n  return { hotkeys, sequences }\n}\n"],"mappings":";;;;;;;;;;;;;;AA+BA,SAAgB,4BAAuD;CACrE,MAAM,yDAAkC;CACxC,MAAM,6DAAsC;AAU5C,QAAO;EAAE,gDARmB,cAAc,gBAAgB,UACxD,MAAM,KAAK,MAAM,QAAQ,CAAC,CAAC,IAAIA,2CAAyB,CACzD;EAMiB,kDAJY,gBAAgB,gBAAgB,UAC5D,MAAM,KAAK,MAAM,QAAQ,CAAC,CAC3B;EAE4B"}

package/dist/createHotkeyRegistrations.d.cts

@@ -1,26 +0,0 @@
-import { HotkeyRegistrationView, SequenceRegistrationView } from "@tanstack/hotkeys";
-
-//#region src/createHotkeyRegistrations.d.ts
-/**
- * Return type for createHotkeyRegistrations.
- */
-interface HotkeyRegistrationsResult {
-  /** Accessor for all registered hotkeys (public view, no callbacks) */
-  hotkeys: () => Array<HotkeyRegistrationView>;
-  /** Accessor for all registered sequences */
-  sequences: () => Array<SequenceRegistrationView>;
-}
-/**
- * Solid primitive that reactively reads all hotkey and sequence registrations
- * from the singleton managers.
- *
- * This is a standalone primitive that does NOT require the HotkeysProvider.
- * It subscribes to both HotkeyManager and SequenceManager stores and
- * triggers reactivity when registrations change.
- *
- * @returns Object with `hotkeys` and `sequences` signal accessors
- */
-declare function createHotkeyRegistrations(): HotkeyRegistrationsResult;
-//#endregion
-export { HotkeyRegistrationsResult, createHotkeyRegistrations };
-//# sourceMappingURL=createHotkeyRegistrations.d.cts.map

package/dist/createHotkeyRegistrations.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createHotkeyRegistrations.js","names":[],"sources":["../src/createHotkeyRegistrations.ts"],"sourcesContent":["import { useSelector } from '@tanstack/solid-store'\nimport {\n  getHotkeyManager,\n  getSequenceManager,\n  toHotkeyRegistrationView,\n} from '@tanstack/hotkeys'\nimport type {\n  HotkeyRegistrationView,\n  SequenceRegistrationView,\n} from '@tanstack/hotkeys'\n\n/**\n * Return type for createHotkeyRegistrations.\n */\nexport interface HotkeyRegistrationsResult {\n  /** Accessor for all registered hotkeys (public view, no callbacks) */\n  hotkeys: () => Array<HotkeyRegistrationView>\n  /** Accessor for all registered sequences */\n  sequences: () => Array<SequenceRegistrationView>\n}\n\n/**\n * Solid primitive that reactively reads all hotkey and sequence registrations\n * from the singleton managers.\n *\n * This is a standalone primitive that does NOT require the HotkeysProvider.\n * It subscribes to both HotkeyManager and SequenceManager stores and\n * triggers reactivity when registrations change.\n *\n * @returns Object with `hotkeys` and `sequences` signal accessors\n */\nexport function createHotkeyRegistrations(): HotkeyRegistrationsResult {\n  const hotkeyManager = getHotkeyManager()\n  const sequenceManager = getSequenceManager()\n\n  const hotkeys = useSelector(hotkeyManager.registrations, (state) =>\n    Array.from(state.values()).map(toHotkeyRegistrationView),\n  )\n\n  const sequences = useSelector(sequenceManager.registrations, (state) =>\n    Array.from(state.values()),\n  )\n\n  return { hotkeys, sequences }\n}\n"],"mappings":";;;;;;;;;;;;;;AA+BA,SAAgB,4BAAuD;CACrE,MAAM,gBAAgB,kBAAkB;CACxC,MAAM,kBAAkB,oBAAoB;AAU5C,QAAO;EAAE,SARO,YAAY,cAAc,gBAAgB,UACxD,MAAM,KAAK,MAAM,QAAQ,CAAC,CAAC,IAAI,yBAAyB,CACzD;EAMiB,WAJA,YAAY,gBAAgB,gBAAgB,UAC5D,MAAM,KAAK,MAAM,QAAQ,CAAC,CAC3B;EAE4B"}