@redhat-developer/page-objects 1.17.0 → 1.18.1

package/out/components/AbstractElement.d.ts

@@ -16,6 +16,17 @@
  */
 import { WebElement, WebDriver, Locator } from 'selenium-webdriver';
 import { Locators } from '../locators/locators';
+import { WaitHelper } from '../utils/WaitHelper';
+import { type ErrorContext } from '../errors/ExTesterError';
+/**
+ * Information needed to relocate an element after it becomes stale.
+ */
+export interface LocatorInfo {
+    /** The locator used to find this element */
+    locator: Locator;
+    /** The parent element or locator this element was found within */
+    enclosingLocator?: Locator | WebElement;
+}
 /**
  * Default wrapper for webElement
  */
@@ -27,7 +38,13 @@ export declare abstract class AbstractElement extends WebElement {
         version: string;
         browser: string;
     };
+    protected static waitHelper: WaitHelper;
     protected enclosingItem: WebElement;
+    /**
+     * Locator information for auto-recovery when element becomes stale.
+     * Stored when element is created with a Locator (not a WebElement).
+     */
+    protected locatorInfo?: LocatorInfo;
     /**
      * Constructs a new element from a Locator or an existing WebElement
      * @param base WebDriver compatible Locator for the given element or a reference to an existing WebElement
@@ -43,11 +60,70 @@ export declare abstract class AbstractElement extends WebElement {
      * @returns thenable self reference
      */
     wait(timeout?: number): Promise<this>;
+    /**
+     * Wait for the element to become stable (position/size stops changing).
+     * Useful after animations or dynamic content loading.
+     * @param timeout Maximum time to wait in milliseconds
+     * @returns thenable self reference
+     */
+    waitForStable(timeout?: number): Promise<this>;
     /**
      * Return a reference to the WebElement containing this element
      */
     getEnclosingElement(): WebElement;
+    /**
+     * Get the stored locator information for this element, if available.
+     */
+    getLocatorInfo(): LocatorInfo | undefined;
+    /**
+     * Check if this element can be automatically recovered when stale.
+     */
+    canAutoRecover(): boolean;
+    /**
+     * Get the WaitHelper instance for condition-based waiting.
+     */
+    protected getWaitHelper(): WaitHelper;
+    /**
+     * Create error context for this element.
+     * Useful for creating detailed error messages.
+     */
+    protected createErrorContext(action: string, details?: string): ErrorContext;
     static init(locators: Locators, driver: WebDriver, browser: string, version: string): void;
-    withRecovery<T>(fn: (self: this) => Promise<T>): Promise<T>;
+    /**
+     * Execute a function with automatic recovery from stale element references.
+     * If the element becomes stale during execution, it will be relocated and
+     * the function will be retried once.
+     *
+     * @param fn The async function to execute
+     * @param maxRetries Maximum number of recovery attempts (default: 1)
+     * @returns The result of the function
+     */
+    withRecovery<T>(fn: (self: this) => Promise<T>, maxRetries?: number): Promise<T>;
+    /**
+     * Re-locate this element using stored locator information.
+     * This is called automatically by withRecovery() when an element becomes stale.
+     *
+     * Subclasses can override this for custom recovery logic, but the default
+     * implementation works for most cases when the element was created with a locator.
+     *
+     * @returns A new instance of this element type pointing to the relocated DOM element
+     * @throws ElementRecoveryError if the element cannot be recovered
+     */
     protected reinitialize(): Promise<this>;
+    /**
+     * Safely click on the element with automatic retry on stale/interactable errors.
+     */
+    safeClick(): Promise<void>;
+    /**
+     * Safely send keys to the element with automatic retry on stale/interactable errors.
+     */
+    safeSendKeys(...keys: (string | Promise<string>)[]): Promise<void>;
+    /**
+     * Safely get text from the element with automatic retry on stale errors.
+     */
+    safeGetText(): Promise<string>;
+    /**
+     * Safely get attribute from the element with automatic retry on stale errors.
+     */
+    safeGetAttribute(name: string): Promise<string>;
 }

