node-native-win-utils 2.1.5 → 2.2.0

package/README.md

@@ -2,17 +2,6 @@
 [![License][license-src]][license-href] 
 ![Node-API v8 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v8%20Badge.svg)
 
-#### USDT TRC20 - TYAJ3K3MZraJhWimxxeCKcJ2SYABkVsrzi
-####  USDT TON - UQDokuYZXr4OHvfslDqUoFYcp1_F8tcjQPk_TvqSSDk7SIa7
-####  BTC - 1A3mNKFdWKXZ7Bcnez8LbWbYHgck1g4GeV
-####  NOT - UQDokuYZXr4OHvfslDqUoFYcp1_F8tcjQPk_TvqSSDk7SIa7
-
-  
-
-####  Will be very thankful for any support
-
-  
-
 # Node Native Win Utils
 
   

package/dist/index.d.mts

@@ -75,6 +75,16 @@ export type Color = [r: number, g: number, b: number];
 export type ROI = [x: number, y: number, width: number, height: number];
 export type Imread = (path: string) => ImageData;
 export type Imwrite = (image: ImageData) => Buffer;
+export type StartMouseListener = (callback: (data: {
+    x: number;
+    y: number;
+    type: string;
+}) => void) => void;
+export type StopMouseListener = (error: {
+    success: boolean;
+    error?: string;
+    errorCode?: number;
+}) => void;
 export type MatchTemplate = (image: ImageData, template: ImageData, method?: number | null, mask?: ImageData) => MatchData;
 export type Blur = (image: ImageData, sizeX: number, sizeY: number) => ImageData;
 export type BgrToGray = (image: ImageData) => ImageData;
