npm - rx-hotkeys - Versions diffs - 1.0.0 - Mend

rx-hotkeys 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/README.md +205 -0
package/dist/hotkeys.d.ts +163 -0
package/dist/hotkeys.d.ts.map +1 -0
package/dist/hotkeys.js +321 -0
package/dist/hotkeys.test.d.ts +2 -0
package/dist/hotkeys.test.d.ts.map +1 -0
package/dist/hotkeys.test.js +360 -0
package/dist/index.d.ts +3 -0
package/dist/index.d.ts.map +1 -0
package/dist/index.js +2 -0
package/dist/keys.d.ts +155 -0
package/dist/keys.d.ts.map +1 -0
package/dist/keys.js +117 -0
package/dist/testutils.d.ts +14 -0
package/dist/testutils.d.ts.map +1 -0
package/dist/testutils.js +31 -0
package/package.json +39 -0

package/dist/hotkeys.test.js ADDED Viewed

@@ -0,0 +1,360 @@
+import { describe, it, before, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+// Importing main library components
+import { HotKeys } from "./hotkeys.js";
+// Importing Keys and StandardKey from the separate keys.js file
+import { Keys } from "./keys.js";
+import { fromEvent, BehaviorSubject } from "rxjs";
+import { createMockFn, dispatchKeyEvent } from "./testutils.js";
+import { JSDOM } from "jsdom";
+// --- JSDOM and RxJS setup for Node.js tests ---
+let dom;
+let window;
+let document;
+let originalPerformanceNow;
+before(() => {
+    dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
+        url: "http://localhost",
+    });
+    window = dom.window;
+    document = window.document;
+    // @ts-ignore
+    global.document = document;
+    // @ts-ignore
+    global.KeyboardEvent = window.KeyboardEvent;
+    // @ts-ignore
+    global.BehaviorSubject = BehaviorSubject;
+    // @ts-ignore
+    global.fromEvent = fromEvent;
+    // @ts-ignore
+    if (typeof global.performance === 'undefined') {
+        // @ts-ignore
+        global.performance = {};
+    }
+    // @ts-ignore
+    originalPerformanceNow = global.performance.now;
+    // @ts-ignore
+    if (typeof global.performance.now !== 'function') {
+        // @ts-ignore
+        global.performance.now = (() => {
+            const start = Date.now();
+            return () => Date.now() - start;
+        })();
+    }
+});
+describe("Hotkeys Library (Node.js Test Runner)", () => {
+    let keyManager;
+    let mockCallback;
+    let consoleWarnMock;
+    let consoleErrorMock;
+    let performanceNowMock; // To mock global.performance.now specifically for sequence tests
+    beforeEach(() => {
+        keyManager = new HotKeys(null, false);
+        mockCallback = createMockFn();
+        consoleWarnMock = mock.method(console, "warn");
+        consoleErrorMock = mock.method(console, "error");
+    });
+    afterEach(() => {
+        if (keyManager) {
+            keyManager.destroy();
+        }
+        mockCallback.mockClear();
+        mock.reset();
+        if (consoleWarnMock && consoleWarnMock.mock)
+            consoleWarnMock.mock.restore();
+        if (consoleErrorMock && consoleErrorMock.mock)
+            consoleErrorMock.mock.restore();
+        // @ts-ignore
+        if (global.performance && global.performance.now !== originalPerformanceNow) {
+            // @ts-ignore
+            global.performance.now = originalPerformanceNow;
+        }
+    });
+    describe("Initialization and Basic Context", () => {
+        it("should initialize without errors", () => {
+            assert(keyManager instanceof HotKeys);
+        });
+        it("should initialize with a null context by default", () => {
+            assert.strictEqual(keyManager.getContext(), null);
+        });
+        it("should initialize with a given initial context", () => {
+            const manager = new HotKeys("editor");
+            assert.strictEqual(manager.getContext(), "editor");
+            manager.destroy();
+        });
+        it("should set and get context", () => {
+            keyManager.setContext("modal");
+            assert.strictEqual(keyManager.getContext(), "modal");
+            keyManager.setContext(null);
+            assert.strictEqual(keyManager.getContext(), null);
+        });
+        it("should toggle debug mode and log appropriately", () => {
+            const consoleLogMock = mock.method(console, "log");
+            keyManager.setDebugMode(true);
+            keyManager.setContext("debug_test");
+            assert.ok(consoleLogMock.mock.calls.some(call => call.arguments[0].includes('Context changed to "debug_test"')));
+            consoleLogMock.mock.resetCalls();
+            keyManager.setDebugMode(false);
+            keyManager.setContext("no_debug_test");
+            assert.ok(!consoleLogMock.mock.calls.some(call => call.arguments[0].includes('Context changed to "no_debug_test"')));
+            consoleLogMock.mock.restore();
+        });
+    });
+    describe("addCombination", () => {
+        it("should trigger callback for a simple key combination (e.g., 'A')", () => {
+            const config = { id: "simpleA", keys: { key: Keys.A }, callback: mockCallback };
+            const result = keyManager.addCombination(config);
+            assert.strictEqual(result, "simpleA");
+            dispatchKeyEvent("a");
+            assert.strictEqual(mockCallback.calledCount, 1, "Callback for 'a' not called");
+            mockCallback.mockClear();
+            dispatchKeyEvent("A");
+            assert.strictEqual(mockCallback.calledCount, 1, "Callback for 'A' not called");
+        });
+        it("should return undefined and warn if keys.key is null or undefined (runtime check)", () => {
+            // This test checks runtime robustness if `any` is used to bypass StandardKey
+            const config = { id: "nullKey", keys: { key: null }, callback: mockCallback };
+            const result = keyManager.addCombination(config);
+            assert.strictEqual(result, undefined, "Should return undefined for null key");
+            assert.strictEqual(consoleWarnMock.mock.calls.length, 1);
+            assert.ok(consoleWarnMock.mock.calls[0].arguments[0].includes('Invalid \'keys.key\' for combination shortcut "nullKey"'));
+        });
+        it("should pass the KeyboardEvent to the callback", () => {
+            const config = { id: "eventPass", keys: { key: Keys.E }, callback: mockCallback };
+            keyManager.addCombination(config);
+            const event = dispatchKeyEvent("e");
+            assert.strictEqual(mockCallback.calledCount, 1);
+            assert.deepStrictEqual(mockCallback.lastArgs, [event]);
+        });
+        it("should trigger callback for a combination with Ctrl key", () => {
+            const config = { id: "ctrlS", keys: { key: Keys.S, ctrlKey: true }, callback: mockCallback };
+            keyManager.addCombination(config);
+            dispatchKeyEvent("s", { ctrlKey: true });
+            assert.strictEqual(mockCallback.calledCount, 1);
+        });
+        it("should NOT trigger callback if specified modifier key (ctrlKey: false) is false and event has it true", () => {
+            const config = { id: "noCtrlA", keys: { key: Keys.A, ctrlKey: false }, callback: mockCallback };
+            keyManager.addCombination(config);
+            dispatchKeyEvent("a", { ctrlKey: true });
+            assert.strictEqual(mockCallback.calledCount, 0);
+            dispatchKeyEvent("a", { ctrlKey: false });
+            assert.strictEqual(mockCallback.calledCount, 1);
+        });
+        it("should trigger for special keys like Escape", () => {
+            const config = { id: "escapeKey", keys: { key: Keys.Escape }, callback: mockCallback };
+            keyManager.addCombination(config);
+            dispatchKeyEvent("Escape"); // Event key matches Keys.Escape
+            assert.strictEqual(mockCallback.calledCount, 1);
+        });
+        it("should handle preventDefault correctly", () => {
+            const config = { id: "preventA", keys: { key: Keys.A }, callback: mockCallback, preventDefault: true };
+            keyManager.addCombination(config);
+            const event = dispatchKeyEvent("a");
+            assert.strictEqual(mockCallback.calledCount, 1);
+            assert.strictEqual(event.defaultPrevented, true);
+        });
+        it("should overwrite an existing combination with the same ID and warn", () => {
+            const firstCallback = createMockFn();
+            const secondCallback = createMockFn();
+            keyManager.addCombination({ id: "combo1", keys: { key: Keys.K }, callback: firstCallback });
+            consoleWarnMock.mock.resetCalls();
+            keyManager.addCombination({ id: "combo1", keys: { key: Keys.K, ctrlKey: true }, callback: secondCallback });
+            assert.strictEqual(consoleWarnMock.mock.calls.length, 1);
+            assert.ok(consoleWarnMock.mock.calls[0].arguments[0].includes(`Shortcut with ID "combo1" already exists`));
+            dispatchKeyEvent("k");
+            assert.strictEqual(firstCallback.calledCount, 0);
+            dispatchKeyEvent("k", { ctrlKey: true });
+            assert.strictEqual(secondCallback.calledCount, 1);
+        });
+        it("should log an error via console.error if callback throws, and not affect other shortcuts", () => {
+            const errorCallback = () => { throw new Error("Test callback error"); };
+            const workingCallback = createMockFn();
+            keyManager.addCombination({ id: "errorCombo", keys: { key: Keys.E }, callback: errorCallback });
+            keyManager.addCombination({ id: "workingCombo", keys: { key: Keys.W }, callback: workingCallback });
+            dispatchKeyEvent("e");
+            assert.strictEqual(consoleErrorMock.mock.calls.length, 1);
+            assert.ok(consoleErrorMock.mock.calls[0].arguments[0].includes('Error in user callback for combination shortcut "errorCombo"'));
+            dispatchKeyEvent("w");
+            assert.strictEqual(workingCallback.calledCount, 1);
+        });
+    });
+    describe("addSequence", () => {
+        it("should trigger callback for a simple key sequence", () => {
+            const config = { id: "seqGI", sequence: [Keys.G, Keys.I], callback: mockCallback };
+            const result = keyManager.addSequence(config);
+            assert.strictEqual(result, "seqGI");
+            dispatchKeyEvent("g"); // Dispatch 'g' (lowercase)
+            dispatchKeyEvent("i"); // Dispatch 'i' (lowercase)
+            assert.strictEqual(mockCallback.calledCount, 1);
+        });
+        it("should trigger callback for Konami code using Keys", () => {
+            const konamiSequence = [
+                Keys.ArrowUp, Keys.ArrowUp, Keys.ArrowDown, Keys.ArrowDown,
+                Keys.ArrowLeft, Keys.ArrowRight, Keys.ArrowLeft, Keys.ArrowRight,
+                Keys.B, Keys.A // Using 'B' and 'A' from Keys
+            ];
+            const config = { id: "konami", sequence: konamiSequence, callback: mockCallback };
+            keyManager.addSequence(config);
+            // Dispatch events using the string values that browser events would produce
+            ["ArrowUp", "ArrowUp", "ArrowDown", "ArrowDown", "ArrowLeft", "ArrowRight", "ArrowLeft", "ArrowRight", "b", "a"].forEach(key => dispatchKeyEvent(key));
+            assert.strictEqual(mockCallback.calledCount, 1, "Konami sequence callback not triggered");
+        });
+        it("should return undefined and warn if sequence is empty", () => {
+            const config = { id: "emptySeq", sequence: [], callback: mockCallback };
+            const result = keyManager.addSequence(config);
+            assert.strictEqual(result, undefined);
+            assert.strictEqual(consoleWarnMock.mock.calls.length, 1);
+            assert.ok(consoleWarnMock.mock.calls[0].arguments[0].includes(`Sequence for shortcut "emptySeq" is empty`));
+        });
+        it("should return undefined and warn if sequence contains an invalid key (runtime check with 'as any')", () => {
+            // This test checks runtime robustness if `any` is used to bypass StandardKey[]
+            const config = { id: "invalidKeyInSeq", sequence: [Keys.A, "", Keys.C], callback: mockCallback };
+            const result = keyManager.addSequence(config);
+            assert.strictEqual(result, undefined, "addSequence should return undefined for sequence with empty string");
+            assert.strictEqual(consoleWarnMock.mock.calls.length, 1, "console.warn was not called for invalid key in sequence");
+            assert.ok(consoleWarnMock.mock.calls[0].arguments[0].includes(`Invalid key in sequence for shortcut "invalidKeyInSeq"`));
+        });
+        it("should pass the last KeyboardEvent of the sequence to the callback", () => {
+            const config = { id: "seqEventPass", sequence: [Keys.X, Keys.Y], callback: mockCallback };
+            keyManager.addSequence(config);
+            dispatchKeyEvent("x");
+            const lastEvent = dispatchKeyEvent("y");
+            assert.strictEqual(mockCallback.calledCount, 1);
+            assert.deepStrictEqual(mockCallback.lastArgs, [lastEvent]);
+        });
+        it("should prevent default for the last key event in the sequence when preventDefault is true", () => {
+            const config = { id: "seqPrevent", sequence: [Keys.M, Keys.N], callback: mockCallback, preventDefault: true };
+            keyManager.addSequence(config);
+            dispatchKeyEvent("m");
+            const eventN = dispatchKeyEvent("n");
+            assert.strictEqual(mockCallback.calledCount, 1);
+            assert.strictEqual(eventN.defaultPrevented, true);
+        });
+        it("should log an error via console.error if sequence callback throws", () => {
+            const errorCallback = () => { throw new Error("Test sequence callback error"); };
+            keyManager.addSequence({ id: "errorSeq", sequence: [Keys.E, Keys.S], callback: errorCallback });
+            dispatchKeyEvent("e");
+            dispatchKeyEvent("s");
+            assert.strictEqual(consoleErrorMock.mock.calls.length, 1);
+            assert.ok(consoleErrorMock.mock.calls[0].arguments[0].includes('Error in user callback for sequence shortcut "errorSeq"'));
+        });
+        describe("Sequence Contextual Triggering", () => {
+            let editorSequenceConfig;
+            beforeEach(() => {
+                editorSequenceConfig = {
+                    id: "sequenceInEditor",
+                    sequence: [Keys.C, Keys.O, Keys.D, Keys.E],
+                    callback: mockCallback,
+                    context: "editor",
+                };
+            });
+            it("should trigger sequence in matching context", () => {
+                keyManager.addSequence(editorSequenceConfig);
+                keyManager.setContext("editor");
+                [Keys.C, Keys.O, Keys.D, Keys.E].forEach(k => dispatchKeyEvent(k));
+                assert.strictEqual(mockCallback.calledCount, 1);
+            });
+        });
+        describe("Sequence Timeouts", () => {
+            const TIMEOUT_MS = 100;
+            let originalPerformanceNowForSuite;
+            beforeEach(() => {
+                mock.timers.enable({ apis: ["Date", "setTimeout", "setInterval"], now: 0 });
+                // @ts-ignore
+                if (!originalPerformanceNowForSuite && global.performance && global.performance.now) {
+                    // @ts-ignore
+                    originalPerformanceNowForSuite = global.performance.now;
+                }
+                // @ts-ignore
+                performanceNowMock = mock.method(global.performance, "now", () => Date.now());
+            });
+            afterEach(() => {
+                if (performanceNowMock && performanceNowMock.mock) {
+                    performanceNowMock.mock.restore();
+                }
+                else if (originalPerformanceNowForSuite) {
+                    // @ts-ignore
+                    global.performance.now = originalPerformanceNowForSuite;
+                }
+                mock.timers.reset();
+            });
+            it("should trigger sequence if keys are pressed within specified timeout", () => {
+                const config = { id: "seqTimeoutOk", sequence: [Keys.T, Keys.O, Keys.K], callback: mockCallback, sequenceTimeoutMs: TIMEOUT_MS };
+                keyManager.addSequence(config);
+                dispatchKeyEvent(Keys.T);
+                mock.timers.tick(TIMEOUT_MS / 2);
+                dispatchKeyEvent(Keys.O);
+                mock.timers.tick(TIMEOUT_MS / 2);
+                const lastEvent = dispatchKeyEvent(Keys.K);
+                assert.strictEqual(mockCallback.calledCount, 1);
+                assert.deepStrictEqual(mockCallback.lastArgs, [lastEvent]);
+            });
+            it("should NOT trigger sequence if a key press is delayed beyond timeout", () => {
+                const config = { id: "seqTimeoutFail", sequence: [Keys.D, Keys.E, Keys.L], callback: mockCallback, sequenceTimeoutMs: TIMEOUT_MS };
+                keyManager.addSequence(config);
+                dispatchKeyEvent(Keys.D);
+                mock.timers.tick(TIMEOUT_MS / 2);
+                dispatchKeyEvent(Keys.E);
+                mock.timers.tick(TIMEOUT_MS + 1);
+                dispatchKeyEvent(Keys.L);
+                assert.strictEqual(mockCallback.calledCount, 0);
+            });
+        });
+    });
+    describe("remove", () => {
+        it("should remove a combination shortcut", () => {
+            keyManager.addCombination({ id: "remA", keys: { key: Keys.A }, callback: mockCallback });
+            assert.strictEqual(keyManager.remove("remA"), true);
+            dispatchKeyEvent(Keys.A);
+            assert.strictEqual(mockCallback.calledCount, 0);
+        });
+        it("should remove a sequence shortcut", () => {
+            keyManager.addSequence({ id: "remSeq", sequence: [Keys.A, Keys.B], callback: mockCallback });
+            assert.strictEqual(keyManager.remove("remSeq"), true);
+            dispatchKeyEvent(Keys.A);
+            dispatchKeyEvent(Keys.B);
+            assert.strictEqual(mockCallback.calledCount, 0);
+        });
+    });
+    describe("getActiveShortcuts", () => {
+        it("should return active combination and sequence shortcuts", () => {
+            keyManager.addCombination({ id: "combo1", keys: { key: Keys.A }, callback: createMockFn(), description: "Test A" });
+            keyManager.addSequence({ id: "seq1", sequence: [Keys.B, Keys.C], callback: createMockFn(), context: "modal", description: "Test BC" });
+            const active = keyManager.getActiveShortcuts();
+            assert.strictEqual(active.length, 2);
+            const combo = active.find(s => s.id === "combo1");
+            assert.ok(combo);
+            assert.strictEqual(combo.type, "combination");
+            const seq = active.find(s => s.id === "seq1");
+            assert.ok(seq);
+            assert.strictEqual(seq.type, "sequence");
+        });
+    });
+    describe("hasShortcut", () => {
+        it("should return true for an existing combination shortcut", () => {
+            keyManager.addCombination({ id: "existsCombo", keys: { key: Keys.E }, callback: mockCallback });
+            assert.strictEqual(keyManager.hasShortcut("existsCombo"), true);
+        });
+        it("should return false for a shortcut that failed to add (e.g. invalid key object)", () => {
+            // This test now relies on the runtime check for !keys.key, as TS would catch `key: null` directly.
+            const config = { id: "invalidKeyCombo", keys: { key: null }, callback: mockCallback };
+            keyManager.addCombination(config);
+            assert.strictEqual(keyManager.hasShortcut("invalidKeyCombo"), false);
+        });
+    });
+    describe("destroy", () => {
+        it("should clear active shortcuts and prevent further triggers", () => {
+            keyManager.addCombination({ id: "destroyTestCombo", keys: { key: Keys.D }, callback: mockCallback });
+            keyManager.addSequence({ id: "destroyTestSeq", sequence: [Keys.X, Keys.Y], callback: mockCallback });
+            // @ts-ignore
+            assert.strictEqual(keyManager['activeShortcuts'].size, 2);
+            keyManager.destroy();
+            // @ts-ignore
+            assert.strictEqual(keyManager['activeShortcuts'].size, 0);
+            dispatchKeyEvent(Keys.D);
+            dispatchKeyEvent(Keys.X);
+            dispatchKeyEvent(Keys.Y);
+            assert.strictEqual(mockCallback.calledCount, 0);
+        });
+    });
+});

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export { type StandardKey, Keys, } from "./keys.js";
+export { type KeyCombinationConfig, type KeySequenceConfig, HotKeys, } from "./hotkeys.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,WAAW,EAChB,IAAI,GACP,MAAM,WAAW,CAAC;AACnB,OAAO,EACH,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,OAAO,GACV,MAAM,cAAc,CAAC"}

