@redhat-developer/page-objects 1.21.0 → 1.23.0

package/README.md

@@ -1,9 +1,64 @@
 <h1 align="center">
-  <img alt="ExTester for Visual Studio Code" width="75%" height="75%" src="../../icons/logo-text-side.png">
+  <img alt="ExTester for Visual Studio Code" width="75%" src="https://raw.githubusercontent.com/redhat-developer/vscode-extension-tester/main/icons/logo-text-side.png">
 </h1>
 
 <h2 align="center">Page Objects</h2>
 
-<p align="center">
-Page Object API implementation for a VS Code editor used by <a href="https://github.com/redhat-developer/vscode-extension-tester">ExTester</a> framework.</br>📄 <a href="https://github.com/redhat-developer/vscode-extension-tester/wiki/Page-Object-APIs">Documentation</a>
-</p>
+<p align="center">Page Object API for the Visual Studio Code UI, used by the <a href="https://github.com/redhat-developer/vscode-extension-tester">ExTester</a> framework.</p>
+
+## What it is
+
+Page objects wrap the parts of the VS Code workbench in classes with meaningful methods, so a test can say `new ActivityBar().getViewControl('Explorer')` instead of searching the DOM. This package contains:
+
+- Page object classes for the activity bar, side bar views and tree sections, editors (text, diff, settings, custom and web view), the bottom panel (problems, output, terminal and debug console), the status bar, title bar and menus, dialogs, notifications and the debug views.
+- `AbstractElement`, the base class every page object extends, including your own custom ones.
+- `LocatorLoader` and `mergeLocators`, which assemble the locator set for the VS Code version under test from [`@redhat-developer/locators`](https://www.npmjs.com/package/@redhat-developer/locators) and an optional custom contribution.
+- `WaitHelper`, timeout constants and a re-export of `selenium-webdriver`, so one import gives you `WebDriver`, `By`, `Key` and the rest.
+
+## Installation
+
+[`vscode-extension-tester`](https://www.npmjs.com/package/vscode-extension-tester) depends on this package and re-exports everything from it. In an ExTester project you import page objects from `vscode-extension-tester` and never install this package directly:
+
+```typescript
+import { ActivityBar, EditorView, TextEditor } from "vscode-extension-tester";
+```
+
+Install it on its own only if you drive a VS Code instance with your own WebDriver setup:
+
+```bash
+npm install --save-dev @redhat-developer/page-objects @redhat-developer/locators selenium-webdriver
+```
+
+Peer dependencies: `selenium-webdriver ^4.48.0` and `typescript >= 4.6.2`.
+
+## Standalone usage
+
+The page objects must be initialised once before the first one is created. ExTester does this for you when `VSBrowser` starts; without ExTester, call `initPageObjects` yourself:
+
+```typescript
+import { getLocatorsPath } from "@redhat-developer/locators";
+import { initPageObjects } from "@redhat-developer/page-objects";
+
+initPageObjects(
+  "1.134.0", // VS Code version under test
+  "1.37.0", // version of the base locator set
+  getLocatorsPath(), // folder with the compiled locators
+  driver, // your selenium-webdriver WebDriver attached to VS Code
+  browserName, // name of the browser the page objects run in
+  "./out/test/pageObjects/locators.js", // optional custom locator contribution
+);
+```
+
+## Documentation
+
+- [Page Object Reference](https://redhat-developer.github.io/vscode-extension-tester/objects/) — every page object with examples
+- [Custom Page Objects](https://redhat-developer.github.io/vscode-extension-tester/guides/custom-page-objects/) — extend the API for your own extension's UI
+
+## Feedback
+
+- Bugs and feature requests: [open an issue](https://github.com/redhat-developer/vscode-extension-tester/issues/new/choose)
+- Questions: [GitHub Discussions](https://github.com/redhat-developer/vscode-extension-tester/discussions)
+
+## License
+
+[Apache License 2.0](https://github.com/redhat-developer/vscode-extension-tester/blob/main/LICENSE)

package/out/components/AbstractElement.d.ts

@@ -53,6 +53,14 @@ export declare abstract class AbstractElement extends WebElement {
      */
     constructor(base: Locator | WebElement, enclosingItem?: WebElement | Locator);
     isEnabled(): Promise<boolean>;
+    /**
+     * Click the element, recovering when a transient overlay intercepts the
+     * click. VS Code renders hovers/tooltips as DOM overlays that appear while
+     * the WebDriver pointer rests on the last click point and never auto-hide,
+     * so a plain W3C click deadlocks on its pre-dispatch hit-test. See
+     * {@link WaitHelper.clickThroughInterception} for the recovery strategy.
+     */
+    click(): Promise<void>;
     isSelected(): Promise<boolean>;
     /**
      * Wait for the element to become visible

package/out/components/AbstractElement.js

@@ -76,6 +76,16 @@ class AbstractElement extends selenium_webdriver_1.WebElement {
     async isEnabled() {
         return (await super.isEnabled()) && (await AbstractElement.locators.AbstractElement.enabled(this));
     }
+    /**
+     * Click the element, recovering when a transient overlay intercepts the
+     * click. VS Code renders hovers/tooltips as DOM overlays that appear while
+     * the WebDriver pointer rests on the last click point and never auto-hide,
+     * so a plain W3C click deadlocks on its pre-dispatch hit-test. See
+     * {@link WaitHelper.clickThroughInterception} for the recovery strategy.
+     */
+    async click() {
+        await AbstractElement.waitHelper.clickThroughInterception(this, () => super.click());
+    }
     async isSelected() {
         return (await super.isSelected()) && (await AbstractElement.locators.AbstractElement.selected(this));
     }
@@ -160,7 +170,8 @@ class AbstractElement extends selenium_webdriver_1.WebElement {
             catch (err) {
                 const isRecoverable = err.name === 'StaleElementReferenceError' ||
                     err.name === 'ElementNotInteractableError' ||
-                    /element.*(detached|not interactable)/i.test(err.message);
+                    err.name === 'ElementClickInterceptedError' ||
+                    /element.*(detached|not interactable|click intercepted)/i.test(err.message);
                 if (isRecoverable && attempt < maxRetries) {
                     try {
                         recoveredElement = await this.reinitialize();

package/out/components/ElementWithContextMenu.d.ts

@@ -24,4 +24,15 @@ export declare abstract class ElementWithContextMenu extends AbstractElement {
      * Open context menu on the element
      */
     openContextMenu(): Promise<ContextMenu>;
+    /**
+     * Since VS Code ~1.133 some context menus (notably the text editor's) render
+     * inside an open shadow root on a `.shadow-root-host` element attached
+     * directly to the workbench, instead of the document-level `.context-view`
+     * container. Which shape a given install uses is not strictly version-bound,
+     * so poll for either: resolve the menu from the shadow root when it appears,
+     * or return undefined as soon as the legacy container shows up (or the
+     * timeout runs out) so the caller can take the regular `.context-view` path.
+     */
+    protected waitForShadowRootMenu(timeout?: number): Promise<ContextMenu | undefined>;
+    private menuContainerInShadowRoot;
 }

package/out/components/ElementWithContextMenu.js

@@ -28,26 +28,74 @@ class ElementWithContextMenu extends AbstractElement_1.AbstractElement {
      * Open context menu on the element
      */
     async openContextMenu() {
-        const workbench = await this.getDriver().findElement(ElementWithContextMenu.locators.Workbench.constructor);
-        const menus = await workbench.findElements(ElementWithContextMenu.locators.ContextMenu.contextView);
-        if (menus.length < 1) {
-            await this.getDriver().actions().contextClick(this).perform();
-            await this.getDriver().wait(selenium_webdriver_1.until.elementLocated(ElementWithContextMenu.locators.ContextMenu.contextView), 2000);
+        return await this.withRecovery(async (self) => {
+            const workbench = await self.getDriver().findElement(ElementWithContextMenu.locators.Workbench.constructor);
+            const menus = await workbench.findElements(ElementWithContextMenu.locators.ContextMenu.contextView);
+            if (menus.length < 1) {
+                await self.getDriver().actions().contextClick(self).perform();
+                await self.getDriver().wait(selenium_webdriver_1.until.elementLocated(ElementWithContextMenu.locators.ContextMenu.contextView), 2000);
+                return new __1.ContextMenu(workbench).wait();
+            }
+            else if ((await workbench.findElements(ElementWithContextMenu.locators.ContextMenu.viewBlock)).length > 0) {
+                await self.getDriver().actions().contextClick(self).perform();
+                try {
+                    await self.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(self), 1000);
+                }
+                catch (err) {
+                    if (!(err instanceof selenium_webdriver_1.error.StaleElementReferenceError)) {
+                        throw err;
+                    }
+                }
+            }
+            await self.getDriver().actions().contextClick(self).perform();
             return new __1.ContextMenu(workbench).wait();
-        }
-        else if ((await workbench.findElements(ElementWithContextMenu.locators.ContextMenu.viewBlock)).length > 0) {
-            await this.getDriver().actions().contextClick(this).perform();
-            try {
-                await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this), 1000);
+        });
+    }
+    /**
+     * Since VS Code ~1.133 some context menus (notably the text editor's) render
+     * inside an open shadow root on a `.shadow-root-host` element attached
+     * directly to the workbench, instead of the document-level `.context-view`
+     * container. Which shape a given install uses is not strictly version-bound,
+     * so poll for either: resolve the menu from the shadow root when it appears,
+     * or return undefined as soon as the legacy container shows up (or the
+     * timeout runs out) so the caller can take the regular `.context-view` path.
+     */
+    async waitForShadowRootMenu(timeout = 2000) {
+        const driver = this.getDriver();
+        const end = Date.now() + timeout;
+        while (Date.now() < end) {
+            const hosts = await driver.findElements(ElementWithContextMenu.locators.ContextMenu.shadowRootHost);
+            for (const host of hosts) {
+                try {
+                    const container = await this.menuContainerInShadowRoot(host);
+                    if (container && (await container.isDisplayed())) {
+                        return await new __1.ContextMenu(host, container).wait();
+                    }
+                }
+                catch (err) {
+                    // the host or menu got removed mid-check - keep polling
+                }
             }
-            catch (err) {
-                if (!(err instanceof selenium_webdriver_1.error.StaleElementReferenceError)) {
-                    throw err;
+            const legacy = await driver.findElements(ElementWithContextMenu.locators.ContextMenu.contextView);
+            for (const view of legacy) {
+                if (await view.isDisplayed().catch(() => false)) {
+                    return undefined;
                 }
             }
+            await new Promise((res) => setTimeout(res, 100));
+        }
+        return undefined;
+    }
+    async menuContainerInShadowRoot(host) {
+        const driver = this.getDriver();
+        const capabilities = await driver.getCapabilities();
+        const chromiumVersion = capabilities.getBrowserVersion();
+        if (chromiumVersion && Number.parseInt(chromiumVersion.split('.')[0]) >= 96) {
+            const shadowRoot = await host.getShadowRoot();
+            const containers = await shadowRoot.findElements(ElementWithContextMenu.locators.ContextMenu.constructor);
+            return containers.length > 0 ? containers[0] : undefined;
         }
-        await this.getDriver().actions().contextClick(this).perform();
-        return new __1.ContextMenu(workbench).wait();
+        return (await driver.executeScript('return arguments[0].shadowRoot ? arguments[0].shadowRoot.querySelector(".monaco-menu-container") : undefined;', host));
     }
 }
 exports.ElementWithContextMenu = ElementWithContextMenu;

package/out/components/WebviewMixin.js

@@ -28,7 +28,9 @@ const AbstractElement_1 = require("./AbstractElement");
 function default_1(Base) {
     return class extends Base {
         /**
-         * Cannot use static element, since this class is unnamed.
+         * Window handle captured once at switchToFrame() time so that switchBack()
+         * always returns to the correct top-level context even when called from
+         * within a nested frame.
          */
         handle;
         /**
@@ -58,25 +60,89 @@ function default_1(Base) {
          * This allows using the findWebElement methods.
          * Note that only elements inside the webview iframe will be accessible.
          * Use the switchBack method to switch to the original context.
+         *
+         * The method polls for both the outer iframe and the inner active-frame to
+         * appear in the DOM under a single shared deadline, so `timeout` is always
+         * honoured regardless of how long each phase takes.  The driver is always
+         * returned to the top-level context before any error is thrown.
+         *
+         * @throws Error when the webview iframe cannot be located within the timeout
          */
         async switchToFrame(timeout = 5000) {
             if (!this.handle) {
                 this.handle = await this.getDriver().getWindowHandle();
             }
-            const view = await this.getViewToSwitchTo();
+            const deadline = Date.now() + timeout;
+            const pollInterval = 200;
+            const minPhase2Budget = Math.min(5000, Math.floor(timeout / 3));
+            // Phase 1 — poll for the outer webview iframe. Stop early to
+            // guarantee at least minPhase2Budget ms for the inner-frame lookup.
+            let view;
+            while (Date.now() < deadline - minPhase2Budget) {
+                try {
+                    view = await this.getViewToSwitchTo();
+                }
+                catch (e) {
+                    if (!(e instanceof selenium_webdriver_1.error.StaleElementReferenceError || e instanceof selenium_webdriver_1.error.NoSuchElementError)) {
+                        throw e;
+                    }
+                }
+                if (view) {
+                    break;
+                }
+                await this.getDriver().sleep(pollInterval);
+            }
             if (!view) {
-                return;
+                throw new Error(`WebviewMixin.switchToFrame: webview iframe was not found within ${timeout}ms. ` +
+                    `The webview may not have been opened, or the locator no longer matches the current VS Code version. ` +
+                    `See https://github.com/redhat-developer/vscode-extension-tester/issues/2450`);
+            }
+            // Phase 2 — switch into the outer iframe, then poll for the inner
+            // active-frame under the remaining budget (at least minPhase2Budget ms).
+            try {
+                await this.getDriver().switchTo().frame(view);
+            }
+            catch (e) {
+                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    throw new Error(`WebviewMixin.switchToFrame: outer iframe became stale during frame switch. ` +
+                        `See https://github.com/redhat-developer/vscode-extension-tester/issues/2450`);
+                }
+                throw e;
+            }
+            let frame;
+            while (Date.now() < deadline) {
+                try {
+                    const frames = await this.getDriver().findElements(AbstractElement_1.AbstractElement.locators.WebView.activeFrame);
+                    if (frames.length > 0) {
+                        frame = frames[0];
+                        break;
+                    }
+                }
+                catch (e) {
+                    if (!(e instanceof selenium_webdriver_1.error.StaleElementReferenceError || e instanceof selenium_webdriver_1.error.NoSuchElementError)) {
+                        await this.getDriver().switchTo().window(this.handle);
+                        throw e;
+                    }
+                }
+                await this.getDriver().sleep(pollInterval);
+            }
+            if (!frame) {
+                // Return to top-level before throwing so callers are not left inside a frame.
+                await this.getDriver().switchTo().window(this.handle);
+                throw new Error(`WebviewMixin.switchToFrame: active-frame iframe was not found within ${timeout}ms. ` +
+                    `The webview content may still be loading. ` +
+                    `See https://github.com/redhat-developer/vscode-extension-tester/issues/2450`);
             }
-            await this.getDriver().switchTo().frame(view);
-            await this.getDriver().wait(selenium_webdriver_1.until.elementLocated(AbstractElement_1.AbstractElement.locators.WebView.activeFrame), timeout);
-            const frame = await this.getDriver().findElement(AbstractElement_1.AbstractElement.locators.WebView.activeFrame);
             await this.getDriver().switchTo().frame(frame);
         }
         /**
-         * Switch the underlying webdriver back to the original window
+         * Switch the underlying webdriver back to the original window.
+         * Uses the handle captured at switchToFrame() time; safe to call even when
+         * the driver context is already at the top level.
          */
         async switchBack() {
             if (!this.handle) {
+                // switchToFrame() was never called — capture and stay at top level
                 this.handle = await this.getDriver().getWindowHandle();
             }
             return await this.getDriver().switchTo().window(this.handle);

package/out/components/activityBar/ViewControl.d.ts

@@ -21,6 +21,11 @@ import { WebElement } from 'selenium-webdriver';
  * Page object representing a view container item in the activity bar
  */
 export declare class ViewControl extends ElementWithContextMenu {
+    /**
+     * Title of this control, cached on the first successful getTitle() call so the
+     * control can be re-located in the activity bar after its element goes stale.
+     */
+    private cachedTitle;
     constructor(element: WebElement, bar: ActivityBar);
     /**
      * Opens the associated view if not already open
@@ -36,4 +41,15 @@ export declare class ViewControl extends ElementWithContextMenu {
      * Returns the title of the associated view
      */
     getTitle(): Promise<string>;
+    /**
+     * Re-locate this control in the activity bar by its cached title.
+     * Used by withRecovery()-based helpers (safeClick, safeGetKlass) when the
+     * stored element reference goes stale, e.g. after the activity bar re-renders.
+     */
+    protected reinitialize(): Promise<this>;
+    /**
+     * Read the CSS class attribute from this element, recovering transparently if
+     * the stored reference has become stale.
+     */
+    private safeGetKlass;
 }

package/out/components/activityBar/ViewControl.js

@@ -25,6 +25,11 @@ const compare_versions_1 = require("compare-versions");
  * Page object representing a view container item in the activity bar
  */
 class ViewControl extends ElementWithContextMenu_1.ElementWithContextMenu {
+    /**
+     * Title of this control, cached on the first successful getTitle() call so the
+     * control can be re-located in the activity bar after its element goes stale.
+     */
+    cachedTitle;
     constructor(element, bar) {
         super(element, bar);
     }
@@ -33,14 +38,19 @@ class ViewControl extends ElementWithContextMenu_1.ElementWithContextMenu {
      * @returns Promise resolving to SideBarView object representing the opened view
      */
     async openView() {
-        // Check whether view is already open
-        const klass = (await this.getAttribute(ViewControl.locators.ViewControl.attribute));
+        // Use safeGetKlass so a stale reference is transparently re-fetched.
+        const klass = await this.safeGetKlass();
         if (klass.indexOf(ViewControl.locators.ViewControl.klass) < 0) {
-            await this.click();
+            await this.safeClick();
             // 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);
+                try {
+                    const newKlass = await this.safeGetKlass();
+                    return newKlass.includes(ViewControl.locators.ViewControl.klass);
+                }
+                catch {
+                    return false;
+                }
             }, { timeout: 2000, pollInterval: 100 });
         }
         const view = await new __1.SideBarView().wait();
@@ -60,9 +70,9 @@ class ViewControl extends ElementWithContextMenu_1.ElementWithContextMenu {
      * @returns Promise resolving when the view closes
      */
     async closeView() {
-        const klass = (await this.getAttribute(ViewControl.locators.ViewControl.attribute));
+        const klass = await this.safeGetKlass();
         if (klass.indexOf(ViewControl.locators.ViewControl.klass) > -1) {
-            await this.click();
+            await this.safeClick();
         }
     }
     /**
@@ -70,7 +80,34 @@ class ViewControl extends ElementWithContextMenu_1.ElementWithContextMenu {
      */
     async getTitle() {
         const badge = await this.findElement(ViewControl.locators.ViewControl.badge);
-        return (await badge.getAttribute('aria-label'));
+        const title = (await badge.getAttribute('aria-label'));
+        this.cachedTitle = title;
+        return title;
+    }
+    /**
+     * Re-locate this control in the activity bar by its cached title.
+     * Used by withRecovery()-based helpers (safeClick, safeGetKlass) when the
+     * stored element reference goes stale, e.g. after the activity bar re-renders.
+     */
+    async reinitialize() {
+        if (!this.cachedTitle) {
+            throw new Error(`ViewControl: element is stale and no cached title is available to re-locate it`);
+        }
+        // getViewControls() always queries live elements, so the new reference is fresh.
+        const fresh = await new __1.ActivityBar().getViewControl(this.cachedTitle);
+        if (!fresh) {
+            throw new Error(`ViewControl: could not re-locate stale element '${this.cachedTitle}' in the activity bar`);
+        }
+        return fresh;
+    }
+    /**
+     * Read the CSS class attribute from this element, recovering transparently if
+     * the stored reference has become stale.
+     */
+    async safeGetKlass() {
+        return await this.withRecovery(async (self) => {
+            return (await self.getAttribute(ViewControl.locators.ViewControl.attribute));
+        });
     }
 }
 exports.ViewControl = ViewControl;

package/out/components/bottomBar/BottomBarPanel.js

@@ -49,7 +49,7 @@ class BottomBarPanel extends AbstractElement_1.AbstractElement {
             }
             else {
                 await this.closePanel();
-                await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this));
+                await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this), 5_000);
             }
         }
     }
@@ -124,16 +124,31 @@ class BottomBarPanel extends AbstractElement_1.AbstractElement {
     }
     async resize(label) {
         await this.toggle(true);
-        let action;
-        try {
-            action = await this.findElement(BottomBarPanel.locators.BottomBarPanel.globalActions).findElement(BottomBarPanel.locators.BottomBarPanel.action(label));
-        }
-        catch (err) {
-            // the panel is already maximized
-        }
-        if (action) {
-            await action.click();
-        }
+        // The resize action button may briefly be non-interactable (or get replaced)
+        // while the panel's open/maximize animation is running — poll the click
+        // instead of failing on the first attempt.
+        await this.getDriver()
+            .wait(async () => {
+            let action;
+            try {
+                action = await this.findElement(BottomBarPanel.locators.BottomBarPanel.globalActions).findElement(BottomBarPanel.locators.BottomBarPanel.action(label));
+            }
+            catch (err) {
+                // the panel is already maximized/restored — the action is absent
+                return true;
+            }
+            try {
+                await action.click();
+                return true;
+            }
+            catch (err) {
+                // not interactable or stale mid-animation — retry
+                return false;
+            }
+        }, 5000, `BottomBarPanel: could not click the '${label}' action`)
+            .catch(() => {
+            // keep previous lenient behavior — resize is best-effort
+        });
     }
     async closePanel() {
         const closeButton = await this.findElement(BottomBarPanel.locators.BottomBarPanel.closeAction);

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

@@ -26,9 +26,17 @@ export declare class ContentAssist extends Menu {
      * until the item is found, or the end is reached
      *
      * @param name name/text to search by
+     * @param timeout overall time budget in ms for the search (default 30000)
      * @returns Promise resolving to ContentAssistItem object if found, undefined otherwise
      */
-    getItem(name: string): Promise<ContentAssistItem | undefined>;
+    getItem(name: string, timeout?: number): Promise<ContentAssistItem | undefined>;
+    /**
+     * Read all currently rendered suggestion rows in a single script call.
+     * Returns the row elements together with their label text, virtual list index
+     * and whether the row is marked as the last element of the list.
+     */
+    private snapshotVisibleRows;
+    private static readonly SNAPSHOT_ROWS_SCRIPT;
     /**
      * Get all visible content assist items
      * @returns Promise resolving to array of ContentAssistItem objects

package/out/components/editor/ContentAssist.js

@@ -31,31 +31,106 @@ class ContentAssist extends __1.Menu {
      * until the item is found, or the end is reached
      *
      * @param name name/text to search by
+     * @param timeout overall time budget in ms for the search (default 30000)
      * @returns Promise resolving to ContentAssistItem object if found, undefined otherwise
      */
-    async getItem(name) {
-        let lastItem = false;
+    async getItem(name, timeout = 30000) {
+        const deadline = Date.now() + timeout;
         const scrollable = await this.findElement(ContentAssist.locators.ContentAssist.itemList);
+        await this.getDriver().wait(async () => {
+            return (await this.isLoaded()) && (await this.findElements(ContentAssist.locators.ContentAssist.itemRow)).length > 0;
+        }, Math.min(10000, Math.max(1000, deadline - Date.now())), 'Content assist item list did not populate');
+        // Scroll back to the top of the list in case it is not there already
         let firstItem = await this.findElements(ContentAssist.locators.ContentAssist.firstItem);
-        while (firstItem.length < 1) {
+        while (firstItem.length < 1 && Date.now() < deadline) {
             await scrollable.sendKeys(selenium_webdriver_1.Key.PAGE_UP, selenium_webdriver_1.Key.NULL);
+            await this.getWaitHelper().sleep(100);
             firstItem = await this.findElements(ContentAssist.locators.ContentAssist.firstItem);
         }
-        while (!lastItem) {
-            const items = await this.getItems();
-            for (const item of items) {
-                if ((await item.getLabel()) === name) {
-                    return item;
+        while (Date.now() < deadline) {
+            let rows;
+            try {
+                rows = await this.snapshotVisibleRows();
+            }
+            catch (err) {
+                if (err instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    // The list re-rendered mid-read — take a fresh snapshot
+                    continue;
                 }
-                lastItem = lastItem || (await item.getAttribute('data-last-element')) === 'true';
+                throw err;
             }
-            if (!lastItem) {
-                await scrollable.sendKeys(selenium_webdriver_1.Key.PAGE_DOWN);
-                // Minimal delay for scroll to render new items
-                await this.getWaitHelper().sleep(100);
+            const match = rows.find((row) => row.label === name);
+            if (match) {
+                try {
+                    return await new ContentAssistItem(match.element, this).wait();
+                }
+                catch (err) {
+                    if (err instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                        continue;
+                    }
+                    throw err;
+                }
+            }
+            if (rows.some((row) => row.last)) {
+                // Reached the end of the list without finding the item
+                return undefined;
             }
+            const maxIndex = rows.reduce((max, row) => Math.max(max, row.index), -1);
+            await scrollable.sendKeys(selenium_webdriver_1.Key.PAGE_DOWN);
+            // Wait for the visible range to actually move instead of sleeping a fixed amount
+            await this.getDriver()
+                .wait(async () => {
+                const next = await this.snapshotVisibleRows().catch(() => undefined);
+                return next !== undefined && (next.some((row) => row.last) || next.reduce((max, row) => Math.max(max, row.index), -1) > maxIndex);
+            }, Math.min(2000, Math.max(200, deadline - Date.now())))
+                .catch(() => {
+                // The list did not move — keep looping, the deadline will end the search
+            });
         }
+        return undefined;
+    }
+    /**
+     * Read all currently rendered suggestion rows in a single script call.
+     * Returns the row elements together with their label text, virtual list index
+     * and whether the row is marked as the last element of the list.
+     */
+    async snapshotVisibleRows() {
+        const container = await this.findElement(ContentAssist.locators.ContentAssist.itemRows);
+        const rowLocator = ContentAssist.locators.ContentAssist.itemRow;
+        const labelLocator = ContentAssist.locators.ContentAssist.itemLabel;
+        const raw = (await this.getDriver().executeScript(ContentAssist.SNAPSHOT_ROWS_SCRIPT, container, rowLocator.using, rowLocator.value, labelLocator.using, labelLocator.value));
+        return raw.map((row) => ({ element: row.element, label: row.label, index: row.index, last: row.last }));
     }
+    static SNAPSHOT_ROWS_SCRIPT = `
+		var container = arguments[0];
+		var rowUsing = arguments[1], rowValue = arguments[2];
+		var labelUsing = arguments[3], labelValue = arguments[4];
+		function findAll(root, using, value) {
+			if (using === 'xpath') {
+				var out = [];
+				var it = document.evaluate(value, root, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+				for (var i = 0; i < it.snapshotLength; i++) { out.push(it.snapshotItem(i)); }
+				return out;
+			}
+			return Array.prototype.slice.call(root.querySelectorAll(value));
+		}
+		function findOne(root, using, value) {
+			if (using === 'xpath') {
+				return document.evaluate(value, root, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+			}
+			return root.querySelector(value);
+		}
+		return findAll(container, rowUsing, rowValue).map(function (row) {
+			var labelEl = findOne(row, labelUsing, labelValue);
+			var label = labelEl ? (labelEl.innerText !== undefined ? labelEl.innerText : labelEl.textContent) : '';
+			return {
+				element: row,
+				label: (label || '').trim(),
+				index: parseInt(row.getAttribute('data-index') || '-1', 10),
+				last: row.getAttribute('data-last-element') === 'true'
+			};
+		});
+	`;
     /**
      * Get all visible content assist items
      * @returns Promise resolving to array of ContentAssistItem objects

package/out/components/editor/CustomEditor.js

@@ -28,7 +28,7 @@ class CustomEditor extends __1.Editor {
      * @returns WebView page object
      */
     getWebView() {
-        return new __1.WebView();
+        return new __1.WebView(this.enclosingItem);
     }
     /**
      * Check if the editor has unsaved changes