node-native-win-utils 2.1.0 → 2.1.2

package/README.md

@@ -1,6 +1,6 @@
 
 [![License][license-src]][license-href] 
-![Node-API v6 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v6%20Badge.svg)
+![Node-API v8 Badge](assets/Node-API%20v8%20Badge.svg)
 
 #### USDT TRC20 - TYAJ3K3MZraJhWimxxeCKcJ2SYABkVsrzi
 ####  USDT TON - UQDokuYZXr4OHvfslDqUoFYcp1_F8tcjQPk_TvqSSDk7SIa7

package/dist/index.cjs

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenCV = exports.KeyboardListener = exports.textRecognition = exports.KeyCodeHelper = exports.rawPressKey = exports.typeString = exports.mouseDrag = exports.mouseClick = exports.mouseMove = exports.captureWindowN = exports.getWindowData = void 0;
+exports.OpenCV = exports.KeyboardListener = exports.captureScreenAsync = exports.textRecognition = exports.KeyCodeHelper = exports.rawPressKey = exports.typeString = exports.mouseDrag = exports.mouseClick = exports.mouseMove = exports.captureWindowN = exports.getWindowData = void 0;
 exports.captureWindow = captureWindow;
 exports.keyPress = keyPress;
 exports.captureScreenToFile = captureScreenToFile;
@@ -17,9 +17,10 @@ const keyCodes_cjs_1 = require("./keyCodes.cjs");
 Object.defineProperty(exports, "KeyCodeHelper", { enumerable: true, get: function () { return keyCodes_cjs_1.KeyCodeHelper; } });
 const dirnameLocal_cjs_1 = require("./dirnameLocal.cjs");
 const bindings = nodeGypBuild(path_1.default.resolve(dirnameLocal_cjs_1.__dirnameLocal, ".."));
-const { setKeyDownCallback, setKeyUpCallback, unsetKeyDownCallback, unsetKeyUpCallback, getWindowData, captureWindowN, captureScreenAsync, mouseMove, mouseClick, mouseDrag, typeString, pressKey, imread, imwrite, matchTemplate, blur, bgrToGray, drawRectangle, getRegion, textRecognition } = bindings;
+const { setKeyDownCallback, setKeyUpCallback, unsetKeyDownCallback, unsetKeyUpCallback, getWindowData, captureWindowN, captureScreenAsync, mouseMove, mouseClick, mouseDrag, typeString, pressKey, imread, imwrite, matchTemplate, blur, bgrToGray, drawRectangle, getRegion, textRecognition, equalizeHist } = bindings;
 exports.getWindowData = getWindowData;
 exports.captureWindowN = captureWindowN;
+exports.captureScreenAsync = captureScreenAsync;
 exports.mouseMove = mouseMove;
 exports.mouseClick = mouseClick;
 exports.mouseDrag = mouseDrag;
@@ -56,21 +57,36 @@ function captureScreenToFile(path) {
     });
 }
 /**
- * Represents a class to listen to keyboard events.
+ * 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 events_1.default {
+    /**
+     * 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) => {
+            // Look up the human-readable key name from a mapping.
             const keyName = keyCodes_cjs_1.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) => {
+            // Look up the human-readable key name from a mapping.
             const keyName = keyCodes_cjs_1.keyCodes.get(keyCode.toString());
+            // Emit the 'keyUp' event to all registered JavaScript listeners.
             this.emit("keyUp", {
                 keyCode,
                 keyName,
@@ -78,13 +94,33 @@ class KeyboardListenerPrivate extends events_1.default {
         });
     }
 }
+/**
+ * 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.
+     */
     static listenerInstance = 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)
+        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();
@@ -146,6 +182,13 @@ class OpenCV {
     bgrToGray() {
         return new OpenCV(bgrToGray(this.imageData));
     }
+    /**
+      * Equalize the Histogram by using the OpenCV function cv::equalizeHist.
+      * @returns A new OpenCV instance with the equalized image data.
+      */
+    equalizeHist() {
+        return new OpenCV(equalizeHist(this.imageData));
+    }
     /**
      * Draws a rectangle on the image.
      * @param start - The starting point of the rectangle.

package/dist/index.d.cts

@@ -78,11 +78,12 @@ 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 EqualizeHist = (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>;
-declare const getWindowData: GetWindowData, captureWindowN: CaptureWindow, mouseMove: MouseMove, mouseClick: MouseClick, mouseDrag: MouseDrag, typeString: TypeString, textRecognition: TextRecognition;
+declare const getWindowData: GetWindowData, captureWindowN: CaptureWindow, captureScreenAsync: CaptureScreenAsync, mouseMove: MouseMove, mouseClick: MouseClick, mouseDrag: MouseDrag, typeString: TypeString, textRecognition: TextRecognition;
 declare const rawPressKey: PressKey;
 /**
  * Captures a window and saves it to a file.
@@ -97,20 +98,31 @@ declare function captureWindow(windowName: string, path: string): boolean;
  * @returns True if the capture and save operation is successful, otherwise false.
  */
 declare function captureScreenToFile(path: string): Promise<boolean>;
+/**
+ * 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 {
     /**
-     * Event: Fires when a key is pressed down.
+     * 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 - The callback function to handle the event.
+     * @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;
     /**
-     * Event: Fires when a key is released.
+     * 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 - The callback function to handle the event.
+     * @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;
@@ -118,15 +130,43 @@ interface KeyboardListenerPrivate extends EventEmitter {
     }) => void): this;
 }
 /**
- * Represents a class to listen to keyboard events.
+ * 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
  */
 declare 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();
 }
