@redhat-developer/page-objects 1.21.0 → 1.23.0

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';

package/out/index.js

@@ -64,6 +64,7 @@ __exportStar(require("./locators/locators"), exports);
 __exportStar(require("./errors/NullAttributeError"), exports);
 __exportStar(require("./errors/ExTesterError"), exports);
 __exportStar(require("./utils/WaitHelper"), exports);
+__exportStar(require("./utils/TimeoutConstants"), exports);
 __exportStar(require("./components/menu/Menu"), exports);
 __exportStar(require("./components/menu/MenuItem"), exports);
 __exportStar(require("./components/menu/TitleBar"), exports);

package/out/locators/locators.js

@@ -66,14 +66,37 @@ function fromText(locator) {
     };
 }
 async function findBestContainingElement(container, testElements) {
-    const areas = await Promise.all(testElements.map(async (value) => {
-        const rect = await value.getRect();
+    if (testElements.length === 0) {
+        return undefined;
+    }
+    // Short-circuit: single candidate needs no geometry.
+    if (testElements.length === 1) {
+        return testElements[0];
+    }
+    const rects = await Promise.all(testElements.map((el) => el.getRect()));
+    // When the container has not been laid out yet its rect is {0,0,0,0}.
+    // In that case overlap with any non-zero-position iframe would be negative
+    // for all candidates, causing the function to incorrectly return undefined.
+    // Fall back to picking the element with the largest own area so that the
+    // poll loop in switchToFrame can still make progress.
+    const containerArea = container.width * container.height;
+    if (containerArea === 0) {
+        let bestIdx = 0;
+        for (let i = 1; i < rects.length; i++) {
+            if (rects[i].width * rects[i].height > rects[bestIdx].width * rects[bestIdx].height) {
+                bestIdx = i;
+            }
+        }
+        return testElements[bestIdx];
+    }
+    // Normal case: pick the iframe whose intersection with the container is largest.
+    const areas = rects.map((rect) => {
         const ax = Math.max(container.x, rect.x);
         const ay = Math.max(container.y, rect.y);
         const bx = Math.min(container.x + container.width, rect.x + rect.width);
         const by = Math.min(container.y + container.height, rect.y + rect.height);
         return (bx - ax) * (by - ay);
-    }));
+    });
     let bestIdx = -1;
     for (let i = 0; i < testElements.length; i++) {
         if (areas[i] < 0) {

package/out/utils/TimeoutConstants.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License", destination); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Centralized timeout constants for page-object operations.
+ * Components should reference these instead of hardcoding values.
+ * Consumers can override by assigning to the mutable fields.
+ */
+export declare const TimeoutConstants: {
+    /** Default wait for an element to become visible (ms) */
+    ELEMENT_VISIBLE: number;
+    /** Default wait for an element to become stable (ms) */
+    ELEMENT_STABLE: number;
+    /** Wait for a menu to appear after context-click (ms) */
+    MENU_APPEAR: number;
+    /** Wait for a menu item count to stabilize (ms) */
+    MENU_STABLE: number;
+    /** Wait for an input box to appear (ms) */
+    INPUT_APPEAR: number;
+    /** Wait for quick open / command palette (ms) */
+    QUICK_OPEN: number;
+    /** Wait for editor to load (ms) */
+    EDITOR_LOAD: number;
+    /** Wait for content assist to populate (ms) */
+    CONTENT_ASSIST: number;
+    /** Wait for a tree section row container (ms) */
+    TREE_SECTION: number;
+    /** Wait for extension install from marketplace (ms) */
+    EXTENSION_INSTALL: number;
+    /** Wait for notifications to appear/dismiss (ms) */
+    NOTIFICATION: number;
+    /** Close all editors timeout (ms) */
+    CLOSE_ALL_EDITORS: number;
+    /** Wait for dialog / workbench elements (ms) */
+    DIALOG: number;
+    /** Debug toolbar / breakpoint wait (ms) */
+    DEBUG: number;
+    /** Webview frame switching (ms) */
+    WEBVIEW: number;
+    /** Wait for clipboard operations (ms) */
+    CLIPBOARD: number;
+    /** Default poll interval for condition waits (ms) */
+    POLL_INTERVAL: number;
+    /** Default number of stability checks */
+    STABILITY_CHECKS: number;
+};

package/out/utils/TimeoutConstants.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License", destination); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutConstants = void 0;
+/**
+ * Centralized timeout constants for page-object operations.
+ * Components should reference these instead of hardcoding values.
+ * Consumers can override by assigning to the mutable fields.
+ */
+exports.TimeoutConstants = {
+    /** Default wait for an element to become visible (ms) */
+    ELEMENT_VISIBLE: 5_000,
+    /** Default wait for an element to become stable (ms) */
+    ELEMENT_STABLE: 2_000,
+    /** Wait for a menu to appear after context-click (ms) */
+    MENU_APPEAR: 2_000,
+    /** Wait for a menu item count to stabilize (ms) */
+    MENU_STABLE: 1_000,
+    /** Wait for an input box to appear (ms) */
+    INPUT_APPEAR: 5_000,
+    /** Wait for quick open / command palette (ms) */
+    QUICK_OPEN: 10_000,
+    /** Wait for editor to load (ms) */
+    EDITOR_LOAD: 5_000,
+    /** Wait for content assist to populate (ms) */
+    CONTENT_ASSIST: 10_000,
+    /** Wait for a tree section row container (ms) */
+    TREE_SECTION: 5_000,
+    /** Wait for extension install from marketplace (ms) */
+    EXTENSION_INSTALL: 300_000,
+    /** Wait for notifications to appear/dismiss (ms) */
+    NOTIFICATION: 2_000,
+    /** Close all editors timeout (ms) */
+    CLOSE_ALL_EDITORS: 60_000,
+    /** Wait for dialog / workbench elements (ms) */
+    DIALOG: 5_000,
+    /** Debug toolbar / breakpoint wait (ms) */
+    DEBUG: 10_000,
+    /** Webview frame switching (ms) */
+    WEBVIEW: 5_000,
+    /** Wait for clipboard operations (ms) */
+    CLIPBOARD: 2_000,
+    /** Default poll interval for condition waits (ms) */
+    POLL_INTERVAL: 100,
+    /** Default number of stability checks */
+    STABILITY_CHECKS: 3,
+};
+//# sourceMappingURL=TimeoutConstants.js.map

package/out/utils/WaitHelper.d.ts

@@ -189,6 +189,37 @@ export declare class WaitHelper {
      * @param ms Milliseconds to sleep
      */
     sleep(ms: number): Promise<void>;
+    /**
+     * Move the virtual pointer to a quiet spot: the title-bar drag region at the
+     * top-center of the window (the command center is disabled by the framework's
+     * default settings, and unlike the status bar the area has no hover targets).
+     *
+     * A WebDriver session has no OS mouse - the pointer rests wherever the last
+     * interaction left it. VS Code hovers appear while the pointer rests on an
+     * element and are torn down only when it moves away, so parking delivers the
+     * mouseout an open hover is waiting for and disarms pending hover timers.
+     */
+    parkPointer(): Promise<void>;
+    /**
+     * Click an element, recovering when a transient overlay intercepts the click.
+     *
+     * VS Code renders rich hovers/tooltips as DOM overlays that appear while the
+     * pointer rests on the last click point and never auto-hide. A W3C click
+     * hit-tests the click point BEFORE dispatching any event, so a resting hover
+     * over the target fails every attempt until the pointer actually moves -
+     * waiting alone can never resolve it. On interception this actively parks
+     * the pointer (dismissing pointer-rest overlays), waits for hover teardown
+     * and retries the native click. As a last resort it falls back to a
+     * JS-executor click, which bypasses hit-testing but also mousedown semantics
+     * (Monaco lists select on mousedown) - the fallback is logged so the call
+     * site's true blocker can be root-caused instead of silently papered over.
+     *
+     * @param element the element to click
+     * @param nativeClick override for the native click action (used by
+     * AbstractElement.click() to reach WebElement.prototype.click through its
+     * own override)
+     */
+    clickThroughInterception(element: WebElement, nativeClick?: () => Promise<void>): Promise<void>;
     /**
      * Get the WebDriver instance.
      */

package/out/utils/WaitHelper.js

@@ -54,8 +54,14 @@ class WaitHelper {
                 }
             }
             catch (e) {
-                // Store error but continue retrying for transient errors
-                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError || e instanceof selenium_webdriver_1.error.NoSuchElementError) {
+                // Store error but continue retrying for transient failures.
+                // TimeoutError from driver.wait(until.elementIsVisible) means the element
+                // exists but is not yet visible — the condition should be retried rather
+                // than aborting the outer poll loop.
+                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError ||
+                    e instanceof selenium_webdriver_1.error.NoSuchElementError ||
+                    e instanceof selenium_webdriver_1.error.TimeoutError ||
+                    e?.name === 'TimeoutError') {
                     lastError = e;
                 }
                 else {
@@ -444,6 +450,76 @@ class WaitHelper {
     async sleep(ms) {
         await new Promise((resolve) => setTimeout(resolve, ms));
     }
+    /**
+     * Move the virtual pointer to a quiet spot: the title-bar drag region at the
+     * top-center of the window (the command center is disabled by the framework's
+     * default settings, and unlike the status bar the area has no hover targets).
+     *
+     * A WebDriver session has no OS mouse - the pointer rests wherever the last
+     * interaction left it. VS Code hovers appear while the pointer rests on an
+     * element and are torn down only when it moves away, so parking delivers the
+     * mouseout an open hover is waiting for and disarms pending hover timers.
+     */
+    async parkPointer() {
+        const width = Number(await this.driver.executeScript('return window.innerWidth')) || 200;
+        await this.driver
+            .actions()
+            .move({ x: Math.floor(width / 2), y: 5 })
+            .perform();
+    }
+    /**
+     * Click an element, recovering when a transient overlay intercepts the click.
+     *
+     * VS Code renders rich hovers/tooltips as DOM overlays that appear while the
+     * pointer rests on the last click point and never auto-hide. A W3C click
+     * hit-tests the click point BEFORE dispatching any event, so a resting hover
+     * over the target fails every attempt until the pointer actually moves -
+     * waiting alone can never resolve it. On interception this actively parks
+     * the pointer (dismissing pointer-rest overlays), waits for hover teardown
+     * and retries the native click. As a last resort it falls back to a
+     * JS-executor click, which bypasses hit-testing but also mousedown semantics
+     * (Monaco lists select on mousedown) - the fallback is logged so the call
+     * site's true blocker can be root-caused instead of silently papered over.
+     *
+     * @param element the element to click
+     * @param nativeClick override for the native click action (used by
+     * AbstractElement.click() to reach WebElement.prototype.click through its
+     * own override)
+     */
+    async clickThroughInterception(element, nativeClick = () => element.click()) {
+        const maxNativeAttempts = 3;
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await nativeClick();
+            }
+            catch (e) {
+                if (e.name !== 'ElementClickInterceptedError') {
+                    throw e;
+                }
+                // a modal dialog blocks the whole workbench by design - neither
+                // pointer parking nor a JS click may subvert it: JS-clicking
+                // through the blocker would trigger actions the real UI forbids.
+                // Fail fast with the original error so modal-aware callers (and
+                // test authors) see the true blocker.
+                const modalUp = await this.driver
+                    .executeScript('return Array.from(document.querySelectorAll(".monaco-dialog-modal-block, .monaco-dialog-box")).some((el) => el.checkVisibility());')
+                    .catch(() => false);
+                if (modalUp) {
+                    throw e;
+                }
+                if (attempt >= maxNativeAttempts - 1) {
+                    console.warn(`clickThroughInterception: falling back to a JS click after ${maxNativeAttempts} intercepted attempts: ${e.message}`);
+                    await this.driver.executeScript('arguments[0].click();', element);
+                    return;
+                }
+                await this.parkPointer();
+                // hover teardown is event-driven and near-instant once the pointer
+                // moved away; a non-hover interceptor (modal, toast) never passes
+                // this check, so time-box it and retry regardless
+                await this.forCondition(async () => await this.driver.executeScript('return !Array.from(document.querySelectorAll(".monaco-hover")).some((el) => el.checkVisibility());'), { timeout: 1500, pollInterval: 50, message: 'hover overlay did not dismiss after parking the pointer' }).catch(() => undefined);
+            }
+        }
+    }
     /**
      * Get the WebDriver instance.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redhat-developer/page-objects",
-  "version": "1.21.0",
+  "version": "1.23.0",
   "description": "Page Object API implementation for a VS Code editor used by ExTester framework.",
   "main": "out/index.js",
   "types": "out/index.d.ts",
@@ -17,6 +17,9 @@
   },
   "author": "Red Hat",
   "license": "Apache-2.0",
+  "engines": {
+    "node": ">=22"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -43,8 +46,8 @@
     "fs-extra": "^11.4.0"
   },
   "peerDependencies": {
-    "selenium-webdriver": ">=4.6.1",
+    "selenium-webdriver": "^4.48.0",
     "typescript": ">=4.6.2"
   },
-  "gitHead": "d3ed855411fdff9575ce7d7e8a65faa70a08349f"
+  "gitHead": "2333228475aff111f91b91d06e50a5b98e371886"
 }