package/dist/index.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { Keys, } from "./keys.js";
2	+ export { HotKeys, } from "./hotkeys.js";

package/dist/keys.d.ts ADDED Viewed

@@ -0,0 +1,155 @@
+/**
+ * Provides a set of common, standard string values for `KeyboardEvent.key`.
+ * Using these values can help avoid typos and ensure consistency.
+ * These are based on the MDN documentation:
+ * https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values
+ *
+ * All shortcut configurations should use values from this object.
+ */
+export declare const Keys: {
+    readonly Unidentified: "Unidentified";
+    readonly Alt: "Alt";
+    readonly AltGraph: "AltGraph";
+    readonly CapsLock: "CapsLock";
+    readonly Control: "Control";
+    readonly Fn: "Fn";
+    readonly FnLock: "FnLock";
+    readonly Hyper: "Hyper";
+    readonly Meta: "Meta";
+    readonly NumLock: "NumLock";
+    readonly ScrollLock: "ScrollLock";
+    readonly Shift: "Shift";
+    readonly Super: "Super";
+    readonly Symbol: "Symbol";
+    readonly SymbolLock: "SymbolLock";
+    readonly Enter: "Enter";
+    readonly Tab: "Tab";
+    readonly Space: " ";
+    readonly ArrowDown: "ArrowDown";
+    readonly ArrowLeft: "ArrowLeft";
+    readonly ArrowRight: "ArrowRight";
+    readonly ArrowUp: "ArrowUp";
+    readonly End: "End";
+    readonly Home: "Home";
+    readonly PageDown: "PageDown";
+    readonly PageUp: "PageUp";
+    readonly Backspace: "Backspace";
+    readonly Clear: "Clear";
+    readonly Copy: "Copy";
+    readonly CrSel: "CrSel";
+    readonly Cut: "Cut";
+    readonly Delete: "Delete";
+    readonly EraseEof: "EraseEof";
+    readonly ExSel: "ExSel";
+    readonly Insert: "Insert";
+    readonly Paste: "Paste";
+    readonly Redo: "Redo";
+    readonly Undo: "Undo";
+    readonly Accept: "Accept";
+    readonly Again: "Again";
+    readonly Attn: "Attn";
+    readonly Cancel: "Cancel";
+    readonly ContextMenu: "ContextMenu";
+    readonly Escape: "Escape";
+    readonly Execute: "Execute";
+    readonly Find: "Find";
+    readonly Finish: "Finish";
+    readonly Help: "Help";
+    readonly Pause: "Pause";
+    readonly Play: "Play";
+    readonly Props: "Props";
+    readonly Select: "Select";
+    readonly ZoomIn: "ZoomIn";
+    readonly ZoomOut: "ZoomOut";
+    readonly BrightnessDown: "BrightnessDown";
+    readonly BrightnessUp: "BrightnessUp";
+    readonly Eject: "Eject";
+    readonly LogOff: "LogOff";
+    readonly Power: "Power";
+    readonly PowerOff: "PowerOff";
+    readonly PrintScreen: "PrintScreen";
+    readonly Hibernate: "Hibernate";
+    readonly Standby: "Standby";
+    readonly WakeUp: "WakeUp";
+    readonly F1: "F1";
+    readonly F2: "F2";
+    readonly F3: "F3";
+    readonly F4: "F4";
+    readonly F5: "F5";
+    readonly F6: "F6";
+    readonly F7: "F7";
+    readonly F8: "F8";
+    readonly F9: "F9";
+    readonly F10: "F10";
+    readonly F11: "F11";
+    readonly F12: "F12";
+    readonly F13: "F13";
+    readonly F14: "F14";
+    readonly F15: "F15";
+    readonly F16: "F16";
+    readonly F17: "F17";
+    readonly F18: "F18";
+    readonly F19: "F19";
+    readonly F20: "F20";
+    readonly AppSwitch: "AppSwitch";
+    readonly Call: "Call";
+    readonly Camera: "Camera";
+    readonly EndCall: "EndCall";
+    readonly GoBack: "GoBack";
+    readonly GoHome: "GoHome";
+    readonly HeadsetHook: "HeadsetHook";
+    readonly MediaPlayPause: "MediaPlayPause";
+    readonly MediaStop: "MediaStop";
+    readonly MediaTrackNext: "MediaTrackNext";
+    readonly MediaTrackPrevious: "MediaTrackPrevious";
+    readonly AudioVolumeDown: "AudioVolumeDown";
+    readonly AudioVolumeUp: "AudioVolumeUp";
+    readonly AudioVolumeMute: "AudioVolumeMute";
+    readonly Decimal: ".";
+    readonly KeypadMultiply: "*";
+    readonly KeypadAdd: "+";
+    readonly KeypadSubtract: "-";
+    readonly KeypadDivide: "/";
+    readonly A: "A";
+    readonly B: "B";
+    readonly C: "C";
+    readonly D: "D";
+    readonly E: "E";
+    readonly F: "F";
+    readonly G: "G";
+    readonly H: "H";
+    readonly I: "I";
+    readonly J: "J";
+    readonly K: "K";
+    readonly L: "L";
+    readonly M: "M";
+    readonly N: "N";
+    readonly O: "O";
+    readonly P: "P";
+    readonly Q: "Q";
+    readonly R: "R";
+    readonly S: "S";
+    readonly T: "T";
+    readonly U: "U";
+    readonly V: "V";
+    readonly W: "W";
+    readonly X: "X";
+    readonly Y: "Y";
+    readonly Z: "Z";
+    readonly Digit0: "0";
+    readonly Digit1: "1";
+    readonly Digit2: "2";
+    readonly Digit3: "3";
+    readonly Digit4: "4";
+    readonly Digit5: "5";
+    readonly Digit6: "6";
+    readonly Digit7: "7";
+    readonly Digit8: "8";
+    readonly Digit9: "9";
+};
+/**
+ * Represents the set of allowed string literal values for keys, derived from the KeyValues object.
+ * This ensures type safety when configuring shortcuts.
+ */
+export type StandardKey = typeof Keys[keyof typeof Keys];
+//# sourceMappingURL=keys.d.ts.map

