Bumped dependency versions, extended window provider with new capabilities for focus/resize/move window (#540)

Author: s1hofmann

index.ts

@@ -42,6 +42,7 @@ export { centerOf, randomPointIn } from "./lib/location.function";
 export { OptionalSearchParameters } from "./lib/optionalsearchparameters.class";
 export { EasingFunction, linear } from "./lib/mouse-movement.function";
 export { Point } from "./lib/point.class";
+export { Size } from "./lib/size.class";
 export { Region } from "./lib/region.class";
 export { Window } from "./lib/window.class";
 export { FileType } from "./lib/file-type.enum";
@@ -63,7 +64,7 @@ const assert = new AssertClass(screen);
 
 const { straightTo, up, down, left, right } = createMovementApi(
   providerRegistry,
-  lineHelper
+  lineHelper,
 );
 const { getWindows, getActiveWindow } = createWindowApi(providerRegistry);
 
@@ -74,7 +75,7 @@ const imageResource = (fileName: string) =>
   loadImageResource(
     providerRegistry,
     screen.config.resourceDirectory,
-    fileName
+    fileName,
   );
 
 const singleWord = (word: string): WordQuery => {

lib/provider/native/libnut-window.class.ts

@@ -1,6 +1,8 @@
 import libnut = require("@nut-tree/libnut");
 import { Region } from "../../region.class";
 import { WindowProviderInterface } from "../window-provider.interface";
+import { Size } from "../../size.class";
+import { Point } from "../../point.class";
 
 export default class WindowAction implements WindowProviderInterface {
   public getWindows(): Promise<number[]> {
@@ -32,8 +34,8 @@ export default class WindowAction implements WindowProviderInterface {
             windowRect.x,
             windowRect.y,
             windowRect.width,
-            windowRect.height
-          )
+            windowRect.height,
+          ),
         );
       } catch (e) {
         reject(e);
@@ -50,4 +52,41 @@ export default class WindowAction implements WindowProviderInterface {
       }
     });
   }
+
+  focusWindow(windowHandle: number): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
+      try {
+        resolve(libnut.focusWindow(windowHandle));
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  moveWindow(windowHandle: number, newOrigin: Point): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
+      try {
+        resolve(
+          libnut.moveWindow(windowHandle, { x: newOrigin.x, y: newOrigin.y }),
+        );
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  resizeWindow(windowHandle: number, newSize: Size): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
+      try {
+        resolve(
+          libnut.resizeWindow(windowHandle, {
+            width: newSize.width,
+            height: newSize.height,
+          }),
+        );
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
 }

lib/provider/window-provider.interface.ts

@@ -1,4 +1,6 @@
 import { Region } from "../region.class";
+import { Point } from "../point.class";
+import { Size } from "../size.class";
 
 /**
  * A WindowActionProvider should provide access to a system's window system
@@ -34,4 +36,19 @@ export interface WindowProviderInterface {
    * @returns The {@link Region} occupied by the window addressed via its window handle
    */
   getWindowRegion(windowHandle: number): Promise<Region>;
+
+  /**
+   * {@link focusWindow} Focuses the window addressed via its window handle
+   */
+  focusWindow(windowHandle: number): Promise<boolean>;
+
+  /**
+   * {@link moveWindow} Moves the window addressed via its window handle to a new origin given as {@link Point}
+   */
+  moveWindow(windowHandle: number, newOrigin: Point): Promise<boolean>;
+
+  /**
+   * {@link resizeWindow} Resizes the window addressed via its window handle to a new {@link Size}
+   */
+  resizeWindow(windowHandle: number, newSize: Size): Promise<boolean>;
 }

lib/size.class.spec.ts

@@ -0,0 +1,68 @@
+import { isSize, Size } from "./size.class";
+
+describe("Size", () => {
+  it("should calculate the correct area of a Size", () => {
+    const size = new Size(100, 100);
+    const expected = size.width * size.height;
+
+    expect(size.area()).toEqual(expected);
+  });
+
+  it("should return a proper string representation", () => {
+    const size = new Size(100, 100);
+    const expected = "(100x100)";
+
+    expect(size.toString()).toEqual(expected);
+  });
+
+  describe("isSize typeguard", () => {
+    it("should identify a Size object", () => {
+      // GIVEN
+      const s = new Size(100, 100);
+
+      // WHEN
+      const result = isSize(s);
+
+      // THEN
+      expect(result).toBeTruthy();
+    });
+
+    it("should rule out non-size objects", () => {
+      // GIVEN
+      const r = "foo";
+
+      // WHEN
+      const result = isSize(r);
+
+      // THEN
+      expect(result).toBeFalsy();
+    });
+
+    it("should rule out possible object with missing properties", () => {
+      // GIVEN
+      const r = {
+        width: 100,
+      };
+
+      // WHEN
+      const result = isSize(r);
+
+      // THEN
+      expect(result).toBeFalsy();
+    });
+
+    it("should rule out possible object with wrong property type", () => {
+      // GIVEN
+      const r = {
+        width: "foo",
+        height: 200,
+      };
+
+      // WHEN
+      const result = isSize(r);
+
+      // THEN
+      expect(result).toBeFalsy();
+    });
+  });
+});

lib/size.class.ts

@@ -0,0 +1,33 @@
+export class Size {
+  constructor(
+    public width: number,
+    public height: number,
+  ) {}
+
+  public area() {
+    return this.width * this.height;
+  }
+
+  public toString() {
+    return `(${this.width}x${this.height})`;
+  }
+}
+
+const testSize = new Size(100, 100);
+const sizeKeys = Object.keys(testSize);
+export function isSize(possibleSize: any): possibleSize is Size {
+  if (typeof possibleSize !== "object") {
+    return false;
+  }
+  for (const key of sizeKeys) {
+    if (!(key in possibleSize)) {
+      return false;
+    }
+    const possibleSizeKeyType = typeof possibleSize[key];
+    const sizeKeyType = typeof testSize[key as keyof typeof testSize];
+    if (possibleSizeKeyType !== sizeKeyType) {
+      return false;
+    }
+  }
+  return true;
+}

lib/window.class.ts

@@ -1,10 +1,12 @@
 import { Region } from "./region.class";
 import { ProviderRegistry } from "./provider/provider-registry.class";
+import { Point } from "./point.class";
+import { Size } from "./size.class";
 
 export class Window {
   constructor(
     private providerRegistry: ProviderRegistry,
-    private windowHandle: number
+    private windowHandle: number,
   ) {}
 
   get title(): Promise<string> {
@@ -14,4 +16,20 @@ export class Window {
   get region(): Promise<Region> {
     return this.providerRegistry.getWindow().getWindowRegion(this.windowHandle);
   }
+
+  async move(newOrigin: Point) {
+    await this.providerRegistry
+      .getWindow()
+      .moveWindow(this.windowHandle, newOrigin);
+  }
+
+  async resize(newSize: Size) {
+    await this.providerRegistry
+      .getWindow()
+      .resizeWindow(this.windowHandle, newSize);
+  }
+
+  async focus() {
+    await this.providerRegistry.getWindow().focusWindow(this.windowHandle);
+  }
 }