@redhat-developer/page-objects 1.0.0

package/out/components/workbench/Workbench.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workbench = void 0;
+const AbstractElement_1 = require("../AbstractElement");
+const selenium_webdriver_1 = require("selenium-webdriver");
+const TitleBar_1 = require("../menu/TitleBar");
+const SideBarView_1 = require("../sidebar/SideBarView");
+const ActivityBar_1 = require("../activityBar/ActivityBar");
+const StatusBar_1 = require("../statusBar/StatusBar");
+const EditorView_1 = require("../editor/EditorView");
+const BottomBarPanel_1 = require("../bottomBar/BottomBarPanel");
+const Notification_1 = require("./Notification");
+const QuickOpenBox_1 = require("./input/QuickOpenBox");
+const SettingsEditor_1 = require("../editor/SettingsEditor");
+const InputBox_1 = require("./input/InputBox");
+/**
+ * Handler for general workbench related actions
+ */
+class Workbench extends AbstractElement_1.AbstractElement {
+    constructor() {
+        super(Workbench.locators.Workbench.constructor);
+    }
+    /**
+     * Get a title bar handle
+     */
+    getTitleBar() {
+        return new TitleBar_1.TitleBar();
+    }
+    /**
+     * Get a side bar handle
+     */
+    getSideBar() {
+        return new SideBarView_1.SideBarView();
+    }
+    /**
+     * Get an activity bar handle
+     */
+    getActivityBar() {
+        return new ActivityBar_1.ActivityBar();
+    }
+    /**
+     * Get a status bar handle
+     */
+    getStatusBar() {
+        return new StatusBar_1.StatusBar();
+    }
+    /**
+     * Get a bottom bar handle
+     */
+    getBottomBar() {
+        return new BottomBarPanel_1.BottomBarPanel();
+    }
+    /**
+     * Get a handle for the editor view
+     */
+    getEditorView() {
+        return new EditorView_1.EditorView();
+    }
+    /**
+     * Get all standalone notifications (notifications outside the notifications center)
+     * @returns Promise resolving to array of Notification objects
+     */
+    async getNotifications() {
+        const notifications = [];
+        let container;
+        try {
+            container = await this.findElement(Workbench.locators.Workbench.notificationContainer);
+        }
+        catch (err) {
+            return [];
+        }
+        const elements = await container.findElements(Workbench.locators.Workbench.notificationItem);
+        for (const element of elements) {
+            notifications.push(await new Notification_1.StandaloneNotification(element).wait());
+        }
+        return notifications;
+    }
+    /**
+     * Opens the notifications center
+     * @returns Promise resolving to NotificationsCenter object
+     */
+    async openNotificationsCenter() {
+        return await new StatusBar_1.StatusBar().openNotificationsCenter();
+    }
+    /**
+     * Opens the settings editor
+     *
+     * @returns promise that resolves to a SettingsEditor instance
+     */
+    async openSettings() {
+        await this.executeCommand('open user settings');
+        await new EditorView_1.EditorView().openEditor('Settings');
+        await Workbench.driver.wait(selenium_webdriver_1.until.elementLocated(Workbench.locators.Editor.constructor));
+        await new Promise((res) => setTimeout(res, 500));
+        return new SettingsEditor_1.SettingsEditor();
+    }
+    /**
+     * Open the VS Code command line prompt
+     * @returns Promise resolving to InputBox (vscode 1.44+) or QuickOpenBox (vscode up to 1.43) object
+     */
+    async openCommandPrompt() {
+        const webview = await new EditorView_1.EditorView().findElements(EditorView_1.EditorView.locators.EditorView.webView);
+        if (webview.length > 0) {
+            const tab = await new EditorView_1.EditorView().getActiveTab();
+            if (tab) {
+                await tab.sendKeys(selenium_webdriver_1.Key.F1);
+                return await InputBox_1.InputBox.create();
+            }
+        }
+        const driver = this.getDriver();
+        await driver.actions().keyDown(Workbench.ctlKey).keyDown(selenium_webdriver_1.Key.SHIFT).sendKeys('p').perform();
+        if (Workbench.versionInfo.version >= '1.44.0') {
+            return await InputBox_1.InputBox.create();
+        }
+        return await QuickOpenBox_1.QuickOpenBox.create();
+    }
+    /**
+     * Open the command prompt, type in a command and execute
+     * @param command text of the command to be executed
+     * @returns Promise resolving when the command prompt is confirmed
+     */
+    async executeCommand(command) {
+        const prompt = await this.openCommandPrompt();
+        await prompt.setText(`>${command}`);
+        const quickPicks = await Promise.all((await prompt.getQuickPicks()).map(item => item.getLabel()));
+        if (quickPicks.includes(command)) {
+            await prompt.selectQuickPick(command);
+        }
+        else {
+            await prompt.confirm();
+        }
+    }
+}
+exports.Workbench = Workbench;
+//# sourceMappingURL=Workbench.js.map

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