@@ -85,7 +95,8 @@ export type DrawRectangle = (image: ImageData, start: Point, end: Point, rgb: Co
 export type GetRegion = (image: ImageData, region: ROI) => ImageData;
 export type TextRecognition = (trainedDataPath: string, dataLang: string, imagePath: string) => string;
 export type CaptureScreenAsync = () => Promise<Buffer>;
-declare const getWindowData: GetWindowData, captureWindowN: CaptureWindow, captureScreenAsync: CaptureScreenAsync, mouseMove: MouseMove, mouseClick: MouseClick, mouseDrag: MouseDrag, typeString: TypeString, textRecognition: TextRecognition;
+export type BringWindowToFront = (windowName: string) => boolean;
+declare const getWindowData: GetWindowData, captureWindowN: CaptureWindow, captureScreenAsync: CaptureScreenAsync, mouseMove: MouseMove, mouseClick: MouseClick, mouseDrag: MouseDrag, typeString: TypeString, textRecognition: TextRecognition, bringWindowToFront: BringWindowToFront, startMouseListener: StartMouseListener, stopMouseListener: StopMouseListener;
 declare const rawPressKey: PressKey;
 /**
  * Captures a window and saves it to a file.
@@ -252,7 +263,7 @@ declare class OpenCV {
       * @returns A new OpenCV instance with the equalized image data.
       */
     equalizeHist(): OpenCV;
-    rgbToHsv(rgb: ColorBound): number[];
+    rgbToHsv(rgb: ColorBound): number[][];
     darkenColor(lowerBound: ColorBound, upperBound: ColorBound, darkenFactor: number): OpenCV;
     /**
      * Draws a rectangle on the image.
@@ -276,4 +287,4 @@ declare class OpenCV {
     imwrite(path: string): void;
 }
 declare function keyPress(keyCode: number, repeat?: number): Promise<boolean>;
-export { getWindowData, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, captureScreenAsync, KeyboardListener, OpenCV };
+export { getWindowData, bringWindowToFront, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, captureScreenAsync, startMouseListener, stopMouseListener, KeyboardListener, OpenCV };

package/dist/index.mjs

@@ -8,7 +8,7 @@ const nodeGypBuild = __require("node-gyp-build");
 import { keyCodes, KeyCodeHelper } from "./keyCodes.mjs";
 import { __dirnameLocal } from "./dirnameLocal.mjs";
 const bindings = nodeGypBuild(path.resolve(__dirnameLocal, ".."));
-const { setKeyDownCallback, setKeyUpCallback, unsetKeyDownCallback, unsetKeyUpCallback, getWindowData, captureWindowN, captureScreenAsync, mouseMove, mouseClick, mouseDrag, typeString, pressKey, imread, imwrite, matchTemplate, blur, bgrToGray, drawRectangle, getRegion, textRecognition, equalizeHist, darkenColor } = bindings;
+const { setKeyDownCallback, setKeyUpCallback, unsetKeyDownCallback, unsetKeyUpCallback, getWindowData, captureWindowN, captureScreenAsync, mouseMove, mouseClick, mouseDrag, typeString, pressKey, imread, imwrite, matchTemplate, blur, bgrToGray, drawRectangle, getRegion, textRecognition, equalizeHist, darkenColor, bringWindowToFront, startMouseListener, stopMouseListener } = bindings;
 const rawPressKey = pressKey;
 /**
  * Captures a window and saves it to a file.
@@ -209,11 +209,8 @@ class OpenCV {
         if (Cmax !== 0)
             Saturation = (delta / Cmax) * 100;
         let Value = Cmax * 100;
-        // 🛠 Convert to OpenCV format
         return [
-            Math.round((Hue / 360) * 179), // Scale H from [0, 360] → [0, 179]
-            Math.round((Saturation / 100) * 255), // Scale S from [0, 100] → [0, 255]
-            Math.round((Value / 100) * 255) // Scale V from [0, 100] → [0, 255]
+            [Hue, Saturation, Value]
         ];
     }
     darkenColor(lowerBound, upperBound, darkenFactor) {
@@ -265,4 +262,4 @@ function keyPress(keyCode, repeat) {
         return resolve(true);
     });
 }
-export { getWindowData, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, captureScreenAsync, KeyboardListener, OpenCV };
+export { getWindowData, bringWindowToFront, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, captureScreenAsync, startMouseListener, stopMouseListener, KeyboardListener, OpenCV };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-native-win-utils",
-  "version": "2.1.5",
+  "version": "2.2.0",
   "author": "Andrew K.",
   "license": "MIT",
   "repository": "https://github.com/T-Rumibul/node-native-win-utils.git",
@@ -43,18 +43,13 @@
     "test": "tap run "
   },
   "dependencies": {
-    "node-addon-api": "^8.3.1",
-    "node-gyp": "^11.1.0",
+    "node-addon-api": "^8.6.0",
+    "node-gyp": "^12.2.0",
     "node-gyp-build": "^4.8.4"
   },
   "devDependencies": {
-    "@types/node": "^20.2.5",
-    "node-api-headers": "^1.5.0",
-    "tap": "^21.1.0"
-  },
-  "tap": {
-    "plugin": [
-      "@tapjs/sinon"
-    ]
+    "@types/node": "^25.3.5",
+    "node-api-headers": "^1.8.0",
+    "tap": "^21.6.2"
   }
 }

package/src/cpp/getWindowData.cpp

@@ -42,5 +42,78 @@ Napi::Value GetWindowData(const Napi::CallbackInfo &info)
     result.Set("x", Napi::Number::New(env, x));
     result.Set("y", Napi::Number::New(env, y));
 
+    return result;
+}
+
+Napi::Value BringWindowToFront(const Napi::CallbackInfo &info)
+{   
+    Napi::Env env = info.Env();
+    Napi::Object result = Napi::Object::New(env);
+
+    auto returnError = [&](const std::string& message, DWORD errorCode = 0) {
+        result.Set("success", false);
+        result.Set("error", message);
+        if (errorCode != 0) {
+            result.Set("errorCode", Napi::Number::New(env, errorCode));
+        }
+        return result;
+    };
+
+    if (info.Length() < 1 || !info[0].IsString())
+    {
+        return returnError("Window name must be provided as a string");
+    }
+
+    std::string windowName = info[0].As<Napi::String>().Utf8Value();
+
+    HWND hWnd = GetWindowByName(windowName.c_str());
+    if (!hWnd || !IsWindow(hWnd))
+    {
+        return returnError("Window not found or invalid: " + windowName);
+    }
+
+    // Restore if minimized
+    if (IsIconic(hWnd))
+    {
+        ShowWindow(hWnd, SW_RESTORE);
+        // Give the window a moment to restore before trying to focus it
+        Sleep(50);
+    }
+
+    HWND fg = GetForegroundWindow();
+
+    // Bug fix 1: must attach the TARGET window's thread, not just the foreground
+    // window's thread. We need a triangle: cur <-> fg thread <-> target thread.
+    DWORD fgThread  = fg ? GetWindowThreadProcessId(fg, nullptr) : 0;
+    DWORD tgtThread = GetWindowThreadProcessId(hWnd, nullptr);
+    DWORD curThread = GetCurrentThreadId();
+
+    // Bug fix 2: attach all relevant thread pairs so input state is fully shared
+    bool attachedFg  = (fgThread  && fgThread  != curThread) ? AttachThreadInput(curThread, fgThread,  TRUE) != 0 : false;
+    bool attachedTgt = (tgtThread && tgtThread != curThread) ? AttachThreadInput(curThread, tgtThread, TRUE) != 0 : false;
+
+    // Bug fix 3: use AllowSetForegroundWindow to explicitly grant permission,
+    // which bypasses Windows' focus-stealing prevention for cross-process calls
+    AllowSetForegroundWindow(ASFW_ANY);
+
+    // Bring the window to front using the full sequence
+    SetForegroundWindow(hWnd);
+    SetActiveWindow(hWnd);
+    BringWindowToTop(hWnd);
+    // Bug fix 4: SetFocus only works reliably once input queues are attached
+    SetFocus(hWnd);
+
+    // Always detach — don't leave threads attached on any code path
+    if (attachedFg)  AttachThreadInput(curThread, fgThread,  FALSE);
+    if (attachedTgt) AttachThreadInput(curThread, tgtThread, FALSE);
+
+    // Verify it actually worked
+    HWND newFg = GetForegroundWindow();
+    if (newFg != hWnd)
+    {
+        return returnError("Window did not come to foreground (focus-stealing prevention may be active)");
+    }
+
+    result.Set("success", true);
     return result;
 }

package/src/cpp/main.cpp

@@ -9,6 +9,7 @@
 
 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("captureScreenAsync", Napi::Function::New(env, CaptureScreenAsync));
@@ -31,6 +32,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));
+    exports.Set("bringWindowToFront", Napi::Function::New(env, BringWindowToFront));
+    exports.Set("startMouseListener", Napi::Function::New(env, StartMouseListener));
+    exports.Set("stopMouseListener", Napi::Function::New(env, StopMouseListener));
     static GdiPlusInitializer gdiplusInitializer;
      // Register cleanup hook
     env.AddCleanupHook(CleanupHook);

package/src/cpp/mouse.cpp

@@ -1,6 +1,11 @@
 // 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>
+
+HHOOK mouseHook;
+Napi::ThreadSafeFunction tsfn;
+static HANDLE hHookThread = NULL;
+static DWORD  hookThreadId = 0;
 /**
  * Move the mouse to a specific point.
  * @param point The coordinates to move the mouse to (x, y).
@@ -173,3 +178,150 @@ Napi::Value DragMouse(const Napi::CallbackInfo &info)
 
     return Napi::Boolean::New(env, true);
 }
+
+
+LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+    if (nCode >= 0)
+    {
+        MSLLHOOKSTRUCT *mouse = (MSLLHOOKSTRUCT *)lParam;
+
+        int x = mouse->pt.x;
+        int y = mouse->pt.y;
+
+        std::string type = "move";
+
+        switch (wParam)
+        {
+        case WM_LBUTTONDOWN:
+            type = "leftDown";
+            break;
+        case WM_LBUTTONUP:
+            type = "leftUp";
+            break;
+        case WM_RBUTTONDOWN:
+            type = "rightDown";
+            break;
+        case WM_RBUTTONUP:
+            type = "rightUp";
+            break;
+        case WM_MBUTTONDOWN:
+            type = "middleDown";
+            break;
+        case WM_MBUTTONUP:
+            type = "middleUp";
+            break;
+        case WM_MOUSEMOVE:
+            type = "move";
+            break;
+        }
+
+        auto callback = [x, y, type](Napi::Env env, Napi::Function jsCallback)
+        {
+            Napi::Object event = Napi::Object::New(env);
+            event.Set("x", x);
+            event.Set("y", y);
+            event.Set("type", type);
+
+            jsCallback.Call({event});
+        };
+
+        tsfn.BlockingCall(callback);
+    }
+
+    return CallNextHookEx(mouseHook, nCode, wParam, lParam);
+}
+
+
+DWORD WINAPI HookThread(LPVOID)
+{
+    mouseHook = SetWindowsHookEx(WH_MOUSE_LL, MouseProc, NULL, 0);
+
+    MSG msg;
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+    UnhookWindowsHookEx(mouseHook);
+    mouseHook = NULL;
+    return 0;
+}
+
+Napi::Value StartMouseListener(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (!info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Callback expected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    // Bug fix: prevent double-start leaking a thread and hook
+    if (hHookThread != NULL)
+    {
+        Napi::TypeError::New(env, "Mouse listener already running").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    Napi::Function callback = info[0].As<Napi::Function>();
+
+    tsfn = Napi::ThreadSafeFunction::New(
+        env,
+        callback,
+        "MouseListener",
+        0,
+        1);
+
+    // Store handle and thread ID so StopMouseListener can signal and wait
+    hHookThread = CreateThread(NULL, 0, HookThread, NULL, 0, &hookThreadId);
+
+    return Napi::Boolean::New(env, true);
+}
+
+
+Napi::Value StopMouseListener(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    Napi::Object result = Napi::Object::New(env);
+
+    if (hHookThread == NULL)
+    {
+        result.Set("success", false);
+        result.Set("error", "No listener is running");
+        return result;
+    }
+
+    // PostThreadMessage with WM_QUIT breaks the GetMessage loop in HookThread,
+    // which then runs UnhookWindowsHookEx and exits
+    if (!PostThreadMessage(hookThreadId, WM_QUIT, 0, 0))
+    {
+        result.Set("success", false);
+        result.Set("error", "Failed to signal hook thread");
+        result.Set("errorCode", Napi::Number::New(env, GetLastError()));
+        return result;
+    }
+
+    // Wait for the thread to fully exit before releasing resources
+    DWORD waitResult = WaitForSingleObject(hHookThread, 3000);
+    if (waitResult != WAIT_OBJECT_0)
+    {
+        // Thread didn't exit in time — force it and warn
+        TerminateThread(hHookThread, 1);
+        result.Set("success", false);
+        result.Set("error", "Hook thread did not exit cleanly, was forcefully terminated");
+    }
+    else
+    {
+        result.Set("success", true);
+    }
+
+    // Release the TSFN so Node.js can garbage collect the JS callback
+    tsfn.Release();
+
+    CloseHandle(hHookThread);
+    hHookThread = NULL;
+    hookThreadId = 0;
+
+    return result;
+}

package/src/index.mts

@@ -107,6 +107,8 @@ export type Imread = (path: string) => ImageData;
 
 export type Imwrite = (image: ImageData) => Buffer;
 
+export type StartMouseListener = (callback: (data: {x: number, y: number, type: string}) => void) => void;
+export type StopMouseListener = () => {success: boolean, error?: string, errorCode?: number};
 export type MatchTemplate = (
   image: ImageData,
   template: ImageData,
@@ -135,7 +137,7 @@ export type GetRegion = (image: ImageData, region: ROI) => ImageData;
 
 export type TextRecognition = (trainedDataPath: string, dataLang: string, imagePath: string) => string;
 export type CaptureScreenAsync = () => Promise<Buffer>;
-
+export type BringWindowToFront = (windowName: string) => boolean;
 const {
   setKeyDownCallback,
   setKeyUpCallback,
@@ -158,7 +160,11 @@ const {
   getRegion,
   textRecognition,
   equalizeHist,
-  darkenColor
+  darkenColor,
+  bringWindowToFront,
+  startMouseListener,
+  stopMouseListener
+  
 }: {
   setKeyDownCallback: SetKeyCallback;
   setKeyUpCallback: SetKeyCallback;
@@ -182,6 +188,9 @@ const {
   captureScreenAsync: CaptureScreenAsync;
   equalizeHist: EqualizeHist;
   darkenColor: DarkenColor;
+  bringWindowToFront: BringWindowToFront;
+  startMouseListener: StartMouseListener;
+  stopMouseListener: StopMouseListener
 } = bindings;
 
 const rawPressKey = pressKey;
@@ -525,6 +534,7 @@ function keyPress(keyCode: number, repeat?: number): Promise<boolean> {
 
 export {
   getWindowData,
+  bringWindowToFront,
   captureWindow,
   captureWindowN,
   mouseMove,
@@ -537,6 +547,8 @@ export {
   textRecognition,
   captureScreenToFile,
   captureScreenAsync,
+  startMouseListener,
+  stopMouseListener,
   KeyboardListener,
   OpenCV
 };