@genesislcap/foundation-utils 14.311.0 → 14.312.0

package/dist/dts/index.d.ts

@@ -13,6 +13,7 @@ export * from './observer';
 export * from './promise';
 export * from './resource';
 export * from './serializers';
+export * from './shortcut-manager';
 export * from './state';
 export * from './styles';
 export * from './utils';

package/dist/dts/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}

package/dist/dts/shortcut-manager/index.d.ts

@@ -0,0 +1,3 @@
+export * from './shortcut-manager';
+export * from './shortcut-listener';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/shortcut-manager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shortcut-manager/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/dts/shortcut-manager/shortcut-listener.d.ts

@@ -0,0 +1,21 @@
+import { FASTElement } from '@microsoft/fast-element';
+import { ShortcutManager } from './shortcut-manager';
+/**
+ * A custom element that listens for keyboard shortcuts.
+ * @public
+ * @remarks Part of the ShortcutManager Service.
+ */
+export declare class FoundationShortcutListener extends FASTElement {
+    shortcutManager: ShortcutManager;
+    private keyListener;
+    private isListening;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private setupStateSubscription;
+    private addKeyListener;
+    private removeKeyListener;
+    private handleKeyDown;
+    private extractKeyFromCode;
+    private isInputElement;
+}
+//# sourceMappingURL=shortcut-listener.d.ts.map

package/dist/dts/shortcut-manager/shortcut-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcut-listener.d.ts","sourceRoot":"","sources":["../../../src/shortcut-manager/shortcut-listener.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAErE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;GAIG;AACH,qBAGa,0BAA2B,SAAQ,WAAW;IAChC,eAAe,EAAE,eAAe,CAAC;IAE1D,OAAO,CAAC,WAAW,CAAiD;IACpE,OAAO,CAAC,WAAW,CAAS;IAE5B,iBAAiB;IAKjB,oBAAoB;IAKpB,OAAO,CAAC,sBAAsB;IAgB9B,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,aAAa;IA6BrB,OAAO,CAAC,kBAAkB;IA6C1B,OAAO,CAAC,cAAc;CAuBvB"}

package/dist/dts/shortcut-manager/shortcut-manager.d.ts

