@tanstack/svelte-hotkeys 0.13.0 → 0.14.1

package/dist/createHotkeys.svelte.js

@@ -1,184 +1,81 @@
-import { detectPlatform, getHotkeyManager, normalizeRegisterableHotkey, } from '@tanstack/hotkeys';
+import { createHotkeyBindings, prepareHotkeyDefinitions, } from '@tanstack/hotkeys/adapter';
 import { onDestroy } from 'svelte';
-import { SvelteMap, SvelteSet } from 'svelte/reactivity';
-import { getDefaultHotkeysOptions } from './HotkeysCtx';
-import { resolveMaybeGetter } from './internal.svelte';
-function cleanupRegistrations(registrations) {
-    for (const { handle } of registrations.values()) {
-        if (handle.isActive) {
-            handle.unregister();
+import { getHotkeysContext } from './HotkeysCtx';
+import { createAppHotkeysSubscriber, resolveMaybeGetter, } from './internal.svelte';
+/**
+ * Registers definitions in an effect. With an element, every hotkey listens on
+ * that element; otherwise each uses its own target (document by default).
+ */
+function bindHotkeys(hotkeys, commonOptions, element) {
+    const context = getHotkeysContext();
+    const subscribeAppHotkeys = createAppHotkeysSubscriber(context?.appHotkeysStore ?? null);
+    const bindings = createHotkeyBindings();
+    $effect(() => {
+        if (typeof document === 'undefined') {
+            return;
         }
-    }
-    registrations.clear();
+        // Track app hotkeys so registrations move with custom hotkeys.
+        subscribeAppHotkeys();
+        const definitions = resolveMaybeGetter(hotkeys).map((definition) => ({
+            hotkey: resolveMaybeGetter(definition.hotkey),
+            callback: definition.callback,
+            options: definition.options
+                ? resolveMaybeGetter(definition.options)
+                : undefined,
+        }));
+        bindings.update(prepareHotkeyDefinitions(definitions, {
+            appHotkeysStore: context?.appHotkeysStore,
+            defaults: context?.defaultOptions.hotkey,
+            commonOptions: element
+                ? { ...resolveMaybeGetter(commonOptions), target: element }
+                : resolveMaybeGetter(commonOptions),
+            resolveTarget: element ? () => element : undefined,
+        }));
+    });
+    return bindings;
 }
 /**
- * Register multiple global hotkeys for the current component.
+ * Svelte function for registering several hotkeys at once on the document:
+ * chords, sequences, and app hotkeys. Pass getters for reactive values. Use
+ * `createHotkeysAttachment` for element-scoped hotkeys.
+ *
+ * Options merge in this order: provider defaults, app hotkey declaration,
+ * commonOptions, per-hotkey options. Each option applies only to the kinds
+ * that support it. Unbound app hotkeys and empty sequences register nothing.
  *
  * @example
  * ```svelte
  * <script lang="ts">
- *   import { createHotkeys } from '@tanstack/svelte-hotkeys'
- *
  *   createHotkeys([
  *     { hotkey: 'Mod+S', callback: () => save() },
- *     { hotkey: 'Mod+Z', callback: () => undo() },
- *     { hotkey: 'Escape', callback: () => close() },
+ *     { hotkey: ['G', 'G'], callback: () => scrollToTop(), options: { timeout: 500 } },
  *   ])
  * </script>
  * ```
  */
 export function createHotkeys(hotkeys, commonOptions = {}) {
-    const registrations = new SvelteMap();
-    onDestroy(() => {
-        cleanupRegistrations(registrations);
-    });
-    $effect(() => {
-        if (typeof document === 'undefined') {
-            return;
-        }
-        const resolvedHotkeys = resolveMaybeGetter(hotkeys);
-        const resolvedCommonOptions = resolveMaybeGetter(commonOptions);
-        const nextKeys = new SvelteSet();
-        const prepared = [];
-        for (let i = 0; i < resolvedHotkeys.length; i++) {
-            const def = resolvedHotkeys[i];
-            const resolvedHotkey = resolveMaybeGetter(def.hotkey);
-            const resolvedDefOptions = def.options
-                ? resolveMaybeGetter(def.options)
-                : {};
-            const mergedOptions = {
-                ...getDefaultHotkeysOptions().hotkey,
-                ...resolvedCommonOptions,
-                ...resolvedDefOptions,
-            };
-            const resolvedTarget = mergedOptions.target ??
-                (typeof document !== 'undefined' ? document : null);
-            if (!resolvedTarget) {
-                continue;
-            }
-            const hotkeyString = normalizeRegisterableHotkey(resolvedHotkey, mergedOptions.platform ?? detectPlatform());
-            const registrationKey = `${i}:${hotkeyString}`;
-            nextKeys.add(registrationKey);
-            prepared.push({
-                registrationKey,
-                def,
-                mergedOptions,
-                hotkeyString,
-                resolvedTarget,
-            });
-        }
-        for (const [key, record] of [...registrations.entries()]) {
-            if (!nextKeys.has(key)) {
-                if (record.handle.isActive) {
-                    record.handle.unregister();
-                }
-                registrations.delete(key);
-            }
-        }
-        for (const p of prepared) {
-            const existing = registrations.get(p.registrationKey);
-            const { target: _target, ...optionsWithoutTarget } = p.mergedOptions;
-            if (existing?.handle.isActive && existing.target === p.resolvedTarget) {
-                existing.handle.callback = p.def.callback;
-                existing.handle.setOptions(optionsWithoutTarget);
-                continue;
-            }
-            if (existing?.handle.isActive) {
-                existing.handle.unregister();
-            }
-            if (existing) {
-                registrations.delete(p.registrationKey);
-            }
-            const handle = getHotkeyManager().register(p.hotkeyString, p.def.callback, {
-                ...optionsWithoutTarget,
-                target: p.resolvedTarget,
-            });
-            registrations.set(p.registrationKey, {
-                handle,
-                target: p.resolvedTarget,
-            });
-        }
-    });
+    const bindings = bindHotkeys(hotkeys, commonOptions);
+    onDestroy(() => bindings.destroy());
 }
 /**
- * Create an attachment for element-scoped multi-hotkey registration.
+ * Create an attachment for element-scoped hotkeys: chords, sequences, and app
+ * hotkeys listen on the attached element.
  *
  * @example
  * ```svelte
  * <script lang="ts">
- *   import { createHotkeysAttachment } from '@tanstack/svelte-hotkeys'
- *
  *   const editorKeys = createHotkeysAttachment([
  *     { hotkey: 'Mod+S', callback: () => save() },
- *     { hotkey: 'Mod+Z', callback: () => undo() },
+ *     { hotkey: ['G', 'G'], callback: () => scrollToTop() },
  *   ])
  * </script>
  *
- * <div tabindex="0" {@attach editorKeys}>
- *   Editor content
- * </div>
+ * <div tabindex="0" {@attach editorKeys}>Editor content</div>
  * ```
  */
 export function createHotkeysAttachment(hotkeys, commonOptions = {}) {
     return (element) => {
-        const registrations = new SvelteMap();
-        $effect(() => {
-            const resolvedHotkeys = resolveMaybeGetter(hotkeys);
-            const resolvedCommonOptions = resolveMaybeGetter(commonOptions);
-            const nextKeys = new SvelteSet();
-            const prepared = [];
-            for (let i = 0; i < resolvedHotkeys.length; i++) {
-                const def = resolvedHotkeys[i];
-                const resolvedHotkey = resolveMaybeGetter(def.hotkey);
-                const resolvedDefOptions = def.options
-                    ? resolveMaybeGetter(def.options)
-                    : {};
-                const mergedOptions = {
-                    ...getDefaultHotkeysOptions().hotkey,
-                    ...resolvedCommonOptions,
-                    ...resolvedDefOptions,
-                };
-                const hotkeyString = normalizeRegisterableHotkey(resolvedHotkey, mergedOptions.platform ?? detectPlatform());
-                const registrationKey = `${i}:${hotkeyString}`;
-                nextKeys.add(registrationKey);
-                prepared.push({
-                    registrationKey,
-                    def,
-                    mergedOptions,
-                    hotkeyString,
-                });
-            }
-            for (const [key, record] of [...registrations.entries()]) {
-                if (!nextKeys.has(key)) {
-                    if (record.handle.isActive) {
-                        record.handle.unregister();
-                    }
-                    registrations.delete(key);
-                }
-            }
-            for (const p of prepared) {
-                const existing = registrations.get(p.registrationKey);
-                const { target: _target, ...optionsWithoutTarget } = p.mergedOptions;
-                if (existing?.handle.isActive) {
-                    existing.handle.callback = p.def.callback;
-                    existing.handle.setOptions(optionsWithoutTarget);
-                    continue;
-                }
-                if (existing?.handle.isActive) {
-                    existing.handle.unregister();
-                }
-                if (existing) {
-                    registrations.delete(p.registrationKey);
-                }
-                const handle = getHotkeyManager().register(p.hotkeyString, p.def.callback, {
-                    ...optionsWithoutTarget,
-                    target: element,
-                });
-                registrations.set(p.registrationKey, { handle, target: element });
-            }
-        });
-        return () => {
-            cleanupRegistrations(registrations);
-        };
+        const bindings = bindHotkeys(hotkeys, commonOptions, element);
+        return () => bindings.destroy();
     };
 }

package/dist/getAppHotkeys.svelte.d.ts

@@ -0,0 +1,49 @@
+import type { AppHotkey, AppHotkeyListItem, CustomHotkeys, Hotkey, RegisteredAppHotkeys } from '@tanstack/hotkeys';
+export interface SvelteAppHotkeys {
+    /** Effective app hotkeys: each declaration with the user's custom hotkey applied. */
+    readonly current: RegisteredAppHotkeys;
+}
+/**
+ * Returns reactive access to the effective app hotkeys from `HotkeysProvider`,
+ * typed by `Register`.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   const hotkeys = getAppHotkeys()
+ *   createHotkey(() => hotkeys.current['doc.save'], () => save())
+ * </script>
+ * ```
+ */
+export declare function getAppHotkeys(): SvelteAppHotkeys;
+export interface SvelteAppHotkeyList {
+    /** Every app hotkey with its live status, in declaration order. */
+    readonly current: Array<AppHotkeyListItem<RegisteredAppHotkeys[keyof RegisteredAppHotkeys]>>;
+}
+/**
+ * Lists every app hotkey with its live status, for cheat sheets and settings
+ * screens. App hotkeys whose components have not mounted are `'inactive'`;
+ * those without a hotkey are `'unbound'`.
+ */
+export declare function getAppHotkeyList(): SvelteAppHotkeyList;
+export interface SvelteCustomHotkeys {
+    /** The user's hotkeys that differ from the defaults. */
+    readonly current: CustomHotkeys;
+    /**
+     * Sets the user's hotkey for an app hotkey. `null` unbinds it.
+     * Returns conflicting app hotkeys; when any exist, nothing changes.
+     */
+    setCustomHotkey: (id: keyof RegisteredAppHotkeys & string, hotkey: Hotkey | null) => Array<AppHotkey>;
+    /** Restores the default hotkey for an app hotkey. */
+    resetCustomHotkey: (id: keyof RegisteredAppHotkeys & string) => void;
+    /** Restores every default hotkey. */
+    resetCustomHotkeys: () => void;
+    /** Other app hotkeys that would collide if `id` used `hotkey`. */
+    findConflicts: (id: keyof RegisteredAppHotkeys & string, hotkey: Hotkey) => Array<AppHotkey>;
+}
+/**
+ * Reads and changes the user's custom hotkeys. Changes apply to every
+ * registered app hotkey immediately and are passed to the provider's
+ * `onCustomHotkeysChange`, ready to save.
+ */
+export declare function getCustomHotkeys(): SvelteCustomHotkeys;

package/dist/getAppHotkeys.svelte.js

@@ -0,0 +1,67 @@
+import { getHotkeysContext } from './HotkeysCtx';
+import { createStoreSubscriber } from './internal.svelte';
+import { getHotkeyRegistrations } from './getHotkeyRegistrations.svelte';
+function requireStore(name) {
+    const store = getHotkeysContext()?.appHotkeysStore;
+    if (!store) {
+        throw new Error(`${name} requires a HotkeysProvider with appHotkeys`);
+    }
+    return {
+        store: store,
+        subscribe: createStoreSubscriber(store.store),
+    };
+}
+/**
+ * Returns reactive access to the effective app hotkeys from `HotkeysProvider`,
+ * typed by `Register`.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   const hotkeys = getAppHotkeys()
+ *   createHotkey(() => hotkeys.current['doc.save'], () => save())
+ * </script>
+ * ```
+ */
+export function getAppHotkeys() {
+    const { store, subscribe } = requireStore('getAppHotkeys');
+    return {
+        get current() {
+            subscribe();
+            return store.appHotkeys;
+        },
+    };
+}
+/**
+ * Lists every app hotkey with its live status, for cheat sheets and settings
+ * screens. App hotkeys whose components have not mounted are `'inactive'`;
+ * those without a hotkey are `'unbound'`.
+ */
+export function getAppHotkeyList() {
+    const { store, subscribe } = requireStore('getAppHotkeyList');
+    const registrations = getHotkeyRegistrations();
+    return {
+        get current() {
+            subscribe();
+            return store.getList(registrations.hotkeys);
+        },
+    };
+}
+/**
+ * Reads and changes the user's custom hotkeys. Changes apply to every
+ * registered app hotkey immediately and are passed to the provider's
+ * `onCustomHotkeysChange`, ready to save.
+ */
+export function getCustomHotkeys() {
+    const { store, subscribe } = requireStore('getCustomHotkeys');
+    return {
+        get current() {
+            subscribe();
+            return store.customHotkeys;
+        },
+        setCustomHotkey: (id, hotkey) => store.setCustomHotkey(id, hotkey),
+        resetCustomHotkey: (id) => store.resetCustomHotkey(id),
+        resetCustomHotkeys: () => store.resetCustomHotkeys(),
+        findConflicts: (id, hotkey) => store.findConflicts(id, hotkey),
+    };
+}

package/dist/getHotkeyHint.svelte.d.ts

@@ -1,13 +1,13 @@
-import type { HeldModifierOptions, RegisterableHotkey } from '@tanstack/hotkeys';
+import type { AppHotkey, HeldModifierOptions, RegisterableHotkey } from '@tanstack/hotkeys';
 import type { MaybeGetter } from './internal.svelte';
 export interface SvelteHotkeyHint {
     readonly visible: boolean;
 }
 /**
- * Returns an object with a reactive `visible` getter indicating whether held modifiers reveal this shortcut.
- * Pass getters to track changing bindings and options.
- * Uses the nonempty-subset/AltGr rules of `matchesHeldModifiers`; `exact` requires
- * every modifier. Combine with the action's enabled state before showing a badge.
- * This helper does not register a shortcut or check whether its target is focused.
+ * Returns an object with a reactive `visible` getter indicating whether held
+ * modifiers reveal this shortcut. Pass getters to track changing hotkeys and
+ * options. A sequence reveals its hint from its first step, and an app hotkey
+ * uses its effective hotkey (false while unbound). This helper does not
+ * register a shortcut or check whether its target is focused.
  */
-export declare function getHotkeyHint(hotkey: MaybeGetter<RegisterableHotkey>, options?: MaybeGetter<HeldModifierOptions>): SvelteHotkeyHint;
+export declare function getHotkeyHint(hotkey: MaybeGetter<RegisterableHotkey | AppHotkey>, options?: MaybeGetter<HeldModifierOptions>): SvelteHotkeyHint;

package/dist/getHotkeyHint.svelte.js

@@ -1,29 +1,43 @@
 import { createSubscriber } from 'svelte/reactivity';
-import { getKeyStateTracker, matchesHeldModifiers } from '@tanstack/hotkeys';
+import { getKeyStateTracker, isAppHotkey, matchesHeldModifiers, resolveAppHotkey, } from '@tanstack/hotkeys';
+import { getHotkeysContext } from './HotkeysCtx';
 import { resolveMaybeGetter } from './internal.svelte';
 /**
- * Returns an object with a reactive `visible` getter indicating whether held modifiers reveal this shortcut.
- * Pass getters to track changing bindings and options.
- * Uses the nonempty-subset/AltGr rules of `matchesHeldModifiers`; `exact` requires
- * every modifier. Combine with the action's enabled state before showing a badge.
- * This helper does not register a shortcut or check whether its target is focused.
+ * Returns an object with a reactive `visible` getter indicating whether held
+ * modifiers reveal this shortcut. Pass getters to track changing hotkeys and
+ * options. A sequence reveals its hint from its first step, and an app hotkey
+ * uses its effective hotkey (false while unbound). This helper does not
+ * register a shortcut or check whether its target is focused.
  */
 export function getHotkeyHint(hotkey, options = {}) {
     const tracker = getKeyStateTracker();
-    // Resolve current reactive arguments without caching a stale binding.
-    const read = () => matchesHeldModifiers(resolveMaybeGetter(hotkey), tracker.store.state.heldKeys, resolveMaybeGetter(options));
+    const store = getHotkeysContext()?.appHotkeysStore ?? null;
+    // Resolve current reactive arguments without caching a stale hotkey.
+    const read = () => {
+        const value = resolveMaybeGetter(hotkey);
+        const resolved = isAppHotkey(value)
+            ? resolveAppHotkey(value, store).hotkey
+            : value;
+        return (resolved !== null &&
+            matchesHeldModifiers(resolved, tracker.store.state.heldKeys, resolveMaybeGetter(options)));
+    };
     let previous = false;
     // Notify Svelte only when visibility changes, not for every unrelated held key.
     const subscribe = createSubscriber((update) => {
         previous = read();
-        const subscription = tracker.store.subscribe(() => {
+        const check = () => {
             const next = read();
             if (next !== previous) {
                 previous = next;
                 update();
             }
-        });
-        return () => subscription.unsubscribe();
+        };
+        const keys = tracker.store.subscribe(check);
+        const custom = store?.store.subscribe(check);
+        return () => {
+            keys.unsubscribe();
+            custom?.unsubscribe();
+        };
     });
     return {
         /** Reads visibility and subscribes the current reactive consumer when needed. */

package/dist/getHotkeyRegistrations.svelte.d.ts

@@ -1,25 +1,22 @@
-import type { HotkeyRegistrationView, SequenceRegistrationView } from '@tanstack/hotkeys';
+import type { HotkeyRegistrationView } from '@tanstack/hotkeys';
 export interface SvelteHotkeyRegistrations {
+    /** Every registration, chords and sequences. Narrow each view with `kind`. */
     readonly hotkeys: Array<HotkeyRegistrationView>;
-    readonly sequences: Array<SequenceRegistrationView>;
 }
 /**
- * Svelte function that returns reactive access to all hotkey and sequence
- * registrations from the singleton managers.
+ * Svelte function that returns reactive access to every hotkey registration,
+ * chords and sequences, from the singleton HotkeyManager.
  *
- * This is a standalone function that does NOT require the HotkeysProvider.
- *
- * @returns Object with reactive `hotkeys` and `sequences` properties
+ * This function does NOT require the HotkeysProvider.
  *
  * @example
  * ```svelte
- * <script>
- *   import { getHotkeyRegistrations } from '@tanstack/svelte-hotkeys'
- *
+ * <script lang="ts">
  *   const registrations = getHotkeyRegistrations()
  * </script>
- * {#each registrations.hotkeys as reg}
- *   <div>{reg.options.meta?.name} — {reg.triggerCount} triggers</div>
+ *
+ * {#each registrations.hotkeys as reg (reg.id)}
+ *   <li>{reg.options.meta?.name}: {formatForDisplay(reg.hotkey)}</li>
  * {/each}
  * ```
  */

package/dist/getHotkeyRegistrations.svelte.js

@@ -1,36 +1,27 @@
-import { getHotkeyManager, getSequenceManager, toHotkeyRegistrationView, } from '@tanstack/hotkeys';
+import { getHotkeyManager, toHotkeyRegistrationView } from '@tanstack/hotkeys';
 import { createStoreSubscriber } from './internal.svelte';
 class HotkeyRegistrationsState {
-    #hotkeyManager = getHotkeyManager();
-    #sequenceManager = getSequenceManager();
-    #subscribeHotkeys = createStoreSubscriber(this.#hotkeyManager.registrations);
-    #subscribeSequences = createStoreSubscriber(this.#sequenceManager.registrations);
+    #manager = getHotkeyManager();
+    #subscribe = createStoreSubscriber(this.#manager.registrations);
     get hotkeys() {
-        this.#subscribeHotkeys();
-        return Array.from(this.#hotkeyManager.registrations.state.values()).map(toHotkeyRegistrationView);
-    }
-    get sequences() {
-        this.#subscribeSequences();
-        return Array.from(this.#sequenceManager.registrations.state.values());
+        this.#subscribe();
+        return Array.from(this.#manager.registrations.state.values()).map(toHotkeyRegistrationView);
     }
 }
 /**
- * Svelte function that returns reactive access to all hotkey and sequence
- * registrations from the singleton managers.
- *
- * This is a standalone function that does NOT require the HotkeysProvider.
+ * Svelte function that returns reactive access to every hotkey registration,
+ * chords and sequences, from the singleton HotkeyManager.
  *
- * @returns Object with reactive `hotkeys` and `sequences` properties
+ * This function does NOT require the HotkeysProvider.
  *
  * @example
  * ```svelte
- * <script>
- *   import { getHotkeyRegistrations } from '@tanstack/svelte-hotkeys'
- *
+ * <script lang="ts">
  *   const registrations = getHotkeyRegistrations()
  * </script>
- * {#each registrations.hotkeys as reg}
- *   <div>{reg.options.meta?.name} — {reg.triggerCount} triggers</div>
+ *
+ * {#each registrations.hotkeys as reg (reg.id)}
+ *   <li>{reg.options.meta?.name}: {formatForDisplay(reg.hotkey)}</li>
  * {/each}
  * ```
  */

package/dist/index.d.ts

@@ -1,15 +1,13 @@
 export * from '@tanstack/hotkeys';
 export * from './createHotkey.svelte';
 export * from './createHotkeys.svelte';
-export * from './createHotkeySequence.svelte';
-export * from './createHotkeySequences.svelte';
 export * from './createHotkeyRecorder.svelte';
-export * from './createHotkeySequenceRecorder.svelte';
 export * from './getHeldKeys.svelte';
 export * from './getHotkeyRegistrations.svelte';
 export * from './getHeldKeyCodesMap.svelte';
 export * from './getIsKeyHeld.svelte';
+export * from './getAppHotkeys.svelte';
 export { default as HotkeysProvider } from './HotkeysProvider.svelte';
 export { DEFAULT_OPTIONS, getDefaultHotkeysOptions, getHotkeysContext, setHotkeysContext, } from './HotkeysCtx';
-export type { HotkeysProviderOptions, HotkeysProviderProps } from './HotkeysCtx';
+export type { HotkeysContextOptions, HotkeysProviderOptions, HotkeysProviderProps, } from './HotkeysCtx';
 export * from './getHotkeyHint.svelte';

package/dist/index.js

@@ -2,14 +2,12 @@
 export * from '@tanstack/hotkeys';
 export * from './createHotkey.svelte';
 export * from './createHotkeys.svelte';
-export * from './createHotkeySequence.svelte';
-export * from './createHotkeySequences.svelte';
 export * from './createHotkeyRecorder.svelte';
-export * from './createHotkeySequenceRecorder.svelte';
 export * from './getHeldKeys.svelte';
 export * from './getHotkeyRegistrations.svelte';
 export * from './getHeldKeyCodesMap.svelte';
 export * from './getIsKeyHeld.svelte';
+export * from './getAppHotkeys.svelte';
 export { default as HotkeysProvider } from './HotkeysProvider.svelte';
 export { DEFAULT_OPTIONS, getDefaultHotkeysOptions, getHotkeysContext, setHotkeysContext, } from './HotkeysCtx';
 export * from './getHotkeyHint.svelte';

package/dist/internal.svelte.d.ts

@@ -1,3 +1,4 @@
+import type { AppHotkeysStore } from '@tanstack/hotkeys';
 export type MaybeGetter<T> = T | (() => T);
 interface SubscribableStore<TState> {
     state: TState;
@@ -7,4 +8,9 @@ interface SubscribableStore<TState> {
 }
 export declare function resolveMaybeGetter<T>(value: MaybeGetter<T>): T;
 export declare function createStoreSubscriber<TState>(store: SubscribableStore<TState>): () => void;
+/**
+ * Returns a function that subscribes the current reactive consumer to an app
+ * hotkeys store, so it re-runs when app hotkeys or custom hotkeys change.
+ */
+export declare function createAppHotkeysSubscriber(store: AppHotkeysStore | null): () => void;
 export {};

package/dist/internal.svelte.js

@@ -10,3 +10,11 @@ export function createStoreSubscriber(store) {
             : () => subscription.unsubscribe();
     });
 }
+const noop = () => { };
+/**
+ * Returns a function that subscribes the current reactive consumer to an app
+ * hotkeys store, so it re-runs when app hotkeys or custom hotkeys change.
+ */
+export function createAppHotkeysSubscriber(store) {
+    return store ? createStoreSubscriber(store.store) : noop;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/svelte-hotkeys",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "description": "Svelte adapter for TanStack Hotkeys",
   "author": "Kunal Rao",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "dist"
   ],
   "dependencies": {
-    "@tanstack/hotkeys": "0.11.0"
+    "@tanstack/hotkeys": "0.12.1"
   },
   "devDependencies": {
     "@sveltejs/package": "^3.0.0",

package/dist/createHotkeySequence.svelte.d.ts

@@ -1,65 +0,0 @@
-import type { HotkeyCallback, HotkeySequence, SequenceOptions } from '@tanstack/hotkeys';
-import type { MaybeGetter } from './internal.svelte';
-import type { Attachment } from 'svelte/attachments';
-export interface CreateHotkeySequenceOptions extends Omit<SequenceOptions, 'target'> {
-    target?: Document | Window;
-}
-/**
- * Register a global keyboard shortcut sequence for the current component.
- *
- * Each step may include modifiers. You can chain the same modifier across
- * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
- * Control, Alt, or Meta pressed alone) are ignored while matching—they do not
- * advance the sequence or reset progress.
- *
- * @example
- * ```svelte
- * <script lang="ts">
- *   import { createHotkeySequence } from '@tanstack/svelte-hotkeys'
- *
- *   // Scroll to top when 'G G' is pressed
- *   createHotkeySequence(['G', 'G'], () => {
- *     scrollToTop()
- *   })
- *
- *   // Delete line when 'D D' is pressed
- *   createHotkeySequence(['D', 'D'], () => {
- *     deleteLine()
- *   })
- *
- *   // Delete inner word when 'D I W' is pressed
- *   createHotkeySequence(['D', 'I', 'W'], () => {
- *     deleteInnerWord()
- *   }, { timeout: 500 })
- *
- *   // Same modifier on consecutive steps (bare Shift between chords is ignored)
- *   createHotkeySequence(['Shift+R', 'Shift+T'], () => {
- *     nextAction()
- *   })
- * </script>
- *
- * <div>
- *   ....
- * </div>
- * ```
- */
-export declare function createHotkeySequence(sequence: MaybeGetter<HotkeySequence>, callback: HotkeyCallback, options?: MaybeGetter<CreateHotkeySequenceOptions>): void;
-/**
- * Create an attachment for element-scoped keyboard sequences.
- *
- * @example
- * ```svelte
- * <script lang="ts">
- *   import { createHotkeySequenceAttachment } from '@tanstack/svelte-hotkeys'
- *
- *   const vimKeys = createHotkeySequenceAttachment(['G', 'G'], () => {
- *     scrollToTop()
- *   })
- * </script>
- *
- * <div tabindex="0" {@attach vimKeys}>
- *   Focus here and press g then g
- * </div>
- * ```
- */
-export declare function createHotkeySequenceAttachment(sequence: MaybeGetter<HotkeySequence>, callback: HotkeyCallback, options?: MaybeGetter<CreateHotkeySequenceOptions>): Attachment<HTMLElement>;