@wdio/ocr-service 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+# @wdio/ocr-service
+
+## 1.0.0
+
+### Major Changes
+
+- a924dfc: # 🚀 New Feature
+
+  Sometimes it can be hard to find an element in a mobile native app or desktop site, with an interactable Canvas, with the default [WebdriverIO selectors](https://webdriver.io/docs/selectors). In that case, it would be nice if you would be able to use something like OCR ([Optical Character Recognition](https://en.wikipedia.org/wiki/Optical_character_recognition)) to interact with elements on your device/screen.
+
+  The new `@wdio/ocr-service` service provides you with the option to interact with elements based on **visible text**. It will provide multiple commands to:
+
+  - wait
+  - search
+  - and interact
+
+  with an element, all based on text.
+
+  The following commands will be added
+
+  - `ocrGetText`
+  - `ocrGetElementPositionByText`
+  - `ocrWaitForTextDisplayed`
+  - `ocrClickOnText`
+  - `ocrSetValue`
+
+  A CLI command will also be provided to pre-check text received from the image. For a demo check this video
+
+  https://github.com/webdriverio/visual-testing/assets/11979740/6e4677ba-1463-4d6e-98b0-9a3bf70b702f

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OpenJS Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# WebdriverIO OCR Service
+
+> A WebdriverIO service for using OCR to interact with elements on a page.
+
+## Installation
+
+The easiest way is to keep `@wdio/ocr-service` as a dev-dependency in your `package.json`, via:
+
+```sh
+npm install @wdio/ocr-service --save-dev
+```
+
+Instructions on how to get started can be found in the [visual testing](https://webdriver.io/docs/visual-testing) docs on the WebdriverIO project page.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export declare const CONFIG_HELPER_INTRO = "\n=============================\n\uD83E\uDD16 WDIO OCR-Service Wizard \uD83E\uDDD9\n=============================\n";
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,mBAAmB,wHAI/B,CAAA"}

package/dist/cli.js

@@ -0,0 +1,165 @@
+import inquirer from 'inquirer';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import getData from './utils/getData.js';
+import { createOcrDir } from './utils/index.js';
+import { isSystemTesseractAvailable } from './utils/tesseract.js';
+import { SUPPORTED_LANGUAGES } from './utils/constants.js';
+export const CONFIG_HELPER_INTRO = `
+=============================
+🤖 WDIO OCR-Service Wizard 🧙
+=============================
+`;
+const currentPath = process.cwd();
+function convertFileToBase64(filePath) {
+    if (!existsSync(filePath)) {
+        throw new Error(`File does not exist at: "${filePath}"`);
+    }
+    const fileBuffer = readFileSync(filePath);
+    const base64String = fileBuffer.toString('base64');
+    return base64String;
+}
+function listFilesAndFolders(folderPath) {
+    const items = readdirSync(folderPath, { withFileTypes: true });
+    const choices = items.filter(item => {
+        if (item.isDirectory() && !item.name.startsWith('node_modules')) {
+            return true;
+        }
+        return /\.(jpg|jpeg|png|gif)$/i.test(item.name);
+    }).map(item => {
+        const isDirectory = item.isDirectory();
+        const value = item.name + (isDirectory ? '/' : '');
+        return {
+            name: value,
+            value,
+        };
+    });
+    if (resolve(folderPath) !== resolve('/')) {
+        choices.push({
+            name: '\x1b[36m↩ Go Back\x1b[0m',
+            value: '..'
+        });
+    }
+    return choices;
+}
+async function chooseFolder(currentPath) {
+    async function prompt(srcPath) {
+        const choices = listFilesAndFolders(srcPath);
+        const answers = await inquirer.prompt([{
+                type: 'list',
+                name: 'path',
+                message: `Please choose a folder (current folder: ${srcPath})`,
+                choices: choices
+            }]);
+        const newPath = join(srcPath, answers.path);
+        if (answers.path === '..') {
+            // Clears the previous line
+            process.stdout.write('\u001b[1A\u001b[2K');
+            return prompt(newPath);
+        }
+        if (answers.path.endsWith('/')) {
+            // Clears the previous line
+            process.stdout.write('\u001b[1A\u001b[2K');
+            return prompt(newPath);
+        }
+        return newPath;
+    }
+    return prompt(currentPath);
+}
+async function main() {
+    const ocrDir = createOcrDir('.tmp/');
+    const defaultOptions = {
+        contrast: 0.25,
+        isTesseractAvailable: isSystemTesseractAvailable(),
+        language: SUPPORTED_LANGUAGES.ENGLISH,
+        ocrImagesPath: ocrDir,
+    };
+    let filePath;
+    console.log(CONFIG_HELPER_INTRO);
+    const initialChoice = await inquirer.prompt({
+        type: 'list',
+        name: 'method',
+        message: 'How would you like to specify the file?',
+        choices: [
+            { name: 'Use a "file explorer"', value: 'explore' },
+            { name: 'Type the file path manually', value: 'type' },
+        ],
+    });
+    if (initialChoice.method === 'explore') {
+        filePath = await chooseFolder(currentPath);
+    }
+    else {
+        const pathInput = await inquirer.prompt({
+            type: 'input',
+            name: 'path',
+            message: 'Please enter the file path:',
+        });
+        filePath = pathInput.path;
+    }
+    const useHaystack = await inquirer.prompt({
+        type: 'confirm',
+        name: 'use',
+        message: 'Would you like to use a haystack?',
+    });
+    let haystack;
+    if (useHaystack.use) {
+        const { x } = await inquirer.prompt({
+            type: 'input',
+            name: 'x',
+            message: 'Enter the x coordinate:',
+            filter: (input) => Number(input),
+        });
+        const { y } = await inquirer.prompt({
+            type: 'input',
+            name: 'y',
+            message: 'Enter the y coordinate:',
+            filter: (input) => Number(input),
+        });
+        const { width } = await inquirer.prompt({
+            type: 'input',
+            name: 'width',
+            message: 'Enter the width:',
+            filter: (input) => Number(input),
+        });
+        const { height } = await inquirer.prompt({
+            type: 'input',
+            name: 'height',
+            message: 'Enter the height:',
+            filter: (input) => Number(input),
+        });
+        haystack = { x, y, width, height };
+    }
+    let options = {
+        ...defaultOptions,
+        ...{ haystack },
+        cliFile: convertFileToBase64(filePath),
+    };
+    const { useAdvanced } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'useAdvanced',
+            message: 'Do you want to use the advanced mode?',
+        }]);
+    if (useAdvanced) {
+        const advancedOptions = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'contrast',
+                message: 'Enter new contrast (0.0 - 1.0):',
+                default: defaultOptions.contrast.toString(),
+                validate: (input) => {
+                    const value = parseFloat(input);
+                    return (value >= 0.0 && value <= 1.0) || 'Please enter a contrast between 0.0 and 1.0';
+                },
+                filter: (input) => input ? parseFloat(input) : defaultOptions.contrast
+            },
+        ]);
+        options = {
+            ...options,
+            contrast: advancedOptions.contrast,
+        };
+    }
+    console.log('\nProcessing image...\n');
+    await getData(options);
+    console.log('\nDone!');
+}
+main();

