@appium/images-plugin 1.2.3 → 1.3.2

package/LICENSE

@@ -178,7 +178,7 @@
    APPENDIX: How to apply the Apache License to your work.
 
       To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
+      boilerplate notice, with the fields enclosed by brackets "{}"
       replaced with your own identifying information. (Don't include
       the brackets!)  The text should be enclosed in the appropriate
       comment syntax for the file format. We also recommend that a
@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright JS Foundation and other contributors, https://js.foundation
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -30,7 +30,7 @@ No special action is needed to make the features available in the various Appium
 The plugin will not be active unless turned on when invoking the Appium server:
 
 ```
-appium --plugins=images
+appium --use-plugins=images
 ```
 
 ## Usage

package/build/lib/compare.d.ts

@@ -0,0 +1,28 @@
+export type OccurrenceResult = import('@appium/opencv').OccurrenceResult;
+/**
+ * Performs images comparison using OpenCV framework features.
+ * It is expected that both OpenCV framework and opencv4nodejs
+ * module are installed on the machine where Appium server is running.
+ *
+ * @param {string} mode - One of possible comparison modes:
+ * matchFeatures, getSimilarity, matchTemplate
+ * @param {string} firstImage - Base64-encoded image file.
+ * All image formats, that OpenCV library itself accepts, are supported.
+ * @param {string} secondImage - Base64-encoded image file.
+ * All image formats, that OpenCV library itself accepts, are supported.
+ * @param {object} [options] - The content of this dictionary depends
+ * on the actual `mode` value. See the documentation on `@appium/support`
+ * module for more details.
+ * @returns {Promise<object|object[]>} The content of the resulting dictionary depends
+ * on the actual `mode` and `options` values. See the documentation on
+ * `@appium/support` module for more details.
+ * @throws {Error} If required OpenCV modules are not installed or
+ * if `mode` value is incorrect or if there was an unexpected issue while
+ * matching the images.
+ */
+export function compareImages(mode: string, firstImage: string, secondImage: string, options?: object): Promise<object | object[]>;
+export const DEFAULT_MATCH_THRESHOLD: 0.4;
+export const MATCH_TEMPLATE_MODE: "matchTemplate";
+export const MATCH_FEATURES_MODE: "matchFeatures";
+export const GET_SIMILARITY_MODE: "getSimilarity";
+//# sourceMappingURL=compare.d.ts.map

package/build/lib/compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../lib/compare.js"],"names":[],"mappings":"+BA2Fa,OAAO,gBAAgB,EAAE,gBAAgB;AAjFtD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAhBW,MAAM,cAEN,MAAM,eAEN,MAAM,YAEN,MAAM,GAGJ,QAAQ,MAAM,GAAC,MAAM,EAAE,CAAC,CAyCpC;AAzDD,0CAAoC;AAFpC,kDAA4C;AAF5C,kDAA4C;AAC5C,kDAA4C"}

package/build/lib/compare.js

@@ -1,21 +1,21 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GET_SIMILARITY_MODE = exports.MATCH_FEATURES_MODE = exports.MATCH_TEMPLATE_MODE = exports.DEFAULT_MATCH_THRESHOLD = exports.compareImages = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const base_driver_1 = require("@appium/base-driver");
-const support_1 = require("@appium/support");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MATCH_TEMPLATE_MODE = exports.MATCH_FEATURES_MODE = exports.GET_SIMILARITY_MODE = exports.DEFAULT_MATCH_THRESHOLD = void 0;
+exports.compareImages = compareImages;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _driver = require("appium/driver");
+
+var _opencv = require("@appium/opencv");
+
 const MATCH_FEATURES_MODE = 'matchFeatures';
 exports.MATCH_FEATURES_MODE = MATCH_FEATURES_MODE;
 const GET_SIMILARITY_MODE = 'getSimilarity';
@@ -24,65 +24,49 @@ const MATCH_TEMPLATE_MODE = 'matchTemplate';
 exports.MATCH_TEMPLATE_MODE = MATCH_TEMPLATE_MODE;
 const DEFAULT_MATCH_THRESHOLD = 0.4;
 exports.DEFAULT_MATCH_THRESHOLD = DEFAULT_MATCH_THRESHOLD;
