@tanstack/lit-hotkeys 0.13.1 → 0.15.0

package/dist/controllers/hotkey.js

@@ -1,19 +1,27 @@
-import { HOTKEY_DEFAULT_OPTIONS } from "../constants.js";
-import { detectPlatform, formatHotkey, getHotkeyManager, rawHotkeyToParsedHotkey } from "@tanstack/hotkeys";
+import { getAppHotkeysStore, subscribeAppHotkeys } from "./_app-hotkeys.js";
+import { createHotkeyBindings, prepareHotkeyDefinitions } from "@tanstack/hotkeys/adapter";
 
 //#region src/controllers/hotkey.ts
 /**
-* A Lit ReactiveController that registers a keyboard hotkey when the host
-* element is connected and unregisters it when the host is disconnected.
+* A Lit ReactiveController that registers a hotkey when the host element is
+* connected and unregisters it when the host is disconnected. The hotkey can
+* be a chord such as `'Mod+S'`, a sequence such as `['G', 'G']`, or an app
+* hotkey from `defineAppHotkeys`, which uses its custom hotkey from
+* `provideAppHotkeys`.
+*
+* Chords accept `requireReset`; sequences accept `timeout`. Pass a getter for
+* the hotkey or options to re-read them after each host update.
 *
 * @example
 * ```ts
 * class MyElement extends LitElement {
-*   private hotkey = new HotkeyController(this, 'Mod+S', () => this.save())
+*   private save = new HotkeyController(this, 'Mod+S', () => this.doSave())
+*   private top = new HotkeyController(this, ['G', 'G'], () => this.scrollToTop())
 *
 *   constructor() {
 *     super()
-*     this.addController(this.hotkey)
+*     this.addController(this.save)
+*     this.addController(this.top)
 *   }
 * }
 * ```
@@ -21,43 +29,44 @@ import { detectPlatform, formatHotkey, getHotkeyManager, rawHotkeyToParsedHotkey
 var HotkeyController = class {
 	_host;
 	_hotkey;
-	_callback;
 	_options;
-	/** The hotkey registration handle. */
-	_registration;
-	/**
-	* @param _host - The Lit component that owns this controller (use `this` and pass it to `addController()`).
-	* @param _hotkey - The key or key combo to listen for (e.g. `'Mod+S'` or a raw hotkey object).
-	* @param _callback - Function to run when the hotkey is pressed; called with the host as `this`.
-	* @param _options - Optional registration options (target, platform, enabled, etc.).
-	*/
-	constructor(_host, _hotkey, _callback, _options = HOTKEY_DEFAULT_OPTIONS) {
+	_bindings = createHotkeyBindings();
+	_connected = false;
+	_boundCallback;
+	_unsubscribe;
+	constructor(_host, _hotkey, callback, _options = {}) {
 		this._host = _host;
 		this._hotkey = _hotkey;
-		this._callback = _callback;
 		this._options = _options;
+		this._boundCallback = callback.bind(this._host);
 	}
-	/**
-	* Registers the hotkey with the global manager when the host is connected to the DOM.
-	* Skips registration if no target is available (e.g. no document or options.target is null).
-	*/
+	/** Registers when connected and a target is available. */
 	hostConnected() {
-		const manager = getHotkeyManager();
-		const platform = this._options.platform ?? detectPlatform();
-		const hotkeyString = typeof this._hotkey === "string" ? this._hotkey : formatHotkey(rawHotkeyToParsedHotkey(this._hotkey, platform));
-		const resolvedTarget = "target" in this._options ? this._options.target ?? null : typeof document !== "undefined" ? document : null;
-		if (!resolvedTarget) return;
-		const { target: _target, ...optionsWithoutTarget } = this._options;
-		const boundCallback = this._callback.bind(this._host);
-		this._registration = manager.register(hotkeyString, boundCallback, {
-			...optionsWithoutTarget,
-			target: resolvedTarget
-		});
+		this._connected = true;
+		this._unsubscribe = subscribeAppHotkeys(() => this._sync());
+		this._sync();
+	}
+	/** Refreshes options after rendering, when scoped targets are available. */
+	hostUpdated() {
+		if (this._connected) this._sync();
+	}
+	_sync() {
+		const options = typeof this._options === "function" ? this._options() : this._options;
+		this._bindings.update(prepareHotkeyDefinitions([{
+			hotkey: typeof this._hotkey === "function" ? this._hotkey() : this._hotkey,
+			callback: this._boundCallback,
+			options
+		}], {
+			appHotkeysStore: getAppHotkeysStore(),
+			resolveTarget: (target) => target
+		}));
 	}
-	/** Unregisters the hotkey when the host is disconnected from the DOM. */
+	/** Releases registrations when the host disconnects. */
 	hostDisconnected() {
-		if (this._registration?.isActive) this._registration.unregister();
-		this._registration = void 0;
+		this._connected = false;
+		this._unsubscribe?.();
+		this._unsubscribe = void 0;
+		this._bindings.destroy();
 	}
 };
 