package/dist/commands/ocrClickOnText.d.ts

@@ -0,0 +1,3 @@
+import type { OcrClickOnTextOptions } from '../types.js';
+export default function ocrClickOnText(options: OcrClickOnTextOptions): Promise<void>;
+//# sourceMappingURL=ocrClickOnText.d.ts.map

package/dist/commands/ocrClickOnText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocrClickOnText.d.ts","sourceRoot":"","sources":["../../src/commands/ocrClickOnText.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAGxD,wBAA8B,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2B1F"}

package/dist/commands/ocrClickOnText.js

@@ -0,0 +1,27 @@
+import ocrGetElementPositionByText from './ocrGetElementPositionByText.js';
+import { determineClickPoint } from '../utils/index.js';
+import { drawTarget } from '../utils/imageProcessing.js';
+export default async function ocrClickOnText(options) {
+    const element = await ocrGetElementPositionByText(options);
+    let { x, y } = determineClickPoint({ rectangles: element.dprPosition });
+    const { relativePosition } = options;
+    // Adjust the x and y coordinates based on the relative position
+    if (relativePosition) {
+        const { above = 0, below = 0, left = 0, right = 0 } = relativePosition;
+        x = x - left + right;
+        y = y - above + below;
+    }
+    // Draw a target on the image so a user can see where the click will happen
+    await drawTarget({ filePath: element.filePath, targetX: x, targetY: y });
+    const actionType = browser.isMobile ? 'touch' : 'mouse';
+    const clickDuration = options.clickDuration ? options.clickDuration : 500;
+    await browser
+        .action('pointer', {
+        parameters: { pointerType: actionType }
+    })
+        .move({ duration: 0, x, y })
+        .down({ button: 0 })
+        .pause(clickDuration)
+        .up({ button: 0 })
+        .perform();
+}

