@tanstack/lit-hotkeys 0.12.0 → 0.13.0

package/dist/controllers/key-hold.d.cts

@@ -1,62 +0,0 @@
-import { IndividualKey } from "@tanstack/hotkeys";
-import { ReactiveController, ReactiveControllerHost } from "lit";
-
-//#region src/controllers/key-hold.d.ts
-/**
- * A Lit ReactiveController that tracks whether a specific key is currently held.
- *
- * Subscribes to the global KeyStateTracker and triggers host updates
- * when the held state of the specified key changes.
- *
- * @example
- * ```ts
- * class MyElement extends LitElement {
- *   private shiftHold = new KeyHoldController(this, 'Shift')
- *
- *   render() {
- *     return html`
- *       <div style="opacity: ${this.shiftHold.value ? 1 : 0.5}">
- *         ${this.shiftHold.value ? 'Shift is pressed!' : 'Press Shift'}
- *       </div>
- *     `
- *   }
- * }
- * ```
- *
- * @example
- * ```ts
- * class ModifierIndicators extends LitElement {
- *   private ctrl = new KeyHoldController(this, 'Control')
- *   private shift = new KeyHoldController(this, 'Shift')
- *   private alt = new KeyHoldController(this, 'Alt')
- *
- *   render() {
- *     return html`
- *       <span style="opacity: ${this.ctrl.value ? 1 : 0.3}">Ctrl</span>
- *       <span style="opacity: ${this.shift.value ? 1 : 0.3}">Shift</span>
- *       <span style="opacity: ${this.alt.value ? 1 : 0.3}">Alt</span>
- *     `
- *   }
- * }
- * ```
- */
-declare class KeyHoldController implements ReactiveController {
-  private _host;
-  private _key;
-  /** The unsubscribe function to unsubscribe from the tracker store. */
-  private _unsubscribe;
-  /** Whether the tracked key is currently held down. */
-  private _value;
-  /** Whether the tracked key is currently held down. */
-  get value(): boolean;
-  /**
-   * @param host - The Lit component that owns this controller.
-   * @param key - The key to track (e.g. 'Shift', 'Control', 'A').
-   */
-  constructor(_host: ReactiveControllerHost, _key: IndividualKey);
-  hostConnected(): void;
-  hostDisconnected(): void;
-}
-//#endregion
-export { KeyHoldController };
-//# sourceMappingURL=key-hold.d.cts.map

