node-native-win-utils 1.0.4 → 1.1.1

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.4",
+  "version": "1.1.1",
   "author": "RynerNO",
   "license": "MIT",
+  "repository": "https://github.com/RynerNO/node-native-win-utils.git",
   "description": "Native addon for Node.js providing utility operations on Windows systems",
   "keywords": [
     "node.js",
@@ -14,7 +15,12 @@
     "window",
     "screenshot",
     "capture",
-    "listener"
+    "listener",
+    "mouse",
+    "movemouse",
+    "click",
+    "keyboard",
+    "mousedrag"
   ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cpp/{keyBoardHandler.cpp → keyboard.cpp}

@@ -162,4 +162,44 @@ Napi::Value SetKeyUpCallback(const Napi::CallbackInfo &info)
     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

@@ -2,7 +2,8 @@
 #include <helpers.cpp>
 #include "captureWindow.cpp"
 #include <getWindowData.cpp>
-#include <keyBoardHandler.cpp>
+#include <keyboard.cpp>
+#include <mouse.cpp>
 
 Napi::Object Init(Napi::Env env, Napi::Object exports)
 {
@@ -10,6 +11,10 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     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;
 }
 

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);
+}