package/dist/commands/ocrGetElementPositionByText.d.ts

@@ -0,0 +1,3 @@
+import type { OcrGetElementPositionByText, OcrGetElementPositionByTextOptions } from '../types.js';
+export default function ocrGetElementPositionByText(data: OcrGetElementPositionByTextOptions): Promise<OcrGetElementPositionByText>;
+//# sourceMappingURL=ocrGetElementPositionByText.d.ts.map

package/dist/commands/ocrGetElementPositionByText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocrGetElementPositionByText.d.ts","sourceRoot":"","sources":["../../src/commands/ocrGetElementPositionByText.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAgB,2BAA2B,EAAE,kCAAkC,EAAE,MAAM,aAAa,CAAA;AAMhH,wBAA8B,2BAA2B,CACrD,IAAI,EAAE,kCAAkC,GACzC,OAAO,CAAC,2BAA2B,CAAC,CAuDtC"}

package/dist/commands/ocrGetElementPositionByText.js

@@ -0,0 +1,46 @@
+import logger from '@wdio/logger';
+import getTextPositions from '../utils/getTextPositions.js';
+import { fuzzyFind } from '../utils/fuzzySearch.js';
+const log = logger('@wdio/ocr-service:ocrGetElementPositionByText');
+export default async function ocrGetElementPositionByText(data) {
+    const { contrast, haystack, fuzzyFindOptions, isTesseractAvailable, language, ocrImagesPath, text, } = data;
+    const textPositions = await getTextPositions({
+        contrast,
+        haystack,
+        isTesseractAvailable,
+        language,
+        ocrImagesPath,
+    });
+    const matches = fuzzyFind({
+        pattern: text,
+        searchOptions: fuzzyFindOptions,
+        textArray: textPositions,
+    });
+    let matchedTextElements;
+    let score;
+    if (matches.length === 0) {
+        log.warn(`No matches were found based on the word "${text}"`);
+        throw new Error(`Invalid Text Selector Match. Visual OCR has failed to find the word '${text}' in the image`);
+    }
+    else if (matches.length > 1) {
+        matches.sort((a, b) => (a.score > b.score ? 1 : -1));
+        matchedTextElements = matches[0];
+        score = Number(((1 - matchedTextElements.score) * 100).toFixed(2));
+        const messageOne = `Multiple matches were found based on the word "${text}".`;
+        const messageTwo = `The match "${matchedTextElements.item.text}" with score "${score}%" will be used.`;
+        log.info(`${messageOne} ${messageTwo}`);
+    }
+    else {
+        matchedTextElements = matches[0];
+        score = Number(((1 - matchedTextElements.score) * 100).toFixed(2));
+        log.info(`We searched for the word "${text}" and found one match "${matchedTextElements.item.text}" with score "${score}%"`);
+    }
+    return {
+        dprPosition: matchedTextElements.item.dprPosition,
+        filePath: matchedTextElements.item.filePath,
+        matchedString: matchedTextElements.item.text,
+        originalPosition: matchedTextElements.item.originalPosition,
+        score,
+        searchValue: text,
+    };
+}

package/dist/commands/ocrGetText.d.ts

@@ -0,0 +1,3 @@
+import type { OcrGetTextOptions } from '../types.js';
+export default function ocrGetText(options: OcrGetTextOptions): Promise<string>;
+//# sourceMappingURL=ocrGetText.d.ts.map

package/dist/commands/ocrGetText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocrGetText.d.ts","sourceRoot":"","sources":["../../src/commands/ocrGetText.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEpD,wBAA8B,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAIpF"}

package/dist/commands/ocrGetText.js

@@ -0,0 +1,5 @@
+import getData from '../utils/getData.js';
+export default async function ocrGetText(options) {
+    const { text } = await getData(options);
+    return text.replace(/\n\s*\n/g, '\n');
+}

package/dist/commands/ocrSetValue.d.ts

@@ -0,0 +1,3 @@
+import type { OcrSetValueOptions } from '../types.js';
+export default function ocrSetValue(options: OcrSetValueOptions): Promise<void>;
+//# sourceMappingURL=ocrSetValue.d.ts.map

