automation_model 1.0.400-dev → 1.0.400-main

package/lib/stable_browser.js

@@ -2,17 +2,22 @@
 import { expect } from "@playwright/test";
 import dayjs from "dayjs";
 import fs from "fs";
+import { Jimp } from "jimp";
 import path from "path";
 import reg_parser from "regex-parser";
-import sharp from "sharp";
 import { findDateAlternatives, findNumberAlternatives } from "./analyze_helper.js";
 import { getDateTimeValue } from "./date_time.js";
 import drawRectangle from "./drawRect.js";
 //import { closeUnexpectedPopups } from "./popups.js";
 import { getTableCells, getTableData } from "./table_analyze.js";
-import objectPath from "object-path";
-import { decrypt } from "./utils.js";
+import { maskValue, replaceWithLocalTestData } from "./utils.js";
 import csv from "csv-parser";
+import { Readable } from "node:stream";
+import readline from "readline";
+import { getContext } from "./init_browser.js";
+import { locate_element } from "./locate_element.js";
+import { _commandError, _commandFinally, _preCommand, _validateSelectors, _screenshot } from "./command_common.js";
+import { registerDownloadEvent, registerNetworkEvents } from "./network.js";
 const Types = {
     CLICK: "click_element",
     NAVIGATE: "navigate",
@@ -37,16 +42,27 @@ const Types = {
     SET_DATE_TIME: "set_date_time",
     SET_VIEWPORT: "set_viewport",
     VERIFY_VISUAL: "verify_visual",
+    LOAD_DATA: "load_data",
+    SET_INPUT: "set_input",
 };
+export const apps = {};
 class StableBrowser {
-    constructor(browser, page, logger = null, context = null) {
+    browser;
+    page;
+    logger;
+    context;
+    world;
+    project_path = null;
+    webLogFile = null;
+    networkLogger = null;
+    configuration = null;
+    appName = "main";
+    constructor(browser, page, logger = null, context = null, world = null) {
         this.browser = browser;
         this.page = page;
         this.logger = logger;
         this.context = context;
-        this.project_path = null;
-        this.webLogFile = null;
-        this.configuration = null;
+        this.world = world;
         if (!this.logger) {
             this.logger = console;
         }
@@ -72,19 +88,45 @@ class StableBrowser {
             this.logger.error("unable to read ai_config.json");
         }
         const logFolder = path.join(this.project_path, "logs", "web");
-        this.webLogFile = this.getWebLogFile(logFolder);
-        this.registerConsoleLogListener(page, context, this.webLogFile);
-        this.registerRequestListener();
+        this.world = world;
         context.pages = [this.page];
         context.pageLoading = { status: false };
+        this.registerEventListeners(this.context);
+        registerNetworkEvents(this.world, this, this.context, this.page);
+        registerDownloadEvent(this.page, this.world, this.context);
+    }
+    registerEventListeners(context) {
+        this.registerConsoleLogListener(this.page, context);
+        this.registerRequestListener(this.page, context, this.webLogFile);
+        if (!context.pageLoading) {
+            context.pageLoading = { status: false };
+        }
         context.playContext.on("page", async function (page) {
+            if (this.configuration && this.configuration.closePopups === true) {
+                console.log("close unexpected popups");
+                await page.close();
+                return;
+            }
             context.pageLoading.status = true;
             this.page = page;
             context.page = page;
             context.pages.push(page);
-            this.webLogFile = this.getWebLogFile(logFolder);
-            this.registerConsoleLogListener(page, context, this.webLogFile);
-            this.registerRequestListener();
+            registerNetworkEvents(this.world, this, context, this.page);
+            registerDownloadEvent(this.page, this.world, context);
+            page.on("close", async () => {
+                if (this.context && this.context.pages && this.context.pages.length > 1) {
+                    this.context.pages.pop();
+                    this.page = this.context.pages[this.context.pages.length - 1];
+                    this.context.page = this.page;
+                    try {
+                        let title = await this.page.title();
+                        console.log("Switched to page " + title);
+                    }
+                    catch (error) {
+                        console.error("Error on page close", error);
+                    }
+                }
+            });
             try {
                 await this.waitForPageLoad();
                 console.log("Switch page: " + (await page.title()));
@@ -95,6 +137,36 @@ class StableBrowser {
             context.pageLoading.status = false;
         }.bind(this));
     }
+    async switchApp(appName) {
+        // check if the current app (this.appName) is the same as the new app
+        if (this.appName === appName) {
+            return;
+        }
+        let navigate = false;
+        if (!apps[appName]) {
+            let newContext = await getContext(null, false, this.logger, appName, false, this);
+            navigate = true;
+            apps[appName] = {
+                context: newContext,
+                browser: newContext.browser,
+                page: newContext.page,
+            };
+        }
+        const tempContext = {};
+        this._copyContext(this, tempContext);
+        this._copyContext(apps[appName], this);
+        apps[this.appName] = tempContext;
+        this.appName = appName;
+        if (navigate) {
+            await this.goto(this.context.environment.baseUrl);
+            await this.waitForPageLoad();
+        }
+    }
+    _copyContext(from, to) {
+        to.browser = from.browser;
+        to.page = from.page;
+        to.context = from.context;
+    }
     getWebLogFile(logFolder) {
         if (!fs.existsSync(logFolder)) {
             fs.mkdirSync(logFolder, { recursive: true });
@@ -106,37 +178,63 @@ class StableBrowser {
         const fileName = nextIndex + ".json";
         return path.join(logFolder, fileName);
     }
-    registerConsoleLogListener(page, context, logFile) {
+    registerConsoleLogListener(page, context) {
         if (!this.context.webLogger) {
             this.context.webLogger = [];
         }
         page.on("console", async (msg) => {
-            this.context.webLogger.push({
+            const obj = {
                 type: msg.type(),
                 text: msg.text(),
                 location: msg.location(),
                 time: new Date().toISOString(),
-            });
-            await fs.promises.writeFile(logFile, JSON.stringify(this.context.webLogger, null, 2));
+            };
+            this.context.webLogger.push(obj);
+            if (msg.type() === "error") {
+                this.world?.attach(JSON.stringify(obj), { mediaType: "application/json+log" });
+            }
         });
     }
-    registerRequestListener() {
-        this.page.on("request", async (data) => {
+    registerRequestListener(page, context, logFile) {
+        if (!this.context.networkLogger) {
+            this.context.networkLogger = [];
+        }
+        page.on("request", async (data) => {
+            const startTime = new Date().getTime();
             try {
-                const pageUrl = new URL(this.page.url());
+                const pageUrl = new URL(page.url());
                 const requestUrl = new URL(data.url());
                 if (pageUrl.hostname === requestUrl.hostname) {
                     const method = data.method();
-                    if (method === "POST" || method === "GET" || method === "PUT" || method === "DELETE" || method === "PATCH") {
+                    if (["POST", "GET", "PUT", "DELETE", "PATCH"].includes(method)) {
                         const token = await data.headerValue("Authorization");
                         if (token) {
-                            this.context.authtoken = token;
+                            context.authtoken = token;
                         }
                     }
                 }
+                const response = await data.response();
+                const endTime = new Date().getTime();
+                const obj = {
+                    url: data.url(),
+                    method: data.method(),
+                    postData: data.postData(),
+                    error: data.failure() ? data.failure().errorText : null,
+                    duration: endTime - startTime,
+                    startTime,
+                };
+                context.networkLogger.push(obj);
+                this.world?.attach(JSON.stringify(obj), { mediaType: "application/json+network" });
             }
             catch (error) {
                 console.error("Error in request listener", error);
+                context.networkLogger.push({
+                    error: "not able to listen",
+                    message: error.message,
+                    stack: error.stack,
+                    time: new Date().toISOString(),
+                });
+                // await fs.promises.writeFile(logFile, JSON.stringify(context.networkLogger, null, 2));
             }
         });
     }
@@ -151,20 +249,6 @@ class StableBrowser {
             timeout: 60000,
         });
     }
-    _validateSelectors(selectors) {
-        if (!selectors) {
-            throw new Error("selectors is null");
-        }
-        if (!selectors.locators) {
-            throw new Error("selectors.locators is null");
-        }
-        if (!Array.isArray(selectors.locators)) {
-            throw new Error("selectors.locators expected to be array");
-        }
-        if (selectors.locators.length === 0) {
-            throw new Error("selectors.locators expected to be non empty array");
-        }
-    }
     _fixUsingParams(text, _params) {
         if (!_params || typeof text !== "string") {
             return text;
@@ -179,27 +263,84 @@ class StableBrowser {
         }
         return text;
     }
-    _getLocator(locator, scope, _params) {
-        if (locator.type === "pw_selector") {
-            return scope.locator(locator.selector);
+    _fixLocatorUsingParams(locator, _params) {
+        // check if not null
+        if (!locator) {
+            return locator;
+        }
+        // clone the locator
+        locator = JSON.parse(JSON.stringify(locator));
+        this.scanAndManipulate(locator, _params);
+        return locator;
+    }
+    _isObject(value) {
+        return value && typeof value === "object" && value.constructor === Object;
+    }
+    scanAndManipulate(currentObj, _params) {
+        for (const key in currentObj) {
+            if (typeof currentObj[key] === "string") {
+                // Perform string manipulation
+                currentObj[key] = this._fixUsingParams(currentObj[key], _params);
+            }
+            else if (this._isObject(currentObj[key])) {
+                // Recursively scan nested objects
+                this.scanAndManipulate(currentObj[key], _params);
+            }
         }
+    }
+    _getLocator(locator, scope, _params) {
+        locator = this._fixLocatorUsingParams(locator, _params);
+        let locatorReturn;
         if (locator.role) {
             if (locator.role[1].nameReg) {
                 locator.role[1].name = reg_parser(locator.role[1].nameReg);
                 delete locator.role[1].nameReg;
             }
-            if (locator.role[1].name) {
-                locator.role[1].name = this._fixUsingParams(locator.role[1].name, _params);
-            }
-            return scope.getByRole(locator.role[0], locator.role[1]);
+            // if (locator.role[1].name) {
+            //   locator.role[1].name = this._fixUsingParams(locator.role[1].name, _params);
+            // }
+            locatorReturn = scope.getByRole(locator.role[0], locator.role[1]);
         }
         if (locator.css) {
-            return scope.locator(this._fixUsingParams(locator.css, _params));
+            locatorReturn = scope.locator(locator.css);
         }
-        throw new Error("unknown locator type");
+        // handle role/name locators
+        // locator.selector will be something like: textbox[name="Username"i]
+        if (locator.engine === "internal:role") {
+            // extract the role, name and the i/s flags using regex
+            const match = locator.selector.match(/(.*)\[(.*)="(.*)"(.*)\]/);
+            if (match) {
+                const role = match[1];
+                const name = match[3];
+                const flags = match[4];
+                locatorReturn = scope.getByRole(role, { name }, { exact: flags === "i" });
+            }
+        }
+        if (locator?.engine) {
+            if (locator.engine === "css") {
+                locatorReturn = scope.locator(locator.selector);
+            }
+            else {
+                let selector = locator.selector;
+                if (locator.engine === "internal:attr") {
+                    if (!selector.startsWith("[")) {
+                        selector = `[${selector}]`;
+                    }
+                }
+                locatorReturn = scope.locator(`${locator.engine}=${selector}`);
+            }
+        }
+        if (!locatorReturn) {
+            console.error(locator);
+            throw new Error("Locator undefined");
+        }
+        return locatorReturn;
     }
     async _locateElmentByTextClimbCss(scope, text, climb, css, _params) {
-        let result = await this._locateElementByText(scope, this._fixUsingParams(text, _params), "*", false, true, _params);
+        if (css && css.locator) {
+            css = css.locator;
+        }
+        let result = await this._locateElementByText(scope, this._fixUsingParams(text, _params), "*", false, false, _params);
         if (result.elementCount === 0) {
             return;
         }
@@ -214,7 +355,7 @@ class StableBrowser {
     }
     async _locateElementByText(scope, text1, tag1, regex1 = false, partial1, _params) {
         //const stringifyText = JSON.stringify(text);
-        return await scope.evaluate(([text, tag, regex, partial]) => {
+        return await scope.locator(":root").evaluate((_node, [text, tag, regex, partial]) => {
             function isParent(parent, child) {
                 let currentNode = child.parentNode;
                 while (currentNode !== null) {
@@ -226,6 +367,15 @@ class StableBrowser {
                 return false;
             }
             document.isParent = isParent;
+            function getRegex(str) {
+                const match = str.match(/^\/(.*?)\/([gimuy]*)$/);
+                if (!match) {
+                    return null;
+                }
+                let [_, pattern, flags] = match;
+                return new RegExp(pattern, flags);
+            }
+            document.getRegex = getRegex;
             function collectAllShadowDomElements(element, result = []) {
                 // Check and add the element if it has a shadow root
                 if (element.shadowRoot) {
@@ -244,6 +394,10 @@ class StableBrowser {
             if (!tag) {
                 tag = "*";
             }
+            let regexpSearch = document.getRegex(text);
+            if (regexpSearch) {
+                regex = true;
+            }
             let elements = Array.from(document.querySelectorAll(tag));
             let shadowHosts = [];
             document.collectAllShadowDomElements(document, shadowHosts);
@@ -259,7 +413,9 @@ class StableBrowser {
             let randomToken = null;
             const foundElements = [];
             if (regex) {
-                let regexpSearch = new RegExp(text, "im");
+                if (!regexpSearch) {
+                    regexpSearch = new RegExp(text, "im");
+                }
                 for (let i = 0; i < elements.length; i++) {
                     const element = elements[i];
                     if ((element.innerText && regexpSearch.test(element.innerText)) ||
@@ -273,8 +429,8 @@ class StableBrowser {
                 for (let i = 0; i < elements.length; i++) {
                     const element = elements[i];
                     if (partial) {
-                        if ((element.innerText && element.innerText.trim().includes(text)) ||
-                            (element.value && element.value.includes(text))) {
+                        if ((element.innerText && element.innerText.toLowerCase().trim().includes(text.toLowerCase())) ||
+                            (element.value && element.value.toLowerCase().includes(text.toLowerCase()))) {
                             foundElements.push(element);
                         }
                     }
@@ -319,6 +475,12 @@ class StableBrowser {
     }
     async _collectLocatorInformation(selectorHierarchy, index = 0, scope, foundLocators, _params, info, visibleOnly = true) {
         let locatorSearch = selectorHierarchy[index];
+        try {
+            locatorSearch = JSON.parse(this._fixUsingParams(JSON.stringify(locatorSearch), _params));
+        }
+        catch (e) {
+            console.error(e);
+        }
         //info.log += "searching for locator " + JSON.stringify(locatorSearch) + "\n";
         let locator = null;
         if (locatorSearch.climb && locatorSearch.climb >= 0) {
@@ -407,15 +569,20 @@ class StableBrowser {
                 if (result.foundElements.length > 0) {
                     let dialogCloseLocator = result.foundElements[0].locator;
                     await dialogCloseLocator.click();
+                    // wait for the dialog to close
+                    await dialogCloseLocator.waitFor({ state: "hidden" });
                     return { rerun: true };
                 }
             }
         }
         return { rerun: false };
     }
-    async _locate(selectors, info, _params, timeout = 30000) {
+    async _locate(selectors, info, _params, timeout) {
+        if (!timeout) {
+            timeout = 30000;
+        }
         for (let i = 0; i < 3; i++) {
-            info.log += "attempt " + i + ": totoal locators " + selectors.locators.length + "\n";
+            info.log += "attempt " + i + ": total locators " + selectors.locators.length + "\n";
             for (let j = 0; j < selectors.locators.length; j++) {
                 let selector = selectors.locators[j];
                 info.log += "searching for locator " + j + ":" + JSON.stringify(selector) + "\n";
@@ -427,17 +594,44 @@ class StableBrowser {
         }
         throw new Error("unable to locate element " + JSON.stringify(selectors));
     }
-    async _locate_internal(selectors, info, _params, timeout = 30000) {
-        let highPriorityTimeout = 5000;
-        let visibleOnlyTimeout = 6000;
-        let startTime = performance.now();
-        let locatorsCount = 0;
-        //let arrayMode = Array.isArray(selectors);
+    async _findFrameScope(selectors, timeout = 30000) {
         let scope = this.page;
+        if (selectors.frame) {
+            return selectors.frame;
+        }
         if (selectors.iframe_src || selectors.frameLocators) {
-            info.log += "searching for iframe " + selectors.iframe_src + "/" + selectors.frameLocators + "\n";
+            const findFrame = async (frame, framescope) => {
+                for (let i = 0; i < frame.selectors.length; i++) {
+                    let frameLocator = frame.selectors[i];
+                    if (frameLocator.css) {
+                        let testframescope = framescope.frameLocator(frameLocator.css);
+                        if (frameLocator.index) {
+                            testframescope = framescope.nth(frameLocator.index);
+                        }
+                        try {
+                            await testframescope.owner().evaluateHandle(() => true, null, {
+                                timeout: 5000,
+                            });
+                            framescope = testframescope;
+                            break;
+                        }
+                        catch (error) {
+                            console.error("frame not found " + frameLocator.css);
+                        }
+                    }
+                }
+                if (frame.children) {
+                    return await findFrame(frame.children, framescope);
+                }
+                return framescope;
+            };
             while (true) {
                 let frameFound = false;
+                if (selectors.nestFrmLoc) {
+                    scope = await findFrame(selectors.nestFrmLoc, scope);
+                    frameFound = true;
+                    break;
+                }
                 if (selectors.frameLocators) {
                     for (let i = 0; i < selectors.frameLocators.length; i++) {
                         let frameLocator = selectors.frameLocators[i];
@@ -463,6 +657,25 @@ class StableBrowser {
                 }
             }
         }
+        if (!scope) {
+            scope = this.page;
+        }
+        return scope;
+    }
+    async _getDocumentBody(selectors, timeout = 30000) {
+        let scope = await this._findFrameScope(selectors, timeout);
+        return scope.evaluate(() => {
+            var bodyContent = document.body.innerHTML;
+            return bodyContent;
+        });
+    }
+    async _locate_internal(selectors, info, _params, timeout = 30000) {
+        let highPriorityTimeout = 5000;
+        let visibleOnlyTimeout = 6000;
+        let startTime = performance.now();
+        let locatorsCount = 0;
+        //let arrayMode = Array.isArray(selectors);
+        let scope = await this._findFrameScope(selectors, timeout);
         let selectorsLocators = null;
         selectorsLocators = selectors.locators;
         // group selectors by priority
@@ -598,83 +811,121 @@ class StableBrowser {
         }
         return result;
     }
-    async click(selectors, _params, options = {}, world = null) {
-        this._validateSelectors(selectors);
+    async simpleClick(elementDescription, _params, options = {}, world = null) {
         const startTime = Date.now();
-        const info = {};
-        info.log = "***** click on " + selectors.element_name + " *****\n";
-        info.operation = "click";
-        info.selectors = selectors;
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
+        let timeout = 30000;
+        if (options && options.timeout) {
+            timeout = options.timeout;
+        }
+        while (true) {
+            try {
+                const result = await locate_element(this.context, elementDescription, "click");
+                if (result?.elementNumber >= 0) {
+                    const selectors = {
+                        frame: result?.frame,
+                        locators: [
+                            {
+                                css: result?.css,
+                            },
+                        ],
+                    };
+                    await this.click(selectors, _params, options, world);
+                    return;
+                }
+            }
+            catch (e) {
+                if (performance.now() - startTime > timeout) {
+                    throw e;
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+        }
+    }
+    async simpleClickType(elementDescription, value, _params, options = {}, world = null) {
+        const startTime = Date.now();
+        let timeout = 30000;
+        if (options && options.timeout) {
+            timeout = options.timeout;
+        }
+        while (true) {
+            try {
+                const result = await locate_element(this.context, elementDescription, "fill", value);
+                if (result?.elementNumber >= 0) {
+                    const selectors = {
+                        frame: result?.frame,
+                        locators: [
+                            {
+                                css: result?.css,
+                            },
+                        ],
+                    };
+                    await this.clickType(selectors, value, false, _params, options, world);
+                    return;
+                }
+            }
+            catch (e) {
+                if (performance.now() - startTime > timeout) {
+                    throw e;
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+        }
+    }
+    async click(selectors, _params, options = {}, world = null) {
+        const state = {
+            selectors,
+            _params,
+            options,
+            world,
+            text: "Click element",
+            type: Types.CLICK,
+            operation: "click",
+            log: "***** click on " + selectors.element_name + " *****\n",
+        };
         try {
-            let element = await this._locate(selectors, info, _params);
-            await this.scrollIfNeeded(element, info);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
+            await _preCommand(state, this);
+            if (state.options && state.options.context) {
+                state.selectors.locators[0].text = state.options.context;
+            }
             try {
-                await this._highlightElements(element);
-                await element.click({ timeout: 5000 });
+                await state.element.click();
                 await new Promise((resolve) => setTimeout(resolve, 1000));
             }
             catch (e) {
                 // await this.closeUnexpectedPopups();
-                info.log += "click failed, will try again" + "\n";
-                element = await this._locate(selectors, info, _params);
-                await element.click({ timeout: 10000, force: true });
+                state.element = await this._locate(selectors, state.info, _params);
+                await state.element.dispatchEvent("click");
                 await new Promise((resolve) => setTimeout(resolve, 1000));
             }
             await this.waitForPageLoad();
-            return info;
+            return state.info;
         }
         catch (e) {
-            this.logger.error("click failed " + info.log);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            error = e;
-            throw e;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: Types.CLICK,
-                text: `Click element`,
-                screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
     async setCheck(selectors, checked = true, _params, options = {}, world = null) {
-        this._validateSelectors(selectors);
-        const startTime = Date.now();
-        const info = {};
-        info.log = "";
-        info.operation = "setCheck";
-        info.checked = checked;
-        info.selectors = selectors;
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
+        const state = {
+            selectors,
+            _params,
+            options,
+            world,
+            type: checked ? Types.CHECK : Types.UNCHECK,
+            text: checked ? `Check element` : `Uncheck element`,
+            operation: "setCheck",
+            log: "***** check " + selectors.element_name + " *****\n",
+        };
         try {
-            let element = await this._locate(selectors, info, _params);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
+            await _preCommand(state, this);
+            state.info.checked = checked;
+            // let element = await this._locate(selectors, info, _params);
+            // ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
             try {
-                await this._highlightElements(element);
-                await element.setChecked(checked, { timeout: 5000 });
+                // await this._highlightElements(element);
+                await state.element.setChecked(checked);
                 await new Promise((resolve) => setTimeout(resolve, 1000));
             }
             catch (e) {
@@ -683,179 +934,108 @@ class StableBrowser {
                 }
                 else {
                     //await this.closeUnexpectedPopups();
-                    info.log += "setCheck failed, will try again" + "\n";
-                    element = await this._locate(selectors, info, _params);
-                    await element.setChecked(checked, { timeout: 5000, force: true });
+                    state.info.log += "setCheck failed, will try again" + "\n";
+                    state.element = await this._locate(selectors, state.info, _params);
+                    await state.element.setChecked(checked, { timeout: 5000, force: true });
                     await new Promise((resolve) => setTimeout(resolve, 1000));
                 }
             }
             await this.waitForPageLoad();
-            return info;
+            return state.info;
         }
         catch (e) {
-            this.logger.error("setCheck failed " + info.log);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            error = e;
-            throw e;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: checked ? Types.CHECK : Types.UNCHECK,
-                text: checked ? `Check element` : `Uncheck element`,
-                screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
     async hover(selectors, _params, options = {}, world = null) {
-        this._validateSelectors(selectors);
-        const startTime = Date.now();
-        const info = {};
-        info.log = "";
-        info.operation = "hover";
-        info.selectors = selectors;
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
+        const state = {
+            selectors,
+            _params,
+            options,
+            world,
+            type: Types.HOVER,
+            text: `Hover element`,
+            operation: "hover",
+            log: "***** hover " + selectors.element_name + " *****\n",
+        };
         try {
-            let element = await this._locate(selectors, info, _params);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
+            await _preCommand(state, this);
             try {
-                await this._highlightElements(element);
-                await element.hover({ timeout: 10000 });
+                await state.element.hover();
                 await new Promise((resolve) => setTimeout(resolve, 1000));
             }
             catch (e) {
                 //await this.closeUnexpectedPopups();
-                info.log += "hover failed, will try again" + "\n";
-                element = await this._locate(selectors, info, _params);
-                await element.hover({ timeout: 10000 });
+                state.info.log += "hover failed, will try again" + "\n";
+                state.element = await this._locate(selectors, state.info, _params);
+                await state.element.hover({ timeout: 10000 });
                 await new Promise((resolve) => setTimeout(resolve, 1000));
             }
             await this.waitForPageLoad();
-            return info;
+            return state.info;
         }
         catch (e) {
-            this.logger.error("hover failed " + info.log);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            error = e;
-            throw e;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: Types.HOVER,
-                text: `Hover element`,
-                screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
     async selectOption(selectors, values, _params = null, options = {}, world = null) {
-        this._validateSelectors(selectors);
         if (!values) {
             throw new Error("values is null");
         }
-        const startTime = Date.now();
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
-        const info = {};
-        info.log = "";
-        info.operation = "selectOptions";
-        info.selectors = selectors;
+        const state = {
+            selectors,
+            _params,
+            options,
+            world,
+            value: values.toString(),
+            type: Types.SELECT,
+            text: `Select option: ${values}`,
+            operation: "selectOption",
+            log: "***** select option " + selectors.element_name + " *****\n",
+        };
         try {
-            let element = await this._locate(selectors, info, _params);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
+            await _preCommand(state, this);
             try {
-                await this._highlightElements(element);
-                await element.selectOption(values, { timeout: 5000 });
+                await state.element.selectOption(values);
             }
             catch (e) {
                 //await this.closeUnexpectedPopups();
-                info.log += "selectOption failed, will try force" + "\n";
-                await element.selectOption(values, { timeout: 10000, force: true });
+                state.info.log += "selectOption failed, will try force" + "\n";
+                await state.element.selectOption(values, { timeout: 10000, force: true });
             }
             await this.waitForPageLoad();
-            return info;
+            return state.info;
         }
         catch (e) {
-            this.logger.error("selectOption failed " + info.log);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            this.logger.info("click failed, will try next selector");
-            error = e;
-            throw e;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: Types.SELECT,
-                text: `Select option: ${values}`,
-                value: values.toString(),
-                screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
     async type(_value, _params = null, options = {}, world = null) {
-        const startTime = Date.now();
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
-        const info = {};
-        info.log = "";
-        info.operation = "type";
-        _value = this._fixUsingParams(_value, _params);
-        info.value = _value;
+        const state = {
+            value: _value,
+            _params,
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            highlight: false,
+            type: Types.TYPE_PRESS,
+            text: `Type value: ${_value}`,
+            operation: "type",
+            log: "",
+        };
         try {
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            const valueSegment = _value.split("&&");
+            await _preCommand(state, this);
+            const valueSegment = state.value.split("&&");
             for (let i = 0; i < valueSegment.length; i++) {
                 if (i > 0) {
                     await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -875,134 +1055,53 @@ class StableBrowser {
                     await this.page.keyboard.type(value);
                 }
             }
-            return info;
+            return state.info;
         }
         catch (e) {
-            //await this.closeUnexpectedPopups();
-            this.logger.error("type failed " + info.log);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            error = e;
-            throw e;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                type: Types.TYPE_PRESS,
-                screenshotId,
-                value: _value,
-                text: `type value: ${_value}`,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
-    async setDateTime(selectors, value, format = null, enter = false, _params = null, options = {}, world = null) {
-        this._validateSelectors(selectors);
-        const startTime = Date.now();
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
-        const info = {};
-        info.log = "";
-        info.operation = Types.SET_DATE_TIME;
-        info.selectors = selectors;
-        info.value = value;
+    async setInputValue(selectors, value, _params = null, options = {}, world = null) {
+        const state = {
+            selectors,
+            _params,
+            value,
+            options,
+            world,
+            type: Types.SET_INPUT,
+            text: `Set input value`,
+            operation: "setInputValue",
+            log: "***** set input value " + selectors.element_name + " *****\n",
+        };
         try {
-            value = await this._replaceWithLocalData(value, this);
-            let element = await this._locate(selectors, info, _params);
-            //insert red border around the element
-            await this.scrollIfNeeded(element, info);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            await this._highlightElements(element);
+            await _preCommand(state, this);
+            let value = await this._replaceWithLocalData(state.value, this);
             try {
-                await element.click();
-                await new Promise((resolve) => setTimeout(resolve, 500));
-                if (format) {
-                    value = dayjs(value).format(format);
-                    await element.fill(value);
-                }
-                else {
-                    const dateTimeValue = await getDateTimeValue({ value, element });
-                    await element.evaluateHandle((el, dateTimeValue) => {
-                        el.value = ""; // clear input
-                        el.value = dateTimeValue;
-                    }, dateTimeValue);
-                }
-                if (enter) {
-                    await new Promise((resolve) => setTimeout(resolve, 2000));
-                    await this.page.keyboard.press("Enter");
-                    await this.waitForPageLoad();
-                }
+                await state.element.evaluateHandle((el, value) => {
+                    el.value = value;
+                }, value);
             }
             catch (error) {
-                //await this.closeUnexpectedPopups();
-                this.logger.error("setting date time input failed " + JSON.stringify(info));
-                this.logger.info("Trying again")(({ screenshotId, screenshotPath } = await this._screenShot(options, world, info)));
-                info.screenshotPath = screenshotPath;
-                Object.assign(error, { info: info });
-                await element.click();
-                await new Promise((resolve) => setTimeout(resolve, 500));
-                if (format) {
-                    value = dayjs(value).format(format);
-                    await element.fill(value);
-                }
-                else {
-                    const dateTimeValue = await getDateTimeValue({ value, element });
-                    await element.evaluateHandle((el, dateTimeValue) => {
-                        el.value = ""; // clear input
-                        el.value = dateTimeValue;
-                    }, dateTimeValue);
-                }
-                if (enter) {
-                    await new Promise((resolve) => setTimeout(resolve, 2000));
-                    await this.page.keyboard.press("Enter");
-                    await this.waitForPageLoad();
-                }
+                this.logger.error("setInputValue failed, will try again");
+                await _screenshot(state, this);
+                Object.assign(error, { info: state.info });
+                await state.element.evaluateHandle((el, value) => {
+                    el.value = value;
+                });
             }
         }
-        catch (error) {
-            error = e;
-            throw e;
+        catch (e) {
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: Types.SET_DATE_TIME,
-                screenshotId,
-                value: value,
-                text: `setDateTime input with value: ${value}`,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
-    async setDateTime(selectors, value, enter = false, _params = null, options = {}, world = null) {
-        this._validateSelectors(selectors);
+    async setDateTime(selectors, value, format = null, enter = false, _params = null, options = {}, world = null) {
+        _validateSelectors(selectors);
         const startTime = Date.now();
         let error = null;
         let screenshotId = null;
@@ -1013,6 +1112,7 @@ class StableBrowser {
         info.selectors = selectors;
         info.value = value;
         try {
+            value = await this._replaceWithLocalData(value, this);
             let element = await this._locate(selectors, info, _params);
             //insert red border around the element
             await this.scrollIfNeeded(element, info);
@@ -1021,28 +1121,51 @@ class StableBrowser {
             try {
                 await element.click();
                 await new Promise((resolve) => setTimeout(resolve, 500));
-                const dateTimeValue = await getDateTimeValue({ value, element });
-                await element.evaluateHandle((el, dateTimeValue) => {
-                    el.value = ""; // clear input
-                    el.value = dateTimeValue;
-                }, dateTimeValue);
+                if (format) {
+                    value = dayjs(value).format(format);
+                    await element.fill(value);
+                }
+                else {
+                    const dateTimeValue = await getDateTimeValue({ value, element });
+                    await element.evaluateHandle((el, dateTimeValue) => {
+                        el.value = ""; // clear input
+                        el.value = dateTimeValue;
+                    }, dateTimeValue);
+                }
+                if (enter) {
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                    await this.page.keyboard.press("Enter");
+                    await this.waitForPageLoad();
+                }
             }
-            catch (error) {
+            catch (err) {
                 //await this.closeUnexpectedPopups();
                 this.logger.error("setting date time input failed " + JSON.stringify(info));
-                this.logger.info("Trying again")(({ screenshotId, screenshotPath } = await this._screenShot(options, world, info)));
+                this.logger.info("Trying again");
+                ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
                 info.screenshotPath = screenshotPath;
-                Object.assign(error, { info: info });
+                Object.assign(err, { info: info });
                 await element.click();
                 await new Promise((resolve) => setTimeout(resolve, 500));
-                const dateTimeValue = await getDateTimeValue({ value, element });
-                await element.evaluateHandle((el, dateTimeValue) => {
-                    el.value = ""; // clear input
-                    el.value = dateTimeValue;
-                }, dateTimeValue);
+                if (format) {
+                    value = dayjs(value).format(format);
+                    await element.fill(value);
+                }
+                else {
+                    const dateTimeValue = await getDateTimeValue({ value, element });
+                    await element.evaluateHandle((el, dateTimeValue) => {
+                        el.value = ""; // clear input
+                        el.value = dateTimeValue;
+                    }, dateTimeValue);
+                }
+                if (enter) {
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                    await this.page.keyboard.press("Enter");
+                    await this.waitForPageLoad();
+                }
             }
         }
-        catch (error) {
+        catch (e) {
             error = e;
             throw e;
         }
@@ -1071,32 +1194,32 @@ class StableBrowser {
         }
     }
     async clickType(selectors, _value, enter = false, _params = null, options = {}, world = null) {
-        this._validateSelectors(selectors);
-        const startTime = Date.now();
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
-        const info = {};
-        info.log = "***** clickType on " + selectors.element_name + " with value " + _value + "*****\n";
-        info.operation = "clickType";
-        info.selectors = selectors;
+        _value = unEscapeString(_value);
         const newValue = await this._replaceWithLocalData(_value, world);
+        const state = {
+            selectors,
+            _params,
+            value: newValue,
+            originalValue: _value,
+            options,
+            world,
+            type: Types.FILL,
+            text: `Click type input with value: ${_value}`,
+            operation: "clickType",
+            log: "***** clickType on " + selectors.element_name + " with value " + maskValue(_value) + "*****\n",
+        };
         if (newValue !== _value) {
             //this.logger.info(_value + "=" + newValue);
             _value = newValue;
         }
-        info.value = _value;
         try {
-            let element = await this._locate(selectors, info, _params);
-            //insert red border around the element
-            await this.scrollIfNeeded(element, info);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            await this._highlightElements(element);
+            await _preCommand(state, this);
+            state.info.value = _value;
             if (options === null || options === undefined || !options.press) {
                 try {
-                    let currentValue = await element.inputValue();
+                    let currentValue = await state.element.inputValue();
                     if (currentValue) {
-                        await element.fill("");
+                        await state.element.fill("");
                     }
                 }
                 catch (e) {
@@ -1105,22 +1228,22 @@ class StableBrowser {
             }
             if (options === null || options === undefined || options.press) {
                 try {
-                    await element.click({ timeout: 5000 });
+                    await state.element.click({ timeout: 5000 });
                 }
                 catch (e) {
-                    await element.dispatchEvent("click");
+                    await state.element.dispatchEvent("click");
                 }
             }
             else {
                 try {
-                    await element.focus();
+                    await state.element.focus();
                 }
                 catch (e) {
-                    await element.dispatchEvent("focus");
+                    await state.element.dispatchEvent("focus");
                 }
             }
             await new Promise((resolve) => setTimeout(resolve, 500));
-            const valueSegment = _value.split("&&");
+            const valueSegment = state.value.split("&&");
             for (let i = 0; i < valueSegment.length; i++) {
                 if (i > 0) {
                     await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -1140,13 +1263,14 @@ class StableBrowser {
                     await new Promise((resolve) => setTimeout(resolve, 500));
                 }
             }
+            await _screenshot(state, this);
             if (enter === true) {
                 await new Promise((resolve) => setTimeout(resolve, 2000));
                 await this.page.keyboard.press("Enter");
                 await this.waitForPageLoad();
             }
             else if (enter === false) {
-                await element.dispatchEvent("change");
+                await state.element.dispatchEvent("change");
                 //await this.page.keyboard.press("Tab");
             }
             else {
@@ -1155,103 +1279,50 @@ class StableBrowser {
                     await this.waitForPageLoad();
                 }
             }
-            return info;
+            return state.info;
         }
         catch (e) {
-            //await this.closeUnexpectedPopups();
-            this.logger.error("fill failed " + JSON.stringify(info));
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            error = e;
-            throw e;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: Types.FILL,
-                screenshotId,
-                value: _value,
-                text: `clickType input with value: ${_value}`,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
     async fill(selectors, value, enter = false, _params = null, options = {}, world = null) {
-        this._validateSelectors(selectors);
-        const startTime = Date.now();
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
-        const info = {};
-        info.log = "***** fill on " + selectors.element_name + " with value " + value + "*****\n";
-        info.operation = "fill";
-        info.selectors = selectors;
-        info.value = value;
+        const state = {
+            selectors,
+            _params,
+            value: unEscapeString(value),
+            options,
+            world,
+            type: Types.FILL,
+            text: `Fill input with value: ${value}`,
+            operation: "fill",
+            log: "***** fill on " + selectors.element_name + " with value " + value + "*****\n",
+        };
         try {
-            let element = await this._locate(selectors, info, _params);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            await this._highlightElements(element);
-            await element.fill(value, { timeout: 10000 });
-            await element.dispatchEvent("change");
+            await _preCommand(state, this);
+            await state.element.fill(value);
+            await state.element.dispatchEvent("change");
             if (enter) {
                 await new Promise((resolve) => setTimeout(resolve, 2000));
                 await this.page.keyboard.press("Enter");
             }
             await this.waitForPageLoad();
-            return info;
+            return state.info;
         }
         catch (e) {
-            //await this.closeUnexpectedPopups();
-            this.logger.error("fill failed " + info.log);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            error = e;
-            throw e;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: Types.FILL,
-                screenshotId,
-                value,
-                text: `Fill input with value: ${value}`,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
     async getText(selectors, _params = null, options = {}, info = {}, world = null) {
         return await this._getText(selectors, 0, _params, options, info, world);
     }
     async _getText(selectors, climb, _params = null, options = {}, info = {}, world = null) {
-        this._validateSelectors(selectors);
+        _validateSelectors(selectors);
         let screenshotId = null;
         let screenshotPath = null;
         if (!info.log) {
@@ -1295,165 +1366,124 @@ class StableBrowser {
         }
     }
     async containsPattern(selectors, pattern, text, _params = null, options = {}, world = null) {
-        var _a;
-        this._validateSelectors(selectors);
         if (!pattern) {
             throw new Error("pattern is null");
         }
         if (!text) {
             throw new Error("text is null");
         }
+        const state = {
+            selectors,
+            _params,
+            pattern,
+            value: pattern,
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            screenshot: false,
+            highlight: false,
+            type: Types.VERIFY_ELEMENT_CONTAINS_TEXT,
+            text: `Verify element contains pattern: ${pattern}`,
+            operation: "containsPattern",
+            log: "***** verify element " + selectors.element_name + " contains pattern " + pattern + " *****\n",
+        };
         const newValue = await this._replaceWithLocalData(text, world);
         if (newValue !== text) {
             this.logger.info(text + "=" + newValue);
             text = newValue;
         }
-        const startTime = Date.now();
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
-        const info = {};
-        info.log =
-            "***** verify element " + selectors.element_name + " contains pattern  " + pattern + "/" + text + " *****\n";
-        info.operation = "containsPattern";
-        info.selectors = selectors;
-        info.value = text;
-        info.pattern = pattern;
         let foundObj = null;
         try {
-            foundObj = await this._getText(selectors, 0, _params, options, info, world);
+            await _preCommand(state, this);
+            state.info.pattern = pattern;
+            foundObj = await this._getText(selectors, 0, _params, options, state.info, world);
             if (foundObj && foundObj.element) {
-                await this.scrollIfNeeded(foundObj.element, info);
+                await this.scrollIfNeeded(foundObj.element, state.info);
             }
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
+            await _screenshot(state, this);
             let escapedText = text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
             pattern = pattern.replace("{text}", escapedText);
             let regex = new RegExp(pattern, "im");
-            if (!regex.test(foundObj === null || foundObj === void 0 ? void 0 : foundObj.text) && !((_a = foundObj === null || foundObj === void 0 ? void 0 : foundObj.value) === null || _a === void 0 ? void 0 : _a.includes(text))) {
-                info.foundText = foundObj === null || foundObj === void 0 ? void 0 : foundObj.text;
+            if (!regex.test(foundObj?.text) && !foundObj?.value?.includes(text)) {
+                state.info.foundText = foundObj?.text;
                 throw new Error("element doesn't contain text " + text);
             }
-            return info;
+            return state.info;
         }
         catch (e) {
-            //await this.closeUnexpectedPopups();
-            this.logger.error("verify element contains text failed " + info.log);
-            this.logger.error("found text " + (foundObj === null || foundObj === void 0 ? void 0 : foundObj.text) + " pattern " + pattern);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            error = e;
-            throw e;
+            this.logger.error("found text " + foundObj?.text + " pattern " + pattern);
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: Types.VERIFY_ELEMENT_CONTAINS_TEXT,
-                value: pattern,
-                text: `Verify element contains pattern: ${pattern}`,
-                screenshotId: foundObj === null || foundObj === void 0 ? void 0 : foundObj.screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
     async containsText(selectors, text, climb, _params = null, options = {}, world = null) {
-        var _a, _b, _c;
-        this._validateSelectors(selectors);
+        const state = {
+            selectors,
+            _params,
+            value: text,
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            screenshot: false,
+            highlight: false,
+            type: Types.VERIFY_ELEMENT_CONTAINS_TEXT,
+            text: `Verify element contains text: ${text}`,
+            operation: "containsText",
+            log: "***** verify element " + selectors.element_name + " contains text " + text + " *****\n",
+        };
         if (!text) {
             throw new Error("text is null");
         }
-        const startTime = Date.now();
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
-        const info = {};
-        info.log = "***** verify element " + selectors.element_name + " contains text " + text + " *****\n";
-        info.operation = "containsText";
-        info.selectors = selectors;
+        text = unEscapeString(text);
         const newValue = await this._replaceWithLocalData(text, world);
         if (newValue !== text) {
             this.logger.info(text + "=" + newValue);
             text = newValue;
         }
-        info.value = text;
         let foundObj = null;
         try {
-            foundObj = await this._getText(selectors, climb, _params, options, info, world);
+            await _preCommand(state, this);
+            foundObj = await this._getText(selectors, climb, _params, options, state.info, world);
             if (foundObj && foundObj.element) {
-                await this.scrollIfNeeded(foundObj.element, info);
+                await this.scrollIfNeeded(foundObj.element, state.info);
             }
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
+            await _screenshot(state, this);
             const dateAlternatives = findDateAlternatives(text);
             const numberAlternatives = findNumberAlternatives(text);
             if (dateAlternatives.date) {
                 for (let i = 0; i < dateAlternatives.dates.length; i++) {
-                    if ((foundObj === null || foundObj === void 0 ? void 0 : foundObj.text.includes(dateAlternatives.dates[i])) ||
-                        ((_a = foundObj === null || foundObj === void 0 ? void 0 : foundObj.value) === null || _a === void 0 ? void 0 : _a.includes(dateAlternatives.dates[i]))) {
-                        return info;
+                    if (foundObj?.text.includes(dateAlternatives.dates[i]) ||
+                        foundObj?.value?.includes(dateAlternatives.dates[i])) {
+                        return state.info;
                     }
                 }
                 throw new Error("element doesn't contain text " + text);
             }
             else if (numberAlternatives.number) {
                 for (let i = 0; i < numberAlternatives.numbers.length; i++) {
-                    if ((foundObj === null || foundObj === void 0 ? void 0 : foundObj.text.includes(numberAlternatives.numbers[i])) ||
-                        ((_b = foundObj === null || foundObj === void 0 ? void 0 : foundObj.value) === null || _b === void 0 ? void 0 : _b.includes(numberAlternatives.numbers[i]))) {
-                        return info;
+                    if (foundObj?.text.includes(numberAlternatives.numbers[i]) ||
+                        foundObj?.value?.includes(numberAlternatives.numbers[i])) {
+                        return state.info;
                     }
                 }
                 throw new Error("element doesn't contain text " + text);
             }
-            else if (!(foundObj === null || foundObj === void 0 ? void 0 : foundObj.text.includes(text)) && !((_c = foundObj === null || foundObj === void 0 ? void 0 : foundObj.value) === null || _c === void 0 ? void 0 : _c.includes(text))) {
-                info.foundText = foundObj === null || foundObj === void 0 ? void 0 : foundObj.text;
-                info.value = foundObj === null || foundObj === void 0 ? void 0 : foundObj.value;
+            else if (!foundObj?.text.includes(text) && !foundObj?.value?.includes(text)) {
+                state.info.foundText = foundObj?.text;
+                state.info.value = foundObj?.value;
                 throw new Error("element doesn't contain text " + text);
             }
-            return info;
+            return state.info;
         }
         catch (e) {
-            //await this.closeUnexpectedPopups();
-            this.logger.error("verify element contains text failed " + info.log);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            error = e;
-            throw e;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: Types.VERIFY_ELEMENT_CONTAINS_TEXT,
-                text: `Verify element contains text: ${text}`,
-                value: text,
-                screenshotId: foundObj === null || foundObj === void 0 ? void 0 : foundObj.screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
     _getDataFile(world = null) {
@@ -1472,6 +1502,29 @@ class StableBrowser {
         }
         return dataFile;
     }
+    async waitForUserInput(message, world = null) {
+        if (!message) {
+            message = "# Wait for user input. Press any key to continue";
+        }
+        else {
+            message = "# Wait for user input. " + message;
+        }
+        message += "\n";
+        const value = await new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            rl.question(message, (answer) => {
+                rl.close();
+                resolve(answer);
+            });
+        });
+        if (value) {
+            this.logger.info(`{{userInput}} was set to: ${value}`);
+        }
+        this.setTestData({ userInput: value }, world);
+    }
     setTestData(testData, world = null) {
         if (!testData) {
             return;
@@ -1499,7 +1552,7 @@ class StableBrowser {
         const data = fs.readFileSync(filePath, "utf8");
         const results = [];
         return new Promise((resolve, reject) => {
-            const readableStream = new stream.Readable();
+            const readableStream = new Readable();
             readableStream._read = () => { }; // _read is required but you can noop it
             readableStream.push(data);
             readableStream.push(null);
@@ -1659,7 +1712,6 @@ class StableBrowser {
     }
     async takeScreenshot(screenshotPath) {
         const playContext = this.context.playContext;
-        const client = await playContext.newCDPSession(this.page);
         // Using CDP to capture the screenshot
         const viewportWidth = Math.max(...(await this.page.evaluate(() => [
             document.body.scrollWidth,
@@ -1669,97 +1721,67 @@ class StableBrowser {
             document.body.clientWidth,
             document.documentElement.clientWidth,
         ])));
-        const viewportHeight = Math.max(...(await this.page.evaluate(() => [
-            document.body.scrollHeight,
-            document.documentElement.scrollHeight,
-            document.body.offsetHeight,
-            document.documentElement.offsetHeight,
-            document.body.clientHeight,
-            document.documentElement.clientHeight,
-        ])));
-        const { data } = await client.send("Page.captureScreenshot", {
-            format: "png",
-            clip: {
-                x: 0,
-                y: 0,
-                width: viewportWidth,
-                height: viewportHeight,
-                scale: 1,
-            },
-        });
-        if (!screenshotPath) {
-            return data;
-        }
-        let screenshotBuffer = Buffer.from(data, "base64");
-        const sharpBuffer = sharp(screenshotBuffer);
-        const metadata = await sharpBuffer.metadata();
-        //check if you are on retina display and reduce the quality of the image
-        if (metadata.width > viewportWidth || metadata.height > viewportHeight) {
-            screenshotBuffer = await sharpBuffer
-                .resize(viewportWidth, viewportHeight, {
-                fit: sharp.fit.inside,
-                withoutEnlargement: true,
-            })
-                .toBuffer();
-        }
-        fs.writeFileSync(screenshotPath, screenshotBuffer);
-        await client.detach();
+        let screenshotBuffer = null;
+        if (this.context.browserName === "chromium") {
+            const client = await playContext.newCDPSession(this.page);
+            const { data } = await client.send("Page.captureScreenshot", {
+                format: "png",
+                // clip: {
+                //   x: 0,
+                //   y: 0,
+                //   width: viewportWidth,
+                //   height: viewportHeight,
+                //   scale: 1,
+                // },
+            });
+            await client.detach();
+            if (!screenshotPath) {
+                return data;
+            }
+            screenshotBuffer = Buffer.from(data, "base64");
+        }
+        else {
+            screenshotBuffer = await this.page.screenshot();
+        }
+        let image = await Jimp.read(screenshotBuffer);
+        // Get the image dimensions
+        const { width, height } = image.bitmap;
+        const resizeRatio = viewportWidth / width;
+        // Resize the image to fit within the viewport dimensions without enlarging
+        if (width > viewportWidth) {
+            image = image.resize({ w: viewportWidth, h: height * resizeRatio }); // Resize the image while maintaining aspect ratio
+            await image.write(screenshotPath);
+        }
+        else {
+            fs.writeFileSync(screenshotPath, screenshotBuffer);
+        }
     }
     async verifyElementExistInPage(selectors, _params = null, options = {}, world = null) {
-        this._validateSelectors(selectors);
-        const startTime = Date.now();
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
+        const state = {
+            selectors,
+            _params,
+            options,
+            world,
+            type: Types.VERIFY_ELEMENT_CONTAINS_TEXT,
+            text: `Verify element exists in page`,
+            operation: "verifyElementExistInPage",
+            log: "***** verify element " + selectors.element_name + " exists in page *****\n",
+        };
         await new Promise((resolve) => setTimeout(resolve, 2000));
-        const info = {};
-        info.log = "***** verify element " + selectors.element_name + " exists in page *****\n";
-        info.operation = "verify";
-        info.selectors = selectors;
         try {
-            const element = await this._locate(selectors, info, _params);
-            if (element) {
-                await this.scrollIfNeeded(element, info);
-            }
-            await this._highlightElements(element);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            await expect(element).toHaveCount(1, { timeout: 10000 });
-            return info;
+            await _preCommand(state, this);
+            await expect(state.element).toHaveCount(1, { timeout: 10000 });
+            return state.info;
         }
         catch (e) {
-            //await this.closeUnexpectedPopups();
-            this.logger.error("verify failed " + info.log);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            error = e;
-            throw e;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: Types.VERIFY_ELEMENT_CONTAINS_TEXT,
-                text: "Verify element exists in page",
-                screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
     async extractAttribute(selectors, attribute, variable, _params = null, options = {}, world = null) {
-        this._validateSelectors(selectors);
+        _validateSelectors(selectors);
         const startTime = Date.now();
         let error = null;
         let screenshotId = null;
@@ -1818,7 +1840,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2027,7 +2049,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2063,20 +2085,20 @@ class StableBrowser {
                 for (let i = 0; i < frames.length; i++) {
                     if (dateAlternatives.date) {
                         for (let j = 0; j < dateAlternatives.dates.length; j++) {
-                            const result = await this._locateElementByText(frames[i], dateAlternatives.dates[j], "*", true, {});
+                            const result = await this._locateElementByText(frames[i], dateAlternatives.dates[j], "*", true, true, {});
                             result.frame = frames[i];
                             results.push(result);
                         }
                     }
                     else if (numberAlternatives.number) {
                         for (let j = 0; j < numberAlternatives.numbers.length; j++) {
-                            const result = await this._locateElementByText(frames[i], numberAlternatives.numbers[j], "*", true, {});
+                            const result = await this._locateElementByText(frames[i], numberAlternatives.numbers[j], "*", true, true, {});
                             result.frame = frames[i];
                             results.push(result);
                         }
                     }
                     else {
-                        const result = await this._locateElementByText(frames[i], text, "*", true, {});
+                        const result = await this._locateElementByText(frames[i], text, "*", true, true, {});
                         result.frame = frames[i];
                         results.push(result);
                     }
@@ -2125,7 +2147,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2209,7 +2231,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2241,7 +2263,7 @@ class StableBrowser {
         this.logger.info("Table data verified");
     }
     async getTableData(selectors, _params = null, options = {}, world = null) {
-        this._validateSelectors(selectors);
+        _validateSelectors(selectors);
         const startTime = Date.now();
         let error = null;
         let screenshotId = null;
@@ -2277,7 +2299,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2289,7 +2311,7 @@ class StableBrowser {
         }
     }
     async analyzeTable(selectors, query, operator, value, _params = null, options = {}, world = null) {
-        this._validateSelectors(selectors);
+        _validateSelectors(selectors);
         if (!query) {
             throw new Error("query is null");
         }
@@ -2442,7 +2464,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2454,27 +2476,7 @@ class StableBrowser {
         }
     }
     async _replaceWithLocalData(value, world, _decrypt = true, totpWait = true) {
-        if (!value) {
-            return value;
-        }
-        // find all the accurance of {{(.*?)}} and replace with the value
-        let regex = /{{(.*?)}}/g;
-        let matches = value.match(regex);
-        if (matches) {
-            const testData = this.getTestData(world);
-            for (let i = 0; i < matches.length; i++) {
-                let match = matches[i];
-                let key = match.substring(2, match.length - 2);
-                let newValue = objectPath.get(testData, key, null);
-                if (newValue !== null) {
-                    value = value.replace(match, newValue);
-                }
-            }
-        }
-        if ((value.startsWith("secret:") || value.startsWith("totp:")) && _decrypt) {
-            return await decrypt(value, null, totpWait);
-        }
-        return value;
+        return await replaceWithLocalTestData(value, world, _decrypt, totpWait, this.context, this);
     }
     _getLoadTimeout(options) {
         let timeout = 15000;
@@ -2511,13 +2513,13 @@ class StableBrowser {
         }
         catch (e) {
             if (e.label === "networkidle") {
-                console.log("waitted for the network to be idle timeout");
+                console.log("waited for the network to be idle timeout");
             }
             else if (e.label === "load") {
-                console.log("waitted for the load timeout");
+                console.log("waited for the load timeout");
             }
             else if (e.label === "domcontentloaded") {
-                console.log("waitted for the domcontent loaded timeout");
+                console.log("waited for the domcontent loaded timeout");
             }
             console.log(".");
         }
@@ -2534,7 +2536,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2552,13 +2554,6 @@ class StableBrowser {
         const info = {};
         try {
             await this.page.close();
-            if (this.context && this.context.pages && this.context.pages.length > 0) {
-                this.context.pages.pop();
-                this.page = this.context.pages[this.context.pages.length - 1];
-                this.context.page = this.page;
-                let title = await this.page.title();
-                console.log("Switched to page " + title);
-            }
         }
         catch (e) {
             console.log(".");
@@ -2576,7 +2571,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2618,7 +2613,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2654,7 +2649,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2667,33 +2662,18 @@ class StableBrowser {
     }
     async scrollIfNeeded(element, info) {
         try {
-            let didScroll = await element.evaluate((node) => {
-                const rect = node.getBoundingClientRect();
-                if (rect &&
-                    rect.top >= 0 &&
-                    rect.left >= 0 &&
-                    rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
-                    rect.right <= (window.innerWidth || document.documentElement.clientWidth)) {
-                    return false;
-                }
-                else {
-                    node.scrollIntoView({
-                        behavior: "smooth",
-                        block: "center",
-                        inline: "center",
-                    });
-                    return true;
-                }
+            await element.scrollIntoViewIfNeeded({
+                timeout: 2000,
             });
-            if (didScroll) {
-                await new Promise((resolve) => setTimeout(resolve, 500));
-                if (info) {
-                    info.box = await element.boundingBox();
-                }
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            if (info) {
+                info.box = await element.boundingBox({
+                    timeout: 1000,
+                });
             }
         }
         catch (e) {
-            console.log("scroll failed");
+            console.log("#-#");
         }
     }
     _reportToWorld(world, properties) {
@@ -2854,5 +2834,10 @@ const KEYBOARD_EVENTS = [
     "TVAntennaCable",
     "TVAudioDescription",
 ];
+function unEscapeString(str) {
+    const placeholder = "__NEWLINE__";
+    str = str.replace(new RegExp(placeholder, "g"), "\n");
+    return str;
+}
 export { StableBrowser };
 //# sourceMappingURL=stable_browser.js.map