@tanstack/lit-hotkeys 0.11.0 → 0.13.0

package/dist/decorators/hotkey-sequence.cjs

@@ -1,45 +0,0 @@
-const require_constants = require('../constants.cjs');
-const require_hotkey_sequence = require('../controllers/hotkey-sequence.cjs');
-
-//#region src/decorators/hotkey-sequence.ts
-/**
-* Decorator that registers a keyboard sequence (e.g. Vim-style) on the element
-* when it connects and unregisters when it disconnects. Uses
-* {@link HotkeySequenceController} under the hood.
-*
-* @param sequence - The key sequence to listen for (e.g. `['G', 'G']` for "g g").
-* @param options - Optional sequence options (target, timeout, enabled, etc.).
-* @returns A method decorator for use on LitElement methods.
-*
-* @example
-* ```ts
-* class MyElement extends LitElement {
-*   @hotkeySequence(['G', 'G'])
-*   goToTop() { window.scrollTo(0, 0) }
-*
-*   @hotkeySequence(['D', 'D'], { timeout: 500 })
-*   deleteLine() { this.deleteCurrentLine() }
-* }
-* ```
-*/
-function hotkeySequence(sequence, options = require_constants.HOTKEY_SEQUENCE_DEFAULT_OPTIONS) {
-	return function(proto, methodName, descriptor) {
-		const originalConnected = proto.connectedCallback;
-		const controllerKey = Symbol(`@hotkeySequence:${methodName}`);
-		proto.connectedCallback = function() {
-			originalConnected.call(this);
-			const host = this;
-			if (!host[controllerKey]) {
-				const callback = descriptor.value ? descriptor.value.bind(this) : host[methodName].bind(this);
-				if (typeof callback !== "function") throw new Error(`@hotkeySequence decorator can only be applied to functions`);
-				const controller = new require_hotkey_sequence.HotkeySequenceController(this, sequence, callback, options);
-				host[controllerKey] = controller;
-				this.addController(controller);
-			}
-		};
-	};
-}
-
-//#endregion
-exports.hotkeySequence = hotkeySequence;
-//# sourceMappingURL=hotkey-sequence.cjs.map