package/dist/commands/ocrSetValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocrSetValue.d.ts","sourceRoot":"","sources":["../../src/commands/ocrSetValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAIrD,wBAA8B,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmDpF"}

package/dist/commands/ocrSetValue.js

@@ -0,0 +1,38 @@
+import sendKeys from '../utils/sendKeys.js';
+import ocrClickOnText from './ocrClickOnText.js';
+export default async function ocrSetValue(options) {
+    const { contrast, clickDuration, haystack, fuzzyFindOptions, isTesseractAvailable, language, ocrImagesPath, submitValue = false, text, value, } = options;
+    // 1. First click on the position of the text to make sure it is intractable
+    await ocrClickOnText({
+        contrast,
+        clickDuration,
+        haystack,
+        fuzzyFindOptions,
+        isTesseractAvailable,
+        language,
+        ocrImagesPath,
+        text,
+    });
+    // 2. If Mobile then a keyboard might be shown
+    if (driver.isMobile) {
+        try {
+            // Wait for 3 seconds for the keyboard to be shown
+            await driver.waitUntil(async () => driver.isKeyboardShown(), { timeout: 3 * 1000 });
+        }
+        catch (ign) {
+            // Keyboard is not shown
+        }
+    }
+    // 3. Send the value to the active element
+    await sendKeys(value, submitValue);
+    // 4. If Mobile then hide the keyboard
+    if (driver.isMobile) {
+        try {
+            await driver.hideKeyboard();
+            await driver.waitUntil(async () => !(await driver.isKeyboardShown()), { timeout: 3 * 1000 });
+        }
+        catch (ign) {
+            // Keyboard is not present or not hidden
+        }
+    }
+}

package/dist/commands/ocrWaitForTextDisplayed.d.ts

@@ -0,0 +1,3 @@
+import type { OcrWaitForTextDisplayedOptions } from '../types.js';
+export default function ocrWaitForTextDisplayed(options: OcrWaitForTextDisplayedOptions): Promise<import("../types.js").OcrGetElementPositionByText>;
+//# sourceMappingURL=ocrWaitForTextDisplayed.d.ts.map

package/dist/commands/ocrWaitForTextDisplayed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocrWaitForTextDisplayed.d.ts","sourceRoot":"","sources":["../../src/commands/ocrWaitForTextDisplayed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAA;AAGjE,wBAA8B,uBAAuB,CACjD,OAAO,EAAE,8BAA8B,8DAW1C"}

package/dist/commands/ocrWaitForTextDisplayed.js