@@ -0,0 +1,120 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+/**
+ * A type which represents the disabled status and tooltip of an item
+ * @public
+ * */
+export type ShortcutExecutionStatus = {
+    disabled?: boolean;
+    tooltip?: string;
+};
+/**
+ * A definition of a keyboard shortcut
+ * @public
+ */
+export interface ShortcutDefinition {
+    id: string;
+    key: string;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    optionKey?: boolean;
+    shiftKey?: boolean;
+    metaKey?: boolean;
+    description: string;
+    action: () => void;
+    context: string;
+    priority?: number;
+    elementRef?: HTMLElement;
+    canExecute?: () => ShortcutExecutionStatus;
+}
+/**
+ * A result of registering a keyboard shortcut
+ * @public
+ */
+export interface ShortcutRegistrationResult {
+    shortcut: ShortcutDefinition;
+    id: string;
+    keyCombination: string;
+    keyCombinationDisplay: string;
+    disabled: () => boolean;
+    tooltip: () => string | undefined;
+}
+/**
+ * Interface of a manager for keyboard shortcuts
+ * @public
+ */
+export interface ShortcutManager {
+    registerShortcuts(shortcuts: ShortcutDefinition[]): void;
+    registerShortcut(shortcut: ShortcutDefinition): ShortcutRegistrationResult;
+    unregisterShortcut(context: string, id: string): void;
+    unregisterShortcutsByContext(context: string): void;
+    /**
+     * Execute a shortcut by its id
+     * @param id - The id of the shortcut to execute
+     * @remarks This method will execute the shortcut in the active context
+     */
+    executeShortcut(id: string): void;
+    /**
+     * Execute a shortcut by its id and context
+     * @param context - The context of the shortcut to execute
+     * @param id - The id of the shortcut to execute
+     */
+    executeShortcutByContext(context: string, id: string): void;
+    getShortcuts(): ShortcutDefinition[];
+    getShortcutsByContext(context: string): ShortcutDefinition[];
+    getContexts(): string[];
+    getShortcutsByContextMap(): Map<string, Map<string, ShortcutDefinition>>;
+    registerContext(context: string): void;
+    setActiveContext(context: string): void;
+    getActiveContext(): string | undefined;
+    clearActiveContext(): void;
+    findShortcutByKeyCombination(key: string, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean, metaKey?: boolean): ShortcutDefinition | undefined;
+    pause(): void;
+    resume(): void;
+    isPaused: boolean;
+    isPaused$: Observable<boolean>;
+    isPausedSubject: BehaviorSubject<boolean>;
+}
+/**
+ * Default implementation of the ShortcutManager interface
+ * @public
+ */
+export declare class DefaultShortcutManager implements ShortcutManager {
+    private shortcuts;
+    private shortcutLookup;
+    private keyCombinationMap;
+    private _isPausedSubject;
+    private _activeContext;
+    get isPaused(): boolean;
+    get isPaused$(): Observable<boolean>;
+    get isPausedSubject(): BehaviorSubject<boolean>;
+    registerShortcuts(shortcuts: ShortcutDefinition[]): void;
+    registerShortcut(shortcut: ShortcutDefinition): ShortcutRegistrationResult;
+    unregisterShortcut(context: string, id: string): void;
+    unregisterShortcutsByContext(context: string): void;
+    executeShortcut(id: string): void;
+    executeShortcutByContext(context: string, id: string): void;
+    getShortcuts(): ShortcutDefinition[];
+    getShortcutsByContext(context: string): ShortcutDefinition[];
+    findShortcutByKeyCombination(key: string, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean, metaKey?: boolean): ShortcutDefinition | undefined;
+    getContexts(): string[];
+    getShortcutsByContextMap(): Map<string, Map<string, ShortcutDefinition>>;
+    registerContext(context: string): void;
+    setActiveContext(context: string): void;
+    getActiveContext(): string | undefined;
+    clearActiveContext(): void;
+    pause(): void;
+    resume(): void;
+    /**
+     * Normalizes a shortcut definition to handle option/alt equivalence
+     * If optionKey is set, altKey will also be set to true (and vice versa)
+     */
+    private normalizeShortcutDefinition;
+    private createKeyCombinationKey;
+    private isElementFocused;
+}
+/**
+ * A dependency injection token for the ShortcutManager interface.
+ * @public
+ */
+export declare const ShortcutManager: import("@microsoft/fast-foundation").InterfaceSymbol<ShortcutManager>;
+//# sourceMappingURL=shortcut-manager.d.ts.map

package/dist/dts/shortcut-manager/shortcut-manager.d.ts.map

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

package/dist/dts/utils/os-platform.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Platform detection utilities for cross-platform compatibility
+ */
+export declare class OperatingSystemUtils {
+    /**
+     * Detects if the current platform is macOS
+     */
+    static get isMacOS(): boolean;
+    /**
+     * Detects if the current platform is Windows
+     */
+    static get isWindows(): boolean;
+    /**
+     * Detects if the current platform is Linux
+     */
+    static get isLinux(): boolean;
+    /**
+     * Gets the appropriate modifier key symbols for the current platform
+     */
+    static getModifierSymbols(): {
+        ctrl: string;
+        alt: string;
+        shift: string;
+        meta: string;
+    };
+    /**
+     * Formats a key combination with platform-appropriate symbols
+     */
+    static formatKeyCombination(key: string, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean, metaKey?: boolean): string;
+}
+//# sourceMappingURL=os-platform.d.ts.map

package/dist/dts/utils/os-platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"os-platform.d.ts","sourceRoot":"","sources":["../../../src/utils/os-platform.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,oBAAoB;IAC/B;;OAEG;IACH,MAAM,KAAK,OAAO,IAAI,OAAO,CAK5B;IAED;;OAEG;IACH,MAAM,KAAK,SAAS,IAAI,OAAO,CAK9B;IAED;;OAEG;IACH,MAAM,KAAK,OAAO,IAAI,OAAO,CAK5B;IAED;;OAEG;IACH,MAAM,CAAC,kBAAkB,IAAI;QAC3B,IAAI,EAAE,MAAM,CAAC;QACb,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;KACd;IAkBD;;OAEG;IACH,MAAM,CAAC,oBAAoB,CACzB,GAAG,EAAE,MAAM,EACX,OAAO,UAAQ,EACf,MAAM,UAAQ,EACd,QAAQ,UAAQ,EAChB,OAAO,UAAQ,GACd,MAAM;CAcV"}

