node-native-win-utils 1.4.0 → 2.1.0

package/src/index.mts

@@ -0,0 +1,454 @@
+import EventEmitter from 'events'
+import path  from "path";
+import fs from "fs";
+
+
+// @ts-ignore
+import nodeGypBuild = require('node-gyp-build');
+
+import {keyCodes, KeyCodeHelper} from "./keyCodes.mjs";
+import { __dirnameLocal } from "./dirnameLocal.mjs";
+
+const bindings = nodeGypBuild(path.resolve(__dirnameLocal, ".."));
+
+
+
+
+/**
+ * Represents the data of a window.
+ */
+export type WindowData = {
+  width: number;
+  height: number;
+  x: number;
+  y: number;
+};
+
+/**
+ * Represents the data of an image.
+ */
+export type ImageData = {
+  width: number;
+  height: number;
+  data: Uint8Array;
+};
+
+/**
+ * Represents the result of a template matching operation.
+ */
+export type MatchData = {
+  minValue: number;
+  maxValue: number;
+  minLocation: { x: number; y: number };
+  maxLocation: { x: number; y: number };
+};
+
+export type GetWindowData = (windowName: string) => WindowData;
+
+export type CaptureWindow = (windowName: string) => Buffer;
+
+/**
+ * The handler to listen to key-events.
+ * @param callback - The callback function to handle key-down events.
+ */
+export type SetKeyCallback = (callback: (keyCode: number) => void) => void;
+
+/**
+ * The handler to stop thread listening to key-events.
+ * @param callback - The callback function to handle key-down events.
+ */
+export type UnsetKeyCallback = () => void;
+
+
+/**
+ * Function type for moving the mouse.
+ */
+export type MouseMove = (posX: number, posY: number) => boolean;
+
+/**
+ * Function type for simulating a mouse click.
+ */
+export type MouseClick = (button?: "left" | "middle" | "right") => boolean;
+
+/**
+ * Function type for simulating typing.
+ */
+export type TypeString = (stringToType: string, delay?: number) => boolean;
+
+/**
+ * Function type for simulating key press and release.
+ */
+export type PressKey = (keyCode: number) => boolean;
+
+/**
+ * Function type for simulating a mouse drag operation.
+ */
+export type MouseDrag = (
+  starX: number,
+  startY: number,
+  endX: Number,
+  endY: number,
+  speed?: number
+) => boolean;
+
+/**
+ * Represents a point in a two-dimensional space.
+ */
+export type Point = [x: number, y: number];
+
+export type Color = [r: number, g: number, b: number];
+
+/**
+ * Represents a region of interest in an image.
+ */
+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 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;
+
+export type DrawRectangle = (
+  image: ImageData,
+  start: Point,
+  end: Point,
+  rgb: Color,
+  thickness: number
+) => ImageData;
+export type GetRegion = (image: ImageData, region: ROI) => ImageData;
+
+export type TextRecognition = (trainedDataPath: string, dataLang: string, imagePath: string) => string;
+export type CaptureScreenAsync = () => Promise<Buffer>;
+
+const {
+  setKeyDownCallback,
+  setKeyUpCallback,
+  unsetKeyDownCallback,
+  unsetKeyUpCallback,
+  getWindowData,
+  captureWindowN,
+  captureScreenAsync,
+  mouseMove,
+  mouseClick,
+  mouseDrag,
+  typeString,
+  pressKey,
+  imread,
+  imwrite,
+  matchTemplate,
+  blur,
+  bgrToGray,
+  drawRectangle,
+  getRegion,
+  textRecognition
+}: {
+  setKeyDownCallback: SetKeyCallback;
+  setKeyUpCallback: SetKeyCallback;
+  unsetKeyDownCallback: UnsetKeyCallback;
+  unsetKeyUpCallback: UnsetKeyCallback;
+  getWindowData: GetWindowData;
+  captureWindowN: CaptureWindow;
+  mouseMove: MouseMove;
+  mouseClick: MouseClick;
+  mouseDrag: MouseDrag;
+  typeString: TypeString;
+  pressKey: PressKey;
+  imread: Imread;
+  imwrite: Imwrite;
+  matchTemplate: MatchTemplate;
+  blur: Blur;
+  bgrToGray: BgrToGray;
+  drawRectangle: DrawRectangle;
+  getRegion: GetRegion;
+  textRecognition: TextRecognition;
+  captureScreenAsync: CaptureScreenAsync;
+} = bindings;
+
+const rawPressKey = pressKey;
+
+/**
+ * Captures a window and saves it to a file.
+ * @param windowName - The name of the window to capture.
+ * @param path - The file path to save the captured image.
+ * @returns True if the capture and save operation is successful, otherwise false.
+ */
+function captureWindow(windowName: string, path: string): boolean {
+  const buffer = captureWindowN(windowName);
+  if (!buffer) return false;
+  fs.writeFileSync(path, new Uint8Array(buffer));
+  return true;
+}
+
+
+/**
+ * Captures a screen and saves it to a file.
+ * @param path - The file path to save the captured image.
+ * @returns True if the capture and save operation is successful, otherwise false.
+ */
+function captureScreenToFile(path: string): Promise<boolean> {
+  return new Promise((resolve, reject) => {
+  captureScreenAsync().then((buffer) => {
+    fs.writeFileSync(path, new Uint8Array(buffer))
+    resolve(true)
+  }).catch((err => {
+    reject(err)
+  }));
+  
+  
+})
+}
+
+
+
+/**
+ * Interface representing a private keyboard listener that extends EventEmitter.
+ * It declares event handlers for native keyboard events, which are forwarded from
+ * the C++ bindings using thread-safe callbacks.
+ */
+interface KeyboardListenerPrivate extends EventEmitter {
+  /**
+   * Registers an event handler for the 'keyDown' event.
+   * This event is fired when a key is pressed down. The C++ native binding calls
+   * this callback using a thread-safe mechanism (via Napi::ThreadSafeFunction).
+   * @param event - The event name ('keyDown').
+   * @param callback - Function invoked with an object containing the keyCode and keyName.
+   * @returns The current instance for method chaining.
+   */
+  on(
+    event: "keyDown",
+    callback: (data: { keyCode: number; keyName: string }) => void
+  ): this;
+
+  /**
+   * Registers an event handler for the 'keyUp' event.
+   * This event is fired when a key is released. The underlying C++ code safely
+   * invokes this callback from a background thread using a thread-safe function.
+   * @param event - The event name ('keyUp').
+   * @param callback - Function invoked with an object containing the keyCode and keyName.
+   * @returns The current instance for method chaining.
+   */
+  on(
+    event: "keyUp",
+    callback: (data: { keyCode: number; keyName: string }) => void
+  ): this;
+}
+
+
+/**
+ * Class that implements a private keyboard listener.
+ * This class leverages native C++ bindings to hook into system keyboard events.
+ * The C++ layer uses global ThreadSafeFunction objects to safely dispatch events
+ * (using a dedicated monitoring thread, mutexes, and atomic flags) to JavaScript.
+ * @extends EventEmitter
+ */
+class KeyboardListenerPrivate extends EventEmitter {
+
+  /**
+   * Constructs the keyboard listener and sets up native callbacks.
+   * The callbacks (set via setKeyDownCallback and setKeyUpCallback) are defined in the
+   * C++ binding layer. They are responsible for invoking these JavaScript callbacks
+   * in a thread-safe manner once a key event is detected.
+   */
+  constructor() {
+    super();
+    // Set the callback for key down events.
+    setKeyDownCallback((keyCode: number) => {
+      // Look up the human-readable key name from a mapping.
+      const keyName: string | undefined = keyCodes.get(keyCode.toString());
+      // Emit the 'keyDown' event to all registered JavaScript listeners.
+      this.emit("keyDown", {
+        keyCode,
+        keyName,
+      });
+    });
+    // Set the callback for key up events.
+    setKeyUpCallback((keyCode: number) => {
+      // Look up the human-readable key name from a mapping.
+      const keyName: string | undefined = keyCodes.get(keyCode.toString());
+      // Emit the 'keyUp' event to all registered JavaScript listeners.
+      this.emit("keyUp", {
+        keyCode,
+        keyName,
+      });
+    });
+  }
+}
+
+
+/**
+ * A singleton manager for the KeyboardListenerPrivate instance.
+ * This class ensures that only one native keyboard listener is active at any time.
+ * When the listener is destroyed, it calls unsetKeyDownCallback and unsetKeyUpCallback
+ * to clean up native resources, mirroring the cleanup logic in the C++ bindings.
+ */
+class KeyboardListener {
+  /**
+   * Holds the singleton instance of KeyboardListenerPrivate.
+   */
+  private static listenerInstance: KeyboardListenerPrivate | null = null;
+
+  /**
+   * Returns the singleton instance of KeyboardListenerPrivate. If not already created,
+   * it instantiates a new instance and sets up the native callbacks.
+   * @returns The active KeyboardListenerPrivate instance.
+   */
+  static listener() {
+    if (!this.listenerInstance) {
+      this.listenerInstance = new KeyboardListenerPrivate();
+    }
+    return this.listenerInstance;
+  }
+
+  /**
+   * Destroys the current KeyboardListenerPrivate instance and cleans up native callbacks.
+   * This method calls unsetKeyDownCallback and unsetKeyUpCallback to release any
+   * native resources (such as the global ThreadSafeFunctions) and stops the monitoring thread.
+   */
+  static destroy() {
+    this.listenerInstance = null;
+    unsetKeyDownCallback();
+    unsetKeyUpCallback();
+  }
+}
+
+
+/**
+ * Represents the OpenCV class that provides image processing functionality.
+ */
+class OpenCV {
+  imageData: ImageData;
+
+  /**
+   * Represents the OpenCV class that provides image processing functionality.
+   */
+  constructor(image: string | ImageData) {
+    if (typeof image === "string") {
+      this.imageData = imread(image);
+    } else {
+      this.imageData = image;
+    }
+  }
+
+  /**
+   * The width of the image.
+   */
+  get width() {
+    return this.imageData.width;
+  }
+
+  /**
+   * The height of the image.
+   */
+  get height() {
+    return this.imageData.height;
+  }
+
+  /**
+   * Matches a template image within the current image.
+   * @param template - The template image data to search for.
+   * @param method - The template matching method (optional).
+   * @param mask - The optional mask image data to apply the operation (optional).
+   * @returns The result of the template matching operation.
+   */
+  matchTemplate(template: ImageData, method?: number | null, mask?: ImageData) {
+    return matchTemplate(this.imageData, template, method, mask);
+  }
+
+  /**
+   * Applies a blur filter to the image.
+   * @param sizeX - The horizontal size of the blur filter.
+   * @param sizeY - The vertical size of the blur filter.
+   * @returns A new OpenCV instance with the blurred image data.
+   */
+  blur(sizeX: number, sizeY: number) {
+    return new OpenCV(blur(this.imageData, sizeX, sizeY));
+  }
+
+  /**
+   * Converts the image from BGR to grayscale.
+   * @returns A new OpenCV instance with the grayscale image data.
+   */
+  bgrToGray() {
+    return new OpenCV(bgrToGray(this.imageData));
+  }
+
+  /**
+   * Draws a rectangle on the image.
+   * @param start - The starting point of the rectangle.
+   * @param end - The ending point of the rectangle.
+   * @param rgb - The color (RGB) of the rectangle.
+   * @param thickness - The thickness of the rectangle's border.
+   * @returns A new OpenCV instance with the image containing the drawn rectangle.
+   */
+  drawRectangle(start: Point, end: Point, rgb: Color, thickness: number) {
+    return new OpenCV(
+      drawRectangle(this.imageData, start, end, rgb, thickness)
+    );
+  }
+
+  /**
+   * Extracts a region of interest (ROI) from the image.
+   * @param region - The region of interest defined as [x, y, width, height].
+   * @returns A new OpenCV instance with the extracted region of interest.
+   */
+  getRegion(region: ROI) {
+    return new OpenCV(getRegion(this.imageData, region));
+  }
+
+  /**
+   * Writes the image data to a file.
+   * @param path - The file path to save the image.
+   */
+  imwrite(path: string) {
+    const buffer = imwrite(this.imageData);
+    if (!buffer) return;
+    fs.writeFileSync(path, new Uint8Array(buffer));
+  }
+}
+function keyPress(keyCode: number, repeat?: number): Promise<boolean> {
+  return new Promise((resolve, reject) => {
+        if(!repeat) {
+          let result = rawPressKey(keyCode)
+          if(!result) reject('Something went wrong');
+          return resolve(true);
+        }
+        for(let i = 0; i <= repeat; i++) {
+          let result = rawPressKey(keyCode);
+          if(!result) reject('Something went wrong');
+        }
+        return resolve(true);
+  })
+}
+
+
+
+
+export {
+  getWindowData,
+  captureWindow,
+  captureWindowN,
+  mouseMove,
+  mouseClick,
+  mouseDrag,
+  typeString,
+  keyPress,
+  rawPressKey,
+  KeyCodeHelper,
+  textRecognition,
+  captureScreenToFile,
+  KeyboardListener,
+  OpenCV
+};

package/src/keyCodes.mts

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

package/dllCopy.js

@@ -1,14 +0,0 @@
-const { cp } = require('fs').promises;
-
-async function copyDlls() {
-  try {
-    // Copy a directory recursively
-    await cp('./dll', './prebuilds\\win32-x64', { recursive: true });
-    console.log('Dlls copied to prebuilds location');
-  } catch (err) {
-    console.error('Error:', err.message);
-  }
-}
-
-
-copyDlls()