-/**
- * Performs images comparison using OpenCV framework features.
- * It is expected that both OpenCV framework and opencv4nodejs
- * module are installed on the machine where Appium server is running.
- *
- * @param {string} mode - One of possible comparison modes:
- * matchFeatures, getSimilarity, matchTemplate
- * @param {string} firstImage - Base64-encoded image file.
- * All image formats, that OpenCV library itself accepts, are supported.
- * @param {string} secondImage - Base64-encoded image file.
- * All image formats, that OpenCV library itself accepts, are supported.
- * @param {?Object} options [{}] - The content of this dictionary depends
- * on the actual `mode` value. See the documentation on `@appium/support`
- * module for more details.
- * @returns {Object} The content of the resulting dictionary depends
- * on the actual `mode` and `options` values. See the documentation on
- * `@appium/support` module for more details.
- * @throws {Error} If required OpenCV modules are not installed or
- * if `mode` value is incorrect or if there was an unexpected issue while
- * matching the images.
- */
-function compareImages(mode, firstImage, secondImage, options = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const img1 = Buffer.from(firstImage, 'base64');
-        const img2 = Buffer.from(secondImage, 'base64');
-        let result = null;
-        switch (lodash_1.default.toLower(mode)) {
-            case MATCH_FEATURES_MODE.toLowerCase():
-                result = yield support_1.imageUtil.getImagesMatches(img1, img2, options);
-                break;
-            case GET_SIMILARITY_MODE.toLowerCase():
-                result = yield support_1.imageUtil.getImagesSimilarity(img1, img2, options);
-                break;
-            case MATCH_TEMPLATE_MODE.toLowerCase():
-                // firstImage/img1 is the full image and secondImage/img2 is the partial one
-                result = yield support_1.imageUtil.getImageOccurrence(img1, img2, options);
-                if (options.multiple) {
-                    return result.multiple.map(convertVisualizationToBase64);
-                }
-                break;
-            default:
-                throw new base_driver_1.errors.InvalidArgumentError(`'${mode}' images comparison mode is unknown. ` +
-                    `Only ${JSON.stringify([MATCH_FEATURES_MODE, GET_SIMILARITY_MODE, MATCH_TEMPLATE_MODE])} modes are supported.`);
-        }
-        return convertVisualizationToBase64(result);
-    });
+
+async function compareImages(mode, firstImage, secondImage, options = {}) {
+  const img1 = Buffer.from(firstImage, 'base64');
+  const img2 = Buffer.from(secondImage, 'base64');
+  let result = null;
+
+  switch (_lodash.default.toLower(mode)) {
+    case MATCH_FEATURES_MODE.toLowerCase():
+      try {
+        result = await (0, _opencv.getImagesMatches)(img1, img2, options);
+      } catch (err) {
+        result = {
+          count: 0
+        };
+      }
+
+      break;
+
+    case GET_SIMILARITY_MODE.toLowerCase():
+      result = await (0, _opencv.getImagesSimilarity)(img1, img2, options);
+      break;
+
+    case MATCH_TEMPLATE_MODE.toLowerCase():
+      result = await (0, _opencv.getImageOccurrence)(img1, img2, options);
+
+      if (options.multiple) {
+        return result.multiple.map(convertVisualizationToBase64);
+      }
+
+      break;
+
+    default:
+      throw new _driver.errors.InvalidArgumentError(`'${mode}' images comparison mode is unknown. ` + `Only ${JSON.stringify([MATCH_FEATURES_MODE, GET_SIMILARITY_MODE, MATCH_TEMPLATE_MODE])} modes are supported.`);
+  }
+
+  return convertVisualizationToBase64(result);
 }