package/dist/keys.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyHP,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,IAAI,CAAC,MAAM,OAAO,IAAI,CAAC,CAAC"}

package/dist/keys.js ADDED Viewed

@@ -0,0 +1,117 @@
+/**
+ * Provides a set of common, standard string values for `KeyboardEvent.key`.
+ * Using these values can help avoid typos and ensure consistency.
+ * These are based on the MDN documentation:
+ * https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values
+ *
+ * All shortcut configurations should use values from this object.
+ */
+export const Keys = {
+    // Special Values
+    Unidentified: "Unidentified",
+    // Modifier Keys
+    Alt: "Alt",
+    AltGraph: "AltGraph",
+    CapsLock: "CapsLock",
+    Control: "Control",
+    Fn: "Fn",
+    FnLock: "FnLock",
+    Hyper: "Hyper",
+    Meta: "Meta", // Command key on Mac, Windows key on Windows
+    NumLock: "NumLock",
+    ScrollLock: "ScrollLock",
+    Shift: "Shift",
+    Super: "Super",
+    Symbol: "Symbol",
+    SymbolLock: "SymbolLock",
+    // Whitespace Keys
+    Enter: "Enter",
+    Tab: "Tab",
+    Space: " ", // Standard value for Space Bar
+    // Navigation Keys
+    ArrowDown: "ArrowDown",
+    ArrowLeft: "ArrowLeft",
+    ArrowRight: "ArrowRight",
+    ArrowUp: "ArrowUp",
+    End: "End",
+    Home: "Home",
+    PageDown: "PageDown",
+    PageUp: "PageUp",
+    // Editing Keys
+    Backspace: "Backspace",
+    Clear: "Clear",
+    Copy: "Copy",
+    CrSel: "CrSel", // Cursor Select
+    Cut: "Cut",
+    Delete: "Delete",
+    EraseEof: "EraseEof", // Erase to End of Field
+    ExSel: "ExSel", // Extend Selection
+    Insert: "Insert",
+    Paste: "Paste",
+    Redo: "Redo",
+    Undo: "Undo",
+    // UI Keys
+    Accept: "Accept",
+    Again: "Again",
+    Attn: "Attn", // Attention
+    Cancel: "Cancel",
+    ContextMenu: "ContextMenu", // Application key
+    Escape: "Escape",
+    Execute: "Execute",
+    Find: "Find",
+    Finish: "Finish",
+    Help: "Help",
+    Pause: "Pause",
+    Play: "Play",
+    Props: "Props", // Properties
+    Select: "Select",
+    ZoomIn: "ZoomIn",
+    ZoomOut: "ZoomOut",
+    // Device Keys
+    BrightnessDown: "BrightnessDown",
+    BrightnessUp: "BrightnessUp",
+    Eject: "Eject",
+    LogOff: "LogOff",
+    Power: "Power",
+    PowerOff: "PowerOff",
+    PrintScreen: "PrintScreen",
+    Hibernate: "Hibernate",
+    Standby: "Standby", // Suspend or Sleep
+    WakeUp: "WakeUp",
+    // Function Keys
+    F1: "F1", F2: "F2", F3: "F3", F4: "F4",
+    F5: "F5", F6: "F6", F7: "F7", F8: "F8",
+    F9: "F9", F10: "F10", F11: "F11", F12: "F12",
+    F13: "F13", F14: "F14", F15: "F15", F16: "F16",
+    F17: "F17", F18: "F18", F19: "F19", F20: "F20",
+    // Phone Keys (selection)
+    AppSwitch: "AppSwitch",
+    Call: "Call",
+    Camera: "Camera",
+    EndCall: "EndCall",
+    GoBack: "GoBack",
+    GoHome: "GoHome",
+    HeadsetHook: "HeadsetHook",
+    // Multimedia Keys (selection)
+    MediaPlayPause: "MediaPlayPause",
+    MediaStop: "MediaStop",
+    MediaTrackNext: "MediaTrackNext",
+    MediaTrackPrevious: "MediaTrackPrevious",
+    AudioVolumeDown: "AudioVolumeDown",
+    AudioVolumeUp: "AudioVolumeUp",
+    AudioVolumeMute: "AudioVolumeMute",
+    // Numeric Keypad (special characters, numbers 0-9 are via KeyValues.DigitN)
+    Decimal: ".", // This is the character for the decimal point
+    KeypadMultiply: "*",
+    KeypadAdd: "+",
+    KeypadSubtract: "-",
+    KeypadDivide: "/",
+    // Character Keys (Uppercase A-Z for configuration via KeyValues)
+    // The library handles case-insensitivity for these when matching browser events.
+    A: "A", B: "B", C: "C", D: "D", E: "E", F: "F", G: "G", H: "H", I: "I",
+    J: "J", K: "K", L: "L", M: "M", N: "N", O: "O", P: "P", Q: "Q", R: "R",
+    S: "S", T: "T", U: "U", V: "V", W: "W", X: "X", Y: "Y", Z: "Z",
+    // Digit Keys (0-9 for configuration via KeyValues)
+    Digit0: "0", Digit1: "1", Digit2: "2", Digit3: "3", Digit4: "4",
+    Digit5: "5", Digit6: "6", Digit7: "7", Digit8: "8", Digit9: "9",
+};

package/dist/testutils.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+export declare function createMockFn(): {
+    (...args: any[]): void;
+    calledCount: number;
+    calls: any[];
+    lastArgs: any[];
+    mockClear(): void;
+};
+/**
+ * Dispatches a KeyboardEvent to the document (JSDOM).
+ * @param key - The key value, e.g., "a", "Escape", "ArrowUp"
+ * @param modifiers - Optional modifier keys
+ */
+export declare function dispatchKeyEvent(key: string, modifiers?: Partial<KeyboardEventInit>): KeyboardEvent;
+//# sourceMappingURL=testutils.d.ts.map

package/dist/testutils.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"testutils.d.ts","sourceRoot":"","sources":["../src/testutils.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY;cACH,GAAG,EAAE;;;;;EAc7B;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC5B,GAAG,EAAE,MAAM,EACX,SAAS,GAAE,OAAO,CAAC,iBAAiB,CAAM,GAC3C,aAAa,CASf"}