node-native-win-utils 1.4.0 → 2.1.1

package/dist/keyCodes.mjs

@@ -0,0 +1,201 @@
+export const keyCodes = new Map(Object.entries({
+    8: "Backspace",
+    9: "Tab",
+    13: "Enter",
+    16: "Shift",
+    17: "Ctrl",
+    18: "Alt",
+    20: "CapsLock",
+    27: "Escape",
+    32: "Space",
+    33: "PageUp",
+    34: "PageDown",
+    35: "End",
+    36: "Home",
+    37: "ArrowLeft",
+    38: "ArrowUp",
+    39: "ArrowRight",
+    40: "ArrowDown",
+    45: "Insert",
+    46: "Delete",
+    48: "0",
+    49: "1",
+    50: "2",
+    51: "3",
+    52: "4",
+    53: "5",
+    54: "6",
+    55: "7",
+    56: "8",
+    57: "9",
+    65: "A",
+    66: "B",
+    67: "C",
+    68: "D",
+    69: "E",
+    70: "F",
+    71: "G",
+    72: "H",
+    73: "I",
+    74: "J",
+    75: "K",
+    76: "L",
+    77: "M",
+    78: "N",
+    79: "O",
+    80: "P",
+    81: "Q",
+    82: "R",
+    83: "S",
+    84: "T",
+    85: "U",
+    86: "V",
+    87: "W",
+    88: "X",
+    89: "Y",
+    90: "Z",
+    91: "MetaLeft",
+    92: "MetaRight",
+    93: "ContextMenu",
+    96: "Numpad0",
+    97: "Numpad1",
+    98: "Numpad2",
+    99: "Numpad3",
+    100: "Numpad4",
+    101: "Numpad5",
+    102: "Numpad6",
+    103: "Numpad7",
+    104: "Numpad8",
+    105: "Numpad9",
+    106: "NumpadMultiply",
+    107: "NumpadAdd",
+    109: "NumpadSubtract",
+    110: "NumpadDecimal",
+    111: "NumpadDivide",
+    112: "F1",
+    113: "F2",
+    114: "F3",
+    115: "F4",
+    116: "F5",
+    117: "F6",
+    118: "F7",
+    119: "F8",
+    120: "F9",
+    121: "F10",
+    122: "F11",
+    123: "F12",
+    144: "NumLock",
+    145: "ScrollLock",
+    186: "Semicolon",
+    187: "Equal",
+    188: "Comma",
+    189: "Minus",
+    190: "Period",
+    191: "Slash",
+    192: "Backquote",
+    219: "BracketLeft",
+    220: "Backslash",
+    221: "BracketRight",
+    222: "Quote",
+}));
+export var KeyCodeHelper;
+(function (KeyCodeHelper) {
+    KeyCodeHelper[KeyCodeHelper["Backspace"] = 8] = "Backspace";
+    KeyCodeHelper[KeyCodeHelper["Tab"] = 9] = "Tab";
+    KeyCodeHelper[KeyCodeHelper["Enter"] = 13] = "Enter";
+    KeyCodeHelper[KeyCodeHelper["Shift"] = 16] = "Shift";
+    KeyCodeHelper[KeyCodeHelper["Ctrl"] = 17] = "Ctrl";
+    KeyCodeHelper[KeyCodeHelper["Alt"] = 18] = "Alt";
+    KeyCodeHelper[KeyCodeHelper["CapsLock"] = 20] = "CapsLock";
+    KeyCodeHelper[KeyCodeHelper["Escape"] = 27] = "Escape";
+    KeyCodeHelper[KeyCodeHelper["Space"] = 32] = "Space";
+    KeyCodeHelper[KeyCodeHelper["PageUp"] = 33] = "PageUp";
+    KeyCodeHelper[KeyCodeHelper["PageDown"] = 34] = "PageDown";
+    KeyCodeHelper[KeyCodeHelper["End"] = 35] = "End";
+    KeyCodeHelper[KeyCodeHelper["Home"] = 36] = "Home";
+    KeyCodeHelper[KeyCodeHelper["ArrowLeft"] = 37] = "ArrowLeft";
+    KeyCodeHelper[KeyCodeHelper["ArrowUp"] = 38] = "ArrowUp";
+    KeyCodeHelper[KeyCodeHelper["ArrowRight"] = 39] = "ArrowRight";
+    KeyCodeHelper[KeyCodeHelper["ArrowDown"] = 40] = "ArrowDown";
+    KeyCodeHelper[KeyCodeHelper["Insert"] = 45] = "Insert";
+    KeyCodeHelper[KeyCodeHelper["Delete"] = 46] = "Delete";
+    KeyCodeHelper[KeyCodeHelper["Zero"] = 48] = "Zero";
+    KeyCodeHelper[KeyCodeHelper["One"] = 49] = "One";
+    KeyCodeHelper[KeyCodeHelper["Two"] = 50] = "Two";
+    KeyCodeHelper[KeyCodeHelper["Three"] = 51] = "Three";
+    KeyCodeHelper[KeyCodeHelper["Four"] = 52] = "Four";
+    KeyCodeHelper[KeyCodeHelper["Five"] = 53] = "Five";
+    KeyCodeHelper[KeyCodeHelper["Six"] = 54] = "Six";
+    KeyCodeHelper[KeyCodeHelper["Seven"] = 55] = "Seven";
+    KeyCodeHelper[KeyCodeHelper["Eight"] = 56] = "Eight";
+    KeyCodeHelper[KeyCodeHelper["Nine"] = 57] = "Nine";
+    KeyCodeHelper[KeyCodeHelper["A"] = 65] = "A";
+    KeyCodeHelper[KeyCodeHelper["B"] = 66] = "B";
+    KeyCodeHelper[KeyCodeHelper["C"] = 67] = "C";
+    KeyCodeHelper[KeyCodeHelper["D"] = 68] = "D";
+    KeyCodeHelper[KeyCodeHelper["E"] = 69] = "E";
+    KeyCodeHelper[KeyCodeHelper["F"] = 70] = "F";
+    KeyCodeHelper[KeyCodeHelper["G"] = 71] = "G";
+    KeyCodeHelper[KeyCodeHelper["H"] = 72] = "H";
+    KeyCodeHelper[KeyCodeHelper["I"] = 73] = "I";
+    KeyCodeHelper[KeyCodeHelper["J"] = 74] = "J";
+    KeyCodeHelper[KeyCodeHelper["K"] = 75] = "K";
+    KeyCodeHelper[KeyCodeHelper["L"] = 76] = "L";
+    KeyCodeHelper[KeyCodeHelper["M"] = 77] = "M";
+    KeyCodeHelper[KeyCodeHelper["N"] = 78] = "N";
+    KeyCodeHelper[KeyCodeHelper["O"] = 79] = "O";
+    KeyCodeHelper[KeyCodeHelper["P"] = 80] = "P";
+    KeyCodeHelper[KeyCodeHelper["Q"] = 81] = "Q";
+    KeyCodeHelper[KeyCodeHelper["R"] = 82] = "R";
+    KeyCodeHelper[KeyCodeHelper["S"] = 83] = "S";
+    KeyCodeHelper[KeyCodeHelper["T"] = 84] = "T";
+    KeyCodeHelper[KeyCodeHelper["U"] = 85] = "U";
+    KeyCodeHelper[KeyCodeHelper["V"] = 86] = "V";
+    KeyCodeHelper[KeyCodeHelper["W"] = 87] = "W";
+    KeyCodeHelper[KeyCodeHelper["X"] = 88] = "X";
+    KeyCodeHelper[KeyCodeHelper["Y"] = 89] = "Y";
+    KeyCodeHelper[KeyCodeHelper["Z"] = 90] = "Z";
+    KeyCodeHelper[KeyCodeHelper["MetaLeft"] = 91] = "MetaLeft";
+    KeyCodeHelper[KeyCodeHelper["MetaRight"] = 92] = "MetaRight";
+    KeyCodeHelper[KeyCodeHelper["ContextMenu"] = 93] = "ContextMenu";
+    KeyCodeHelper[KeyCodeHelper["Numpad0"] = 96] = "Numpad0";
+    KeyCodeHelper[KeyCodeHelper["Numpad1"] = 97] = "Numpad1";
+    KeyCodeHelper[KeyCodeHelper["Numpad2"] = 98] = "Numpad2";
+    KeyCodeHelper[KeyCodeHelper["Numpad3"] = 99] = "Numpad3";
+    KeyCodeHelper[KeyCodeHelper["Numpad4"] = 100] = "Numpad4";
+    KeyCodeHelper[KeyCodeHelper["Numpad5"] = 101] = "Numpad5";
+    KeyCodeHelper[KeyCodeHelper["Numpad6"] = 102] = "Numpad6";
+    KeyCodeHelper[KeyCodeHelper["Numpad7"] = 103] = "Numpad7";
+    KeyCodeHelper[KeyCodeHelper["Numpad8"] = 104] = "Numpad8";
+    KeyCodeHelper[KeyCodeHelper["Numpad9"] = 105] = "Numpad9";
+    KeyCodeHelper[KeyCodeHelper["NumpadMultiply"] = 106] = "NumpadMultiply";
+    KeyCodeHelper[KeyCodeHelper["NumpadAdd"] = 107] = "NumpadAdd";
+    KeyCodeHelper[KeyCodeHelper["NumpadSubtract"] = 109] = "NumpadSubtract";
+    KeyCodeHelper[KeyCodeHelper["NumpadDecimal"] = 110] = "NumpadDecimal";
+    KeyCodeHelper[KeyCodeHelper["NumpadDivide"] = 111] = "NumpadDivide";
+    KeyCodeHelper[KeyCodeHelper["F1"] = 112] = "F1";
+    KeyCodeHelper[KeyCodeHelper["F2"] = 113] = "F2";
+    KeyCodeHelper[KeyCodeHelper["F3"] = 114] = "F3";
+    KeyCodeHelper[KeyCodeHelper["F4"] = 115] = "F4";
+    KeyCodeHelper[KeyCodeHelper["F5"] = 116] = "F5";
+    KeyCodeHelper[KeyCodeHelper["F6"] = 117] = "F6";
+    KeyCodeHelper[KeyCodeHelper["F7"] = 118] = "F7";
+    KeyCodeHelper[KeyCodeHelper["F8"] = 119] = "F8";
+    KeyCodeHelper[KeyCodeHelper["F9"] = 120] = "F9";
+    KeyCodeHelper[KeyCodeHelper["F10"] = 121] = "F10";
+    KeyCodeHelper[KeyCodeHelper["F11"] = 122] = "F11";
+    KeyCodeHelper[KeyCodeHelper["F12"] = 123] = "F12";
+    KeyCodeHelper[KeyCodeHelper["NumLock"] = 144] = "NumLock";
+    KeyCodeHelper[KeyCodeHelper["ScrollLock"] = 145] = "ScrollLock";
+    KeyCodeHelper[KeyCodeHelper["Semicolon"] = 186] = "Semicolon";
+    KeyCodeHelper[KeyCodeHelper["Equal"] = 187] = "Equal";
+    KeyCodeHelper[KeyCodeHelper["Comma"] = 188] = "Comma";
+    KeyCodeHelper[KeyCodeHelper["Minus"] = 189] = "Minus";
+    KeyCodeHelper[KeyCodeHelper["Period"] = 190] = "Period";
+    KeyCodeHelper[KeyCodeHelper["Slash"] = 191] = "Slash";
+    KeyCodeHelper[KeyCodeHelper["Backquote"] = 192] = "Backquote";
+    KeyCodeHelper[KeyCodeHelper["BracketLeft"] = 219] = "BracketLeft";
+    KeyCodeHelper[KeyCodeHelper["Backslash"] = 220] = "Backslash";
+    KeyCodeHelper[KeyCodeHelper["BracketRight"] = 221] = "BracketRight";
+    KeyCodeHelper[KeyCodeHelper["Quote"] = 222] = "Quote";
+})(KeyCodeHelper || (KeyCodeHelper = {}));

