node-native-win-utils 1.0.3 → 1.1.0

package/README.md

@@ -2,25 +2,23 @@
 
 # Node Native Win Utils
 
-I did it for myself because I didn't feel like dealing with libraries like 'node-ffi' to implement this functionality. Maybe someone will find it useful. I'ts WINDOWS OS ONLY
+I did it for myself because I didn't feel like dealing with libraries like 'node-ffi' to implement this functionality. Maybe someone will find it useful. It's WINDOWS OS ONLY
 
-This package provides a native addon for Node.js that allows you to perform various utility operations on Windows systems. It includes key event listeners, window data retrieval, and window screenshot capture functionality.
+This package is a native addon for Node.js that allows you to perform various utility operations on Windows systems. It includes key event listeners, window data retrieval, window screenshot capture functionality, mouse movement, mouse click, mouse drag, and typing functionality.
 
 ## Installation
 
 You can install the package using npm:
 
 ```shell
-
-npm  install  node-native-win-utils
-
+npm install node-native-win-utils
 ```
 
 ## Usage
 
 ### Importing the Package
 
-To use the package, import the necessary functions and types:
+To use the package, import the necessary functions, types, and classes:
 
 ```javascript
 import {
@@ -28,6 +26,10 @@ import {
   keyUpHandler,
   getWindowData,
   captureWindow,
+  mouseMove,
+  mouseClick,
+  mouseDrag,
+  typeString,
   KeyListener,
 } from "node-native-win-utils";
 ```
