Merge pull request #54 from nut-tree/feature/53/api_overhaul

Feature/53/api overhaul

Author: s1hofmann

Diff for: README.md

@@ -28,13 +28,13 @@ The following snippet shows a valid NUT example (on macOS)
 ```js
 "use strict";
 
-const { keyboard, Key, mouse, movement } = require("@nut-tree/nut-js");
+const { keyboard, Key, mouse, left, right, up, down } = require("@nut-tree/nut-js");
 
 const square = async () => {
-  await mouse.move(movement.right(500));
-  await mouse.move(movement.down(500));
-  await mouse.move(movement.left(500));
-  await mouse.move(movement.up(500));
+  await mouse.move(right(500));
+  await mouse.move(down(500));
+  await mouse.move(left(500));
+  await mouse.move(up(500));
 };
 
 const openSpotlight = async () => {

Diff for: index.e2e.spec.ts

@@ -1,8 +1,7 @@
-import { assert, Key, keyboard, Location, mouse, movement, screen } from "./index";
+import { assert, centerOf, Key, keyboard, mouse, screen, straightTo } from "./index";
 
 const openXfceMenu = async () => {
-  const menu = await screen.find("menu.png");
-  await mouse.move(await movement.straightTo(Location.centerOf(menu)));
+  await mouse.move(straightTo(centerOf(screen.find("menu.png"))));
   await mouse.leftClick();
   await mouse.leftClick();
 };
@@ -14,22 +13,18 @@ const run = async (cmd: string) => {
 };
 
 const calculate = async () => {
-  const plus = await screen.find("plus.png");
-  await mouse.move(await movement.straightTo(Location.centerOf(plus)));
+  await mouse.move(straightTo(centerOf(screen.find("plus.png"))));
   await mouse.leftClick();
-  const one = await screen.find("one.png");
-  await mouse.move(await movement.straightTo(Location.centerOf(one)));
+  await mouse.move(straightTo(centerOf(screen.find("one.png"))));
   await mouse.leftClick();
-  const zero = await screen.find("zero.png");
-  await mouse.move(await movement.straightTo(Location.centerOf(zero)));
+  await mouse.move(straightTo(centerOf(screen.find("zero.png"))));
   await mouse.leftClick();
   await mouse.leftClick();
   await keyboard.type(Key.Enter);
 };
 
 const close = async () => {
-  const x = await screen.find("close.png");
-  await mouse.move(await movement.straightTo(Location.centerOf(x)));
+  await mouse.move(straightTo(centerOf(screen.find("close.png"))));
   await mouse.leftClick();
 };
 

Diff for: index.ts

@@ -4,28 +4,40 @@ import { Assert } from "./lib/assert.class";
 import { Clipboard } from "./lib/clipboard.class";
 import { Keyboard } from "./lib/keyboard.class";
 import { Mouse } from "./lib/mouse.class";
-import { Movement } from "./lib/movement.class";
+import { createMovementApi } from "./lib/movement.function";
 import { Screen } from "./lib/screen.class";
 import { LineHelper } from "./lib/util/linehelper.class";
 
 export { jestMatchers } from "./lib/expect/jest.matcher.function";
 export { Image } from "./lib/image.class";
 export { Key } from "./lib/key.enum";
-export { Location } from "./lib/location.class";
+export { centerOf, randomPointIn } from "./lib/location.function";
 export { LocationParameters } from "./lib/locationparameters.class";
-export { Movement } from "./lib/movement.class";
-export { MovementType } from "./lib/movementtype.class";
+export { linear } from "./lib/movementtype.function";
 export { Point } from "./lib/point.class";
 export { Region } from "./lib/region.class";
 
 const screenActions = new VisionAdapter();
 const nativeActions = new NativeAdapter();
+const lineHelper = new LineHelper();
 
 const clipboard = new Clipboard(nativeActions);
 const keyboard = new Keyboard(nativeActions);
 const mouse = new Mouse(nativeActions);
-const movement = new Movement(nativeActions, new LineHelper());
 const screen = new Screen(screenActions);
 const assert = new Assert(screen);
 
-export { clipboard, keyboard, mouse, movement, screen, assert };
+const {straightTo, up, down, left, right} = createMovementApi(nativeActions, lineHelper);
+
+export {
+  clipboard,
+  keyboard,
+  mouse,
+  screen,
+  assert,
+  straightTo,
+  up,
+  down,
+  left,
+  right,
+};

Diff for: lib/keyboard.class.spec.ts

@@ -9,15 +9,15 @@ beforeEach(() => {
 });
 
 describe("Keyboard", () => {
-  it("should have a default delay of 500 ms", () => {
+  it("should have a default delay of 300 ms", () => {
     // GIVEN
     const adapterMock = new NativeAdapter();
     const SUT = new Keyboard(adapterMock);
 
     // WHEN
 
     // THEN
-    expect(SUT.config.autoDelayMs).toEqual(500);
+    expect(SUT.config.autoDelayMs).toEqual(300);
   });
 
   it("should pass input strings down to the type call.", async () => {
@@ -38,6 +38,7 @@ describe("Keyboard", () => {
 
   it("should pass multiple input strings down to the type call.", async () => {
     // GIVEN
+    jest.setTimeout(10000);
     const adapterMock = new NativeAdapter();
     const SUT = new Keyboard(adapterMock);
     const payload = ["Test input!", "Array test2"];

Diff for: lib/keyboard.class.ts

@@ -1,5 +1,6 @@
 import { NativeAdapter } from "./adapter/native.adapter.class";
 import { Key } from "./key.enum";
+import { sleep } from "./sleep.function";
 
 type StringOrKey = string[] | Key[];
 
@@ -10,24 +11,20 @@ const inputIsString = (input: string[] | Key[]): input is string[] => {
 export class Keyboard {
 
   public config = {
-    autoDelayMs: 500,
+    autoDelayMs: 300,
   };
 
-  private lastAction: number;
-
   constructor(private nativeAdapter: NativeAdapter) {
     this.nativeAdapter.setKeyboardDelay(this.config.autoDelayMs);
-    this.lastAction = Date.now();
   }
 
   public type(...input: StringOrKey): Promise<Keyboard> {
     return new Promise<Keyboard>(async (resolve, reject) => {
       try {
         if (inputIsString(input)) {
           for (const char of input.join(" ").split("")) {
-            await this.nextTick();
+            await sleep(this.config.autoDelayMs);
             await this.nativeAdapter.type(char);
-            this.updateTick();
           }
         } else {
           await this.nativeAdapter.click(...input as Key[]);
@@ -60,18 +57,4 @@ export class Keyboard {
       }
     });
   }
-
-  private updateTick() {
-    this.lastAction = Date.now();
-  }
-
-  private async nextTick(): Promise<void> {
-    return new Promise<void>(resolve => {
-      let current = Date.now();
-      while (current - this.lastAction < this.config.autoDelayMs) {
-        current = Date.now();
-      }
-      resolve();
-    });
-  }
 }

Diff for: lib/location.class.ts

@@ -1,4 +1,4 @@
-import { Location } from "./location.class";
+import { centerOf, randomPointIn } from "./location.function";
 import { Point } from "./point.class";
 import { Region } from "./region.class";
 
@@ -7,12 +7,12 @@ describe("Location", () => {
     const expected = new Point(2, 2);
     const testRegion = new Region(0, 0, 4, 4);
 
-    expect(Location.centerOf(testRegion)).toEqual(expected);
+    expect(centerOf(testRegion)).resolves.toEqual(expected);
   });
 
-  it("should return a random point inside of an area.", () => {
+  it("should return a random point inside of an area.", async () => {
     const testRegion = new Region(100, 20, 50, 35);
-    const result = Location.randomPointIn(testRegion);
+    const result = await randomPointIn(testRegion);
     expect(result.x).toBeGreaterThanOrEqual(testRegion.left);
     expect(result.x).toBeLessThanOrEqual(testRegion.left + testRegion.width);
     expect(result.y).toBeGreaterThanOrEqual(testRegion.top);

Diff for: lib/location.class.spec.ts renamed to lib/location.function.spec.ts

@@ -0,0 +1,18 @@
+import { Point } from "./point.class";
+import { Region } from "./region.class";
+
+export const centerOf = async (target: Region | Promise<Region>): Promise<Point> => {
+  const targetRegion = await target;
+  const x = Math.floor(targetRegion.left + targetRegion.width / 2);
+  const y = Math.floor(targetRegion.top + targetRegion.height / 2);
+
+  return new Point(x, y);
+};
+
+export const randomPointIn = async (target: Region | Promise<Region>): Promise<Point> => {
+  const targetRegion = await target;
+  const x = Math.floor(targetRegion.left + Math.random() * targetRegion.width);
+  const y = Math.floor(targetRegion.top + Math.random() * targetRegion.height);
+
+  return new Point(x, y);
+};

Diff for: lib/location.function.ts

@@ -1,19 +1,17 @@
 import { NativeAdapter } from "./adapter/native.adapter.class";
 import { Button } from "./button.enum";
-import { MovementType } from "./movementtype.class";
+import { linear } from "./movementtype.function";
 import { Point } from "./point.class";
+import { sleep } from "./sleep.function";
 
 export class Mouse {
   public config = {
     autoDelayMs: 100,
     mouseSpeed: 1000,
   };
 
-  private lastAction: number;
-
   constructor(private native: NativeAdapter) {
     this.native.setMouseDelay(0);
-    this.lastAction = Date.now();
   }
 
   public async setPosition(target: Point): Promise<Mouse> {
@@ -31,16 +29,16 @@ export class Mouse {
     return this.native.currentMousePosition();
   }
 
-  public async move(path: Point[], movementType = MovementType.linear): Promise<Mouse> {
+  public async move(path: Point[] | Promise<Point[]>, movementType = linear): Promise<Mouse> {
     return new Promise<Mouse>(async (resolve, reject) => {
       try {
-        const timeSteps = movementType(path.length, this.config.mouseSpeed);
-        for (let idx = 0; idx < path.length; ++idx) {
-          const node = path[idx];
+        const pathSteps = await path;
+        const timeSteps = movementType(pathSteps.length, this.config.mouseSpeed);
+        for (let idx = 0; idx < pathSteps.length; ++idx) {
+          const node = pathSteps[idx];
           const minTime = timeSteps[idx];
-          await this.waitForNextTick(minTime);
+          await sleep(minTime);
           await this.native.setMousePosition(node);
-          await this.updateTick();
         }
         resolve(this);
       } catch (e) {
@@ -51,19 +49,17 @@ export class Mouse {
 
   public async leftClick(): Promise<Mouse> {
     return new Promise<Mouse>(async resolve => {
-      await this.waitForNextTick(this.config.autoDelayMs);
+      await sleep(this.config.autoDelayMs);
       await this.native.leftClick();
-      await this.updateTick();
       resolve(this);
     });
   }
 
   public async rightClick(): Promise<Mouse> {
     return new Promise<Mouse>(async (resolve, reject) => {
       try {
-        await this.waitForNextTick(this.config.autoDelayMs);
+        await sleep(this.config.autoDelayMs);
         await this.native.rightClick();
-        await this.updateTick();
         resolve(this);
       } catch (e) {
         reject(e);
@@ -74,9 +70,8 @@ export class Mouse {
   public async scrollDown(amount: number): Promise<Mouse> {
     return new Promise<Mouse>(async (resolve, reject) => {
       try {
-        await this.waitForNextTick(this.config.autoDelayMs);
+        await sleep(this.config.autoDelayMs);
         await this.native.scrollDown(amount);
-        await this.updateTick();
         resolve(this);
       } catch (e) {
         reject(e);
@@ -87,9 +82,8 @@ export class Mouse {
   public async scrollUp(amount: number): Promise<Mouse> {
     return new Promise<Mouse>(async (resolve, reject) => {
       try {
-        await this.waitForNextTick(this.config.autoDelayMs);
+        await sleep(this.config.autoDelayMs);
         await this.native.scrollUp(amount);
-        await this.updateTick();
         resolve(this);
       } catch (e) {
         reject(e);
@@ -100,9 +94,8 @@ export class Mouse {
   public async scrollLeft(amount: number): Promise<Mouse> {
     return new Promise<Mouse>(async (resolve, reject) => {
       try {
-        await this.waitForNextTick(this.config.autoDelayMs);
+        await sleep(this.config.autoDelayMs);
         await this.native.scrollLeft(amount);
-        await this.updateTick();
         resolve(this);
       } catch (e) {
         reject(e);
@@ -113,42 +106,26 @@ export class Mouse {
   public async scrollRight(amount: number): Promise<Mouse> {
     return new Promise<Mouse>(async (resolve, reject) => {
       try {
-        await this.waitForNextTick(this.config.autoDelayMs);
+        await sleep(this.config.autoDelayMs);
         await this.native.scrollRight(amount);
-        await this.updateTick();
         resolve(this);
       } catch (e) {
         reject(e);
       }
     });
   }
 
-  public async drag(path: Point[]): Promise<Mouse> {
+  public async drag(path: Point[] | Promise<Point[]>): Promise<Mouse> {
     return new Promise<Mouse>(async (resolve, reject) => {
       try {
-        await this.waitForNextTick(this.config.autoDelayMs);
+        await sleep(this.config.autoDelayMs);
         await this.native.pressButton(Button.LEFT);
         await this.move(path);
         await this.native.releaseButton(Button.LEFT);
-        await this.updateTick();
         resolve(this);
       } catch (e) {
         reject(e);
       }
     });
   }
-
-  private async updateTick() {
-    this.lastAction = Date.now();
-  }
-
-  private async waitForNextTick(minTime: number): Promise<void> {
-    return new Promise<void>(resolve => {
-      let current = Date.now();
-      while (current - this.lastAction < minTime) {
-        current = Date.now();
-      }
-      resolve();
-    });
-  }
 }