package/out/components/AbstractElement.js

@@ -18,6 +18,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractElement = void 0;
 const selenium_webdriver_1 = require("selenium-webdriver");
+const WaitHelper_1 = require("../utils/WaitHelper");
+const ExTesterError_1 = require("../errors/ExTesterError");
 /**
  * Default wrapper for webElement
  */
@@ -26,13 +28,24 @@ class AbstractElement extends selenium_webdriver_1.WebElement {
     static driver;
     static locators;
     static versionInfo;
+    static waitHelper;
     enclosingItem;
+    /**
+     * Locator information for auto-recovery when element becomes stale.
+     * Stored when element is created with a Locator (not a WebElement).
+     */
+    locatorInfo;
     /**
      * Constructs a new element from a Locator or an existing WebElement
      * @param base WebDriver compatible Locator for the given element or a reference to an existing WebElement
      * @param enclosingItem Locator or a WebElement reference to an element containing the element being constructed
      * this will be used to narrow down the search for the underlying DOM element
      */
+    /*
+     * Note: The findElement calls below use selenium-webdriver's ThenableWebElement pattern
+     * for lazy element resolution. The WebElement base class is designed to work with these
+     * thenables, making this an intentional pattern.
+     */
     constructor(base, enclosingItem) {
         let item = AbstractElement.driver.findElement(AbstractElement.locators.AbstractElement.tag);
         if (!enclosingItem) {
@@ -46,11 +59,17 @@ class AbstractElement extends selenium_webdriver_1.WebElement {
         }
         if (base instanceof selenium_webdriver_1.WebElement) {
             super(AbstractElement.driver, base.getId());
+            // Cannot store locator info for WebElement-based construction
         }
         else {
             const toFind = item.findElement(base);
             const id = toFind.getId();
             super(AbstractElement.driver, id);
+            // Store locator info for potential recovery
+            this.locatorInfo = {
+                locator: base,
+                enclosingLocator: enclosingItem,
+            };
         }
         this.enclosingItem = item;
     }
@@ -69,34 +88,172 @@ class AbstractElement extends selenium_webdriver_1.WebElement {
         await this.getDriver().wait(selenium_webdriver_1.until.elementIsVisible(this), timeout);
         return this;
     }
+    /**
+     * Wait for the element to become stable (position/size stops changing).
+     * Useful after animations or dynamic content loading.
+     * @param timeout Maximum time to wait in milliseconds
+     * @returns thenable self reference
+     */
+    async waitForStable(timeout = 2000) {
+        await AbstractElement.waitHelper.forStable(this, { timeout });
+        return this;
+    }
     /**
      * Return a reference to the WebElement containing this element
      */
     getEnclosingElement() {
         return this.enclosingItem;
     }
+    /**
+     * Get the stored locator information for this element, if available.
+     */
+    getLocatorInfo() {
+        return this.locatorInfo;
+    }
+    /**
+     * Check if this element can be automatically recovered when stale.
+     */
+    canAutoRecover() {
+        return this.locatorInfo !== undefined;
+    }
+    /**
+     * Get the WaitHelper instance for condition-based waiting.
+     */
+    getWaitHelper() {
+        return AbstractElement.waitHelper;
+    }
+    /**
+     * Create error context for this element.
+     * Useful for creating detailed error messages.
+     */
+    createErrorContext(action, details) {
+        return {
+            component: this.constructor.name,
+            action,
+            vscodeVersion: AbstractElement.versionInfo?.version,
+            locator: this.locatorInfo?.locator ? JSON.stringify(this.locatorInfo.locator) : undefined,
+            details,
+        };
+    }
     static init(locators, driver, browser, version) {
         AbstractElement.locators = locators;
         AbstractElement.driver = driver;
         AbstractElement.versionInfo = { version: version, browser: browser };
+        AbstractElement.waitHelper = new WaitHelper_1.WaitHelper(driver);
+    }
+    /**
+     * Execute a function with automatic recovery from stale element references.
+     * If the element becomes stale during execution, it will be relocated and
+     * the function will be retried once.
+     *
+     * @param fn The async function to execute
+     * @param maxRetries Maximum number of recovery attempts (default: 1)
+     * @returns The result of the function
+     */
+    async withRecovery(fn, maxRetries = 1) {
+        let lastError;
+        let recoveredElement;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await fn(recoveredElement ?? this);
+            }
+            catch (err) {
+                const isRecoverable = err.name === 'StaleElementReferenceError' ||
+                    err.name === 'ElementNotInteractableError' ||
+                    /element.*(detached|not interactable)/i.test(err.message);
+                if (isRecoverable && attempt < maxRetries) {
+                    try {
+                        recoveredElement = await this.reinitialize();
+                    }
+                    catch (error_) {
+                        // Recovery failed, throw original error with context
+                        throw (0, ExTesterError_1.wrapError)(err, this.createErrorContext('withRecovery', `Recovery failed: ${error_.message}`));
+                    }
+                    lastError = err;
+                }
+                else {
+                    throw (0, ExTesterError_1.wrapError)(err, this.createErrorContext('withRecovery'));
+                }
+            }
+        }
+        // Should not reach here, but just in case
+        throw lastError || new Error('Unexpected error in withRecovery');
     }