+/**
+ * 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.
+ */
 declare class KeyboardListener {
+    /**
+     * Holds the singleton instance of KeyboardListenerPrivate.
+     */
     private static listenerInstance;
+    /**
+     * 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(): KeyboardListenerPrivate;
+    /**
+     * 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(): void;
 }
 /**
@@ -166,6 +206,11 @@ declare class OpenCV {
      * @returns A new OpenCV instance with the grayscale image data.
      */
     bgrToGray(): OpenCV;
+    /**
+      * Equalize the Histogram by using the OpenCV function cv::equalizeHist.
+      * @returns A new OpenCV instance with the equalized image data.
+      */
+    equalizeHist(): OpenCV;
     /**
      * Draws a rectangle on the image.
      * @param start - The starting point of the rectangle.
@@ -188,4 +233,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, KeyboardListener, OpenCV };
+export { getWindowData, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, captureScreenAsync, KeyboardListener, OpenCV };

package/dist/index.d.mts

@@ -78,11 +78,12 @@ 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 EqualizeHist = (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>;
-declare const getWindowData: GetWindowData, captureWindowN: CaptureWindow, mouseMove: MouseMove, mouseClick: MouseClick, mouseDrag: MouseDrag, typeString: TypeString, textRecognition: TextRecognition;
+declare const getWindowData: GetWindowData, captureWindowN: CaptureWindow, captureScreenAsync: CaptureScreenAsync, mouseMove: MouseMove, mouseClick: MouseClick, mouseDrag: MouseDrag, typeString: TypeString, textRecognition: TextRecognition;
 declare const rawPressKey: PressKey;
 /**
  * Captures a window and saves it to a file.
@@ -97,20 +98,31 @@ declare function captureWindow(windowName: string, path: string): boolean;
  * @returns True if the capture and save operation is successful, otherwise false.
  */
 declare function captureScreenToFile(path: string): Promise<boolean>;
+/**
+ * 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 {
     /**
-     * Event: Fires when a key is pressed down.
+     * 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 - The callback function to handle the event.
+     * @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;
     /**
-     * Event: Fires when a key is released.
+     * 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 - The callback function to handle the event.
+     * @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;
@@ -118,15 +130,43 @@ interface KeyboardListenerPrivate extends EventEmitter {
     }) => void): this;
 }
 /**
- * Represents a class to listen to keyboard events.
+ * 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
  */
 declare 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();
 }
+/**
+ * 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.
+ */
 declare class KeyboardListener {
+    /**
+     * Holds the singleton instance of KeyboardListenerPrivate.
+     */
     private static listenerInstance;
+    /**
+     * 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(): KeyboardListenerPrivate;
+    /**
+     * 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(): void;
 }
 /**
@@ -166,6 +206,11 @@ declare class OpenCV {
      * @returns A new OpenCV instance with the grayscale image data.
      */
     bgrToGray(): OpenCV;
+    /**
+      * Equalize the Histogram by using the OpenCV function cv::equalizeHist.
+      * @returns A new OpenCV instance with the equalized image data.
+      */
+    equalizeHist(): OpenCV;
     /**
      * Draws a rectangle on the image.
      * @param start - The starting point of the rectangle.
@@ -188,4 +233,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, KeyboardListener, OpenCV };
+export { getWindowData, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, captureScreenAsync, 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 } = bindings;
+const { setKeyDownCallback, setKeyUpCallback, unsetKeyDownCallback, unsetKeyUpCallback, getWindowData, captureWindowN, captureScreenAsync, mouseMove, mouseClick, mouseDrag, typeString, pressKey, imread, imwrite, matchTemplate, blur, bgrToGray, drawRectangle, getRegion, textRecognition, equalizeHist } = bindings;
 const rawPressKey = pressKey;
 /**
  * Captures a window and saves it to a file.
@@ -39,21 +39,36 @@ function captureScreenToFile(path) {
     });
 }
 /**
- * Represents a class to listen to keyboard events.
+ * 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) => {
+            // Look up the human-readable key name from a mapping.
             const keyName = 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) => {
+            // Look up the human-readable key name from a mapping.
             const keyName = keyCodes.get(keyCode.toString());
+            // Emit the 'keyUp' event to all registered JavaScript listeners.
             this.emit("keyUp", {
                 keyCode,
                 keyName,
@@ -61,13 +76,33 @@ class KeyboardListenerPrivate extends EventEmitter {
         });
     }
 }
+/**
+ * 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.
+     */
     static listenerInstance = 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)
