@tanstack/lit-hotkeys 0.0.1

package/dist/controllers/hotkey-recorder.cjs

@@ -0,0 +1,104 @@
+let _tanstack_hotkeys = require("@tanstack/hotkeys");
+
+//#region src/controllers/hotkey-recorder.ts
+/**
+* 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}
+*     `
+*   }
+* }
+* ```
+*/
+var HotkeyRecorderController = class {
+	/** Whether recording is currently active. */
+	get isRecording() {
+		return this._isRecording;
+	}
+	/** The currently recorded hotkey (for live preview). */
+	get recordedHotkey() {
+		return this._recordedHotkey;
+	}
+	/**
+	* @param _host - The Lit component that owns this controller.
+	* @param _options - Configuration options for the recorder.
+	*/
+	constructor(_host, _options) {
+		this._host = _host;
+		this._options = _options;
+		this._isRecording = false;
+		this._recordedHotkey = null;
+		this._recorder = new _tanstack_hotkeys.HotkeyRecorder(_options);
+		this._host.addController(this);
+	}
+	/** Subscribes to the recorder store and updates the internal state when changes occur. */
+	hostConnected() {
+		const subscription = this._recorder.store.subscribe(() => {
+			const { isRecording, recordedHotkey } = this._recorder.store.state;
+			if (isRecording !== this._isRecording || recordedHotkey !== this._recordedHotkey) {
+				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. */
+	hostDisconnected() {
+		this._unsubscribe?.();
+		this._unsubscribe = void 0;
+		this._recorder.stop();
+		this._isRecording = false;
+		this._recordedHotkey = null;
+	}
+	/** Updates the recorder options (e.g. callbacks). */
+	setOptions(options) {
+		this._options = {
+			...this._options,
+			...options
+		};
+		this._recorder.setOptions(this._options);
+	}
+	/** Start recording a new hotkey. */
+	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();
+	}
+};
+
+//#endregion
+exports.HotkeyRecorderController = HotkeyRecorderController;
+//# sourceMappingURL=hotkey-recorder.cjs.map

package/dist/controllers/hotkey-recorder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotkey-recorder.cjs","names":["HotkeyRecorder"],"sources":["../../src/controllers/hotkey-recorder.ts"],"sourcesContent":["import { HotkeyRecorder } from '@tanstack/hotkeys'\nimport type { ReactiveController, ReactiveControllerHost } from 'lit'\nimport type { Hotkey, HotkeyRecorderOptions } from '@tanstack/hotkeys'\n\n/**\n * A Lit ReactiveController that records keyboard shortcuts.\n *\n * Wraps the framework-agnostic `HotkeyRecorder` class, managing all the\n * complexity of capturing keyboard events, converting them to hotkey strings,\n * and handling edge cases like Escape to cancel or Backspace/Delete to clear.\n *\n * @example\n * ```ts\n * class ShortcutSettings extends LitElement {\n *   private recorder = new HotkeyRecorderController(this, {\n *     onRecord: (hotkey) => {\n *       this.shortcut = hotkey\n *       this.requestUpdate()\n *     },\n *     onCancel: () => {\n *       console.log('Recording cancelled')\n *     },\n *   })\n *\n *   private shortcut: Hotkey | null = null\n *\n *   render() {\n *     return html`\n *       <button @click=${() => this.recorder.startRecording()}>\n *         ${this.recorder.isRecording ? 'Recording...' : 'Edit Shortcut'}\n *       </button>\n *       ${this.recorder.recordedHotkey\n *         ? html`<div>Recording: ${this.recorder.recordedHotkey}</div>`\n *         : nothing}\n *     `\n *   }\n * }\n * ```\n */\nexport class HotkeyRecorderController implements ReactiveController {\n  /** The recorder instance. */\n  private _recorder: HotkeyRecorder\n  /** The unsubscribe function to unsubscribe from the recorder store. */\n  private _unsubscribe: (() => void) | undefined\n  /** Whether recording is currently active. */\n  private _isRecording = false\n  /** The currently recorded hotkey (for live preview). */\n  private _recordedHotkey: Hotkey | null = null\n\n  /** Whether recording is currently active. */\n  public get isRecording(): boolean {\n    return this._isRecording\n  }\n\n  /** The currently recorded hotkey (for live preview). */\n  public get recordedHotkey(): Hotkey | null {\n    return this._recordedHotkey\n  }\n\n  /**\n   * @param _host - The Lit component that owns this controller.\n   * @param _options - Configuration options for the recorder.\n   */\n  constructor(\n    private _host: ReactiveControllerHost,\n    private _options: HotkeyRecorderOptions,\n  ) {\n    this._recorder = new HotkeyRecorder(_options)\n    this._host.addController(this)\n  }\n\n  /** Subscribes to the recorder store and updates the internal state when changes occur. */\n  public hostConnected(): void {\n    const subscription = this._recorder.store.subscribe(() => {\n      const { isRecording, recordedHotkey } = this._recorder.store.state\n\n      const hasChanged: boolean =\n        isRecording !== this._isRecording ||\n        recordedHotkey !== this._recordedHotkey\n\n      if (hasChanged) {\n        this._isRecording = isRecording\n        this._recordedHotkey = recordedHotkey\n        this._host.requestUpdate()\n      }\n    })\n\n    this._unsubscribe = () => subscription.unsubscribe()\n  }\n\n  /** Unsubscribes from the recorder store and destroys the recorder instance to prevent memory leaks. */\n  public hostDisconnected(): void {\n    this._unsubscribe?.()\n    this._unsubscribe = undefined\n    this._recorder.stop()\n    this._isRecording = false\n    this._recordedHotkey = null\n  }\n\n  /** Updates the recorder options (e.g. callbacks). */\n  public setOptions(options: Partial<HotkeyRecorderOptions>): void {\n    this._options = { ...this._options, ...options }\n    this._recorder.setOptions(this._options)\n  }\n\n  /** Start recording a new hotkey. */\n  public startRecording(): void {\n    this._recorder.start()\n  }\n\n  /** Stop recording (same as cancel but without calling onCancel). */\n  public stopRecording(): void {\n    this._recorder.stop()\n  }\n\n  /** Cancel recording without saving. */\n  public cancelRecording(): void {\n    this._recorder.cancel()\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAa,2BAAb,MAAoE;;CAWlE,IAAW,cAAuB;AAChC,SAAO,KAAK;;;CAId,IAAW,iBAAgC;AACzC,SAAO,KAAK;;;;;;CAOd,YACE,AAAQ,OACR,AAAQ,UACR;EAFQ;EACA;sBApBa;yBAEkB;AAoBvC,OAAK,YAAY,IAAIA,iCAAe,SAAS;AAC7C,OAAK,MAAM,cAAc,KAAK;;;CAIhC,AAAO,gBAAsB;EAC3B,MAAM,eAAe,KAAK,UAAU,MAAM,gBAAgB;GACxD,MAAM,EAAE,aAAa,mBAAmB,KAAK,UAAU,MAAM;AAM7D,OAHE,gBAAgB,KAAK,gBACrB,mBAAmB,KAAK,iBAEV;AACd,SAAK,eAAe;AACpB,SAAK,kBAAkB;AACvB,SAAK,MAAM,eAAe;;IAE5B;AAEF,OAAK,qBAAqB,aAAa,aAAa;;;CAItD,AAAO,mBAAyB;AAC9B,OAAK,gBAAgB;AACrB,OAAK,eAAe;AACpB,OAAK,UAAU,MAAM;AACrB,OAAK,eAAe;AACpB,OAAK,kBAAkB;;;CAIzB,AAAO,WAAW,SAA+C;AAC/D,OAAK,WAAW;GAAE,GAAG,KAAK;GAAU,GAAG;GAAS;AAChD,OAAK,UAAU,WAAW,KAAK,SAAS;;;CAI1C,AAAO,iBAAuB;AAC5B,OAAK,UAAU,OAAO;;;CAIxB,AAAO,gBAAsB;AAC3B,OAAK,UAAU,MAAM;;;CAIvB,AAAO,kBAAwB;AAC7B,OAAK,UAAU,QAAQ"}

package/dist/controllers/hotkey-recorder.d.cts

@@ -0,0 +1,75 @@
+import { Hotkey, HotkeyRecorderOptions } from "@tanstack/hotkeys";
+import { ReactiveController, ReactiveControllerHost } from "lit";
+
+//#region src/controllers/hotkey-recorder.d.ts
+/**
+ * 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}
+ *     `
+ *   }
+ * }
+ * ```
+ */
+declare class HotkeyRecorderController implements ReactiveController {
+  private _host;
+  private _options;
+  /** The recorder instance. */
+  private _recorder;
+  /** The unsubscribe function to unsubscribe from the recorder store. */
+  private _unsubscribe;
+  /** Whether recording is currently active. */
+  private _isRecording;
+  /** The currently recorded hotkey (for live preview). */
+  private _recordedHotkey;
+  /** Whether recording is currently active. */
+  get isRecording(): boolean;
+  /** The currently recorded hotkey (for live preview). */
+  get recordedHotkey(): Hotkey | null;
+  /**
+   * @param _host - The Lit component that owns this controller.
+   * @param _options - Configuration options for the recorder.
+   */
+  constructor(_host: ReactiveControllerHost, _options: HotkeyRecorderOptions);
+  /** Subscribes to the recorder store and updates the 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 (e.g. callbacks). */
+  setOptions(options: Partial<HotkeyRecorderOptions>): void;
+  /** Start recording a new hotkey. */
+  startRecording(): void;
+  /** Stop recording (same as cancel but without calling onCancel). */
+  stopRecording(): void;
+  /** Cancel recording without saving. */
+  cancelRecording(): void;
+}
+//#endregion
+export { HotkeyRecorderController };
+//# sourceMappingURL=hotkey-recorder.d.cts.map

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

@@ -0,0 +1,75 @@
+import { Hotkey, HotkeyRecorderOptions } from "@tanstack/hotkeys";
+import { ReactiveController, ReactiveControllerHost } from "lit";
+
+//#region src/controllers/hotkey-recorder.d.ts
+/**
+ * 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}
+ *     `
+ *   }
+ * }
+ * ```
+ */
+declare class HotkeyRecorderController implements ReactiveController {
+  private _host;
+  private _options;
+  /** The recorder instance. */
+  private _recorder;
+  /** The unsubscribe function to unsubscribe from the recorder store. */
+  private _unsubscribe;
+  /** Whether recording is currently active. */
+  private _isRecording;
+  /** The currently recorded hotkey (for live preview). */
+  private _recordedHotkey;
+  /** Whether recording is currently active. */
+  get isRecording(): boolean;
+  /** The currently recorded hotkey (for live preview). */
+  get recordedHotkey(): Hotkey | null;
+  /**
+   * @param _host - The Lit component that owns this controller.
+   * @param _options - Configuration options for the recorder.
+   */
+  constructor(_host: ReactiveControllerHost, _options: HotkeyRecorderOptions);
+  /** Subscribes to the recorder store and updates the 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 (e.g. callbacks). */
+  setOptions(options: Partial<HotkeyRecorderOptions>): void;
+  /** Start recording a new hotkey. */
+  startRecording(): void;
+  /** Stop recording (same as cancel but without calling onCancel). */
+  stopRecording(): void;
+  /** Cancel recording without saving. */
+  cancelRecording(): void;
+}
+//#endregion
+export { HotkeyRecorderController };
+//# sourceMappingURL=hotkey-recorder.d.ts.map

package/dist/controllers/hotkey-recorder.js

@@ -0,0 +1,104 @@
+import { HotkeyRecorder } from "@tanstack/hotkeys";
+
+//#region src/controllers/hotkey-recorder.ts
+/**
+* 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}
+*     `
+*   }
+* }
+* ```
+*/
+var HotkeyRecorderController = class {
+	/** Whether recording is currently active. */
+	get isRecording() {
+		return this._isRecording;
+	}
+	/** The currently recorded hotkey (for live preview). */
+	get recordedHotkey() {
+		return this._recordedHotkey;
+	}
+	/**
+	* @param _host - The Lit component that owns this controller.
+	* @param _options - Configuration options for the recorder.
+	*/
+	constructor(_host, _options) {
+		this._host = _host;
+		this._options = _options;
+		this._isRecording = false;
+		this._recordedHotkey = null;
+		this._recorder = new HotkeyRecorder(_options);
+		this._host.addController(this);
+	}
+	/** Subscribes to the recorder store and updates the internal state when changes occur. */
+	hostConnected() {
+		const subscription = this._recorder.store.subscribe(() => {
+			const { isRecording, recordedHotkey } = this._recorder.store.state;
+			if (isRecording !== this._isRecording || recordedHotkey !== this._recordedHotkey) {
+				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. */
+	hostDisconnected() {
+		this._unsubscribe?.();
+		this._unsubscribe = void 0;
+		this._recorder.stop();
+		this._isRecording = false;
+		this._recordedHotkey = null;
+	}
+	/** Updates the recorder options (e.g. callbacks). */
+	setOptions(options) {
+		this._options = {
+			...this._options,
+			...options
+		};
+		this._recorder.setOptions(this._options);
+	}
+	/** Start recording a new hotkey. */
+	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();
+	}
+};
+
+//#endregion
+export { HotkeyRecorderController };
+//# sourceMappingURL=hotkey-recorder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hotkey-recorder.js","names":[],"sources":["../../src/controllers/hotkey-recorder.ts"],"sourcesContent":["import { HotkeyRecorder } from '@tanstack/hotkeys'\nimport type { ReactiveController, ReactiveControllerHost } from 'lit'\nimport type { Hotkey, HotkeyRecorderOptions } from '@tanstack/hotkeys'\n\n/**\n * A Lit ReactiveController that records keyboard shortcuts.\n *\n * Wraps the framework-agnostic `HotkeyRecorder` class, managing all the\n * complexity of capturing keyboard events, converting them to hotkey strings,\n * and handling edge cases like Escape to cancel or Backspace/Delete to clear.\n *\n * @example\n * ```ts\n * class ShortcutSettings extends LitElement {\n *   private recorder = new HotkeyRecorderController(this, {\n *     onRecord: (hotkey) => {\n *       this.shortcut = hotkey\n *       this.requestUpdate()\n *     },\n *     onCancel: () => {\n *       console.log('Recording cancelled')\n *     },\n *   })\n *\n *   private shortcut: Hotkey | null = null\n *\n *   render() {\n *     return html`\n *       <button @click=${() => this.recorder.startRecording()}>\n *         ${this.recorder.isRecording ? 'Recording...' : 'Edit Shortcut'}\n *       </button>\n *       ${this.recorder.recordedHotkey\n *         ? html`<div>Recording: ${this.recorder.recordedHotkey}</div>`\n *         : nothing}\n *     `\n *   }\n * }\n * ```\n */\nexport class HotkeyRecorderController implements ReactiveController {\n  /** The recorder instance. */\n  private _recorder: HotkeyRecorder\n  /** The unsubscribe function to unsubscribe from the recorder store. */\n  private _unsubscribe: (() => void) | undefined\n  /** Whether recording is currently active. */\n  private _isRecording = false\n  /** The currently recorded hotkey (for live preview). */\n  private _recordedHotkey: Hotkey | null = null\n\n  /** Whether recording is currently active. */\n  public get isRecording(): boolean {\n    return this._isRecording\n  }\n\n  /** The currently recorded hotkey (for live preview). */\n  public get recordedHotkey(): Hotkey | null {\n    return this._recordedHotkey\n  }\n\n  /**\n   * @param _host - The Lit component that owns this controller.\n   * @param _options - Configuration options for the recorder.\n   */\n  constructor(\n    private _host: ReactiveControllerHost,\n    private _options: HotkeyRecorderOptions,\n  ) {\n    this._recorder = new HotkeyRecorder(_options)\n    this._host.addController(this)\n  }\n\n  /** Subscribes to the recorder store and updates the internal state when changes occur. */\n  public hostConnected(): void {\n    const subscription = this._recorder.store.subscribe(() => {\n      const { isRecording, recordedHotkey } = this._recorder.store.state\n\n      const hasChanged: boolean =\n        isRecording !== this._isRecording ||\n        recordedHotkey !== this._recordedHotkey\n\n      if (hasChanged) {\n        this._isRecording = isRecording\n        this._recordedHotkey = recordedHotkey\n        this._host.requestUpdate()\n      }\n    })\n\n    this._unsubscribe = () => subscription.unsubscribe()\n  }\n\n  /** Unsubscribes from the recorder store and destroys the recorder instance to prevent memory leaks. */\n  public hostDisconnected(): void {\n    this._unsubscribe?.()\n    this._unsubscribe = undefined\n    this._recorder.stop()\n    this._isRecording = false\n    this._recordedHotkey = null\n  }\n\n  /** Updates the recorder options (e.g. callbacks). */\n  public setOptions(options: Partial<HotkeyRecorderOptions>): void {\n    this._options = { ...this._options, ...options }\n    this._recorder.setOptions(this._options)\n  }\n\n  /** Start recording a new hotkey. */\n  public startRecording(): void {\n    this._recorder.start()\n  }\n\n  /** Stop recording (same as cancel but without calling onCancel). */\n  public stopRecording(): void {\n    this._recorder.stop()\n  }\n\n  /** Cancel recording without saving. */\n  public cancelRecording(): void {\n    this._recorder.cancel()\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAa,2BAAb,MAAoE;;CAWlE,IAAW,cAAuB;AAChC,SAAO,KAAK;;;CAId,IAAW,iBAAgC;AACzC,SAAO,KAAK;;;;;;CAOd,YACE,AAAQ,OACR,AAAQ,UACR;EAFQ;EACA;sBApBa;yBAEkB;AAoBvC,OAAK,YAAY,IAAI,eAAe,SAAS;AAC7C,OAAK,MAAM,cAAc,KAAK;;;CAIhC,AAAO,gBAAsB;EAC3B,MAAM,eAAe,KAAK,UAAU,MAAM,gBAAgB;GACxD,MAAM,EAAE,aAAa,mBAAmB,KAAK,UAAU,MAAM;AAM7D,OAHE,gBAAgB,KAAK,gBACrB,mBAAmB,KAAK,iBAEV;AACd,SAAK,eAAe;AACpB,SAAK,kBAAkB;AACvB,SAAK,MAAM,eAAe;;IAE5B;AAEF,OAAK,qBAAqB,aAAa,aAAa;;;CAItD,AAAO,mBAAyB;AAC9B,OAAK,gBAAgB;AACrB,OAAK,eAAe;AACpB,OAAK,UAAU,MAAM;AACrB,OAAK,eAAe;AACpB,OAAK,kBAAkB;;;CAIzB,AAAO,WAAW,SAA+C;AAC/D,OAAK,WAAW;GAAE,GAAG,KAAK;GAAU,GAAG;GAAS;AAChD,OAAK,UAAU,WAAW,KAAK,SAAS;;;CAI1C,AAAO,iBAAuB;AAC5B,OAAK,UAAU,OAAO;;;CAIxB,AAAO,gBAAsB;AAC3B,OAAK,UAAU,MAAM;;;CAIvB,AAAO,kBAAwB;AAC7B,OAAK,UAAU,QAAQ"}

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

@@ -0,0 +1,117 @@
+let _tanstack_hotkeys = require("@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 {
+	/** 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._isRecording = false;
+		this._steps = [];
+		this._recordedSequence = null;
+		this._recorder = new _tanstack_hotkeys.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
+exports.HotkeySequenceRecorderController = HotkeySequenceRecorderController;
+//# sourceMappingURL=hotkey-sequence-recorder.cjs.map

package/dist/controllers/hotkey-sequence-recorder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotkey-sequence-recorder.cjs","names":["HotkeySequenceRecorder"],"sources":["../../src/controllers/hotkey-sequence-recorder.ts"],"sourcesContent":["import { HotkeySequenceRecorder } from '@tanstack/hotkeys'\nimport type { ReactiveController, ReactiveControllerHost } from 'lit'\nimport type {\n  HotkeySequence,\n  HotkeySequenceRecorderOptions,\n} from '@tanstack/hotkeys'\n\n/**\n * A Lit ReactiveController that records multi-chord sequences (Vim-style shortcuts).\n *\n * Wraps the framework-agnostic `HotkeySequenceRecorder` class, managing store\n * subscriptions and host update lifecycle automatically.\n *\n * @example\n * ```ts\n * class ShortcutSettings extends LitElement {\n *   private recorder = new HotkeySequenceRecorderController(this, {\n *     onRecord: (sequence) => {\n *       this.sequence = sequence\n *       this.requestUpdate()\n *     },\n *     onCancel: () => {\n *       console.log('Recording cancelled')\n *     },\n *   })\n *\n *   private sequence: HotkeySequence | null = null\n *\n *   render() {\n *     return html`\n *       <button @click=${() => this.recorder.startRecording()}>\n *         ${this.recorder.isRecording ? 'Recording...' : 'Edit Sequence'}\n *       </button>\n *       ${this.recorder.steps.length\n *         ? html`<div>Steps: ${this.recorder.steps.join(' → ')}</div>`\n *         : nothing}\n *       ${this.recorder.recordedSequence\n *         ? html`<div>Recorded: ${this.recorder.recordedSequence.join(' → ')}</div>`\n *         : nothing}\n *     `\n *   }\n * }\n * ```\n */\nexport class HotkeySequenceRecorderController implements ReactiveController {\n  /** The recorder instance. */\n  private _recorder: HotkeySequenceRecorder\n  /** The unsubscribe function. */\n  private _unsubscribe: (() => void) | undefined\n  /** Whether recording is currently active. */\n  private _isRecording = false\n  /** Chords captured in the current session. */\n  private _steps: HotkeySequence = []\n  /** Last committed sequence, or null if none. */\n  private _recordedSequence: HotkeySequence | null = null\n\n  /** Whether recording is currently active. */\n  public get isRecording(): boolean {\n    return this._isRecording\n  }\n\n  /** Chords captured in the current session. */\n  public get steps(): HotkeySequence {\n    return this._steps\n  }\n\n  /** Last committed sequence, or null if none. */\n  public get recordedSequence(): HotkeySequence | null {\n    return this._recordedSequence\n  }\n\n  /**\n   * @param _host - The Lit component that owns this controller.\n   * @param _options - Configuration options for the sequence recorder.\n   */\n  constructor(\n    private _host: ReactiveControllerHost,\n    private _options: HotkeySequenceRecorderOptions,\n  ) {\n    this._recorder = new HotkeySequenceRecorder(_options)\n    this._host.addController(this)\n  }\n\n  /** Subscribes to the recorder store and updates internal state when changes occur. */\n  public hostConnected(): void {\n    const subscription = this._recorder.store.subscribe(() => {\n      const { isRecording, steps, recordedSequence } =\n        this._recorder.store.state\n\n      const hasChanged: boolean =\n        isRecording !== this._isRecording ||\n        steps !== this._steps ||\n        recordedSequence !== this._recordedSequence\n\n      if (hasChanged) {\n        this._isRecording = isRecording\n        this._steps = steps\n        this._recordedSequence = recordedSequence\n        this._host.requestUpdate()\n      }\n    })\n\n    this._unsubscribe = () => subscription.unsubscribe()\n  }\n\n  /** Unsubscribes from the recorder store and destroys the recorder instance to prevent memory leaks. */\n  public hostDisconnected(): void {\n    this._unsubscribe?.()\n    this._unsubscribe = undefined\n    this._recorder.stop()\n    this._isRecording = false\n    this._steps = []\n    this._recordedSequence = null\n  }\n\n  /** Updates the recorder options. */\n  public setOptions(options: Partial<HotkeySequenceRecorderOptions>): void {\n    this._options = { ...this._options, ...options }\n    this._recorder.setOptions(this._options)\n  }\n\n  /** Start recording a new sequence. */\n  public startRecording(): void {\n    this._recorder.start()\n  }\n\n  /** Stop recording (same as cancel but without calling onCancel). */\n  public stopRecording(): void {\n    this._recorder.stop()\n  }\n\n  /** Cancel recording without saving. */\n  public cancelRecording(): void {\n    this._recorder.cancel()\n  }\n\n  /** Commit current steps as a sequence (no-op if empty). */\n  public commitRecording(): void {\n    this._recorder.commit()\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,IAAa,mCAAb,MAA4E;;CAa1E,IAAW,cAAuB;AAChC,SAAO,KAAK;;;CAId,IAAW,QAAwB;AACjC,SAAO,KAAK;;;CAId,IAAW,mBAA0C;AACnD,SAAO,KAAK;;;;;;CAOd,YACE,AAAQ,OACR,AAAQ,UACR;EAFQ;EACA;sBA3Ba;gBAEU,EAAE;2BAEgB;AAyBjD,OAAK,YAAY,IAAIA,yCAAuB,SAAS;AACrD,OAAK,MAAM,cAAc,KAAK;;;CAIhC,AAAO,gBAAsB;EAC3B,MAAM,eAAe,KAAK,UAAU,MAAM,gBAAgB;GACxD,MAAM,EAAE,aAAa,OAAO,qBAC1B,KAAK,UAAU,MAAM;AAOvB,OAJE,gBAAgB,KAAK,gBACrB,UAAU,KAAK,UACf,qBAAqB,KAAK,mBAEZ;AACd,SAAK,eAAe;AACpB,SAAK,SAAS;AACd,SAAK,oBAAoB;AACzB,SAAK,MAAM,eAAe;;IAE5B;AAEF,OAAK,qBAAqB,aAAa,aAAa;;;CAItD,AAAO,mBAAyB;AAC9B,OAAK,gBAAgB;AACrB,OAAK,eAAe;AACpB,OAAK,UAAU,MAAM;AACrB,OAAK,eAAe;AACpB,OAAK,SAAS,EAAE;AAChB,OAAK,oBAAoB;;;CAI3B,AAAO,WAAW,SAAuD;AACvE,OAAK,WAAW;GAAE,GAAG,KAAK;GAAU,GAAG;GAAS;AAChD,OAAK,UAAU,WAAW,KAAK,SAAS;;;CAI1C,AAAO,iBAAuB;AAC5B,OAAK,UAAU,OAAO;;;CAIxB,AAAO,gBAAsB;AAC3B,OAAK,UAAU,MAAM;;;CAIvB,AAAO,kBAAwB;AAC7B,OAAK,UAAU,QAAQ;;;CAIzB,AAAO,kBAAwB;AAC7B,OAAK,UAAU,QAAQ"}

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

@@ -0,0 +1,83 @@
+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}
+ *     `
+ *   }
+ * }
+ * ```
+ */
+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
+export { HotkeySequenceRecorderController };
+//# sourceMappingURL=hotkey-sequence-recorder.d.cts.map

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

@@ -0,0 +1,83 @@
+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}
+ *     `
+ *   }
+ * }
+ * ```
+ */
+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
+export { HotkeySequenceRecorderController };
+//# sourceMappingURL=hotkey-sequence-recorder.d.ts.map