@redhat-developer/page-objects 1.21.0 → 1.22.0

package/out/components/editor/EditorView.js

@@ -25,6 +25,7 @@ const DiffEditor_1 = require("./DiffEditor");
 const EditorAction_1 = require("./EditorAction");
 const SettingsEditor_1 = require("./SettingsEditor");
 const WebView_1 = require("./WebView");
+const ModalDialog_1 = require("../dialog/ModalDialog");
 class EditorTabNotFound extends Error {
     constructor(title, group) {
         super(`No editor with title '${title}' in group '${group}' available`);
@@ -68,7 +69,8 @@ class EditorView extends AbstractElement_1.AbstractElement {
         if (groupIndex !== undefined) {
             return groups[groupIndex].closeAllEditors();
         }
-        while (groups.length > 0 && (await groups[0].getOpenEditorTitles()).length > 0) {
+        const deadline = Date.now() + 60000;
+        while (groups.length > 0 && (await groups[0].getOpenEditorTitles()).length > 0 && Date.now() < deadline) {
             await groups[0].closeAllEditors();
             // Brief wait for DOM to settle after closing editors
             await this.getWaitHelper().sleep(500);
@@ -250,15 +252,39 @@ class EditorGroup extends AbstractElement_1.AbstractElement {
     async closeEditor(title) {
         const tab = await this.getTabByTitle(title);
         const closeButton = await tab.findElement(EditorView.locators.EditorView.closeTab);
-        await closeButton.click();
+        // VS Code renders hover tooltip overlays (<div class="hover-contents">) that can
+        // intercept the click (ElementClickInterceptedError) on CI. Retry with an
+        // increasing delay; fall back to a JS-executor click on the last attempt which
+        // bypasses overlay elements entirely.
+        const maxAttempts = 3;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                await closeButton.click();
+                return;
+            }
+            catch (err) {
+                if (err.name !== 'ElementClickInterceptedError' || attempt === maxAttempts - 1) {
+                    // On the final attempt use executeScript to bypass the overlay, then return.
+                    if (err.name === 'ElementClickInterceptedError') {
+                        await this.getDriver().executeScript('arguments[0].click()', closeButton);
+                        return;
+                    }
+                    throw err;
+                }
+                // Brief back-off so the tooltip has time to dismiss before the next attempt.
+                await this.getWaitHelper().sleep(300 * (attempt + 1));
+            }
+        }
     }
     /**
      * Close all open editor tabs
      * @returns Promise resolving once all tabs have had their close button pressed
      */
     async closeAllEditors() {
+        const deadline = Date.now() + 30000;
         let titles = await this.getOpenEditorTitles();
-        while (titles.length > 0) {
+        while (titles.length > 0 && Date.now() < deadline) {
+            const previousCount = titles.length;
             await this.closeEditor(titles[0]);
             try {
                 // check if the group still exists
@@ -268,6 +294,50 @@ class EditorGroup extends AbstractElement_1.AbstractElement {
                 break;
             }
             titles = await this.getOpenEditorTitles();
+            if (titles.length >= previousCount) {
+                // The tab did not close: a dirty editor raises a "save changes?" modal
+                // that blocks the close. Discard the changes so the editor actually
+                // closes — otherwise the modal is left intercepting every subsequent
+                // click and cascades the rest of the suite into failure. Fall back to
+                // Escape (which cancels the modal) if the dialog cannot be handled.
+                if (!(await this.discardDirtyEditorDialog())) {
+                    try {
+                        await this.getDriver().actions().sendKeys(selenium_webdriver_1.Key.ESCAPE).perform();
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+                await this.getWaitHelper().sleep(500);
+                titles = await this.getOpenEditorTitles();
+                if (titles.length >= previousCount) {
+                    break;
+                }
+            }
+        }
+    }
+    /**
+     * If a "save changes?" modal dialog is currently blocking the workbench,
+     * dismiss it by discarding the changes ("Don't Save") so the underlying
+     * dirty editor closes. Returns true when a dialog was found and handled.
+     */
+    async discardDirtyEditorDialog() {
+        const dialogs = await this.getDriver().findElements(EditorView.locators.Dialog.constructor);
+        if (dialogs.length === 0) {
+            return false;
+        }
+        try {
+            const dialog = new ModalDialog_1.ModalDialog();
+            await dialog.pushButton(`Don't Save`);
+            await this.getDriver()
+                .wait(selenium_webdriver_1.until.stalenessOf(dialogs[0]), 5000)
+                .catch(() => {
+                /* dialog may already be gone */
+            });
+            return true;
+        }
+        catch {
+            return false;
         }
     }
     /**

package/out/components/editor/SettingsEditor.d.ts

@@ -49,6 +49,7 @@ export declare class SettingsEditor extends Editor {
      */
     findSettingByID(id: string): Promise<Setting>;
     private _getSettingItem;
+    private scanForSettingItem;
     /**
      * Switch between settings perspectives
      * Works only if your vscode instance has both user and workspace settings available

package/out/components/editor/SettingsEditor.js

@@ -82,7 +82,23 @@ class SettingsEditor extends Editor_1.Editor {
             const match = new RegExp(/\d+/).exec(text);
             return match ? Number.parseInt(match[0], 10) : 0;
         }, { timeout: 5000, stabilityInterval: 300, stableChecks: 2 });
+        // The count can stabilize before the search filter has been applied on slow
+        // machines — poll the rendered rows until the requested setting shows up
+        // instead of sampling them a single time.
+        const deadline = Date.now() + 10_000;
         let setting;
+        for (;;) {
+            const found = await this.scanForSettingItem(title, category);
+            if (found) {
+                return found;
+            }
+            if (Date.now() >= deadline) {
+                return setting;
+            }
+            await this.getWaitHelper().sleep(500);
+        }
+    }
+    async scanForSettingItem(title, category) {
         const items = await this.findElements(SettingsEditor.locators.SettingsEditor.itemRow);
         for (const item of items) {
             try {
@@ -105,7 +121,7 @@ class SettingsEditor extends Editor_1.Editor {
                 // do nothing
             }
         }
-        return setting;
+        return undefined;
     }
     /**
      * Switch between settings perspectives

package/out/components/editor/TextEditor.d.ts

@@ -221,8 +221,10 @@ export declare class TextEditor extends Editor {
      * Get the cursor's coordinates as an array of two numbers: `[line, column]`
      *
      * **Caution** line & column coordinates do not start at `0` but at `1`!
+     *
+     * @param timeout ms to wait for the status bar to show a valid position (default 5000)
      */
-    getCoordinates(): Promise<[number, number]>;
+    getCoordinates(timeout?: number): Promise<[number, number]>;
     private getTabSize;
     /**
      * Toggle breakpoint on a given line

package/out/components/editor/TextEditor.js

@@ -19,7 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FindWidget = exports.CodeLens = exports.TextEditor = exports.BreakpointError = void 0;
 const __1 = require("../..");
 const selenium_webdriver_1 = require("selenium-webdriver");
-const url_1 = require("url");
+const node_url_1 = require("node:url");
 const StatusBar_1 = require("../statusBar/StatusBar");
 const Editor_1 = require("./Editor");
 const ElementWithContextMenu_1 = require("../ElementWithContextMenu");
@@ -41,7 +41,7 @@ class TextEditor extends Editor_1.Editor {
     async isDirty() {
         const tab = await this.enclosingItem.findElement(TextEditor.locators.TextEditor.activeTab);
         const klass = (await tab.getAttribute('class'));
-        return klass.indexOf('dirty') >= 0;
+        return klass.includes('dirty');
     }
     /**
      * Saves the active editor
@@ -74,7 +74,7 @@ class TextEditor extends Editor_1.Editor {
      * @returns Promise resolving to editor's underlying file path
      */
     async getFilePath() {
-        return (0, url_1.fileURLToPath)(await this.getFileUri());
+        return (0, node_url_1.fileURLToPath)(await this.getFileUri());
     }
     /**
      * Open/Close the content assistant at the current position in the editor by sending the default
@@ -179,6 +179,13 @@ class TextEditor extends Editor_1.Editor {
      * @returns Promise resolving once the text is deleted
      */
     async clearText() {
+        // Dismiss any open menu or overlay first (e.g. context menu left open after
+        // formatDocument), then focus the editor container so the inputArea becomes
+        // interactable.  We press Escape via the driver (safe regardless of focus) and
+        // click the outer editor element — NOT the native-edit-context, which cannot
+        // receive a synthetic click when it is not the active focus target.
+        await this.getDriver().actions().sendKeys(selenium_webdriver_1.Key.ESCAPE).perform();
+        await this.enclosingItem.click();
         return this.withRecovery(async (self) => {
             const input = await self.findElement(TextEditor.locators.Editor.inputArea);
             await input.sendKeys(selenium_webdriver_1.Key.chord(TextEditor.ctlKey, 'a'));
@@ -341,12 +348,16 @@ class TextEditor extends Editor_1.Editor {
     async setCursor(line, column, timeout = 2_500) {
         const input = await new __1.Workbench().openCommandPrompt();
         await input.setText(`:${line},${column}`);
-        // Wait for input to be processed - check for quick picks appearing
-        await this.getWaitHelper().forCondition(async () => {
-            const picks = await input.getQuickPicks().catch(() => []);
-            return picks.length > 0;
-        }, { timeout: 1000, pollInterval: 50 });
-        await input.selectQuickPick(0);
+        try {
+            await this.getWaitHelper().forCondition(async () => {
+                const picks = await input.getQuickPicks().catch(() => []);
+                return picks.length > 0;
+            }, { timeout: 2000, pollInterval: 50 });
+            await input.selectQuickPick(0);
+        }
+        catch {
+            await input.confirm();
+        }
         await this.waitForCursorPositionAt(line, column, timeout);
     }
     /**
@@ -533,19 +544,9 @@ class TextEditor extends Editor_1.Editor {
     }
     async openContextMenu() {
         await this.getDriver().actions().contextClick(this).perform();
-        const shadowRootHost = await this.enclosingItem.findElements(TextEditor.locators.TextEditor.shadowRootHost);
-        if (shadowRootHost.length > 0) {
-            let shadowRoot;
-            const webdriverCapabilities = await this.getDriver().getCapabilities();
-            const chromiumVersion = webdriverCapabilities.getBrowserVersion();
-            if (chromiumVersion && parseInt(chromiumVersion.split('.')[0]) >= 96) {
-                shadowRoot = await shadowRootHost[0].getShadowRoot();
-                return new __1.ContextMenu(await shadowRoot.findElement(TextEditor.locators.TextEditor.monacoMenuContainer)).wait();
-            }
-            else {
-                shadowRoot = (await this.getDriver().executeScript('return arguments[0].shadowRoot', shadowRootHost[0]));
-                return new __1.ContextMenu(shadowRoot).wait();
-            }
+        const menu = await this.waitForShadowRootMenu();
+        if (menu) {
+            return menu;
         }
         return await super.openContextMenu();
     }
@@ -553,15 +554,30 @@ class TextEditor extends Editor_1.Editor {
      * Get the cursor's coordinates as an array of two numbers: `[line, column]`
      *
      * **Caution** line & column coordinates do not start at `0` but at `1`!
+     *
+     * @param timeout ms to wait for the status bar to show a valid position (default 5000)
      */
-    async getCoordinates() {
-        const coords = [];
+    async getCoordinates(timeout = 5_000) {
         const statusBar = new StatusBar_1.StatusBar();
-        const coordinates = (await statusBar.getCurrentPosition()).match(/\d+/g);
-        for (const c of coordinates) {
-            coords.push(+c);
-        }
-        return [coords[0], coords[1]];
+        // The status bar position item may not update immediately after a cursor move,
+        // especially on slow CI runners. Poll until it returns a valid "Ln X, Col Y" string.
+        let positionText = '';
+        await this.getDriver().wait(async () => {
+            try {
+                const text = await statusBar.getCurrentPosition();
+                const match = text.match(/\d+/g);
+                if (match && match.length >= 2) {
+                    positionText = text;
+                    return true;
+                }
+            }
+            catch {
+                // Status bar item not yet available — keep polling
+            }
+            return false;
+        }, timeout, `Status bar did not show a valid cursor position within ${timeout}ms`);
+        const coordinates = positionText.match(/\d+/g);
+        return [+coordinates[0], +coordinates[1]];
     }
     async getTabSize() {
         const statusBar = new StatusBar_1.StatusBar();
@@ -585,7 +601,7 @@ class TextEditor extends Editor_1.Editor {
             : lineOverlay;
         const breakPoint = await breakpointContainer.findElements(TextEditor.locators.TextEditor.breakpoint.generalSelector);
         if (breakPoint.length > 0) {
-            if (this.breakPoints.indexOf(line) !== -1) {
+            if (this.breakPoints.includes(line)) {
                 await breakPoint[this.breakPoints.indexOf(line)].click();
                 // Wait for breakpoint to be removed
                 await this.getWaitHelper().forCondition(async () => {
@@ -665,15 +681,23 @@ class TextEditor extends Editor_1.Editor {
     async getBreakpoints() {
         const breakpoints = [];
         const breakpointLocators = Breakpoint_1.Breakpoint.locators.TextEditor.breakpoint;
-        const breakpointContainer = (0, compare_versions_1.satisfies)(TextEditor.versionInfo.version, '>=1.80.0')
-            ? await this.findElement(TextEditor.locators.TextEditor.glyphMarginWidget)
-            : this;
+        const isNewVersion = (0, compare_versions_1.satisfies)(TextEditor.versionInfo.version, '>=1.80.0');
+        const breakpointContainer = isNewVersion ? await this.findElement(TextEditor.locators.TextEditor.glyphMarginWidget) : this;
         const breakpointsSelectors = await breakpointContainer.findElements(breakpointLocators.generalSelector);
+        // When a debug session is paused at a breakpoint, VS Code renders two overlapping
+        // elements with the `codicon-debug-breakpoint` class at the same vertical position
+        // (the regular breakpoint dot and the stackframe arrow). Deduplicate by `top` so
+        // that each line contributes at most one Breakpoint.
+        const seenTops = new Set();
         for (const breakpointSelector of breakpointsSelectors) {
             try {
                 let lineElement;
-                if ((0, compare_versions_1.satisfies)(TextEditor.versionInfo.version, '>=1.80.0')) {
+                if (isNewVersion) {
                     const styleTopAttr = await breakpointSelector.getCssValue('top');
+                    if (seenTops.has(styleTopAttr)) {
+                        continue;
+                    }
+                    seenTops.add(styleTopAttr);
                     lineElement = await this.findElement(TextEditor.locators.TextEditor.marginArea).findElement(TextEditor.locators.TextEditor.lineElement(styleTopAttr));
                 }
                 else {
@@ -696,14 +720,23 @@ class TextEditor extends Editor_1.Editor {
      */
     async getCodeLenses() {
         const lenses = [];
-        const widgets = await this.findElement(TextEditor.locators.TextEditor.contentWidgets);
-        const items = await widgets.findElements(TextEditor.locators.TextEditor.contentWidgetsElements);
+        // Use findElements so that a missing/not-yet-visible contentWidgets container
+        // returns an empty array rather than throwing a TimeoutError.  The caller
+        // (or the before-hook poll loop) is responsible for retrying until lenses appear.
+        const widgetContainers = await this.findElements(TextEditor.locators.TextEditor.contentWidgets);
+        if (widgetContainers.length === 0) {
+            return lenses;
+        }
+        const items = await widgetContainers[0].findElements(TextEditor.locators.TextEditor.contentWidgetsElements);
         for (const item of items) {
             try {
                 lenses.push(await new CodeLens(item, this).wait());
             }
             catch (e) {
-                if (e.name === 'StaleElementReferenceError') {
+                // Skip stale or not-yet-visible lens elements.  TimeoutError means the
+                // lens widget exists in the DOM but is not visible yet (e.g. the editor
+                // is still rendering); the caller's poll loop will retry the whole call.
+                if (e.name === 'StaleElementReferenceError' || e.name === 'TimeoutError') {
                     continue;
                 }
                 throw e;
@@ -779,19 +812,9 @@ class Selection extends ElementWithContextMenu_1.ElementWithContextMenu {
                 }
             }
         }
-        const shadowRootHost = await ed.getEnclosingElement().findElements(TextEditor.locators.TextEditor.shadowRootHost);
-        if (shadowRootHost.length > 0) {
-            let shadowRoot;
-            const webdriverCapabilities = await this.getDriver().getCapabilities();
-            const chromiumVersion = webdriverCapabilities.getBrowserVersion();
-            if (chromiumVersion && parseInt(chromiumVersion.split('.')[0]) >= 96) {
-                shadowRoot = await shadowRootHost[0].getShadowRoot();
-                return new __1.ContextMenu(await shadowRoot.findElement(TextEditor.locators.TextEditor.monacoMenuContainer)).wait();
-            }
-            else {
-                shadowRoot = (await this.getDriver().executeScript('return arguments[0].shadowRoot', shadowRootHost[0]));
-                return new __1.ContextMenu(shadowRoot).wait();
-            }
+        const menu = await this.waitForShadowRootMenu();
+        if (menu) {
+            return menu;
         }
         return await super.openContextMenu();
     }
@@ -973,8 +996,12 @@ class FindWidget extends AbstractElement_1.AbstractElement {
         }
         const btn = await element.findElement(FindWidget.locators.FindWidget.button(title));
         await btn.click();
-        // Wait for button action to complete
-        await this.getWaitHelper().forStable(element, { timeout: 500 });
+        // Give the widget a moment to settle after the action (animations, relayout).
+        // Best-effort: a slow animation must not fail the interaction that already
+        // happened, so a stability timeout is not an error here.
+        await this.getWaitHelper()
+            .forStable(element, { timeout: 2000 })
+            .catch(() => undefined);
     }
     async setText(text, composite) {
         const input = await composite.findElement(FindWidget.locators.FindWidget.input);

package/out/components/editor/WebView.js

@@ -29,7 +29,12 @@ const locators_1 = require("../../locators/locators");
 class WebViewBase extends Editor_1.Editor {
     async getViewToSwitchTo() {
         const frames = await this.getDriver().findElements(WebViewBase.locators.WebView.iframe);
-        return (0, locators_1.findBestContainingElement)(await this.getRect(), frames);
+        if (frames.length === 0) {
+            return undefined;
+        }
+        // Try geometry-based selection first; fall back to the first available frame
+        // when the editor container has not been laid out yet (common on slow CI runners).
+        return (await (0, locators_1.findBestContainingElement)(await this.getRect(), frames)) ?? frames[0];
     }
 }
 exports.WebView = (0, WebviewMixin_1.default)(WebViewBase);

package/out/components/menu/ContextMenu.d.ts

@@ -20,7 +20,7 @@ import { WebElement } from 'selenium-webdriver';
  * Object representing a context menu
  */
 export declare class ContextMenu extends Menu {
-    constructor(containingElement: WebElement);
+    constructor(containingElement: WebElement, menuElement?: WebElement);
     /**
      * Get context menu item by name
      * @param name name of the item to search by

package/out/components/menu/ContextMenu.js

@@ -23,8 +23,11 @@ const selenium_webdriver_1 = require("selenium-webdriver");
  * Object representing a context menu
  */
 class ContextMenu extends __1.Menu {
-    constructor(containingElement) {
-        super(ContextMenu.locators.ContextMenu.constructor, containingElement);
+    constructor(containingElement, menuElement) {
+        // menuElement covers menus whose container cannot be found by locator
+        // from the containing element, e.g. the menu inside a shadow root where
+        // the root's only child IS the menu container.
+        super(menuElement ?? ContextMenu.locators.ContextMenu.constructor, containingElement);
     }
     /**
      * Get context menu item by name
@@ -84,7 +87,7 @@ class ContextMenu extends __1.Menu {
         await actions.clear();
         await this.getDriver().actions().sendKeys(selenium_webdriver_1.Key.ESCAPE).perform();
         try {
-            await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this));
+            await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this), 5_000);
         }
         catch (err) {
             if (!(err instanceof selenium_webdriver_1.error.StaleElementReferenceError)) {
@@ -146,7 +149,7 @@ class ContextMenuItem extends __1.MenuItem {
                 const actions = this.getDriver().actions();
                 await actions.clear();
                 await this.getDriver().actions().sendKeys(selenium_webdriver_1.Key.ESCAPE).perform();
-                await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this));
+                await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this), 5_000);
             }
         }
         catch (err) {

package/out/components/menu/Menu.js

@@ -52,9 +52,11 @@ class Menu extends AbstractElement_1.AbstractElement {
             if (!item) {
                 return parent;
             }
+            // Guard with an explicit timeout so the wait never hangs indefinitely
+            // on CI where the implicit/default Selenium timeout may be 0 or very low.
             await Menu.driver.wait(async function () {
                 return (await item.isDisplayed()) && (await item.isEnabled());
-            });
+            }, 5000);
             const submenu = await item.select();
             if (submenu) {
                 parent = submenu;

package/out/components/sidebar/ViewItem.js

@@ -68,6 +68,7 @@ class TreeItem extends ViewItem {
     async expand() {
         if ((await this.isExpandable()) && !(await this.isExpanded())) {
             await (await this.findTwistie()).click();
+            await this.getDriver().wait(() => this.isExpanded(), 5000, 'Tree item did not expand within 5s');
         }
     }
     /**

package/out/components/sidebar/tree/default/DefaultTreeSection.js

@@ -45,7 +45,13 @@ class DefaultTreeSection extends TreeSection_1.TreeSection {
         const container = await this.findElement(DefaultTreeSection.locators.DefaultTreeSection.rowContainer);
         await container.sendKeys(selenium_webdriver_1.Key.HOME);
         let item = undefined;
+        const maxIterations = 500;
+        let iteration = 0;
         do {
+            if (iteration++ >= maxIterations) {
+                console.warn(`findItem('${label}'): exceeded ${maxIterations} scroll iterations, giving up`);
+                break;
+            }
             const temp = await container.findElements(DefaultTreeSection.locators.DefaultTreeItem.ctor(label));
             if (temp.length > 0) {
                 const level = +(await temp[0].getAttribute(DefaultTreeSection.locators.ViewSection.level));

package/out/components/workbench/DebugToolbar.js

@@ -42,7 +42,7 @@ class DebugToolbar extends AbstractElement_1.AbstractElement {
      * Wait for the execution to pause at the next breakpoint
      */
     async waitForBreakPoint(timeout = 10_000) {
-        let btn = await this.getDriver().wait(selenium_webdriver_1.until.elementLocated(DebugToolbar.locators.DebugToolbar.button('continue')));
+        let btn = await this.getDriver().wait(selenium_webdriver_1.until.elementLocated(DebugToolbar.locators.DebugToolbar.button('continue')), timeout);
         await this.getDriver().wait(async () => {
             try {
                 const enabled = await btn.isEnabled();

package/out/components/workbench/NotificationsCenter.js

@@ -48,7 +48,12 @@ class NotificationsCenter extends AbstractElement_1.AbstractElement {
      * @returns Promise resolving when the clear all button is pressed
      */
     async clearAllNotifications() {
-        await this.findElement(NotificationsCenter.locators.NotificationsCenter.clear).click();
+        const btn = await this.findElement(NotificationsCenter.locators.NotificationsCenter.clear);
+        const classes = (await btn.getAttribute('class')) ?? '';
+        if (classes.includes('disabled')) {
+            return;
+        }
+        await this.getDriver().executeScript('arguments[0].click()', btn);
     }
     /**
      * Get all notifications of a given type

package/out/components/workbench/Workbench.js

@@ -115,7 +115,7 @@ class Workbench extends AbstractElement_1.AbstractElement {
     async openSettings() {
         await this.executeCommand('Preferences: Open User Settings');
         await new EditorView_1.EditorView().openEditor('Settings');
-        await Workbench.driver.wait(selenium_webdriver_1.until.elementLocated(Workbench.locators.Editor.constructor));
+        await Workbench.driver.wait(selenium_webdriver_1.until.elementLocated(Workbench.locators.Editor.constructor), 10_000);
         // Wait for settings editor to fully load
         const editor = new SettingsEditor_1.SettingsEditor();
         await this.getWaitHelper().forStable(editor, { timeout: 2000 });

package/out/components/workbench/input/Input.d.ts

@@ -41,6 +41,24 @@ export declare abstract class Input extends AbstractElement {
      * @returns Promise resolving when the input is confirmed
      */
     confirm(): Promise<void>;
+    /**
+     * Confirm path selection for file/folder dialog.
+     *
+     * VS Code's file picker auto-navigates as text is typed: when a full path such as
+     * `/dir/file.txt` is in the input, the picker shows the parent directory contents
+     * with the filename filtered in the list. A single Enter press navigates into the
+     * matched list entry. A subsequent click on the OK button (or a second Enter) then
+     * confirms the selection and closes the dialog.
+     *
+     * When the path is not formatted to OS specifics there may first be a 'Select' step.
+     * See also https://github.com/redhat-developer/vscode-extension-tester/issues/1778
+     */
+    confirmPath(): Promise<void>;
+    /**
+     * Best-effort check whether this input/picker widget is still displayed.
+     * A hidden, detached or stale widget counts as closed.
+     */
+    private isPickerOpen;
     /**
      * Cancel the input field by pressing Escape
      * @returns Promise resolving when the input is cancelled

package/out/components/workbench/input/Input.js

@@ -86,6 +86,74 @@ class Input extends AbstractElement_1.AbstractElement {
         await input.click();
         await input.sendKeys(selenium_webdriver_1.Key.ENTER);
     }
+    /**
+     * Confirm path selection for file/folder dialog.
+     *
+     * VS Code's file picker auto-navigates as text is typed: when a full path such as
+     * `/dir/file.txt` is in the input, the picker shows the parent directory contents
+     * with the filename filtered in the list. A single Enter press navigates into the
+     * matched list entry. A subsequent click on the OK button (or a second Enter) then
+     * confirms the selection and closes the dialog.
+     *
+     * When the path is not formatted to OS specifics there may first be a 'Select' step.
+     * See also https://github.com/redhat-developer/vscode-extension-tester/issues/1778
+     */
+    async confirmPath() {
+        // Step 1 — drive VS Code's file picker to navigate into the typed path.
+        // Sending Enter selects the highlighted entry in the suggestion list, which
+        // causes the picker to consume the directory portion and reveal the target file.
+        const inputEl = await this.findElement(Input.locators.Input.inputBox).findElement(Input.locators.Input.input);
+        await inputEl.sendKeys(selenium_webdriver_1.Key.ENTER);
+        // When the typed path uniquely resolves the target, the first Enter both
+        // navigates and confirms — the picker closes on its own and no second step
+        // is needed (attempting one would hit a hidden input).
+        if (!(await this.isPickerOpen())) {
+            return;
+        }
+        // Step 2 — click the OK button to confirm and close the dialog.
+        // Use a JS click to bypass any overlay that may intercept a normal WebDriver click.
+        // Falls back to a second Enter if no matching button is found.
+        try {
+            const buttons = await this.findElements(selenium_webdriver_1.By.className('monaco-button'));
+            for (const btn of buttons) {
+                if (await btn.isDisplayed()) {
+                    const label = ((await btn.getText()) || (await btn.getAttribute('aria-label')) || '').trim();
+                    if (label === 'Select' || label === 'Ok' || label === 'OK') {
+                        await Input.driver.executeScript('arguments[0].click()', btn);
+                        return;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // ignore if button is not found or stale
+        }
+        if (!(await this.isPickerOpen())) {
+            return;
+        }
+        try {
+            await inputEl.sendKeys(selenium_webdriver_1.Key.ENTER);
+        }
+        catch (err) {
+            // The picker can close in the instant between the check above and the
+            // keystroke — a failure only matters while the picker is still open.
+            if (await this.isPickerOpen()) {
+                throw err;
+            }
+        }
+    }
+    /**
+     * Best-effort check whether this input/picker widget is still displayed.
+     * A hidden, detached or stale widget counts as closed.
+     */
+    async isPickerOpen() {
+        try {
+            return await this.isDisplayed();
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Cancel the input field by pressing Escape
      * @returns Promise resolving when the input is cancelled

package/out/components/workbench/input/QuickOpenBox.js

@@ -32,7 +32,7 @@ class QuickOpenBox extends __1.Input {
      * Use when a quick open box is scheduled to appear.
      */
     static async create() {
-        await QuickOpenBox.driver.wait(selenium_webdriver_1.until.elementLocated(QuickOpenBox.locators.QuickOpenBox.constructor));
+        await QuickOpenBox.driver.wait(selenium_webdriver_1.until.elementLocated(QuickOpenBox.locators.QuickOpenBox.constructor), 10_000);
         return new QuickOpenBox().wait();
     }
     async hasProgress() {

package/out/errors/ExTesterError.js

@@ -101,7 +101,7 @@ exports.ElementNotInteractableError = ElementNotInteractableError;
 class StaleElementError extends ExTesterError {
     constructor(message, context = {}) {
         super(message, context);
-        this.name = 'StaleElementError';
+        this.name = 'StaleElementReferenceError';
     }
 }
 exports.StaleElementError = StaleElementError;

package/out/index.d.ts

@@ -21,6 +21,7 @@ export * from './locators/locators';
 export * from './errors/NullAttributeError';
 export * from './errors/ExTesterError';
 export * from './utils/WaitHelper';
+export * from './utils/TimeoutConstants';
 export * from './components/menu/Menu';
 export * from './components/menu/MenuItem';
 export * from './components/menu/TitleBar';