@@ -0,0 +1,8 @@
+import ocrGetElementPositionByText from './ocrGetElementPositionByText.js';
+export default async function ocrWaitForTextDisplayed(options) {
+    const { timeout, timeoutMsg } = options;
+    return driver.waitUntil(async () => ocrGetElementPositionByText(options), {
+        timeout: timeout || 180000,
+        timeoutMsg: timeoutMsg || `Could not find the text "${options.text}" within the requested time.`,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,90 @@
+import WdioOcrService from './service.js';
+import type { ClickOnTextOptions, GetElementPositionByTextOptions, GetTextOptions, OcrGetElementPositionByText, SetValueOptions, WaitForTextDisplayedOptions } from './types.js';
+declare global {
+    namespace WebdriverIO {
+        interface Browser {
+            /**
+             * Get the text of an image base on OCR
+             */
+            ocrGetText(options?: GetTextOptions): Promise<string>;
+            /**
+             * Get the text of an image base on OCR
+             */
+            ocrGetElementPositionByText(options: GetElementPositionByTextOptions): Promise<OcrGetElementPositionByText>;
+            /**
+             * Click on an element based on text
+             */
+            ocrClickOnText(options: ClickOnTextOptions): Promise<void>;
+            /**
+             * Set value on an element based on text
+             */
+            ocrSetValue(options: SetValueOptions): Promise<void>;
+            /**
+             * Wait for the text to be displayed based on OCR
+             */
+            ocrWaitForTextDisplayed(options: WaitForTextDisplayedOptions): Promise<void>;
+        }
+        interface Element {
+        }
+    }
+}
+export default WdioOcrService;
+export declare const SUPPORTED_OCR_LANGUAGES: {
+    AFRIKAANS: string;
+    AMHARIC: string;
+    ARABIC: string;
+    ASSANESE: string;
+    AZERBAIJANI: string;
+    BELARUSIAN: string;
+    BENGALI: string;
+    TIBETAN: string;
+    BOSNIAN: string;
+    BULGARIAN: string;
+    CATALAN: string;
+    CZECH: string;
+    CHINESE: string;
+    CORSICAN: string;
+    DANISH: string;
+    GERMAN: string;
+    GREEK: string;
+    ENGLISH: string;
+    MATH: string;
+    ESTONIAN: string;
+    FINNISH: string;
+    FRENCH: string;
+    GAELIC: string;
+    IRISH: string; /**
+     * Get the text of an image base on OCR
+     */
+    HINDI: string;
+    CROATIAN: string;
+    HUNGARIAN: string;
+    ARMENIAN: string;
+    ITALIAN: string;
+    JAPANESE: string;
+    KANNADA: string;
+    KOREAN: string;
+    LATIN: string;
+    LATVIAN: string;
+    LITHUANIAN: string;
+    LUXEMBOURGISH: string;
+    MACEDONIAN: string;
+    DUTCH: string;
+    NORWEGIAN: string;
+    POLISH: string;
+    PORTUGUESE: string;
+    ROMANIAN: string;
+    RUSSIAN: string;
+    SLOVAK: string;
+    SLOVENIAN: string;
+    SPANISH: string;
+    ALBANIAN: string;
+    SERBIAN: string;
+    SWAHILI: string;
+    SWEDISH: string;
+    THAI: string;
+    TURKISH: string;
+    UKRAINIAN: string;
+    VIETNAMESE: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,MAAM,cAAc,CAAA;AACzC,OAAO,KAAK,EACR,kBAAkB,EAClB,+BAA+B,EAC/B,cAAc,EACd,2BAA2B,EAC3B,eAAe,EACf,2BAA2B,EAC9B,MAAM,YAAY,CAAA;AAGnB,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,WAAW,CAAC;QAClB,UAAU,OAAO;YACb;;eAEG;YACH,UAAU,CACN,OAAO,CAAC,EAAE,cAAc,GACzB,OAAO,CAAC,MAAM,CAAC,CAAC;YAEnB;;eAEG;YACH,2BAA2B,CACvB,OAAO,EAAE,+BAA+B,GACzC,OAAO,CAAC,2BAA2B,CAAC,CAAC;YAExC;;eAEG;YACH,cAAc,CACV,OAAO,EAAE,kBAAkB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAAC;YAEjB;;eAEG;YACH,WAAW,CACP,OAAO,EAAE,eAAe,GACzB,OAAO,CAAC,IAAI,CAAC,CAAC;YAEjB;;eAEG;YACH,uBAAuB,CACnB,OAAO,EAAE,2BAA2B,GACrC,OAAO,CAAC,IAAI,CAAC,CAAC;SACpB;QACD,UAAU,OAAO;SAAI;KACxB;CACJ;AAED,eAAe,cAAc,CAAA;AAC7B,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;mBAjCxB;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+B2C,CAAA"}

package/dist/index.js

@@ -0,0 +1,4 @@
+import WdioOcrService from './service.js';
+import { SUPPORTED_LANGUAGES } from './utils/constants.js';
+export default WdioOcrService;
+export const SUPPORTED_OCR_LANGUAGES = SUPPORTED_LANGUAGES;

package/dist/service.d.ts

@@ -0,0 +1,15 @@
+import type { OcrOptions } from './types.js';
+export default class WdioOcrService {
+    #private;
+    private _browser?;
+    private _ocrDir;
+    private _ocrLanguage;
+    private _ocrContrast;
+    constructor(options: OcrOptions);
+    /**
+     * Set up the service if users want to use it in standalone mode
+     */
+    remoteSetup(browser: WebdriverIO.Browser | WebdriverIO.MultiRemoteBrowser): Promise<void>;
+    before(capabilities: WebdriverIO.Capabilities, _specs: string[], browser: WebdriverIO.Browser | WebdriverIO.MultiRemoteBrowser): Promise<void>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAgB5C,MAAM,CAAC,OAAO,OAAO,cAAc;;IAC/B,OAAO,CAAC,QAAQ,CAAC,CAAsD;IACvE,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,YAAY,CAAQ;gBAEhB,OAAO,EAAE,UAAU;IAM/B;;OAEG;IACG,WAAW,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,kBAAkB;IAIzE,MAAM,CACR,YAAY,EAAE,WAAW,CAAC,YAAY,EACtC,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,EAAE,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,kBAAkB;CA2EpE"}

package/dist/service.js

@@ -0,0 +1,97 @@
+import logger from '@wdio/logger';
+import { isSystemTesseractAvailable } from './utils/tesseract.js';
+import { CONTRAST, DEFAULT_IMAGES_FOLDER, SUPPORTED_LANGUAGES } from './utils/constants.js';
+import { createOcrDir } from './utils/index.js';
+import ocrGetText from './commands/ocrGetText.js';
+import ocrGetElementPositionByText from './commands/ocrGetElementPositionByText.js';
+import ocrWaitForTextDisplayed from './commands/ocrWaitForTextDisplayed.js';
+import ocrClickOnText from './commands/ocrClickOnText.js';
+import ocrSetValue from './commands/ocrSetValue.js';
+const log = logger('@wdio/ocr-service');
+const ocrCommands = {
+    ocrGetText,
+    ocrGetElementPositionByText,
+    ocrWaitForTextDisplayed,
+    ocrClickOnText,
+    ocrSetValue,
+};
+export default class WdioOcrService {
+    _browser;
+    _ocrDir;
+    _ocrLanguage;
+    _ocrContrast;
+    constructor(options) {
+        this._ocrDir = createOcrDir(options?.imagesFolder || DEFAULT_IMAGES_FOLDER);
+        this._ocrLanguage = options?.language || SUPPORTED_LANGUAGES.ENGLISH;
+        this._ocrContrast = options?.contrast || CONTRAST;
+    }
+    /**
+     * Set up the service if users want to use it in standalone mode
+     */
+    async remoteSetup(browser) {
+        await this.before(browser.capabilities, [], browser);
+    }
+    async before(capabilities, _specs, browser) {
+        this._browser = browser;
+        if (!this._browser.isMultiremote) {
+            log.info('Adding commands to global browser');
+            await this.#addCommandsToBrowser(this._browser);
+        }
+        else {
+            await this.#extendMultiremoteBrowser(capabilities);
+        }
+    }
+    async #extendMultiremoteBrowser(capabilities) {
+        const browser = this._browser;
+        const browserNames = Object.keys(capabilities);
+        const self = this;
+        log.info(`Adding commands to Multi Browser: ${browserNames.join(', ')}`);
+        for (const browserName of browserNames) {
+            const multiremoteBrowser = browser;
+            const browserInstance = multiremoteBrowser.getInstance(browserName);
+            await this.#addCommandsToBrowser(browserInstance);
+        }
+        /**
+         * Add all OCR commands to the global browser object that will execute
+         * on each browser in the Multi Remote. This involves mapping through both the visualElementCommands,
+         * visualPageCommands, and ocrCommands.
+         */
+        for (const command of Object.keys(ocrCommands)) {
+            browser.addCommand(command, async function (...args) {
+                const returnData = {};
+                if (typeof args[0] === 'object' && args[0] !== null) {
+                    const options = args[0];
+                    options.contrast = options.contrast || self._ocrContrast;
+                    args[0] = options;
+                }
+                for (const browserName of browserNames) {
+                    const multiremoteBrowser = browser;
+                    const browserInstance = multiremoteBrowser.getInstance(browserName);
+                    if (typeof browserInstance[command] === 'function') {
+                        returnData[browserName] = await browserInstance[command].apply(browserInstance, args);
+                    }
+                    else {
+                        throw new Error(`Command ${command} is not a function on the browser instance ${browserName}`);
+                    }
+                }
+                return returnData;
+            });
+        }
+    }
+    async #addCommandsToBrowser(currentBrowser) {
+        const isTesseractAvailable = isSystemTesseractAvailable();
+        const self = this;
+        for (const [commandName, command] of Object.entries(ocrCommands)) {
+            log.info(`Adding browser command "${commandName}" to browser object`);
+            currentBrowser.addCommand(commandName, function (options) {
+                return command({
+                    ...options,
+                    contrast: options.contrast || self._ocrContrast,
+                    isTesseractAvailable,
+                    language: options.language || self._ocrLanguage,
+                    ocrImagesPath: self._ocrDir,
+                });
+            });
+        }
+    }
+}