package/dist/controllers/key-hold.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"key-hold.js","names":[],"sources":["../../src/controllers/key-hold.ts"],"sourcesContent":["import { getKeyStateTracker } from '@tanstack/hotkeys'\nimport type { ReactiveController, ReactiveControllerHost } from 'lit'\nimport type { IndividualKey, KeyStateTracker } from '@tanstack/hotkeys'\n\n/**\n * A Lit ReactiveController that tracks whether a specific key is currently held.\n *\n * Subscribes to the global KeyStateTracker and triggers host updates\n * when the held state of the specified key changes.\n *\n * @example\n * ```ts\n * class MyElement extends LitElement {\n *   private shiftHold = new KeyHoldController(this, 'Shift')\n *\n *   render() {\n *     return html`\n *       <div style=\"opacity: ${this.shiftHold.value ? 1 : 0.5}\">\n *         ${this.shiftHold.value ? 'Shift is pressed!' : 'Press Shift'}\n *       </div>\n *     `\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * class ModifierIndicators extends LitElement {\n *   private ctrl = new KeyHoldController(this, 'Control')\n *   private shift = new KeyHoldController(this, 'Shift')\n *   private alt = new KeyHoldController(this, 'Alt')\n *\n *   render() {\n *     return html`\n *       <span style=\"opacity: ${this.ctrl.value ? 1 : 0.3}\">Ctrl</span>\n *       <span style=\"opacity: ${this.shift.value ? 1 : 0.3}\">Shift</span>\n *       <span style=\"opacity: ${this.alt.value ? 1 : 0.3}\">Alt</span>\n *     `\n *   }\n * }\n * ```\n */\nexport class KeyHoldController implements ReactiveController {\n  /** The unsubscribe function to unsubscribe from the tracker store. */\n  private _unsubscribe: (() => void) | undefined\n  /** Whether the tracked key is currently held down. */\n  private _value = false\n\n  /** Whether the tracked key is currently held down. */\n  public get value(): boolean {\n    return this._value\n  }\n\n  /**\n   * @param host - The Lit component that owns this controller.\n   * @param key - The key to track (e.g. 'Shift', 'Control', 'A').\n   */\n  constructor(\n    private _host: ReactiveControllerHost,\n    private _key: IndividualKey,\n  ) {\n    this._host.addController(this)\n  }\n\n  public hostConnected(): void {\n    const tracker: KeyStateTracker = getKeyStateTracker()\n    const normalizedKey: string = this._key.toLowerCase()\n\n    const subscription = tracker.store.subscribe(() => {\n      const isHeld: boolean = tracker.store.state.heldKeys.some(\n        (heldKey: string) => heldKey.toLowerCase() === normalizedKey,\n      )\n\n      if (isHeld !== this._value) {\n        this._value = isHeld\n        this._host.requestUpdate()\n      }\n    })\n\n    this._unsubscribe = () => subscription.unsubscribe()\n  }\n\n  public hostDisconnected(): void {\n    this._unsubscribe?.()\n    this._unsubscribe = undefined\n    this._value = false\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,oBAAb,MAA6D;;CAO3D,IAAW,QAAiB;AAC1B,SAAO,KAAK;;;;;;CAOd,YACE,AAAQ,OACR,AAAQ,MACR;EAFQ;EACA;gBAbO;AAef,OAAK,MAAM,cAAc,KAAK;;CAGhC,AAAO,gBAAsB;EAC3B,MAAM,UAA2B,oBAAoB;EACrD,MAAM,gBAAwB,KAAK,KAAK,aAAa;EAErD,MAAM,eAAe,QAAQ,MAAM,gBAAgB;GACjD,MAAM,SAAkB,QAAQ,MAAM,MAAM,SAAS,MAClD,YAAoB,QAAQ,aAAa,KAAK,cAChD;AAED,OAAI,WAAW,KAAK,QAAQ;AAC1B,SAAK,SAAS;AACd,SAAK,MAAM,eAAe;;IAE5B;AAEF,OAAK,qBAAqB,aAAa,aAAa;;CAGtD,AAAO,mBAAyB;AAC9B,OAAK,gBAAgB;AACrB,OAAK,eAAe;AACpB,OAAK,SAAS"}

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,31 +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');
-const require_hotkey_hint = require('./controllers/hotkey-hint.cjs');
-
-exports.HeldKeyCodesController = require_held_key_codes.HeldKeyCodesController;
-exports.HeldKeysController = require_held_keys.HeldKeysController;
-exports.HotkeyController = require_hotkey.HotkeyController;
-exports.HotkeyHintController = require_hotkey_hint.HotkeyHintController;
-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,13 +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";
-import { HotkeyHintController } from "./controllers/hotkey-hint.cjs";
-export * from "@tanstack/hotkeys";
-export { HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyHintController, 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-hint.ts

@@ -1,56 +0,0 @@
-import { getKeyStateTracker, matchesHeldModifiers } from '@tanstack/hotkeys'
-import type { ReactiveController, ReactiveControllerHost } from 'lit'
-import type { HeldModifierOptions, RegisterableHotkey } from '@tanstack/hotkeys'
-
-/** Modifier hint controller. Getter arguments can read reactive host properties. */
-export class HotkeyHintController implements ReactiveController {
-  private unsubscribe?: () => void
-  private visible = false
-
-  /** Attaches to the host; getter arguments can read changing reactive properties. */
-  constructor(
-    private host: ReactiveControllerHost,
-    private hotkey: RegisterableHotkey | (() => RegisterableHotkey),
-    private options: HeldModifierOptions | (() => HeldModifierOptions) = {},
-  ) {
-    host.addController(this)
-  }
-
-  /** Current visibility; combine with the action’s enabled state when rendering. */
-  get value(): boolean {
-    return this.visible
-  }
-
-  /** Subscribes on connection and requests renders only when hint visibility changes. */
-  hostConnected(): void {
-    this.update()
-    const subscription = getKeyStateTracker().store.subscribe(() => {
-      if (this.update()) this.host.requestUpdate()
-    })
-    this.unsubscribe = () => subscription.unsubscribe()
-  }
-
-  /** Re-evaluates getter arguments when host properties trigger an update. */
-  hostUpdate(): void {
-    this.update()
-  }
-
-  /** Releases the subscription and clears cached visibility while disconnected. */
-  hostDisconnected(): void {
-    this.unsubscribe?.()
-    this.unsubscribe = undefined
-    this.visible = false
-  }
-
-  /** Recomputes visibility and reports whether the host needs another render. */
-  private update(): boolean {
-    const next = matchesHeldModifiers(
-      typeof this.hotkey === 'function' ? this.hotkey() : this.hotkey,
-      getKeyStateTracker().store.state.heldKeys,
-      typeof this.options === 'function' ? this.options() : this.options,
-    )
-    const changed = next !== this.visible
-    this.visible = next
-    return changed
-  }
-}

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()
-  }
-}