@seleniumhq/side-runtime 4.0.0-alpha.9 → 4.0.2

package/dist/webdriver.js

@@ -23,20 +23,15 @@ const selenium_webdriver_1 = __importDefault(require("selenium-webdriver"));
 const utils_1 = require("./utils");
 const preprocessors_1 = require("./preprocessors");
 const errors_1 = require("./errors");
-const { By, Condition, until, Key, WebElement, WebElementCondition, WebElementPromise, } = selenium_webdriver_1.default;
-const { TimeoutError } = selenium_webdriver_1.default.error;
-const POLL_TIMEOUT = 50;
+const util_1 = require("util");
+const { version: SeleniumWebdriverVersion, } = require('selenium-webdriver/package.json');
+const { By, Condition, until, Key, WebElementCondition } = selenium_webdriver_1.default;
 const DEFAULT_CAPABILITIES = {
     browserName: 'chrome',
 };
 const state = Symbol('state');
-const defaultWindowAPI = {
-    setWindowSize: async (executor, width, height) => {
-        await executor.driver.manage().window().setRect({ width, height });
-    },
-};
 class WebDriverExecutor {
-    constructor({ customCommands = {}, disableCodeExportCompat = false, driver, capabilities, server, hooks = {}, implicitWait, windowAPI = defaultWindowAPI, }) {
+    constructor({ customCommands = {}, disableCodeExportCompat = false, driver, capabilities, server, hooks = {}, implicitWait, }) {
         if (driver) {
             this.driver = driver;
         }
@@ -50,23 +45,76 @@ class WebDriverExecutor {
         this.hooks = hooks;
         this.waitForNewWindow = this.waitForNewWindow.bind(this);
         this.customCommands = customCommands;
-        this.windowAPI = windowAPI;
     }
-    async init({ baseUrl, logger, variables }) {
+    getDriverSync({ debug, logger, }) {
+        const { browserName, ...capabilities } = this
+            .capabilities;
+        if (debug) {
+            logger.info('Building driver for ' + browserName);
+            logger.info('Driver attributes:' +
+                (0, util_1.inspect)({
+                    capabilities,
+                    server: this.server,
+                    browserName,
+                }));
+        }
+        let builder = new selenium_webdriver_1.default.Builder().withCapabilities(capabilities);
+        if (this.server) {
+            builder = builder.usingServer(this.server);
+        }
+        return builder.forBrowser(browserName).build();
+    }
+    async getDriver({ debug, logger, }) {
+        const { browserName, ...capabilities } = this
+            .capabilities;
+        try {
+            const driver = await this.getDriverSync({ debug, logger });
+            debug && logger.info('Driver has been built for ' + browserName);
+            return driver;
+        }
+        catch (e) {
+            if (debug) {
+                const driverCode = 'const driver = new webdriver.Builder()' +
+                    `.withCapabilities(${JSON.stringify(capabilities)})` +
+                    (this.server ? `.usingServer('${this.server}')` : '') +
+                    `.forBrowser('${browserName}').build()`;
+                console.error(`
+          Failed to build driver for ${browserName}
+          Supplied capabilities: ${JSON.stringify(capabilities)}
+          Server: ${this.server || 'none'}
+          Error: ${e}
+
+          OS: ${process.platform}
+          Node: ${process.version}
+          Selenium-Webdriver: ${SeleniumWebdriverVersion}
+
+          This is breaking at the boundary of the following code in selenium-webdriver:
+
+          // BEGIN SELENIUM-WEBDRIVER CODE
+          const webdriver = require('selenium-webdriver')
+          ${driverCode}
+          // END SELENIUM-WEBDRIVER CODE
+
+          To ensure the bug is in selenium IDE, please attempt to run the above code in a script or node REPL.
+          You may have to npm install selenium-webdriver first.
+
+          If you are unable to proceed further, please raise a bug here:
+          https://github.com/SeleniumHQ/selenium/issues/new?assignees=&labels=I-defect%2Cneeds-triaging&projects=&template=bug-report.yml&title=%5B%F0%9F%90%9B+Bug%5D%3A+
+
+          If this code works in selenium-webdriver, but not the IDE or side-runner, please raise a bug here:
+          https://github.com/SeleniumHQ/selenium-ide/issues/new?assignees=&labels=&projects=&template=bug.md
+        `);
+            }
+            throw e;
+        }
+    }
+    async init({ baseUrl, debug, logger, variables, }) {
         this.baseUrl = baseUrl;
         this.logger = logger;
         this.variables = variables;
         this[state] = {};
         if (!this.driver) {
-            const { browserName, ...capabilities } = this
-                .capabilities;
-            this.logger.info('Building driver for ' + browserName);
-            this.driver = await new selenium_webdriver_1.default.Builder()
-                .withCapabilities(capabilities)
-                .usingServer(this.server)
-                .forBrowser(browserName)
-                .build();
-            this.logger.info('Driver has been built for ' + browserName);
+            this.driver = await this.getDriver({ debug, logger });
         }
         this.initialized = true;
     }
@@ -75,9 +123,15 @@ class WebDriverExecutor {
             await this.cancellable.cancel();
         }
     }
-    async cleanup() {
-        if (this.initialized) {
-            await this.driver.quit();
+    async cleanup(persistSession = false) {
+        // await this.cancel()
+        if (this.driver) {
+            if (persistSession) {
+                await this.driver.close();
+            }
+            else {
+                await this.driver.quit();
+            }
             // @ts-expect-error
             this.driver = undefined;
             this.initialized = false;
@@ -92,18 +146,25 @@ class WebDriverExecutor {
         if (!command) {
             return 'skip';
         }
-        const upperCase = command.charAt(0).toUpperCase() + command.slice(1);
-        const func = 'do' + upperCase;
+        if (this.customCommands[command]) {
+            return command;
+        }
+        const func = this.nameTransform(command);
         // @ts-expect-error The functions can be overridden by custom commands and stuff
         if (!this[func]) {
             throw new Error(`Unknown command ${command}`);
         }
         return func;
     }
+    nameTransform(command) {
+        const upperCase = command.charAt(0).toUpperCase() + command.slice(1);
+        return 'do' + upperCase;
+    }
     async executeHook(hook, ...args) {
         const fn = this.hooks[hook];
         if (!fn)
             return;
+        // @ts-expect-error it's okay, this shape is fine
         await fn.apply(this, args);
     }
     async beforeCommand(commandObject) {
@@ -115,7 +176,7 @@ class WebDriverExecutor {
     async afterCommand(commandObject) {
         this.cancellable = undefined;
         if (commandObject.opensWindow) {
-            const handle = await this.wait(this.waitForNewWindow(), commandObject.windowTimeout);
+            const handle = await this.waitForNewWindow(commandObject.windowTimeout);
             this.variables.set(commandObject.windowHandleName, handle);
             await this.executeHook('onWindowAppeared', {
                 command: commandObject,
@@ -125,9 +186,26 @@ class WebDriverExecutor {
         }
         await this.executeHook('onAfterCommand', { command: commandObject });
     }
-    async waitForNewWindow() {
-        const currentHandles = await this.driver.getAllWindowHandles();
-        return currentHandles.find((handle) => !this[state].openedWindows.includes(handle));
+    async waitForNewWindow(timeout = 2000) {
+        const finder = new Promise((resolve) => {
+            const start = Date.now();
+            const findHandle = this.withCancel(async () => {
+                if (Date.now() - start > timeout) {
+                    resolve(undefined);
+                    return;
+                }
+                const currentHandles = await this.driver.getAllWindowHandles();
+                const newHandle = currentHandles.find((handle) => !this[state].openedWindows.includes(handle));
+                if (newHandle) {
+                    resolve(newHandle);
+                    return;
+                }
+                // cant find, wait next time.
+                setTimeout(findHandle, 200);
+            });
+            findHandle();
+        });
+        return this.driver.wait(finder, timeout);
     }
     registerCommand(commandName, fn) {
         // @ts-expect-error
@@ -143,7 +221,7 @@ class WebDriverExecutor {
     }
     async doSetWindowSize(widthXheight) {
         const [width, height] = widthXheight.split('x').map((v) => parseInt(v));
-        await this.windowAPI.setWindowSize(this, width, height);
+        await this.driver.manage().window().setRect({ width, height });
     }
     async doSelectWindow(handleLocator) {
         const prefix = 'handle=';
@@ -206,12 +284,9 @@ class WebDriverExecutor {
             await targetLocator.frame(element);
         }
     }
-    async doSubmit() {
-        throw new Error('"submit" is not a supported command in Selenium WebDriver. Please re-record the step.');
-    }
     // mouse commands
     async doAddSelection(locator, optionLocator, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const option = await element.findElement(parseOptionLocator(optionLocator));
         const selections = (await this.driver.executeScript('return arguments[0].selectedOptions', element));
         if (!(await findElement(selections, option))) {
@@ -219,7 +294,7 @@ class WebDriverExecutor {
         }
     }
     async doRemoveSelection(locator, optionLocator, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         if (!(await element.getAttribute('multiple'))) {
             throw new Error('Given element is not a multiple select type element');
         }
@@ -230,37 +305,38 @@ class WebDriverExecutor {
         }
     }
     async doCheck(locator, _, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         if (!(await element.isSelected())) {
             await element.click();
         }
     }
     async doUncheck(locator, _, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         if (await element.isSelected()) {
             await element.click();
         }
     }
-    async doClick(locator, _) {
-        const element = await this.waitForElementVisible(locator, this.implicitWait);
+    async doClick(locator, _, commandObject = {}) {
+        const element = await this.waitForElementVisible(locator, this.implicitWait, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await element.click();
     }
     async doClickAt(locator, coordString, commandObject = {}) {
         const coords = parseCoordString(coordString);
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await this.driver
             .actions({ bridge: true })
             .move({ origin: element, ...coords })
             .click()
             .perform();
     }
-    async doDoubleClick(locator, _, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+    async doDoubleClick(locator, _, _commandObject) {
+        const commandObject = _commandObject || {};
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await this.driver.actions({ bridge: true }).doubleClick(element).perform();
     }
     async doDoubleClickAt(locator, coordString, commandObject = {}) {
         const coords = parseCoordString(coordString);
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await this.driver
             .actions({ bridge: true })
             .move({ origin: element, ...coords })
@@ -275,8 +351,9 @@ class WebDriverExecutor {
             .dragAndDrop(drag, drop)
             .perform();
     }
-    async doMouseDown(locator, _, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+    async doMouseDown(locator, _, _commandObject) {
+        const commandObject = _commandObject || {};
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await this.driver
             .actions({ bridge: true })
             .move({ origin: element })
@@ -285,7 +362,7 @@ class WebDriverExecutor {
     }
     async doMouseDownAt(locator, coordString, commandObject = {}) {
         const coords = parseCoordString(coordString);
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await this.driver
             .actions({ bridge: true })
             .move({ origin: element, ...coords })
@@ -294,18 +371,19 @@ class WebDriverExecutor {
     }
     async doMouseMoveAt(locator, coordString, commandObject = {}) {
         const coords = parseCoordString(coordString);
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await this.driver
             .actions({ bridge: true })
             .move({ origin: element, ...coords })
             .perform();
     }
-    async doMouseOut(locator, _, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+    async doMouseOut(locator, _, _commandObject) {
+        const commandObject = _commandObject || {};
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const [rect, vp] = await this.driver.executeScript('return [arguments[0].getBoundingClientRect(), {height: window.innerHeight, width: window.innerWidth}];', element);
         // try top
         if (rect.top > 0) {
-            const y = -(rect.height / 2 + 1);
+            const y = Math.round(-(rect.height / 2 + 1));
             return await this.driver
                 .actions({ bridge: true })
                 .move({ origin: element, y })
@@ -313,7 +391,7 @@ class WebDriverExecutor {
         }
         // try right
         else if (vp.width > rect.right) {
-            const x = rect.right / 2 + 1;
+            const x = Math.round(rect.right / 2 + 1);
             return await this.driver
                 .actions({ bridge: true })
                 .move({ origin: element, x })
@@ -321,7 +399,7 @@ class WebDriverExecutor {
         }
         // try bottom
         else if (vp.height > rect.bottom) {
-            const y = rect.height / 2 + 1;
+            const y = Math.round(rect.height / 2 + 1);
             return await this.driver
                 .actions({ bridge: true })
                 .move({ origin: element, y })
@@ -329,7 +407,7 @@ class WebDriverExecutor {
         }
         // try left
         else if (rect.left > 0) {
-            const x = -rect.right / 2;
+            const x = Math.round(-rect.right / 2);
             return await this.driver
                 .actions({ bridge: true })
                 .move({ origin: element, x })
@@ -337,15 +415,17 @@ class WebDriverExecutor {
         }
         throw new Error('Unable to perform mouse out as the element takes up the entire viewport');
     }
-    async doMouseOver(locator, _, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+    async doMouseOver(locator, _, _commandObject) {
+        const commandObject = _commandObject || {};
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await this.driver
             .actions({ bridge: true })
             .move({ origin: element })
             .perform();
     }
-    async doMouseUp(locator, _, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+    async doMouseUp(locator, _, _commandObject) {
+        const commandObject = _commandObject || {};
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await this.driver
             .actions({ bridge: true })
             .move({ origin: element })
@@ -354,7 +434,7 @@ class WebDriverExecutor {
     }
     async doMouseUpAt(locator, coordString, commandObject = {}) {
         const coords = parseCoordString(coordString);
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await this.driver
             .actions({ bridge: true })
             .move({ origin: element, ...coords })
@@ -362,53 +442,86 @@ class WebDriverExecutor {
             .perform();
     }
     async doSelect(locator, optionLocator, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const option = await element.findElement(parseOptionLocator(optionLocator));
         await option.click();
     }
+    async doSubmit(locator, _, _commandObject) {
+        const commandObject = _commandObject || {};
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
+        console.error(`
+      "submit" is not a good command in Selenium WebDriver. It's not supported by 
+      all browsers and it's manually triggering an event, when it should really
+      be driven out of an interaction (click submit, hit enter, etc).
+      Please re-record the step using a "click" or "sendKeys" command instead.
+    `);
+        await element.submit();
+    }
     // keyboard commands
     async doEditContent(locator, value, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await this.driver.executeScript("if(arguments[0].contentEditable === 'true') {arguments[0].innerText = arguments[1]} else {throw new Error('Element is not content editable')}", element, value);
     }
     async doType(locator, value, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await element.clear();
         await element.sendKeys(value);
     }
     async doSendKeys(locator, value, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         await element.sendKeys(...value);
     }
     // wait commands
     async doWaitForElementEditable(locator, timeout) {
-        const element = await this.driver.findElement(parseLocator(locator));
-        await this.wait(this.isElementEditable(element), parseInt(timeout), 'Timed out waiting for element to be editable');
+        const condition = new Condition('for element to be editable', async () => {
+            const element = await this.driver.findElement(parseLocator(locator));
+            if (!element) {
+                return null;
+            }
+            const isEditable = await this.isElementEditable(element);
+            return isEditable;
+        });
+        await this.driver.wait(condition, parseInt(timeout));
     }
     async doWaitForElementNotEditable(locator, timeout) {
-        const element = await this.driver.findElement(parseLocator(locator));
-        await this.wait(this.isElementEditable(element), parseInt(timeout), 'Timed out waiting for element to not be editable');
+        const condition = new Condition('for element to be editable', async () => {
+            const element = await this.driver.findElement(parseLocator(locator));
+            if (!element) {
+                return null;
+            }
+            const isEditable = await this.isElementEditable(element);
+            return !isEditable;
+        });
+        await this.driver.wait(condition, parseInt(timeout));
     }
-    async doWaitForElementPresent(locator, timeout) {
-        await this.wait(until.elementLocated(parseLocator(locator)), parseInt(timeout));
+    async doWaitForElementPresent(locator, timeout, commandObj = {}) {
+        const locatorCondition = new WebElementCondition('for element to be present', async () => await this.elementIsLocated(locator, commandObj.targetFallback, commandObj.targets, commandObj.fallbackTargets));
+        await this.driver.wait(locatorCondition, Number(timeout));
     }
     async doWaitForElementNotPresent(locator, timeout) {
         const parsedLocator = parseLocator(locator);
         const elements = await this.driver.findElements(parsedLocator);
         if (elements.length !== 0) {
-            await this.wait(until.stalenessOf(elements[0]), parseInt(timeout));
+            const noElementPresentCondition = new Condition('for element to not be present', async () => {
+                const elements = await this.driver.findElements(parsedLocator);
+                return elements.length === 0;
+            });
+            await this.driver.wait(noElementPresentCondition, Number(timeout));
         }
     }
-    async doWaitForElementVisible(locator, timeout) {
-        await this.waitForElementVisible(locator, parseInt(timeout));
+    async doWaitForElementVisible(locator, timeout, commandObj = {}) {
+        await this.waitForElementVisible(locator, parseInt(timeout), commandObj.targetFallback);
     }
     async doWaitForElementNotVisible(locator, timeout) {
         const parsedLocator = parseLocator(locator);
         const elements = await this.driver.findElements(parsedLocator);
         if (elements.length > 0) {
-            await this.wait(until.elementIsNotVisible(elements[0]), parseInt(timeout));
+            await this.driver.wait(until.elementIsNotVisible(elements[0]), parseInt(timeout));
         }
     }
+    async doWaitForText(locator, text, commandObj = {}) {
+        await this.waitForText(locator, text, commandObj.targetFallback);
+    }
     // script commands
     async doRunScript(script) {
         await this.driver.executeScript(script.script, ...script.argv);
@@ -467,7 +580,7 @@ class WebDriverExecutor {
         return Promise.resolve();
     }
     async doStoreText(locator, variable, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const text = await element.getText();
         this.variables.set(variable, text);
     }
@@ -476,7 +589,7 @@ class WebDriverExecutor {
         this.variables.set(variable, title);
     }
     async doStoreValue(locator, variable, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const value = await element.getAttribute('value');
         this.variables.set(variable, value);
     }
@@ -517,14 +630,16 @@ class WebDriverExecutor {
                 "'");
         }
     }
-    async doAssertEditable(locator, _, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+    async doAssertEditable(locator, _, _commandObject) {
+        const commandObject = _commandObject || {};
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         if (!(await this.isElementEditable(element))) {
             throw new errors_1.AssertionError('Element is not editable');
         }
     }
-    async doAssertNotEditable(locator, _, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+    async doAssertNotEditable(locator, _, _commandObject) {
+        const commandObject = _commandObject || {};
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         if (await this.isElementEditable(element)) {
             throw new errors_1.AssertionError('Element is editable');
         }
@@ -556,21 +671,21 @@ class WebDriverExecutor {
         }
     }
     async doAssertText(locator, value, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const text = await element.getText();
         if (text !== value) {
             throw new errors_1.AssertionError("Actual value '" + text + "' did not match '" + value + "'");
         }
     }
     async doAssertNotText(locator, value, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const text = await element.getText();
         if (text === value) {
             throw new errors_1.AssertionError("Actual value '" + text + "' did match '" + value + "'");
         }
     }
     async doAssertValue(locator, value, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const elementValue = await element.getAttribute('value');
         if (elementValue !== value) {
             throw new errors_1.AssertionError("Actual value '" + elementValue + "' did not match '" + value + "'");
@@ -578,40 +693,40 @@ class WebDriverExecutor {
     }
     // not generally implemented
     async doAssertNotValue(locator, value, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const elementValue = await element.getAttribute('value');
         if (elementValue === value) {
             throw new errors_1.AssertionError("Actual value '" + elementValue + "' did match '" + value + "'");
         }
     }
     async doAssertChecked(locator, _, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         if (!(await element.isSelected())) {
             throw new errors_1.AssertionError('Element is not checked, expected to be checked');
         }
     }
     async doAssertNotChecked(locator, _, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         if (await element.isSelected()) {
             throw new errors_1.AssertionError('Element is checked, expected to be unchecked');
         }
     }
     async doAssertSelectedValue(locator, value, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const elementValue = await element.getAttribute('value');
         if (elementValue !== value) {
             throw new errors_1.AssertionError("Actual value '" + elementValue + "' did not match '" + value + "'");
         }
     }
     async doAssertNotSelectedValue(locator, value, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const elementValue = await element.getAttribute('value');
         if (elementValue === value) {
             throw new errors_1.AssertionError("Actual value '" + elementValue + "' did match '" + value + "'");
         }
     }
     async doAssertSelectedLabel(locator, label, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const selectedValue = await element.getAttribute('value');
         const selectedOption = await element.findElement(By.xpath(`option[@value="${selectedValue}"]`));
         const selectedOptionLabel = await selectedOption.getText();
@@ -624,7 +739,7 @@ class WebDriverExecutor {
         }
     }
     async doAssertNotSelectedLabel(locator, label, commandObject = {}) {
-        const element = await this.waitForElement(locator, commandObject?.targetFallback);
+        const element = await this.waitForElement(locator, commandObject.targetFallback, commandObject.targets, commandObject.fallbackTargets);
         const selectedValue = await element.getAttribute('value');
         const selectedOption = await element.findElement(By.xpath(`option[@value="${selectedValue}"]`));
         const selectedOptionLabel = await selectedOption.getText();
@@ -651,154 +766,82 @@ class WebDriverExecutor {
         throw new Error('`set speed` is not supported in this run mode');
     }
     async evaluateConditional(script) {
-        const result = await this.driver.executeScript(`return (${script.script})`, ...script.argv);
+        const result = await this.driver.executeScript((0, preprocessors_1.interpolateScript)(`return (${script.script})`, this.variables).script, ...script.argv);
         return {
             value: !!result,
         };
     }
-    async waitForElement(locator, fallback = []) {
+    async elementIsLocated(locator, ..._fallbacks) {
         const elementLocator = parseLocator(locator);
-        try {
-            return (await this.wait(until.elementLocated(elementLocator), this.implicitWait));
-        }
-        catch (err) {
-            if (fallback) {
-                for (let i = 0; i < fallback.length; i++) {
-                    try {
-                        let loc = parseLocator(fallback[i][0]);
-                        return await this.driver.findElement(loc);
-                    }
-                    catch (e) {
-                        // try the next one
-                    }
-                }
-            }
-            throw err;
+        const matches = await this.driver.findElements(elementLocator);
+        if (matches.length > 0)
+            return matches[0];
+        const fallbacks = _fallbacks.filter(Boolean).flat();
+        for (let i = 0; i < fallbacks.length; i++) {
+            const loc = parseLocator(fallbacks[i][0]);
+            const fallbackMatches = await this.driver.findElements(loc);
+            if (fallbackMatches.length)
+                return fallbackMatches[0];
         }
+        return null;
+    }
+    withCancel(poller) {
+        let resolveCancel;
+        const cancelPromise = new Promise((res) => {
+            resolveCancel = res;
+        });
+        let cancelled = false;
+        this.cancellable = {
+            cancel: () => {
+                cancelled = true;
+                return cancelPromise;
+            },
+        };
+        return async () => {
+            if (cancelled) {
+                resolveCancel();
+                throw new Error('aborted');
+            }
+            return await poller();
+        };
+    }
+    async waitForElement(locator, ...fallbacks) {
+        const locatorCondition = new WebElementCondition('for element to be located', this.withCancel(async () => await this.elementIsLocated(locator, ...fallbacks)));
+        return await this.driver.wait(locatorCondition, this.implicitWait);
     }
     async isElementEditable(element) {
         const { enabled, readonly } = await this.driver.executeScript('return { enabled: !arguments[0].disabled, readonly: arguments[0].readOnly };', element);
         return enabled && !readonly;
     }
-    async retryToAllowForIntermittency(locator, timeout) {
-        const startTime = Date.now();
-        const element = (await this.wait(until.elementLocated(parseLocator(locator)), timeout));
-        const elapsed = Date.now() - startTime;
-        await this.wait(until.elementIsVisible(element), timeout - elapsed);
-        return element;
-    }
-    async waitForElementVisible(locator, timeout) {
-        const startTime = Date.now();
-        const element = (await this.wait(until.elementLocated(parseLocator(locator)), timeout));
-        const elapsed = Date.now() - startTime;
-        await this.wait(until.elementIsVisible(element), timeout - elapsed);
-        return element;
-    }
-    async wait(condition, timeout = 0, message = '', pollTimeout = POLL_TIMEOUT) {
-        if (typeof timeout !== 'number' || timeout < 0) {
-            throw TypeError('timeout must be a number >= 0: ' + timeout);
-        }
-        if (typeof pollTimeout !== 'number' || pollTimeout < 0) {
-            throw TypeError('pollTimeout must be a number >= 0: ' + pollTimeout);
-        }
-        if (isConditionPromiseLike(condition)) {
-            return new Promise((resolve, reject) => {
-                if (!timeout) {
-                    resolve(condition);
-                    return;
-                }
-                let start = Date.now();
-                let timer = setTimeout(function () {
-                    timer = null;
-                    reject(new TimeoutError((message ? `${message}\n` : '') +
-                        'Timed out waiting for promise to resolve after ' +
-                        (Date.now() - start) +
-                        'ms'));
-                }, timeout);
-                const clearTimer = () => timer && clearTimeout(timer);
-                condition.then(function (value) {
-                    clearTimer();
-                    resolve(value);
-                }, function (error) {
-                    clearTimer();
-                    reject(error);
-                });
-            });
-        }
-        // @ts-expect-error
-        let fn = condition;
-        if (condition instanceof Condition) {
-            message = message || condition.description();
-            fn = condition.fn;
-        }
-        if (typeof fn !== 'function') {
-            throw TypeError('Wait condition must be a promise-like object, function, or a ' +
-                'Condition object');
-        }
-        const { driver } = this;
-        function evaluateCondition() {
-            return new Promise((resolve, reject) => {
-                try {
-                    resolve(fn(driver));
-                }
-                catch (ex) {
-                    reject(ex);
-                }
-            });
-        }
-        let result = new Promise((resolve, reject) => {
-            const startTime = Date.now();
-            let cancelled = false;
-            let resolveCancel;
-            const cancelPromise = new Promise((res) => {
-                resolveCancel = res;
-            });
-            this.cancellable = {
-                cancel: () => {
-                    cancelled = true;
-                    return cancelPromise;
-                },
-            };
-            const pollCondition = async () => {
-                evaluateCondition().then((value) => {
-                    const elapsed = Date.now() - startTime;
-                    if (cancelled) {
-                        resolveCancel();
-                        reject(new Error('Aborted by user'));
-                        this.cancellable = undefined;
-                    }
-                    else if (value) {
-                        resolve(value);
-                        this.cancellable = undefined;
-                    }
-                    else if (timeout && elapsed >= timeout) {
-                        reject(new TimeoutError((message ? `${message}\n` : '') +
-                            `Wait timed out after ${elapsed}ms`));
-                        this.cancellable = undefined;
-                    }
-                    else {
-                        setTimeout(pollCondition, pollTimeout);
-                    }
-                }, reject);
-            };
-            pollCondition();
-        });
-        if (condition instanceof WebElementCondition) {
-            result = new WebElementPromise(driver, result.then(function (value) {
-                if (!(value instanceof WebElement)) {
-                    throw TypeError('WebElementCondition did not resolve to a WebElement: ' +
-                        Object.prototype.toString.call(value));
-                }
-                return value;
-            }));
-        }
-        return result;
+    async waitForElementVisible(locator, timeout, ...fallbacks) {
+        const visibleCondition = new WebElementCondition('for element to be visible', this.withCancel(async () => {
+            const el = await this.elementIsLocated(locator, ...fallbacks);
+            if (!el)
+                return null;
+            try {
+                if (!(await el.isDisplayed()))
+                    return null;
+            }
+            catch (e) {
+                return null;
+            }
+            return el;
+        }));
+        return await this.driver.wait(visibleCondition, timeout);
+    }
+    async waitForText(locator, text, fallback = []) {
+        const timeout = this.implicitWait;
+        const textCondition = new Condition('for text to be present in element', this.withCancel(async () => {
+            const el = await this.elementIsLocated(locator, fallback);
+            if (!el)
+                return null;
+            const elText = (await el.getText()).replace(/\u00A0/g, ' ').trim();
+            return elText === text.replace(/\u00A0/g, ' ').trim();
+        }));
+        await this.driver.wait(textCondition, timeout);
     }
 }
 exports.default = WebDriverExecutor;
-function isConditionPromiseLike(condition) {
-    return condition && typeof condition.then === 'function';
-}
 WebDriverExecutor.prototype.doOpen = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, WebDriverExecutor.prototype.doOpen);
 WebDriverExecutor.prototype.doSetWindowSize = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, WebDriverExecutor.prototype.doSetWindowSize);
 WebDriverExecutor.prototype.doSelectWindow = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, WebDriverExecutor.prototype.doSelectWindow);
@@ -865,10 +908,28 @@ WebDriverExecutor.prototype.doAssert = (0, preprocessors_1.composePreprocessors)
 WebDriverExecutor.prototype.doAssertAlert = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, null, WebDriverExecutor.prototype.doAssertAlert);
 WebDriverExecutor.prototype.doAssertConfirmation = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, null, WebDriverExecutor.prototype.doAssertConfirmation);
 WebDriverExecutor.prototype.doAssertEditable = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, null, { targetFallback: (0, preprocessors_1.preprocessArray)(preprocessors_1.interpolateString) }, WebDriverExecutor.prototype.doAssertEditable);
+WebDriverExecutor.prototype.doAssertElementPresent = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, null, WebDriverExecutor.prototype.doAssertElementPresent);
+WebDriverExecutor.prototype.doAssertElementNotPresent = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, null, WebDriverExecutor.prototype.doAssertElementNotPresent);
 WebDriverExecutor.prototype.doAssertNotEditable = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, null, { targetFallback: (0, preprocessors_1.preprocessArray)(preprocessors_1.interpolateString) }, WebDriverExecutor.prototype.doAssertNotEditable);
 WebDriverExecutor.prototype.doAssertPrompt = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, null, WebDriverExecutor.prototype.doAssertPrompt);
+WebDriverExecutor.prototype.doAssertSelectedLabel = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, preprocessors_1.interpolateString, { targetFallback: (0, preprocessors_1.preprocessArray)(preprocessors_1.interpolateString) }, WebDriverExecutor.prototype.doAssertSelectedLabel);
 WebDriverExecutor.prototype.doAssertText = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, preprocessors_1.interpolateString, WebDriverExecutor.prototype.doAssertText);
+WebDriverExecutor.prototype.doAssertTitle = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, null, WebDriverExecutor.prototype.doAssertTitle);
+WebDriverExecutor.prototype.doAssertValue = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, preprocessors_1.interpolateString, { targetFallback: (0, preprocessors_1.preprocessArray)(preprocessors_1.interpolateString) }, WebDriverExecutor.prototype.doAssertValue);
 WebDriverExecutor.prototype.doEcho = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, WebDriverExecutor.prototype.doEcho);
+const waitCommands = [
+    'doWaitForElementEditable',
+    'doWaitForElementNotEditable',
+    'doWaitForElementPresent',
+    'doWaitForElementNotPresent',
+    'doWaitForElementVisible',
+    'doWaitForElementNotVisible',
+    'doWaitForText',
+];
+waitCommands.forEach((cmd) => {
+    // @ts-expect-error - Whatever who cares
+    WebDriverExecutor.prototype[cmd] = (0, preprocessors_1.composePreprocessors)(preprocessors_1.interpolateString, preprocessors_1.interpolateString, WebDriverExecutor.prototype[cmd]);
+});
 function createVerifyCommands(Executor) {
     // @ts-expect-error
     Object.getOwnPropertyNames(Executor.prototype)