Updated interfaces

Author: s1hofmann

demo/mouse.js

@@ -12,19 +12,19 @@ const square = async () => {
 };
 
 (async () => {
-  mouse
-    .leftClick()
-  // await square();
+  await mouse
+    .leftClick();
+    await square();
   try {
     screen.config.resourceDirectory = "./assets";
     const whale = await screen.findOnScreen("docker.png");
-    mouse.move(await movement.straightTo(Location.centerOf(whale)));
+    await mouse.move(await movement.straightTo(Location.centerOf(whale)));
 
     const gitlens = await screen.findOnScreen("gitlens.png");
-    mouse.move(await movement.straightTo(Location.centerOf(gitlens)));
-    mouse.drag(await movement.right(600));
-    mouse.move(await movement.straightTo(Location.centerOf(gitlens)));
-    mouse.drag(await movement.straightTo(Location.centerOf(whale)));
+    await mouse.move(await movement.straightTo(Location.centerOf(gitlens)));
+    await mouse.drag(await movement.right(600));
+    await mouse.move(await movement.straightTo(Location.centerOf(gitlens)));
+    await mouse.drag(await movement.straightTo(Location.centerOf(whale)));
   } catch (error) {
     console.log(error);
   }

lib/clipboard.class.ts

@@ -3,8 +3,11 @@ import { NativeAdapter } from "./adapter/native.adapter.class";
 export class Clipboard {
   constructor(private nativeAdapter: NativeAdapter) {}
 
-  public copy(text: string): void {
-    this.nativeAdapter.copy(text);
+  public copy(text: string): Promise<void> {
+    return new Promise<void>(resolve => {
+      this.nativeAdapter.copy(text);
+      resolve();
+    });
   }
 
   public paste(): Promise<string> {

lib/keyboard.class.spec.ts

@@ -20,14 +20,14 @@ describe("Keyboard", () => {
     expect(SUT.config.autoDelayMs).toEqual(500);
   });
 
-  it("should pass input strings down to the type call.", () => {
+  it("should pass input strings down to the type call.", async () => {
     // GIVEN
     const adapterMock = new NativeAdapter();
     const SUT = new Keyboard(adapterMock);
     const payload = "Test input!";
 
     // WHEN
-    SUT.type(payload);
+    await SUT.type(payload);
 
     // THEN
     expect(adapterMock.type).toHaveBeenCalledTimes(payload.length);
@@ -36,14 +36,14 @@ describe("Keyboard", () => {
     }
   });
 
-  it("should pass multiple input strings down to the type call.", () => {
+  it("should pass multiple input strings down to the type call.", async () => {
     // GIVEN
     const adapterMock = new NativeAdapter();
     const SUT = new Keyboard(adapterMock);
     const payload = ["Test input!", "Array test2"];
 
     // WHEN
-    SUT.type(...payload);
+    await SUT.type(...payload);
 
     // THEN
     expect(adapterMock.type).toHaveBeenCalledTimes(payload.join(" ").length);
@@ -52,59 +52,59 @@ describe("Keyboard", () => {
     }
   });
 
-  it("should pass input keys down to the click call.", () => {
+  it("should pass input keys down to the click call.", async () => {
     // GIVEN
     const adapterMock = new NativeAdapter();
     const SUT = new Keyboard(adapterMock);
     const payload = [Key.A, Key.S, Key.D, Key.F];
 
     // WHEN
-    SUT.type(...payload);
+    await SUT.type(...payload);
 
     // THEN
     expect(adapterMock.click).toHaveBeenCalledTimes(1);
     expect(adapterMock.click).toHaveBeenCalledWith(...payload);
   });
 
-  it("should pass a list of input keys down to the click call.", () => {
+  it("should pass a list of input keys down to the click call.", async () => {
     // GIVEN
     const adapterMock = new NativeAdapter();
     const SUT = new Keyboard(adapterMock);
     const payload = [Key.A, Key.S, Key.D, Key.F];
 
     // WHEN
     for (const key of payload) {
-      SUT.type(key);
+      await SUT.type(key);
     }
 
     // THEN
     expect(adapterMock.click).toHaveBeenCalledTimes(payload.length);
   });
 
-  it("should pass a list of input keys down to the pressKey call.", () => {
+  it("should pass a list of input keys down to the pressKey call.", async () => {
     // GIVEN
     const adapterMock = new NativeAdapter();
     const SUT = new Keyboard(adapterMock);
     const payload = [Key.A, Key.S, Key.D, Key.F];
 
     // WHEN
     for (const key of payload) {
-      SUT.pressKey(key);
+      await SUT.pressKey(key);
     }
 
     // THEN
     expect(adapterMock.pressKey).toHaveBeenCalledTimes(payload.length);
   });
 
-  it("should pass a list of input keys down to the releaseKey call.", () => {
+  it("should pass a list of input keys down to the releaseKey call.", async () => {
     // GIVEN
     const adapterMock = new NativeAdapter();
     const SUT = new Keyboard(adapterMock);
     const payload = [Key.A, Key.S, Key.D, Key.F];
 
     // WHEN
     for (const key of payload) {
-      SUT.releaseKey(key);
+      await SUT.releaseKey(key);
     }
 
     // THEN

lib/keyboard.class.ts

@@ -18,37 +18,46 @@ export class Keyboard {
     this.lastAction = Date.now();
   }
 
-  public type(...input: string[] | Key[]): Keyboard {
-    if (Keyboard.inputIsString(input)) {
-      for (const char of input.join(" ").split("")) {
-        this.waitForNextTick();
-        this.nativeAdapter.type(char);
-        this.updateTick();
+  public type(...input: string[] | Key[]): Promise<Keyboard> {
+    return new Promise<Keyboard>(async resolve => {
+      if (Keyboard.inputIsString(input)) {
+        for (const char of input.join(" ").split("")) {
+          await this.waitForNextTick();
+          this.nativeAdapter.type(char);
+          this.updateTick();
+        }
+      } else {
+        this.nativeAdapter.click(...input as Key[]);
       }
-    } else {
-      this.nativeAdapter.click(...input as Key[]);
-    }
-    return this;
+      resolve(this);
+    });
   }
 
-  public pressKey(...keys: Key[]): Keyboard {
-    this.nativeAdapter.pressKey(...keys);
-    return this;
+  public pressKey(...keys: Key[]): Promise<Keyboard> {
+    return new Promise<Keyboard>(async resolve => {
+      this.nativeAdapter.pressKey(...keys);
+      resolve(this);
+    });
   }
 
-  public releaseKey(...keys: Key[]): Keyboard {
-    this.nativeAdapter.releaseKey(...keys);
-    return this;
+  public releaseKey(...keys: Key[]): Promise<Keyboard> {
+    return new Promise<Keyboard>(async resolve => {
+      this.nativeAdapter.releaseKey(...keys);
+      resolve(this);
+    });
   }
 
   private updateTick() {
     this.lastAction = Date.now();
   }
 
-  private waitForNextTick() {
-    let current = Date.now();
-    while (current - this.lastAction < this.config.autoDelayMs) {
-      current = Date.now();
-    }
+  private async waitForNextTick(): Promise<void> {
+    return new Promise<void>(resolve => {
+      let current = Date.now();
+      while (current - this.lastAction < this.config.autoDelayMs) {
+        current = Date.now();
+      }
+      resolve();
+    });
   }
 }

lib/mouse.class.spec.ts

@@ -24,110 +24,110 @@ describe("Mouse class", () => {
     expect(SUT.config.autoDelayMs).toEqual(100);
   });
 
-  it("should forward scrollLeft to the native adapter class", () => {
+  it("should forward scrollLeft to the native adapter class", async () => {
     // GIVEN
     const nativeAdapterMock = new NativeAdapter();
     const SUT = new Mouse(nativeAdapterMock);
     const scrollAmount = 5;
 
     // WHEN
-    const result = SUT.scrollLeft(scrollAmount);
+    const result = await SUT.scrollLeft(scrollAmount);
 
     // THEN
     expect(nativeAdapterMock.scrollLeft).toBeCalledWith(scrollAmount);
     expect(result).toBe(SUT);
   });
 
-  it("should forward scrollRight to the native adapter class", () => {
+  it("should forward scrollRight to the native adapter class", async () => {
     // GIVEN
     const nativeAdapterMock = new NativeAdapter();
     const SUT = new Mouse(nativeAdapterMock);
     const scrollAmount = 5;
 
     // WHEN
-    const result = SUT.scrollRight(scrollAmount);
+    const result = await SUT.scrollRight(scrollAmount);
 
     // THEN
     expect(nativeAdapterMock.scrollRight).toBeCalledWith(scrollAmount);
     expect(result).toBe(SUT);
   });
 
-  it("should forward scrollDown to the native adapter class", () => {
+  it("should forward scrollDown to the native adapter class", async () => {
     // GIVEN
     const nativeAdapterMock = new NativeAdapter();
     const SUT = new Mouse(nativeAdapterMock);
     const scrollAmount = 5;
 
     // WHEN
-    const result = SUT.scrollDown(scrollAmount);
+    const result = await SUT.scrollDown(scrollAmount);
 
     // THEN
     expect(nativeAdapterMock.scrollDown).toBeCalledWith(scrollAmount);
     expect(result).toBe(SUT);
   });
 
-  it("should forward scrollUp to the native adapter class", () => {
+  it("should forward scrollUp to the native adapter class", async () => {
     // GIVEN
     const nativeAdapterMock = new NativeAdapter();
     const SUT = new Mouse(nativeAdapterMock);
     const scrollAmount = 5;
 
     // WHEN
-    const result = SUT.scrollUp(scrollAmount);
+    const result = await SUT.scrollUp(scrollAmount);
 
     // THEN
     expect(nativeAdapterMock.scrollUp).toBeCalledWith(scrollAmount);
     expect(result).toBe(SUT);
   });
 
-  it("should forward leftClick to the native adapter class", () => {
+  it("should forward leftClick to the native adapter class", async () => {
     // GIVEN
     const nativeAdapterMock = new NativeAdapter();
     const SUT = new Mouse(nativeAdapterMock);
 
     // WHEN
-    const result = SUT.leftClick();
+    const result = await SUT.leftClick();
 
     // THEN
     expect(nativeAdapterMock.leftClick).toBeCalled();
     expect(result).toBe(SUT);
   });
 
-  it("should forward rightClick to the native adapter class", () => {
+  it("should forward rightClick to the native adapter class", async () => {
     // GIVEN
     const nativeAdapterMock = new NativeAdapter();
     const SUT = new Mouse(nativeAdapterMock);
 
     // WHEN
-    const result = SUT.rightClick();
+    const result = await SUT.rightClick();
 
     // THEN
     expect(nativeAdapterMock.rightClick).toBeCalled();
     expect(result).toBe(SUT);
   });
 
-  it("update mouse position along path on move", () => {
+  it("update mouse position along path on move", async () => {
     // GIVEN
     const nativeAdapterMock = new NativeAdapter();
     const SUT = new Mouse(nativeAdapterMock);
     const path = linehelper.straightLine(new Point(0, 0), new Point(10, 10));
 
     // WHEN
-    const result = SUT.move(path);
+    const result = await SUT.move(path);
 
     // THEN
     expect(nativeAdapterMock.setMousePosition).toBeCalledTimes(path.length);
     expect(result).toBe(SUT);
   });
 
-  it("should press and hold left mouse button, move and release left mouse button on drag", () => {
+  it("should press and hold left mouse button, move and release left mouse button on drag", async () => {
     // GIVEN
     const nativeAdapterMock = new NativeAdapter();
     const SUT = new Mouse(nativeAdapterMock);
     const path = linehelper.straightLine(new Point(0, 0), new Point(10, 10));
 
     // WHEN
-    const result = SUT.drag(path);
+    const result = await SUT.drag(path);
 
     // THEN
     expect(nativeAdapterMock.pressButton).toBeCalledWith(Button.LEFT);