Feature/294/export provider interfaces (#295)

* (#294) Export interfaces for providers

* (#294) Align naming of interfaces

Author: s1hofmann

Diff for: index.ts

@@ -19,6 +19,10 @@ export {
     providerRegistry
 }
 
+export {MatchRequest} from "./lib/match-request.class";
+export {MatchResult} from "./lib/match-result.class";
+export * from "./lib/provider";
+
 export {jestMatchers} from "./lib/expect/jest.matcher.function";
 export {sleep} from "./lib/sleep.function";
 export {Image} from "./lib/image.class";

Diff for: lib/provider/clipboard-provider.interface.ts

@@ -1,7 +1,7 @@
 /**
  * A ClipboardActionProvider should allow access to the system clipboard
  */
-export interface ClipboardProvider {
+export interface ClipboardProviderInterface {
   /**
    * hasText should return whether the system clipboard currently holds text or not
    *

Diff for: lib/provider/data-sink.interface.ts

@@ -1,9 +1,9 @@
 /**
  * A DataSink should provide methods to store data
  *
- * @interface DataSink
+ * @interface DataSinkInterface
  */
-export interface DataSink<PARAMETER_TYPE, RETURN_TYPE> {
+export interface DataSinkInterface<PARAMETER_TYPE, RETURN_TYPE> {
   /**
    * store will store data to disk
    * @param parameters Required parameters

Diff for: lib/provider/data-source.interface.ts

@@ -1,9 +1,9 @@
 /**
  * A DataSource should provide methods to load data
  *
- * @interface DataSource
+ * @interface DataSourceInterface
  */
-export interface DataSource<PARAMETER_TYPE, RESULT_TYPE> {
+export interface DataSourceInterface<PARAMETER_TYPE, RESULT_TYPE> {
   /**
    * load will load data from disk
    * @param parameters Required parameters

Diff for: lib/provider/image-reader.type.ts

@@ -1,4 +1,4 @@
-import {DataSource} from "./data-source.interface";
+import {DataSourceInterface} from "./data-source.interface";
 import {Image} from "../image.class";
 
-export type ImageReader = DataSource<string, Image>;
+export type ImageReader = DataSourceInterface<string, Image>;

Diff for: lib/provider/image-writer.type.ts

@@ -1,9 +1,9 @@
 import {Image} from "../image.class";
-import {DataSink} from "./data-sink.interface";
+import {DataSinkInterface} from "./data-sink.interface";
 
 export interface ImageWriterParameters {
     data: Image,
     path: string
 }
 
-export type ImageWriter = DataSink<ImageWriterParameters, void>;
+export type ImageWriter = DataSinkInterface<ImageWriterParameters, void>;

Diff for: lib/provider/index.ts

@@ -0,0 +1,10 @@
+export {ClipboardProviderInterface} from "./clipboard-provider.interface";
+export {DataSinkInterface} from "./data-sink.interface";
+export {DataSourceInterface} from "./data-source.interface";
+export {ImageFinderInterface} from "./image-finder.interface";
+export {ImageReader} from "./image-reader.type";
+export {ImageWriter} from "./image-writer.type";
+export {KeyboardProviderInterface} from "./keyboard-provider.interface";
+export {MouseProviderInterface} from "./mouse-provider.interface";
+export {ScreenProviderInterface} from "./screen-provider.interface";
+export {WindowProviderInterface} from "./window-provider.interface";

Diff for: lib/provider/keyboard-provider.interface.ts

@@ -3,7 +3,7 @@ import { Key } from "../key.enum";
 /**
  * A KeyboardActionProvider should provide access to a systems keyboard
  */
-export interface KeyboardProvider {
+export interface KeyboardProviderInterface {
   /**
    * setKeyboardDelay should allow to configure a delay between key presses
    *

Diff for: lib/provider/mouse-provider.interface.ts

@@ -4,7 +4,7 @@ import { Point } from "../point.class";
 /**
  * A MouseActionProvider should provide access to a systems mouse input
  */
-export interface MouseProvider {
+export interface MouseProviderInterface {
   /**
    * setMouseDelay should allow to configure mouse movement speed
    *

Diff for: lib/provider/native/clipboardy-clipboard.class.ts

@@ -1,7 +1,7 @@
 import clippy from "clipboardy";
-import { ClipboardProvider } from "../clipboard-provider.interface";
+import { ClipboardProviderInterface } from "../clipboard-provider.interface";
 
-export default class implements ClipboardProvider {
+export default class implements ClipboardProviderInterface {
   constructor() {
   }
 

Diff for: lib/provider/native/libnut-keyboard.class.ts

@@ -1,8 +1,8 @@
 import libnut = require("@nut-tree/libnut");
 import { Key } from "../../key.enum";
-import { KeyboardProvider } from "../keyboard-provider.interface";
+import { KeyboardProviderInterface } from "../keyboard-provider.interface";
 
-export default class KeyboardAction implements KeyboardProvider {
+export default class KeyboardAction implements KeyboardProviderInterface {
 
   public static KeyLookupMap = new Map<Key, string | null>([
     [Key.A, "a"],

Diff for: lib/provider/native/libnut-mouse.class.ts

@@ -1,9 +1,9 @@
 import libnut = require("@nut-tree/libnut");
 import { Button } from "../../button.enum";
 import { Point } from "../../point.class";
-import { MouseProvider } from "../mouse-provider.interface";
+import { MouseProviderInterface } from "../mouse-provider.interface";
 
-export default class MouseAction implements MouseProvider {
+export default class MouseAction implements MouseProviderInterface {
   public static buttonLookup(btn: Button): any {
     return this.ButtonLookupMap.get(btn);
   }

Diff for: lib/provider/native/libnut-screen.class.ts

@@ -1,9 +1,9 @@
 import libnut = require("@nut-tree/libnut");
 import { Image } from "../../image.class";
 import { Region } from "../../region.class";
-import { ScreenProvider } from "../screen-provider.interface";
+import { ScreenProviderInterface } from "../screen-provider.interface";
 
-export default class ScreenAction implements ScreenProvider {
+export default class ScreenAction implements ScreenProviderInterface {
 
   private static determinePixelDensity(
     screen: Region,

Diff for: lib/provider/native/libnut-window.class.ts

@@ -1,8 +1,8 @@
 import libnut = require("@nut-tree/libnut");
 import { Region } from "../../region.class";
-import { WindowProvider } from "../window-provider.interface";
+import { WindowProviderInterface } from "../window-provider.interface";
 
-export default class WindowAction implements WindowProvider {
+export default class WindowAction implements WindowProviderInterface {
   public getWindows(): Promise<number[]> {
     return new Promise<number[]>((resolve, reject) => {
       try {

Diff for: lib/provider/provider-registry.class.ts

@@ -1,9 +1,9 @@
-import {ClipboardProvider} from "./clipboard-provider.interface";
+import {ClipboardProviderInterface} from "./clipboard-provider.interface";
 import {ImageFinderInterface} from "./image-finder.interface";
-import {KeyboardProvider} from "./keyboard-provider.interface";
-import {MouseProvider} from "./mouse-provider.interface";
-import {ScreenProvider} from "./screen-provider.interface";
-import {WindowProvider} from "./window-provider.interface";
+import {KeyboardProviderInterface} from "./keyboard-provider.interface";
+import {MouseProviderInterface} from "./mouse-provider.interface";
+import {ScreenProviderInterface} from "./screen-provider.interface";
+import {WindowProviderInterface} from "./window-provider.interface";
 
 import Clipboard from "./native/clipboardy-clipboard.class";
 import Finder from "./opencv/template-matching-finder.class";
@@ -17,23 +17,23 @@ import ImageReaderImpl from "./opencv/image-reader.class";
 import ImageWriterImpl from "./opencv/image-writer.class";
 
 export interface ProviderRegistry {
-    getClipboard(): ClipboardProvider;
-    registerClipboardProvider(value: ClipboardProvider): void;
+    getClipboard(): ClipboardProviderInterface;
+    registerClipboardProvider(value: ClipboardProviderInterface): void;
 
     getImageFinder(): ImageFinderInterface;
     registerImageFinder(value: ImageFinderInterface): void;
 
-    getKeyboard(): KeyboardProvider;
-    registerKeyboardProvider(value: KeyboardProvider): void;
+    getKeyboard(): KeyboardProviderInterface;
+    registerKeyboardProvider(value: KeyboardProviderInterface): void;
 
-    getMouse(): MouseProvider;
-    registerMouseProvider(value: MouseProvider): void;
+    getMouse(): MouseProviderInterface;
+    registerMouseProvider(value: MouseProviderInterface): void;
 
-    getScreen(): ScreenProvider;
-    registerScreenProvider(value: ScreenProvider): void;
+    getScreen(): ScreenProviderInterface;
+    registerScreenProvider(value: ScreenProviderInterface): void;
 
-    getWindow(): WindowProvider;
-    registerWindowProvider(value: WindowProvider): void;
+    getWindow(): WindowProviderInterface;
+    registerWindowProvider(value: WindowProviderInterface): void;
 
     getImageReader(): ImageReader;
     registerImageReader(value: ImageReader): void;
@@ -43,23 +43,23 @@ export interface ProviderRegistry {
 }
 
 class DefaultProviderRegistry implements ProviderRegistry {
-    private _clipboard?: ClipboardProvider;
+    private _clipboard?: ClipboardProviderInterface;
     private _finder?: ImageFinderInterface;
-    private _keyboard?: KeyboardProvider;
-    private _mouse?: MouseProvider;
-    private _screen?: ScreenProvider;
-    private _window?: WindowProvider;
+    private _keyboard?: KeyboardProviderInterface;
+    private _mouse?: MouseProviderInterface;
+    private _screen?: ScreenProviderInterface;
+    private _window?: WindowProviderInterface;
     private _imageReader?: ImageReader;
     private _imageWriter?: ImageWriter;
 
-    getClipboard(): ClipboardProvider {
+    getClipboard(): ClipboardProviderInterface {
         if (this._clipboard) {
             return this._clipboard;
         }
         throw new Error(`No ClipboardProvider registered`);
     }
 
-    registerClipboardProvider(value: ClipboardProvider) {
+    registerClipboardProvider(value: ClipboardProviderInterface) {
         this._clipboard = value;
     }
 
@@ -74,47 +74,47 @@ class DefaultProviderRegistry implements ProviderRegistry {
         this._finder = value;
     }
 
-    getKeyboard(): KeyboardProvider {
+    getKeyboard(): KeyboardProviderInterface {
         if (this._keyboard) {
             return this._keyboard;
         }
         throw new Error(`No KeyboardProvider registered`);
     }
 
-    registerKeyboardProvider(value: KeyboardProvider) {
+    registerKeyboardProvider(value: KeyboardProviderInterface) {
         this._keyboard = value;
     }
 
-    getMouse(): MouseProvider {
+    getMouse(): MouseProviderInterface {
         if (this._mouse) {
             return this._mouse;
         }
         throw new Error(`No MouseProvider registered`);
     }
 
-    registerMouseProvider(value: MouseProvider) {
+    registerMouseProvider(value: MouseProviderInterface) {
         this._mouse = value;
     }
 
-    getScreen(): ScreenProvider {
+    getScreen(): ScreenProviderInterface {
         if (this._screen) {
             return this._screen;
         }
         throw new Error(`No ScreenProvider registered`);
     }
 
-    registerScreenProvider(value: ScreenProvider) {
+    registerScreenProvider(value: ScreenProviderInterface) {
         this._screen = value;
     }
 
-    getWindow(): WindowProvider {
+    getWindow(): WindowProviderInterface {
         if (this._window) {
             return this._window;
         }
         throw new Error(`No WindowProvider registered`);
     }
 
-    registerWindowProvider(value: WindowProvider) {
+    registerWindowProvider(value: WindowProviderInterface) {
         this._window = value;
     }
 

Diff for: lib/provider/screen-provider.interface.ts

@@ -4,9 +4,9 @@ import { Region } from "../region.class";
 /**
  * A ScreenActionProvider should provide access to a system's main screen
  *
- * @interface ScreenProvider
+ * @interface ScreenProviderInterface
  */
-export interface ScreenProvider {
+export interface ScreenProviderInterface {
   /**
    * grabScreen should return an {@link Image} object containing a screenshot data of a systems
    * main screen as well as its dimensions

Diff for: lib/provider/window-provider.interface.ts

@@ -3,9 +3,9 @@ import { Region } from "../region.class";
 /**
  * A WindowActionProvider should provide access to a system's window system
  *
- * @interface WindowProvider
+ * @interface WindowProviderInterface
  */
-export interface WindowProvider {
+export interface WindowProviderInterface {
   /**
    * {@link getWindows} returns a list of window handles for further processing.
    * These window handles may serve as input to e.g. {@link getWindowTitle}