package/dist/controllers/index.d.ts

@@ -1,10 +1,9 @@
+import { AppHotkeyControllerOptions, HotkeyController, HotkeyControllerChordOptions, HotkeyControllerCommonOptions, HotkeyControllerOptions, HotkeyControllerOptionsFor, HotkeyControllerSequenceOptions, HotkeyControllerTarget } from "./hotkey.js";
+import { AppHotkeysController } from "./app-hotkeys.js";
 import { HeldKeyCodesController } from "./held-key-codes.js";
 import { HeldKeysController } from "./held-keys.js";
-import { HotkeyController } from "./hotkey.js";
 import { HotkeyRecorderController } from "./hotkey-recorder.js";
 import { HotkeyRegistrationsController } from "./hotkey-registrations.js";
-import { HotkeySequenceController } from "./hotkey-sequence.js";
-import { HotkeySequenceRecorderController } from "./hotkey-sequence-recorder.js";
 import { KeyHoldController } from "./key-hold.js";
 import { HotkeyHintController } from "./hotkey-hint.js";
-export { HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, HotkeySequenceController, HotkeySequenceRecorderController, KeyHoldController };
+export { AppHotkeyControllerOptions, AppHotkeysController, HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyControllerChordOptions, HotkeyControllerCommonOptions, HotkeyControllerOptions, HotkeyControllerOptionsFor, HotkeyControllerSequenceOptions, HotkeyControllerTarget, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, KeyHoldController };

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