package/node22.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Node 22",
+  "_version": "22.0.0",
+
+  "compilerOptions": {
+    "lib": ["es2023"],
+    "module": "node16",
+    "target": "es2022",
+
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node16"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-native-win-utils",
-  "version": "1.4.0",
+  "version": "2.1.1",
   "author": "Andrew K.",
   "license": "MIT",
   "repository": "https://github.com/T-Rumibul/node-native-win-utils.git",
@@ -29,22 +29,32 @@
     "text recognition",
     "OCR"
   ],
-  "main": "dist/index.js",
+  "exports": {
+    "require": "./dist/index.cjs",
+    "import": "./dist/index.mjs"
+  },
+  "main": "dist/index.cjs",
   "types": "dist/index.d.ts",
   "gypfile": true,
   "scripts": {
     "install": "node-gyp-build",
-    "build": "node-gyp clean && npx prebuildify --napi && npx tsc && node ./dllCopy.js",
-    "test": "jest"
+    "build": "node-gyp clean && npx prebuildify --napi && node ./buildHelpers/dllCopy.js && npm run buildts",
+    "buildts": "node ./buildHelpers/cjsCompatBuild.js",
+    "test": "tap run "
   },
   "dependencies": {
-    "node-addon-api": "^6.1.0",
-    "node-gyp": "^9.3.1",
-    "node-gyp-build": "4.8.0"
+    "node-addon-api": "^8.3.1",
+    "node-gyp": "^11.1.0",
+    "node-gyp-build": "^4.8.4"
   },
   "devDependencies": {
     "@types/node": "^20.2.5",
-    "jest": "^29.7.0",
-    "node-api-headers": "^1.5.0"
+    "node-api-headers": "^1.5.0",
+    "tap": "^21.1.0"
+  },
+  "tap": {
+    "plugin": [
+      "@tapjs/sinon"
+    ]
   }
 }

