@tanstack/hotkeys 0.18.0 → 0.20.0

package/dist/_app-hotkeys-factory.d.ts

@@ -0,0 +1,5 @@
+import { AppHotkeys, AppHotkeysStore, AppHotkeysStoreOptions } from "./app-hotkeys.js";
+//#region src/_app-hotkeys-factory.d.ts
+/** Creates the store for app hotkeys from `defineAppHotkeys`. */
+export declare function createAppHotkeysStore<T extends AppHotkeys>(appHotkeys: T, options: AppHotkeysStoreOptions<T>): AppHotkeysStore<T>;
+//#endregion

package/dist/_app-hotkeys-factory.js

@@ -0,0 +1,13 @@
+//#region src/_app-hotkeys-factory.ts
+let factory;
+function setAppHotkeysStoreFactory(create) {
+	factory = create;
+}
+/** Creates the store for app hotkeys from `defineAppHotkeys`. */
+function createAppHotkeysStore(appHotkeys, options) {
+	if (!factory) throw new Error("[hotkeys] App hotkeys must come from defineAppHotkeys.");
+	return factory(appHotkeys, options);
+}
+
+//#endregion
+export { createAppHotkeysStore, setAppHotkeysStoreFactory };

package/dist/_event-target.js

@@ -1,78 +1,169 @@
 import { normalizeKeyName } from "./constants.js";
 
 //#region src/_event-target.ts