@@ -49,8 +49,8 @@ export declare class KeyHoldController implements ReactiveController {
   /** 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').
+   * @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;

package/dist/controllers/key-hold.js

@@ -51,8 +51,8 @@ var KeyHoldController = class {
 		return this._value;
 	}
 	/**
-	* @param host - The Lit component that owns this controller.
-	* @param key - The key to track (e.g. 'Shift', 'Control', 'A').
+	* @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;

package/dist/decorators/hotkey.d.ts

@@ -1,11 +1,14 @@
-import { HotkeyCallback, HotkeyOptions, RegisterableHotkey } from "@tanstack/hotkeys";
+import { AppHotkeyControllerOptions, HotkeyControllerOptionsFor } from "../controllers/hotkey.js";
+import { AppHotkey, HotkeyCallback, RegisterableHotkey } from "@tanstack/hotkeys";
 import { LitElement } from "lit";
 //#region src/decorators/hotkey.d.ts
+type HotkeyDecorator = <T extends HotkeyCallback>(proto: LitElement, propertyKey: string, descriptor?: TypedPropertyDescriptor<T>) => void;
 /**
- * Decorator that registers a keyboard hotkey on the element when it connects
- * and unregisters when it disconnects. Uses {@link HotkeyController} under the hood.
+ * Decorator that registers a hotkey on the element when it connects and
+ * unregisters when it disconnects: a chord such as `'Mod+S'`, a sequence such
+ * as `['G', 'G']`, or an app hotkey. 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 hotkey - The chord, sequence, or app hotkey to listen for.
  * @param options - Optional registration options (target, platform, enabled, etc.).
  * @returns A method decorator for use on LitElement methods.
  *
@@ -15,10 +18,11 @@ import { LitElement } from "lit";
  *   @hotkey('Mod+S')
  *   save() { this.doSave() }
  *
- *   @hotkey('Escape')
- *   close() { this.dismiss() }
+ *   @hotkey(['G', 'G'], { timeout: 500 })
+ *   goToTop() { window.scrollTo(0, 0) }
  * }
  * ```
  */
-export declare function hotkey(hotkey: RegisterableHotkey, options?: HotkeyOptions): <T extends HotkeyCallback>(proto: LitElement, propertyKey: string, descriptor?: TypedPropertyDescriptor<T>) => void;
+export declare function hotkey<T extends AppHotkey>(hotkey: T, options?: AppHotkeyControllerOptions<T>): HotkeyDecorator;
+export declare function hotkey<T extends RegisterableHotkey>(hotkey: T, options?: HotkeyControllerOptionsFor<T>): HotkeyDecorator;
 //#endregion

package/dist/decorators/hotkey.js

@@ -1,27 +1,7 @@
-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) {
+function hotkey(hotkey, options = {}) {
 	return function(proto, propertyKey, descriptor) {
 		const originalConnected = proto.connectedCallback;
 		const controllerKey = Symbol(`@hotkey:${propertyKey}`);

package/dist/decorators/index.d.ts

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

package/dist/index.d.ts

@@ -1,15 +1,13 @@
-import { hotkeySequence } from "./decorators/hotkey-sequence.js";
+import { AppHotkeyControllerOptions, HotkeyController, HotkeyControllerChordOptions, HotkeyControllerCommonOptions, HotkeyControllerOptions, HotkeyControllerOptionsFor, HotkeyControllerSequenceOptions, HotkeyControllerTarget } from "./controllers/hotkey.js";
 import { hotkey } from "./decorators/hotkey.js";
 import "./decorators/index.js";
+import { AppHotkeysController } from "./controllers/app-hotkeys.js";
 import { HeldKeyCodesController } from "./controllers/held-key-codes.js";
 import { HeldKeysController } from "./controllers/held-keys.js";
-import { HotkeyController } from "./controllers/hotkey.js";
 import { HotkeyRecorderController } from "./controllers/hotkey-recorder.js";
 import { HotkeyRegistrationsController } from "./controllers/hotkey-registrations.js";
-import { HotkeySequenceController } from "./controllers/hotkey-sequence.js";
-import { HotkeySequenceRecorderController } from "./controllers/hotkey-sequence-recorder.js";
 import { KeyHoldController } from "./controllers/key-hold.js";
 import { HotkeyHintController } from "./controllers/hotkey-hint.js";
 import "./controllers/index.js";
 export * from "@tanstack/hotkeys";
-export { HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, HotkeySequenceController, HotkeySequenceRecorderController, KeyHoldController, hotkey, hotkeySequence };
+export { AppHotkeyControllerOptions, AppHotkeysController, HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyControllerChordOptions, HotkeyControllerCommonOptions, HotkeyControllerOptions, HotkeyControllerOptionsFor, HotkeyControllerSequenceOptions, HotkeyControllerTarget, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, KeyHoldController, hotkey };

package/dist/index.js

@@ -1,15 +1,13 @@
-import { HotkeySequenceController } from "./controllers/hotkey-sequence.js";
-import { hotkeySequence } from "./decorators/hotkey-sequence.js";
 import { HotkeyController } from "./controllers/hotkey.js";
 import { hotkey } from "./decorators/hotkey.js";
+import { AppHotkeysController } from "./controllers/app-hotkeys.js";
 import { HeldKeyCodesController } from "./controllers/held-key-codes.js";
 import { HeldKeysController } from "./controllers/held-keys.js";
 import { HotkeyRecorderController } from "./controllers/hotkey-recorder.js";
 import { HotkeyRegistrationsController } from "./controllers/hotkey-registrations.js";
-import { HotkeySequenceRecorderController } from "./controllers/hotkey-sequence-recorder.js";
 import { KeyHoldController } from "./controllers/key-hold.js";
 import { HotkeyHintController } from "./controllers/hotkey-hint.js";
 
 export * from "@tanstack/hotkeys"
 
-export { HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, HotkeySequenceController, HotkeySequenceRecorderController, KeyHoldController, hotkey, hotkeySequence };
+export { AppHotkeysController, HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, KeyHoldController, hotkey };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/lit-hotkeys",
-  "version": "0.13.1",
+  "version": "0.15.0",
   "description": "Lit adapter for TanStack Hotkeys",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "dist"
   ],
   "dependencies": {
-    "@tanstack/hotkeys": "0.10.1"
+    "@tanstack/hotkeys": "0.12.0"
   },
   "devDependencies": {
     "lit": "^3.3.3"

package/dist/constants.js

@@ -1,24 +0,0 @@
-//#region src/constants.ts
-const HOTKEY_DEFAULT_OPTIONS = {
-	enabled: true,
-	preventDefault: true,
-	stopPropagation: true,
-	eventType: "keydown",
-	requireReset: false,
-	ignoreInputs: void 0,
-	platform: void 0,
-	conflictBehavior: "warn"
-};
-const HOTKEY_SEQUENCE_DEFAULT_OPTIONS = {
-	enabled: true,
-	timeout: 1e3,
-	preventDefault: true,
-	stopPropagation: true,
-	eventType: "keydown",
-	ignoreInputs: void 0,
-	platform: void 0,
-	conflictBehavior: "warn"
-};
-
-//#endregion
-export { HOTKEY_DEFAULT_OPTIONS, HOTKEY_SEQUENCE_DEFAULT_OPTIONS };

package/dist/controllers/hotkey-sequence-recorder.d.ts

@@ -1,80 +0,0 @@
-import { HotkeySequence, HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
-import { ReactiveController, ReactiveControllerHost } from "lit";
-//#region src/controllers/hotkey-sequence-recorder.d.ts
-/**
- * A Lit ReactiveController that records multi-chord sequences (Vim-style shortcuts).
- *
- * Wraps the framework-agnostic `HotkeySequenceRecorder` class, managing store
- * subscriptions and host update lifecycle automatically.
- *
- * @example
- * ```ts
- * class ShortcutSettings extends LitElement {
- *   private recorder = new HotkeySequenceRecorderController(this, {
- *     onRecord: (sequence) => {
- *       this.sequence = sequence
- *       this.requestUpdate()
- *     },
- *     onCancel: () => {
- *       console.log('Recording cancelled')
- *     },
- *   })
- *
- *   private sequence: HotkeySequence | null = null
- *
- *   render() {
- *     return html`
- *       <button @click=${() => this.recorder.startRecording()}>
- *         ${this.recorder.isRecording ? 'Recording...' : 'Edit Sequence'}
- *       </button>
- *       ${this.recorder.steps.length
- *         ? html`<div>Steps: ${this.recorder.steps.join(' → ')}</div>`
- *         : nothing}
- *       ${this.recorder.recordedSequence
- *         ? html`<div>Recorded: ${this.recorder.recordedSequence.join(' → ')}</div>`
- *         : nothing}
- *     `
- *   }
- * }
- * ```
- */
-export declare class HotkeySequenceRecorderController implements ReactiveController {
-  private _host;
-  private _options;
-  /** The recorder instance. */
-  private _recorder;
-  /** The unsubscribe function. */
-  private _unsubscribe;
-  /** Whether recording is currently active. */
-  private _isRecording;
-  /** Chords captured in the current session. */
-  private _steps;
-  /** Last committed sequence, or null if none. */
-  private _recordedSequence;
-  /** Whether recording is currently active. */
-  get isRecording(): boolean;
-  /** Chords captured in the current session. */
-  get steps(): HotkeySequence;
-  /** Last committed sequence, or null if none. */
-  get recordedSequence(): HotkeySequence | null;
-  /**
-   * @param _host - The Lit component that owns this controller.
-   * @param _options - Configuration options for the sequence recorder.
-   */
-  constructor(_host: ReactiveControllerHost, _options: HotkeySequenceRecorderOptions);
-  /** Subscribes to the recorder store and updates internal state when changes occur. */
-  hostConnected(): void;
-  /** Unsubscribes from the recorder store and destroys the recorder instance to prevent memory leaks. */
-  hostDisconnected(): void;
-  /** Updates the recorder options. */
-  setOptions(options: Partial<HotkeySequenceRecorderOptions>): void;
-  /** Start recording a new sequence. */
-  startRecording(): void;
-  /** Stop recording (same as cancel but without calling onCancel). */
-  stopRecording(): void;
-  /** Cancel recording without saving. */
-  cancelRecording(): void;
-  /** Commit current steps as a sequence (no-op if empty). */
-  commitRecording(): void;
-}
-//#endregion

package/dist/controllers/hotkey-sequence-recorder.js

@@ -1,125 +0,0 @@
-import { HotkeySequenceRecorder } from "@tanstack/hotkeys";
-
-//#region src/controllers/hotkey-sequence-recorder.ts
-/**
-* A Lit ReactiveController that records multi-chord sequences (Vim-style shortcuts).
-*
-* Wraps the framework-agnostic `HotkeySequenceRecorder` class, managing store
-* subscriptions and host update lifecycle automatically.
-*
-* @example
-* ```ts
-* class ShortcutSettings extends LitElement {
-*   private recorder = new HotkeySequenceRecorderController(this, {
-*     onRecord: (sequence) => {
-*       this.sequence = sequence
-*       this.requestUpdate()
-*     },
-*     onCancel: () => {
-*       console.log('Recording cancelled')
-*     },
-*   })
-*
-*   private sequence: HotkeySequence | null = null
-*
-*   render() {
-*     return html`
-*       <button @click=${() => this.recorder.startRecording()}>
-*         ${this.recorder.isRecording ? 'Recording...' : 'Edit Sequence'}
-*       </button>
-*       ${this.recorder.steps.length
-*         ? html`<div>Steps: ${this.recorder.steps.join(' → ')}</div>`
-*         : nothing}
-*       ${this.recorder.recordedSequence
-*         ? html`<div>Recorded: ${this.recorder.recordedSequence.join(' → ')}</div>`
-*         : nothing}
-*     `
-*   }
-* }
-* ```
-*/
-var HotkeySequenceRecorderController = class {
-	_host;
-	_options;
-	/** The recorder instance. */
-	_recorder;
-	/** The unsubscribe function. */
-	_unsubscribe;
-	/** Whether recording is currently active. */
-	_isRecording = false;
-	/** Chords captured in the current session. */
-	_steps = [];
-	/** Last committed sequence, or null if none. */
-	_recordedSequence = null;
-	/** Whether recording is currently active. */
-	get isRecording() {
-		return this._isRecording;
-	}
-	/** Chords captured in the current session. */
-	get steps() {
-		return this._steps;
-	}
-	/** Last committed sequence, or null if none. */
-	get recordedSequence() {
-		return this._recordedSequence;
-	}
-	/**
-	* @param _host - The Lit component that owns this controller.
-	* @param _options - Configuration options for the sequence recorder.
-	*/
-	constructor(_host, _options) {
-		this._host = _host;
-		this._options = _options;
-		this._recorder = new HotkeySequenceRecorder(_options);
-		this._host.addController(this);
-	}
-	/** Subscribes to the recorder store and updates internal state when changes occur. */
-	hostConnected() {
-		const subscription = this._recorder.store.subscribe(() => {
-			const { isRecording, steps, recordedSequence } = this._recorder.store.state;
-			if (isRecording !== this._isRecording || steps !== this._steps || recordedSequence !== this._recordedSequence) {
-				this._isRecording = isRecording;
-				this._steps = steps;
-				this._recordedSequence = recordedSequence;
-				this._host.requestUpdate();
-			}
-		});
-		this._unsubscribe = () => subscription.unsubscribe();
-	}
-	/** Unsubscribes from the recorder store and destroys the recorder instance to prevent memory leaks. */
-	hostDisconnected() {
-		this._unsubscribe?.();
-		this._unsubscribe = void 0;
-		this._recorder.stop();
-		this._isRecording = false;
-		this._steps = [];
-		this._recordedSequence = null;
-	}
-	/** Updates the recorder options. */
-	setOptions(options) {
-		this._options = {
-			...this._options,
-			...options
-		};
-		this._recorder.setOptions(this._options);
-	}
-	/** Start recording a new sequence. */
-	startRecording() {
-		this._recorder.start();
-	}
-	/** Stop recording (same as cancel but without calling onCancel). */
-	stopRecording() {
-		this._recorder.stop();
-	}
-	/** Cancel recording without saving. */
-	cancelRecording() {
-		this._recorder.cancel();
-	}
-	/** Commit current steps as a sequence (no-op if empty). */
-	commitRecording() {
-		this._recorder.commit();
-	}
-};
-
-//#endregion
-export { HotkeySequenceRecorderController };

package/dist/controllers/hotkey-sequence.d.ts

@@ -1,42 +0,0 @@
-import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
-import { ReactiveController, ReactiveControllerHost } from "lit";
-//#region src/controllers/hotkey-sequence.d.ts
-/**
- * A Lit ReactiveController that registers a keyboard sequence (e.g. Vim-style)
- * when the host element is connected and unregisters it when the host is disconnected.
- *
- * @example
- * ```ts
- * class MyElement extends LitElement {
- *   private seq = new HotkeySequenceController(this, ['G', 'G'], () => this.goToTop())
- *
- *   constructor() {
- *     super()
- *     this.addController(this.seq)
- *   }
- * }
- * ```
- */
-export declare class HotkeySequenceController implements ReactiveController {
-  private _host;
-  private _sequence;
-  private _callback;
-  private _options;
-  /** The sequence registration handle. */
-  private _registration;
-  /**
-   * @param _host - The Lit component that owns this controller (use `this` and pass it to `addController()`).
-   * @param _sequence - The key sequence to listen for (e.g. `['G', 'G']`).
-   * @param _callback - Function to run when the sequence is completed; called with the host as `this`.
-   * @param _options - Optional sequence options (target, timeout, enabled, etc.).
-   */
-  constructor(_host: ReactiveControllerHost, _sequence: HotkeySequence, _callback: HotkeyCallback, _options?: SequenceOptions);
-  /**
-   * Registers the sequence with the global sequence manager when the host is connected to the DOM.
-   * Skips registration if disabled, sequence is empty, or no target is available.
-   */
-  hostConnected(): void;
-  /** Unregisters the sequence when the host is disconnected from the DOM. */
-  hostDisconnected(): void;
-}
-//#endregion

package/dist/controllers/hotkey-sequence.js

@@ -1,63 +0,0 @@
-import { HOTKEY_SEQUENCE_DEFAULT_OPTIONS } from "../constants.js";
-import { getSequenceManager } from "@tanstack/hotkeys";
-
-//#region src/controllers/hotkey-sequence.ts
-/**
-* A Lit ReactiveController that registers a keyboard sequence (e.g. Vim-style)
-* when the host element is connected and unregisters it when the host is disconnected.
-*
-* @example
-* ```ts
-* class MyElement extends LitElement {
-*   private seq = new HotkeySequenceController(this, ['G', 'G'], () => this.goToTop())
-*
-*   constructor() {
-*     super()
-*     this.addController(this.seq)
-*   }
-* }
-* ```
-*/
-var HotkeySequenceController = class {
-	_host;
-	_sequence;
-	_callback;
-	_options;
-	/** The sequence registration handle. */
-	_registration;
-	/**
-	* @param _host - The Lit component that owns this controller (use `this` and pass it to `addController()`).
-	* @param _sequence - The key sequence to listen for (e.g. `['G', 'G']`).
-	* @param _callback - Function to run when the sequence is completed; called with the host as `this`.
-	* @param _options - Optional sequence options (target, timeout, enabled, etc.).
-	*/
-	constructor(_host, _sequence, _callback, _options = HOTKEY_SEQUENCE_DEFAULT_OPTIONS) {
-		this._host = _host;
-		this._sequence = _sequence;
-		this._callback = _callback;
-		this._options = _options;
-	}
-	/**
-	* Registers the sequence with the global sequence manager when the host is connected to the DOM.
-	* Skips registration if disabled, sequence is empty, or no target is available.
-	*/
-	hostConnected() {
-		const { target: _target, ...optionsWithoutTarget } = this._options;
-		const manager = getSequenceManager();
-		const resolvedTarget = "target" in this._options ? this._options.target ?? null : typeof document !== "undefined" ? document : null;
-		if (!resolvedTarget) return;
-		const boundCallback = this._callback.bind(this._host);
-		this._registration = manager.register(this._sequence, boundCallback, {
-			...optionsWithoutTarget,
-			target: resolvedTarget
-		});
-	}
-	/** Unregisters the sequence when the host is disconnected from the DOM. */
-	hostDisconnected() {
-		if (this._registration?.isActive) this._registration.unregister();
-		this._registration = void 0;
-	}
-};
-
-//#endregion
-export { HotkeySequenceController };

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

@@ -1,25 +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() }
- * }
- * ```
- */
-export declare function hotkeySequence(sequence: HotkeySequence, options?: SequenceOptions): <T extends HotkeyCallback>(proto: LitElement, methodName: string, descriptor: TypedPropertyDescriptor<T>) => void;
-//#endregion