core: Keybind setting for plugins + shortcustScreenShare example

packages/discord-types/src/components.d.ts

@@ -1,4 +1,5 @@
 import type { ComponentClass, ComponentPropsWithRef, ComponentType, CSSProperties, FunctionComponent, HtmlHTMLAttributes, HTMLProps, JSX, KeyboardEvent, MouseEvent, PointerEvent, PropsWithChildren, ReactNode, Ref, RefObject } from "react";
+import { GlobalShortcut } from "./utils";
 
 
 // #region Old compability
@@ -513,3 +514,9 @@ export type ColorPicker = ComponentType<{
     label?: ReactNode;
     onChange(value: number | null): void;
 }>;
+
+export type GlobalKeybind = ComponentType<{
+    defaultValue: GlobalShortcut;
+    disabled: boolean;
+    onChange(value: GlobalShortcut): void;
+}>;

packages/discord-types/src/utils.d.ts

@@ -335,3 +335,33 @@ export interface CommandOptions {
     max_value?: number;
     autocomplete?: boolean;
 }
+
+// Global shortcut types
+export enum GlobalShortcutKeyOS {
+    WINDOWS = 1,
+    MACOS = 2,
+    LINUX = 3,
+    BROWSER = 4
+}
+export enum GlobalShortcutKeyType {
+    KEYBOARD_KEY = 0,
+    MOUSE_BUTTON = 1,
+    KEYBOARD_MODIFIER_KEY = 2,
+    GAMEPAD_BUTTON = 3
+}
+export type GlobalShortcutKey = [GlobalShortcutKeyType, number] | [GlobalShortcutKeyType, number, GlobalShortcutKeyOS | `${number}:${number}`];
+export type GlobalShortcut = GlobalShortcutKey[];
+export type GlobalShortcutOptions = {
+    blurred: boolean;
+    focused: boolean;
+    keydown: boolean;
+    keyup: boolean;
+};
+
+export type DiscordUtils = {
+    inputCaptureRegisterElement(elementId: string, callback: (keys: GlobalShortcut) => void): () => void;
+    inputGetRegisteredEvents(callback: (keys: GlobalShortcut) => void): undefined;
+    inputEventRegister(id: number, keys: GlobalShortcut, callback: () => void, options: GlobalShortcutOptions): undefined;
+    inputEventUnregister(id: number): undefined;
+    inputSetFocused(focused: boolean): undefined;
+};

src/api/Keybinds/globalManager.ts