-function isNode(target) {
-	return typeof target?.nodeType === "number";
+function isElement(node) {
+	return node?.nodeType === 1;
 }
-function isElement(target) {
-	return isNode(target) && target.nodeType === 1;
-}
-function isWindow(target) {
-	return "document" in target;
+/** Whether a target is a document or window, which receive every key press in their document. */
+function isDocumentLevel(target) {
+	return "document" in target || target.nodeType === 9;
 }
 /** Returns the document a listener target belongs to, in any frame. */
 function getTargetDocument(target) {
-	if (isWindow(target)) return target.document;
-	if (target.nodeType === 9) return target;
-	return target.ownerDocument;
+	return "document" in target ? target.document : target.ownerDocument ?? target;
+}
+/** The focused element, looking inside open shadow roots. */
+function getDeepActiveElement(doc) {
+	let active = doc.activeElement;
+	while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
+	return active;
+}
+/** The next node a key event bubbles to: a slot, a shadow host, or the parent. */
+function composedParent(node) {
+	return node.assignedSlot ?? node.parentNode ?? (node.host || null);
 }
 /**
 * Whether key presses reach a listener on `target` right now. Document and
 * window listeners receive every key press in their document. An element
 * receives them only while focus is inside it, including inside a shadow
-* root it contains.
+* root it contains or on content slotted into it.
 */
 function targetHasFocus(target) {
-	if (isWindow(target) || target.nodeType === 9) return true;
-	const active = target.getRootNode().activeElement;
-	return !!active && target.contains(active);
+	if (isDocumentLevel(target)) return true;
+	for (let node = getDeepActiveElement(target.ownerDocument); node; node = composedParent(node)) if (node === target) return true;
+	return false;
 }
+const VERTICAL = ["ArrowUp", "ArrowDown"];
+const HORIZONTAL = ["ArrowLeft", "ArrowRight"];
+const ENTER = ["Enter"];
+const SPACE = ["Space"];
+const ACTIVATION = ["Enter", "Space"];
+const TYPEAHEAD = "typeahead";
+const MENU = [
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End",
+	"Enter",
+	"Space",
+	TYPEAHEAD
+];
+const COMBOBOX = [
+	"ArrowUp",
+	"ArrowDown",
+	"Home",
+	"End",
+	"Enter",
+	"Space",
+	TYPEAHEAD
+];
+const GRID = [
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown",
+	"Enter",
+	"Space"
+];
+const RADIOS = [
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Space"
+];
+const NAVIGATION = [
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown"
+];
+const SPIN = [
+	"ArrowUp",
+	"ArrowDown",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown"
+];
+const CARET = [
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End"
+];
 /**
-* Checks if an element is an input-like element that should be ignored for hotkeys.
-*
-* This includes:
-* - HTMLInputElement (all input types except button, submit, reset)
-* - HTMLTextAreaElement
-* - HTMLSelectElement
-* - Elements with contentEditable enabled
+* Input types that aren't text fields, with the keys each one keeps. Browsers
+* report unknown types as `'text'`.
+*/
+const INPUT_KEYS = {
+	button: ACTIVATION,
+	submit: ACTIVATION,
+	reset: ACTIVATION,
+	image: ACTIVATION,
+	color: ACTIVATION,
+	file: ACTIVATION,
+	checkbox: SPACE,
+	radio: RADIOS,
+	range: NAVIGATION
+};
+function getRole(element) {
+	return element.getAttribute("role")?.trim().split(/\s+/)[0];
+}
+/**
+* Checks if an element is a text field that hotkeys should not type over:
+* - text-entry `<input>` types (text, number, date, and similar) that aren't read-only
+* - `<textarea>` elements that aren't read-only, and `<select>` elements
+* - elements with `role="textbox"` or `role="searchbox"`
+* - contenteditable elements
 *
-* Button-type inputs (button, submit, reset) are excluded so hotkeys like
-* Mod+S and Escape fire when the user has tabbed to a form button.
+* Checkbox, radio, range, color, file, and button-type inputs are not text
+* fields. Hotkeys skip only the keys those controls use themselves.
 */
 function isInputElement(element) {
 	if (!isElement(element)) return false;
-	if (element.localName === "input") {
-		const type = element.type.toLowerCase();
-		return type !== "button" && type !== "submit" && type !== "reset";
+	switch (element.localName) {
+		case "input": {
+			const input = element;
+			return !INPUT_KEYS[input.type] && !input.readOnly;
+		}
+		case "textarea": return !element.readOnly;
+		case "select": return true;
 	}
-	if (element.localName === "textarea" || element.localName === "select") return true;
-	return element.isContentEditable === true;
+	const role = getRole(element);
+	return role === "textbox" || role === "searchbox" || element.isContentEditable;
 }
 /**
-* Returns the focused element for the document associated with where hotkey
-* listeners are attached (listener root). Use this instead of the global
-* `document.activeElement` so registrations scoped to an iframe (or another
-* document) read focus from the correct tree.
+* Whether the focused custom element may be a text field whose contents can't
+* be seen from outside:
+* - a host with focus inside a closed shadow root. Without a `tabindex` it
+*   can't hold focus itself, and an open root would have shown the focused
+*   element inside it.
+* - a form-associated element without a `role` attribute naming another control
 */
-function getActiveElementForListenerTarget(target) {
-	if (typeof document === "undefined") return null;
-	return getTargetDocument(target).activeElement;
+function isHiddenTextField(element) {
+	if (!element.localName.includes("-")) return false;
+	return element.constructor.formAssociated === true ? !element.hasAttribute("role") : !element.hasAttribute("tabindex");
 }
-const VERTICAL = ["ArrowUp", "ArrowDown"];
-const HORIZONTAL = ["ArrowLeft", "ArrowRight"];
-const ARROWS = [...VERTICAL, ...HORIZONTAL];
-const EDGES = ["Home", "End"];
-const PAGES = ["PageUp", "PageDown"];
-const ACTIVATION = ["Enter", "Space"];
-const TYPEAHEAD = "typeahead";
 /**
 * Returns the keys a control handles itself: activation for buttons and
 * links, and navigation for ARIA widgets, following the WAI-ARIA Authoring
 * Practices keyboard patterns (https://www.w3.org/WAI/ARIA/apg/patterns/).
+* Editable text fields never get here: they block every key that types text.
 */
 function getOwnedKeys(element) {
 	const orientation = element.getAttribute("aria-orientation");
-	switch (element.getAttribute("role")?.trim().split(/\s+/)[0]) {
+	switch (getRole(element)) {
 		case "button":
 		case "tab":
 		case "option":
@@ -80,64 +171,47 @@ function getOwnedKeys(element) {
 		case "menuitem":
 		case "menuitemcheckbox":
 		case "menuitemradio": return ACTIVATION;
-		case "link": return ["Enter"];
+		case "link": return ENTER;
 		case "checkbox":
 		case "switch":
-		case "radio": return ["Space"];
+		case "radio": return SPACE;
 		case "menu":
 		case "menubar":
-		case "tree": return [
-			...ARROWS,
-			...EDGES,
-			...ACTIVATION,
-			TYPEAHEAD
-		];
+		case "tree": return MENU;
 		case "listbox": return [
 			...orientation === "horizontal" ? HORIZONTAL : VERTICAL,
-			...EDGES,
-			...ACTIVATION,
-			TYPEAHEAD
-		];
-		case "combobox": return [
-			...VERTICAL,
-			...EDGES,
-			...ACTIVATION,
+			"Home",
+			"End",
+			"Enter",
+			"Space",
 			TYPEAHEAD
 		];
+		case "combobox": return COMBOBOX;
 		case "tablist": return [
 			...orientation === "vertical" ? VERTICAL : HORIZONTAL,
-			...EDGES,
-			...ACTIVATION
-		];
-		case "toolbar": return [...orientation === "vertical" ? VERTICAL : HORIZONTAL, ...EDGES];
-		case "grid":
-		case "treegrid": return [
-			...ARROWS,
-			...EDGES,
-			...PAGES,
-			...ACTIVATION
+			"Home",
+			"End",
+			"Enter",
+			"Space"
 		];
-		case "radiogroup": return [...ARROWS, "Space"];
-		case "slider": return [
-			...ARROWS,
-			...EDGES,
-			...PAGES
-		];
-		case "spinbutton": return [
-			...VERTICAL,
-			...EDGES,
-			...PAGES
+		case "toolbar": return [
+			...orientation === "vertical" ? VERTICAL : HORIZONTAL,
+			"Home",
+			"End"
 		];
+		case "grid":
+		case "treegrid": return GRID;
+		case "radiogroup": return RADIOS;
+		case "slider": return NAVIGATION;
+		case "spinbutton": return SPIN;
 	}
 	switch (element.localName) {
 		case "button":
 		case "summary": return ACTIVATION;
-		case "input": {
-			const type = element.type;
-			return type === "button" || type === "submit" || type === "reset" ? ACTIVATION : [];
-		}
+		case "input": return INPUT_KEYS[element.type] ?? CARET;
+		case "textarea": return NAVIGATION;
 		case "a":
-		case "area": return element.hasAttribute("href") ? ["Enter"] : [];
+		case "area": return element.hasAttribute("href") ? ENTER : [];
 	}
 	return [];
 }
@@ -150,56 +224,60 @@ function ownsKey(element, event, key) {
 	if (event.ctrlKey || event.metaKey || event.altKey) return false;
 	const owned = getOwnedKeys(element);
 	if (key === "Enter" || key === "Space") return !event.shiftKey && owned.includes(key);
-	return owned.includes(key) || owned.includes(TYPEAHEAD) && /^\S$/u.test(event.key);
+	return owned.includes(key) || owned.includes(TYPEAHEAD) && /^.$/u.test(event.key);
 }
 /**
-* Whether the focused element or an element on the event's path passes `test`.
-* Only elements inside the registration target count: walking outward from
-* the event's origin stops at the registration target, so a hotkey targeted
-* at a control, or at an element inside it, is not blocked by that control.
+* Finds the first element on the event's way out that blocks it, walking out
+* from the focused element. A key event starts there in a browser. One sent
+* by a test may start at an ancestor of the focused element or at the
+* document, and the walk from focus passes through those too. Only an event
+* that starts where focus can't be seen, such as inside a closed shadow root,
+* uses its own path.
 */
-function someElementInsideTarget(event, listenerTarget, registrationTarget, test) {
-	const scoped = !isWindow(registrationTarget) && registrationTarget.nodeType !== 9;
-	const focused = getActiveElementForListenerTarget(listenerTarget);
-	if (focused && focused !== registrationTarget && (!scoped || registrationTarget.contains(focused)) && test(focused)) return true;
-	const path = event.composedPath();
-	for (const element of path.length > 0 ? path : [event.target]) {
-		if (element === registrationTarget) break;
-		if (isElement(element) && test(element)) return true;
-	}
-	return false;
+function findBlocker(event, doc, test) {
+	const focused = getDeepActiveElement(doc);
+	let elements = [];
+	for (let node = focused; node; node = composedParent(node)) if (isElement(node)) elements.push(node);
+	const origin = event.composedPath()[0];
+	if (isElement(origin) && !elements.includes(origin)) elements = event.composedPath().filter(isElement);
+	const index = elements.findIndex((element) => test(element) || element === focused && isHiddenTextField(element));
+	return {
+		elements,
+		index
+	};
 }
-/**
-* Returns whether a hotkey should skip an event because a focused control
-* inside the registration target handles the key itself:
-* - text inputs, textareas, selects, and contenteditable elements (typing)
-* - buttons, links, and `<summary>` elements (Enter and Space activation)
-* - ARIA widgets such as menus, listboxes, tabs, and grids (navigation keys)
-*/
-function shouldIgnoreInputEvent(event, listenerTarget, registrationTarget) {
-	const key = normalizeKeyName(event.key);
-	return someElementInsideTarget(event, listenerTarget, registrationTarget, (element) => isInputElement(element) || ownsKey(element, event, key));
+/** Whether the blocking element is inside `target`. A target never blocks itself. */
+function blocks({ elements, index }, target) {
+	return index >= 0 && (isDocumentLevel(target) || index < elements.indexOf(target));
 }
+const ignoreCache = /* @__PURE__ */ new WeakMap();
 /**
-* Returns whether an event comes from a text input, textarea, select, or
-* contenteditable element in the target's document. Unlike
-* `shouldIgnoreInputEvent`, buttons, links, and ARIA widgets don't count.
+* Returns whether a hotkey on `target` should skip an event because a control
+* inside the target handles the key itself:
+* - text fields, including ARIA text roles and custom elements that hide one (typing)
+* - buttons, links, `<summary>`, and button-like inputs (Enter and Space activation)
+* - checkbox, radio, and range inputs, and ARIA widgets such as menus,
+*   listboxes, tabs, and grids (the keys they use)
+*
+* A hotkey targeted at a control receives that control's keys.
 */
-function isTypingEvent(event, target) {
-	return someElementInsideTarget(event, target, target, isInputElement);
+function shouldIgnoreInputEvent(event, target) {
+	let blocker = ignoreCache.get(event);
+	if (!blocker) {
+		const key = normalizeKeyName(event.key);
+		blocker = findBlocker(event, getTargetDocument(target), (element) => isInputElement(element) || ownsKey(element, event, key));
+		ignoreCache.set(event, blocker);
+	}
+	return blocks(blocker, target);
 }
 /**
-* Checks if an event is for the given target (originated from or bubbled to it).
-*
-* For document/window targets, also accepts the document's root element as
-* currentTarget to handle Brave and other browsers where currentTarget may be
-* documentElement instead of document when listeners are attached to document.
+* Returns whether an event comes from a text field inside `target`, as
+* `isInputElement` and hidden custom text fields define them. Buttons, links,
+* and other controls don't count.
 */
-function isEventForTarget(event, target) {
-	if (event.currentTarget === target) return true;
-	if (isWindow(target) || target.nodeType === 9) return event.currentTarget === getTargetDocument(target).documentElement;
-	return isNode(event.target) && target.contains(event.target);
+function isTypingEvent(event, target) {
+	return blocks(findBlocker(event, getTargetDocument(target), isInputElement), target);
 }
 
 //#endregion
-export { getActiveElementForListenerTarget, getTargetDocument, isEventForTarget, isInputElement, isTypingEvent, shouldIgnoreInputEvent, targetHasFocus };
+export { getTargetDocument, isDocumentLevel, isInputElement, isTypingEvent, shouldIgnoreInputEvent, targetHasFocus };

package/dist/_keyboard-event.js

@@ -34,9 +34,8 @@ function codeToLogicalKey(code) {
 	if (/^Key[A-Z]$/i.test(code)) return code.slice(3).toUpperCase();
 	if (/^Digit[0-9]$/i.test(code)) return code.slice(5);
 	if (/^Numpad[0-9]$/i.test(code)) return code.slice(6);
-	const punctuation = PUNCTUATION_CODE_MAP[code];
-	if (punctuation) return punctuation;
-	return {
+	if (Object.hasOwn(PUNCTUATION_CODE_MAP, code)) return PUNCTUATION_CODE_MAP[code];
+	const named = {
 		NumpadAdd: "+",
 		NumpadSubtract: "-",
 		NumpadMultiply: "*",
@@ -44,7 +43,8 @@ function codeToLogicalKey(code) {
 		NumpadDecimal: ".",
 		NumpadEnter: "Enter",
 		Space: "Space"
-	}[code];
+	};
+	return Object.hasOwn(named, code) ? named[code] : void 0;
 }
 /**
 * Whether AltGr changed what a key typed, as in AltGr+Q typing `@`. False when
@@ -102,6 +102,14 @@ function keysEqual(left, right) {
 function assertLogicalKey(key) {
 	if (/^\[.*\]$/s.test(key.trim())) throw new Error("Logical key must not contain a bracketed physical code. Use the code field instead.");
 }
+/**
+* Whether a key is written like a key the library knows: one character,
+* F1-F24, or a capitalized name such as `Escape`. Key names are
+* case-sensitive, so `escape` and `f1` don't qualify.
+*/
+function isKeyNameShape(key) {
+	return /^(?:.|F(?:[1-9]|1\d|2[0-4])|[A-Z][a-z][A-Za-z\d]*)$/su.test(key);
+}
 
 //#endregion
-export { altGraphTypedCharacter, assertLogicalKey, codeToLogicalKey, isAsciiLetter, isCodeName, isLatinLetter, isPrintableKey, keysEqual, modifierAlias, normalizeKeyboardEvent, physicalCodeOf, splitChordParts };
+export { altGraphTypedCharacter, assertLogicalKey, codeToLogicalKey, isAsciiLetter, isCodeName, isKeyNameShape, isLatinLetter, isPrintableKey, keysEqual, modifierAlias, normalizeKeyboardEvent, physicalCodeOf, splitChordParts };

package/dist/_match.js

@@ -22,7 +22,7 @@ function matchKeyboardEvent(event, hotkey, platform = detectPlatform()) {
 	const direct = keysEqual(normalized.key, parsed.key);
 	const implicitShift = direct && isPrintableKey(normalized.key) && !/^\p{Letter}$/u.test(normalized.key) && !parsed.shift;
 	if (direct && modifiersMatch(normalized, parsed, implicitShift)) return matched("key", implicitShift ? 2 : 3);
-	if (isAsciiLetter(normalized.key) || isLatinLetter(normalized.key) && normalized.code.startsWith("Key") && !normalized.alt) return noMatch;
+	if (!positionStandsIn(normalized)) return noMatch;
 	if (normalized.altGraph) return noMatch;
 	if (!modifiersMatch(normalized, parsed, false)) return noMatch;
 	const fallbackKey = codeToLogicalKey(normalized.code);
@@ -39,6 +39,28 @@ function matchKeyboardEvent(event, hotkey, platform = detectPlatform()) {
 		};
 	}
 }
+/**
+* Whether a key's conventional position may stand in for what it typed. Only
+* output that can't name a shortcut falls back:
+* - non-Latin letters and symbols, such as Russian `ы` or macOS Option's `–`
+* - dead keys
+* - anything on the digit row, where AZERTY types `&` and `é` for 1 and 2
+* - ASCII symbols typed with Shift, such as `!` for Shift+1
+* - Latin letters on punctuation keys with Control or Command, so German
+*   Cmd+ü still fires `Mod+[` (German types `[` with Option)
+*
+* A named key (`End` from a NumLock-off numpad), any other ASCII character,
+* or a Latin letter typed on its own is the key the user meant, wherever it
+* sits. AZERTY's `+` on the US `/` position is `+`, not `/`.
+*/
+function positionStandsIn({ key, code, ctrl, meta, shift, alt }) {
+	if (key !== "Dead" && !isPrintableKey(key)) return false;
+	if (code.startsWith("Digit")) return true;
+	if (isAsciiLetter(key)) return false;
+	if (/^[!-~]$/.test(key)) return shift;
+	if (!isLatinLetter(key) || alt) return true;
+	return (ctrl || meta) && !code.startsWith("Key");
+}
 /** Compares modifiers, excluding synthetic AltGr flags and optionally allowing Shift used to type a glyph. */
 function modifiersMatch(event, parsed, allowImplicitShift) {
 	const ctrl = event.altGraph ? false : event.ctrl;

package/dist/_named-keys.js

@@ -60,6 +60,26 @@ const LOGICAL_ONLY_NAMED_KEYS = [
 	"Hankaku",
 	"ZenkakuHankaku"
 ];
+/** Arrow, Home/End, and PageUp/PageDown keys. */
+const NAVIGATION_KEY_NAMES = [
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown"
+];
+/** Editing and special keys. */
+const EDITING_KEY_NAMES = [
+	"Enter",
+	"Escape",
+	"Space",
+	"Tab",
+	"Backspace",
+	"Delete"
+];
 
 //#endregion
-export { LOGICAL_ONLY_NAMED_KEYS, SHARED_NAMED_KEYS };
+export { EDITING_KEY_NAMES, LOGICAL_ONLY_NAMED_KEYS, NAVIGATION_KEY_NAMES, SHARED_NAMED_KEYS };

package/dist/_registration.js

@@ -35,7 +35,7 @@ function getDefaultIgnoreInputs(parsedChord) {
 function handleConflict(conflictingId, keyDisplay, conflictBehavior, unregister) {
 	if (conflictBehavior === "allow") return;
 	if (conflictBehavior === "warn") {
-		console.warn(`'${keyDisplay}' is already registered. Multiple handlers may be triggered. Use conflictBehavior: 'replace' to replace the existing handler, or conflictBehavior: 'allow' to suppress this warning.`);
+		if (process.env.NODE_ENV !== "production") console.warn(`'${keyDisplay}' is already registered. Multiple handlers may be triggered. Use conflictBehavior: 'replace' to replace the existing handler, or conflictBehavior: 'allow' to suppress this warning.`);
 		return;
 	}
 	if (conflictBehavior === "error") throw new Error(`'${keyDisplay}' is already registered. Use conflictBehavior: 'replace' to replace the existing handler, or conflictBehavior: 'allow' to allow multiple registrations.`);

package/dist/_store.d.ts

@@ -0,0 +1,14 @@
+import { Store as Store$1 } from "./vendor/@tanstack/store/dist/store.js";
+//#region src/_store.d.ts
+/**
+ * The part of TanStack Store's `Store` that TanStack Hotkeys uses. Its stores
+ * work with TanStack Store's framework adapters, such as `useSelector` from
+ * `@tanstack/react-store`.
+ */
+export type Store<T> = Pick<Store$1<T>, 'state' | 'get' | 'setState' | 'subscribe'>;
+/**
+ * Creates a store. Listeners run synchronously after each change, and an
+ * update to an equal value (by `Object.is`) notifies no one.
+ */
+export declare function createStore<T>(initialState: T): Store<T>;
+//#endregion

package/dist/_store.js

@@ -0,0 +1,43 @@
+//#region src/_store.ts
+const queue = /* @__PURE__ */ new Set();
+function notify(listeners) {
+	for (const listener of listeners) queue.add(listener);
+	for (const listener of queue) {
+		queue.delete(listener);
+		listener();
+	}
+}
+/**
+* Creates a store. Listeners run synchronously after each change, and an
+* update to an equal value (by `Object.is`) notifies no one.
+*/
+function createStore(initialState) {
+	let state = initialState;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		get state() {
+			return state;
+		},
+		get: () => state,
+		setState(updater) {
+			const next = updater(state);
+			if (Object.is(state, next)) return;
+			state = next;
+			notify(listeners);
+		},
+		subscribe(observerOrFn) {
+			const listener = () => {
+				if (typeof observerOrFn === "function") observerOrFn(state);
+				else observerOrFn.next?.(state);
+			};
+			listeners.add(listener);
+			return { unsubscribe() {
+				listeners.delete(listener);
+				queue.delete(listener);
+			} };
+		}
+	};
+}
+
+//#endregion
+export { createStore };

package/dist/adapter.d.ts

@@ -1,6 +1,8 @@
+import { Store, createStore } from "./_store.js";
 import { HotkeyCallback, HotkeyChord, HotkeySequence, RegisterableHotkey, RegisterableHotkeyChord, RegisterableHotkeySequence } from "./hotkey.types.js";
 import { ActivateHotkeyScopeOptions, HotkeyChordOptions, HotkeyOptions, HotkeySequenceOptions, Target } from "./hotkey-manager.js";
 import { AppHotkey, AppHotkeysStore } from "./app-hotkeys.js";
+import { createAppHotkeysStore } from "./_app-hotkeys-factory.js";
 //#region src/adapter.d.ts
 /**
  * A hotkey and its callback, with optional per-binding options. Chords accept
@@ -160,4 +162,5 @@ export declare function getHotkeysProviderScopeKey(options: {
  * Returns a function that releases the activation.
  */
 export declare function activateHotkeysProviderScope(key: string): () => void;
-//#endregion
+//#endregion
+export { type Store, createAppHotkeysStore, createStore };

package/dist/adapter.js

@@ -1,7 +1,9 @@
 import { detectPlatform } from "./platform.js";
 import { isHotkeySequence, normalizeHotkey } from "./parse.js";
+import { createStore } from "./_store.js";
 import { defaultHotkeyOptions } from "./_registration.js";
 import { getHotkeyManager } from "./hotkey-manager.js";
+import { createAppHotkeysStore } from "./_app-hotkeys-factory.js";
 import { getAppHotkeyRegistrationOptions, isAppHotkey, resolveAppHotkey } from "./app-hotkeys.js";
 
 //#region src/adapter.ts
@@ -171,4 +173,4 @@ function activateHotkeysProviderScope(key) {
 }
 
 //#endregion
-export { activateHotkeysProviderScope, createHotkeyBindings, getHotkeysProviderScopeKey, mergeHotkeysProviderDefaults, prepareHotkeyDefinitions, subscribePublishedAppHotkeys };
+export { activateHotkeysProviderScope, createAppHotkeysStore, createHotkeyBindings, createStore, getHotkeysProviderScopeKey, mergeHotkeysProviderDefaults, prepareHotkeyDefinitions, subscribePublishedAppHotkeys };

package/dist/app-hotkeys.d.ts

@@ -1,6 +1,6 @@
+import { Store } from "./_store.js";
 import { Hotkey, HotkeyChord, HotkeyMeta, HotkeySequence } from "./hotkey.types.js";
 import { HotkeyChordOptions, HotkeyRegistrationView, HotkeySequenceOptions } from "./hotkey-manager.js";
-import { Store } from "@tanstack/store";
 //#region src/app-hotkeys.d.ts
 type Platform = 'mac' | 'windows' | 'linux';
 type DeclaredOptionKeys = 'capture' | 'conflictBehavior' | 'eventType' | 'ignoreInputs' | 'preventDefault' | 'stopPropagation';