@meadowsjared/qhotkeys 1.1.17

package/LICENSE

@@ -0,0 +1,21 @@
+ MIT License
+
+Copyright (c) 2023 Derek Comella
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+# qHotkeys
+Global shotcut replacement for [Electron's implementation](https://www.electronjs.org/docs/latest/api/global-shortcut) without preventing native OS shortcuts.
+
+This project utilizes [uiohook-napi](https://npmjs.org/uiohook-napi). It depends on them and might not work on every system nor node/electron version.
+
+My purpose in creating qHotkeys was to be a replacement for Electron's global shortcut. With qHotkeys you can create a shortcut such as ``CommandOrControl + X`` and your app will still recognize the input AND your os will perform the 'cut' action
+
+This project is early in development. Report any bugs or issues on the [GitHub](https://github.com/qartho/qhotkeys/issues/) issue tracker.
+
+## Installation
+
+Install qHotkeys using npm:
+
+```
+npm i qhotkeys
+```
+
+## Example Implementation
+
+```JavaScript
+
+import { qKeys, qHotkeys } from 'qHotkeys'
+
+// Create instance
+var hotkeys = new qHotkeys()
+
+// ... 
+app.whenReady().then(() => {
+
+    // ...
+
+    // Your custom actions
+    const hotkeyAction = () => {
+        console.log("I pressed my hotkeys!")
+    }
+
+    const scrollUpAction = () => {
+        console.log("I scrolled up!")
+    }
+
+    const scrollDownAction = () => {
+        console.log("I scrolled down!")
+    }
+
+    // Registers your hotkey actions
+    // Command or Control + X = hotkeyAction called
+    hotkeys.register([qKeys.CmdOrCtrl, qKeys.X], hotkeyAction)
+    
+    // Registers your scroll actions
+    // Command or Control + ScrollUp = scrollUpAction called
+    // Command or Control + ScrollDown = scrollDownAction called
+    hotkeys.registerScroll([qKeys.CmdOrCtrl], scrollUpAction, scrollDownAction)
+    
+    // For scroll register, the hotkey list can be empty
+    hotkeys.registerScroll([], scrollUpAction, scrollDownAction)
+
+    // Starts
+    hotkeys.run()
+    
+    // ...
+})
+```
+
+## To-Do List
+This project is early in development and I have lots of ideas to expand the capabilities. Here's a roadmap of planned additions to qHotkeys.
+
+- Add event info to the action callbacks
+- Individual scroll registers
+- Add mouse buttons
+- Add mouse move
+- Horizontal Scroll
+
+Anymore ideas? Create an issue on the github page!
+
+## License
+
+[MIT](https://github.com/QarthO/qHotkeys/blob/main/LICENSE)
+
+Maintained by [QarthO](https://github.com/qartho).
+

package/bun.lock

@@ -0,0 +1,26 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "qhotkeys",
+      "dependencies": {
+        "uiohook-napi": "^1.5.4",
+      },
+      "devDependencies": {
+        "@types/node": "^25.0.3",
+        "typescript": "^5.9.3",
+      },
+    },
+  },
+  "packages": {
+    "@types/node": ["@types/node@25.0.3", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA=="],
+
+    "node-gyp-build": ["node-gyp-build@4.6.0", "", { "bin": { "node-gyp-build": "bin.js", "node-gyp-build-optional": "optional.js", "node-gyp-build-test": "build-test.js" } }, "sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "uiohook-napi": ["uiohook-napi@1.5.4", "", { "dependencies": { "node-gyp-build": "4.x.x" } }, "sha512-7vPVDNwgb6MwTgviA/dnF2MrW0X5xm76fAqaOAC3cEKkswqAZOPw1USu14Sr6383s5qhXegcJaR63CpJOPCNAg=="],
+
+    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,152 @@
+export declare const qKeys: {
+    readonly Backspace: 14;
+    readonly Tab: 15;
+    readonly Enter: 28;
+    readonly CapsLock: 58;
+    readonly Escape: 1;
+    readonly Space: 57;
+    readonly PageUp: 3657;
+    readonly PageDown: 3665;
+    readonly End: 3663;
+    readonly Home: 3655;
+    readonly ArrowLeft: 57419;
+    readonly ArrowUp: 57416;
+    readonly ArrowRight: 57421;
+    readonly ArrowDown: 57424;
+    readonly Insert: 3666;
+    readonly Delete: 3667;
+    readonly 0: 11;
+    readonly 1: 2;
+    readonly 2: 3;
+    readonly 3: 4;
+    readonly 4: 5;
+    readonly 5: 6;
+    readonly 6: 7;
+    readonly 7: 8;
+    readonly 8: 9;
+    readonly 9: 10;
+    readonly A: 30;
+    readonly B: 48;
+    readonly C: 46;
+    readonly D: 32;
+    readonly E: 18;
+    readonly F: 33;
+    readonly G: 34;
+    readonly H: 35;
+    readonly I: 23;
+    readonly J: 36;
+    readonly K: 37;
+    readonly L: 38;
+    readonly M: 50;
+    readonly N: 49;
+    readonly O: 24;
+    readonly P: 25;
+    readonly Q: 16;
+    readonly R: 19;
+    readonly S: 31;
+    readonly T: 20;
+    readonly U: 22;
+    readonly V: 47;
+    readonly W: 17;
+    readonly X: 45;
+    readonly Y: 21;
+    readonly Z: 44;
+    readonly Numpad0: 82;
+    readonly Numpad1: 79;
+    readonly Numpad2: 80;
+    readonly Numpad3: 81;
+    readonly Numpad4: 75;
+    readonly Numpad5: 76;
+    readonly Numpad6: 77;
+    readonly Numpad7: 71;
+    readonly Numpad8: 72;
+    readonly Numpad9: 73;
+    readonly NumpadMultiply: 55;
+    readonly NumpadAdd: 78;
+    readonly NumpadSubtract: 74;
+    readonly NumpadDecimal: 83;
+    readonly NumpadDivide: 3637;
+    readonly NumpadEnd: number;
+    readonly NumpadArrowDown: number;
+    readonly NumpadPageDown: number;
+    readonly NumpadArrowLeft: number;
+    readonly NumpadArrowRight: number;
+    readonly NumpadHome: number;
+    readonly NumpadArrowUp: number;
+    readonly NumpadPageUp: number;
+    readonly NumpadInsert: number;
+    readonly NumpadDelete: number;
+    readonly F1: 59;
+    readonly F2: 60;
+    readonly F3: 61;
+    readonly F4: 62;
+    readonly F5: 63;
+    readonly F6: 64;
+    readonly F7: 65;
+    readonly F8: 66;
+    readonly F9: 67;
+    readonly F10: 68;
+    readonly F11: 87;
+    readonly F12: 88;
+    readonly F13: 91;
+    readonly F14: 92;
+    readonly F15: 93;
+    readonly F16: 99;
+    readonly F17: 100;
+    readonly F18: 101;
+    readonly F19: 102;
+    readonly F20: 103;
+    readonly F21: 104;
+    readonly F22: 105;
+    readonly F23: 106;
+    readonly F24: 107;
+    readonly Semicolon: 39;
+    readonly Equal: 13;
+    readonly Comma: 51;
+    readonly Minus: 12;
+    readonly Period: 52;
+    readonly Slash: 53;
+    readonly Backquote: 41;
+    readonly BracketLeft: 26;
+    readonly Backslash: 43;
+    readonly BracketRight: 27;
+    readonly Quote: 40;
+    readonly Ctrl: 29;
+    readonly CtrlRight: 3613;
+    readonly Alt: 56;
+    readonly AltRight: 3640;
+    readonly Shift: 42;
+    readonly ShiftRight: 54;
+    readonly Meta: 3675;
+    readonly MetaRight: 3676;
+    readonly NumLock: 69;
+    readonly ScrollLock: 70;
+    readonly PrintScreen: 3639;
+    readonly Pause: 119;
+    readonly Cmd: 3675;
+    readonly CmdOrCtrl: 29 | 3675;
+    readonly MediaTrackNext: 57369;
+    readonly MediaTrackPrevious: 57360;
+    readonly MediaStop: 57380;
+    readonly MediaPlayPause: 57378;
+    readonly VolumeMute: 57376;
+    readonly VolumeUp: 57392;
+    readonly VolumeDown: 57390;
+};
+export declare const getKeyFromCode: (code: number) => string | undefined;
+export declare class qHotkeys {
+    private keys_pressed;
+    private hotkey_map;
+    private scroll_hotkey_map;
+    private debug;
+    register: (keys: number[], action: () => void) => void;
+    unregisterAll: (scroll?: boolean) => void;
+    unregister: (keys: number[]) => void;
+    registerScroll: (keys: number[], upAction: () => void, downAction: () => void) => void;
+    unregisterScroll: (keys: number[]) => void;
+    run: (debug?: boolean) => void;
+    private _handleKeydown;
+    private _handleKeyup;
+    private _handleWheel;
+    stop: () => void;
+}

package/dist/index.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.qHotkeys = exports.getKeyFromCode = exports.qKeys = void 0;
+const uiohook_napi_1 = require("uiohook-napi");
+// export type qKeyMap = {
+//   [key_name: string | number]: number
+// }
+// Same mapping from UiohookKey + Additions
+exports.qKeys = {
+    Backspace: 0x000E,
+    Tab: 0x000F,
+    Enter: 0x001C,
+    CapsLock: 0x003A,
+    Escape: 0x0001,
+    Space: 0x0039,
+    PageUp: 0x0E49,
+    PageDown: 0x0E51,
+    End: 0x0E4F,
+    Home: 0x0E47,
+    ArrowLeft: 0xE04B,
+    ArrowUp: 0xE048,
+    ArrowRight: 0xE04D,
+    ArrowDown: 0xE050,
+    Insert: 0x0E52,
+    Delete: 0x0E53,
+    0: 0x000B,
+    1: 0x0002,
+    2: 0x0003,
+    3: 0x0004,
+    4: 0x0005,
+    5: 0x0006,
+    6: 0x0007,
+    7: 0x0008,
+    8: 0x0009,
+    9: 0x000A,
+    A: 0x001E,
+    B: 0x0030,
+    C: 0x002E,
+    D: 0x0020,
+    E: 0x0012,
+    F: 0x0021,
+    G: 0x0022,
+    H: 0x0023,
+    I: 0x0017,
+    J: 0x0024,
+    K: 0x0025,
+    L: 0x0026,
+    M: 0x0032,
+    N: 0x0031,
+    O: 0x0018,
+    P: 0x0019,
+    Q: 0x0010,
+    R: 0x0013,
+    S: 0x001F,
+    T: 0x0014,
+    U: 0x0016,
+    V: 0x002F,
+    W: 0x0011,
+    X: 0x002D,
+    Y: 0x0015,
+    Z: 0x002C,
+    Numpad0: 0x0052,
+    Numpad1: 0x004F,
+    Numpad2: 0x0050,
+    Numpad3: 0x0051,
+    Numpad4: 0x004B,
+    Numpad5: 0x004C,
+    Numpad6: 0x004D,
+    Numpad7: 0x0047,
+    Numpad8: 0x0048,
+    Numpad9: 0x0049,
+    NumpadMultiply: 0x0037,
+    NumpadAdd: 0x004E,
+    NumpadSubtract: 0x004A,
+    NumpadDecimal: 0x0053,
+    NumpadDivide: 0x0E35,
+    NumpadEnd: 0xEE00 | 0x004F,
+    NumpadArrowDown: 0xEE00 | 0x0050,
+    NumpadPageDown: 0xEE00 | 0x0051,
+    NumpadArrowLeft: 0xEE00 | 0x004B,
+    NumpadArrowRight: 0xEE00 | 0x004D,
+    NumpadHome: 0xEE00 | 0x0047,
+    NumpadArrowUp: 0xEE00 | 0x0048,
+    NumpadPageUp: 0xEE00 | 0x0049,
+    NumpadInsert: 0xEE00 | 0x0052,
+    NumpadDelete: 0xEE00 | 0x0053,
+    F1: 0x003B,
+    F2: 0x003C,
+    F3: 0x003D,
+    F4: 0x003E,
+    F5: 0x003F,
+    F6: 0x0040,
+    F7: 0x0041,
+    F8: 0x0042,
+    F9: 0x0043,
+    F10: 0x0044,
+    F11: 0x0057,
+    F12: 0x0058,
+    F13: 0x005B,
+    F14: 0x005C,
+    F15: 0x005D,
+    F16: 0x0063,
+    F17: 0x0064,
+    F18: 0x0065,
+    F19: 0x0066,
+    F20: 0x0067,
+    F21: 0x0068,
+    F22: 0x0069,
+    F23: 0x006A,
+    F24: 0x006B,
+    Semicolon: 0x0027,
+    Equal: 0x000D,
+    Comma: 0x0033,
+    Minus: 0x000C,
+    Period: 0x0034,
+    Slash: 0x0035,
+    Backquote: 0x0029,
+    BracketLeft: 0x001A,
+    Backslash: 0x002B,
+    BracketRight: 0x001B,
+    Quote: 0x0028,
+    Ctrl: 0x001D, // Left
+    CtrlRight: 0x0E1D,
+    Alt: 0x0038, // Left
+    AltRight: 0x0E38,
+    Shift: 0x002A, // Left
+    ShiftRight: 0x0036,
+    Meta: 0x0E5B,
+    MetaRight: 0x0E5C,
+    NumLock: 0x0045,
+    ScrollLock: 0x0046,
+    PrintScreen: 0x0E37,
+    // + Addtions
+    Pause: 0x0077, // Pause Break Key
+    Cmd: 0x0E5B, // MacOS Command Key
+    CmdOrCtrl: process.platform === 'darwin' ? 0x0E5B : 0x001D, // Command or Control (like Electron's)
+    // Multimedia Keys
+    MediaTrackNext: 0xE019,
+    MediaTrackPrevious: 0xE010,
+    MediaStop: 0xE024,
+    MediaPlayPause: 0xE022,
+    VolumeMute: 0xE020,
+    VolumeUp: 0xE030,
+    VolumeDown: 0xE02E
+};
+const getKeyFromCode = (code) => {
+    return Object.keys(exports.qKeys).find((key) => exports.qKeys[key] === code);
+};
+exports.getKeyFromCode = getKeyFromCode;
+class qHotkeys {
+    keys_pressed = [];
+    hotkey_map = new Map();
+    scroll_hotkey_map = new Map();
+    debug = false;
+    register = (keys, action) => {
+        if (!keys)
+            return console.log(`Error: Hotkey map empty for '${action}'`);
+        this.hotkey_map.set(keys, action);
+    };
+    unregisterAll = (scroll = false) => {
+        this.hotkey_map.clear();
+        if (this.debug)
+            console.log('Unregistered all hotkeys');
+        if (scroll) {
+            this.scroll_hotkey_map.clear();
+            if (this.debug)
+                console.log('Unregistered all scroll hotkeys');
+        }
+    };
+    unregister = (keys) => {
+        // remove keys from the map
+        this.hotkey_map.forEach((_, hotkeys) => {
+            if (hotkeys.every((key) => keys.includes(key)) && hotkeys.length == keys.length) {
+                if (this.debug)
+                    console.log(`Unregistered: ${hotkeys.join(' + ')}`);
+                this.hotkey_map.delete(hotkeys);
+            }
+        });
+    };
+    registerScroll = (keys, upAction, downAction) => {
+        this.scroll_hotkey_map.set(keys, [upAction, downAction]);
+    };
+    unregisterScroll = (keys) => {
+        this.scroll_hotkey_map.forEach((_, hotkeys) => {
+            if (hotkeys.every((key) => keys.includes(key)) && hotkeys.length == keys.length) {
+                if (this.debug)
+                    console.log(`Unregistered: ${hotkeys.join(' + ')}`);
+                this.scroll_hotkey_map.delete(hotkeys);
+            }
+        });
+    };
+    run = (debug = false) => {
+        this.debug = debug;
+        uiohook_napi_1.uIOhook.on('keydown', this._handleKeydown);
+        uiohook_napi_1.uIOhook.on('keyup', this._handleKeyup);
+        uiohook_napi_1.uIOhook.on('wheel', this._handleWheel);
+        uiohook_napi_1.uIOhook.start();
+    };
+    _handleKeydown = (event) => {
+        const key = event.keycode;
+        // ignore if already pressed
+        if (this.keys_pressed.includes(key))
+            return;
+        // add to pressed keys
+        this.keys_pressed.push(key);
+        // debug
+        if (this.debug)
+            console.log(`Pressed: ${(0, exports.getKeyFromCode)(key)} key: ${key}`);
+        // loop through hotkey map
+        this.hotkey_map.forEach((action, hotkeys) => {
+            // ignore if not all keys are pressed
+            if (hotkeys.every((key) => !this.keys_pressed.includes(key)))
+                return;
+            // debug
+            if (this.debug)
+                console.log(`Hotkey Map Pressed: ${hotkeys}`);
+            // run action
+            action();
+        });
+    };
+    _handleKeyup = (event) => {
+        const key = event.keycode;
+        const i = this.keys_pressed.indexOf(key);
+        if (i != -1)
+            this.keys_pressed.splice(i, 1);
+        if (this.debug)
+            console.log(`Let Go: ${(0, exports.getKeyFromCode)(key)}`);
+    };
+    _handleWheel = (event) => {
+        if (this.scroll_hotkey_map.size == 0)
+            return;
+        const direction = event.rotation === 1 ? 'DOWN' : 'UP';
+        if (this.debug)
+            console.log(`Scrolled ${direction}`);
+        this.scroll_hotkey_map.forEach((actions, hotkeys) => {
+            if (hotkeys.length == 0 || hotkeys.every((key) => this.keys_pressed.includes(key))) {
+                if (direction === 'UP')
+                    actions[0]();
+                if (direction === 'DOWN')
+                    actions[1]();
+            }
+        });
+    };
+    stop = () => {
+        uiohook_napi_1.uIOhook.removeListener('keydown', this._handleKeydown);
+        uiohook_napi_1.uIOhook.removeListener('keyup', this._handleKeyup);
+        uiohook_napi_1.uIOhook.removeListener('wheel', this._handleWheel);
+        uiohook_napi_1.uIOhook.stop();
+    };
+}
+exports.qHotkeys = qHotkeys;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@meadowsjared/qhotkeys",
+  "version": "1.1.17",
+  "description": "Electron global shortcut registrar that doesn't override pre-existing shortcuts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "iohook",
+    "hook",
+    "input",
+    "keyboard",
+    "scrollwheel",
+    "shortcut",
+    "hotkey",
+    "electron",
+    "globalshortcut"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/meadowsjared/qhotkeys.git"
+  },
+  "author": "meadowsjared <meadowsjared@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "uiohook-napi": "^1.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "typescript": "^5.9.3"
+  }
+}