@@ -0,0 +1,107 @@
+import { AbstractElement } from "../../AbstractElement";
+/**
+ * Abstract page object for input fields
+ */
+export declare abstract class Input extends AbstractElement {
+    /**
+     * Get current text of the input field
+     * @returns Promise resolving to text of the input field
+     */
+    getText(): Promise<string>;
+    /**
+     * Set (by selecting all and typing) text in the input field
+     * @param text text to set into the input field
+     * @returns Promise resolving when the text is typed in
+     */
+    setText(text: string): Promise<void>;
+    /**
+     * Get the placeholder text for the input field
+     * @returns Promise resolving to input placeholder
+     */
+    getPlaceHolder(): Promise<string>;
+    /**
+     * Confirm the input field by pressing Enter
+     * @returns Promise resolving when the input is confirmed
+     */
+    confirm(): Promise<void>;
+    /**
+     * Cancel the input field by pressing Escape
+     * @returns Promise resolving when the input is cancelled
+     */
+    cancel(): Promise<void>;
+    /**
+     * Clear the inpur field
+     * @returns Promise resolving when the field is cleared
+     */
+    clear(): Promise<void>;
+    /**
+     * Select (click) a quick pick option. Will scroll through the quick picks to find the item.
+     * Search for the item can be done by its text, or index in the quick pick menu.
+     * Note that scrolling does not affect the item's index, but it will
+     * replace some items in the DOM (thus they become unreachable)
+     *
+     * @param indexOrText index (number) or text (string) of the item to search by
+     * @returns Promise resolving when the given quick pick is selected
+     */
+    selectQuickPick(indexOrText: string | number): Promise<void>;
+    /**
+     * Select/Deselect all quick picks using the 'select all' checkbox
+     * If multiple selection is disabled on the input box, no action is performed
+     *
+     * @param state true to select all, false to deselect all
+     * @returns Promise resolving when all quick picks have been toggled to desired state
+     */
+    toggleAllQuickPicks(state: boolean): Promise<void>;
+    /**
+     * Scroll through the quick picks to find an item by the name or index
+     * @param indexOrText index (number) or text (string) of the item to search by
+     * @returns Promise resolvnig to QuickPickItem if found, to undefined otherwise
+     */
+    findQuickPick(indexOrText: string | number): Promise<QuickPickItem | undefined>;
+    /**
+     * Retrieve the title of an input box if it has one
+     * @returns Promise resolving to title if it exists, to undefined otherwise
+     */
+    getTitle(): Promise<string | undefined>;
+    /**
+     * Click on the back button if it exists
+     * @returns Promise resolving to true if a button was clicked, to false otherwise
+     */
+    back(): Promise<boolean>;
+    /**
+     * Find whether the input box has an active progress bar
+     * @returns Promise resolving to true/false
+     */
+    abstract hasProgress(): Promise<boolean>;
+    /**
+     * Retrieve the quick pick items currently available in the DOM
+     * (visible in the quick pick menu)
+     * @returns Promise resolving to array of QuickPickItem objects
+     */
+    abstract getQuickPicks(): Promise<QuickPickItem[]>;
+    private resetPosition;
+}
+/**
+ * Page object representing a quick pick option in the input box
+ */
+export declare class QuickPickItem extends AbstractElement {
+    private index;
+    constructor(index: number, input: Input, isMultiSelect?: boolean);
+    /**
+     * Get the label of the quick pick item
+     */
+    getLabel(): Promise<string>;
+    /**
+     * Get the description of the quick pick item
+     */
+    getDescription(): Promise<string | undefined>;
+    /**
+     * Get the index of the quick pick item
+     */
+    getIndex(): number;
+    /**
+     * Select (click) the quick pick item
+     * @returns Promise resolving when the item has been clicked
+     */
+    select(): Promise<void>;
+}

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

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickPickItem = exports.Input = void 0;
+const AbstractElement_1 = require("../../AbstractElement");
+const selenium_webdriver_1 = require("selenium-webdriver");
+const __1 = require("../../..");
+/**
+ * Abstract page object for input fields
+ */
+class Input extends AbstractElement_1.AbstractElement {
+    /**
+     * Get current text of the input field
+     * @returns Promise resolving to text of the input field
+     */
+    async getText() {
+        const input = await this.findElement(Input.locators.Input.inputBox)
+            .findElement(Input.locators.Input.input);
+        return await input.getAttribute('value');
+    }
+    /**
+     * Set (by selecting all and typing) text in the input field
+     * @param text text to set into the input field
+     * @returns Promise resolving when the text is typed in
+     */
+    async setText(text) {
+        const clipboard = (await import('clipboardy')).default;
+        let originalClipboard = '';
+        try {
+            originalClipboard = clipboard.readSync();
+        }
+        catch (error) {
+            // workaround issue https://github.com/redhat-developer/vscode-extension-tester/issues/835
+            // do not fail if clipboard is empty
+        }
+        const input = await this.findElement(Input.locators.Input.inputBox)
+            .findElement(Input.locators.Input.input);
+        await this.clear();
+        await new Promise(res => setTimeout(res, 200));
+        if ((await this.getText()).length > 0) {
+            await input.sendKeys(selenium_webdriver_1.Key.END, selenium_webdriver_1.Key.chord(selenium_webdriver_1.Key.SHIFT, selenium_webdriver_1.Key.HOME));
+        }
+        await input.sendKeys(text);
+        // fallback to clipboard if the text gets malformed
+        if ((await this.getText()) !== text) {
+            await clipboard.write(text);
+            await input.sendKeys(selenium_webdriver_1.Key.END, selenium_webdriver_1.Key.chord(selenium_webdriver_1.Key.SHIFT, selenium_webdriver_1.Key.HOME));
+            await input.sendKeys(selenium_webdriver_1.Key.chord(Input.ctlKey, 'v'));
+            if (originalClipboard.length > 0) {
+                clipboard.writeSync(originalClipboard);
+            }
+        }
+    }
+    /**
+     * Get the placeholder text for the input field
+     * @returns Promise resolving to input placeholder
+     */
+    async getPlaceHolder() {
+        return await this.findElement(Input.locators.Input.inputBox)
+            .findElement(Input.locators.Input.input).getAttribute('placeholder');
+    }
+    /**
+     * Confirm the input field by pressing Enter
+     * @returns Promise resolving when the input is confirmed
+     */
+    async confirm() {
+        const input = await this.findElement(Input.locators.Input.inputBox)
+            .findElement(Input.locators.Input.input);
+        await input.click();
+        await input.sendKeys(selenium_webdriver_1.Key.ENTER);
+    }
+    /**
+     * Cancel the input field by pressing Escape
+     * @returns Promise resolving when the input is cancelled
+     */
+    async cancel() {
+        const input = await this.findElement(Input.locators.Input.inputBox)
+            .findElement(Input.locators.Input.input);
+        await input.sendKeys(selenium_webdriver_1.Key.ESCAPE);
+    }
+    /**
+     * Clear the inpur field
+     * @returns Promise resolving when the field is cleared
+     */
+    async clear() {
+        const input = await this.findElement(Input.locators.Input.inputBox)
+            .findElement(Input.locators.Input.input);
+        // VS Code 1.40 breaks the default clear method, use select all + back space instead
+        await input.sendKeys(selenium_webdriver_1.Key.END, selenium_webdriver_1.Key.chord(selenium_webdriver_1.Key.SHIFT, selenium_webdriver_1.Key.HOME), selenium_webdriver_1.Key.BACK_SPACE);
+        if ((await input.getAttribute('value')).length > 0) {
+            await input.sendKeys(selenium_webdriver_1.Key.END, selenium_webdriver_1.Key.chord(selenium_webdriver_1.Key.SHIFT, selenium_webdriver_1.Key.HOME), selenium_webdriver_1.Key.BACK_SPACE);
+        }
+    }
+    /**
+     * Select (click) a quick pick option. Will scroll through the quick picks to find the item.
+     * Search for the item can be done by its text, or index in the quick pick menu.
+     * Note that scrolling does not affect the item's index, but it will
+     * replace some items in the DOM (thus they become unreachable)
+     *
+     * @param indexOrText index (number) or text (string) of the item to search by
+     * @returns Promise resolving when the given quick pick is selected
+     */
+    async selectQuickPick(indexOrText) {
+        const pick = await this.findQuickPick(indexOrText);
+        if (pick) {
+            await pick.select();
+        }
+        else {
+            await this.resetPosition();
+        }
+    }
+    /**
+     * Select/Deselect all quick picks using the 'select all' checkbox
+     * If multiple selection is disabled on the input box, no action is performed
+     *
+     * @param state true to select all, false to deselect all
+     * @returns Promise resolving when all quick picks have been toggled to desired state
+     */
+    async toggleAllQuickPicks(state) {
+        const checkboxes = await this.findElements(Input.locators.Input.quickPickSelectAll);
+        if (!checkboxes) {
+            return;
+        }
+        if (!await checkboxes[0].isSelected()) {
+            await checkboxes[0].click();
+        }
+        if (state === false) {
+            await checkboxes[0].click();
+        }
+    }
+    /**
+     * Scroll through the quick picks to find an item by the name or index
+     * @param indexOrText index (number) or text (string) of the item to search by
+     * @returns Promise resolvnig to QuickPickItem if found, to undefined otherwise
+     */
+    async findQuickPick(indexOrText) {
+        const input = await this.findElement(Input.locators.Input.inputBox)
+            .findElement(Input.locators.Input.input);
+        const first = await this.findElements(Input.locators.Input.quickPickPosition(1));
+        if (first.length < 1) {
+            await this.resetPosition();
+        }
+        let endReached = false;
+        while (!endReached) {
+            const picks = await this.getQuickPicks();
+            for (const pick of picks) {
+                const lastRow = await this.findElements(Input.locators.DefaultTreeSection.lastRow);
+                if (lastRow.length > 0) {
+                    endReached = true;
+                }
+                else if (await pick.getAttribute('aria-posinset') === await pick.getAttribute('aria-setsize')) {
+                    endReached = true;
+                }
+                if (typeof indexOrText === 'string') {
+                    const text = await pick.getLabel();
+                    if (text.indexOf(indexOrText) > -1) {
+                        return pick;
+                    }
+                }
+                else if (indexOrText === pick.getIndex()) {
+                    return pick;
+                }
+            }
+            if (!endReached) {
+                await input.sendKeys(selenium_webdriver_1.Key.PAGE_DOWN);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Retrieve the title of an input box if it has one
+     * @returns Promise resolving to title if it exists, to undefined otherwise
+     */
+    async getTitle() {
+        const titleBar = await this.findElements(Input.locators.Input.titleBar);
+        if (titleBar.length > 0 && await titleBar[0].isDisplayed()) {
+            return (await titleBar[0].findElement(Input.locators.Input.title)).getText();
+        }
+    }
+    /**
+     * Click on the back button if it exists
+     * @returns Promise resolving to true if a button was clicked, to false otherwise
+     */
+    async back() {
+        const titleBar = await this.findElements(Input.locators.Input.titleBar);
+        if (titleBar.length > 0 && await titleBar[0].isDisplayed()) {
+            const backBtn = await titleBar[0].findElements(Input.locators.Input.backButton);
+            if (backBtn.length > 0 && await backBtn[0].isEnabled()) {
+                await backBtn[0].click();
+                return true;
+            }
+        }
+        return false;
+    }
+    async resetPosition() {
+        const text = await this.getText();
+        await this.clear();
+        await this.setText(text);
+    }
+}
+exports.Input = Input;
+/**
+ * Page object representing a quick pick option in the input box
+ */
+class QuickPickItem extends AbstractElement_1.AbstractElement {
+    index;
+    constructor(index, input, isMultiSelect = false) {
+        let locator = Input.locators.Input.quickPickIndex(index);
+        if (input instanceof __1.QuickOpenBox) {
+            locator = Input.locators.Input.quickPickPosition(index);
+        }
+        if (isMultiSelect) {
+            locator = Input.locators.Input.multiSelectIndex(index);
+        }
+        super(locator, input);
+        this.index = index;
+    }
+    /**
+     * Get the label of the quick pick item
+     */
+    async getLabel() {
+        return await this.findElement(Input.locators.Input.quickPickLabel).getText();
+    }
+    /**
+     * Get the description of the quick pick item
+     */
+    async getDescription() {
+        try {
+            return await this.findElement(Input.locators.Input.quickPickDescription).getText();
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    /**
+     * Get the index of the quick pick item
+     */
+    getIndex() {
+        return this.index;
+    }
+    /**
+     * Select (click) the quick pick item
+     * @returns Promise resolving when the item has been clicked
+     */
+    async select() {
+        await this.click();
+    }
+}
+exports.QuickPickItem = QuickPickItem;
+//# sourceMappingURL=Input.js.map

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

@@ -0,0 +1,30 @@
+import { Input, QuickPickItem } from "../../..";
+/**
+ * Plain input box variation of the input page object
+ */
+export declare class InputBox extends Input {
+    constructor();
+    /**
+     * Construct a new InputBox instance after waiting for its underlying element to exist
+     * Use when an input box is scheduled to appear.
+     * @param timeout max time to wait in milliseconds, default 5000
+     */
+    static create(timeout?: number): Promise<InputBox>;
+    /**
+     * Get the message below the input field
+     */
+    getMessage(): Promise<string>;
+    hasProgress(): Promise<boolean>;
+    getQuickPicks(): Promise<QuickPickItem[]>;
+    getCheckboxes(): Promise<QuickPickItem[]>;
+    /**
+     * Find whether the input is showing an error
+     * @returns Promise resolving to notification message
+     */
+    hasError(): Promise<boolean>;
+    /**
+     * Check if the input field is masked (input type password)
+     * @returns Promise resolving to notification message
+     */
+    isPassword(): Promise<boolean>;
+}

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputBox = void 0;
+const __1 = require("../../..");
+const selenium_webdriver_1 = require("selenium-webdriver");
+/**
+ * Plain input box variation of the input page object
+ */
+class InputBox extends __1.Input {
+    constructor() {
+        super(InputBox.locators.InputBox.constructor, InputBox.locators.Workbench.constructor);
+    }
+    /**
+     * Construct a new InputBox instance after waiting for its underlying element to exist
+     * Use when an input box is scheduled to appear.
+     * @param timeout max time to wait in milliseconds, default 5000
+     */
+    static async create(timeout = 5000) {
+        await InputBox.driver.wait(selenium_webdriver_1.until.elementLocated(InputBox.locators.InputBox.constructor), timeout);
+        return new InputBox().wait();
+    }
+    /**
+     * Get the message below the input field
+     */
+    async getMessage() {
+        return await this.findElement(InputBox.locators.InputBox.message).getText();
+    }
+    async hasProgress() {
+        const klass = await this.findElement(InputBox.locators.InputBox.progress)
+            .getAttribute('class');
+        return klass.indexOf('done') < 0;
+    }
+    async getQuickPicks() {
+        const picks = [];
+        const elements = await this.findElement(InputBox.locators.InputBox.quickList)
+            .findElement(InputBox.locators.InputBox.rows)
+            .findElements(InputBox.locators.InputBox.row);
+        for (const element of elements) {
+            if (await element.isDisplayed()) {
+                picks.push(await new __1.QuickPickItem(+await element.getAttribute('data-index'), this).wait());
+            }
+        }
+        return picks;
+    }
+    async getCheckboxes() {
+        const picks = [];
+        const elements = await this.findElement(InputBox.locators.InputBox.quickList)
+            .findElement(InputBox.locators.InputBox.rows)
+            .findElements(InputBox.locators.InputBox.row);
+        for (const element of elements) {
+            if (await element.isDisplayed()) {
+                picks.push(await new __1.QuickPickItem(+await element.getAttribute('data-index'), this, true).wait());
+            }
+        }
+        return picks;
+    }
+    /**
+     * Find whether the input is showing an error
+     * @returns Promise resolving to notification message
+     */
+    async hasError() {
+        const klass = await this.findElement(InputBox.locators.Input.inputBox).getAttribute('class');
+        return klass.indexOf('error') > -1;
+    }
+    /**
+     * Check if the input field is masked (input type password)
+     * @returns Promise resolving to notification message
+     */
+    async isPassword() {
+        const input = await this.findElement(InputBox.locators.Input.input);
+        return await input.getAttribute('type') === 'password';
+    }
+}
+exports.InputBox = InputBox;
+//# sourceMappingURL=InputBox.js.map

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

@@ -0,0 +1,15 @@
+import { Input, QuickPickItem } from "../../..";
+/**
+ * @deprecated as of VS Code 1.44.0, quick open box has been replaced with input box
+ * The quick open box variation of the input
+ */
+export declare class QuickOpenBox extends Input {
+    constructor();
+    /**
+     * Construct a new QuickOpenBox instance after waiting for its underlying element to exist
+     * Use when a quick open box is scheduled to appear.
+     */
+    static create(): Promise<QuickOpenBox>;
+    hasProgress(): Promise<boolean>;
+    getQuickPicks(): Promise<QuickPickItem[]>;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickOpenBox = void 0;
+const __1 = require("../../..");
+const selenium_webdriver_1 = require("selenium-webdriver");
+/**
+ * @deprecated as of VS Code 1.44.0, quick open box has been replaced with input box
+ * The quick open box variation of the input
+ */
+class QuickOpenBox extends __1.Input {
+    constructor() {
+        super(QuickOpenBox.locators.QuickOpenBox.constructor, QuickOpenBox.locators.Workbench.constructor);
+    }
+    /**
+     * Construct a new QuickOpenBox instance after waiting for its underlying element to exist
+     * 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));
+        return new QuickOpenBox().wait();
+    }
+    async hasProgress() {
+        const klass = await this.findElement(QuickOpenBox.locators.QuickOpenBox.progress)
+            .getAttribute('class');
+        return klass.indexOf('done') < 0;
+    }
+    async getQuickPicks() {
+        const picks = [];
+        const tree = await this.getDriver().wait(selenium_webdriver_1.until.elementLocated(QuickOpenBox.locators.QuickOpenBox.quickList), 1000);
+        const elements = await tree.findElements(QuickOpenBox.locators.QuickOpenBox.row);
+        for (const element of elements) {
+            const index = +await element.getAttribute('aria-posinset');
+            if (await element.isDisplayed()) {
+                picks.push(await new __1.QuickPickItem(index, this).wait());
+            }
+        }
+        return picks;
+    }
+}
+exports.QuickOpenBox = QuickOpenBox;
+//# sourceMappingURL=QuickOpenBox.js.map

package/out/conditions/WaitForAttribute.d.ts

@@ -0,0 +1,8 @@
+import { WebElement } from "selenium-webdriver";
+/**
+ * Condition to wait until an element's attribute has a specified value
+ * @param element webelement to check
+ * @param attribute attribute to check
+ * @param value value to wait for the attribute to have
+ */
+export declare function waitForAttributeValue(element: WebElement, attribute: string, value: string): () => Promise<boolean>;

package/out/conditions/WaitForAttribute.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForAttributeValue = void 0;
+/**
+ * Condition to wait until an element's attribute has a specified value
+ * @param element webelement to check
+ * @param attribute attribute to check
+ * @param value value to wait for the attribute to have
+ */
+function waitForAttributeValue(element, attribute, value) {
+    return async () => {
+        const result = await element.getAttribute(attribute);
+        return result === value;
+    };
+}
+exports.waitForAttributeValue = waitForAttributeValue;
+//# sourceMappingURL=WaitForAttribute.js.map

package/out/errors/NullAttributeError.d.ts

@@ -0,0 +1,3 @@
+export declare class NullAttributeError extends Error {
+    constructor(message?: string);
+}