@tanstack/solid-hotkeys 0.11.0 → 0.12.1

package/dist/createHotkeys.d.cts

@@ -1,57 +0,0 @@
-import { CreateHotkeyOptions } from "./createHotkey.cjs";
-import { HotkeyCallback, RegisterableHotkey } from "@tanstack/hotkeys";
-
-//#region src/createHotkeys.d.ts
-/**
- * A single hotkey definition for use with `createHotkeys`.
- */
-interface CreateHotkeyDefinition {
-  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */
-  hotkey: RegisterableHotkey;
-  /** The function to call when the hotkey is pressed */
-  callback: HotkeyCallback;
-  /** Per-hotkey options (merged on top of commonOptions) */
-  options?: CreateHotkeyOptions;
-}
-/**
- * SolidJS primitive 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.
- *
- * Options are merged in this order:
- * HotkeysProvider defaults < commonOptions < per-definition options
- *
- * @param hotkeys - Array of hotkey definitions, or accessor returning them
- * @param commonOptions - Shared options applied to all hotkeys, or accessor
- *
- * @example
- * ```tsx
- * function Editor() {
- *   createHotkeys([
- *     { hotkey: 'Mod+S', callback: () => save() },
- *     { hotkey: 'Mod+Z', callback: () => undo() },
- *     { hotkey: 'Escape', callback: () => close() },
- *   ])
- * }
- * ```
- *
- * @example
- * ```tsx
- * function MenuShortcuts(props) {
- *   createHotkeys(
- *     () => props.items.map((item) => ({
- *       hotkey: item.shortcut,
- *       callback: item.action,
- *       options: { enabled: item.enabled },
- *     })),
- *     { preventDefault: true },
- *   )
- * }
- * ```
- */
-declare function createHotkeys(hotkeys: Array<CreateHotkeyDefinition> | (() => Array<CreateHotkeyDefinition>), commonOptions?: CreateHotkeyOptions | (() => CreateHotkeyOptions)): void;
-//#endregion
-export { CreateHotkeyDefinition, createHotkeys };
-//# sourceMappingURL=createHotkeys.d.cts.map

