automation_model 1.0.519-dev → 1.0.519-stage

package/lib/stable_browser.js

@@ -7,18 +7,19 @@ import path from "path";
 import reg_parser from "regex-parser";
 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 { maskValue, replaceWithLocalTestData } from "./utils.js";
+import { _convertToRegexQuery, _copyContext, _fixLocatorUsingParams, _fixUsingParams, _getServerUrl, KEYBOARD_EVENTS, maskValue, replaceWithLocalTestData, scrollPageToLoadLazyElements, unEscapeString, } 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 { randomUUID } from "crypto";
+import { _commandError, _commandFinally, _preCommand, _validateSelectors, _screenshot, _reportToWorld, } from "./command_common.js";
 import { registerDownloadEvent, registerNetworkEvents } from "./network.js";
-const Types = {
+import { LocatorLog } from "./locator_log.js";
+export const Types = {
     CLICK: "click_element",
     NAVIGATE: "navigate",
     FILL: "fill_element",
@@ -29,6 +30,8 @@ const Types = {
     GET_PAGE_STATUS: "get_page_status",
     CLICK_ROW_ACTION: "click_row_action",
     VERIFY_ELEMENT_CONTAINS_TEXT: "verify_element_contains_text",
+    VERIFY_PAGE_CONTAINS_TEXT: "verify_page_contains_text",
+    VERIFY_PAGE_CONTAINS_NO_TEXT: "verify_page_contains_no_text",
     ANALYZE_TABLE: "analyze_table",
     SELECT: "select_combobox",
     VERIFY_PAGE_PATH: "verify_page_path",
@@ -45,6 +48,8 @@ const Types = {
     LOAD_DATA: "load_data",
     SET_INPUT: "set_input",
     WAIT_FOR_TEXT_TO_DISAPPEAR: "wait_for_text_to_disappear",
+    VERIFY_ATTRIBUTE: "verify_element_attribute",
+    VERIFY_TEXT_WITH_RELATION: "verify_text_with_relation",
 };
 export const apps = {};
 class StableBrowser {
@@ -58,6 +63,7 @@ class StableBrowser {
     networkLogger = null;
     configuration = null;
     appName = "main";
+    tags = null;
     constructor(browser, page, logger = null, context = null, world = null) {
         this.browser = browser;
         this.page = page;
@@ -88,17 +94,17 @@ class StableBrowser {
         catch (e) {
             this.logger.error("unable to read ai_config.json");
         }
-        context.pageLoading = { status: false };
-        context.pages = [this.page];
         const logFolder = path.join(this.project_path, "logs", "web");
         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);
+        // this.registerRequestListener(this.page, context, this.webLogFile);
         if (!context.pageLoading) {
             context.pageLoading = { status: false };
         }
@@ -143,7 +149,7 @@ class StableBrowser {
         if (this.appName === appName) {
             return;
         }
-        let newContextCreated = false;
+        let navigate = false;
         if (!apps[appName]) {
             let newContext = await getContext(null, this.context.headless ? this.context.headless : false, this, this.logger, appName, false, this, -1, this.context.reportFolder);
             newContextCreated = true;
@@ -154,32 +160,15 @@ class StableBrowser {
             };
         }
         const tempContext = {};
-        this._copyContext(this, tempContext);
-        this._copyContext(apps[appName], this);
+        _copyContext(this, tempContext);
+        _copyContext(apps[appName], this);
         apps[this.appName] = tempContext;
         this.appName = appName;
-        if (newContextCreated) {
-            this.registerEventListeners(this.context);
+        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 });
-        }
-        let nextIndex = 1;
-        while (fs.existsSync(path.join(logFolder, nextIndex.toString() + ".json"))) {
-            nextIndex++;
-        }
-        const fileName = nextIndex + ".json";
-        return path.join(logFolder, fileName);
-    }
     registerConsoleLogListener(page, context) {
         if (!this.context.webLogger) {
             this.context.webLogger = [];
@@ -243,55 +232,48 @@ class StableBrowser {
     // async closeUnexpectedPopups() {
     //   await closeUnexpectedPopups(this.page);
     // }
-    async goto(url) {
+    async goto(url, world = null) {
         if (!url.startsWith("http")) {
             url = "https://" + url;
         }
-        await this.page.goto(url, {
-            timeout: 60000,
-        });
-    }
-    _fixUsingParams(text, _params) {
-        if (!_params || typeof text !== "string") {
-            return text;
+        const state = {
+            value: url,
+            world: world,
+            type: Types.NAVIGATE,
+            text: `Navigate Page to: ${url}`,
+            operation: "goto",
+            log: "***** navigate page to " + url + " *****\n",
+            info: {},
+            locate: false,
+            scroll: false,
+            screenshot: false,
+            highlight: false,
+        };
+        try {
+            await _preCommand(state, this, world);
+            await this.page.goto(url, {
+                timeout: 60000,
+            });
+            await _screenshot(state, this);
         }
-        for (let key in _params) {
-            let regValue = key;
-            if (key.startsWith("_")) {
-                // remove the _ prefix
-                regValue = key.substring(1);
-            }
-            text = text.replaceAll(new RegExp("{" + regValue + "}", "g"), _params[key]);
+        catch (error) {
+            console.error("Error on goto", error);
+            _commandError(state, error, this);
         }
-        return text;
-    }
-    _fixLocatorUsingParams(locator, _params) {
-        // check if not null
-        if (!locator) {
-            return locator;
+        finally {
+            _commandFinally(state, this);
         }
-        // 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);
+    async _getLocator(locator, scope, _params) {
+        locator = _fixLocatorUsingParams(locator, _params);
+        // locator = await this._replaceWithLocalData(locator);
+        for (let key in locator) {
+            if (typeof locator[key] !== "string")
+                continue;
+            if (locator[key].includes("{{") && locator[key].includes("}}")) {
+                locator[key] = await this._replaceWithLocalData(locator[key], this.world);
             }
         }
-    }
-    _getLocator(locator, scope, _params) {
-        locator = this._fixLocatorUsingParams(locator, _params);
         let locatorReturn;
         if (locator.role) {
             if (locator.role[1].nameReg) {
@@ -299,7 +281,7 @@ class StableBrowser {
                 delete locator.role[1].nameReg;
             }
             // if (locator.role[1].name) {
-            //   locator.role[1].name = this._fixUsingParams(locator.role[1].name, _params);
+            //   locator.role[1].name = _fixUsingParams(locator.role[1].name, _params);
             // }
             locatorReturn = scope.getByRole(locator.role[0], locator.role[1]);
         }
@@ -342,140 +324,54 @@ class StableBrowser {
         if (css && css.locator) {
             css = css.locator;
         }
-        let result = await this._locateElementByText(scope, this._fixUsingParams(text, _params), "*:not(script, style, head)", false, false, _params);
+        let result = await this._locateElementByText(scope, _fixUsingParams(text, _params), "*:not(script, style, head)", false, false, true, _params);
         if (result.elementCount === 0) {
             return;
         }
-        let textElementCss = "[data-blinq-id='blinq-id-" + result.randomToken + "']";
+        let textElementCss = "[data-blinq-id-" + result.randomToken + "]";
         // css climb to parent element
         const climbArray = [];
         for (let i = 0; i < climb; i++) {
             climbArray.push("..");
         }
         let climbXpath = "xpath=" + climbArray.join("/");
-        return textElementCss + " >> " + climbXpath + " >> " + css;
-    }
-    async _locateElementByText(scope, text1, tag1, regex1 = false, partial1, _params) {
-        //const stringifyText = JSON.stringify(text);
-        return await scope.locator(":root").evaluate((_node, [text, tag, regex, partial]) => {
-            function isParent(parent, child) {
-                let currentNode = child.parentNode;
-                while (currentNode !== null) {
-                    if (currentNode === parent) {
-                        return true;
+        let resultCss = textElementCss + " >> " + climbXpath;
+        if (css) {
+            resultCss = resultCss + " >> " + css;
+        }
+        return resultCss;
+    }
+    async _locateElementByText(scope, text1, tag1, regex1 = false, partial1, ignoreCase = true, _params) {
+        const query = _convertToRegexQuery(text1, regex1, !partial1, ignoreCase);
+        const locator = scope.locator(query);
+        const count = await locator.count();
+        if (!tag1) {
+            tag1 = "*";
+        }
+        const randomToken = Math.random().toString(36).substring(7);
+        let tagCount = 0;
+        for (let i = 0; i < count; i++) {
+            const element = locator.nth(i);
+            // check if the tag matches
+            if (!(await element.evaluate((el, [tag, randomToken]) => {
+                if (!tag.startsWith("*")) {
+                    if (el.tagName.toLowerCase() !== tag) {
+                        return false;
                     }
-                    currentNode = currentNode.parentNode;
-                }
-                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) {
-                    result.push(element);
-                    // Also search within the shadow root
-                    document.collectAllShadowDomElements(element.shadowRoot, result);
-                }
-                // Iterate over child nodes
-                element.childNodes.forEach((child) => {
-                    // Recursively call the function for each child node
-                    document.collectAllShadowDomElements(child, result);
-                });
-                return result;
-            }
-            document.collectAllShadowDomElements = collectAllShadowDomElements;
-            if (!tag) {
-                tag = "*:not(script, style, head)";
-            }
-            let regexpSearch = document.getRegex(text);
-            if (regexpSearch) {
-                regex = true;
-            }
-            let elements = Array.from(document.querySelectorAll(tag));
-            let shadowHosts = [];
-            document.collectAllShadowDomElements(document, shadowHosts);
-            for (let i = 0; i < shadowHosts.length; i++) {
-                let shadowElement = shadowHosts[i].shadowRoot;
-                if (!shadowElement) {
-                    console.log("shadowElement is null, for host " + shadowHosts[i]);
-                    continue;
-                }
-                let shadowElements = Array.from(shadowElement.querySelectorAll(tag));
-                elements = elements.concat(shadowElements);
-            }
-            let randomToken = null;
-            const foundElements = [];
-            if (regex) {
-                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)) ||
-                        (element.value && regexpSearch.test(element.value))) {
-                        foundElements.push(element);
-                    }
+                if (!el.setAttribute) {
+                    el = el.parentElement;
                 }
+                el.setAttribute("data-blinq-id-" + randomToken, "");
+                return true;
+            }, [tag1, randomToken]))) {
+                continue;
             }
-            else {
-                text = text.trim();
-                for (let i = 0; i < elements.length; i++) {
-                    const element = elements[i];
-                    if (partial) {
-                        if ((element.innerText && element.innerText.toLowerCase().trim().includes(text.toLowerCase())) ||
-                            (element.value && element.value.toLowerCase().includes(text.toLowerCase()))) {
-                            foundElements.push(element);
-                        }
-                    }
-                    else {
-                        if ((element.innerText && element.innerText.trim() === text) ||
-                            (element.value && element.value === text)) {
-                            foundElements.push(element);
-                        }
-                    }
-                }
-            }
-            let noChildElements = [];
-            for (let i = 0; i < foundElements.length; i++) {
-                let element = foundElements[i];
-                let hasChild = false;
-                for (let j = 0; j < foundElements.length; j++) {
-                    if (i === j) {
-                        continue;
-                    }
-                    if (isParent(element, foundElements[j])) {
-                        hasChild = true;
-                        break;
-                    }
-                }
-                if (!hasChild) {
-                    noChildElements.push(element);
-                }
-            }
-            let elementCount = 0;
-            if (noChildElements.length > 0) {
-                for (let i = 0; i < noChildElements.length; i++) {
-                    if (randomToken === null) {
-                        randomToken = Math.random().toString(36).substring(7);
-                    }
-                    let element = noChildElements[i];
-                    element.setAttribute("data-blinq-id", "blinq-id-" + randomToken);
-                    elementCount++;
-                }
-            }
-            return { elementCount: elementCount, randomToken: randomToken };
-        }, [text1, tag1, regex1, partial1]);
+            tagCount++;
+        }
+        return { elementCount: tagCount, randomToken };
     }
-    async _collectLocatorInformation(selectorHierarchy, index = 0, scope, foundLocators, _params, info, visibleOnly = true) {
+    async _collectLocatorInformation(selectorHierarchy, index = 0, scope, foundLocators, _params, info, visibleOnly = true, allowDisabled = false) {
         if (!info) {
             info = {};
         }
@@ -484,10 +380,13 @@ class StableBrowser {
         }
         if (!info.log) {
             info.log = "";
+            info.locatorLog = new LocatorLog(selectorHierarchy);
         }
         let locatorSearch = selectorHierarchy[index];
+        let originalLocatorSearch = "";
         try {
-            locatorSearch = JSON.parse(this._fixUsingParams(JSON.stringify(locatorSearch), _params));
+            originalLocatorSearch = _fixUsingParams(JSON.stringify(locatorSearch), _params);
+            locatorSearch = JSON.parse(originalLocatorSearch);
         }
         catch (e) {
             console.error(e);
@@ -495,30 +394,31 @@ class StableBrowser {
         //info.log += "searching for locator " + JSON.stringify(locatorSearch) + "\n";
         let locator = null;
         if (locatorSearch.climb && locatorSearch.climb >= 0) {
-            let locatorString = await this._locateElmentByTextClimbCss(scope, locatorSearch.text, locatorSearch.climb, locatorSearch.css, _params);
+            const replacedText = await this._replaceWithLocalData(locatorSearch.text, this.world);
+            let locatorString = await this._locateElmentByTextClimbCss(scope, replacedText, locatorSearch.climb, locatorSearch.css, _params);
             if (!locatorString) {
                 info.failCause.textNotFound = true;
                 info.failCause.lastError = "failed to locate element by text: " + locatorSearch.text;
                 return;
             }
-            locator = this._getLocator({ css: locatorString }, scope, _params);
+            locator = await this._getLocator({ css: locatorString }, scope, _params);
         }
         else if (locatorSearch.text) {
-            let text = this._fixUsingParams(locatorSearch.text, _params);
-            let result = await this._locateElementByText(scope, text, locatorSearch.tag, false, locatorSearch.partial === true, _params);
+            let text = _fixUsingParams(locatorSearch.text, _params);
+            let result = await this._locateElementByText(scope, text, locatorSearch.tag, false, locatorSearch.partial === true, true, _params);
             if (result.elementCount === 0) {
                 info.failCause.textNotFound = true;
                 info.failCause.lastError = "failed to locate element by text: " + text;
                 return;
             }
-            locatorSearch.css = "[data-blinq-id='blinq-id-" + result.randomToken + "']";
+            locatorSearch.css = "[data-blinq-id-" + result.randomToken + "]";
             if (locatorSearch.childCss) {
                 locatorSearch.css = locatorSearch.css + " " + locatorSearch.childCss;
             }
-            locator = this._getLocator(locatorSearch, scope, _params);
+            locator = await this._getLocator(locatorSearch, scope, _params);
         }
         else {
-            locator = this._getLocator(locatorSearch, scope, _params);
+            locator = await this._getLocator(locatorSearch, scope, _params);
         }
         // let cssHref = false;
         // if (locatorSearch.css && locatorSearch.css.includes("href=")) {
@@ -531,18 +431,27 @@ class StableBrowser {
         //info.log += "total elements found " + count + "\n";
         //let visibleCount = 0;
         let visibleLocator = null;
-        if (locatorSearch.index && locatorSearch.index < count) {
+        if (typeof locatorSearch.index === "number" && locatorSearch.index < count) {
             foundLocators.push(locator.nth(locatorSearch.index));
+            if (info.locatorLog) {
+                info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "FOUND");
+            }
             return;
         }
+        if (info.locatorLog && count === 0) {
+            info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "NOT_FOUND");
+        }
         for (let j = 0; j < count; j++) {
             let visible = await locator.nth(j).isVisible();
             const enabled = await locator.nth(j).isEnabled();
             if (!visibleOnly) {
                 visible = true;
             }
-            if (visible && enabled) {
+            if (visible && (allowDisabled || enabled)) {
                 foundLocators.push(locator.nth(j));
+                if (info.locatorLog) {
+                    info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "FOUND");
+                }
             }
             else {
                 info.failCause.visible = visible;
@@ -550,8 +459,16 @@ class StableBrowser {
                 if (!info.printMessages) {
                     info.printMessages = {};
                 }
+                if (info.locatorLog && !visible) {
+                    info.failCause.lastError = "element " + originalLocatorSearch + " is not visible";
+                    info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "FOUND_NOT_VISIBLE");
+                }
+                if (info.locatorLog && !enabled) {
+                    info.failCause.lastError = "element " + originalLocatorSearch + " is disabled, ";
+                    info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "FOUND_NOT_ENABLED");
+                }
                 if (!info.printMessages[j.toString()]) {
-                    info.log += "element " + locator + " visible " + visible + " enabled " + enabled + "\n";
+                    //info.log += "element " + locator + " visible " + visible + " enabled " + enabled + "\n";
                     info.printMessages[j.toString()] = true;
                 }
             }
@@ -567,7 +484,7 @@ class StableBrowser {
             if (!info) {
                 info = {};
             }
-            info.log += "scan for popup handlers" + "\n";
+            //info.log += "scan for popup handlers" + "\n";
             const handlerGroup = [];
             for (let i = 0; i < this.configuration.popupHandlers.length; i++) {
                 handlerGroup.push(this.configuration.popupHandlers[i].locator);
@@ -594,16 +511,28 @@ 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" });
+                    try {
+                        await scope?.evaluate(() => {
+                            window.__isClosingPopups = true;
+                        });
+                        await dialogCloseLocator.click();
+                        // wait for the dialog to close
+                        await dialogCloseLocator.waitFor({ state: "hidden" });
+                    }
+                    catch (e) {
+                    }
+                    finally {
+                        await scope?.evaluate(() => {
+                            window.__isClosingPopups = false;
+                        });
+                    }
                     return { rerun: true };
                 }
             }
         }
         return { rerun: false };
     }
-    async _locate(selectors, info, _params, timeout) {
+    async _locate(selectors, info, _params, timeout, allowDisabled = false) {
         if (!timeout) {
             timeout = 30000;
         }
@@ -613,7 +542,7 @@ class StableBrowser {
                 let selector = selectors.locators[j];
                 info.log += "searching for locator " + j + ":" + JSON.stringify(selector) + "\n";
             }
-            let element = await this._locate_internal(selectors, info, _params, timeout);
+            let element = await this._locate_internal(selectors, info, _params, timeout, allowDisabled);
             if (!element.rerun) {
                 return element;
             }
@@ -626,6 +555,7 @@ class StableBrowser {
             info.failCause = {};
             info.log = "";
         }
+        let startTime = Date.now();
         let scope = this.page;
         if (selectors.frame) {
             return selectors.frame;
@@ -656,9 +586,11 @@ class StableBrowser {
                 }
                 return framescope;
             };
+            let fLocator = null;
             while (true) {
                 let frameFound = false;
                 if (selectors.nestFrmLoc) {
+                    fLocator = selectors.nestFrmLoc;
                     scope = await findFrame(selectors.nestFrmLoc, scope);
                     frameFound = true;
                     break;
@@ -667,6 +599,7 @@ class StableBrowser {
                     for (let i = 0; i < selectors.frameLocators.length; i++) {
                         let frameLocator = selectors.frameLocators[i];
                         if (frameLocator.css) {
+                            fLocator = frameLocator.css;
                             scope = scope.frameLocator(frameLocator.css);
                             frameFound = true;
                             break;
@@ -674,11 +607,15 @@ class StableBrowser {
                     }
                 }
                 if (!frameFound && selectors.iframe_src) {
+                    fLocator = selectors.iframe_src;
                     scope = this.page.frame({ url: selectors.iframe_src });
                 }
                 if (!scope) {
-                    info.log += "unable to locate iframe " + selectors.iframe_src + "\n";
-                    if (performance.now() - startTime > timeout) {
+                    if (info && info.locatorLog) {
+                        info.locatorLog.setLocatorSearchStatus("frame-" + fLocator, "NOT_FOUND");
+                    }
+                    //info.log += "unable to locate iframe " + selectors.iframe_src + "\n";
+                    if (Date.now() - startTime > timeout) {
                         info.failCause.iframeNotFound = true;
                         info.failCause.lastError = "unable to locate iframe " + selectors.iframe_src;
                         throw new Error("unable to locate iframe " + selectors.iframe_src);
@@ -686,6 +623,9 @@ class StableBrowser {
                     await new Promise((resolve) => setTimeout(resolve, 1000));
                 }
                 else {
+                    if (info && info.locatorLog) {
+                        info.locatorLog.setLocatorSearchStatus("frame-" + fLocator, "FOUND");
+                    }
                     break;
                 }
             }
@@ -702,16 +642,18 @@ class StableBrowser {
             return bodyContent;
         });
     }
-    async _locate_internal(selectors, info, _params, timeout = 30000) {
+    async _locate_internal(selectors, info, _params, timeout = 30000, allowDisabled = false) {
         if (!info) {
             info = {};
             info.failCause = {};
             info.log = "";
+            info.locatorLog = new LocatorLog(selectors);
         }
         let highPriorityTimeout = 5000;
         let visibleOnlyTimeout = 6000;
-        let startTime = performance.now();
+        let startTime = Date.now();
         let locatorsCount = 0;
+        let lazy_scroll = false;
         //let arrayMode = Array.isArray(selectors);
         let scope = await this._findFrameScope(selectors, timeout, info);
         let selectorsLocators = null;
@@ -749,17 +691,17 @@ class StableBrowser {
             }
             // info.log += "scanning locators in priority 1" + "\n";
             let onlyPriority3 = selectorsLocators[0].priority === 3;
-            result = await this._scanLocatorsGroup(locatorsByPriority["1"], scope, _params, info, visibleOnly);
+            result = await this._scanLocatorsGroup(locatorsByPriority["1"], scope, _params, info, visibleOnly, allowDisabled);
             if (result.foundElements.length === 0) {
                 // info.log += "scanning locators in priority 2" + "\n";
-                result = await this._scanLocatorsGroup(locatorsByPriority["2"], scope, _params, info, visibleOnly);
+                result = await this._scanLocatorsGroup(locatorsByPriority["2"], scope, _params, info, visibleOnly, allowDisabled);
             }
             if (result.foundElements.length === 0 && onlyPriority3) {
-                result = await this._scanLocatorsGroup(locatorsByPriority["3"], scope, _params, info, visibleOnly);
+                result = await this._scanLocatorsGroup(locatorsByPriority["3"], scope, _params, info, visibleOnly, allowDisabled);
             }
             else {
                 if (result.foundElements.length === 0 && !highPriorityOnly) {
-                    result = await this._scanLocatorsGroup(locatorsByPriority["3"], scope, _params, info, visibleOnly);
+                    result = await this._scanLocatorsGroup(locatorsByPriority["3"], scope, _params, info, visibleOnly, allowDisabled);
                 }
             }
             let foundElements = result.foundElements;
@@ -800,26 +742,38 @@ class StableBrowser {
                     return maxCountElement.locator;
                 }
             }
-            if (performance.now() - startTime > timeout) {
+            if (Date.now() - startTime > timeout) {
                 break;
             }
-            if (performance.now() - startTime > highPriorityTimeout) {
-                info.log += "high priority timeout, will try all elements" + "\n";
+            if (Date.now() - startTime > highPriorityTimeout) {
+                //info.log += "high priority timeout, will try all elements" + "\n";
                 highPriorityOnly = false;
+                if (this.configuration && this.configuration.load_all_lazy === true && !lazy_scroll) {
+                    lazy_scroll = true;
+                    await scrollPageToLoadLazyElements(this.page);
+                }
             }
-            if (performance.now() - startTime > visibleOnlyTimeout) {
-                info.log += "visible only timeout, will try all elements" + "\n";
+            if (Date.now() - startTime > visibleOnlyTimeout) {
+                //info.log += "visible only timeout, will try all elements" + "\n";
                 visibleOnly = false;
             }
             await new Promise((resolve) => setTimeout(resolve, 1000));
         }
         this.logger.debug("unable to locate unique element, total elements found " + locatorsCount);
-        info.log += "failed to locate unique element, total elements found " + locatorsCount + "\n";
+        // if (info.locatorLog) {
+        //   const lines = info.locatorLog.toString().split("\n");
+        //   for (let line of lines) {
+        //     this.logger.debug(line);
+        //   }
+        // }
+        //info.log += "failed to locate unique element, total elements found " + locatorsCount + "\n";
         info.failCause.locatorNotFound = true;
-        info.failCause.lastError = "failed to locate unique element";
+        if (!info?.failCause?.lastError) {
+            info.failCause.lastError = "failed to locate unique element";
+        }
         throw new Error("failed to locate first element no elements found, " + info.log);
     }
-    async _scanLocatorsGroup(locatorsGroup, scope, _params, info, visibleOnly) {
+    async _scanLocatorsGroup(locatorsGroup, scope, _params, info, visibleOnly, allowDisabled = false) {
         let foundElements = [];
         const result = {
             foundElements: foundElements,
@@ -827,14 +781,15 @@ class StableBrowser {
         for (let i = 0; i < locatorsGroup.length; i++) {
             let foundLocators = [];
             try {
-                await this._collectLocatorInformation(locatorsGroup, i, scope, foundLocators, _params, info, visibleOnly);
+                await this._collectLocatorInformation(locatorsGroup, i, scope, foundLocators, _params, info, visibleOnly, allowDisabled);
             }
             catch (e) {
-                this.logger.debug("unable to use locator " + JSON.stringify(locatorsGroup[i]));
-                this.logger.debug(e);
+                // this call can fail it the browser is navigating
+                // this.logger.debug("unable to use locator " + JSON.stringify(locatorsGroup[i]));
+                // this.logger.debug(e);
                 foundLocators = [];
                 try {
-                    await this._collectLocatorInformation(locatorsGroup, i, this.page, foundLocators, _params, info, visibleOnly);
+                    await this._collectLocatorInformation(locatorsGroup, i, this.page, foundLocators, _params, info, visibleOnly, allowDisabled);
                 }
                 catch (e) {
                     this.logger.info("unable to use locator (second try) " + JSON.stringify(locatorsGroup[i]));
@@ -850,11 +805,27 @@ class StableBrowser {
             }
             if (foundLocators.length > 1) {
                 info.failCause.foundMultiple = true;
+                if (info.locatorLog) {
+                    info.locatorLog.setLocatorSearchStatus(JSON.stringify(locatorsGroup[i]), "FOUND_NOT_UNIQUE");
+                }
             }
         }
         return result;
     }
     async simpleClick(elementDescription, _params, options = {}, world = null) {
+        const state = {
+            locate: false,
+            scroll: false,
+            highlight: false,
+            _params,
+            options,
+            world,
+            type: Types.CLICK,
+            text: "Click element",
+            operation: "simpleClick",
+            log: "***** click on " + elementDescription + " *****\n",
+        };
+        _preCommand(state, this, world);
         const startTime = Date.now();
         let timeout = 30000;
         if (options && options.timeout) {
@@ -879,13 +850,31 @@ class StableBrowser {
             catch (e) {
                 if (performance.now() - startTime > timeout) {
                     // throw e;
-                    await _commandError({ text: "simpleClick", operation: "simpleClick", elementDescription, info: {} }, e, this);
+                    try {
+                        await _commandError(state, "timeout looking for " + elementDescription, this);
+                    }
+                    finally {
+                        _commandFinally(state, this);
+                    }
                 }
             }
             await new Promise((resolve) => setTimeout(resolve, 3000));
         }
     }
     async simpleClickType(elementDescription, value, _params, options = {}, world = null) {
+        const state = {
+            locate: false,
+            scroll: false,
+            highlight: false,
+            _params,
+            options,
+            world,
+            type: Types.FILL,
+            text: "Fill element",
+            operation: "simpleClickType",
+            log: "***** click type on " + elementDescription + " *****\n",
+        };
+        _preCommand(state, this, world);
         const startTime = Date.now();
         let timeout = 30000;
         if (options && options.timeout) {
@@ -910,7 +899,12 @@ class StableBrowser {
             catch (e) {
                 if (performance.now() - startTime > timeout) {
                     // throw e;
-                    await _commandError({ text: "simpleClickType", operation: "simpleClickType", value, elementDescription, info: {} }, e, this);
+                    try {
+                        await _commandError(state, "timeout looking for " + elementDescription, this);
+                    }
+                    finally {
+                        _commandFinally(state, this);
+                    }
                 }
             }
             await new Promise((resolve) => setTimeout(resolve, 3000));
@@ -928,10 +922,10 @@ class StableBrowser {
             log: "***** click on " + selectors.element_name + " *****\n",
         };
         try {
-            await _preCommand(state, this);
-            if (state.options && state.options.context) {
-                state.selectors.locators[0].text = state.options.context;
-            }
+            await _preCommand(state, this, world);
+            // if (state.options && state.options.context) {
+            //   state.selectors.locators[0].text = state.options.context;
+            // }
             try {
                 await state.element.click();
                 // await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -964,14 +958,20 @@ class StableBrowser {
             log: "***** check " + selectors.element_name + " *****\n",
         };
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             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);
+                if (world && world.screenshot && !world.screenshotPath) {
+                    // console.log(`Highlighting while running from recorder`);
+                    await this._highlightElements(element);
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                    await this._unHighlightElements(element);
+                }
                 await state.element.setChecked(checked);
-                await new Promise((resolve) => setTimeout(resolve, 1000));
+                // await new Promise((resolve) => setTimeout(resolve, 1000));
+                //  await this._unHighlightElements(element);
             }
             catch (e) {
                 if (e.message && e.message.includes("did not change its state")) {
@@ -1007,9 +1007,10 @@ class StableBrowser {
             log: "***** hover " + selectors.element_name + " *****\n",
         };
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             try {
                 await state.element.hover();
+                await _screenshot(state, this);
                 await new Promise((resolve) => setTimeout(resolve, 1000));
             }
             catch (e) {
@@ -1017,9 +1018,10 @@ class StableBrowser {
                 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 _screenshot(state, this);
                 await new Promise((resolve) => setTimeout(resolve, 1000));
             }
-            await _screenshot(state, this);
+            // await _screenshot(state, this);
             await this.waitForPageLoad();
             return state.info;
         }
@@ -1046,7 +1048,7 @@ class StableBrowser {
             log: "***** select option " + selectors.element_name + " *****\n",
         };
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             try {
                 await state.element.selectOption(values);
             }
@@ -1080,7 +1082,7 @@ class StableBrowser {
             log: "",
         };
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             const valueSegment = state.value.split("&&");
             for (let i = 0; i < valueSegment.length; i++) {
                 if (i > 0) {
@@ -1123,7 +1125,7 @@ class StableBrowser {
             log: "***** set input value " + selectors.element_name + " *****\n",
         };
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             let value = await this._replaceWithLocalData(state.value, this);
             try {
                 await state.element.evaluateHandle((el, value) => {
@@ -1160,7 +1162,7 @@ class StableBrowser {
             throwError: false,
         };
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             try {
                 await state.element.click();
                 await new Promise((resolve) => setTimeout(resolve, 500));
@@ -1234,7 +1236,7 @@ class StableBrowser {
             _value = newValue;
         }
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             state.info.value = _value;
             if (options === null || options === undefined || !options.press) {
                 try {
@@ -1291,7 +1293,12 @@ class StableBrowser {
                 await this.waitForPageLoad();
             }
             else if (enter === false) {
-                await state.element.dispatchEvent("change");
+                try {
+                    await state.element.dispatchEvent("change", null, { timeout: 5000 });
+                }
+                catch (e) {
+                    // ignore
+                }
                 //await this.page.keyboard.press("Tab");
             }
             else {
@@ -1322,7 +1329,7 @@ class StableBrowser {
             log: "***** fill on " + selectors.element_name + " with value " + value + "*****\n",
         };
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             await state.element.fill(value);
             await state.element.dispatchEvent("change");
             if (enter) {
@@ -1348,6 +1355,7 @@ class StableBrowser {
         let screenshotPath = null;
         if (!info.log) {
             info.log = "";
+            info.locatorLog = new LocatorLog(selectors);
         }
         info.operation = "getText";
         info.selectors = selectors;
@@ -1367,9 +1375,19 @@ class StableBrowser {
         catch (e) {
             //ignore
         }
-        ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
+        ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info, element));
         try {
-            await this._highlightElements(element);
+            if (world && world.screenshot && !world.screenshotPath) {
+                // console.log(`Highlighting for get text while running from recorder`);
+                this._highlightElements(element)
+                    .then(async () => {
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    this._unhighlightElements(element).then(() => { }
+                    // console.log(`Unhighlighting vrtr in recorder is successful`)
+                    );
+                })
+                    .catch(e);
+            }
             const elementText = await element.innerText();
             return {
                 text: elementText,
@@ -1381,7 +1399,7 @@ class StableBrowser {
         }
         catch (e) {
             //await this.closeUnexpectedPopups();
-            this.logger.info("no innerText will use textContent");
+            this.logger.info("no innerText, will use textContent");
             const elementText = await element.textContent();
             return { text: elementText, screenshotId, screenshotPath, value: value };
         }
@@ -1416,13 +1434,13 @@ class StableBrowser {
         }
         let foundObj = null;
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             state.info.pattern = pattern;
             foundObj = await this._getText(selectors, 0, _params, options, state.info, world);
             if (foundObj && foundObj.element) {
                 await this.scrollIfNeeded(foundObj.element, state.info);
             }
-            await _screenshot(state, this);
+            await _screenshot(state, this, foundObj.element);
             let escapedText = text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
             pattern = pattern.replace("{text}", escapedText);
             let regex = new RegExp(pattern, "im");
@@ -1467,12 +1485,12 @@ class StableBrowser {
         }
         let foundObj = null;
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             foundObj = await this._getText(selectors, climb, _params, options, state.info, world);
             if (foundObj && foundObj.element) {
                 await this.scrollIfNeeded(foundObj.element, state.info);
             }
-            await _screenshot(state, this);
+            await _screenshot(state, this, foundObj.element);
             const dateAlternatives = findDateAlternatives(text);
             const numberAlternatives = findNumberAlternatives(text);
             if (dateAlternatives.date) {
@@ -1661,7 +1679,7 @@ class StableBrowser {
         }
         return data;
     }
-    async _screenShot(options = {}, world = null, info = null) {
+    async _screenShot(options = {}, world = null, info = null, focusedElement = null) {
         // collect url/path/title
         if (info) {
             if (!info.title) {
@@ -1686,13 +1704,11 @@ class StableBrowser {
             if (!fs.existsSync(world.screenshotPath)) {
                 fs.mkdirSync(world.screenshotPath, { recursive: true });
             }
-            let nextIndex = 1;
-            while (fs.existsSync(path.join(world.screenshotPath, nextIndex + ".png"))) {
-                nextIndex++;
-            }
-            const screenshotPath = path.join(world.screenshotPath, nextIndex + ".png");
+            // to make sure the path doesn't start with -
+            const uuidStr = "id_" + randomUUID();
+            const screenshotPath = path.join(world.screenshotPath, uuidStr + ".png");
             try {
-                await this.takeScreenshot(screenshotPath);
+                await this.takeScreenshot(screenshotPath, focusedElement);
                 // let buffer = await this.page.screenshot({ timeout: 4000 });
                 // // save the buffer to the screenshot path asynchrously
                 // fs.writeFile(screenshotPath, buffer, (err) => {
@@ -1700,20 +1716,20 @@ class StableBrowser {
                 //     this.logger.info("unable to save screenshot " + screenshotPath);
                 //   }
                 // });
+                result.screenshotId = uuidStr;
+                result.screenshotPath = screenshotPath;
+                if (info && info.box) {
+                    // await drawRectangle(screenshotPath, info.box.x, info.box.y, info.box.width, info.box.height);
+                }
             }
             catch (e) {
                 this.logger.info("unable to take screenshot, ignored");
             }
-            result.screenshotId = nextIndex;
-            result.screenshotPath = screenshotPath;
-            if (info && info.box) {
-                await drawRectangle(screenshotPath, info.box.x, info.box.y, info.box.width, info.box.height);
-            }
         }
         else if (options && options.screenshot) {
             result.screenshotPath = options.screenshotPath;
             try {
-                await this.takeScreenshot(options.screenshotPath);
+                await this.takeScreenshot(options.screenshotPath, focusedElement);
                 // let buffer = await this.page.screenshot({ timeout: 4000 });
                 // // save the buffer to the screenshot path asynchrously
                 // fs.writeFile(options.screenshotPath, buffer, (err) => {
@@ -1726,12 +1742,12 @@ class StableBrowser {
                 this.logger.info("unable to take screenshot, ignored");
             }
             if (info && info.box) {
-                await drawRectangle(options.screenshotPath, info.box.x, info.box.y, info.box.width, info.box.height);
+                // await drawRectangle(options.screenshotPath, info.box.x, info.box.y, info.box.width, info.box.height);
             }
         }
         return result;
     }
-    async takeScreenshot(screenshotPath) {
+    async takeScreenshot(screenshotPath, focusedElement = null) {
         const playContext = this.context.playContext;
         // Using CDP to capture the screenshot
         const viewportWidth = Math.max(...(await this.page.evaluate(() => [
@@ -1743,6 +1759,15 @@ class StableBrowser {
             document.documentElement.clientWidth,
         ])));
         let screenshotBuffer = null;
+        // if (focusedElement) {
+        //   // console.log(`Focused element ${JSON.stringify(focusedElement._selector)}`)
+        //   await this._unhighlightElements(focusedElement);
+        //   await new Promise((resolve) => setTimeout(resolve, 100));
+        //   console.log(`Unhighlighted previous element`);
+        // }
+        if (focusedElement) {
+            await this._highlightElements(focusedElement);
+        }
         if (this.context.browserName === "chromium") {
             const client = await playContext.newCDPSession(this.page);
             const { data } = await client.send("Page.captureScreenshot", {
@@ -1764,6 +1789,10 @@ class StableBrowser {
         else {
             screenshotBuffer = await this.page.screenshot();
         }
+        if (focusedElement) {
+            // console.log(`Focused element ${JSON.stringify(focusedElement._selector)}`)
+            await this._unhighlightElements(focusedElement);
+        }
         let image = await Jimp.read(screenshotBuffer);
         // Get the image dimensions
         const { width, height } = image.bitmap;
@@ -1790,7 +1819,7 @@ class StableBrowser {
         };
         await new Promise((resolve) => setTimeout(resolve, 2000));
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             await expect(state.element).toHaveCount(1, { timeout: 10000 });
             return state.info;
         }
@@ -1816,7 +1845,7 @@ class StableBrowser {
         };
         await new Promise((resolve) => setTimeout(resolve, 2000));
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             switch (attribute) {
                 case "inner_text":
                     state.value = await state.element.innerText();
@@ -1834,6 +1863,70 @@ class StableBrowser {
             state.info.value = state.value;
             this.setTestData({ [variable]: state.value }, world);
             this.logger.info("set test data: " + variable + "=" + state.value);
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            return state.info;
+        }
+        catch (e) {
+            await _commandError(state, e, this);
+        }
+        finally {
+            _commandFinally(state, this);
+        }
+    }
+    async verifyAttribute(selectors, attribute, value, _params = null, options = {}, world = null) {
+        const state = {
+            selectors,
+            _params,
+            attribute,
+            value,
+            options,
+            world,
+            type: Types.VERIFY_ATTRIBUTE,
+            highlight: true,
+            screenshot: true,
+            text: `Verify element attribute`,
+            operation: "verifyAttribute",
+            log: "***** verify attribute " + attribute + " from " + selectors.element_name + " *****\n",
+            allowDisabled: true,
+        };
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        let val;
+        try {
+            await _preCommand(state, this, world);
+            switch (attribute) {
+                case "innerText":
+                    val = String(await state.element.innerText());
+                    break;
+                case "value":
+                    val = String(await state.element.inputValue());
+                    break;
+                case "checked":
+                    val = String(await state.element.isChecked());
+                    break;
+                case "disabled":
+                    val = String(await state.element.isDisabled());
+                    break;
+                case "readOnly":
+                    const isEditable = await state.element.isEditable();
+                    val = String(!isEditable);
+                    break;
+                default:
+                    val = String(await state.element.getAttribute(attribute));
+                    break;
+            }
+            state.info.expectedValue = val;
+            let regex;
+            if (value.startsWith("/") && value.endsWith("/")) {
+                const patternBody = value.slice(1, -1);
+                regex = new RegExp(patternBody, "g");
+            }
+            else {
+                const escapedPattern = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                regex = new RegExp(escapedPattern, "g");
+            }
+            if (!val.match(regex)) {
+                throw new Error(`The ${attribute} attribute has a value of "${val}", but the expected value is "${value}"`);
+            }
             return state.info;
         }
         catch (e) {
@@ -1861,7 +1954,7 @@ class StableBrowser {
         if (options && options.timeout) {
             timeout = options.timeout;
         }
-        const serviceUrl = this._getServerUrl() + "/api/mail/createLinkOrCodeFromEmail";
+        const serviceUrl = _getServerUrl() + "/api/mail/createLinkOrCodeFromEmail";
         const request = {
             method: "POST",
             url: serviceUrl,
@@ -1932,27 +2025,32 @@ class StableBrowser {
     async _highlightElements(scope, css) {
         try {
             if (!scope) {
+                // console.log(`Scope is not defined`);
                 return;
             }
             if (!css) {
                 scope
                     .evaluate((node) => {
                     if (node && node.style) {
-                        let originalBorder = node.style.border;
-                        node.style.border = "2px solid red";
-                        if (window) {
-                            window.addEventListener("beforeunload", function (e) {
-                                node.style.border = originalBorder;
-                            });
-                        }
-                        setTimeout(function () {
-                            node.style.border = originalBorder;
-                        }, 2000);
+                        let originalOutline = node.style.outline;
+                        // console.log(`Original outline was: ${originalOutline}`);
+                        node.__previousOutline = originalOutline;
+                        node.style.outline = "2px solid red";
+                        // console.log(`New outline is: ${node.style.outline}`);
+                        // if (window) {
+                        //   window.addEventListener("beforeunload", function (e) {
+                        //     node.style.outline = originalBorder;
+                        //   });
+                        // }
+                        // setTimeout(function () {
+                        //   node.style.outline = originalBorder;
+                        //}, 2000);
                     }
                 })
                     .then(() => { })
                     .catch((e) => {
                     // ignore
+                    // console.error(`Could not highlight node : ${e}`);
                 });
             }
             else {
@@ -1968,24 +2066,26 @@ class StableBrowser {
                         if (!element.style) {
                             return;
                         }
-                        var originalBorder = element.style.border;
+                        let originalOutline = element.style.outline;
+                        element.__previousOutline = originalOutline;
                         // Set the new border to be red and 2px solid
-                        element.style.border = "2px solid red";
-                        if (window) {
-                            window.addEventListener("beforeunload", function (e) {
-                                element.style.border = originalBorder;
-                            });
-                        }
+                        element.style.outline = "2px solid red";
+                        // if (window) {
+                        //   window.addEventListener("beforeunload", function (e) {
+                        //     element.style.outline = originalBorder;
+                        //   });
+                        // }
                         // Set a timeout to revert to the original border after 2 seconds
-                        setTimeout(function () {
-                            element.style.border = originalBorder;
-                        }, 2000);
+                        // setTimeout(function () {
+                        //   element.style.outline = originalBorder;
+                        // }, 2000);
                     }
                     return;
                 }, [css])
                     .then(() => { })
                     .catch((e) => {
                     // ignore
+                    // console.error(`Could not highlight css: ${e}`);
                 });
             }
         }
@@ -1993,6 +2093,58 @@ class StableBrowser {
             console.debug(error);
         }
     }
+    async _unhighlightElements(scope, css) {
+        try {
+            if (!scope) {
+                return;
+            }
+            if (!css) {
+                scope
+                    .evaluate((node) => {
+                    if (node && node.style) {
+                        if (!node.__previousOutline) {
+                            node.style.outline = "";
+                        }
+                        else {
+                            node.style.outline = node.__previousOutline;
+                        }
+                    }
+                })
+                    .then(() => { })
+                    .catch((e) => {
+                    // console.log(`Error while unhighlighting node ${JSON.stringify(scope)}: ${e}`);
+                });
+            }
+            else {
+                scope
+                    .evaluate(([css]) => {
+                    if (!css) {
+                        return;
+                    }
+                    let elements = Array.from(document.querySelectorAll(css));
+                    for (i = 0; i < elements.length; i++) {
+                        let element = elements[i];
+                        if (!element.style) {
+                            return;
+                        }
+                        if (!element.__previousOutline) {
+                            element.style.outline = "";
+                        }
+                        else {
+                            element.style.outline = element.__previousOutline;
+                        }
+                    }
+                })
+                    .then(() => { })
+                    .catch((e) => {
+                    // console.error(`Error while unhighlighting element in css: ${e}`);
+                });
+            }
+        }
+        catch (error) {
+            // console.debug(error);
+        }
+    }
     async verifyPagePath(pathPart, options = {}, world = null) {
         const startTime = Date.now();
         let error = null;
@@ -2034,7 +2186,7 @@ class StableBrowser {
         }
         finally {
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 type: Types.VERIFY_PAGE_PATH,
                 text: "Verify page path",
                 screenshotId,
@@ -2054,6 +2206,35 @@ class StableBrowser {
             });
         }
     }
+    async findTextInAllFrames(dateAlternatives, numberAlternatives, text, state) {
+        const frames = this.page.frames();
+        let results = [];
+        let ignoreCase = false;
+        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], "*:not(script, style, head)", false, true, ignoreCase, {});
+                    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], "*:not(script, style, head)", false, true, ignoreCase, {});
+                    result.frame = frames[i];
+                    results.push(result);
+                }
+            }
+            else {
+                const result = await this._locateElementByText(frames[i], text, "*:not(script, style, head)", false, true, ignoreCase, {});
+                result.frame = frames[i];
+                results.push(result);
+            }
+        }
+        state.info.results = results;
+        const resultWithElementsFound = results.filter((result) => result.elementCount > 0);
+        return resultWithElementsFound;
+    }
     async verifyTextExistInPage(text, options = {}, world = null) {
         text = unEscapeString(text);
         const state = {
@@ -2063,7 +2244,7 @@ class StableBrowser {
             locate: false,
             scroll: false,
             highlight: false,
-            type: Types.VERIFY_ELEMENT_CONTAINS_TEXT,
+            type: Types.VERIFY_PAGE_CONTAINS_TEXT,
             text: `Verify text exists in page`,
             operation: "verifyTextExistInPage",
             log: "***** verify text " + text + " exists in page *****\n",
@@ -2078,34 +2259,10 @@ class StableBrowser {
         let dateAlternatives = findDateAlternatives(text);
         let numberAlternatives = findNumberAlternatives(text);
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             state.info.text = text;
             while (true) {
-                const frames = this.page.frames();
-                let results = [];
-                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], "*:not(script, style, head)", 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], "*:not(script, style, head)", true, true, {});
-                            result.frame = frames[i];
-                            results.push(result);
-                        }
-                    }
-                    else {
-                        const result = await this._locateElementByText(frames[i], text, "*:not(script, style, head)", true, true, {});
-                        result.frame = frames[i];
-                        results.push(result);
-                    }
-                }
-                state.info.results = results;
-                const resultWithElementsFound = results.filter((result) => result.elementCount > 0);
+                const resultWithElementsFound = await this.findTextInAllFrames(dateAlternatives, numberAlternatives, text, state);
                 if (resultWithElementsFound.length === 0) {
                     if (Date.now() - state.startTime > timeout) {
                         throw new Error(`Text ${text} not found in page`);
@@ -2115,15 +2272,32 @@ class StableBrowser {
                 }
                 if (resultWithElementsFound[0].randomToken) {
                     const frame = resultWithElementsFound[0].frame;
-                    const dataAttribute = `[data-blinq-id="blinq-id-${resultWithElementsFound[0].randomToken}"]`;
-                    await this._highlightElements(frame, dataAttribute);
-                    const element = await frame.$(dataAttribute);
+                    const dataAttribute = `[data-blinq-id-${resultWithElementsFound[0].randomToken}]`;
+                    if (world && world.screenshot && !world.screenshotPath) {
+                        // console.log(`Highlighting for verify text is found while running from recorder`);
+                        this._highlightElements(frame, dataAttribute).then(async () => {
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            this._unhighlightElements(frame, dataAttribute)
+                                .then(async () => {
+                                // console.log(`Unhighlighted frame dataAttribute successfully`);
+                            })
+                                .catch((e) => { }
+                            //  console.error(e)
+                            );
+                        });
+                    }
+                    const element = await frame.locator(dataAttribute).first();
+                    // await new Promise((resolve) => setTimeout(resolve, 100));
+                    // await this._unhighlightElements(frame, dataAttribute);
                     if (element) {
                         await this.scrollIfNeeded(element, state.info);
                         await element.dispatchEvent("bvt_verify_page_contains_text");
+                        await _screenshot(state, this, element);
                     }
                 }
-                await _screenshot(state, this);
+                else {
+                    await _screenshot(state, this);
+                }
                 return state.info;
             }
             // await expect(element).toHaveCount(1, { timeout: 10000 });
@@ -2159,34 +2333,10 @@ class StableBrowser {
         let dateAlternatives = findDateAlternatives(text);
         let numberAlternatives = findNumberAlternatives(text);
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             state.info.text = text;
             while (true) {
-                const frames = this.page.frames();
-                let results = [];
-                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], "*:not(script, style, head)", 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], "*:not(script, style, head)", true, true, {});
-                            result.frame = frames[i];
-                            results.push(result);
-                        }
-                    }
-                    else {
-                        const result = await this._locateElementByText(frames[i], text, "*:not(script, style, head)", true, true, {});
-                        result.frame = frames[i];
-                        results.push(result);
-                    }
-                }
-                state.info.results = results;
-                const resultWithElementsFound = results.filter((result) => result.elementCount > 0);
+                const resultWithElementsFound = await this.findTextInAllFrames(dateAlternatives, numberAlternatives, text, state);
                 if (resultWithElementsFound.length === 0) {
                     await _screenshot(state, this);
                     return state.info;
@@ -2204,15 +2354,103 @@ class StableBrowser {
             _commandFinally(state, this);
         }
     }
-    _getServerUrl() {
-        let serviceUrl = "https://api.blinq.io";
-        if (process.env.NODE_ENV_BLINQ === "dev") {
-            serviceUrl = "https://dev.api.blinq.io";
+    async verifyTextRelatedToText(textAnchor, climb, textToVerify, options = {}, world = null) {
+        textAnchor = unEscapeString(textAnchor);
+        textToVerify = unEscapeString(textToVerify);
+        const state = {
+            text_search: textToVerify,
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            highlight: false,
+            type: Types.VERIFY_TEXT_WITH_RELATION,
+            text: `Verify text with relation to another text`,
+            operation: "verify_text_with_relation",
+            log: "***** search for " + textAnchor + " climb " + climb + " and verify " + textToVerify + " found *****\n",
+        };
+        const timeout = this._getLoadTimeout(options);
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        let newValue = await this._replaceWithLocalData(textAnchor, world);
+        if (newValue !== textAnchor) {
+            this.logger.info(textAnchor + "=" + newValue);
+            textAnchor = newValue;
+        }
+        newValue = await this._replaceWithLocalData(textToVerify, world);
+        if (newValue !== textToVerify) {
+            this.logger.info(textToVerify + "=" + newValue);
+            textToVerify = newValue;
+        }
+        let dateAlternatives = findDateAlternatives(textToVerify);
+        let numberAlternatives = findNumberAlternatives(textToVerify);
+        let foundAncore = false;
+        try {
+            await _preCommand(state, this, world);
+            state.info.text = textToVerify;
+            while (true) {
+                const resultWithElementsFound = await this.findTextInAllFrames(dateAlternatives, numberAlternatives, textAnchor, state);
+                if (resultWithElementsFound.length === 0) {
+                    if (Date.now() - state.startTime > timeout) {
+                        throw new Error(`Text ${foundAncore ? textToVerify : textAnchor} not found in page`);
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    continue;
+                }
+                for (let i = 0; i < resultWithElementsFound.length; i++) {
+                    foundAncore = true;
+                    const result = resultWithElementsFound[i];
+                    const token = result.randomToken;
+                    const frame = result.frame;
+                    let css = `[data-blinq-id-${token}]`;
+                    const climbArray1 = [];
+                    for (let i = 0; i < climb; i++) {
+                        climbArray1.push("..");
+                    }
+                    let climbXpath = "xpath=" + climbArray1.join("/");
+                    css = css + " >> " + climbXpath;
+                    const count = await frame.locator(css).count();
+                    for (let j = 0; j < count; j++) {
+                        const continer = await frame.locator(css).nth(j);
+                        const result = await this._locateElementByText(continer, textToVerify, "*", false, true, true, {});
+                        if (result.elementCount > 0) {
+                            const dataAttribute = "[data-blinq-id-" + result.randomToken + "]";
+                            //const cssAnchor = `[data-blinq-id="blinq-id-${token}-anchor"]`;
+                            if (world && world.screenshot && !world.screenshotPath) {
+                                // console.log(`Highlighting for vtrt while running from recorder`);
+                                this._highlightElements(frame, dataAttribute)
+                                    .then(async () => {
+                                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                                    this._unhighlightElements(frame, dataAttribute).then(() => { }
+                                    // console.log(`Unhighlighting vrtr in recorder is successful`)
+                                    );
+                                })
+                                    .catch(e);
+                            }
+                            //await this._highlightElements(frame, cssAnchor);
+                            const element = await frame.locator(dataAttribute).first();
+                            // await new Promise((resolve) => setTimeout(resolve, 100));
+                            // await this._unhighlightElements(frame, dataAttribute);
+                            if (element) {
+                                await this.scrollIfNeeded(element, state.info);
+                                await element.dispatchEvent("bvt_verify_page_contains_text");
+                                await _screenshot(state, this, element);
+                            }
+                            else {
+                                await _screenshot(state, this);
+                            }
+                            return state.info;
+                        }
+                    }
+                }
+            }
+            // await expect(element).toHaveCount(1, { timeout: 10000 });
         }
-        else if (process.env.NODE_ENV_BLINQ === "stage") {
-            serviceUrl = "https://stage.api.blinq.io";
+        catch (e) {
+            await _commandError(state, e, this);
+        }
+        finally {
+            _commandFinally(state, this);
         }
-        return serviceUrl;
     }
     async visualVerification(text, options = {}, world = null) {
         const startTime = Date.now();
@@ -2228,7 +2466,7 @@ class StableBrowser {
             throw new Error("TOKEN is not set");
         }
         try {
-            let serviceUrl = this._getServerUrl();
+            let serviceUrl = _getServerUrl();
             ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
             info.screenshotPath = screenshotPath;
             const screenshot = await this.takeScreenshot();
@@ -2269,7 +2507,7 @@ class StableBrowser {
         }
         finally {
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 type: Types.VERIFY_VISUAL,
                 text: "Visual verification",
                 screenshotId,
@@ -2317,18 +2555,19 @@ class StableBrowser {
         let screenshotPath = null;
         const info = {};
         info.log = "";
+        info.locatorLog = new LocatorLog(selectors);
         info.operation = "getTableData";
         info.selectors = selectors;
         try {
             let table = await this._locate(selectors, info, _params);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
+            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info, table));
             const tableData = await getTableData(this.page, table);
             return tableData;
         }
         catch (e) {
             this.logger.error("getTableData failed " + info.log);
             this.logger.error(e);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
+            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info, table));
             info.screenshotPath = screenshotPath;
             Object.assign(e, { info: info });
             error = e;
@@ -2337,7 +2576,7 @@ class StableBrowser {
         }
         finally {
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 element_name: selectors.element_name,
                 type: Types.GET_TABLE_DATA,
                 text: "Get table data",
@@ -2392,7 +2631,7 @@ class StableBrowser {
         info.operation = "analyzeTable";
         info.selectors = selectors;
         info.query = query;
-        query = this._fixUsingParams(query, _params);
+        query = _fixUsingParams(query, _params);
         info.query_fixed = query;
         info.operator = operator;
         info.value = value;
@@ -2503,7 +2742,7 @@ class StableBrowser {
         }
         finally {
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 element_name: selectors.element_name,
                 type: Types.ANALYZE_TABLE,
                 text: "Analyze table",
@@ -2576,7 +2815,7 @@ class StableBrowser {
             await new Promise((resolve) => setTimeout(resolve, 2000));
             ({ screenshotId, screenshotPath } = await this._screenShot(options, world));
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 type: Types.GET_PAGE_STATUS,
                 text: "Wait for page load",
                 screenshotId,
@@ -2609,7 +2848,7 @@ class StableBrowser {
             throwError: false,
         };
         try {
-            await _preCommand(state, this);
+            await _preCommand(state, this, world);
             await this.page.close();
         }
         catch (e) {
@@ -2620,6 +2859,11 @@ class StableBrowser {
             _commandFinally(state, this);
         }
     }
+    saveTestDataAsGlobal(options, world) {
+        const dataFile = this._getDataFile(world);
+        process.env.GLOBAL_TEST_DATA_FILE = dataFile;
+        this.logger.info("Save the scenario test data as global for the following scenarios.");
+    }
     async setViewportSize(width, hight, options = {}, world = null) {
         const startTime = Date.now();
         let error = null;
@@ -2643,7 +2887,7 @@ class StableBrowser {
             await new Promise((resolve) => setTimeout(resolve, 2000));
             ({ screenshotId, screenshotPath } = await this._screenShot(options, world));
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 type: Types.SET_VIEWPORT,
                 text: "set viewport size to " + width + "x" + hight,
                 screenshotId,
@@ -2680,7 +2924,7 @@ class StableBrowser {
             await new Promise((resolve) => setTimeout(resolve, 2000));
             ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 type: Types.GET_PAGE_STATUS,
                 text: "page relaod",
                 screenshotId,
@@ -2716,26 +2960,35 @@ class StableBrowser {
             console.log("#-#");
         }
     }
-    _reportToWorld(world, properties) {
-        if (!world || !world.attach) {
-            return;
-        }
-        world.attach(JSON.stringify(properties), { mediaType: "application/json" });
-    }
     async beforeStep(world, step) {
-        this.stepName = step.pickleStep.text;
-        this.logger.info("step: " + this.stepName);
         if (this.stepIndex === undefined) {
             this.stepIndex = 0;
         }
         else {
             this.stepIndex++;
         }
+        if (step && step.pickleStep && step.pickleStep.text) {
+            this.stepName = step.pickleStep.text;
+            this.logger.info("step: " + this.stepName);
+        }
+        else if (step && step.text) {
+            this.stepName = step.text;
+        }
+        else {
+            this.stepName = "step " + this.stepIndex;
+        }
         if (this.context && this.context.browserObject && this.context.browserObject.trace === true) {
             if (this.context.browserObject.context) {
                 await this.context.browserObject.context.tracing.startChunk({ title: this.stepName });
             }
         }
+        if (this.tags === null && step && step.pickle && step.pickle.tags) {
+            this.tags = step.pickle.tags.map((tag) => tag.name);
+            // check if @global_test_data tag is present
+            if (this.tags.includes("@global_test_data")) {
+                this.saveTestDataAsGlobal({}, world);
+            }
+        }
     }
     async afterStep(world, step) {
         this.stepName = null;
@@ -2753,156 +3006,5 @@ function createTimedPromise(promise, label) {
         .then((result) => ({ status: "fulfilled", label, result }))
         .catch((error) => Promise.reject({ status: "rejected", label, error }));
 }
-const KEYBOARD_EVENTS = [
-    "ALT",
-    "AltGraph",
-    "CapsLock",
-    "Control",
-    "Fn",
-    "FnLock",
-    "Hyper",
-    "Meta",
-    "NumLock",
-    "ScrollLock",
-    "Shift",
-    "Super",
-    "Symbol",
-    "SymbolLock",
-    "Enter",
-    "Tab",
-    "ArrowDown",
-    "ArrowLeft",
-    "ArrowRight",
-    "ArrowUp",
-    "End",
-    "Home",
-    "PageDown",
-    "PageUp",
-    "Backspace",
-    "Clear",
-    "Copy",
-    "CrSel",
-    "Cut",
-    "Delete",
-    "EraseEof",
-    "ExSel",
-    "Insert",
-    "Paste",
-    "Redo",
-    "Undo",
-    "Accept",
-    "Again",
-    "Attn",
-    "Cancel",
-    "ContextMenu",
-    "Escape",
-    "Execute",
-    "Find",
-    "Finish",
-    "Help",
-    "Pause",
-    "Play",
-    "Props",
-    "Select",
-    "ZoomIn",
-    "ZoomOut",
-    "BrightnessDown",
-    "BrightnessUp",
-    "Eject",
-    "LogOff",
-    "Power",
-    "PowerOff",
-    "PrintScreen",
-    "Hibernate",
-    "Standby",
-    "WakeUp",
-    "AllCandidates",
-    "Alphanumeric",
-    "CodeInput",
-    "Compose",
-    "Convert",
-    "Dead",
-    "FinalMode",
-    "GroupFirst",
-    "GroupLast",
-    "GroupNext",
-    "GroupPrevious",
-    "ModeChange",
-    "NextCandidate",
-    "NonConvert",
-    "PreviousCandidate",
-    "Process",
-    "SingleCandidate",
-    "HangulMode",
-    "HanjaMode",
-    "JunjaMode",
-    "Eisu",
-    "Hankaku",
-    "Hiragana",
-    "HiraganaKatakana",
-    "KanaMode",
-    "KanjiMode",
-    "Katakana",
-    "Romaji",
-    "Zenkaku",
-    "ZenkakuHanaku",
-    "F1",
-    "F2",
-    "F3",
-    "F4",
-    "F5",
-    "F6",
-    "F7",
-    "F8",
-    "F9",
-    "F10",
-    "F11",
-    "F12",
-    "Soft1",
-    "Soft2",
-    "Soft3",
-    "Soft4",
-    "ChannelDown",
-    "ChannelUp",
-    "Close",
-    "MailForward",
-    "MailReply",
-    "MailSend",
-    "MediaFastForward",
-    "MediaPause",
-    "MediaPlay",
-    "MediaPlayPause",
-    "MediaRecord",
-    "MediaRewind",
-    "MediaStop",
-    "MediaTrackNext",
-    "MediaTrackPrevious",
-    "AudioBalanceLeft",
-    "AudioBalanceRight",
-    "AudioBassBoostDown",
-    "AudioBassBoostToggle",
-    "AudioBassBoostUp",
-    "AudioFaderFront",
-    "AudioFaderRear",
-    "AudioSurroundModeNext",
-    "AudioTrebleDown",
-    "AudioTrebleUp",
-    "AudioVolumeDown",
-    "AudioVolumeMute",
-    "AudioVolumeUp",
-    "MicrophoneToggle",
-    "MicrophoneVolumeDown",
-    "MicrophoneVolumeMute",
-    "MicrophoneVolumeUp",
-    "TV",
-    "TV3DMode",
-    "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