package/src/cpp/keyboard.cpp

@@ -2,166 +2,167 @@
 #include <Windows.h>
 #include <thread>
 #include <iostream>
+#include <unordered_set>
+#include <mutex>
+#include <atomic>
 
-// Global variable to store the JavaScript callback function
+// Global variables for JavaScript callback functions
 Napi::ThreadSafeFunction globalJsCallbackKeyDown;
 Napi::ThreadSafeFunction globalJsCallbackKeyUp;
 
-// Global variable to store the previous key state
-bool isKeyPressed = false;
-bool handleKeyUp = false;
-bool handleKeyDown = false;
-bool monitorThreadRunning = false;
-int previousKeyState;
-LRESULT CALLBACK KeyboardHookProc(int nCode, WPARAM wParam, LPARAM lParam)
-{
-  if (nCode >= 0)
-  {
-    if (wParam == WM_KEYDOWN)
-    {
-      KBDLLHOOKSTRUCT *kbdStruct = (KBDLLHOOKSTRUCT *)lParam;
-      int keyCode = kbdStruct->vkCode;
-
-      // Handle the keyCode here or call your JavaScript callback
-      // std::cout << "Key Code: " << keyCode << std::endl;
-
-      if (keyCode != previousKeyState || !isKeyPressed)
-      {
-        isKeyPressed = true;
-        previousKeyState = keyCode;
-        if (handleKeyDown)
-        {
-          int *keyCodeCopy = new int(keyCode); // Create a copy of the keyCode value
-
-          napi_status status = globalJsCallbackKeyDown.BlockingCall(
-              keyCodeCopy,
-              [](Napi::Env env, Napi::Function jsCallback, int *keyCodePtr)
-              {
-                Napi::HandleScope scope(env);
-                int keyCode = *keyCodePtr;
-                jsCallback.Call({Napi::Number::New(env, keyCode)});
-                delete keyCodePtr; // Clean up the dynamically allocated keyCode copy
-              });
-
-          if (status != napi_ok)
-          {
-            // Handle the error
-          }
-        }
-      }
+// Thread-safe tracking of pressed keys
+std::mutex pressedKeysMutex;
+std::unordered_set<int> pressedKeys;
+
+// Thread management
+std::atomic<bool> handleKeyDown(false);
+std::atomic<bool> handleKeyUp(false);
+std::atomic<bool> monitorThreadRunning(false);
+DWORD monitorThreadId = 0;
+
+
+// Environment Cleanup Hook
+void CleanupHook() {
+    handleKeyDown = false;
+    handleKeyUp = false;
+    if(globalJsCallbackKeyDown) {
+        globalJsCallbackKeyDown.Release();
     }
-    else if (wParam == WM_KEYUP)
-    {
-      KBDLLHOOKSTRUCT *kbdStruct = (KBDLLHOOKSTRUCT *)lParam;
-      int keyCode = kbdStruct->vkCode;
-
-      if (keyCode == previousKeyState)
-      {
-        isKeyPressed = false;
-        if (handleKeyUp)
-        {
-          int *keyCodeCopy = new int(keyCode); // Create a copy of the keyCode value
-          napi_status status = globalJsCallbackKeyUp.BlockingCall(
-              keyCodeCopy,
-              [](Napi::Env env, Napi::Function jsCallback, int *keyCodePtr)
-              {
-                Napi::HandleScope scope(env);
-                int keyCode = *keyCodePtr;
-                jsCallback.Call({Napi::Number::New(env, keyCode)});
-                delete keyCodePtr; // Clean up the dynamically allocated keyCode copy
-              });
-
-          if (status != napi_ok)
-          {
-            // Handle the error
-          }
+    if(globalJsCallbackKeyUp) {
+        globalJsCallbackKeyUp.Release();
+    }
+    if (monitorThreadRunning) {
+        PostThreadMessage(monitorThreadId, WM_QUIT, 0, 0);
+        
+    }
+}
+
+
+LRESULT CALLBACK KeyboardHookProc(int nCode, WPARAM wParam, LPARAM lParam) {
+    if (nCode >= 0) {
+        KBDLLHOOKSTRUCT* kbdStruct = reinterpret_cast<KBDLLHOOKSTRUCT*>(lParam);
+        int keyCode = kbdStruct->vkCode;
+
+        if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) {
+            std::lock_guard<std::mutex> lock(pressedKeysMutex);
+            if (pressedKeys.insert(keyCode).second) {
+                if (handleKeyDown) {
+                    // Allocate copy on heap for thread-safe transfer
+                    int* keyCopy = new int(keyCode);
+                    globalJsCallbackKeyDown.BlockingCall(keyCopy,
+                        [](Napi::Env env, Napi::Function jsCallback, int* keyCode) {
+                            jsCallback.Call({Napi::Number::New(env, *keyCode)});
+                            delete keyCode; // Clean up allocated memory
+                        });
+                }
+            }
+        } 
+        else if (wParam == WM_KEYUP || wParam == WM_SYSKEYUP) {
+            std::lock_guard<std::mutex> lock(pressedKeysMutex);
+            if (pressedKeys.erase(keyCode)) {
+                if (handleKeyUp) {
+                    // Allocate copy on heap for thread-safe transfer
+                    int* keyCopy = new int(keyCode);
+                    globalJsCallbackKeyUp.BlockingCall(keyCopy,
+                        [](Napi::Env env, Napi::Function jsCallback, int* keyCode) {
+                            jsCallback.Call({Napi::Number::New(env, *keyCode)});
+                            delete keyCode; // Clean up allocated memory
+                        });
+                }
+            }
         }
-      }
     }
-  }
+    return CallNextHookEx(NULL, nCode, wParam, lParam);
+}
+
+void MonitorKeyboardEvents() {
+    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
+
+    HHOOK keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProc, NULL, 0);
+    if (!keyboardHook) {
+        CoUninitialize();
+        monitorThreadRunning = false;
+        return;
+    }
+
+    MSG msg;
+    while (GetMessage(&msg, NULL, 0, 0) > 0) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
 
-  return CallNextHookEx(NULL, nCode, wParam, lParam);
+    UnhookWindowsHookEx(keyboardHook);
+    CoUninitialize();
+    monitorThreadRunning = false;
+    monitorThreadId = 0;
 }
 
-// Function to monitor keyboard events
-void MonitorKeyboardEvents()
-{
-  HHOOK keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProc, NULL, 0);
-  if (keyboardHook == NULL)
-  {
-    // Error setting hook
-    return;
-  }
+Napi::Value SetKeyDownCallback(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::Function jsCallback = info[0].As<Napi::Function>();
 
-  // Main loop to process keyboard events
-  MSG message;
-  while (GetMessage(&message, NULL, 0, 0) > 0)
-  {
-    TranslateMessage(&message);
-    DispatchMessage(&message);
-  }
+       // Release existing callback
+    if (globalJsCallbackKeyDown) {
+        globalJsCallbackKeyDown.Release();
+    }
+    globalJsCallbackKeyDown = Napi::ThreadSafeFunction::New(
+        env, jsCallback, "KeyDownCallback", 0, 1);
+    handleKeyDown = true;
+
+    if (!monitorThreadRunning.exchange(true)) {
+        std::thread monitorThread(MonitorKeyboardEvents);
+        monitorThreadId = GetThreadId(monitorThread.native_handle());
+        monitorThread.detach();
+    }
 
-  UnhookWindowsHookEx(keyboardHook);
+    return env.Undefined();
 }
 
-// Function called from JavaScript to set the callback function
-Napi::Value SetKeyDownCallback(const Napi::CallbackInfo &info)
-{
-  Napi::Env env = info.Env();
+Napi::Value SetKeyUpCallback(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::Function jsCallback = info[0].As<Napi::Function>();
+    
 
-  // Get the callback function from the arguments
-  Napi::Function jsCallback = info[0].As<Napi::Function>();
-
-  // Create a ThreadSafeFunction with the JavaScript callback
-  globalJsCallbackKeyDown = Napi::ThreadSafeFunction::New(
-      env,
-      jsCallback,
-      "KeyDownCallback",
-      0,
-      1,
-      [](Napi::Env)
-      {
-        // Finalizer callback (optional)
-      });
-  handleKeyDown = true;
-  if (!monitorThreadRunning)
-  {
-    std::thread monitorThread(MonitorKeyboardEvents);
-    monitorThread.detach();
+       // Release existing callback
+    if (globalJsCallbackKeyUp) {
+        globalJsCallbackKeyUp.Release();
+    }
 
-    monitorThreadRunning = true;
-  }
+    globalJsCallbackKeyUp = Napi::ThreadSafeFunction::New(
+        env, jsCallback, "KeyUpCallback", 0, 1);
+    handleKeyUp = true;
+
+    if (!monitorThreadRunning.exchange(true)) {
+        std::thread monitorThread(MonitorKeyboardEvents);
+        monitorThreadId = GetThreadId(monitorThread.native_handle());
+        monitorThread.detach();
+    }
 
-  return env.Undefined();
+    return env.Undefined();
 }
 
-// Function called from JavaScript to set the callback function
-Napi::Value SetKeyUpCallback(const Napi::CallbackInfo &info)
-{
-  Napi::Env env = info.Env();
+Napi::Value UnsetKeyDownCallback(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    handleKeyDown = false;
+    globalJsCallbackKeyDown.Release();
 
-  // Get the callback function from the arguments
-  Napi::Function jsCallback = info[0].As<Napi::Function>();
-
-  // Create a ThreadSafeFunction with the JavaScript callback
-  globalJsCallbackKeyUp = Napi::ThreadSafeFunction::New(
-      env,
-      jsCallback,
-      "KeyUpCallback",
-      0,
-      1,
-      [](Napi::Env)
-      {
-        // Finalizer callback (optional)
-      });
-  handleKeyUp = true;
-  if (!monitorThreadRunning)
-  {
-    std::thread monitorThread(MonitorKeyboardEvents);
-    monitorThread.detach();
-    monitorThreadRunning = true;
-  }
-  return env.Undefined();
+    if (!handleKeyUp && monitorThreadRunning) {
+        PostThreadMessage(monitorThreadId, WM_QUIT, 0, 0);
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value UnsetKeyUpCallback(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    handleKeyUp = false;
+    globalJsCallbackKeyUp.Release();
+
+    if (!handleKeyDown && monitorThreadRunning) {
+        PostThreadMessage(monitorThreadId, WM_QUIT, 0, 0);
+    }
+
+    return env.Undefined();
 }
 
 Napi::Value TypeString(const Napi::CallbackInfo &info) {

package/src/cpp/main.cpp

@@ -1,6 +1,6 @@
 #include <napi.h>
 #include <helpers.cpp>
-#include <captureWindow.cpp>
+#include <screenshot.cpp>
 #include <getWindowData.cpp>
 #include <keyboard.cpp>
 #include <mouse.cpp>
@@ -11,8 +11,11 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
 {
     exports.Set("getWindowData", Napi::Function::New(env, GetWindowData));
     exports.Set("captureWindowN", Napi::Function::New(env, CaptureWindow));
-    exports.Set("keyDownHandler", Napi::Function::New(env, SetKeyDownCallback));
-    exports.Set("keyUpHandler", Napi::Function::New(env, SetKeyUpCallback));
+    exports.Set("captureScreenAsync", Napi::Function::New(env, CaptureScreenAsync));
+    exports.Set("setKeyDownCallback", Napi::Function::New(env, SetKeyDownCallback));
+    exports.Set("setKeyUpCallback", Napi::Function::New(env, SetKeyUpCallback));
+    exports.Set("unsetKeyUpCallback", Napi::Function::New(env, UnsetKeyUpCallback));
+    exports.Set("unsetKeyDownCallback", Napi::Function::New(env, UnsetKeyDownCallback));
     exports.Set("mouseMove", Napi::Function::New(env, MoveMouse));
     exports.Set("mouseClick", Napi::Function::New(env, ClickMouse));
     exports.Set("mouseDrag", Napi::Function::New(env, DragMouse));
@@ -26,6 +29,9 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     exports.Set("drawRectangle", Napi::Function::New(env, DrawRectangle));
     exports.Set("getRegion", Napi::Function::New(env, GetRegion));
     exports.Set("textRecognition", Napi::Function::New(env, TextRecognition));
+    static GdiPlusInitializer gdiplusInitializer;
+     // Register cleanup hook
+    env.AddCleanupHook(CleanupHook);
     return exports;
 }