package/dist/esm/index.js

@@ -13,6 +13,7 @@ export * from './observer';
 export * from './promise';
 export * from './resource';
 export * from './serializers';
+export * from './shortcut-manager';
 export * from './state';
 export * from './styles';
 export * from './utils';

package/dist/esm/shortcut-manager/index.js

@@ -0,0 +1,2 @@
+export * from './shortcut-manager';
+export * from './shortcut-listener';

package/dist/esm/shortcut-manager/shortcut-listener.js

@@ -0,0 +1,140 @@
+import { __decorate } from "tslib";
+import { customElement, FASTElement } from '@microsoft/fast-element';
+import { inject } from '@microsoft/fast-foundation';
+import { ShortcutManager } from './shortcut-manager';
+/**
+ * A custom element that listens for keyboard shortcuts.
+ * @public
+ * @remarks Part of the ShortcutManager Service.
+ */
+let FoundationShortcutListener = class FoundationShortcutListener extends FASTElement {
+    constructor() {
+        super(...arguments);
+        this.keyListener = null;
+        this.isListening = false;
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.setupStateSubscription();
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.removeKeyListener();
+    }
+    setupStateSubscription() {
+        // Subscribe to the pause state changes
+        this.shortcutManager.isPaused$.subscribe((isPaused) => {
+            if (isPaused) {
+                this.removeKeyListener();
+            }
+            else {
+                this.addKeyListener();
+            }
+        });
+        // Set initial state
+        if (!this.shortcutManager.isPaused) {
+            this.addKeyListener();
+        }
+    }
+    addKeyListener() {
+        if (this.isListening)
+            return;
+        this.keyListener = this.handleKeyDown.bind(this);
+        document.addEventListener('keydown', this.keyListener);
+        this.isListening = true;
+    }
+    removeKeyListener() {
+        if (!this.isListening || !this.keyListener)
+            return;
+        document.removeEventListener('keydown', this.keyListener);
+        this.keyListener = null;
+        this.isListening = false;
+    }
+    handleKeyDown(event) {
+        // Don't handle shortcuts if the service is paused
+        if (this.shortcutManager.isPaused) {
+            return;
+        }
+        // Don't handle shortcuts if user is typing in an input field
+        if (this.isInputElement(event.target)) {
+            return;
+        }
+        // Extract key from event.code with proper mapping for all key types
+        const key = this.extractKeyFromCode(event.code);
+        const shortcut = this.shortcutManager.findShortcutByKeyCombination(key, event.ctrlKey, event.altKey, event.shiftKey, event.metaKey);
+        if (shortcut) {
+            event.preventDefault();
+            event.stopPropagation();
+            this.shortcutManager.executeShortcut(shortcut.id);
+        }
+    }
+    extractKeyFromCode(code) {
+        // Handle regular letter keys (KeyA, KeyB, etc.)
+        if (code.startsWith('Key')) {
+            return code.replace('Key', '').toLowerCase();
+        }
+        // Handle digit keys (Digit0, Digit1, etc.)
+        if (code.startsWith('Digit')) {
+            return code.replace('Digit', '');
+        }
+        // Handle special keys with direct mapping
+        const specialKeyMap = {
+            Space: 'space',
+            Enter: 'enter',
+            Escape: 'escape',
+            Tab: 'tab',
+            Backspace: 'backspace',
+            Delete: 'delete',
+            Insert: 'insert',
+            Home: 'home',
+            End: 'end',
+            PageUp: 'pageup',
+            PageDown: 'pagedown',
+            ArrowUp: 'arrowup',
+            ArrowDown: 'arrowdown',
+            ArrowLeft: 'arrowleft',
+            ArrowRight: 'arrowright',
+            F1: 'f1',
+            F2: 'f2',
+            F3: 'f3',
+            F4: 'f4',
+            F5: 'f5',
+            F6: 'f6',
+            F7: 'f7',
+            F8: 'f8',
+            F9: 'f9',
+            F10: 'f10',
+            F11: 'f11',
+            F12: 'f12',
+        };
+        return specialKeyMap[code] || code.toLowerCase();
+    }
+    isInputElement(element) {
+        if (!element)
+            return false;
+        const inputTypes = ['input', 'textarea', 'select'];
+        const tagName = element.tagName.toLowerCase();
+        if (inputTypes.includes(tagName)) {
+            return true;
+        }
+        // Check for contenteditable
+        if (element.contentEditable === 'true') {
+            return true;
+        }
+        // Check for role="textbox" or similar
+        const role = element.getAttribute('role');
+        if (role && ['textbox', 'searchbox', 'combobox'].includes(role)) {
+            return true;
+        }
+        return false;
+    }
+};
+__decorate([
+    inject(ShortcutManager)
+], FoundationShortcutListener.prototype, "shortcutManager", void 0);
+FoundationShortcutListener = __decorate([
+    customElement({
+        name: 'foundation-shortcut-listener',
+    })
+], FoundationShortcutListener);
+export { FoundationShortcutListener };

