@tanstack/hotkeys 0.14.0 → 0.15.0

package/dist/_target-listeners.js

@@ -20,7 +20,8 @@ var TargetListeners = class {
 			const listener = (eventType) => (rawEvent) => {
 				const event = rawEvent;
 				let processed = this.#processed.get(event);
-				if (!processed || processed.groups.has(ids)) {
+				const first = !processed || processed.groups.has(ids);
+				if (!processed || first) {
 					processed = {
 						ids: /* @__PURE__ */ new Set(),
 						groups: /* @__PURE__ */ new Set()
@@ -33,7 +34,7 @@ var TargetListeners = class {
 					processed.ids.add(registrationId);
 					pending.add(registrationId);
 				}
-				this.dispatch(event, target, eventType, capture, pending);
+				this.dispatch(event, target, eventType, capture, pending, first);
 			};
 			group = {
 				ids,

package/dist/hotkey-manager.js

@@ -5,7 +5,7 @@ import { isHotkeySequence, isModifierKey, parseHotkey, rawHotkeyToParsedHotkey,
 import { formatHotkey } from "./format.js";
 import { matchKeyboardEvent } from "./_match.js";
 import { DEFAULT_SEQUENCE_TIMEOUT, areHotkeysEqual } from "./match.js";
-import { isEventForTarget, shouldIgnoreInputEvent } from "./_event-target.js";
+import { getTargetDocument, isEventForTarget, shouldIgnoreInputEvent } from "./_event-target.js";
 import { TargetListeners } from "./_target-listeners.js";
 import { isRecordingEvent } from "./_recording-guard.js";
 import { defaultHotkeyOptions, getDefaultIgnoreInputs, handleConflict, optionsEqual } from "./_registration.js";
@@ -125,6 +125,10 @@ var HotkeyManager = class HotkeyManager {
 	appHotkeys = new Store(null);
 	#platform;
 	#listeners = new TargetListeners((...args) => this.#processTargetEvent(...args));
+	/** Events that continue a sequence in progress, decided before any listener runs. */
+	#sequenceOwned = /* @__PURE__ */ new WeakMap();
+	/** Physical keys whose keydown a sequence owned, so their repeats and keyup are owned too. */
+	#sequenceOwnedKeys = /* @__PURE__ */ new Set();
 	constructor() {
 		this.#platform = detectPlatform();
 	}
@@ -285,9 +289,11 @@ var HotkeyManager = class HotkeyManager {
 	}
 	/**
 	* Processes keyboard events for a specific target and event type.
-	* Chords and sequences match independently; both may fire for one event.
+	* A key that continues a sequence in progress belongs to that sequence, so
+	* chords skip it. Chords and first steps of sequences may both fire.
 	*/
-	#processTargetEvent(event, target, eventType, capture, ids) {
+	#processTargetEvent(event, target, eventType, capture, ids, first) {
+		if (first) this.#sequenceOwned.set(event, this.#isOwnedBySequence(event, eventType));
 		this.#processChords(event, target, eventType, capture, this.#registrationsIn(ids, capture, "chord"));
 		this.#processSequences(event, target, eventType, capture, this.#registrationsIn(ids, capture, "sequence"));
 	}
@@ -298,7 +304,7 @@ var HotkeyManager = class HotkeyManager {
 				registration.activeMatch = void 0;
 			}
 		}
-		if (isRecordingEvent(event)) return;
+		if (isRecordingEvent(event) || this.#sequenceOwned.get(event)) return;
 		const matches = /* @__PURE__ */ new Map();
 		let bestScore = 0;
 		for (const registration of registrations) {
@@ -329,6 +335,34 @@ var HotkeyManager = class HotkeyManager {
 			}
 		}
 	}
+	/**
+	* Whether the event continues or completes a sequence in progress whose
+	* target the event reaches. The repeats and keyup of a keydown that a
+	* sequence owns belong to the sequence too.
+	*/
+	#isOwnedBySequence(event, eventType) {
+		const key = event.code || normalizeKeyName(event.key);
+		if (eventType === "keyup") {
+			const ownedKeydown = this.#sequenceOwnedKeys.delete(key);
+			return this.#continuesSequence(event, eventType) || ownedKeydown;
+		}
+		if (event.repeat) return this.#sequenceOwnedKeys.has(key);
+		const owned = this.#continuesSequence(event, eventType);
+		if (owned) this.#sequenceOwnedKeys.add(key);
+		else this.#sequenceOwnedKeys.delete(key);
+		return owned;
+	}
+	#continuesSequence(event, eventType) {
+		if (isRecordingEvent(event) || normalizeKeyboardEvent(event).isComposing || isModifierKey(normalizeKeyName(event.key))) return false;
+		const path = event.composedPath();
+		const now = Date.now();
+		for (const registration of this.registrations.state.values()) {
+			if (registration.kind !== "sequence" || registration.currentIndex === 0 || !registration.options.enabled || registration.options.eventType !== eventType || now - registration.lastKeyTime > (registration.options.timeout ?? 1e3)) continue;
+			const target = registration.target;
+			if (path.includes(target.nodeType === 1 ? target : getTargetDocument(target)) && !(ignoresInputs(registration) && shouldIgnoreInputEvent(event, target, target)) && matchKeyboardEvent(event, registration.parsedSequence[registration.currentIndex], registration.options.platform).matched) return true;
+		}
+		return false;
+	}
 	#processSequences(event, target, eventType, capture, registrations) {
 		if (registrations.length === 0) return;
 		if (isRecordingEvent(event)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/hotkeys",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Type-safe, framework-agnostic keyboard hotkey management for the browser",
   "author": "Tanner Linsley",
   "license": "MIT",