+        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();
@@ -128,6 +163,13 @@ class OpenCV {
     bgrToGray() {
         return new OpenCV(bgrToGray(this.imageData));
     }
+    /**
+      * Equalize the Histogram by using the OpenCV function cv::equalizeHist.
+      * @returns A new OpenCV instance with the equalized image data.
+      */
+    equalizeHist() {
+        return new OpenCV(equalizeHist(this.imageData));
+    }
     /**
      * Draws a rectangle on the image.
      * @param start - The starting point of the rectangle.
@@ -174,4 +216,4 @@ function keyPress(keyCode, repeat) {
         return resolve(true);
     });
 }
-export { getWindowData, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, KeyboardListener, OpenCV };
+export { getWindowData, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, captureScreenAsync, KeyboardListener, OpenCV };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-native-win-utils",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "author": "Andrew K.",
   "license": "MIT",
   "repository": "https://github.com/T-Rumibul/node-native-win-utils.git",

package/src/cpp/main.cpp

@@ -26,6 +26,7 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     exports.Set("matchTemplate", Napi::Function::New(env, MatchTemplate));
     exports.Set("blur", Napi::Function::New(env, Blur));
     exports.Set("bgrToGray", Napi::Function::New(env, BgrToGray));
+    exports.Set("equalizeHist", Napi::Function::New(env, EqualizeHist));
     exports.Set("drawRectangle", Napi::Function::New(env, DrawRectangle));
     exports.Set("getRegion", Napi::Function::New(env, GetRegion));
     exports.Set("textRecognition", Napi::Function::New(env, TextRecognition));

package/src/cpp/opencv.cpp

@@ -234,6 +234,52 @@ Napi::Value BgrToGray(const Napi::CallbackInfo &info)
     return result;
 }
 
+Napi::Value EqualizeHist(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsObject())
+    {
+        Napi::TypeError::New(env, "Invalid arguments. Expected: (object)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object srcObj = info[0].As<Napi::Object>();
+
+    if (!srcObj.Has("data") || !srcObj.Has("width") || !srcObj.Has("height"))
+    {
+        Napi::TypeError::New(env, "Invalid image data object. Expected properties: 'data', 'width', 'height'").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (!srcObj.Get("data").IsTypedArray())
+    {
+        Napi::TypeError::New(env, "TypedArray expected for 'data' property").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    int width = srcObj.Get("width").ToNumber().Int32Value();
+    int height = srcObj.Get("height").ToNumber().Int32Value();
+
+    cv::Mat src(height, width, CV_8UC1, srcObj.Get("data").As<Napi::TypedArray>().ArrayBuffer().Data());
+    cv::Mat dst;
+
+    cv::equalizeHist(src, dst);
+
+    Napi::Object result = Napi::Object::New(env);
+    size_t totalBytes = dst.total() * dst.elemSize();
+    Napi::ArrayBuffer arrayBuffer = Napi::ArrayBuffer::New(env, totalBytes);
+    Napi::Uint8Array uint8Array = Napi::Uint8Array::New(env, totalBytes, arrayBuffer, 0);
+
+    memcpy(uint8Array.Data(), dst.data, totalBytes);
+    result.Set("width", width);
+    result.Set("height", height);
+    result.Set("data", uint8Array);
+    
+    return result;
+}
+
+
 Napi::Value Blur(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();

package/src/index.mts

@@ -120,7 +120,7 @@ export type Blur = (
   sizeY: number
 ) => ImageData;
 export type BgrToGray = (image: ImageData) => ImageData;
-
+export type EqualizeHist = (image: ImageData) => ImageData;
 export type DrawRectangle = (
   image: ImageData,
   start: Point,
@@ -153,7 +153,8 @@ const {
   bgrToGray,
   drawRectangle,
   getRegion,
-  textRecognition
+  textRecognition,
+  equalizeHist
 }: {
   setKeyDownCallback: SetKeyCallback;
   setKeyUpCallback: SetKeyCallback;
@@ -175,6 +176,7 @@ const {
   getRegion: GetRegion;
   textRecognition: TextRecognition;
   captureScreenAsync: CaptureScreenAsync;
+  equalizeHist: EqualizeHist
 } = bindings;
 
 const rawPressKey = pressKey;
@@ -385,6 +387,15 @@ class OpenCV {
     return new OpenCV(bgrToGray(this.imageData));
   }
 
+ /**
+   * Equalize the Histogram by using the OpenCV function cv::equalizeHist.
+   * @returns A new OpenCV instance with the equalized image data.
+   */
+ equalizeHist() {
+  return new OpenCV(equalizeHist(this.imageData));
+}
+
+
   /**
    * Draws a rectangle on the image.
    * @param start - The starting point of the rectangle.
@@ -449,6 +460,7 @@ export {
   KeyCodeHelper,
   textRecognition,
   captureScreenToFile,
+  captureScreenAsync,
   KeyboardListener,
   OpenCV
 };