package/dist/esm/shortcut-manager/shortcut-manager.js

@@ -0,0 +1,286 @@
+import { DI } from '@microsoft/fast-foundation';
+import { BehaviorSubject } from 'rxjs';
+import { logger } from '../utils';
+import { OperatingSystemUtils } from '../utils/os-platform';
+/**
+ * Default implementation of the ShortcutManager interface
+ * @public
+ */
+export class DefaultShortcutManager {
+    constructor() {
+        this.shortcuts = new Map(); // context -> id -> ShortcutDefinition
+        this.shortcutLookup = new Map(); // context:id -> ShortcutDefinition for quick lookups
+        this.keyCombinationMap = new Map(); // key combination -> set of "context:id" strings
+        this._isPausedSubject = new BehaviorSubject(false);
+    }
+    get isPaused() {
+        return this._isPausedSubject.value;
+    }
+    get isPaused$() {
+        return this._isPausedSubject.asObservable();
+    }
+    get isPausedSubject() {
+        return this._isPausedSubject;
+    }
+    registerShortcuts(shortcuts) {
+        shortcuts.forEach((shortcut) => {
+            this.registerShortcut(shortcut);
+        });
+    }
+    registerShortcut(shortcut) {
+        const compositeKey = `${shortcut.context}:${shortcut.id}`;
+        // Normalize shortcut definition: handle option/alt equivalence
+        const normalizedShortcut = this.normalizeShortcutDefinition(shortcut);
+        // Check if there's already a shortcut with the same key combination
+        const keyCombo = this.createKeyCombinationKey(normalizedShortcut.key, normalizedShortcut.ctrlKey, normalizedShortcut.altKey, normalizedShortcut.shiftKey, normalizedShortcut.metaKey);
+        // Create platform-friendly display format
+        const keyCombinationDisplay = OperatingSystemUtils.formatKeyCombination(normalizedShortcut.key, normalizedShortcut.ctrlKey, normalizedShortcut.altKey, normalizedShortcut.shiftKey, normalizedShortcut.metaKey);
+        const existingShortcutIds = this.keyCombinationMap.get(keyCombo);
+        if (existingShortcutIds) {
+            // Check if we should replace any existing shortcuts
+            const shortcutsToRemove = [];
+            for (const existingCompositeId of existingShortcutIds) {
+                const existingShortcut = this.shortcutLookup.get(existingCompositeId);
+                if (existingShortcut) {
+                    // Replace if same context (prevents conflicts within same component/page)
+                    if (existingShortcut.context === normalizedShortcut.context) {
+                        // Log warning about shortcut replacement
+                        logger.warn(`Shortcut with key combination '${keyCombo}' already exists in context '${normalizedShortcut.context}' (id: '${existingShortcut.id}'). It will be replaced by new shortcut '${normalizedShortcut.id}'.`);
+                        shortcutsToRemove.push(existingCompositeId);
+                    }
+                }
+            }
+            // Remove shortcuts that should be replaced
+            shortcutsToRemove.forEach((compositeId) => {
+                const shortcutToRemove = this.shortcutLookup.get(compositeId);
+                if (shortcutToRemove) {
+                    const contextMap = this.shortcuts.get(shortcutToRemove.context);
+                    if (contextMap) {
+                        contextMap.delete(shortcutToRemove.id);
+                        if (contextMap.size === 0) {
+                            this.shortcuts.delete(shortcutToRemove.context);
+                        }
+                    }
+                    this.shortcutLookup.delete(compositeId);
+                }
+                existingShortcutIds.delete(compositeId);
+            });
+            // If no shortcuts remain for this key combination, remove the entry
+            if (existingShortcutIds.size === 0) {
+                this.keyCombinationMap.delete(keyCombo);
+            }
+        }
+        // Register the new shortcut
+        if (!this.shortcuts.has(normalizedShortcut.context)) {
+            this.shortcuts.set(normalizedShortcut.context, new Map());
+        }
+        this.shortcuts.get(normalizedShortcut.context).set(normalizedShortcut.id, normalizedShortcut);
+        this.shortcutLookup.set(compositeKey, normalizedShortcut);
+        // Add to key combination map
+        if (!this.keyCombinationMap.has(keyCombo)) {
+            this.keyCombinationMap.set(keyCombo, new Set());
+        }
+        this.keyCombinationMap.get(keyCombo).add(compositeKey);
+        return {
+            shortcut: normalizedShortcut,
+            id: normalizedShortcut.id,
+            keyCombination: keyCombo,
+            keyCombinationDisplay,
+            // Functions that can be directly used in AG Grid menu items
+            disabled: () => {
+                if (this.isPaused)
+                    return true;
+                if (normalizedShortcut.canExecute) {
+                    const status = normalizedShortcut.canExecute();
+                    return status.disabled || false;
+                }
+                return false;
+            },
+            tooltip: () => {
+                if (this.isPaused)
+                    return 'Shortcuts are paused';
+                if (normalizedShortcut.canExecute) {
+                    const status = normalizedShortcut.canExecute();
+                    return status.tooltip;
+                }
+                return undefined;
+            },
+        };
+    }
+    unregisterShortcut(context, id) {
+        const compositeKey = `${context}:${id}`;
+        const contextMap = this.shortcuts.get(context);
+        if (contextMap) {
+            const shortcut = contextMap.get(id);
+            if (shortcut) {
+                // Normalize the shortcut to ensure consistent key combination
+                const normalizedShortcut = this.normalizeShortcutDefinition(shortcut);
+                const keyCombo = this.createKeyCombinationKey(normalizedShortcut.key, normalizedShortcut.ctrlKey, normalizedShortcut.altKey, normalizedShortcut.shiftKey, normalizedShortcut.metaKey);
+                // Remove from shortcuts map
+                contextMap.delete(id);
+                if (contextMap.size === 0) {
+                    this.shortcuts.delete(context);
+                }
+                // Remove from lookup map
+                this.shortcutLookup.delete(compositeKey);
+                // Remove from key combination map
+                const shortcutIds = this.keyCombinationMap.get(keyCombo);
+                if (shortcutIds) {
+                    shortcutIds.delete(compositeKey);
+                    if (shortcutIds.size === 0) {
+                        this.keyCombinationMap.delete(keyCombo);
+                    }
+                }
+            }
+        }
+    }
+    unregisterShortcutsByContext(context) {
+        const contextMap = this.shortcuts.get(context);
+        if (contextMap) {
+            const shortcutIds = Array.from(contextMap.keys());
+            shortcutIds.forEach((id) => this.unregisterShortcut(context, id));
+        }
+    }
+    executeShortcut(id) {
+        this.executeShortcutByContext(this.getActiveContext(), id);
+    }
+    executeShortcutByContext(context, id) {
+        if (this.isPaused) {
+            return; // Don't execute shortcuts when paused
+        }
+        const contextMap = this.shortcuts.get(context);
+        if (contextMap) {
+            const shortcut = contextMap.get(id);
+            if (shortcut) {
+                // Check if shortcut requires a specific element to be focused
+                if (shortcut.elementRef && !this.isElementFocused(shortcut.elementRef)) {
+                    return; // Don't execute if the required element is not focused
+                }
+                // Check if shortcut can be executed
+                if (shortcut.canExecute) {
+                    const executionStatus = shortcut.canExecute();
+                    if (executionStatus.disabled) {
+                        return; // Don't execute if disabled
+                    }
+                }
+                try {
+                    shortcut.action();
+                }
+                catch (error) {
+                    logger.error(`Error executing shortcut ${context}:${id}:`, error);
+                }
+            }
+        }
+    }
+    getShortcuts() {
+        const allShortcuts = [];
+        // Iterate through all contexts and collect all shortcuts
+        for (const contextMap of this.shortcuts.values()) {
+            allShortcuts.push(...contextMap.values());
+        }
+        return allShortcuts;
+    }
+    getShortcutsByContext(context) {
+        const contextMap = this.shortcuts.get(context);
+        return contextMap ? Array.from(contextMap.values()) : [];
+    }
+    findShortcutByKeyCombination(key, ctrlKey = false, altKey = false, shiftKey = false, metaKey = false) {
+        const keyCombo = this.createKeyCombinationKey(key, ctrlKey, altKey, shiftKey, metaKey);
+        const shortcutIds = this.keyCombinationMap.get(keyCombo);
+        if (!shortcutIds) {
+            return undefined;
+        }
+        // First, try to find a shortcut in the active context if one is set
+        if (this._activeContext) {
+            const activeContextMap = this.shortcuts.get(this._activeContext);
+            if (!activeContextMap) {
+                // Continue to search all shortcuts
+            }
+            else {
+                for (const compositeId of shortcutIds) {
+                    const [context, id] = compositeId.split(':');
+                    if (context !== this._activeContext)
+                        continue;
+                    const shortcut = activeContextMap.get(id);
+                    if (shortcut) {
+                        return shortcut;
+                    }
+                }
+            }
+        }
+        // If no active context or no shortcut found in active context,
+        // return the first shortcut found for this key combination
+        for (const compositeId of shortcutIds) {
+            const shortcut = this.shortcutLookup.get(compositeId);
+            if (shortcut) {
+                return shortcut;
+            }
+        }
+        return undefined;
+    }
+    getContexts() {
+        return Array.from(this.shortcuts.keys());
+    }
+    getShortcutsByContextMap() {
+        return new Map(this.shortcuts);
+    }
+    registerContext(context) {
+        if (!this.shortcuts.has(context)) {
+            this.shortcuts.set(context, new Map());
+        }
+    }
+    setActiveContext(context) {
+        this.registerContext(context);
+        this._activeContext = context;
+    }
+    getActiveContext() {
+        return this._activeContext;
+    }
+    clearActiveContext() {
+        this._activeContext = undefined;
+    }
+    pause() {
+        this._isPausedSubject.next(true);
+    }
+    resume() {
+        this._isPausedSubject.next(false);
+    }
+    /**
+     * Normalizes a shortcut definition to handle option/alt equivalence
+     * If optionKey is set, altKey will also be set to true (and vice versa)
+     */
+    normalizeShortcutDefinition(shortcut) {
+        const normalized = Object.assign({}, shortcut);
+        // Handle option/alt equivalence
+        if (normalized.optionKey || normalized.altKey) {
+            normalized.altKey = true;
+            normalized.optionKey = true;
+        }
+        return normalized;
+    }
+    createKeyCombinationKey(key, ctrlKey = false, altKey = false, shiftKey = false, metaKey = false) {
+        const modifiers = [];
+        if (ctrlKey)
+            modifiers.push('ctrl');
+        if (altKey)
+            modifiers.push('alt');
+        if (shiftKey)
+            modifiers.push('shift');
+        if (metaKey)
+            modifiers.push('meta');
+        // Create a consistent format like "ctrl+alt+s" instead of "ctrl+alt:s"
+        const keyCombo = modifiers.length > 0 ? `${modifiers.join('+')}+${key}` : key;
+        return keyCombo.toLowerCase();
+    }
+    isElementFocused(element) {
+        if (element instanceof HTMLElement) {
+            return document.activeElement === element;
+        }
+        return false;
+    }
+}
+/**
+ * A dependency injection token for the ShortcutManager interface.
+ * @public
+ */
+export const ShortcutManager = DI.createInterface((x) => x.singleton(DefaultShortcutManager));