(#47) Refactored mouse provider

Author: s1hofmann

lib/provider/native/mouse-action-provider.interface.ts

@@ -21,7 +21,7 @@ export interface MouseActionInterface {
    * @param {Point} p The point to which the mouse pointer should be set
    * @memberof MouseActionInterface
    */
-  setMousePosition(p: Point): void;
+  setMousePosition(p: Point): Promise<void>;
 
   /**
    * currentMousePosition should return the current mouse pointer position
@@ -36,67 +36,67 @@ export interface MouseActionInterface {
    *
    * @memberof MouseActionInterface
    */
-  leftClick(): void;
+  leftClick(): Promise<void>;
 
   /**
    * rightClick should allow to perform a right click via OS event
    *
    * @memberof MouseActionInterface
    */
-  rightClick(): void;
+  rightClick(): Promise<void>;
 
   /**
    * middleClick should allow to perform a middle click via OS event
    *
    * @memberof MouseActionInterface
    */
-  middleClick(): void;
+  middleClick(): Promise<void>;
 
   /**
    * scrollUp should allow to perform an upward mouse scroll
    *
    * @param {number} amount The scroll amount
    * @memberof MouseActionInterface
    */
-  scrollUp(amount: number): void;
+  scrollUp(amount: number): Promise<void>;
 
   /**
    * scrollDown should allow to perform an downward mouse scroll
    *
    * @param {number} amount The scroll amount
    * @memberof MouseActionInterface
    */
-  scrollDown(amount: number): void;
+  scrollDown(amount: number): Promise<void>;
 
   /**
    * scrollLeft should allow to perform a left mouse scroll
    *
    * @param {number} amount The scroll amount
    * @memberof MouseActionInterface
    */
-  scrollLeft(amount: number): void;
+  scrollLeft(amount: number): Promise<void>;
 
   /**
    * scrollRight should perform a right mouse scroll
    *
    * @param {number} amount The scroll amount
    * @memberof MouseActionInterface
    */
-  scrollRight(amount: number): void;
+  scrollRight(amount: number): Promise<void>;
 
   /**
    * pressButton should allow to press and hold a mouse button
    *
    * @param {Button} btn The button to press and hold
    * @memberof MouseActionInterface
    */
-  pressButton(btn: Button): void;
+  pressButton(btn: Button): Promise<void>;
 
   /**
    * releaseButton should allow to release a pressed button
    *
    * @param {Button} btn The button to release
    * @memberof MouseActionInterface
    */
-  releaseButton(btn: Button): void;
+  releaseButton(btn: Button): Promise<void>;
 }

lib/provider/native/robotjs-mouse-action.class.ts

@@ -12,54 +12,131 @@ export class MouseAction implements MouseActionInterface {
     [[Button.LEFT, "left"], [Button.MIDDLE, "middle"], [Button.RIGHT, "right"]],
   );
 
-  constructor() {}
+  constructor() {
+  }
 
   public setMouseDelay(delay: number): void {
     robot.setMouseDelay(delay);
   }
 
-  public setMousePosition(p: Point): void {
-    robot.moveMouse(p.x, p.y);
+  public setMousePosition(p: Point): Promise<void> {
+    return new Promise<void>(((resolve, reject) => {
+      try {
+        robot.moveMouse(p.x, p.y);
+        resolve();
+      } catch (e) {
+        reject(e);
+      }
+    }));
   }
 
   public currentMousePosition(): Promise<Point> {
-    const position = robot.getMousePos();
-    return Promise.resolve(new Point(position.x, position.y));
+    return new Promise<Point>(((resolve, reject) => {
+      try {
+        const position = robot.getMousePos();
+        resolve(new Point(position.x, position.y));
+      } catch (e) {
+        reject(e);
+      }
+    }));
   }
 
-  public leftClick(): void {
-    robot.mouseClick(MouseAction.buttonLookup(Button.LEFT));
+  public leftClick(): Promise<void> {
+    return new Promise<void>(((resolve, reject) => {
+      try {
+        robot.mouseClick(MouseAction.buttonLookup(Button.LEFT));
+        resolve();
+      } catch (e) {
+        reject(e);
+      }
+    }));
   }
 
-  public rightClick(): void {
-    robot.mouseClick(MouseAction.buttonLookup(Button.RIGHT));
+  public rightClick(): Promise<void> {
+    return new Promise<void>(((resolve, reject) => {
+      try {
+        robot.mouseClick(MouseAction.buttonLookup(Button.RIGHT));
+        resolve();
+      } catch (e) {
+        reject(e);
+      }
+    }));
   }
 
-  public middleClick(): void {
-    robot.mouseClick(MouseAction.buttonLookup(Button.MIDDLE));
+  public middleClick(): Promise<void> {
+    return new Promise<void>(((resolve, reject) => {
+      try {
+        robot.mouseClick(MouseAction.buttonLookup(Button.MIDDLE));
+        resolve();
+      } catch (e) {
+        reject(e);
+      }
+    }));
   }
 
-  public pressButton(btn: Button): void {
-    robot.mouseToggle("down", MouseAction.buttonLookup(btn));
+  public pressButton(btn: Button): Promise<void> {
+    return new Promise<void>(((resolve, reject) => {
+      try {
+        robot.mouseToggle("down", MouseAction.buttonLookup(btn));
+        resolve();
+      } catch (e) {
+        reject(e);
+      }
+    }));
   }
 
-  public releaseButton(btn: Button): void {
-    robot.mouseToggle("up", MouseAction.buttonLookup(btn));
+  public releaseButton(btn: Button): Promise<void> {
+    return new Promise<void>(((resolve, reject) => {
+      try {
+        robot.mouseToggle("up", MouseAction.buttonLookup(btn));
+        resolve();
+      } catch (e) {
+        reject(e);
+      }
+    }));
   }
 
-  public scrollUp(amount: number): void {
-    robot.scrollMouse(0, amount);
+  public scrollUp(amount: number): Promise<void> {
+    return new Promise<void>(((resolve, reject) => {
+      try {
+        robot.scrollMouse(0, amount);
+        resolve();
+      } catch (e) {
+        reject(e);
+      }
+    }));
   }
 
-  public scrollDown(amount: number): void {
-    robot.scrollMouse(0, -amount);
+  public scrollDown(amount: number): Promise<void> {
+    return new Promise<void>(((resolve, reject) => {
+      try {
+        robot.scrollMouse(0, -amount);
+        resolve();
+      } catch (e) {
+        reject(e);
+      }
+    }));
   }
 
-  public scrollLeft(amount: number): void {
-    robot.scrollMouse(-amount, 0);
+  public scrollLeft(amount: number): Promise<void> {
+    return new Promise<void>(((resolve, reject) => {
+      try {
+        robot.scrollMouse(-amount, 0);
+        resolve();
+      } catch (e) {
+        reject(e);
+      }
+    }));
   }
 
-  public scrollRight(amount: number): void {
-    robot.scrollMouse(amount, 0);
+  public scrollRight(amount: number): Promise<void> {
+    return new Promise<void>(((resolve, reject) => {
+      try {
+        robot.scrollMouse(amount, 0);
+        resolve();
+      } catch (e) {
+        reject(e);
+      }
+    }));
   }
 }