@tanstack/lit-hotkeys 0.0.1

package/dist/controllers/key-hold.cjs

@@ -0,0 +1,78 @@
+let _tanstack_hotkeys = require("@tanstack/hotkeys");
+
+//#region src/controllers/key-hold.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>
+*     `
+*   }
+* }
+* ```
+*/
+var KeyHoldController = class {
+	/** Whether the tracked key is currently held down. */
+	get value() {
+		return this._value;
+	}
+	/**
+	* @param host - The Lit component that owns this controller.
+	* @param key - The key to track (e.g. 'Shift', 'Control', 'A').
+	*/
+	constructor(_host, _key) {
+		this._host = _host;
+		this._key = _key;
+		this._value = false;
+		this._host.addController(this);
+	}
+	hostConnected() {
+		const tracker = (0, _tanstack_hotkeys.getKeyStateTracker)();
+		const normalizedKey = this._key.toLowerCase();
+		const subscription = tracker.store.subscribe(() => {
+			const isHeld = tracker.store.state.heldKeys.some((heldKey) => heldKey.toLowerCase() === normalizedKey);
+			if (isHeld !== this._value) {
+				this._value = isHeld;
+				this._host.requestUpdate();
+			}
+		});
+		this._unsubscribe = () => subscription.unsubscribe();
+	}
+	hostDisconnected() {
+		this._unsubscribe?.();
+		this._unsubscribe = void 0;
+		this._value = false;
+	}
+};
+
+//#endregion
+exports.KeyHoldController = KeyHoldController;
+//# sourceMappingURL=key-hold.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"key-hold.cjs","names":[],"sources":["../../src/controllers/key-hold.ts"],"sourcesContent":["import { getKeyStateTracker } from '@tanstack/hotkeys'\nimport type { ReactiveController, ReactiveControllerHost } from 'lit'\nimport type { HeldKey, 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: HeldKey,\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,qDAA+C;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/controllers/key-hold.d.cts

@@ -0,0 +1,62 @@
+import { HeldKey } 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: HeldKey);
+  hostConnected(): void;
+  hostDisconnected(): void;
+}
+//#endregion
+export { KeyHoldController };
+//# sourceMappingURL=key-hold.d.cts.map

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

@@ -0,0 +1,62 @@
+import { HeldKey } 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: HeldKey);
+  hostConnected(): void;
+  hostDisconnected(): void;
+}
+//#endregion
+export { KeyHoldController };
+//# sourceMappingURL=key-hold.d.ts.map

package/dist/controllers/key-hold.js

@@ -0,0 +1,78 @@
+import { getKeyStateTracker } from "@tanstack/hotkeys";
+
+//#region src/controllers/key-hold.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>
+*     `
+*   }
+* }
+* ```
+*/
+var KeyHoldController = class {
+	/** Whether the tracked key is currently held down. */
+	get value() {
+		return this._value;
+	}
+	/**
+	* @param host - The Lit component that owns this controller.
+	* @param key - The key to track (e.g. 'Shift', 'Control', 'A').
+	*/
+	constructor(_host, _key) {
+		this._host = _host;
+		this._key = _key;
+		this._value = false;
+		this._host.addController(this);
+	}
+	hostConnected() {
+		const tracker = getKeyStateTracker();
+		const normalizedKey = this._key.toLowerCase();
+		const subscription = tracker.store.subscribe(() => {
+			const isHeld = tracker.store.state.heldKeys.some((heldKey) => heldKey.toLowerCase() === normalizedKey);
+			if (isHeld !== this._value) {
+				this._value = isHeld;
+				this._host.requestUpdate();
+			}
+		});
+		this._unsubscribe = () => subscription.unsubscribe();
+	}
+	hostDisconnected() {
+		this._unsubscribe?.();
+		this._unsubscribe = void 0;
+		this._value = false;
+	}
+};
+
+//#endregion
+export { KeyHoldController };
+//# sourceMappingURL=key-hold.js.map

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

@@ -0,0 +1 @@
+{"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 { HeldKey, 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: HeldKey,\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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,28 @@
+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.d.ts

@@ -0,0 +1,28 @@
+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.ts.map

package/dist/decorators/hotkey-sequence.js

@@ -0,0 +1,45 @@
+import { HOTKEY_SEQUENCE_DEFAULT_OPTIONS } from "../constants.js";
+import { HotkeySequenceController } from "../controllers/hotkey-sequence.js";
+
+//#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 = 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 HotkeySequenceController(this, sequence, callback, options);
+				host[controllerKey] = controller;
+				this.addController(controller);
+			}
+		};
+	};
+}
+
+//#endregion
+export { hotkeySequence };
+//# sourceMappingURL=hotkey-sequence.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,27 @@
+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.d.ts

@@ -0,0 +1,27 @@
+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.ts.map

package/dist/decorators/hotkey.js

@@ -0,0 +1,44 @@
+import { HOTKEY_DEFAULT_OPTIONS } from "../constants.js";
+import { HotkeyController } from "../controllers/hotkey.js";
+
+//#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 = 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 HotkeyController(this, hotkey, callback, options);
+				host[controllerKey] = controller;
+				this.addController(controller);
+			}
+		};
+	};
+}
+
+//#endregion
+export { hotkey };
+//# sourceMappingURL=hotkey.js.map

package/dist/decorators/hotkey.js.map

@@ -0,0 +1 @@
+{"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

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

package/dist/decorators/index.d.ts

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