package/dist/createHotkeys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createHotkeys.js","names":[],"sources":["../src/createHotkeys.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 { CreateHotkeyOptions } from './createHotkey'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\n/**\n * A single hotkey definition for use with `createHotkeys`.\n */\nexport interface CreateHotkeyDefinition {\n  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */\n  hotkey: RegisterableHotkey\n  /** The function to call when the hotkey is pressed */\n  callback: HotkeyCallback\n  /** Per-hotkey options (merged on top of commonOptions) */\n  options?: CreateHotkeyOptions\n}\n\n/**\n * SolidJS primitive for registering multiple keyboard hotkeys at once.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * Accepts a dynamic array of hotkey definitions, making it safe to use\n * with variable-length lists.\n *\n * Options are merged in this order:\n * HotkeysProvider defaults < commonOptions < per-definition options\n *\n * @param hotkeys - Array of hotkey definitions, or accessor returning them\n * @param commonOptions - Shared options applied to all hotkeys, or accessor\n *\n * @example\n * ```tsx\n * function Editor() {\n *   createHotkeys([\n *     { hotkey: 'Mod+S', callback: () => save() },\n *     { hotkey: 'Mod+Z', callback: () => undo() },\n *     { hotkey: 'Escape', callback: () => close() },\n *   ])\n * }\n * ```\n *\n * @example\n * ```tsx\n * function MenuShortcuts(props) {\n *   createHotkeys(\n *     () => props.items.map((item) => ({\n *       hotkey: item.shortcut,\n *       callback: item.action,\n *       options: { enabled: item.enabled },\n *     })),\n *     { preventDefault: true },\n *   )\n * }\n * ```\n */\nexport function createHotkeys(\n  hotkeys:\n    | Array<CreateHotkeyDefinition>\n    | (() => Array<CreateHotkeyDefinition>),\n  commonOptions: CreateHotkeyOptions | (() => CreateHotkeyOptions) = {},\n): void {\n  type RegistrationRecord = {\n    handle: HotkeyRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = useDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n\n  const registrations = new Map<string, RegistrationRecord>()\n\n  // Clean up only when this component/scope disposes — not before every effect\n  // re-run. An inner `onCleanup` inside `createEffect` runs whenever reactive\n  // deps change (e.g. dynamic hotkey list), which unregistered every hotkey and\n  // re-registered them, flooding the manager store and could freeze the tab.\n  onCleanup(() => {\n    for (const { handle } of registrations.values()) {\n      if (handle.isActive) {\n        handle.unregister()\n      }\n    }\n    registrations.clear()\n  })\n\n  createEffect(() => {\n    const resolvedHotkeys = typeof hotkeys === 'function' ? hotkeys() : hotkeys\n    const resolvedCommonOptions =\n      typeof commonOptions === 'function' ? commonOptions() : commonOptions\n\n    const nextKeys = new Set<string>()\n    const prepared: Array<{\n      registrationKey: string\n      def: CreateHotkeyDefinition\n      mergedOptions: CreateHotkeyOptions\n      hotkeyString: Hotkey\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < resolvedHotkeys.length; i++) {\n      const def = resolvedHotkeys[i]!\n      const resolvedDefOptions = def.options ?? {}\n\n      const mergedOptions = {\n        ...defaultOptions.hotkey,\n        ...resolvedCommonOptions,\n        ...resolvedDefOptions,\n      } as CreateHotkeyOptions\n\n      const platform = mergedOptions.platform ?? detectPlatform()\n      const hotkeyString = normalizeRegisterableHotkey(def.hotkey, platform)\n\n      const resolvedTarget =\n        'target' in mergedOptions\n          ? (mergedOptions.target ?? null)\n          : typeof document !== 'undefined'\n            ? document\n            : null\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${hotkeyString}`\n      nextKeys.add(registrationKey)\n      prepared.push({\n        registrationKey,\n        def,\n        mergedOptions,\n        hotkeyString,\n        resolvedTarget,\n      })\n    }\n\n    // Untrack store mutations so that registering/updating hotkeys doesn't\n    // create a circular reactive dependency when createHotkeyRegistrations\n    // subscribes to the same store.\n    untrack(() => {\n      // Drop stale keys first so list index shifts don't briefly double-register\n      // the same hotkey+target (conflictBehavior: 'warn' + devtools can loop).\n      for (const [key, record] of [...registrations.entries()]) {\n        if (!nextKeys.has(key)) {\n          if (record.handle.isActive) {\n            record.handle.unregister()\n          }\n          registrations.delete(key)\n        }\n      }\n\n      for (const p of prepared) {\n        const existing = registrations.get(p.registrationKey)\n        if (existing?.handle.isActive && existing.target === p.resolvedTarget) {\n          existing.handle.callback = p.def.callback\n          const { target: _target, ...optionsWithoutTarget } = p.mergedOptions\n          existing.handle.setOptions(optionsWithoutTarget)\n          continue\n        }\n\n        if (existing) {\n          if (existing.handle.isActive) {\n            existing.handle.unregister()\n          }\n          registrations.delete(p.registrationKey)\n        }\n\n        const { target: _target, ...optionsWithoutTarget } = p.mergedOptions\n        const handle = manager.register(p.hotkeyString, p.def.callback, {\n          ...optionsWithoutTarget,\n          target: p.resolvedTarget,\n        })\n        registrations.set(p.registrationKey, {\n          handle,\n          target: p.resolvedTarget,\n        })\n      }\n    })\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA,SAAgB,cACd,SAGA,gBAAmE,EAAE,EAC/D;CAMN,MAAM,iBAAiB,0BAA0B;CACjD,MAAM,UAAU,kBAAkB;CAElC,MAAM,gCAAgB,IAAI,KAAiC;AAM3D,iBAAgB;AACd,OAAK,MAAM,EAAE,YAAY,cAAc,QAAQ,CAC7C,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,gBAAc,OAAO;GACrB;AAEF,oBAAmB;EACjB,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EACpE,MAAM,wBACJ,OAAO,kBAAkB,aAAa,eAAe,GAAG;EAE1D,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAMD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK;GAC/C,MAAM,MAAM,gBAAgB;GAC5B,MAAM,qBAAqB,IAAI,WAAW,EAAE;GAE5C,MAAM,gBAAgB;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;GAED,MAAM,WAAW,cAAc,YAAY,gBAAgB;GAC3D,MAAM,eAAe,4BAA4B,IAAI,QAAQ,SAAS;GAEtE,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,GAAG;AAChC,YAAS,IAAI,gBAAgB;AAC7B,YAAS,KAAK;IACZ;IACA;IACA;IACA;IACA;IACD,CAAC;;AAMJ,gBAAc;AAGZ,QAAK,MAAM,CAAC,KAAK,WAAW,CAAC,GAAG,cAAc,SAAS,CAAC,CACtD,KAAI,CAAC,SAAS,IAAI,IAAI,EAAE;AACtB,QAAI,OAAO,OAAO,SAChB,QAAO,OAAO,YAAY;AAE5B,kBAAc,OAAO,IAAI;;AAI7B,QAAK,MAAM,KAAK,UAAU;IACxB,MAAM,WAAW,cAAc,IAAI,EAAE,gBAAgB;AACrD,QAAI,UAAU,OAAO,YAAY,SAAS,WAAW,EAAE,gBAAgB;AACrE,cAAS,OAAO,WAAW,EAAE,IAAI;KACjC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;AACvD,cAAS,OAAO,WAAW,qBAAqB;AAChD;;AAGF,QAAI,UAAU;AACZ,SAAI,SAAS,OAAO,SAClB,UAAS,OAAO,YAAY;AAE9B,mBAAc,OAAO,EAAE,gBAAgB;;IAGzC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;IACvD,MAAM,SAAS,QAAQ,SAAS,EAAE,cAAc,EAAE,IAAI,UAAU;KAC9D,GAAG;KACH,QAAQ,EAAE;KACX,CAAC;AACF,kBAAc,IAAI,EAAE,iBAAiB;KACnC;KACA,QAAQ,EAAE;KACX,CAAC;;IAEJ;GACF"}

package/dist/createKeyHold.cjs

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

package/dist/createKeyHold.cjs.map

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

package/dist/createKeyHold.d.cts

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

package/dist/createKeyHold.js.map

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

package/dist/index.cjs

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

package/dist/index.d.cts

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

package/src/HotkeysProvider.tsx

@@ -1,51 +0,0 @@
-import { createContext, useContext } from 'solid-js'
-import type { JSX, ParentComponent } from 'solid-js'
-import type {
-  HotkeyRecorderOptions,
-  HotkeySequenceRecorderOptions,
-} from '@tanstack/hotkeys'
-import type { CreateHotkeyOptions } from './createHotkey'
-import type { CreateHotkeySequenceOptions } from './createHotkeySequence'
-
-export interface HotkeysProviderOptions {
-  hotkey?: Partial<CreateHotkeyOptions>
-  hotkeyRecorder?: Partial<HotkeyRecorderOptions>
-  hotkeySequenceRecorder?: Partial<HotkeySequenceRecorderOptions>
-  hotkeySequence?: Partial<CreateHotkeySequenceOptions>
-}
-
-interface HotkeysContextValue {
-  defaultOptions: HotkeysProviderOptions
-}
-
-const HotkeysContext = createContext<HotkeysContextValue | null>(null)
-
-export interface HotkeysProviderProps {
-  children: JSX.Element
-  defaultOptions?: HotkeysProviderOptions
-}
-
-const DEFAULT_OPTIONS: HotkeysProviderOptions = {}
-
-export const HotkeysProvider: ParentComponent<HotkeysProviderProps> = (
-  props,
-) => {
-  const contextValue: HotkeysContextValue = {
-    defaultOptions: props.defaultOptions ?? DEFAULT_OPTIONS,
-  }
-
-  return (
-    <HotkeysContext.Provider value={contextValue}>
-      {props.children}
-    </HotkeysContext.Provider>
-  )
-}
-
-export function useHotkeysContext() {
-  return useContext(HotkeysContext)
-}
-
-export function useDefaultHotkeysOptions() {
-  const context = useContext(HotkeysContext)
-  return context?.defaultOptions ?? {}
-}

package/src/createHeldKeyCodes.ts

@@ -1,38 +0,0 @@
-import { useSelector } from '@tanstack/solid-store'
-import { getKeyStateTracker } from '@tanstack/hotkeys'
-
-/**
- * SolidJS primitive that returns a signal of a map from currently held key names to their physical `event.code` values.
- *
- * This is useful for debugging which physical key was pressed (e.g. distinguishing
- * left vs right Shift via "ShiftLeft" / "ShiftRight").
- *
- * This primitive uses `useSelector` from `@tanstack/solid-store` to subscribe
- * to the global KeyStateTracker.
- *
- * @returns Signal accessor for record mapping normalized key names to their `event.code` values
- *
- * @example
- * ```tsx
- * function KeyDebugDisplay() {
- *   const heldKeys = createHeldKeys()
- *   const heldCodes = createHeldKeyCodes()
- *
- *   return (
- *     <div>
- *       <For each={heldKeys()}>
- *         {(key) => (
- *           <kbd>
- *             {key} <small>{heldCodes()[key]}</small>
- *           </kbd>
- *         )}
- *       </For>
- *     </div>
- *   )
- * }
- * ```
- */
-export function createHeldKeyCodes(): () => Record<string, string> {
-  const tracker = getKeyStateTracker()
-  return useSelector(tracker.store, (state) => state.heldCodes)
-}

package/src/createHeldKeys.ts

@@ -1,29 +0,0 @@
-import { useSelector } from '@tanstack/solid-store'
-import { getKeyStateTracker } from '@tanstack/hotkeys'
-
-/**
- * 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>
- *   )
- * }
- * ```
- */
-export function createHeldKeys(): () => Array<string> {
-  const tracker = getKeyStateTracker()
-  return useSelector(tracker.store, (state) => state.heldKeys)
-}

package/src/createHotkey.ts

@@ -1,172 +0,0 @@
-import { createEffect, onCleanup, untrack } from 'solid-js'
-import {
-  detectPlatform,
-  getHotkeyManager,
-  normalizeRegisterableHotkey,
-} from '@tanstack/hotkeys'
-import { useDefaultHotkeysOptions } from './HotkeysProvider'
-import type {
-  Hotkey,
-  HotkeyCallback,
-  HotkeyOptions,
-  HotkeyRegistrationHandle,
-  RegisterableHotkey,
-} from '@tanstack/hotkeys'
-
-export 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>
- * }
- * ```
- */
-export function createHotkey(
-  hotkey: RegisterableHotkey | (() => RegisterableHotkey),
-  callback: HotkeyCallback,
-  options: CreateHotkeyOptions | (() => CreateHotkeyOptions) = {},
-): void {
-  const defaultOptions = useDefaultHotkeysOptions()
-  const manager = getHotkeyManager()
-
-  let registration: HotkeyRegistrationHandle | null = null
-  let lastHotkeyString: Hotkey | null = null
-  let lastTarget: HTMLElement | Document | Window | null = null
-
-  onCleanup(() => {
-    if (registration?.isActive) {
-      registration.unregister()
-      registration = null
-    }
-    lastHotkeyString = null
-    lastTarget = null
-  })
-
-  createEffect(() => {
-    // Resolve reactive values
-    const resolvedHotkey = typeof hotkey === 'function' ? hotkey() : hotkey
-    const resolvedOptions = typeof options === 'function' ? options() : options
-
-    const mergedOptions = {
-      ...defaultOptions.hotkey,
-      ...resolvedOptions,
-    } as CreateHotkeyOptions
-
-    // Normalize to hotkey string
-    const platform = mergedOptions.platform ?? detectPlatform()
-    const hotkeyString = normalizeRegisterableHotkey(resolvedHotkey, platform)
-
-    // Resolve target: when explicitly provided (even as null), use it and skip if null.
-    // When not provided, default to document. Matches React's ref handling.
-    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
-    }
-
-    // Extract options without target (target is handled separately)
-    const { target: _target, ...optionsWithoutTarget } = mergedOptions
-
-    // Untrack store mutations so that registering/updating the hotkey doesn't
-    // create a circular reactive dependency when createHotkeyRegistrations
-    // subscribes to the same store.
-    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
-    })
-  })
-}

package/src/createHotkeyHint.ts

@@ -1,28 +0,0 @@
-import { createMemo } from 'solid-js'
-import { useSelector } from '@tanstack/solid-store'
-import { getKeyStateTracker, matchesHeldModifiers } from '@tanstack/hotkeys'
-import type { HeldModifierOptions, RegisterableHotkey } from '@tanstack/hotkeys'
-
-/**
- * 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.
- */
-export function createHotkeyHint(
-  hotkey: RegisterableHotkey | (() => RegisterableHotkey),
-  options: HeldModifierOptions | (() => HeldModifierOptions) = {},
-): () => boolean {
-  const held = useSelector(
-    getKeyStateTracker().store,
-    (state) => state.heldKeys,
-  )
-  return createMemo(() =>
-    matchesHeldModifiers(
-      typeof hotkey === 'function' ? hotkey() : hotkey,
-      held(),
-      typeof options === 'function' ? options() : options,
-    ),
-  )
-}

package/src/createHotkeyRecorder.ts

@@ -1,103 +0,0 @@
-import { createEffect, onCleanup } from 'solid-js'
-import { useSelector } from '@tanstack/solid-store'
-import { HotkeyRecorder } from '@tanstack/hotkeys'
-import { useDefaultHotkeysOptions } from './HotkeysProvider'
-import type { Hotkey, HotkeyRecorderOptions } from '@tanstack/hotkeys'
-
-export 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>
- *   )
- * }
- * ```
- */
-export function createHotkeyRecorder(
-  options: HotkeyRecorderOptions | (() => HotkeyRecorderOptions),
-): SolidHotkeyRecorder {
-  const defaultOptions = useDefaultHotkeysOptions()
-
-  const resolvedOptions = typeof options === 'function' ? options() : options
-  const mergedOptions = {
-    ...defaultOptions.hotkeyRecorder,
-    ...resolvedOptions,
-  } as HotkeyRecorderOptions
-
-  // Create recorder once synchronously (matches React's useRef pattern)
-  const recorder = new HotkeyRecorder(mergedOptions)
-
-  // Subscribe to recorder state using useSelector (same pattern as useHotkeyRecorder)
-  const isRecording = useSelector(recorder.store, (state) => state.isRecording)
-  const recordedHotkey = useSelector(
-    recorder.store,
-    (state) => state.recordedHotkey,
-  )
-
-  // Sync options on every effect run (matches React's sync on render)
-  createEffect(() => {
-    const resolved = typeof options === 'function' ? options() : options
-    recorder.setOptions({
-      ...defaultOptions.hotkeyRecorder,
-      ...resolved,
-    } as HotkeyRecorderOptions)
-  })
-
-  // Cleanup on unmount
-  onCleanup(() => {
-    recorder.destroy()
-  })
-
-  return {
-    isRecording,
-    recordedHotkey,
-    startRecording: () => recorder.start(),
-    stopRecording: () => recorder.stop(),
-    cancelRecording: () => recorder.cancel(),
-  }
-}