-exports.compareImages = compareImages;
-/**
- * base64 encodes the visualization part of the result
- * (if necessary)
- *
- * @param {OccurrenceResult} element - occurrence result
- *
-**/
+
 function convertVisualizationToBase64(element) {
-    if (!lodash_1.default.isEmpty(element.visualization)) {
-        element.visualization = element.visualization.toString('base64');
-    }
-    return element;
+  if (!_lodash.default.isEmpty(element.visualization)) {
+    element.visualization = element.visualization.toString('base64');
+  }
+
+  return element;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGFyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2xpYi9jb21wYXJlLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG9EQUF1QjtBQUN2QixxREFBNkM7QUFDN0MsNkNBQTRDO0FBRTVDLE1BQU0sbUJBQW1CLEdBQUcsZUFBZSxDQUFDO0FBbUUwQixrREFBbUI7QUFsRXpGLE1BQU0sbUJBQW1CLEdBQUcsZUFBZSxDQUFDO0FBbUUxQyxrREFBbUI7QUFsRXJCLE1BQU0sbUJBQW1CLEdBQUcsZUFBZSxDQUFDO0FBaUVLLGtEQUFtQjtBQS9EcEUsTUFBTSx1QkFBdUIsR0FBRyxHQUFHLENBQUM7QUErRFosMERBQXVCO0FBN0QvQzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FvQkc7QUFDSCxTQUFlLGFBQWEsQ0FBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxPQUFPLEdBQUcsRUFBRTs7UUFDdkUsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDL0MsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDaEQsSUFBSSxNQUFNLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLFFBQVEsZ0JBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDdkIsS0FBSyxtQkFBbUIsQ0FBQyxXQUFXLEVBQUU7Z0JBQ3BDLE1BQU0sR0FBRyxNQUFNLG1CQUFTLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLElBQUksRUFBRSxPQUFPLENBQUMsQ0FBQztnQkFDL0QsTUFBTTtZQUNSLEtBQUssbUJBQW1CLENBQUMsV0FBVyxFQUFFO2dCQUNwQyxNQUFNLEdBQUcsTUFBTSxtQkFBUyxDQUFDLG1CQUFtQixDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7Z0JBQ2xFLE1BQU07WUFDUixLQUFLLG1CQUFtQixDQUFDLFdBQVcsRUFBRTtnQkFDcEMsNEVBQTRFO2dCQUM1RSxNQUFNLEdBQUcsTUFBTSxtQkFBUyxDQUFDLGtCQUFrQixDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7Z0JBQ2pFLElBQUksT0FBTyxDQUFDLFFBQVEsRUFBRTtvQkFDcEIsT0FBTyxNQUFNLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyw0QkFBNEIsQ0FBQyxDQUFDO2lCQUMxRDtnQkFDRCxNQUFNO1lBQ1I7Z0JBQ0UsTUFBTSxJQUFJLG9CQUFNLENBQUMsb0JBQW9CLENBQUMsSUFBSSxJQUFJLHVDQUF1QztvQkFDbkYsUUFBUSxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQUUsbUJBQW1CLENBQUMsQ0FBQyx1QkFBdUIsQ0FBQyxDQUFDO1NBQ3JIO1FBQ0QsT0FBTyw0QkFBNEIsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUM5QyxDQUFDO0NBQUE7QUFpQlEsc0NBQWE7QUFmdEI7Ozs7OztHQU1HO0FBQ0gsU0FBUyw0QkFBNEIsQ0FBRSxPQUFPO0lBQzVDLElBQUksQ0FBQyxnQkFBQyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLEVBQUU7UUFDckMsT0FBTyxDQUFDLGFBQWEsR0FBRyxPQUFPLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQztLQUNsRTtJQUVELE9BQU8sT0FBTyxDQUFDO0FBQ2pCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/finder.d.ts

@@ -0,0 +1,163 @@
+export default class ImageElementFinder {
+    /**
+     *
+     * @param {ExternalDriver} driver
+     * @param {number} [maxSize]
+     */
+    constructor(driver: ExternalDriver, maxSize?: number | undefined);
+    /** @type {ExternalDriver} */
+    driver: ExternalDriver;
+    /** @type {LRU<string,ImageElement>} */
+    imgElCache: LRU<string, ImageElement>;
+    setDriver(driver: any): void;
+    /**
+     * @param {ImageElement} imgEl
+     * @returns {Element}
+     */
+    registerImageElement(imgEl: ImageElement): Element;
+    /**
+     * @typedef FindByImageOptions
+     * @property {boolean} [shouldCheckStaleness=false] - whether this call to find an
+     * image is merely to check staleness. If so we can bypass a lot of logic
+     * @property {boolean} [multiple=false] - Whether we are finding one element or
+     * multiple
+     * @property {boolean} [ignoreDefaultImageTemplateScale=false] - Whether we
+     * ignore defaultImageTemplateScale. It can be used when you would like to
+     * scale b64Template with defaultImageTemplateScale setting.
+     */
+    /**
+     * Find a screen rect represented by an ImageElement corresponding to an image
+     * template sent in by the client
+     *
+     * @param {string} b64Template - base64-encoded image used as a template to be
+     * matched in the screenshot
+     * @param {FindByImageOptions} opts - additional options
+     *
+     * @returns {Promise<Element|Element[]|ImageElement>} - WebDriver element with a special id prefix
+     */
+    findByImage(b64Template: string, { shouldCheckStaleness, multiple, ignoreDefaultImageTemplateScale }: {
+        /**
+         * - whether this call to find an
+         * image is merely to check staleness. If so we can bypass a lot of logic
+         */
+        shouldCheckStaleness?: boolean | undefined;
+        /**
+         * - Whether we are finding one element or
+         * multiple
+         */
+        multiple?: boolean | undefined;
+        /**
+         * - Whether we
+         * ignore defaultImageTemplateScale. It can be used when you would like to
+         * scale b64Template with defaultImageTemplateScale setting.
+         */
+        ignoreDefaultImageTemplateScale?: boolean | undefined;
+    }): Promise<Element | Element[] | ImageElement>;
+    /**
+     * Ensure that the image template sent in for a find is of a suitable size
+     *
+     * @param {string} b64Template - base64-encoded image
+     * @param {number} screenWidth - width of screen
+     * @param {number} screenHeight - height of screen
+     *
+     * @returns {Promise<string>} base64-encoded image, potentially resized
+     */
+    ensureTemplateSize(b64Template: string, screenWidth: number, screenHeight: number): Promise<string>;
+    /**
+     * Get the screenshot image that will be used for find by element, potentially
+     * altering it in various ways based on user-requested settings
+     *
+     * @param {number} screenWidth - width of screen
+     * @param {number} screenHeight - height of screen
+     *
+     * @returns {Promise<Screenshot & {scale?: ScreenshotScale}>} base64-encoded screenshot and ScreenshotScale
+     */
+    getScreenshotForImageFind(screenWidth: number, screenHeight: number): Promise<Screenshot & {
+        scale?: ScreenshotScale | undefined;
+    }>;
+    /**
+     * @typedef ImageTemplateSettings
+     * @property {boolean} fixImageTemplateScale - fixImageTemplateScale in device-settings
+     * @property {number} defaultImageTemplateScale - defaultImageTemplateScale in device-settings
+     * @property {boolean} ignoreDefaultImageTemplateScale - Ignore defaultImageTemplateScale if it has true.
+     * If b64Template has been scaled to defaultImageTemplateScale or should ignore the scale,
+     * this parameter should be true. e.g. click in image-element module
+     * @property {number} xScale - Scale ratio for width
+     * @property {number} yScale - Scale ratio for height
+  
+     */
+    /**
+     * Get a image that will be used for template maching.
+     * Returns scaled image if scale ratio is provided.
+     *
+     *
+     * @param {string} b64Template - base64-encoded image used as a template to be
+     * matched in the screenshot
+     * @param {ImageTemplateSettings} opts - Image template scale related options
+     *
+     * @returns {Promise<string>} base64-encoded scaled template screenshot
+     */
+    fixImageTemplateScale(b64Template: string, opts: {
+        /**
+         * - fixImageTemplateScale in device-settings
+         */
+        fixImageTemplateScale: boolean;
+        /**
+         * - defaultImageTemplateScale in device-settings
+         */
+        defaultImageTemplateScale: number;
+        /**
+         * - Ignore defaultImageTemplateScale if it has true.
+         * If b64Template has been scaled to defaultImageTemplateScale or should ignore the scale,
+         * this parameter should be true. e.g. click in image-element module
+         */
+        ignoreDefaultImageTemplateScale: boolean;
+        /**
+         * - Scale ratio for width
+         */
+        xScale: number;
+        /**
+         * - Scale ratio for height
+         */
+        yScale: number;
+    }): Promise<string>;
+}
+export type ExternalDriver = import('@appium/types').ExternalDriver;
+export type Element = import('@appium/types').Element;
+export type Screenshot = {
+    /**
+     * - base64 based screenshot string
+     */
+    b64Screenshot: string;
+};
+export type ScreenshotScale = {
+    /**
+     * - Scale ratio for width
+     */
+    xScale: number;
+    /**
+     * - Scale ratio for height
+     */
+    yScale: number;
+};
+import LRU from "lru-cache";
+import { ImageElement } from "./image-element";
+export const W3C_ELEMENT_KEY: "element-6066-11e4-a52e-4f735466cecf";
+export const MJSONWP_ELEMENT_KEY: "ELEMENT";
+export namespace DEFAULT_SETTINGS {
+    export { DEFAULT_MATCH_THRESHOLD as imageMatchThreshold };
+    export const imageMatchMethod: string;
+    export const fixImageFindScreenshotDims: boolean;
+    export const fixImageTemplateSize: boolean;
+    export const fixImageTemplateScale: boolean;
+    export { DEFAULT_TEMPLATE_IMAGE_SCALE as defaultImageTemplateScale };
+    export const checkForImageElementStaleness: boolean;
+    export const autoUpdateImageElementPosition: boolean;
+    export { IMAGE_EL_TAP_STRATEGY_W3C as imageElementTapStrategy };
+    export const getMatchedImageResult: boolean;
+}
+export const DEFAULT_FIX_IMAGE_TEMPLATE_SCALE: 1;
+import { DEFAULT_MATCH_THRESHOLD } from "./compare";
+import { DEFAULT_TEMPLATE_IMAGE_SCALE } from "./image-element";
+import { IMAGE_EL_TAP_STRATEGY_W3C } from "./image-element";
+//# sourceMappingURL=finder.d.ts.map

package/build/lib/finder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finder.d.ts","sourceRoot":"","sources":["../../lib/finder.js"],"names":[],"mappings":"AA0EA;IAOE;;;;OAIG;IACH,oBAHW,cAAc,gCAUxB;IAlBD,6BAA6B;IAC7B,QADW,cAAc,CAClB;IAEP,uCAAuC;IACvC,YADW,IAAI,MAAM,EAAC,YAAY,CAAC,CACxB;IAgBX,6BAEC;IAED;;;OAGG;IACH,4BAHW,YAAY,GACV,OAAO,CAMnB;IAED;;;;;;;;;OASG;IAEH;;;;;;;;;OASG;IACH,yBANW,MAAM;;;;;;;;;;;;;;;;;QAIJ,QAAQ,OAAO,GAAC,OAAO,EAAE,GAAC,YAAY,CAAC,CAuHnD;IAED;;;;;;;;OAQG;IACH,gCANW,MAAM,eACN,MAAM,gBACN,MAAM,GAEJ,QAAQ,MAAM,CAAC,CAqB3B;IAED;;;;;;;;OAQG;IACH,uCALW,MAAM,gBACN,MAAM;;OAuHhB;IAED;;;;;;;;;;OAUG;IACH;;;;;;;;;;OAUG;IACH,mCANW,MAAM;;;;+BAdH,OAAO;;;;mCACP,MAAM;;;;;;yCACN,OAAO;;;;gBAGP,MAAM;;;;gBACN,MAAM;QAYP,QAAQ,MAAM,CAAC,CA+D3B;CACF;6BAKY,OAAO,eAAe,EAAE,cAAc;sBACtC,OAAO,eAAe,EAAE,OAAO;;;;;mBAK9B,MAAM;;;;;;YAKN,MAAM;;;;YACN,MAAM;;;;AA7epB,oEAAwD;AADxD,4CAAsC;;;;;;;;;;;;;AAEtC,iDAA2C"}