rx-hotkeys 2.1.1 → 2.2.1

package/dist/hotkeys.d.ts

@@ -1,3 +1,4 @@
+import { Observable } from "rxjs";
 import { StandardKey } from "./keys.js";
 export declare enum ShortcutTypes {
     Combination = "combination",
@@ -96,6 +97,25 @@ export declare class Hotkeys {
      * @param enable - True to enable debug logs, false to disable.
      */
     setDebugMode(enable: boolean): void;
+    /**
+     * An Observable that emits the new context name (or null) whenever the active context changes.
+     * This allows external parts of the application to react to context transitions.
+     *
+     * Note: This observable benefits from the distinct check within the `setContext` method,
+     * meaning it will only emit when the context value actually changes.
+     *
+     * @example
+     * ```typescript
+     * const hotkeys = new Hotkeys();
+     * const subscription = hotkeys.onContextChange$.subscribe(newContext => {
+     * console.log("Hotkey context changed to:", newContext);
+     * // Update UI or perform other actions
+     * });
+     * // To unsubscribe when no longer needed:
+     * // subscription.unsubscribe();
+     * ```
+     */
+    get onContextChange$(): Observable<string | null>;
     /**
      * Checks if a shortcut with the given ID is currently registered and active.
      * @param id - The unique ID of the shortcut to check.

package/dist/hotkeys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hotkeys.d.ts","sourceRoot":"","sources":["../src/hotkeys.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAIxC,oBAAY,aAAa;IACrB,WAAW,gBAAgB;IAC3B,QAAQ,aAAa;CACxB;AAED,UAAU,kBAAkB;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;IAC1C,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC5D;;;;;;;;;;OAUG;IACH,IAAI,EAAE;QACF;;;;;;;;;WASG;QACH,GAAG,EAAE,WAAW,CAAC;QACjB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,OAAO,CAAC,EAAE,OAAO,CAAC;KACrB,GAAG,WAAW,CAAC;CACnB;AAED,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;IACzD;;;;;;;;OAQG;IACH,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAyCD;;;;GAIG;AACH,qBAAa,OAAO;IAChB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAa;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAc;IAEhD,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,cAAc,CAAiC;IACvD,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,SAAS,CAAU;IAE3B;;;;;OAKG;gBACS,cAAc,GAAE,MAAM,GAAG,IAAW,EAAE,SAAS,GAAE,OAAe;IAe5E;;;;;;OAMG;IACI,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAOnD;;;OAGG;IACI,UAAU,IAAI,MAAM,GAAG,IAAI;IAIlC;;;;OAIG;IACI,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAO1C;;;;OAIG;IACI,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIvC,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,iBAAiB;IAkBzB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,MAAM,GAAG,SAAS;IA6EvE;;;;;;;;;;;;;;;;;;;OAmBG;IACI,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,GAAG,SAAS;IAiHjE;;;;;;OAMG;IACI,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAYlC;;;;;;OAMG;IACI,kBAAkB,IAAI;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,EAAE,aAAa,CAAA;KAAC,EAAE;IAa/G;;;;;OAKG;IACI,OAAO,IAAI,IAAI;CAOzB"}
+{"version":3,"file":"hotkeys.d.ts","sourceRoot":"","sources":["../src/hotkeys.ts"],"names":[],"mappings":"AAAA,OAAO,EACuC,UAAU,EAEvD,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAIxC,oBAAY,aAAa;IACrB,WAAW,gBAAgB;IAC3B,QAAQ,aAAa;CACxB;AAED,UAAU,kBAAkB;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;IAC1C,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC5D;;;;;;;;;;OAUG;IACH,IAAI,EAAE;QACF;;;;;;;;;WASG;QACH,GAAG,EAAE,WAAW,CAAC;QACjB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,OAAO,CAAC,EAAE,OAAO,CAAC;KACrB,GAAG,WAAW,CAAC;CACnB;AAED,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;IACzD;;;;;;;;OAQG;IACH,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAyCD;;;;GAIG;AACH,qBAAa,OAAO;IAChB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAa;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAc;IAEhD,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,cAAc,CAAiC;IACvD,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,SAAS,CAAU;IAE3B;;;;;OAKG;gBACS,cAAc,GAAE,MAAM,GAAG,IAAW,EAAE,SAAS,GAAE,OAAe;IAe5E;;;;;;OAMG;IACI,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAiBnD;;;OAGG;IACI,UAAU,IAAI,MAAM,GAAG,IAAI;IAIlC;;;;OAIG;IACI,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAa1C;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAW,gBAAgB,IAAI,UAAU,CAAC,MAAM,GAAG,IAAI,CAAC,CAEvD;IAED;;;;OAIG;IACI,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIvC,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,iBAAiB;IAkBzB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,MAAM,GAAG,SAAS;IAgFvE;;;;;;;;;;;;;;;;;;;OAmBG;IACI,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,GAAG,SAAS;IAkHjE;;;;;;OAMG;IACI,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAYlC;;;;;;OAMG;IACI,kBAAkB,IAAI;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,EAAE,aAAa,CAAA;KAAC,EAAE;IAa/G;;;;;OAKG;IACI,OAAO,IAAI,IAAI;CAOzB"}

package/dist/hotkeys.js

@@ -65,8 +65,17 @@ export class Hotkeys {
      * Pass `null` to activate shortcuts with no context or to deactivate context-specific shortcuts.
      */
     setContext(contextName) {
+        if (this.activeContext$.getValue() === contextName) {
+            if (this.debugMode) {
+                // Optional: Log that no change is happening, or simply do nothing.
+                console.log(`${Hotkeys.LOG_PREFIX} setContext called with the same context "${contextName}". No change made.`);
+            }
+            return; // Context is the same, so no further action is needed.
+        }
+        // If we reach here, the context is actually changing.
+        const oldContext = this.activeContext$.getValue(); // For more informative logging
         if (this.debugMode) {
-            console.log(`${Hotkeys.LOG_PREFIX} Context changed to "${contextName}"`);
+            console.log(`${Hotkeys.LOG_PREFIX} Context changed from "${oldContext}" to "${contextName}".`);
         }
         this.activeContext$.next(contextName);
     }
@@ -83,11 +92,38 @@ export class Hotkeys {
      * @param enable - True to enable debug logs, false to disable.
      */
     setDebugMode(enable) {
-        this.debugMode = enable;
-        if (this.debugMode) {
-            console.log(`${Hotkeys.LOG_PREFIX} Debug mode ${enable ? "enabled" : "disabled"}.`);
+        if (this.debugMode === enable) { // Check if state is actually changing
+            return; // If no change, do nothing (no log)
+        }
+        this.debugMode = enable; // Set the new state
+        if (enable) { // Log based on the NEW state after a change
+            console.log(`${Hotkeys.LOG_PREFIX} Debug mode enabled.`);
+        }
+        else {
+            console.log(`${Hotkeys.LOG_PREFIX} Debug mode disabled.`);
         }
     }
+    /**
+     * An Observable that emits the new context name (or null) whenever the active context changes.
+     * This allows external parts of the application to react to context transitions.
+     *
+     * Note: This observable benefits from the distinct check within the `setContext` method,
+     * meaning it will only emit when the context value actually changes.
+     *
+     * @example
+     * ```typescript
+     * const hotkeys = new Hotkeys();
+     * const subscription = hotkeys.onContextChange$.subscribe(newContext => {
+     * console.log("Hotkey context changed to:", newContext);
+     * // Update UI or perform other actions
+     * });
+     * // To unsubscribe when no longer needed:
+     * // subscription.unsubscribe();
+     * ```
+     */
+    get onContextChange$() {
+        return this.activeContext$.asObservable();
+    }
     /**
      * Checks if a shortcut with the given ID is currently registered and active.
      * @param id - The unique ID of the shortcut to check.
@@ -148,8 +184,9 @@ export class Hotkeys {
         let keyDetailsForLog;
         if (typeof keys === "string") {
             // Shorthand: keys is StandardKey, implying no modifiers should be active
-            if (keys.trim() === "") {
-                console.warn(`${Hotkeys.LOG_PREFIX} Invalid "keys" (shorthand) for combination shortcut "${id}". Key string must not be empty. Shortcut not added.`);
+            // Corrected validation: Check for actual empty string, not a string that trims to empty.
+            if (keys === "") { // StandardKey type should prevent this, but check for robustness.
+                console.warn(`${Hotkeys.LOG_PREFIX} Invalid "keys" (shorthand) for combination shortcut "${id}". Key must not be an empty string. Shortcut not added.`);
                 return undefined;
             }
             configuredMainKey = keys;
@@ -161,8 +198,9 @@ export class Hotkeys {
         }
         else {
             // Object form
-            if (!keys || !keys.key || typeof keys.key !== "string" || keys.key.trim() === "") {
-                console.warn(`${Hotkeys.LOG_PREFIX} Invalid "keys.key" for combination shortcut "${id}". Key must be a non-empty value from Keys. Shortcut not added.`);
+            // Corrected validation for keys.key
+            if (!keys || !keys.key || typeof keys.key !== "string" || keys.key === "") { // StandardKey type should prevent empty string for key.key
+                console.warn(`${Hotkeys.LOG_PREFIX} Invalid "keys.key" for combination shortcut "${id}". Key must be a non-empty string value from Keys. Shortcut not added.`);
                 return undefined;
             }
             configuredMainKey = keys.key;
@@ -234,8 +272,9 @@ export class Hotkeys {
             console.warn(`${Hotkeys.LOG_PREFIX} Sequence for shortcut "${id}" is empty or invalid. Shortcut not added.`);
             return undefined;
         }
-        if (sequence.some(key => typeof key !== "string" || key.trim() === "")) {
-            console.warn(`${Hotkeys.LOG_PREFIX} Invalid key in sequence for shortcut "${id}". All keys must be non-empty strings from Keys. Shortcut not added.`);
+        // Corrected validation: Check for actual empty string, not a string that trims to empty.
+        if (sequence.some(key => typeof key !== "string" || key === "")) { // StandardKey type should prevent empty strings.
+            console.warn(`${Hotkeys.LOG_PREFIX} Invalid key in sequence for shortcut "${id}". All keys must be non-empty string values from Keys. Shortcut not added.`);
             return undefined;
         }
         const configuredSequence = sequence;

package/dist/hotkeys.test.js

@@ -69,35 +69,134 @@ describe("Hotkeys Library (Node.js Test Runner)", () => {
         }
     });
     // ... (Initialization and Basic Context tests remain the same) ...
-    describe("Initialization and Basic Context", () => {
+    describe("Initialization and Context Management", () => {
         it("should initialize without errors", () => {
             assert(keyManager instanceof Hotkeys);
+            assert.strictEqual(keyManager.getContext(), null); // Default initial context
         });
         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");
+        it("should initialize with a given initial context (debug off)", () => {
+            const manager = new Hotkeys("editor", false);
             assert.strictEqual(manager.getContext(), "editor");
             manager.destroy();
         });
-        it("should set and get context", () => {
+        it("should log library initialization with context in debug mode", () => {
+            const consoleLogMock = mock.method(console, "log");
+            const manager = new Hotkeys("debugInitCtx", true);
+            const initLog = consoleLogMock.mock.calls.find(call => call.arguments[0].includes(`Library initialized. Initial context: "debugInitCtx"`));
+            assert.ok(initLog, "Library initialization log not found or incorrect.");
+            manager.destroy();
+            consoleLogMock.mock.restore();
+        });
+        it("should set and get context correctly", () => {
             keyManager.setContext("modal");
             assert.strictEqual(keyManager.getContext(), "modal");
             keyManager.setContext(null);
             assert.strictEqual(keyManager.getContext(), null);
         });
-        it("should toggle debug mode and log appropriately", () => {
+        it("should log context change correctly when context is different (debug mode on)", () => {
             const consoleLogMock = mock.method(console, "log");
             keyManager.setDebugMode(true);
+            // Initial context is null for keyManager
+            consoleLogMock.mock.resetCalls(); // Clear "Debug mode enabled" log
             keyManager.setContext("debug_test");
-            assert.ok(consoleLogMock.mock.calls.some(call => call.arguments[0].includes(`Context changed to "debug_test"`)));
+            assert.ok(consoleLogMock.mock.calls.some(call => call.arguments[0].includes(`Context changed from "null" to "debug_test"`)), "Log for context change from null incorrect.");
+            assert.strictEqual(keyManager.getContext(), "debug_test");
+            consoleLogMock.mock.resetCalls();
+            keyManager.setContext("another_test");
+            assert.ok(consoleLogMock.mock.calls.some(call => call.arguments[0].includes(`Context changed from "debug_test" to "another_test"`)), "Log for context change between non-null incorrect.");
+            assert.strictEqual(keyManager.getContext(), "another_test");
+            consoleLogMock.mock.restore();
+        });
+        it("should log context change from non-null to null (debug mode on)", () => {
+            const consoleLogMock = mock.method(console, "log");
+            keyManager.setContext("fromCtx"); // Initial context
+            keyManager.setDebugMode(true);
+            consoleLogMock.mock.resetCalls();
+            keyManager.setContext(null);
+            const logCall = consoleLogMock.mock.calls.find(call => call.arguments[0].includes(`Context changed from "fromCtx" to "null"`));
+            assert.ok(logCall, "Context change to null log not found or incorrect.");
+            assert.strictEqual(keyManager.getContext(), null);
+            consoleLogMock.mock.restore();
+        });
+        it(`should not call activeContext$.next and log "no change" if context is set to the same value (debug mode on)`, () => {
+            keyManager.setContext("sameCtx"); // Set initial context
+            const consoleLogMock = mock.method(console, "log");
+            keyManager.setDebugMode(true); // Enable debug for this test
+            consoleLogMock.mock.resetCalls(); // Clear "Debug mode enabled" log
+            // @ts-ignore: Accessing private member for test
+            const activeContextNextSpy = mock.method(keyManager["activeContext$"], "next");
+            keyManager.setContext("sameCtx"); // Attempt to set the same context
+            const noChangeLogCall = consoleLogMock.mock.calls.find(call => call.arguments[0].includes(`setContext called with the same context "sameCtx". No change made.`));
+            assert.ok(noChangeLogCall, "No-change log not found or incorrect for same context.");
+            const changedLogCall = consoleLogMock.mock.calls.find(call => call.arguments[0].includes(`Context changed from`));
+            assert.strictEqual(changedLogCall, undefined, "Context changed log should not appear for same context.");
+            assert.strictEqual(keyManager.getContext(), "sameCtx");
+            assert.strictEqual(activeContextNextSpy.mock.callCount(), 0, "activeContext$.next should not have been called.");
+            activeContextNextSpy.mock.restore();
+            consoleLogMock.mock.restore();
+        });
+        it("should not log or call next if context is set to the same value (debug mode off)", () => {
+            keyManager.setContext("sameCtxNoDebug"); // Set initial context
+            keyManager.setDebugMode(false);
+            // Ensure debug is off
+            const consoleLogMock = mock.method(console, "log");
+            // @ts-ignore: Accessing private member for test
+            const activeContextNextSpy = mock.method(keyManager["activeContext$"], "next");
+            keyManager.setContext("sameCtxNoDebug"); // Attempt to set the same context
+            assert.strictEqual(consoleLogMock.mock.callCount(), 0, "Console.log should not have been called with debug mode off.");
+            assert.strictEqual(activeContextNextSpy.mock.callCount(), 0, "activeContext$.next should not have been called.");
+            assert.strictEqual(keyManager.getContext(), "sameCtxNoDebug");
+            activeContextNextSpy.mock.restore();
+            consoleLogMock.mock.restore();
+        });
+        it("should toggle debug mode and log its state", () => {
+            const consoleLogMock = mock.method(console, "log");
+            keyManager.setDebugMode(true);
+            assert.ok(consoleLogMock.mock.calls.some(call => call.arguments[0].includes("Debug mode enabled")));
             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"`)));
+            console.log(">>>>>>>>>>>>>>>>>>>>>>>>>>>", consoleLogMock.mock.calls);
+            assert.ok(consoleLogMock.mock.calls.some(call => call.arguments[0].includes("Debug mode disabled")));
             consoleLogMock.mock.restore();
         });
+        describe("onContextChange$ observable", () => {
+            it("should emit initial context to new subscriber", () => {
+                const manager = new Hotkeys("initial", false);
+                const spy = createMockFn();
+                const sub = manager.onContextChange$.subscribe(spy);
+                assert.strictEqual(spy.calledCount, 1);
+                assert.strictEqual(spy.lastArgs[0], "initial");
+                sub.unsubscribe();
+                manager.destroy();
+            });
+            it("should emit when context changes", () => {
+                const spy = createMockFn();
+                const sub = keyManager.onContextChange$.subscribe(spy); // Subscribes, gets initial null
+                spy.mockClear(); // Clear initial emission
+                keyManager.setContext("newContext");
+                assert.strictEqual(spy.calledCount, 1);
+                assert.strictEqual(spy.lastArgs[0], "newContext");
+                keyManager.setContext("anotherContext");
+                assert.strictEqual(spy.calledCount, 2);
+                assert.strictEqual(spy.lastArgs[0], "anotherContext");
+                keyManager.setContext(null);
+                assert.strictEqual(spy.calledCount, 3);
+                assert.strictEqual(spy.lastArgs[0], null);
+                sub.unsubscribe();
+            });
+            it("should not emit if context is set to the same value", () => {
+                keyManager.setContext("testContext");
+                const spy = createMockFn();
+                const sub = keyManager.onContextChange$.subscribe(spy); // Subscribes, gets "testContext"
+                spy.mockClear(); // Clear initial emission
+                keyManager.setContext("testContext"); // Set same context
+                assert.strictEqual(spy.calledCount, 0, "Observable should not emit if context value is the same.");
+                sub.unsubscribe();
+            });
+        });
     });
     describe("addCombination", () => {
         it("should trigger callback for a simple key combination (e.g., 'A')", () => {
@@ -241,6 +340,18 @@ describe("Hotkeys Library (Node.js Test Runner)", () => {
                 consoleLogMock.mock.restore();
                 keyManager.setDebugMode(false);
             });
+            it("should trigger callback for Keys.Space using shorthand", () => {
+                const config = { id: "spaceShorthand", keys: Keys.Space, callback: mockCallback };
+                keyManager.addCombination(config);
+                dispatchKeyEvent(" "); // Event key for space is " "
+                assert.strictEqual(mockCallback.calledCount, 1, "Callback for Keys.Space (shorthand) not called");
+            });
+            it("should trigger callback for Keys.Space using object form", () => {
+                const config = { id: "spaceObject", keys: { key: Keys.Space }, callback: mockCallback };
+                keyManager.addCombination(config);
+                dispatchKeyEvent(" ");
+                assert.strictEqual(mockCallback.calledCount, 1, "Callback for Keys.Space (object form) not called");
+            });
         });
     });
     describe("addSequence", () => {
@@ -303,6 +414,29 @@ describe("Hotkeys Library (Node.js Test Runner)", () => {
             assert.strictEqual(consoleErrorMock.mock.calls.length, 1);
             assert.ok(consoleErrorMock.mock.calls[0].arguments[0].includes(`Error in user callback for sequence shortcut "errorSeq"`));
         });
+        it("should trigger callback for a sequence including Keys.Space", () => {
+            const config = {
+                id: "seqWithSpace",
+                sequence: [Keys.G, Keys.Space, Keys.I],
+                callback: mockCallback
+            };
+            keyManager.addSequence(config);
+            dispatchKeyEvent(Keys.G);
+            dispatchKeyEvent(Keys.Space); // Dispatch " " for space
+            dispatchKeyEvent(Keys.I);
+            assert.strictEqual(mockCallback.calledCount, 1, "Callback for sequence with Keys.Space not called");
+        });
+        it("should trigger callback for a sequence starting or ending with Keys.Space", () => {
+            const config = {
+                id: "seqStartSpace",
+                sequence: [Keys.Space, Keys.A],
+                callback: mockCallback
+            };
+            keyManager.addSequence(config);
+            dispatchKeyEvent(Keys.Space);
+            dispatchKeyEvent(Keys.A);
+            assert.strictEqual(mockCallback.calledCount, 1, "Callback for sequence starting with Keys.Space not called");
+        });
         describe("Sequence Contextual Triggering", () => {
             let editorSequenceConfig;
             beforeEach(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rx-hotkeys",
-  "version": "2.1.1",
+  "version": "2.2.1",
   "type": "module",
   "scripts": {
     "build": "tsc",