@@ -0,0 +1,79 @@
+/*
+ * Vencord, a Discord client mod
+ * Copyright (c) 2025 Vendicated and contributors
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { DiscordUtils, GlobalShortcut, GlobalShortcutOptions } from "@vencord/discord-types";
+import { findByCodeLazy } from "webpack";
+
+import { KeybindManager } from "./types";
+
+// Discord mapping from keycodes array to string (mouse, keyboard, gamepad)
+const keycodesToString = IS_DISCORD_DESKTOP ? findByCodeLazy(".map(", ".KEYBOARD_KEY", ".KEYBOARD_MODIFIER_KEY", ".MOUSE_BUTTON", ".GAMEPAD_BUTTON") as (keys: GlobalShortcut) => string : (keys: GlobalShortcut) => keys.join("+");
+
+export default new class GlobalManager implements KeybindManager {
+    private discordUtils: undefined | DiscordUtils; // TODO: Maybe check if IS_VESKTOP and use its global keybinds api
+    private lastGlobalId: number = 1000;
+    private mapIdToEvent: Map<string, number> = new Map();
+
+    private initDiscordUtils() {
+        if (!IS_DISCORD_DESKTOP || this.discordUtils || !DiscordNative) return;
+        this.discordUtils = DiscordNative.nativeModules.requireModule("discord_utils");
+    }
+
+    // From discord key registration
+    private newKeysInstance(keys: GlobalShortcut): GlobalShortcut {
+        return keys.map(e => {
+            const [t, n, r] = e;
+            return typeof r === "string" ? [t, n, r] : [t, n];
+        });
+    }
+
+    private getIdForEvent(event: string): number {
+        const found = this.mapIdToEvent.get(event);
+        if (!found) {
+            const id = this.lastGlobalId++;
+            this.mapIdToEvent.set(event, id);
+            return id;
+        } else {
+            return found;
+        }
+    }
+
+    public isAvailable() {
+        this.initDiscordUtils();
+        return !!this.discordUtils;
+    }
+
+    public getDiscordUtils() {
+        this.initDiscordUtils();
+        return this.discordUtils;
+    }
+
+    public registerKeybind(event: string, keys: GlobalShortcut, callback: () => void, options: GlobalShortcutOptions) {
+        this.initDiscordUtils();
+        if (!this.discordUtils) return;
+        const id = this.getIdForEvent(event);
+        if (!id) return;
+        this.discordUtils.inputEventRegister(id, this.newKeysInstance(keys), callback, options);
+    }
+
+    public unregisterKeybind(event: string) {
+        this.initDiscordUtils();
+        if (!this.discordUtils) return;
+        const id = this.mapIdToEvent.get(event);
+        if (!id) return;
+        this.discordUtils.inputEventUnregister(id);
+    }
+
+    public inputCaptureKeys(inputId: string, callback: (keys: GlobalShortcut) => void): () => void {
+        this.initDiscordUtils();
+        if (!this.discordUtils) return () => { };
+        return this.discordUtils.inputCaptureRegisterElement(inputId, callback);
+    }
+
+    public keysToString(keys: GlobalShortcut): string {
+        return keycodesToString(keys).toUpperCase();
+    }
+};

src/api/Keybinds/index.ts

@@ -0,0 +1,9 @@
+/*
+ * Vencord, a Discord client mod
+ * Copyright (c) 2025 Vendicated and contributors
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import keybindsManager from "./keybindsManager";
+
+export { keybindsManager };

src/api/Keybinds/keybindsManager.ts

@@ -0,0 +1,94 @@
+/*
+ * Vencord, a Discord client mod
+ * Copyright (c) 2025 Vendicated and contributors
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { GlobalShortcut, GlobalShortcutOptions } from "@vencord/discord-types";
+
+import globalManager from "./globalManager";
+import { InternalKeybind, Keybind, KeybindShortcut, WindowShortcut } from "./types";
+import windowManager from "./windowManager";
+
+export default new class KeybindsManager {
+    private keybindsGlobal: Map<string, InternalKeybind> = new Map();
+    private keybindsWindow: Map<string, InternalKeybind> = new Map();
+
+    isAvailable(global: boolean) {
+        return global ? globalManager.isAvailable() : windowManager.isAvailable();
+    }
+
+    inputCaptureKeys(inputId: string, callback: (keys: KeybindShortcut) => void, global: boolean) {
+        return global ? globalManager.inputCaptureKeys(inputId, callback) : windowManager.inputCaptureKeys(inputId, callback);
+    }
+
+    keysToString(keys: KeybindShortcut, global: boolean): string {
+        return global ? globalManager.keysToString(keys as GlobalShortcut) : windowManager.keysToString(keys as WindowShortcut);
+    }
+
+    private getBinding(event: string, global: boolean): InternalKeybind | undefined {
+        return global ? this.keybindsGlobal.get(event) : this.keybindsWindow.get(event);
+    }
+
+    private isEventAvailable(event: string, global: boolean): boolean {
+        return global ? !this.keybindsGlobal.has(event) : !this.keybindsWindow.has(event);
+    }
+
+    registerKeybind(binding: Keybind, keys: KeybindShortcut = []) {
+        if (!this.isEventAvailable(binding.event, binding.global)) return false;
+        if (binding.global) {
+            this.keybindsGlobal.set(binding.event, { keys: (keys as GlobalShortcut), enabled: false, ...(binding as Keybind) });
+        } else {
+            this.keybindsWindow.set(binding.event, { keys: (keys as WindowShortcut), enabled: false, ...(binding as Keybind) });
+        }
+        return true;
+    }
+
+    unregisterKeybind(event: string, global: boolean): boolean {
+        const binding = this.getBinding(event, global);
+        if (!binding) return false;
+        if (binding.enabled) {
+            this.disableKeybind(event, global);
+        }
+        return global ? this.keybindsGlobal.delete(event) : this.keybindsWindow.delete(event);
+    }
+
+    updateKeybind(event: string, keys: KeybindShortcut, global: boolean) {
+        const binding = this.getBinding(event, global);
+        if (!binding) return;
+        binding.keys = keys;
+        if (binding.enabled) {
+            this.disableKeybind(event, global);
+        }
+        this.enableKeybind(event, global);
+    }
+
+    enableKeybind(event: string, global: boolean) {
+        const binding = this.getBinding(event, global);
+        if (!binding) return;
+        if (binding.enabled || !binding.keys.length) return;
+        if (global) {
+            globalManager.registerKeybind(binding.event, binding.keys as GlobalShortcut, binding.function, binding.options as GlobalShortcutOptions);
+        } else {
+            windowManager.registerKeybind(binding.event, binding.keys as WindowShortcut, binding.function, binding.options);
+        }
+        binding.enabled = true;
+    }
+
+    disableKeybind(event: string, global: boolean) {
+        if (global) {
+            if (!globalManager.isAvailable()) return;
+            const binding = this.getBinding(event, true);
+            if (!binding) return;
+            if (!binding.enabled) return;
+            globalManager.unregisterKeybind(binding.event);
+            binding.enabled = false;
+        } else {
+            const binding = this.getBinding(event, false);
+            if (!binding) return;
+            if (!binding.enabled) return;
+            windowManager.unregisterKeybind(binding.event);
+            binding.enabled = false;
+        }
+    }
+};

src/api/Keybinds/types.d.ts

@@ -0,0 +1,36 @@
+/*
+ * Vencord, a Discord client mod
+ * Copyright (c) 2025 Vendicated and contributors
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { GlobalShortcut, GlobalShortcutOptions } from "@vencord/discord-types";
+
+export type WindowShortcut = string[];
+export type WindowShortcutOptions = {
+    keydown: boolean;
+    keyup: boolean;
+};
+
+export type KeybindShortcut = GlobalShortcut | WindowShortcut;
+export type KeybindOptions = GlobalShortcutOptions | WindowShortcutOptions;
+
+export type Keybind = {
+    event: string;
+    function: () => void;
+    options: KeybindOptions;
+    global: boolean;
+};
+
+export type InternalKeybind = Keybind & {
+    enabled: boolean;
+    keys: KeybindShortcut;
+};
+
+interface KeybindManager {
+    isAvailable(): boolean;
+    registerKeybind(event: string, keys: KeybindShortcut, callback: () => void, options: GlobalShortcutOptions): void;
+    unregisterKeybind(event: string): void;
+    inputCaptureKeys(inputId: string, callback: (keys: KeybindShortcut) => void): () => void;
+    keysToString(keys: KeybindShortcut): string;
+}