package/dist/decorators/hotkey-sequence.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hotkey-sequence.cjs","names":["HOTKEY_SEQUENCE_DEFAULT_OPTIONS","HotkeySequenceController"],"sources":["../../src/decorators/hotkey-sequence.ts"],"sourcesContent":["import { HotkeySequenceController } from '../controllers/hotkey-sequence'\nimport { HOTKEY_SEQUENCE_DEFAULT_OPTIONS } from '../constants'\nimport type { LitElement } from 'lit'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n} from '@tanstack/hotkeys'\n\n/**\n * Decorator that registers a keyboard sequence (e.g. Vim-style) on the element\n * when it connects and unregisters when it disconnects. Uses\n * {@link HotkeySequenceController} under the hood.\n *\n * @param sequence - The key sequence to listen for (e.g. `['G', 'G']` for \"g g\").\n * @param options - Optional sequence options (target, timeout, enabled, etc.).\n * @returns A method decorator for use on LitElement methods.\n *\n * @example\n * ```ts\n * class MyElement extends LitElement {\n *   @hotkeySequence(['G', 'G'])\n *   goToTop() { window.scrollTo(0, 0) }\n *\n *   @hotkeySequence(['D', 'D'], { timeout: 500 })\n *   deleteLine() { this.deleteCurrentLine() }\n * }\n * ```\n */\nexport function hotkeySequence(\n  sequence: HotkeySequence,\n  options: SequenceOptions = HOTKEY_SEQUENCE_DEFAULT_OPTIONS,\n) {\n  return function <T extends HotkeyCallback>(\n    proto: LitElement,\n    methodName: string,\n    descriptor: TypedPropertyDescriptor<T>,\n  ) {\n    const originalConnected = proto.connectedCallback\n    const controllerKey = Symbol(`@hotkeySequence:${methodName}`)\n\n    proto.connectedCallback = function () {\n      originalConnected.call(this)\n\n      const host = this as unknown as {\n        [key: symbol]: HotkeySequenceController | undefined\n        addController: (c: unknown) => void\n        [key: string]: unknown\n      }\n      if (!host[controllerKey]) {\n        const callback: HotkeyCallback = descriptor.value\n          ? descriptor.value.bind(this)\n          : (host[methodName] as HotkeyCallback).bind(this)\n\n        if (typeof callback !== 'function') {\n          throw new Error(\n            `@hotkeySequence decorator can only be applied to functions`,\n          )\n        }\n\n        const controller: HotkeySequenceController =\n          new HotkeySequenceController(this, sequence, callback, options)\n        host[controllerKey] = controller\n        this.addController(controller)\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,eACd,UACA,UAA2BA,mDAC3B;AACA,QAAO,SACL,OACA,YACA,YACA;EACA,MAAM,oBAAoB,MAAM;EAChC,MAAM,gBAAgB,OAAO,mBAAmB,aAAa;AAE7D,QAAM,oBAAoB,WAAY;AACpC,qBAAkB,KAAK,KAAK;GAE5B,MAAM,OAAO;AAKb,OAAI,CAAC,KAAK,gBAAgB;IACxB,MAAM,WAA2B,WAAW,QACxC,WAAW,MAAM,KAAK,KAAK,GAC1B,KAAK,YAA+B,KAAK,KAAK;AAEnD,QAAI,OAAO,aAAa,WACtB,OAAM,IAAI,MACR,6DACD;IAGH,MAAM,aACJ,IAAIC,iDAAyB,MAAM,UAAU,UAAU,QAAQ;AACjE,SAAK,iBAAiB;AACtB,SAAK,cAAc,WAAW"}

package/dist/decorators/hotkey-sequence.d.cts

@@ -1,28 +0,0 @@
-import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
-import { LitElement } from "lit";
-
-//#region src/decorators/hotkey-sequence.d.ts
-/**
- * Decorator that registers a keyboard sequence (e.g. Vim-style) on the element
- * when it connects and unregisters when it disconnects. Uses
- * {@link HotkeySequenceController} under the hood.
- *
- * @param sequence - The key sequence to listen for (e.g. `['G', 'G']` for "g g").
- * @param options - Optional sequence options (target, timeout, enabled, etc.).
- * @returns A method decorator for use on LitElement methods.
- *
- * @example
- * ```ts
- * class MyElement extends LitElement {
- *   @hotkeySequence(['G', 'G'])
- *   goToTop() { window.scrollTo(0, 0) }
- *
- *   @hotkeySequence(['D', 'D'], { timeout: 500 })
- *   deleteLine() { this.deleteCurrentLine() }
- * }
- * ```
- */
-declare function hotkeySequence(sequence: HotkeySequence, options?: SequenceOptions): <T extends HotkeyCallback>(proto: LitElement, methodName: string, descriptor: TypedPropertyDescriptor<T>) => void;
-//#endregion
-export { hotkeySequence };
-//# sourceMappingURL=hotkey-sequence.d.cts.map

package/dist/decorators/hotkey-sequence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hotkey-sequence.js","names":[],"sources":["../../src/decorators/hotkey-sequence.ts"],"sourcesContent":["import { HotkeySequenceController } from '../controllers/hotkey-sequence'\nimport { HOTKEY_SEQUENCE_DEFAULT_OPTIONS } from '../constants'\nimport type { LitElement } from 'lit'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n} from '@tanstack/hotkeys'\n\n/**\n * Decorator that registers a keyboard sequence (e.g. Vim-style) on the element\n * when it connects and unregisters when it disconnects. Uses\n * {@link HotkeySequenceController} under the hood.\n *\n * @param sequence - The key sequence to listen for (e.g. `['G', 'G']` for \"g g\").\n * @param options - Optional sequence options (target, timeout, enabled, etc.).\n * @returns A method decorator for use on LitElement methods.\n *\n * @example\n * ```ts\n * class MyElement extends LitElement {\n *   @hotkeySequence(['G', 'G'])\n *   goToTop() { window.scrollTo(0, 0) }\n *\n *   @hotkeySequence(['D', 'D'], { timeout: 500 })\n *   deleteLine() { this.deleteCurrentLine() }\n * }\n * ```\n */\nexport function hotkeySequence(\n  sequence: HotkeySequence,\n  options: SequenceOptions = HOTKEY_SEQUENCE_DEFAULT_OPTIONS,\n) {\n  return function <T extends HotkeyCallback>(\n    proto: LitElement,\n    methodName: string,\n    descriptor: TypedPropertyDescriptor<T>,\n  ) {\n    const originalConnected = proto.connectedCallback\n    const controllerKey = Symbol(`@hotkeySequence:${methodName}`)\n\n    proto.connectedCallback = function () {\n      originalConnected.call(this)\n\n      const host = this as unknown as {\n        [key: symbol]: HotkeySequenceController | undefined\n        addController: (c: unknown) => void\n        [key: string]: unknown\n      }\n      if (!host[controllerKey]) {\n        const callback: HotkeyCallback = descriptor.value\n          ? descriptor.value.bind(this)\n          : (host[methodName] as HotkeyCallback).bind(this)\n\n        if (typeof callback !== 'function') {\n          throw new Error(\n            `@hotkeySequence decorator can only be applied to functions`,\n          )\n        }\n\n        const controller: HotkeySequenceController =\n          new HotkeySequenceController(this, sequence, callback, options)\n        host[controllerKey] = controller\n        this.addController(controller)\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,eACd,UACA,UAA2B,iCAC3B;AACA,QAAO,SACL,OACA,YACA,YACA;EACA,MAAM,oBAAoB,MAAM;EAChC,MAAM,gBAAgB,OAAO,mBAAmB,aAAa;AAE7D,QAAM,oBAAoB,WAAY;AACpC,qBAAkB,KAAK,KAAK;GAE5B,MAAM,OAAO;AAKb,OAAI,CAAC,KAAK,gBAAgB;IACxB,MAAM,WAA2B,WAAW,QACxC,WAAW,MAAM,KAAK,KAAK,GAC1B,KAAK,YAA+B,KAAK,KAAK;AAEnD,QAAI,OAAO,aAAa,WACtB,OAAM,IAAI,MACR,6DACD;IAGH,MAAM,aACJ,IAAI,yBAAyB,MAAM,UAAU,UAAU,QAAQ;AACjE,SAAK,iBAAiB;AACtB,SAAK,cAAc,WAAW"}

package/dist/decorators/hotkey.cjs

@@ -1,44 +0,0 @@
-const require_constants = require('../constants.cjs');
-const require_hotkey = require('../controllers/hotkey.cjs');
-
-//#region src/decorators/hotkey.ts
-/**
-* Decorator that registers a keyboard hotkey on the element when it connects
-* and unregisters when it disconnects. Uses {@link HotkeyController} under the hood.
-*
-* @param hotkey - The key or key combo to listen for (e.g. `'Mod+S'` or a raw hotkey object).
-* @param options - Optional registration options (target, platform, enabled, etc.).
-* @returns A method decorator for use on LitElement methods.
-*
-* @example
-* ```ts
-* class MyElement extends LitElement {
-*   @hotkey('Mod+S')
-*   save() { this.doSave() }
-*
-*   @hotkey('Escape')
-*   close() { this.dismiss() }
-* }
-* ```
-*/
-function hotkey(hotkey, options = require_constants.HOTKEY_DEFAULT_OPTIONS) {
-	return function(proto, propertyKey, descriptor) {
-		const originalConnected = proto.connectedCallback;
-		const controllerKey = Symbol(`@hotkey:${propertyKey}`);
-		proto.connectedCallback = function() {
-			originalConnected.call(this);
-			const host = this;
-			if (!host[controllerKey]) {
-				const callback = descriptor?.value ? descriptor.value.bind(this) : host[propertyKey];
-				if (typeof callback !== "function") throw new Error(`@hotkey decorator can only be applied to functions`);
-				const controller = new require_hotkey.HotkeyController(this, hotkey, callback, options);
-				host[controllerKey] = controller;
-				this.addController(controller);
-			}
-		};
-	};
-}
-
-//#endregion
-exports.hotkey = hotkey;
-//# sourceMappingURL=hotkey.cjs.map

package/dist/decorators/hotkey.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hotkey.cjs","names":["HOTKEY_DEFAULT_OPTIONS","HotkeyController"],"sources":["../../src/decorators/hotkey.ts"],"sourcesContent":["import { HotkeyController } from '../controllers/hotkey'\nimport { HOTKEY_DEFAULT_OPTIONS } from '../constants'\nimport type { LitElement } from 'lit'\nimport type {\n  HotkeyCallback,\n  HotkeyOptions,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\n/**\n * Decorator that registers a keyboard hotkey on the element when it connects\n * and unregisters when it disconnects. Uses {@link HotkeyController} under the hood.\n *\n * @param hotkey - The key or key combo to listen for (e.g. `'Mod+S'` or a raw hotkey object).\n * @param options - Optional registration options (target, platform, enabled, etc.).\n * @returns A method decorator for use on LitElement methods.\n *\n * @example\n * ```ts\n * class MyElement extends LitElement {\n *   @hotkey('Mod+S')\n *   save() { this.doSave() }\n *\n *   @hotkey('Escape')\n *   close() { this.dismiss() }\n * }\n * ```\n */\nexport function hotkey(\n  hotkey: RegisterableHotkey,\n  options: HotkeyOptions = HOTKEY_DEFAULT_OPTIONS,\n) {\n  return function <T extends HotkeyCallback>(\n    proto: LitElement,\n    propertyKey: string,\n    descriptor?: TypedPropertyDescriptor<T>,\n  ) {\n    const originalConnected = proto.connectedCallback\n    const controllerKey = Symbol(`@hotkey:${propertyKey}`)\n\n    proto.connectedCallback = function () {\n      originalConnected.call(this)\n\n      const host = this as unknown as {\n        [key: symbol]: HotkeyController | undefined\n        addController: (c: unknown) => void\n        [key: string]: unknown\n      }\n\n      if (!host[controllerKey]) {\n        const callback: HotkeyCallback = descriptor?.value\n          ? (descriptor.value.bind(this) as HotkeyCallback)\n          : (host[propertyKey] as HotkeyCallback)\n\n        if (typeof callback !== 'function') {\n          throw new Error(`@hotkey decorator can only be applied to functions`)\n        }\n\n        const controller: HotkeyController = new HotkeyController(\n          this,\n          hotkey,\n          callback,\n          options,\n        )\n        host[controllerKey] = controller\n        this.addController(controller)\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,OACd,QACA,UAAyBA,0CACzB;AACA,QAAO,SACL,OACA,aACA,YACA;EACA,MAAM,oBAAoB,MAAM;EAChC,MAAM,gBAAgB,OAAO,WAAW,cAAc;AAEtD,QAAM,oBAAoB,WAAY;AACpC,qBAAkB,KAAK,KAAK;GAE5B,MAAM,OAAO;AAMb,OAAI,CAAC,KAAK,gBAAgB;IACxB,MAAM,WAA2B,YAAY,QACxC,WAAW,MAAM,KAAK,KAAK,GAC3B,KAAK;AAEV,QAAI,OAAO,aAAa,WACtB,OAAM,IAAI,MAAM,qDAAqD;IAGvE,MAAM,aAA+B,IAAIC,gCACvC,MACA,QACA,UACA,QACD;AACD,SAAK,iBAAiB;AACtB,SAAK,cAAc,WAAW"}

package/dist/decorators/hotkey.d.cts

@@ -1,27 +0,0 @@
-import { HotkeyCallback, HotkeyOptions, RegisterableHotkey } from "@tanstack/hotkeys";
-import { LitElement } from "lit";
-
-//#region src/decorators/hotkey.d.ts
-/**
- * Decorator that registers a keyboard hotkey on the element when it connects
- * and unregisters when it disconnects. Uses {@link HotkeyController} under the hood.
- *
- * @param hotkey - The key or key combo to listen for (e.g. `'Mod+S'` or a raw hotkey object).
- * @param options - Optional registration options (target, platform, enabled, etc.).
- * @returns A method decorator for use on LitElement methods.
- *
- * @example
- * ```ts
- * class MyElement extends LitElement {
- *   @hotkey('Mod+S')
- *   save() { this.doSave() }
- *
- *   @hotkey('Escape')
- *   close() { this.dismiss() }
- * }
- * ```
- */
-declare function hotkey(hotkey: RegisterableHotkey, options?: HotkeyOptions): <T extends HotkeyCallback>(proto: LitElement, propertyKey: string, descriptor?: TypedPropertyDescriptor<T>) => void;
-//#endregion
-export { hotkey };
-//# sourceMappingURL=hotkey.d.cts.map

package/dist/decorators/hotkey.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hotkey.js","names":[],"sources":["../../src/decorators/hotkey.ts"],"sourcesContent":["import { HotkeyController } from '../controllers/hotkey'\nimport { HOTKEY_DEFAULT_OPTIONS } from '../constants'\nimport type { LitElement } from 'lit'\nimport type {\n  HotkeyCallback,\n  HotkeyOptions,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\n/**\n * Decorator that registers a keyboard hotkey on the element when it connects\n * and unregisters when it disconnects. Uses {@link HotkeyController} under the hood.\n *\n * @param hotkey - The key or key combo to listen for (e.g. `'Mod+S'` or a raw hotkey object).\n * @param options - Optional registration options (target, platform, enabled, etc.).\n * @returns A method decorator for use on LitElement methods.\n *\n * @example\n * ```ts\n * class MyElement extends LitElement {\n *   @hotkey('Mod+S')\n *   save() { this.doSave() }\n *\n *   @hotkey('Escape')\n *   close() { this.dismiss() }\n * }\n * ```\n */\nexport function hotkey(\n  hotkey: RegisterableHotkey,\n  options: HotkeyOptions = HOTKEY_DEFAULT_OPTIONS,\n) {\n  return function <T extends HotkeyCallback>(\n    proto: LitElement,\n    propertyKey: string,\n    descriptor?: TypedPropertyDescriptor<T>,\n  ) {\n    const originalConnected = proto.connectedCallback\n    const controllerKey = Symbol(`@hotkey:${propertyKey}`)\n\n    proto.connectedCallback = function () {\n      originalConnected.call(this)\n\n      const host = this as unknown as {\n        [key: symbol]: HotkeyController | undefined\n        addController: (c: unknown) => void\n        [key: string]: unknown\n      }\n\n      if (!host[controllerKey]) {\n        const callback: HotkeyCallback = descriptor?.value\n          ? (descriptor.value.bind(this) as HotkeyCallback)\n          : (host[propertyKey] as HotkeyCallback)\n\n        if (typeof callback !== 'function') {\n          throw new Error(`@hotkey decorator can only be applied to functions`)\n        }\n\n        const controller: HotkeyController = new HotkeyController(\n          this,\n          hotkey,\n          callback,\n          options,\n        )\n        host[controllerKey] = controller\n        this.addController(controller)\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,OACd,QACA,UAAyB,wBACzB;AACA,QAAO,SACL,OACA,aACA,YACA;EACA,MAAM,oBAAoB,MAAM;EAChC,MAAM,gBAAgB,OAAO,WAAW,cAAc;AAEtD,QAAM,oBAAoB,WAAY;AACpC,qBAAkB,KAAK,KAAK;GAE5B,MAAM,OAAO;AAMb,OAAI,CAAC,KAAK,gBAAgB;IACxB,MAAM,WAA2B,YAAY,QACxC,WAAW,MAAM,KAAK,KAAK,GAC3B,KAAK;AAEV,QAAI,OAAO,aAAa,WACtB,OAAM,IAAI,MAAM,qDAAqD;IAGvE,MAAM,aAA+B,IAAI,iBACvC,MACA,QACA,UACA,QACD;AACD,SAAK,iBAAiB;AACtB,SAAK,cAAc,WAAW"}

package/dist/decorators/index.d.cts

@@ -1,2 +0,0 @@
-import { hotkeySequence } from "./hotkey-sequence.cjs";
-import { hotkey } from "./hotkey.cjs";

package/dist/index.cjs

@@ -1,29 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_hotkey_sequence = require('./controllers/hotkey-sequence.cjs');
-const require_hotkey_sequence$1 = require('./decorators/hotkey-sequence.cjs');
-const require_hotkey = require('./controllers/hotkey.cjs');
-const require_hotkey$1 = require('./decorators/hotkey.cjs');
-const require_held_key_codes = require('./controllers/held-key-codes.cjs');
-const require_held_keys = require('./controllers/held-keys.cjs');
-const require_hotkey_recorder = require('./controllers/hotkey-recorder.cjs');
-const require_hotkey_registrations = require('./controllers/hotkey-registrations.cjs');
-const require_hotkey_sequence_recorder = require('./controllers/hotkey-sequence-recorder.cjs');
-const require_key_hold = require('./controllers/key-hold.cjs');
-
-exports.HeldKeyCodesController = require_held_key_codes.HeldKeyCodesController;
-exports.HeldKeysController = require_held_keys.HeldKeysController;
-exports.HotkeyController = require_hotkey.HotkeyController;
-exports.HotkeyRecorderController = require_hotkey_recorder.HotkeyRecorderController;
-exports.HotkeyRegistrationsController = require_hotkey_registrations.HotkeyRegistrationsController;
-exports.HotkeySequenceController = require_hotkey_sequence.HotkeySequenceController;
-exports.HotkeySequenceRecorderController = require_hotkey_sequence_recorder.HotkeySequenceRecorderController;
-exports.KeyHoldController = require_key_hold.KeyHoldController;
-exports.hotkey = require_hotkey$1.hotkey;
-exports.hotkeySequence = require_hotkey_sequence$1.hotkeySequence;
-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,12 +0,0 @@
-import { hotkeySequence } from "./decorators/hotkey-sequence.cjs";
-import { hotkey } from "./decorators/hotkey.cjs";
-import { HeldKeyCodesController } from "./controllers/held-key-codes.cjs";
-import { HeldKeysController } from "./controllers/held-keys.cjs";
-import { HotkeyController } from "./controllers/hotkey.cjs";
-import { HotkeyRecorderController } from "./controllers/hotkey-recorder.cjs";
-import { HotkeyRegistrationsController } from "./controllers/hotkey-registrations.cjs";
-import { HotkeySequenceController } from "./controllers/hotkey-sequence.cjs";
-import { HotkeySequenceRecorderController } from "./controllers/hotkey-sequence-recorder.cjs";
-import { KeyHoldController } from "./controllers/key-hold.cjs";
-export * from "@tanstack/hotkeys";
-export { HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyRecorderController, HotkeyRegistrationsController, HotkeySequenceController, HotkeySequenceRecorderController, KeyHoldController, hotkey, hotkeySequence };

package/src/constants.ts

@@ -1,23 +0,0 @@
-import type { HotkeyOptions, SequenceOptions } from '@tanstack/hotkeys'
-
-export const HOTKEY_DEFAULT_OPTIONS: HotkeyOptions = {
-  enabled: true,
-  preventDefault: true,
-  stopPropagation: true,
-  eventType: 'keydown',
-  requireReset: false,
-  ignoreInputs: undefined, // smart default: false for Mod+S, true for single keys
-  platform: undefined, // auto-detected
-  conflictBehavior: 'warn',
-}
-
-export const HOTKEY_SEQUENCE_DEFAULT_OPTIONS: SequenceOptions = {
-  enabled: true,
-  timeout: 1000,
-  preventDefault: true,
-  stopPropagation: true,
-  eventType: 'keydown',
-  ignoreInputs: undefined, // smart default: false for Mod+S, true for single keys
-  platform: undefined, // auto-detected
-  conflictBehavior: 'warn',
-}

package/src/controllers/held-key-codes.ts

@@ -1,67 +0,0 @@
-import { getKeyStateTracker } from '@tanstack/hotkeys'
-import type { KeyStateTracker } from '@tanstack/hotkeys'
-import type { ReactiveController, ReactiveControllerHost } from 'lit'
-
-/**
- * A Lit ReactiveController that tracks all currently held key names to their physical `event.code` values.
- *
- * Subscribes to the global KeyStateTracker and triggers host updates
- * whenever keys are pressed or released.
- *
- * @example
- * ```ts
- * class KeyDisplay extends LitElement {
- *   private heldKeyCodes = new HeldKeyCodesController(this)
- *
- *   render() {
- *     const heldCodes = Object.entries(this.heldKeyCodes.value).map(([key, code]) => `${key}: ${code}`).join(' + ')
- *     return html`
- *       <div>
- *         Currently pressed: ${heldCodes || 'None'}
- *       </div>
- *     `
- *   }
- * }
- * ```
- */
-export class HeldKeyCodesController implements ReactiveController {
-  /** The unsubscribe function to unsubscribe from the tracker store. */
-  private _unsubscribe: (() => void) | undefined
-  /** The currently held key names to their physical `event.code` values. */
-  private _value: Record<string, string> = {}
-
-  /** Map of currently held key names to their physical `event.code` values. */
-  public get value(): Record<string, string> {
-    return this._value
-  }
-
-  /**
-   * @param _host - The Lit component that owns this controller.
-   */
-  constructor(private _host: ReactiveControllerHost) {
-    this._host.addController(this)
-  }
-
-  /** Subscribes to the tracker store and updates the internal state when changes occur. */
-  public hostConnected(): void {
-    const tracker: KeyStateTracker = getKeyStateTracker()
-    this._value = tracker.store.state.heldCodes
-    this._host.requestUpdate()
-
-    const subscription = tracker.store.subscribe(() => {
-      const { heldCodes } = tracker.store.state
-
-      this._value = heldCodes
-      this._host.requestUpdate()
-    })
-
-    this._unsubscribe = () => subscription.unsubscribe()
-  }
-
-  /** Unsubscribes from the tracker store and stops tracking the held key codes. */
-  public hostDisconnected(): void {
-    this._unsubscribe?.()
-    this._unsubscribe = undefined
-    this._value = {}
-  }
-}

package/src/controllers/held-keys.ts

@@ -1,64 +0,0 @@
-import { getKeyStateTracker } from '@tanstack/hotkeys'
-import type { KeyStateTracker } from '@tanstack/hotkeys'
-import type { ReactiveController, ReactiveControllerHost } from 'lit'
-
-/**
- * A Lit ReactiveController that tracks all currently held keyboard keys.
- *
- * Subscribes to the global KeyStateTracker and triggers host updates
- * whenever keys are pressed or released.
- *
- * @example
- * ```ts
- * class KeyDisplay extends LitElement {
- *   private heldKeys = new HeldKeysController(this)
- *
- *   render() {
- *     return html`
- *       <div>
- *         Currently pressed: ${this.heldKeys.value.join(' + ') || 'None'}
- *       </div>
- *     `
- *   }
- * }
- * ```
- */
-export class HeldKeysController implements ReactiveController {
-  /** The unsubscribe function to unsubscribe from the tracker store. */
-  private _unsubscribe: (() => void) | undefined
-  /** The currently held key names. */
-  private _value: Array<string> = []
-
-  /** Array of currently held key names. */
-  public get value(): Array<string> {
-    return this._value
-  }
-
-  /**
-   * @param _host - The Lit component that owns this controller.
-   */
-  constructor(private _host: ReactiveControllerHost) {
-    this._host.addController(this)
-  }
-
-  /** Subscribes to the tracker store and updates the internal state when changes occur. */
-  public hostConnected(): void {
-    const tracker: KeyStateTracker = getKeyStateTracker()
-
-    const subscription = tracker.store.subscribe(() => {
-      const { heldKeys } = tracker.store.state
-
-      this._value = heldKeys
-      this._host.requestUpdate()
-    })
-
-    this._unsubscribe = () => subscription.unsubscribe()
-  }
-
-  /** Unsubscribes from the tracker store and stops tracking the held keys. */
-  public hostDisconnected(): void {
-    this._unsubscribe?.()
-    this._unsubscribe = undefined
-    this._value = []
-  }
-}

package/src/controllers/hotkey-recorder.ts

@@ -1,120 +0,0 @@
-import { HotkeyRecorder } from '@tanstack/hotkeys'
-import type { ReactiveController, ReactiveControllerHost } from 'lit'
-import type { Hotkey, HotkeyRecorderOptions } from '@tanstack/hotkeys'
-
-/**
- * A Lit ReactiveController that records keyboard shortcuts.
- *
- * Wraps 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.
- *
- * @example
- * ```ts
- * class ShortcutSettings extends LitElement {
- *   private recorder = new HotkeyRecorderController(this, {
- *     onRecord: (hotkey) => {
- *       this.shortcut = hotkey
- *       this.requestUpdate()
- *     },
- *     onCancel: () => {
- *       console.log('Recording cancelled')
- *     },
- *   })
- *
- *   private shortcut: Hotkey | null = null
- *
- *   render() {
- *     return html`
- *       <button @click=${() => this.recorder.startRecording()}>
- *         ${this.recorder.isRecording ? 'Recording...' : 'Edit Shortcut'}
- *       </button>
- *       ${this.recorder.recordedHotkey
- *         ? html`<div>Recording: ${this.recorder.recordedHotkey}</div>`
- *         : nothing}
- *     `
- *   }
- * }
- * ```
- */
-export class HotkeyRecorderController implements ReactiveController {
-  /** The recorder instance. */
-  private _recorder: HotkeyRecorder
-  /** The unsubscribe function to unsubscribe from the recorder store. */
-  private _unsubscribe: (() => void) | undefined
-  /** Whether recording is currently active. */
-  private _isRecording = false
-  /** The currently recorded hotkey (for live preview). */
-  private _recordedHotkey: Hotkey | null = null
-
-  /** Whether recording is currently active. */
-  public get isRecording(): boolean {
-    return this._isRecording
-  }
-
-  /** The currently recorded hotkey (for live preview). */
-  public get recordedHotkey(): Hotkey | null {
-    return this._recordedHotkey
-  }
-
-  /**
-   * @param _host - The Lit component that owns this controller.
-   * @param _options - Configuration options for the recorder.
-   */
-  constructor(
-    private _host: ReactiveControllerHost,
-    private _options: HotkeyRecorderOptions,
-  ) {
-    this._recorder = new HotkeyRecorder(_options)
-    this._host.addController(this)
-  }
-
-  /** Subscribes to the recorder store and updates the internal state when changes occur. */
-  public hostConnected(): void {
-    const subscription = this._recorder.store.subscribe(() => {
-      const { isRecording, recordedHotkey } = this._recorder.store.state
-
-      const hasChanged: boolean =
-        isRecording !== this._isRecording ||
-        recordedHotkey !== this._recordedHotkey
-
-      if (hasChanged) {
-        this._isRecording = isRecording
-        this._recordedHotkey = recordedHotkey
-        this._host.requestUpdate()
-      }
-    })
-
-    this._unsubscribe = () => subscription.unsubscribe()
-  }
-
-  /** Unsubscribes from the recorder store and destroys the recorder instance to prevent memory leaks. */
-  public hostDisconnected(): void {
-    this._unsubscribe?.()
-    this._unsubscribe = undefined
-    this._recorder.stop()
-    this._isRecording = false
-    this._recordedHotkey = null
-  }
-
-  /** Updates the recorder options (e.g. callbacks). */
-  public setOptions(options: Partial<HotkeyRecorderOptions>): void {
-    this._options = { ...this._options, ...options }
-    this._recorder.setOptions(this._options)
-  }
-
-  /** Start recording a new hotkey. */
-  public startRecording(): void {
-    this._recorder.start()
-  }
-
-  /** Stop recording (same as cancel but without calling onCancel). */
-  public stopRecording(): void {
-    this._recorder.stop()
-  }
-
-  /** Cancel recording without saving. */
-  public cancelRecording(): void {
-    this._recorder.cancel()
-  }
-}

package/src/controllers/hotkey-registrations.ts

@@ -1,89 +0,0 @@
-import {
-  getHotkeyManager,
-  getSequenceManager,
-  toHotkeyRegistrationView,
-} from '@tanstack/hotkeys'
-import type {
-  HotkeyRegistrationView,
-  SequenceRegistrationView,
-} from '@tanstack/hotkeys'
-import type { ReactiveController, ReactiveControllerHost } from 'lit'
-
-/**
- * A Lit ReactiveController that tracks all hotkey and sequence registrations.
- *
- * Subscribes to the singleton HotkeyManager and SequenceManager stores and
- * triggers host updates whenever registrations change.
- *
- * @example
- * ```ts
- * class ShortcutPalette extends LitElement {
- *   private registrations = new HotkeyRegistrationsController(this)
- *
- *   render() {
- *     return html`
- *       <ul>
- *         ${this.registrations.hotkeys.map(
- *           (reg) => html`<li>${reg.options.meta?.name ?? reg.hotkey}</li>`,
- *         )}
- *       </ul>
- *     `
- *   }
- * }
- * ```
- */
-export class HotkeyRegistrationsController implements ReactiveController {
-  private _unsubscribeHotkeys: (() => void) | undefined
-  private _unsubscribeSequences: (() => void) | undefined
-  private _hotkeys: Array<HotkeyRegistrationView> = []
-  private _sequences: Array<SequenceRegistrationView> = []
-
-  /** All registered hotkeys (public view, no callbacks). */
-  public get hotkeys(): Array<HotkeyRegistrationView> {
-    return this._hotkeys
-  }
-
-  /** All registered sequences. */
-  public get sequences(): Array<SequenceRegistrationView> {
-    return this._sequences
-  }
-
-  constructor(private _host: ReactiveControllerHost) {
-    this._host.addController(this)
-  }
-
-  public hostConnected(): void {
-    const hotkeyManager = getHotkeyManager()
-    const sequenceManager = getSequenceManager()
-
-    const hotkeysSub = hotkeyManager.registrations.subscribe(() => {
-      this._hotkeys = Array.from(
-        hotkeyManager.registrations.state.values(),
-      ).map(toHotkeyRegistrationView)
-      this._host.requestUpdate()
-    })
-
-    const sequencesSub = sequenceManager.registrations.subscribe(() => {
-      this._sequences = Array.from(sequenceManager.registrations.state.values())
-      this._host.requestUpdate()
-    })
-
-    this._unsubscribeHotkeys = () => hotkeysSub.unsubscribe()
-    this._unsubscribeSequences = () => sequencesSub.unsubscribe()
-
-    // Sync initial state
-    this._hotkeys = Array.from(hotkeyManager.registrations.state.values()).map(
-      toHotkeyRegistrationView,
-    )
-    this._sequences = Array.from(sequenceManager.registrations.state.values())
-  }
-
-  public hostDisconnected(): void {
-    this._unsubscribeHotkeys?.()
-    this._unsubscribeSequences?.()
-    this._unsubscribeHotkeys = undefined
-    this._unsubscribeSequences = undefined
-    this._hotkeys = []
-    this._sequences = []
-  }
-}