rx-hotkeys 2.5.0 → 2.6.0

package/dist/tt.js

@@ -0,0 +1,384 @@
+import { fromEvent, BehaviorSubject, EMPTY, filter, map, bufferCount, withLatestFrom, tap, catchError, scan, merge, } from "rxjs";
+// --- Enums, Interfaces and Types ---
+export var ShortcutTypes;
+(function (ShortcutTypes) {
+    ShortcutTypes["Combination"] = "combination";
+    ShortcutTypes["Sequence"] = "sequence";
+})(ShortcutTypes || (ShortcutTypes = {}));
+var EmitStates;
+(function (EmitStates) {
+    EmitStates[EmitStates["Emit"] = 0] = "Emit";
+    EmitStates[EmitStates["Ignore"] = 1] = "Ignore";
+    EmitStates[EmitStates["InProgress"] = 2] = "InProgress";
+})(EmitStates || (EmitStates = {}));
+// --- Helper function to compare keys ---
+/**
+ * Compares a browser event's key with a configured key.
+ * - For single character keys (e.g., "a", "A", "7"), comparison is case-insensitive.
+ * - For multi-character special keys (e.g., "Enter", "ArrowUp"), comparison is case-sensitive.
+ */
+function compareKey(eventKey, configuredKey) {
+    if (configuredKey.length === 1 && eventKey.length === 1) {
+        return eventKey.toLowerCase() === configuredKey.toLowerCase();
+    }
+    return eventKey === configuredKey;
+}
+// --- Hotkeys Library ---
+/**
+ * Manages keyboard shortcuts for web applications.
+ */
+export class Hotkeys {
+    static KEYDOWN_EVENT = "keydown";
+    static LOG_PREFIX = "Hotkeys:";
+    keydown$;
+    activeContext$;
+    activeShortcuts;
+    debugMode;
+    /**
+     * Creates an instance of Hotkeys.
+     * @param initialContext - Optional initial context name.
+     * @param debugMode - Optional. If true, debug messages will be logged to the console.
+     */
+    constructor(initialContext = null, debugMode = false) {
+        this.debugMode = debugMode;
+        if (typeof document === "undefined" || typeof performance === "undefined") {
+            throw new Error(`${Hotkeys.LOG_PREFIX} Hotkeys can only be used in a browser environment with global "document" and "performance" objects.`);
+        }
+        this.keydown$ = fromEvent(document, Hotkeys.KEYDOWN_EVENT);
+        this.activeContext$ = new BehaviorSubject(initialContext);
+        this.activeShortcuts = new Map();
+        if (this.debugMode) {
+            console.log(`${Hotkeys.LOG_PREFIX} Library initialized. Initial context: "${initialContext}". Debug mode: ${debugMode}.`);
+        }
+    }
+    /**
+     * Sets the active context for shortcuts.
+     * @param contextName - The name of the context (e.g., "editor"). Pass `null` to clear the context.
+     * @returns `true` if the context was changed, `false` otherwise.
+     */
+    setContext(contextName) {
+        const currentContext = this.activeContext$.getValue();
+        if (currentContext === contextName) {
+            if (this.debugMode) {
+                console.log(`${Hotkeys.LOG_PREFIX} setContext called with the same context "${contextName}". No change made.`);
+            }
+            return false;
+        }
+        if (this.debugMode) {
+            console.log(`${Hotkeys.LOG_PREFIX} Context changed from "${currentContext}" to "${contextName}".`);
+        }
+        this.activeContext$.next(contextName);
+        return true;
+    }
+    /**
+     * Gets the current active context.
+     */
+    getContext() {
+        return this.activeContext$.getValue();
+    }
+    /**
+     * Enables or disables debug logging.
+     */
+    setDebugMode(enable) {
+        if (this.debugMode === enable)
+            return;
+        this.debugMode = enable;
+        console.log(`${Hotkeys.LOG_PREFIX} Debug mode ${enable ? "enabled" : "disabled"}.`);
+    }
+    /**
+     * Checks if a shortcut with the given ID is registered.
+     */
+    hasShortcut(id) {
+        return this.activeShortcuts.has(id);
+    }
+    /**
+     * An Observable that emits the new context name whenever it changes.
+     */
+    get onContextChange$() {
+        return this.activeContext$.asObservable();
+    }
+    _areSequencesIdentical(seq1, seq2) {
+        if (seq1.length !== seq2.length)
+            return false;
+        for (let i = 0; i < seq1.length; i++) {
+            if (seq1[i] !== seq2[i])
+                return false;
+        }
+        return true;
+    }
+    _shortcutMatchesEvent(shortcutConfig, event) {
+        const keyTriggers = Array.isArray(shortcutConfig.keys) ? shortcutConfig.keys : [shortcutConfig.keys];
+        for (const keyInput of keyTriggers) {
+            let configuredMainKey;
+            let ctrlKeyConfig, altKeyConfig, shiftKeyConfig, metaKeyConfig;
+            if (typeof keyInput === "string") {
+                if (keyInput === "")
+                    continue;
+                configuredMainKey = keyInput;
+                [ctrlKeyConfig, altKeyConfig, shiftKeyConfig, metaKeyConfig] = [false, false, false, false];
+            }
+            else {
+                if (!keyInput.key)
+                    continue;
+                configuredMainKey = keyInput.key;
+                ({ ctrlKey: ctrlKeyConfig, altKey: altKeyConfig, shiftKey: shiftKeyConfig, metaKey: metaKeyConfig } = keyInput);
+            }
+            const keyMatch = compareKey(event.key, configuredMainKey);
+            if (!keyMatch)
+                continue;
+            const ctrlMatch = (ctrlKeyConfig === undefined) ? true : (event.ctrlKey === ctrlKeyConfig);
+            const altMatch = (altKeyConfig === undefined) ? true : (event.altKey === altKeyConfig);
+            const shiftMatch = (shiftKeyConfig === undefined) ? true : (event.shiftKey === shiftKeyConfig);
+            const metaMatch = (metaKeyConfig === undefined) ? true : (event.metaKey === metaKeyConfig);
+            if (ctrlMatch && altMatch && shiftMatch && metaMatch) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _registerShortcut(config, sub, type, log) {
+        const existing = this.activeShortcuts.get(config.id);
+        if (existing) {
+            console.warn(`${Hotkeys.LOG_PREFIX} Shortcut with ID "${config.id}" already exists. It will be overwritten.`);
+            existing.subscription.unsubscribe();
+        }
+        this.activeShortcuts.set(config.id, { id: config.id, config, subscription: sub });
+        if (this.debugMode) {
+            const contextLog = config.context ? `"${config.context}"` : config.strict ? "global (strict)" : "global (default)";
+            console.log(`${Hotkeys.LOG_PREFIX} ${type} shortcut "${config.id}" added. ${log}, Context: ${contextLog}`);
+        }
+        return config.id;
+    }
+    _parseKeyTrigger(keyInput, shortcutId) {
+        if (typeof keyInput === "string") {
+            if (keyInput === "") {
+                console.warn(`${Hotkeys.LOG_PREFIX} Invalid key (shorthand) in shortcut "${shortcutId}". Key must not be empty.`);
+                return null;
+            }
+            return {
+                configuredMainKey: keyInput, ctrlKeyConfig: false, altKeyConfig: false,
+                shiftKeyConfig: false, metaKeyConfig: false,
+                logDetails: `key: "${keyInput}" (no mods)`,
+            };
+        }
+        else {
+            if (!keyInput.key) {
+                console.warn(`${Hotkeys.LOG_PREFIX} Invalid "key" property in shortcut "${shortcutId}". Key must be a non-empty string.`);
+                return null;
+            }
+            const logDetails = `key: "${keyInput.key}"` +
+                (keyInput.ctrlKey !== undefined ? `, ctrl: ${keyInput.ctrlKey}` : "") +
+                (keyInput.altKey !== undefined ? `, alt: ${keyInput.altKey}` : "") +
+                (keyInput.shiftKey !== undefined ? `, shift: ${keyInput.shiftKey}` : "") +
+                (keyInput.metaKey !== undefined ? `, meta: ${keyInput.metaKey}` : "");
+            return {
+                configuredMainKey: keyInput.key, ctrlKeyConfig: keyInput.ctrlKey, altKeyConfig: keyInput.altKey,
+                shiftKeyConfig: keyInput.shiftKey, metaKeyConfig: keyInput.metaKey,
+                logDetails,
+            };
+        }
+    }
+    addCombination(config) {
+        const { keys, callback, context, preventDefault = false, id, strict = false } = config;
+        const keyTriggers = Array.isArray(keys) ? keys : [keys];
+        if (keyTriggers.length === 0) {
+            console.warn(`${Hotkeys.LOG_PREFIX} "keys" array for combination shortcut "${id}" is empty. Shortcut not added.`);
+            return undefined;
+        }
+        if (context != null && strict) {
+            console.warn(`${Hotkeys.LOG_PREFIX} In shortcut "${id}", the "strict" flag is redundant because the shortcut has a top-level context "${context}". Flag will be ignored.`);
+        }
+        const baseStream$ = (context == null && strict)
+            ? this.keydown$.pipe(// Strictly global, only listen when context is null
+            withLatestFrom(this.activeContext$), filter(([, activeCtx]) => activeCtx === null), map(([event]) => event))
+            : this.keydown$; // Default global or context-specific, listen to all keys
+        const observables = [];
+        const logParts = [];
+        for (const keyInput of keyTriggers) {
+            const parsedTrigger = this._parseKeyTrigger(keyInput, id);
+            if (!parsedTrigger)
+                return undefined;
+            const { configuredMainKey, ctrlKeyConfig, altKeyConfig, shiftKeyConfig, metaKeyConfig, logDetails } = parsedTrigger;
+            logParts.push(`{ ${logDetails} }`);
+            const stream = baseStream$.pipe(
+            // Filter by specific context if the shortcut is not strictly global
+            filter(() => {
+                if (context != null) {
+                    return context === this.activeContext$.getValue();
+                }
+                return true;
+            }), 
+            // Match the key and modifiers for this specific trigger
+            filter(event => {
+                const ctrlMatch = (ctrlKeyConfig === undefined) ? true : (event.ctrlKey === ctrlKeyConfig);
+                const altMatch = (altKeyConfig === undefined) ? true : (event.altKey === altKeyConfig);
+                const shiftMatch = (shiftKeyConfig === undefined) ? true : (event.shiftKey === shiftKeyConfig);
+                const metaMatch = (metaKeyConfig === undefined) ? true : (event.metaKey === metaKeyConfig);
+                return ctrlMatch && altMatch && shiftMatch && metaMatch && compareKey(event.key, configuredMainKey);
+            }), 
+            // Priority filter for global shortcuts to prevent them from firing over specific ones
+            filter(event => {
+                if (context != null || strict)
+                    return true;
+                const currentSpecificContext = this.activeContext$.getValue();
+                if (currentSpecificContext == null)
+                    return true;
+                for (const [, otherAS] of this.activeShortcuts) {
+                    if (otherAS.config.id !== config.id && 'keys' in otherAS.config &&
+                        otherAS.config.context === currentSpecificContext && this._shortcutMatchesEvent(otherAS.config, event)) {
+                        if (this.debugMode) {
+                            console.log(`${Hotkeys.LOG_PREFIX} Global shortcut "${config.id}" (key: "${event.key}") suppressed by specific context shortcut "${otherAS.config.id}".`);
+                        }
+                        return false;
+                    }
+                }
+                return true;
+            }));
+            observables.push(stream);
+        }
+        if (observables.length === 0)
+            return undefined;
+        const finalShortcut$ = merge(...observables);
+        const overallLogDetails = `Triggers: [ ${logParts.join(", ")} ]`;
+        const subscription = finalShortcut$.pipe(tap(event => {
+            if (this.debugMode)
+                console.log(`${Hotkeys.LOG_PREFIX} Combination "${id}" triggered by key "${event.key}".`);
+            if (preventDefault)
+                event.preventDefault();
+        }), catchError(err => {
+            console.error(`${Hotkeys.LOG_PREFIX} Error in stream for combination "${id}":`, err);
+            return EMPTY;
+        })).subscribe(event => {
+            try {
+                callback(event);
+            }
+            catch (e) {
+                console.error(`${Hotkeys.LOG_PREFIX} Error in callback for combination "${id}":`, e);
+            }
+        });
+        return this._registerShortcut(config, subscription, ShortcutTypes.Combination, overallLogDetails);
+    }
+    addSequence(config) {
+        const { sequence, callback, context, preventDefault = false, id, sequenceTimeoutMs, strict = false } = config;
+        if (!Array.isArray(sequence) || sequence.length === 0) {
+            console.warn(`${Hotkeys.LOG_PREFIX} Sequence for shortcut "${id}" is empty. Not added.`);
+            return undefined;
+        }
+        if (sequence.some(key => typeof key !== "string" || key === "")) {
+            console.warn(`${Hotkeys.LOG_PREFIX} Invalid key in sequence for shortcut "${id}". Not added.`);
+            return undefined;
+        }
+        if (context != null && strict) {
+            console.warn(`${Hotkeys.LOG_PREFIX} In sequence shortcut "${id}", the "strict" flag is redundant because it has a top-level context "${context}". Flag will be ignored.`);
+        }
+        const sequenceLength = sequence.length;
+        const baseKeydownStream$ = (context == null && strict)
+            ? this.keydown$.pipe(// Strictly global
+            withLatestFrom(this.activeContext$), filter(([, activeCtx]) => activeCtx === null), map(([event]) => event))
+            : this.keydown$.pipe(// Default global or context-specific
+            withLatestFrom(this.activeContext$), filter(([, activeCtx]) => context == null || context === activeCtx), map(([event]) => event));
+        let shortcut$;
+        if (sequenceTimeoutMs && sequenceTimeoutMs > 0) {
+            shortcut$ = baseKeydownStream$.pipe(scan((acc, event) => {
+                let { matchedEvents, lastEventTime } = acc;
+                const currentTime = performance.now();
+                if (acc.emitState === EmitStates.Emit)
+                    matchedEvents = [];
+                if (matchedEvents.length > 0 && (currentTime - lastEventTime > sequenceTimeoutMs)) {
+                    matchedEvents = [];
+                }
+                if (compareKey(event.key, sequence[matchedEvents.length])) {
+                    const newMatched = [...matchedEvents, event];
+                    if (newMatched.length === sequenceLength) {
+                        return { matchedEvents: newMatched, lastEventTime: currentTime, emitState: EmitStates.Emit };
+                    }
+                    return { matchedEvents: newMatched, lastEventTime: currentTime, emitState: EmitStates.InProgress };
+                }
+                const newSequenceStartsWithKey = compareKey(event.key, sequence[0]);
+                if (matchedEvents.length > 0 && this.debugMode && !newSequenceStartsWithKey) {
+                    console.log(`${Hotkeys.LOG_PREFIX} Sequence "${id}" broken by key "${event.key}". Resetting.`);
+                }
+                return { matchedEvents: newSequenceStartsWithKey ? [event] : [], lastEventTime: currentTime, emitState: EmitStates.InProgress };
+            }, { matchedEvents: [], lastEventTime: 0, emitState: EmitStates.Ignore }), filter(state => state.emitState === EmitStates.Emit), map(state => state.matchedEvents));
+        }
+        else {
+            shortcut$ = baseKeydownStream$.pipe(bufferCount(sequenceLength, 1), filter(events => events.every((e, i) => compareKey(e.key, sequence[i]))));
+        }
+        const finalShortcutWithPriority$ = shortcut$.pipe(filter(() => {
+            if (context != null || strict)
+                return true;
+            const currentSpecificContext = this.activeContext$.getValue();
+            if (currentSpecificContext == null)
+                return true;
+            for (const [, otherAS] of this.activeShortcuts) {
+                if (otherAS.config.id !== config.id && "sequence" in otherAS.config &&
+                    otherAS.config.context === currentSpecificContext && this._areSequencesIdentical(config.sequence, otherAS.config.sequence)) {
+                    if (this.debugMode) {
+                        console.log(`${Hotkeys.LOG_PREFIX} Global sequence "${config.id}" suppressed by specific context shortcut "${otherAS.config.id}".`);
+                    }
+                    return false;
+                }
+            }
+            return true;
+        }), tap(events => {
+            if (this.debugMode)
+                console.log(`${Hotkeys.LOG_PREFIX} Sequence "${id}" triggered.`);
+            if (preventDefault && events.length > 0)
+                events[events.length - 1].preventDefault();
+        }), catchError(err => {
+            console.error(`${Hotkeys.LOG_PREFIX} Error in stream for sequence "${id}":`, err);
+            return EMPTY;
+        }));
+        const subscription = finalShortcutWithPriority$.subscribe(events => {
+            try {
+                if (events.length > 0)
+                    callback(events[events.length - 1]);
+            }
+            catch (e) {
+                console.error(`${Hotkeys.LOG_PREFIX} Error in callback for sequence "${id}":`, e);
+            }
+        });
+        const logDetails = `Sequence: ${sequence.join(" -> ")}`;
+        return this._registerShortcut(config, subscription, ShortcutTypes.Sequence, logDetails);
+    }
+    /**
+     * Removes a registered shortcut by its ID.
+     */
+    remove(id) {
+        const shortcut = this.activeShortcuts.get(id);
+        if (shortcut) {
+            shortcut.subscription.unsubscribe();
+            this.activeShortcuts.delete(id);
+            if (this.debugMode)
+                console.log(`${Hotkeys.LOG_PREFIX} Shortcut "${id}" removed.`);
+            return true;
+        }
+        console.warn(`${Hotkeys.LOG_PREFIX} Shortcut with ID "${id}" not found for removal.`);
+        return false;
+    }
+    /**
+     * Retrieves a list of all currently active shortcuts.
+     */
+    getActiveShortcuts() {
+        const shortcuts = [];
+        for (const [id, activeShortcut] of this.activeShortcuts.entries()) {
+            shortcuts.push({
+                id,
+                description: activeShortcut.config.description,
+                context: activeShortcut.config.context,
+                type: "sequence" in activeShortcut.config ? ShortcutTypes.Sequence : ShortcutTypes.Combination
+            });
+        }
+        return shortcuts;
+    }
+    /**
+     * Cleans up all active subscriptions.
+     */
+    destroy() {
+        if (this.debugMode)
+            console.log(`${Hotkeys.LOG_PREFIX} Destroying library instance.`);
+        this.activeShortcuts.forEach(shortcut => shortcut.subscription.unsubscribe());
+        this.activeShortcuts.clear();
+        this.activeContext$.complete();
+    }
+}

package/dist/ttt.d.ts

@@ -0,0 +1,164 @@
+import { Subscription, Observable } from "rxjs";
+import { type StandardKey } from "./keys.js";
+export declare enum ShortcutTypes {
+    Combination = "combination",
+    Sequence = "sequence"
+}
+interface ShortcutConfigBase {
+    id: string;
+    callback: (event: KeyboardEvent) => void;
+    context?: string | null;
+    preventDefault?: boolean;
+    description?: string;
+}
+/**
+ * Defines a single key trigger, which can be a StandardKey (for simple presses like "Escape")
+ * or an object specifying the main key and its modifiers (e.g., { key: Keys.S, ctrlKey: true }).
+ */
+type KeyCombinationTrigger = {
+    /**
+     * The main key for the combination.
+     * This MUST be a value from the exported `Keys` object
+     * (e.g., `Keys.A`, `Keys.Enter`, `Keys.Escape`).
+     * The library handles case-insensitivity for single character keys (like A-Z, 0-9)
+     * automatically when comparing with the actual browser event's `event.key`.
+     * For special, multi-character keys (e.g. "ArrowUp", "Escape"), the value from
+     * `Keys` ensures the correct case-sensitive string is used.
+     * Refer to: https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values
+     */
+    key: StandardKey;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    metaKey?: boolean;
+} | StandardKey;
+export interface KeyCombinationConfig extends ShortcutConfigBase {
+    /**
+     * Defines the key or key combination(s) that trigger the shortcut.
+     * Can be a single trigger or an array of triggers.
+     * Each trigger can be an object specifying the main `key` (from `StandardKey`) and optional
+     * modifiers (`ctrlKey`, `altKey`, `shiftKey`, `metaKey`).
+     * Example: `{ key: Keys.S, ctrlKey: true }` for Ctrl+S.
+     *
+     * Alternatively, for a simple key press without any modifiers, a trigger can be
+     * a `StandardKey` directly.
+     * Example: `Keys.Escape` for the Escape key. When using this shorthand,
+     * it implies that no modifier keys (Ctrl, Alt, Shift, Meta) should be active.
+     *
+     * To define multiple triggers for the same action:
+     * Example: `keys: [Keys.Enter, { key: Keys.Space, ctrlKey: true }]`
+     */
+    keys: KeyCombinationTrigger | KeyCombinationTrigger[];
+}
+export interface KeySequenceConfig extends ShortcutConfigBase {
+    /**
+     * An array of keys that form the sequence.
+     * Each key in the sequence MUST be a value from the exported `Keys` object
+     * (e.g., `Keys.ArrowUp`, `Keys.G`, `Keys.Digit1`).
+     * The library handles case-insensitivity for single character keys automatically
+     * when comparing with the actual browser event's `event.key`.
+     * Refer to: https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values
+     * Example: [Keys.Control, Keys.Alt, Keys.Delete] or [Keys.G, Keys.I]
+     */
+    sequence: StandardKey[];
+    /**
+     * Optional: Timeout in milliseconds between consecutive key presses in the sequence.
+     * If the time between two keys in the sequence exceeds this value, the sequence attempt is reset.
+     * Set to 0 or undefined to disable inter-key timeout behavior (uses simpler buffer-based matching).
+     */
+    sequenceTimeoutMs?: number;
+}
+type ShortcutConfig = KeyCombinationConfig | KeySequenceConfig;
+export interface ActiveShortcut {
+    id: string;
+    config: ShortcutConfig;
+    subscription: Subscription;
+}
+/**
+ * Manages keyboard shortcuts for web applications.
+ * Allows registration of single key combinations (e.g., Ctrl+S) and key sequences (e.g., g -> i).
+ * Supports contexts to enable/disable shortcuts based on application state.
+ */
+export declare class Hotkeys {
+    private static readonly KEYDOWN_EVENT;
+    private static readonly LOG_PREFIX;
+    private keydown$;
+    private activeContext$;
+    private activeShortcuts;
+    private debugMode;
+    /**
+     * Creates an instance of Hotkeys.
+     * @param initialContext - Optional initial context name. Shortcuts will only trigger if their context matches this, or if they have no context defined.
+     * @param debugMode - Optional. If true, debug messages will be logged to the console. Defaults to false.
+     * @throws Error if not in a browser environment (i.e., `document` or `performance` is undefined).
+     */
+    constructor(initialContext?: string | null, debugMode?: boolean);
+    /**
+     * Sets the active context for shortcuts.
+     * Only shortcuts matching this context (or shortcuts with no specific context defined)
+     * will be active and can be triggered.
+     * @param contextName - The name of the context (e.g., "modal", "editor", "global").
+     * Pass `null` to activate shortcuts with no context or to deactivate context-specific shortcuts.
+     * @returns `true` if the context was changed, `false` if the new context was the same as the current one.
+     */
+    setContext(contextName: string | null): boolean;
+    /**
+     * Gets the current active context.
+     * @returns The current context name as a string, or `null` if no context is set.
+     */
+    getContext(): string | null;
+    /**
+     * Enables or disables debug logging for the Hotkeys instance.
+     * When enabled, various internal actions and shortcut triggers will be logged to the console.
+     * @param enable - True to enable debug logs, false to disable.
+     */
+    setDebugMode(enable: boolean): void;
+    /**
+     * Checks if a shortcut with the given ID is currently registered and active.
+     * @param id - The unique ID of the shortcut to check.
+     * @returns True if a shortcut with the specified ID exists, false otherwise.
+     */
+    hasShortcut(id: string): boolean;
+    /**
+     * An Observable that emits the new context name (or null) whenever the active context changes.
+     */
+    get onContextChange$(): Observable<string | null>;
+    private _areSequencesIdentical;
+    private _shortcutMatchesEvent;
+    private filterByContext;
+    private _registerShortcut;
+    private _parseKeyTrigger;
+    /**
+     * Registers a key combination shortcut.
+     * @param config - Configuration object for the key combination.
+     * @param strict - If `true` and the shortcut has no context, it will only fire when no context is active. Defaults to `false`.
+     * @returns The ID of the registered shortcut, or `undefined` if invalid.
+     */
+    addCombination(config: KeyCombinationConfig, strict?: boolean): string | undefined;
+    /**
+     * Registers a key sequence shortcut.
+     * @param config - Configuration object for the key sequence.
+     * @param strict - If `true` and the shortcut has no context, it will only fire when no context is active. Defaults to `false`.
+     * @returns The ID of the registered shortcut, or `undefined` if invalid.
+     */
+    addSequence(config: KeySequenceConfig, strict?: boolean): string | undefined;
+    /**
+     * Removes a registered shortcut by its ID.
+     */
+    remove(id: string): boolean;
+    /**
+     * Retrieves a list of all currently active (registered) shortcut configurations.
+     */
+    getActiveShortcuts(): {
+        id: string;
+        description?: string;
+        context?: string | null;
+        type: ShortcutTypes;
+    }[];
+    /**
+     * Cleans up all active subscriptions and resources used by the Hotkeys instance.
+     */
+    destroy(): void;
+}
+export {};
+//# sourceMappingURL=ttt.d.ts.map

package/dist/ttt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ttt.d.ts","sourceRoot":"","sources":["../src/ttt.ts"],"names":[],"mappings":"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"}