(#40) Fixed names to use libnut instead of robotjs

Author: s1hofmann

Diff for: lib/adapter/native.adapter.class.spec.ts

@@ -2,13 +2,13 @@ import { Button } from "../button.enum";
 import { Key } from "../key.enum";
 import { Point } from "../point.class";
 import { ClipboardAction } from "../provider/native/clipboardy-clipboard-action.class";
-import { KeyboardAction } from "../provider/native/robotjs-keyboard-action.class";
-import { MouseAction } from "../provider/native/robotjs-mouse-action.class";
+import { KeyboardAction } from "../provider/native/libnut-keyboard-action.class";
+import { MouseAction } from "../provider/native/libnut-mouse-action.class";
 import { NativeAdapter } from "./native.adapter.class";
 
 jest.mock("../provider/native/clipboardy-clipboard-action.class");
-jest.mock("../provider/native/robotjs-mouse-action.class");
-jest.mock("../provider/native/robotjs-keyboard-action.class");
+jest.mock("../provider/native/libnut-mouse-action.class");
+jest.mock("../provider/native/libnut-keyboard-action.class");
 
 describe("NativeAdapter class", () => {
   it("should delegate calls to setMouseDelay", async () => {

Diff for: lib/adapter/native.adapter.class.ts

@@ -5,8 +5,8 @@ import { ClipboardActionProvider } from "../provider/native/clipboard-action-pro
 import { ClipboardAction } from "../provider/native/clipboardy-clipboard-action.class";
 import { KeyboardActionProvider } from "../provider/native/keyboard-action-provider.interface";
 import { MouseActionProvider } from "../provider/native/mouse-action-provider.interface";
-import { KeyboardAction } from "../provider/native/robotjs-keyboard-action.class";
-import { MouseAction } from "../provider/native/robotjs-mouse-action.class";
+import { KeyboardAction } from "../provider/native/libnut-keyboard-action.class";
+import { MouseAction } from "../provider/native/libnut-mouse-action.class";
 
 /**
  * {@link NativeAdapter} serves as an abstraction layer for all OS level interactions.

Diff for: lib/adapter/vision.adapter.class.spec.ts

@@ -1,12 +1,12 @@
 import { Image } from "../image.class";
 import { MatchRequest } from "../match-request.class";
-import { ScreenAction } from "../provider/native/robotjs-screen-action.class";
+import { ScreenAction } from "../provider/native/libnut-screen-action.class";
 import { TemplateMatchingFinder } from "../provider/opencv/template-matching-finder.class";
 import { Region } from "../region.class";
 import { VisionAdapter } from "./vision.adapter.class";
 
 jest.mock("../provider/opencv/template-matching-finder.class");
-jest.mock("../provider/native/robotjs-screen-action.class");
+jest.mock("../provider/native/libnut-screen-action.class");
 
 describe("VisionAdapter class", () => {
   it("should delegate calls to grabScreen", () => {

Diff for: lib/adapter/vision.adapter.class.ts

@@ -1,7 +1,7 @@
 import { Image } from "../image.class";
 import { MatchRequest } from "../match-request.class";
 import { MatchResult } from "../match-result.class";
-import { ScreenAction } from "../provider/native/robotjs-screen-action.class";
+import { ScreenAction } from "../provider/native/libnut-screen-action.class";
 import { ScreenActionProvider } from "../provider/native/screen-action-provider.interface";
 import { DataSink } from "../provider/opencv/data-sink.interface";
 import { FinderInterface } from "../provider/opencv/finder.interface";

Diff for: lib/provider/native/robotjs-keyboard-action.class.ts renamed to lib/provider/native/libnut-keyboard-action.class.ts

@@ -1,4 +1,4 @@
-import robot = require("@nut-tree/libnut");
+import libnut = require("@nut-tree/libnut");
 import { Key } from "../../key.enum";
 import { KeyboardActionProvider } from "./keyboard-action-provider.interface";
 
@@ -135,7 +135,7 @@ export class KeyboardAction implements KeyboardActionProvider {
         const nativeKey = KeyboardAction.keyLookup(key);
         const modifierKeys = this.mapModifierKeys(...modifiers);
         if (nativeKey) {
-          robot.keyToggle(nativeKey, event, modifierKeys);
+          libnut.keyToggle(nativeKey, event, modifierKeys);
         }
         resolve();
       } catch (e) {
@@ -150,7 +150,7 @@ export class KeyboardAction implements KeyboardActionProvider {
   public type(input: string): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       try {
-        robot.typeString(input);
+        libnut.typeString(input);
         resolve();
       } catch (e) {
         reject(e);
@@ -166,7 +166,7 @@ export class KeyboardAction implements KeyboardActionProvider {
         const nativeKey = KeyboardAction.keyLookup(key);
         const modifierKeys = KeyboardAction.mapModifierKeys(...modifiers);
         if (nativeKey) {
-          robot.keyTap(nativeKey, modifierKeys);
+          libnut.keyTap(nativeKey, modifierKeys);
         }
         resolve();
       } catch (e) {
@@ -202,6 +202,6 @@ export class KeyboardAction implements KeyboardActionProvider {
   }
 
   public setKeyboardDelay(delay: number): void {
-    robot.setKeyboardDelay(delay);
+    libnut.setKeyboardDelay(delay);
   }
 }

Diff for: lib/provider/native/robotjs-keyboard.action.class.spec.ts renamed to lib/provider/native/libnut-keyboard.action.class.spec.ts

@@ -1,30 +1,30 @@
-import robot = require("@nut-tree/libnut");
+import libnut = require("@nut-tree/libnut");
 import { Key } from "../../key.enum";
-import { KeyboardAction } from "./robotjs-keyboard-action.class";
+import { KeyboardAction } from "./libnut-keyboard-action.class";
 
 jest.mock("@nut-tree/libnut");
 
 beforeEach(() => {
   jest.resetAllMocks();
 });
 
-describe("robotjs keyboard action", () => {
+describe("libnut keyboard action", () => {
   describe("click", () => {
-    it("should forward the keyTap call to robotjs for a known key", () => {
+    it("should forward the keyTap call to libnut for a known key", () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
       SUT.click(Key.A);
 
       // THEN
-      expect(robot.keyTap).toBeCalledTimes(1);
+      expect(libnut.keyTap).toBeCalledTimes(1);
     });
 
-    it("should reject on robotjs errors", async () => {
+    it("should reject on libnut errors", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
-      robot.keyTap = jest.fn(() => {
+      libnut.keyTap = jest.fn(() => {
         throw new Error("Test error");
       });
 
@@ -34,20 +34,20 @@ describe("robotjs keyboard action", () => {
       expect(SUT.click(Key.A)).rejects.toThrowError("Test error");
     });
 
-    it("should not forward the keyTap call to robotjs for an unknown key", () => {
+    it("should not forward the keyTap call to libnut for an unknown key", () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
       SUT.click(Key.Add);
 
       // THEN
-      expect(robot.keyTap).not.toBeCalled();
+      expect(libnut.keyTap).not.toBeCalled();
     });
   });
 
   describe("type", () => {
-    it("should forward the type call to robotjs", () => {
+    it("should forward the type call to libnut", () => {
       // GIVEN
       const SUT = new KeyboardAction();
       const payload = "testInput";
@@ -56,14 +56,14 @@ describe("robotjs keyboard action", () => {
       SUT.type(payload);
 
       // THEN
-      expect(robot.typeString).toBeCalledTimes(1);
-      expect(robot.typeString).toBeCalledWith(payload);
+      expect(libnut.typeString).toBeCalledTimes(1);
+      expect(libnut.typeString).toBeCalledWith(payload);
     });
 
-    it("should reject on robotjs errors", async () => {
+    it("should reject on libnut errors", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
-      robot.typeString = jest.fn(() => {
+      libnut.typeString = jest.fn(() => {
         throw new Error("Test error");
       });
 
@@ -75,16 +75,16 @@ describe("robotjs keyboard action", () => {
   });
 
   describe("pressKey", () => {
-    it("should forward the pressKey call to robotjs for a known key", () => {
+    it("should forward the pressKey call to libnut for a known key", () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
       SUT.pressKey(Key.A);
 
       // THEN
-      expect(robot.keyToggle).toBeCalledTimes(1);
-      expect(robot.keyToggle).toBeCalledWith(KeyboardAction.keyLookup(Key.A), "down", []);
+      expect(libnut.keyToggle).toBeCalledTimes(1);
+      expect(libnut.keyToggle).toBeCalledWith(KeyboardAction.keyLookup(Key.A), "down", []);
     });
 
     it("should treat a list of keys as modifiers + the actual key to press", () => {
@@ -95,26 +95,26 @@ describe("robotjs keyboard action", () => {
       SUT.pressKey(Key.LeftControl, Key.A);
 
       // THEN
-      expect(robot.keyToggle).toBeCalledTimes(1);
-      expect(robot.keyToggle)
+      expect(libnut.keyToggle).toBeCalledTimes(1);
+      expect(libnut.keyToggle)
         .toBeCalledWith(KeyboardAction.keyLookup(Key.A), "down", [KeyboardAction.keyLookup(Key.LeftControl)]);
     });
 
-    it("should not forward the pressKey call to robotjs for an unknown key", () => {
+    it("should not forward the pressKey call to libnut for an unknown key", () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
       SUT.pressKey(Key.Add);
 
       // THEN
-      expect(robot.keyToggle).not.toBeCalled();
+      expect(libnut.keyToggle).not.toBeCalled();
     });
 
-    it("should reject on robotjs errors", async () => {
+    it("should reject on libnut errors", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
-      robot.keyToggle = jest.fn(() => {
+      libnut.keyToggle = jest.fn(() => {
         throw new Error("Test error");
       });
 
@@ -126,16 +126,16 @@ describe("robotjs keyboard action", () => {
   });
 
   describe("releaseKey", () => {
-    it("should forward the releaseKey call to robotjs for a known key", () => {
+    it("should forward the releaseKey call to libnut for a known key", () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
       SUT.releaseKey(Key.A);
 
       // THEN
-      expect(robot.keyToggle).toBeCalledTimes(1);
-      expect(robot.keyToggle).toBeCalledWith(KeyboardAction.keyLookup(Key.A), "up", []);
+      expect(libnut.keyToggle).toBeCalledTimes(1);
+      expect(libnut.keyToggle).toBeCalledWith(KeyboardAction.keyLookup(Key.A), "up", []);
     });
 
     it("should treat a list of keys as modifiers + the actual key to release", () => {
@@ -146,26 +146,26 @@ describe("robotjs keyboard action", () => {
       SUT.releaseKey(Key.LeftControl, Key.A);
 
       // THEN
-      expect(robot.keyToggle).toBeCalledTimes(1);
-      expect(robot.keyToggle)
+      expect(libnut.keyToggle).toBeCalledTimes(1);
+      expect(libnut.keyToggle)
         .toBeCalledWith(KeyboardAction.keyLookup(Key.A), "up", [KeyboardAction.keyLookup(Key.LeftControl)]);
     });
 
-    it("should not forward the releaseKey call to robotjs for an unknown key", () => {
+    it("should not forward the releaseKey call to libnut for an unknown key", () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
       SUT.releaseKey(Key.Add);
 
       // THEN
-      expect(robot.keyToggle).not.toBeCalled();
+      expect(libnut.keyToggle).not.toBeCalled();
     });
 
-    it("should reject on robotjs errors", async () => {
+    it("should reject on libnut errors", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
-      robot.keyToggle = jest.fn(() => {
+      libnut.keyToggle = jest.fn(() => {
         throw new Error("Test error");
       });