-    async withRecovery(fn) {
+    /**
+     * Re-locate this element using stored locator information.
+     * This is called automatically by withRecovery() when an element becomes stale.
+     *
+     * Subclasses can override this for custom recovery logic, but the default
+     * implementation works for most cases when the element was created with a locator.
+     *
+     * @returns A new instance of this element type pointing to the relocated DOM element
+     * @throws ElementRecoveryError if the element cannot be recovered
+     */
+    async reinitialize() {
+        if (!this.locatorInfo) {
+            throw new ExTesterError_1.ElementRecoveryError(`Cannot auto-recover ${this.constructor.name}: no locator information stored. ` +
+                `Element was likely created from a WebElement reference. ` +
+                `Override reinitialize() in ${this.constructor.name} for custom recovery logic.`, this.createErrorContext('reinitialize'));
+        }
         try {
-            return await fn(this);
+            // Resolve the parent element
+            let parentElement;
+            if (this.locatorInfo.enclosingLocator instanceof selenium_webdriver_1.WebElement) {
+                parentElement = this.locatorInfo.enclosingLocator;
+            }
+            else if (this.locatorInfo.enclosingLocator) {
+                parentElement = await AbstractElement.driver.findElement(this.locatorInfo.enclosingLocator);
+            }
+            else {
+                parentElement = await AbstractElement.driver.findElement(AbstractElement.locators.AbstractElement.tag);
+            }
+            // Find the element again
+            const newElement = await parentElement.findElement(this.locatorInfo.locator);
+            // Create a new instance of the same class
+            const Constructor = this.constructor;
+            const recovered = new Constructor(newElement, parentElement);
+            // Copy over the locator info so subsequent recoveries work
+            recovered.locatorInfo = this.locatorInfo;
+            return recovered;
         }
         catch (err) {
-            if (err.name === 'StaleElementReferenceError' ||
-                err.name === 'ElementNotInteractableError' ||
-                /element.*(detached|not interactable)/i.test(err.message)) {
-                const reinit = await this.reinitialize();
-                return await fn(reinit);
-            }
-            throw err;
+            throw new ExTesterError_1.ElementRecoveryError(`Failed to relocate ${this.constructor.name}`, {
+                ...this.createErrorContext('reinitialize'),
+                cause: err,
+            });
         }
     }
-    async reinitialize() {
-        // Implement generic fallback if possible — otherwise force override in subclasses
-        throw new Error(`reinitialize() not implemented in ${this.constructor.name}`);
+    /**
+     * Safely click on the element with automatic retry on stale/interactable errors.
+     */
+    async safeClick() {
+        await this.withRecovery(async (self) => {
+            await self.click();
+        });
+    }
+    /**
+     * Safely send keys to the element with automatic retry on stale/interactable errors.
+     */
+    async safeSendKeys(...keys) {
+        await this.withRecovery(async (self) => {
+            await self.sendKeys(...keys);
+        });
+    }
+    /**
+     * Safely get text from the element with automatic retry on stale errors.
+     */
+    async safeGetText() {
+        return await this.withRecovery(async (self) => {
+            return await self.getText();
+        });
+    }
+    /**
+     * Safely get attribute from the element with automatic retry on stale errors.
+     */
+    async safeGetAttribute(name) {
+        return await this.withRecovery(async (self) => {
+            return await self.getAttribute(name);
+        });
     }
 }
 exports.AbstractElement = AbstractElement;

package/out/components/ActionButtonElementDropdown.js

@@ -23,14 +23,26 @@ const selenium_webdriver_1 = require("selenium-webdriver");
 class ActionButtonElementDropdown extends AbstractElement_1.AbstractElement {
     async open() {
         await this.click();
-        await this.getDriver().sleep(500);
+        // Wait for dropdown to open
+        await this.getWaitHelper()
+            .forCondition(async () => {
+            const expanded = await this.getAttribute('aria-expanded');
+            return expanded === 'true';
+        }, { timeout: 2000, pollInterval: 50 })
+            .catch(() => {
+            /* May not have aria-expanded attribute */
+        });
         const shadowRootHost = await this.enclosingItem.findElements(ActionButtonElementDropdown.locators.ContextMenu.shadowRootHost);
         const actions = this.getDriver().actions();
         await actions.clear();
         if (shadowRootHost.length > 0) {
             if ((await this.getAttribute('aria-expanded')) !== 'true') {
                 await this.click();
-                await this.getDriver().sleep(500);
+                // Wait for dropdown to expand after second click
+                await this.getWaitHelper().forCondition(async () => {
+                    const expanded = await this.getAttribute('aria-expanded');
+                    return expanded === 'true';
+                }, { timeout: 2000, pollInterval: 50 });
             }
             const shadowRoot = await shadowRootHost[0].getShadowRoot();
             return new ContextMenu_1.ContextMenu(await shadowRoot.findElement(selenium_webdriver_1.By.className('monaco-menu-container'))).wait();

package/out/components/activityBar/ViewControl.js

@@ -37,7 +37,11 @@ class ViewControl extends ElementWithContextMenu_1.ElementWithContextMenu {
         const klass = await this.getAttribute(ViewControl.locators.ViewControl.attribute);
         if (klass.indexOf(ViewControl.locators.ViewControl.klass) < 0) {
             await this.click();
-            await ViewControl.driver.sleep(500);
+            // Wait for view to be marked as active
+            await this.getWaitHelper().forCondition(async () => {
+                const newKlass = await this.getAttribute(ViewControl.locators.ViewControl.attribute);
+                return newKlass.includes(ViewControl.locators.ViewControl.klass);
+            }, { timeout: 2000, pollInterval: 100 });
         }
         const view = await new __1.SideBarView().wait();
         if ((await view.findElements(ViewControl.locators.ViewControl.scmId)).length > 0) {

package/out/components/bottomBar/Views.js

@@ -123,16 +123,16 @@ class TerminalView extends AbstractViews_1.ChannelView {
             // try clearing, ignore if not available
         }
         await input.sendKeys(command, selenium_webdriver_1.Key.ENTER);
-        let timer = 0;
-        let style = await input.getCssValue('left');
-        do {
-            if (timeout > 0 && timer > timeout) {
-                throw new Error(`Timeout of ${timeout}ms exceeded`);
-            }
-            await new Promise((res) => setTimeout(res, 500));
-            timer += 500;
-            style = await input.getCssValue('left');
-        } while (style === '0px');
+        // Wait for command to complete by monitoring cursor position
+        const effectiveTimeout = timeout > 0 ? timeout : 30000;
+        await this.getWaitHelper().forCondition(async () => {
+            const style = await input.getCssValue('left');
+            return style !== '0px';
+        }, {
+            timeout: effectiveTimeout,
+            pollInterval: 200,
+            message: `Terminal command did not complete within ${effectiveTimeout}ms`,
+        });
     }
     /**
      * Get all text from the internal terminal
@@ -152,7 +152,16 @@ class TerminalView extends AbstractViews_1.ChannelView {
         }
         const workbench = new __1.Workbench();
         await workbench.executeCommand('terminal select all');
-        await workbench.getDriver().sleep(500);
+        // Wait for clipboard to be updated
+        await this.getWaitHelper().forCondition(async () => {
+            try {
+                const current = clipboard.readSync();
+                return current !== originalClipboard;
+            }
+            catch {
+                return false;
+            }
+        }, { timeout: 2000, pollInterval: 100 });
         const text = clipboard.readSync();
         if (originalClipboard.length > 0) {
             clipboard.writeSync(originalClipboard);
@@ -191,7 +200,11 @@ class TerminalView extends AbstractViews_1.ChannelView {
         }
         const list = await this.findElement(TerminalView.locators.TerminalView.tabList);
         const row = await list.findElement(TerminalView.locators.TerminalView.selectedRow);
-        await this.getDriver().sleep(1000);
+        // Wait for row to have a valid aria-label
+        await this.getWaitHelper().forCondition(async () => {
+            const label = await row.getAttribute('aria-label');
+            return label && label.split(' ').length >= 3;
+        }, { timeout: 2000, pollInterval: 100 });
         const label = (await row.getAttribute('aria-label')).split(' ');
         return `${label[1]}: ${label[2]}`;
     }

package/out/components/editor/ContentAssist.js

@@ -51,7 +51,8 @@ class ContentAssist extends __1.Menu {
             }
             if (!lastItem) {
                 await scrollable.sendKeys(selenium_webdriver_1.Key.PAGE_DOWN);
-                await new Promise((res) => setTimeout(res, 100));
+                // Minimal delay for scroll to render new items
+                await this.getWaitHelper().sleep(100);
             }
         }
     }

package/out/components/editor/EditorView.js

@@ -70,7 +70,8 @@ class EditorView extends AbstractElement_1.AbstractElement {
         }
         while (groups.length > 0 && (await groups[0].getOpenEditorTitles()).length > 0) {
             await groups[0].closeAllEditors();
-            await new Promise((res) => setTimeout(res, 1000));
+            // Brief wait for DOM to settle after closing editors
+            await this.getWaitHelper().sleep(500);
             groups = await this.getEditorGroups();
         }
     }
@@ -86,7 +87,15 @@ class EditorView extends AbstractElement_1.AbstractElement {
         }
         const titles = [];
         for (const group of groups) {
-            titles.push(...(await group.getOpenEditorTitles()));
+            try {
+                titles.push(...(await group.getOpenEditorTitles()));
+            }
+            catch (e) {
+                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    continue;
+                }
+                throw e;
+            }
         }
         return titles;
     }
@@ -112,7 +121,15 @@ class EditorView extends AbstractElement_1.AbstractElement {
         }
         const tabs = [];
         for (const group of groups) {
-            tabs.push(...(await group.getOpenTabs()));
+            try {
+                tabs.push(...(await group.getOpenTabs()));
+            }
+            catch (e) {
+                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    continue;
+                }
+                throw e;
+            }
         }
         return tabs;
     }
@@ -123,8 +140,16 @@ class EditorView extends AbstractElement_1.AbstractElement {
     async getActiveTab() {
         const tabs = await this.getOpenTabs();
         for (const tab of tabs) {
-            if (await tab.isSelected()) {
-                return tab;
+            try {
+                if (await tab.isSelected()) {
+                    return tab;
+                }
+            }
+            catch (e) {
+                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    continue;
+                }
+                throw e;
             }
         }
         return undefined;
@@ -305,8 +330,16 @@ class EditorGroup extends AbstractElement_1.AbstractElement {
     async getActiveTab() {
         const tabs = await this.getOpenTabs();
         for (const tab of tabs) {
-            if (await tab.isSelected()) {
-                return tab;
+            try {
+                if (await tab.isSelected()) {
+                    return tab;
+                }
+            }
+            catch (e) {
+                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    continue;
+                }
+                throw e;
             }
         }
         return undefined;
@@ -336,8 +369,16 @@ class EditorGroup extends AbstractElement_1.AbstractElement {
         const predicate = typeof predicateOrTitle === 'string' ? async (action) => (await action.getTitle()) === predicateOrTitle : predicateOrTitle;
         const actions = await this.getActions();
         for (const action of actions) {
-            if (await predicate(action)) {
-                return action;
+            try {
+                if (await predicate(action)) {
+                    return action;
+                }
+            }
+            catch (e) {
+                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    continue;
+                }
+                throw e;
             }
         }
         return undefined;

package/out/components/editor/ExtensionEditorDetailsSection.js

@@ -28,7 +28,15 @@ class ExtensionEditorDetailsSection extends __1.ExtensionEditorView {
         const container = await this.findElement(ExtensionEditorDetailsSection.locators.ExtensionEditorDetailsSection.categoriesContainer);
         const categoriesInContainer = await container.findElements(ExtensionEditorDetailsSection.locators.ExtensionEditorDetailsSection.category);
         for (const cat of categoriesInContainer) {
-            categories.push(await cat.getText());
+            try {
+                categories.push(await cat.getText());
+            }
+            catch (e) {
+                if (e.name === 'StaleElementReferenceError') {
+                    continue;
+                }
+                throw e;
+            }
         }
         return categories;
     }
@@ -41,7 +49,15 @@ class ExtensionEditorDetailsSection extends __1.ExtensionEditorView {
         const container = await this.findElement(ExtensionEditorDetailsSection.locators.ExtensionEditorDetailsSection.resourcesContainer);
         const resourcesInContainer = await container.findElements(ExtensionEditorDetailsSection.locators.ExtensionEditorDetailsSection.resource);
         for (const res of resourcesInContainer) {
-            resources.push(await res.getText());
+            try {
+                resources.push(await res.getText());
+            }
+            catch (e) {
+                if (e.name === 'StaleElementReferenceError') {
+                    continue;
+                }
+                throw e;
+            }
         }
         return resources;
     }
@@ -54,11 +70,19 @@ class ExtensionEditorDetailsSection extends __1.ExtensionEditorView {
         const container = await this.findElement(ExtensionEditorDetailsSection.locators.ExtensionEditorDetailsSection.moreInfoContainer);
         const moreInfoInContainer = await container.findElements(ExtensionEditorDetailsSection.locators.ExtensionEditorDetailsSection.moreInfo);
         for (const entry of moreInfoInContainer) {
-            const elmnts = await entry.findElements(ExtensionEditorDetailsSection.locators.ExtensionEditorDetailsSection.moreInfoElements);
-            const name = await elmnts.at(0)?.getText();
-            const value = await elmnts.at(1)?.getText();
-            if (name !== undefined && value !== undefined) {
-                moreInfo[name] = value;
+            try {
+                const elmnts = await entry.findElements(ExtensionEditorDetailsSection.locators.ExtensionEditorDetailsSection.moreInfoElements);
+                const name = await elmnts.at(0)?.getText();
+                const value = await elmnts.at(1)?.getText();
+                if (name !== undefined && value !== undefined) {
+                    moreInfo[name] = value;
+                }
+            }
+            catch (e) {
+                if (e.name === 'StaleElementReferenceError') {
+                    continue;
+                }
+                throw e;
             }
         }
         return moreInfo;