@@ -72,6 +74,43 @@ captureWindow("Window Name", "output.png");
 // Output: output.png with a screenshot of the window
 ```
 
+### Mouse Movement
+
+The `mouseMove` function allows you to move the mouse to a specific position on the screen. Provide the `posX` and `posY` coordinates as parameters:
+
+```javascript
+mouseMove(100, 200);
+```
+
+### Mouse Click
+
+The `mouseClick` function allows you to perform a mouse click event. Optionally, you can specify the mouse button as a parameter (`"left"`, `"middle"`, or `"right"`). If no button is specified, a left mouse click is performed by default:
+
+```javascript
+mouseClick(); // Left mouse click
+mouseClick("right"); // Right mouse click
+```
+
+### Mouse Drag
+
+The `mouseDrag` function allows you to simulate dragging the mouse from one position to another. Provide the starting and ending coordinates (`startX`, `startY`, `endX`, `endY`) as parameters. Optionally, you can specify the speed at which the mouse should be dragged:
+
+```javascript
+mouseDrag(100, 200, 300, 400);
+mouseDrag(100, 200, 300, 400, 100); // Drag with speed 100
+```
+
+### Typing
+
+The `typeString` function allows you to simulate typing a string of characters. Provide the string to type as the `stringToType` parameter. Optionally, you can specify
+
+a delay between each character (in milliseconds) using the `delay` parameter:
+
+```javascript
+typeString("Hello, world!");
+typeString("Hello, world!", 100); // Type with a delay of 100ms between characters
+```
+
 ### Key Listener Class
 
 The `KeyListener` class extends the EventEmitter class and simplifies working with the `keyDownHandler` and `keyUpHandler` functions. You can register event listeners for the "keyDown" and "keyUp" events using the `on` method:
@@ -100,6 +139,10 @@ listener.on("keyUp", (data) => {
 | keyUpHandler   | `callback: (keyCode: number) => void`                                                   | `void`                 |
 | getWindowData  | `windowName: string`                                                                    | `WindowData`           |
 | captureWindow  | `windowName: string, outputPath: string`                                                | `void`                 |
+| mouseMove      | `posX: number, posY: number`                                                            | `boolean`              |
+| mouseClick     | `button?: "left" \| "middle" \| "right"`                                                | `boolean`              |
+| mouseDrag      | `startX: number, startY: number, endX: number, endY: number, speed?: number`            | `boolean`              |
+| typeString     | `stringToType: string, delay?: number`                                                  | `boolean`              |
 | KeyListener.on | `event: "keyDown"`,<br>`callback: (data: { keyCode: number; keyName: string }) => void` | `this` (EventListener) |
 | KeyListener.on | `event: "keyUp"`,<br>`callback: (data: { keyCode: number; keyName: string }) => void`   | `this` (EventListener) |
 
@@ -113,6 +156,10 @@ import {
   keyUpHandler,
   getWindowData,
   captureWindow,
+  mouseMove,
+  mouseClick,
+  mouseDrag,
+  typeString,
   KeyListener,
 } from "node-native-win-utils";
 
@@ -144,6 +191,25 @@ captureWindow("My Window", "output.png");
 
 // Output: output.png with a screenshot of the window
 
+// Move the mouse
+
+mouseMove(100, 200);
+
+// Perform mouse click
+
+mouseClick(); // Left mouse click
+mouseClick("right"); // Right mouse click
+
+// Simulate mouse drag
+
+mouseDrag(100, 200, 300, 400);
+mouseDrag(100, 200, 300, 400, 100); // Drag with speed 100
+
+// Simulate typing
+
+typeString("Hello, world!");
+typeString("Hello, world!", 100); // Type with a delay of 100ms between characters
+
 // Use KeyListener class
 
 const listener = new KeyListener();

package/dist/index.d.ts

@@ -10,6 +10,10 @@ export type GetWindowData = (windowName: string) => WindowData;
 export type CaptureWindow = (windowName: string, outputPath: string) => void;
 export type KeyDownHandler = (callback: (keyCode: number) => void) => void;
 export type KeyUpHandler = (callback: (keyCode: number) => void) => void;
+export type MouseMove = (posX: number, posY: number) => boolean;
+export type MouseClick = (button?: "left" | "middle" | "right") => boolean;
+export type TypeString = (stringToType: string, delay?: number) => boolean;
+export type MouseDrag = (starX: number, startY: number, endX: Number, endY: number, speed?: number) => boolean;
 export interface KeyListener extends EventEmitter {
     on(event: "keyDown", callback: (data: {
         keyCode: number;
@@ -20,8 +24,8 @@ export interface KeyListener extends EventEmitter {
         keyName: string;
     }) => void): this;
 }
-declare const keyDownHandler: KeyDownHandler, keyUpHandler: KeyUpHandler, getWindowData: GetWindowData, captureWindow: CaptureWindow;
+declare const keyDownHandler: KeyDownHandler, keyUpHandler: KeyUpHandler, getWindowData: GetWindowData, captureWindow: CaptureWindow, mouseMove: MouseMove, mouseClick: MouseClick, mouseDrag: MouseDrag, typeString: TypeString;
 export declare class KeyListener extends EventEmitter {
     constructor();
 }
-export { keyDownHandler, keyUpHandler, getWindowData, captureWindow };
+export { keyDownHandler, keyUpHandler, getWindowData, captureWindow, mouseMove, mouseClick, mouseDrag, typeString, };

package/dist/index.js

@@ -3,16 +3,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.captureWindow = exports.getWindowData = exports.keyUpHandler = exports.keyDownHandler = exports.KeyListener = void 0;
+exports.typeString = exports.mouseDrag = exports.mouseClick = exports.mouseMove = exports.captureWindow = exports.getWindowData = exports.keyUpHandler = exports.keyDownHandler = exports.KeyListener = void 0;
 const EventEmitter = require("events");
 const path_1 = __importDefault(require("path"));
 const bindings = require("node-gyp-build")(path_1.default.resolve(__dirname, ".."));
 const keyCodes_1 = __importDefault(require("./keyCodes"));
-const { keyDownHandler, keyUpHandler, getWindowData, captureWindow, } = bindings;
+const { keyDownHandler, keyUpHandler, getWindowData, captureWindow, mouseMove, mouseClick, mouseDrag, typeString, } = bindings;
 exports.keyDownHandler = keyDownHandler;
 exports.keyUpHandler = keyUpHandler;
 exports.getWindowData = getWindowData;
 exports.captureWindow = captureWindow;
+exports.mouseMove = mouseMove;
+exports.mouseClick = mouseClick;
+exports.mouseDrag = mouseDrag;
+exports.typeString = typeString;
 class KeyListener extends EventEmitter {
     constructor() {
         super();

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "node-native-win-utils",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "author": "RynerNO",
   "license": "MIT",
+  "git": "https://github.com/RynerNO/node-native-win-utils.git",
   "description": "Native addon for Node.js providing utility operations on Windows systems",
   "keywords": [
     "node.js",

package/src/cpp/capturewindow.cpp

@@ -0,0 +1,183 @@
+#include <napi.h>
+#include <iostream>
+#include <Windows.h>
+#include <dxgi.h>
+#include <inspectable.h>
+#include <dxgi1_2.h>
+#include <d3d11.h>
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.System.h>
+#include <winrt/Windows.Graphics.Capture.h>
+#include <windows.graphics.capture.interop.h>
+#include <windows.graphics.directx.direct3d11.interop.h>
+#include <roerrorapi.h>
+#include <shlobj_core.h>
+#include <dwmapi.h>
+#include <helpers.h>
+
+#pragma comment(lib, "Dwmapi.lib")
+#pragma comment(lib, "windowsapp.lib")
+
+void CaptureWindow(const Napi::CallbackInfo &info)
+{
+
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsString() || !info[1].IsString())
+    {
+        Napi::TypeError::New(env, "Window name and file path must be provided as strings").ThrowAsJavaScriptException();
+        return;
+    }
+
+    std::string windowName = info[0].As<Napi::String>().Utf8Value();
+    std::string filePath = info[1].As<Napi::String>().Utf8Value();
+    std::wstring outputFilePath = ToWChar(filePath);
+    HWND hwndTarget = GetWindowByName(windowName.c_str());
+    // Init COM
+    winrt::init_apartment(winrt::apartment_type::multi_threaded);
+
+    // Create Direct 3D Device
+    winrt::com_ptr<ID3D11Device> d3dDevice;
+
+    winrt::check_hresult(D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, D3D11_CREATE_DEVICE_BGRA_SUPPORT,
+                                           nullptr, 0, D3D11_SDK_VERSION, d3dDevice.put(), nullptr, nullptr));
+
+    winrt::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice device;
+    const auto dxgiDevice = d3dDevice.as<IDXGIDevice>();
+    {
+        winrt::com_ptr<::IInspectable> inspectable;
+        winrt::check_hresult(CreateDirect3D11DeviceFromDXGIDevice(dxgiDevice.get(), inspectable.put()));
+        device = inspectable.as<winrt::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice>();
+    }
+
+    auto idxgiDevice2 = dxgiDevice.as<IDXGIDevice2>();
+    winrt::com_ptr<IDXGIAdapter> adapter;
+    winrt::check_hresult(idxgiDevice2->GetParent(winrt::guid_of<IDXGIAdapter>(), adapter.put_void()));
+    winrt::com_ptr<IDXGIFactory2> factory;
+    winrt::check_hresult(adapter->GetParent(winrt::guid_of<IDXGIFactory2>(), factory.put_void()));
+
+    ID3D11DeviceContext *d3dContext = nullptr;
+    d3dDevice->GetImmediateContext(&d3dContext);
+
+    RECT rect{};
+    DwmGetWindowAttribute(hwndTarget, DWMWA_EXTENDED_FRAME_BOUNDS, &rect, sizeof(RECT));
+    const auto size = winrt::Windows::Graphics::SizeInt32{rect.right - rect.left, rect.bottom - rect.top};
+
+    winrt::Windows::Graphics::Capture::Direct3D11CaptureFramePool m_framePool =
+        winrt::Windows::Graphics::Capture::Direct3D11CaptureFramePool::Create(
+            device,
+            winrt::Windows::Graphics::DirectX::DirectXPixelFormat::B8G8R8A8UIntNormalized,
+            2,
+            size);
+
+    const auto activationFactory = winrt::get_activation_factory<
+        winrt::Windows::Graphics::Capture::GraphicsCaptureItem>();
+    auto interopFactory = activationFactory.as<IGraphicsCaptureItemInterop>();
+    winrt::Windows::Graphics::Capture::GraphicsCaptureItem captureItem = {nullptr};
+    interopFactory->CreateForWindow(hwndTarget, winrt::guid_of<ABI::Windows::Graphics::Capture::IGraphicsCaptureItem>(),
+                                    reinterpret_cast<void **>(winrt::put_abi(captureItem)));
+
+    auto isFrameArrived = false;
+    winrt::com_ptr<ID3D11Texture2D> texture;
+    const auto session = m_framePool.CreateCaptureSession(captureItem);
+    m_framePool.FrameArrived([&](auto &framePool, auto &)
+                             {
+        if (isFrameArrived) return;
+        auto frame = framePool.TryGetNextFrame();
+
+        struct __declspec(uuid("A9B3D012-3DF2-4EE3-B8D1-8695F457D3C1"))
+            IDirect3DDxgiInterfaceAccess : ::IUnknown
+        {
+            virtual HRESULT __stdcall GetInterface(GUID const& id, void** object) = 0;
+        };
+
+        auto access = frame.Surface().as<IDirect3DDxgiInterfaceAccess>();
+        access->GetInterface(winrt::guid_of<ID3D11Texture2D>(), texture.put_void());
+        isFrameArrived = true;
+        return; });
+
+    session.IsCursorCaptureEnabled(false);
+    session.StartCapture();
+
+    // Message pump
+    MSG msg;
+    clock_t timer = clock();
+    while (!isFrameArrived)
+    {
+        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) > 0)
+            DispatchMessage(&msg);
+
+        if (clock() - timer > 20000)
+        {
+            // TODO: try to make here a better error handling
+            return;
+        }
+    }
+
+    session.Close();
+
+    D3D11_TEXTURE2D_DESC capturedTextureDesc;
+    texture->GetDesc(&capturedTextureDesc);
+
+    capturedTextureDesc.Usage = D3D11_USAGE_STAGING;
+    capturedTextureDesc.BindFlags = 0;
+    capturedTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+    capturedTextureDesc.MiscFlags = 0;
+
+    winrt::com_ptr<ID3D11Texture2D> userTexture = nullptr;
+    winrt::check_hresult(d3dDevice->CreateTexture2D(&capturedTextureDesc, NULL, userTexture.put()));
+
+    d3dContext->CopyResource(userTexture.get(), texture.get());
+
+    D3D11_MAPPED_SUBRESOURCE resource;
+    winrt::check_hresult(d3dContext->Map(userTexture.get(), NULL, D3D11_MAP_READ, 0, &resource));
+
+    BITMAPINFO lBmpInfo;
+
+    // BMP 32 bpp
+    ZeroMemory(&lBmpInfo, sizeof(BITMAPINFO));
+    lBmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    lBmpInfo.bmiHeader.biBitCount = 32;
+    lBmpInfo.bmiHeader.biCompression = BI_RGB;
+    lBmpInfo.bmiHeader.biWidth = capturedTextureDesc.Width;
+    lBmpInfo.bmiHeader.biHeight = capturedTextureDesc.Height;
+    lBmpInfo.bmiHeader.biPlanes = 1;
+    lBmpInfo.bmiHeader.biSizeImage = capturedTextureDesc.Width * capturedTextureDesc.Height * 4;
+
+    std::unique_ptr<BYTE> pBuf(new BYTE[lBmpInfo.bmiHeader.biSizeImage]);
+    UINT lBmpRowPitch = capturedTextureDesc.Width * 4;
+    auto sptr = static_cast<BYTE *>(resource.pData);
+    auto dptr = pBuf.get() + lBmpInfo.bmiHeader.biSizeImage - lBmpRowPitch;
+
+    UINT lRowPitch = std::min<UINT>(lBmpRowPitch, resource.RowPitch);
+
+    for (size_t h = 0; h < capturedTextureDesc.Height; ++h)
+    {
+        memcpy_s(dptr, lBmpRowPitch, sptr, lRowPitch);
+        sptr += resource.RowPitch;
+        dptr -= lBmpRowPitch;
+    }
+
+    // Save bitmap buffer into the provided output file path
+    FILE *lfile = nullptr;
+
+    if (auto lerr = _wfopen_s(&lfile, outputFilePath.c_str(), L"wb"); lerr != 0)
+        return;
+
+    if (lfile != nullptr)
+    {
+        BITMAPFILEHEADER bmpFileHeader;
+
+        bmpFileHeader.bfReserved1 = 0;
+        bmpFileHeader.bfReserved2 = 0;
+        bmpFileHeader.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + lBmpInfo.bmiHeader.biSizeImage;
+        bmpFileHeader.bfType = 'MB';
+        bmpFileHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
+
+        fwrite(&bmpFileHeader, sizeof(BITMAPFILEHEADER), 1, lfile);
+        fwrite(&lBmpInfo.bmiHeader, sizeof(BITMAPINFOHEADER), 1, lfile);
+        fwrite(pBuf.get(), lBmpInfo.bmiHeader.biSizeImage, 1, lfile);
+
+        fclose(lfile);
+    }
+}

package/src/cpp/getWindowData.cpp

@@ -0,0 +1,46 @@
+#include <napi.h>
+#include <Windows.h>
+#include <iostream>
+#include <dwmapi.h>
+#include <helpers.h>
+
+Napi::Value GetWindowData(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsString())
+    {
+        Napi::TypeError::New(env, "Window name must be provided as a string").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    std::string windowName = info[0].As<Napi::String>().Utf8Value();
+
+    HWND windowHandle = GetWindowByName(windowName.c_str());
+
+    if (windowHandle == NULL)
+    {
+        Napi::Error::New(env, "Window not found").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    RECT windowRect;
+    DwmGetWindowAttribute(windowHandle, DWMWA_EXTENDED_FRAME_BOUNDS, &windowRect, sizeof(windowRect));
+    HDC hdc = GetDC(windowHandle);
+    int dpiX = GetDeviceCaps(hdc, LOGPIXELSX);
+    int dpiY = GetDeviceCaps(hdc, LOGPIXELSY);
+    ReleaseDC(windowHandle, hdc);
+
+    int width = windowRect.right - windowRect.left;
+    int height = windowRect.bottom - windowRect.top;
+    int x = windowRect.left;
+    int y = windowRect.top;
+
+    Napi::Object result = Napi::Object::New(env);
+    result.Set("width", Napi::Number::New(env, width));
+    result.Set("height", Napi::Number::New(env, height));
+    result.Set("x", Napi::Number::New(env, x));
+    result.Set("y", Napi::Number::New(env, y));
+
+    return result;
+}

package/src/cpp/helpers.cpp

@@ -0,0 +1,15 @@
+
+#include "helpers.h"
+
+std::wstring ToWChar(const std::string &str)
+{
+    int bufferSize = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, NULL, 0);
+    std::wstring wstr(bufferSize, 0);
+    MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, &wstr[0], bufferSize);
+    return wstr;
+}
+
+HWND GetWindowByName(const char *windowName)
+{
+    return FindWindowA(NULL, windowName);
+}

package/src/cpp/helpers.h

@@ -0,0 +1,8 @@
+#include <Windows.h>
+#include <iostream>
+#include <codecvt>
+#include <Windows.h>
+#include <napi.h>
+
+std::wstring ToWChar(const std::string &str);
+HWND GetWindowByName(const char *windowName);

package/src/cpp/keyboard.cpp

@@ -0,0 +1,205 @@
+#include <napi.h>
+#include <Windows.h>
+#include <thread>
+#include <iostream>
+
+// Global variable to store the JavaScript callback function
+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
+          }
+        }
+      }
+    }
+    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
+          }
+        }
+      }
+    }
+  }
+
+  return CallNextHookEx(NULL, nCode, wParam, lParam);
+}
+
+// Function to monitor keyboard events
+void MonitorKeyboardEvents()
+{
+  HHOOK keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProc, NULL, 0);
+  if (keyboardHook == NULL)
+  {
+    // Error setting hook
+    return;
+  }
+
+  // Main loop to process keyboard events
+  MSG message;
+  while (GetMessage(&message, NULL, 0, 0) > 0)
+  {
+    TranslateMessage(&message);
+    DispatchMessage(&message);
+  }
+
+  UnhookWindowsHookEx(keyboardHook);
+}
+
+// Function called from JavaScript to set the callback function
+Napi::Value SetKeyDownCallback(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+
+  // 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();
+
+    monitorThreadRunning = true;
+  }
+
+  return env.Undefined();
+}
+
+// Function called from JavaScript to set the callback function
+Napi::Value SetKeyUpCallback(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+
+  // 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();
+}
+
+Napi::Value TypeString(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsString())
+  {
+    Napi::TypeError::New(env, "You should provide a string to type").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int delay = 15;
+  std::string text = info[0].As<Napi::String>();
+  if (info.Length() > 1 && info[1].IsNumber())
+  {
+    delay = info[1].As<Napi::Number>();
+  }
+  // Convert the string to wide string
+  std::wstring wideText(text.begin(), text.end());
+
+  // Simulate typing by sending keyboard events
+  for (const wchar_t &character : wideText)
+  {
+    INPUT keyboardInput = {0};
+    keyboardInput.type = INPUT_KEYBOARD;
+    keyboardInput.ki.wVk = 0;
+    keyboardInput.ki.wScan = character;
+    keyboardInput.ki.dwFlags = KEYEVENTF_UNICODE;
+    keyboardInput.ki.time = 0; // System will provide the timestamp
+
+    SendInput(1, &keyboardInput, sizeof(keyboardInput));
+
+    keyboardInput.ki.dwFlags = KEYEVENTF_UNICODE | KEYEVENTF_KEYUP;
+    SendInput(1, &keyboardInput, sizeof(keyboardInput));
+
+    // Sleep for 15 milliseconds between each character input
+    Sleep(delay);
+  }
+
+  return Napi::Boolean::New(env, true);
+}

package/src/cpp/main.cpp

@@ -0,0 +1,21 @@
+#include <napi.h>
+#include <helpers.cpp>
+#include "captureWindow.cpp"
+#include <getWindowData.cpp>
+#include <keyboard.cpp>
+#include <mouse.cpp>
+
+Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+    exports.Set("getWindowData", Napi::Function::New(env, GetWindowData));
+    exports.Set("captureWindow", Napi::Function::New(env, CaptureWindow));
+    exports.Set("keyDownHandler", Napi::Function::New(env, SetKeyDownCallback));
+    exports.Set("keyUpHandler", Napi::Function::New(env, SetKeyUpCallback));
+    exports.Set("mouseMove", Napi::Function::New(env, MoveMouse));
+    exports.Set("mouseClick", Napi::Function::New(env, ClickMouse));
+    exports.Set("mouseDrag", Napi::Function::New(env, DragMouse));
+    exports.Set("typeString", Napi::Function::New(env, TypeString));
+    return exports;
+}
+
+NODE_API_MODULE(addon, Init)

package/src/cpp/mouse.cpp

@@ -0,0 +1,175 @@
+// patrially used code from https://github.com/octalmage/robotjs witch is under MIT License Copyright (c) 2014 Jason Stallings
+#include <napi.h>
+#include <windows.h>
+/**
+ * Move the mouse to a specific point.
+ * @param point The coordinates to move the mouse to (x, y).
+ */
+
+Napi::Value MoveMouse(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsNumber() || !info[1].IsNumber())
+    {
+        Napi::TypeError::New(env, "You should provide x and y position of type number").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    int posX = info[0].As<Napi::Number>();
+    int posY = info[1].As<Napi::Number>();
+
+    // Get the screen metrics
+    int screenWidth = GetSystemMetrics(SM_CXSCREEN);
+    int screenHeight = GetSystemMetrics(SM_CYSCREEN);
+
+    // Convert coordinates to absolute values
+    int absoluteX = static_cast<int>((65536 * posX) / screenWidth);
+    int absoluteY = static_cast<int>((65536 * posY) / screenHeight);
+
+    // Move the mouse
+    INPUT mouseInput = {0};
+    mouseInput.type = INPUT_MOUSE;
+    mouseInput.mi.dx = absoluteX;
+    mouseInput.mi.dy = absoluteY;
+    mouseInput.mi.dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE | MOUSEEVENTF_VIRTUALDESK;
+    mouseInput.mi.time = 0; // System will provide the timestamp
+
+    SendInput(1, &mouseInput, sizeof(mouseInput));
+
+    return Napi::Boolean::New(env, true);
+}
+
+Napi::Value ClickMouse(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    std::string button;
+
+    if (info.Length() < 1 || !info[0].IsString())
+        button = "left";
+    else
+        button = info[0].As<Napi::String>();
+
+    WORD mouseEvent = 0;
+
+    if (button == "left")
+    {
+        mouseEvent = MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP;
+    }
+    else if (button == "right")
+    {
+        mouseEvent = MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP;
+    }
+    else if (button == "middle")
+    {
+        mouseEvent = MOUSEEVENTF_MIDDLEDOWN | MOUSEEVENTF_MIDDLEUP;
+    }
+    else
+    {
+        Napi::TypeError::New(env, "Invalid button name").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Perform the mouse click
+    INPUT mouseInput = {0};
+    mouseInput.type = INPUT_MOUSE;
+    mouseInput.mi.dwFlags = mouseEvent;
+    mouseInput.mi.time = 0; // System will provide the timestamp
+
+    SendInput(1, &mouseInput, sizeof(mouseInput));
+
+    return Napi::Boolean::New(env, true);
+}
+
+Napi::Value DragMouse(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 4 || !info[0].IsNumber() || !info[1].IsNumber() || !info[2].IsNumber() || !info[3].IsNumber())
+    {
+        Napi::TypeError::New(env, "You should provide startX, startY, endX, endY").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    int startX = info[0].As<Napi::Number>();
+    int startY = info[1].As<Napi::Number>();
+    int endX = info[2].As<Napi::Number>();
+    int endY = info[3].As<Napi::Number>();
+    int speed = 100;
+    if (info.Length() > 4 && info[4].IsNumber())
+    {
+        speed = info[4].As<Napi::Number>();
+    }
+
+    // Get the screen metrics
+    int screenWidth = GetSystemMetrics(SM_CXSCREEN);
+    int screenHeight = GetSystemMetrics(SM_CYSCREEN);
+
+    // Convert coordinates to absolute values
+    int absoluteStartX = static_cast<int>((65536 * startX) / screenWidth);
+    int absoluteStartY = static_cast<int>((65536 * startY) / screenHeight);
+    int absoluteEndX = static_cast<int>((65536 * endX) / screenWidth);
+    int absoluteEndY = static_cast<int>((65536 * endY) / screenHeight);
+
+    // Calculate the distance and duration based on speed
+    double distanceX = absoluteEndX - absoluteStartX;
+    double distanceY = absoluteEndY - absoluteStartY;
+    double distance = sqrt(distanceX * distanceX + distanceY * distanceY);
+    double duration = distance / speed;
+
+    // Move the mouse to the starting position
+    INPUT startMouseInput = {0};
+    startMouseInput.type = INPUT_MOUSE;
+    startMouseInput.mi.dx = absoluteStartX;
+    startMouseInput.mi.dy = absoluteStartY;
+    startMouseInput.mi.dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE | MOUSEEVENTF_VIRTUALDESK;
+    startMouseInput.mi.time = 0; // System will provide the timestamp
+
+    SendInput(1, &startMouseInput, sizeof(startMouseInput));
+
+    // Perform mouse button down event
+    INPUT mouseDownInput = {0};
+    mouseDownInput.type = INPUT_MOUSE;
+    mouseDownInput.mi.dwFlags = MOUSEEVENTF_LEFTDOWN;
+    mouseDownInput.mi.time = 0; // System will provide the timestamp
+
+    SendInput(1, &mouseDownInput, sizeof(mouseDownInput));
+
+    // Calculate the number of steps based on the duration and desired speed
+    const int steps = 100; // Adjust the number of steps for smoother movement
+
+    // Calculate the incremental values for each step
+    double stepX = distanceX / steps;
+    double stepY = distanceY / steps;
+
+    // Move the mouse in increments to simulate dragging with speed control
+    for (int i = 0; i < steps; ++i)
+    {
+        // Calculate the position for the current step
+        int currentX = static_cast<int>(absoluteStartX + (stepX * i));
+        int currentY = static_cast<int>(absoluteStartY + (stepY * i));
+
+        // Move the mouse to the current position
+        INPUT mouseMoveInput = {0};
+        mouseMoveInput.type = INPUT_MOUSE;
+        mouseMoveInput.mi.dx = currentX;
+        mouseMoveInput.mi.dy = currentY;
+        mouseMoveInput.mi.dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE | MOUSEEVENTF_VIRTUALDESK;
+        mouseMoveInput.mi.time = 0; // System will provide the timestamp
+
+        SendInput(1, &mouseMoveInput, sizeof(mouseMoveInput));
+
+        // Sleep for a short duration to control the speed
+        Sleep(static_cast<DWORD>(duration / steps));
+    }
+
+    // Perform mouse button up event
+    INPUT mouseUpInput = {0};
+    mouseUpInput.type = INPUT_MOUSE;
+    mouseUpInput.mi.dwFlags = MOUSEEVENTF_LEFTUP;
+    mouseUpInput.mi.time = 0; // System will provide the timestamp
+
+    SendInput(1, &mouseUpInput, sizeof(mouseUpInput));
+
+    return Napi::Boolean::New(env, true);
+}