@redhat-developer/page-objects 1.0.0

package/out/components/sidebar/scm/NewScmView.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiScmProvider = exports.SingleScmProvider = exports.NewScmView = void 0;
+const ScmView_1 = require("./ScmView");
+const selenium_webdriver_1 = require("selenium-webdriver");
+const ElementWithContextMenu_1 = require("../../ElementWithContextMenu");
+const ViewTitlePart_1 = require("../ViewTitlePart");
+/**
+ * New SCM view for code 1.47 onwards
+ */
+class NewScmView extends ScmView_1.ScmView {
+    async getProviders() {
+        const inputs = await this.findElements(NewScmView.locators.ScmView.inputField);
+        if (inputs.length < 1) {
+            return [];
+        }
+        const providers = await this.findElements(NewScmView.locators.ScmView.multiScmProvider);
+        if (inputs.length === 1 && providers.length < 1) {
+            const element = await this.findElement(NewScmView.locators.ScmView.singleScmProvider);
+            return [await new SingleScmProvider(element, this).wait()];
+        }
+        const elements = await this.findElements(NewScmView.locators.ScmView.multiProviderItem);
+        return await Promise.all(elements.map(async (element) => new MultiScmProvider(element, this).wait()));
+    }
+}
+exports.NewScmView = NewScmView;
+/**
+ * Implementation for a single SCM provider
+ */
+class SingleScmProvider extends ScmView_1.ScmProvider {
+    /**
+     * There is no title available for a single provider
+     */
+    async getTitle() {
+        return '';
+    }
+    /**
+     * No title available for single provider
+     */
+    async getType() {
+        return '';
+    }
+    async takeAction(title) {
+        const view = this.enclosingItem;
+        const titlePart = view.getTitlePart();
+        const elements = await titlePart.findElements(ScmView_1.ScmView.locators.ScmView.action);
+        const buttons = [];
+        for (const element of elements) {
+            const title = await element.getAttribute(ScmView_1.ScmView.locators.ScmView.actionLabel);
+            buttons.push(await new ViewTitlePart_1.TitleActionButton(ScmView_1.ScmView.locators.ScmView.actionConstructor(title), titlePart).wait());
+        }
+        const names = await Promise.all(buttons.map(async (button) => button.getTitle()));
+        const index = names.findIndex(name => name === title);
+        if (index > -1) {
+            await buttons[index].click();
+            return true;
+        }
+        return false;
+    }
+    async openMoreActions() {
+        const view = this.enclosingItem;
+        return await new ScmView_1.MoreAction(view).openContextMenu();
+    }
+    async getChanges(staged = false) {
+        const count = await this.getChangeCount(staged);
+        const elements = [];
+        if (count > 0) {
+            const locator = staged ? ScmView_1.ScmProvider.locators.ScmView.stagedChanges : ScmView_1.ScmProvider.locators.ScmView.changes;
+            const header = await this.findElement(locator);
+            const startIndex = +await header.getAttribute('data-index');
+            const depth = +await header.getAttribute('aria-level') + 1;
+            const items = await this.findElements(NewScmView.locators.ScmView.itemLevel(depth));
+            for (const item of items) {
+                const index = +await item.getAttribute('data-index');
+                if (index > startIndex && index <= startIndex + count) {
+                    elements.push(item);
+                }
+            }
+        }
+        return Promise.all(elements.map(async (element) => new ScmView_1.ScmChange(element, this).wait()));
+    }
+}
+exports.SingleScmProvider = SingleScmProvider;
+/**
+ * Implementation of an SCM provider when multiple providers are available
+ */
+class MultiScmProvider extends ScmView_1.ScmProvider {
+    async takeAction(title) {
+        const actions = await this.findElements(ScmView_1.ScmProvider.locators.ScmView.action);
+        const names = await Promise.all(actions.map(async (action) => await action.getAttribute('title')));
+        const index = names.findIndex(item => item === title);
+        if (index > -1) {
+            await actions[index].click();
+            return true;
+        }
+        return false;
+    }
+    async openMoreActions() {
+        return await new MultiMoreAction(this).openContextMenu();
+    }
+    async commitChanges(message) {
+        const index = +await this.getAttribute('data-index') + 1;
+        const input = await this.enclosingItem.findElement(NewScmView.locators.ScmView.itemIndex(index));
+        await input.clear();
+        await input.sendKeys(message);
+        await input.sendKeys(selenium_webdriver_1.Key.chord(ScmView_1.ScmProvider.ctlKey, selenium_webdriver_1.Key.ENTER));
+    }
+    async getChanges(staged = false) {
+        const count = await this.getChangeCount(staged);
+        const elements = [];
+        if (count > 0) {
+            const index = +await this.getAttribute('data-index');
+            const locator = staged ? ScmView_1.ScmProvider.locators.ScmView.stagedChanges : ScmView_1.ScmProvider.locators.ScmView.changes;
+            const headers = await this.enclosingItem.findElements(locator);
+            let header;
+            for (const item of headers) {
+                if (+await item.getAttribute('data-index') > index) {
+                    header = item;
+                }
+            }
+            if (!header) {
+                return [];
+            }
+            const startIndex = +await header.getAttribute('data-index');
+            const depth = +await header.getAttribute('aria-level') + 1;
+            const items = await this.enclosingItem.findElements(NewScmView.locators.ScmView.itemLevel(depth));
+            for (const item of items) {
+                const index = +await item.getAttribute('data-index');
+                if (index > startIndex && index <= startIndex + count) {
+                    elements.push(item);
+                }
+            }
+        }
+        return await Promise.all(elements.map(async (element) => new ScmView_1.ScmChange(element, this).wait()));
+    }
+    async getChangeCount(staged = false) {
+        const locator = staged ? ScmView_1.ScmProvider.locators.ScmView.stagedChanges : ScmView_1.ScmProvider.locators.ScmView.changes;
+        const rows = await this.enclosingItem.findElements(locator);
+        const index = +await this.getAttribute('data-index');
+        for (const row of rows) {
+            if (+await row.getAttribute('data-index') > index) {
+                const count = await rows[0].findElement(ScmView_1.ScmChange.locators.ScmView.changeCount);
+                return +await count.getText();
+            }
+        }
+        return 0;
+    }
+}
+exports.MultiScmProvider = MultiScmProvider;
+class MultiMoreAction extends ElementWithContextMenu_1.ElementWithContexMenu {
+    constructor(scm) {
+        super(ScmView_1.MoreAction.locators.ScmView.multiMore, scm);
+    }
+}
+//# sourceMappingURL=NewScmView.js.map

package/out/components/sidebar/scm/ScmView.d.ts

@@ -0,0 +1,110 @@
+import { SideBarView } from "../SideBarView";
+import { WebElement } from "selenium-webdriver";
+import { AbstractElement } from "../../AbstractElement";
+import { ContextMenu } from "../../..";
+import { ElementWithContexMenu } from "../../ElementWithContextMenu";
+/**
+ * Page object representing the Source Control view
+ */
+export declare class ScmView extends SideBarView {
+    /**
+     * Get SCM provider (repository) by title
+     * @param title name of the repository
+     * @returns promise resolving to ScmProvider object
+     */
+    getProvider(title?: string): Promise<ScmProvider | undefined>;
+    /**
+     * Get all SCM providers
+     * @returns promise resolving to ScmProvider array
+     */
+    getProviders(): Promise<ScmProvider[]>;
+    /**
+     * Initialize repository in the current folder if no SCM provider is found
+     * @returns true if the action was completed succesfully, false if a provider already exists
+     */
+    initializeRepository(): Promise<boolean>;
+}
+/**
+ * Page object representing a repository in the source control view
+ * Maps roughly to a view section of the source control view
+ */
+export declare class ScmProvider extends AbstractElement {
+    constructor(element: WebElement, view: ScmView);
+    /**
+     * Get title of the scm provider
+     */
+    getTitle(): Promise<string>;
+    /**
+     * Get type of the scm provider (e.g. Git)
+     */
+    getType(): Promise<string>;
+    /**
+     * Find an action button for the SCM provider by title and click it. (e.g 'Commit')
+     * @param title Title of the action button to click
+     * @returns true if the given action could be performed, false if the button doesn't exist
+     */
+    takeAction(title: string): Promise<boolean>;
+    /**
+     * Open a context menu using the 'More Actions...' button
+     * @returns Promise resolving to a ContextMenu object
+     */
+    openMoreActions(): Promise<ContextMenu>;
+    /**
+     * Fill in the message field and send ctrl/cmd + enter to commit the changes
+     * @param message the commit message to use
+     * @returns promise resolving once the keypresses are sent
+     */
+    commitChanges(message: string): Promise<void>;
+    /**
+     * Get page objects for all tree items representing individual changes
+     * @param staged when true, finds staged changes; otherwise finds unstaged changes
+     * @returns promise resolving to ScmChange object array
+     */
+    getChanges(staged?: boolean): Promise<ScmChange[]>;
+    /**
+     * Get the number of changes for a given section
+     * @param staged when true, counts the staged changes, unstaged otherwise
+     * @returns promise resolving to number of changes in the given subsection
+     */
+    getChangeCount(staged?: boolean): Promise<number>;
+}
+/**
+ * Page object representing a SCM change tree item
+ */
+export declare class ScmChange extends ElementWithContexMenu {
+    constructor(row: WebElement, provider: ScmProvider);
+    /**
+     * Get label as a string
+     */
+    getLabel(): Promise<string>;
+    /**
+     * Get description as a string
+     */
+    getDescription(): Promise<string>;
+    /**
+     * Get the status string (e.g. 'Modified')
+     */
+    getStatus(): Promise<string>;
+    /**
+     * Find if the item is expanded
+     * @returns promise resolving to true if change is expanded, to false otherwise
+     */
+    isExpanded(): Promise<boolean>;
+    /**
+     * Expand or collapse a change item if possible, only works for folders in hierarchical view mode
+     * @param expand true to expand the item, false to collapse
+     * @returns promise resolving to true if the item changed state, to false otherwise
+     */
+    toggleExpand(expand: boolean): Promise<boolean>;
+    /**
+     * Find and click an action button available to a given change tree item
+     * @param title title of the action button (e.g 'Stage Changes')
+     * @returns promise resolving to true if the action was performed successfully,
+     * false if the given button does not exist
+     */
+    takeAction(title: string): Promise<boolean>;
+}
+export declare class MoreAction extends ElementWithContexMenu {
+    constructor(scm: ScmProvider | ScmView);
+    openContextMenu(): Promise<ContextMenu>;
+}

package/out/components/sidebar/scm/ScmView.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoreAction = exports.ScmChange = exports.ScmProvider = exports.ScmView = void 0;
+const SideBarView_1 = require("../SideBarView");
+const selenium_webdriver_1 = require("selenium-webdriver");
+const AbstractElement_1 = require("../../AbstractElement");
+const __1 = require("../../..");
+const ElementWithContextMenu_1 = require("../../ElementWithContextMenu");
+/**
+ * Page object representing the Source Control view
+ */
+class ScmView extends SideBarView_1.SideBarView {
+    /**
+     * Get SCM provider (repository) by title
+     * @param title name of the repository
+     * @returns promise resolving to ScmProvider object
+     */
+    async getProvider(title) {
+        const providers = await this.getProviders();
+        if (!title || providers.length === 1) {
+            return providers[0];
+        }
+        const names = await Promise.all(providers.map(async (item) => await item.getTitle()));
+        const index = names.findIndex(name => name === title);
+        return index > -1 ? providers[index] : undefined;
+    }
+    /**
+     * Get all SCM providers
+     * @returns promise resolving to ScmProvider array
+     */
+    async getProviders() {
+        const headers = await this.findElements(ScmView.locators.ScmView.providerHeader);
+        const sections = await Promise.all(headers.map(async (header) => await header.findElement(ScmView.locators.ScmView.providerRelative)));
+        return await Promise.all(sections.map(async (section) => new ScmProvider(section, this)));
+    }
+    /**
+     * Initialize repository in the current folder if no SCM provider is found
+     * @returns true if the action was completed succesfully, false if a provider already exists
+     */
+    async initializeRepository() {
+        const buttons = await this.findElements(ScmView.locators.ScmView.initButton);
+        if (buttons.length > 0) {
+            await buttons[0].click();
+            return true;
+        }
+        return false;
+    }
+}
+exports.ScmView = ScmView;
+/**
+ * Page object representing a repository in the source control view
+ * Maps roughly to a view section of the source control view
+ */
+class ScmProvider extends AbstractElement_1.AbstractElement {
+    constructor(element, view) {
+        super(element, view);
+    }
+    /**
+     * Get title of the scm provider
+     */
+    async getTitle() {
+        return await this.findElement(ScmProvider.locators.ScmView.providerTitle).getAttribute('innerHTML');
+    }
+    /**
+     * Get type of the scm provider (e.g. Git)
+     */
+    async getType() {
+        return await this.findElement(ScmProvider.locators.ScmView.providerType).getAttribute('innerHTML');
+    }
+    /**
+     * Find an action button for the SCM provider by title and click it. (e.g 'Commit')
+     * @param title Title of the action button to click
+     * @returns true if the given action could be performed, false if the button doesn't exist
+     */
+    async takeAction(title) {
+        const header = await this.findElement(ScmProvider.locators.ScmView.providerHeader);
+        let actions = [];
+        if ((await header.getAttribute('class')).indexOf('hidden') > -1) {
+            const view = this.enclosingItem;
+            actions = await view.getTitlePart().getActions();
+        }
+        else {
+            await this.getDriver().actions().move({ origin: this }).perform();
+            actions = await header.findElements(ScmProvider.locators.ScmView.action);
+        }
+        const names = await Promise.all(actions.map(async (action) => await action.getAttribute('title')));
+        const index = names.findIndex(item => item === title);
+        if (index > -1) {
+            await actions[index].click();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Open a context menu using the 'More Actions...' button
+     * @returns Promise resolving to a ContextMenu object
+     */
+    async openMoreActions() {
+        const header = await this.findElement(ScmProvider.locators.ScmView.providerHeader);
+        if ((await header.getAttribute('class')).indexOf('hidden') > -1) {
+            return await new MoreAction(this.enclosingItem).openContextMenu();
+        }
+        else {
+            await this.getDriver().actions().move({ origin: this }).perform();
+            return await new MoreAction(this).openContextMenu();
+        }
+    }
+    /**
+     * Fill in the message field and send ctrl/cmd + enter to commit the changes
+     * @param message the commit message to use
+     * @returns promise resolving once the keypresses are sent
+     */
+    async commitChanges(message) {
+        const input = await this.findElement(ScmProvider.locators.ScmView.inputField);
+        await input.clear();
+        await input.sendKeys(message);
+        await input.sendKeys(selenium_webdriver_1.Key.chord(ScmProvider.ctlKey, selenium_webdriver_1.Key.ENTER));
+    }
+    /**
+     * Get page objects for all tree items representing individual changes
+     * @param staged when true, finds staged changes; otherwise finds unstaged changes
+     * @returns promise resolving to ScmChange object array
+     */
+    async getChanges(staged = false) {
+        const changes = await this.getChangeCount(staged);
+        const label = staged ? 'STAGED CHANGES' : 'CHANGES';
+        let elements = [];
+        if (changes > 0) {
+            let i = -1;
+            elements = await this.findElements(ScmProvider.locators.ScmView.changeItem);
+            for (const [index, item] of elements.entries()) {
+                const name = await item.findElement(ScmProvider.locators.ScmView.changeName);
+                if (await name.getText() === label) {
+                    i = index + 1;
+                    break;
+                }
+            }
+            if (i < 0) {
+                return [];
+            }
+            elements = elements.slice(i, i + changes);
+        }
+        return await Promise.all(elements.map(async (element) => new ScmChange(element, this).wait()));
+    }
+    /**
+     * Get the number of changes for a given section
+     * @param staged when true, counts the staged changes, unstaged otherwise
+     * @returns promise resolving to number of changes in the given subsection
+     */
+    async getChangeCount(staged = false) {
+        const locator = staged ? ScmProvider.locators.ScmView.stagedChanges : ScmProvider.locators.ScmView.changes;
+        const rows = await this.findElements(locator);
+        if (rows.length < 1) {
+            return 0;
+        }
+        const count = await rows[0].findElement(ScmChange.locators.ScmView.changeCount);
+        return +await count.getText();
+    }
+}
+exports.ScmProvider = ScmProvider;
+/**
+ * Page object representing a SCM change tree item
+ */
+class ScmChange extends ElementWithContextMenu_1.ElementWithContexMenu {
+    constructor(row, provider) {
+        super(row, provider);
+    }
+    /**
+     * Get label as a string
+     */
+    async getLabel() {
+        const label = await this.findElement(ScmChange.locators.ScmView.changeLabel);
+        return await label.getText();
+    }
+    /**
+     * Get description as a string
+     */
+    async getDescription() {
+        const desc = await this.findElements(ScmChange.locators.ScmView.changeDesc);
+        if (desc.length < 1) {
+            return '';
+        }
+        return await desc[0].getText();
+    }
+    /**
+     * Get the status string (e.g. 'Modified')
+     */
+    async getStatus() {
+        const res = await this.findElement(ScmChange.locators.ScmView.resource);
+        const status = await res.getAttribute('data-tooltip');
+        if (status && status.length > 0) {
+            return status;
+        }
+        return 'folder';
+    }
+    /**
+     * Find if the item is expanded
+     * @returns promise resolving to true if change is expanded, to false otherwise
+     */
+    async isExpanded() {
+        const twisties = await this.findElements(ScmChange.locators.ScmView.expand);
+        if (twisties.length < 1) {
+            return true;
+        }
+        return (await twisties[0].getAttribute('class')).indexOf('collapsed') < 0;
+    }
+    /**
+     * Expand or collapse a change item if possible, only works for folders in hierarchical view mode
+     * @param expand true to expand the item, false to collapse
+     * @returns promise resolving to true if the item changed state, to false otherwise
+     */
+    async toggleExpand(expand) {
+        if (await this.isExpanded() !== expand) {
+            await this.click();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Find and click an action button available to a given change tree item
+     * @param title title of the action button (e.g 'Stage Changes')
+     * @returns promise resolving to true if the action was performed successfully,
+     * false if the given button does not exist
+     */
+    async takeAction(title) {
+        await this.getDriver().actions().move({ origin: this }).perform();
+        const actions = await this.findElements(ScmChange.locators.ScmView.action);
+        const names = await Promise.all(actions.map(async (action) => await action.getAttribute(ScmChange.locators.ScmView.actionLabel)));
+        const index = names.findIndex(item => item === title);
+        if (index > -1) {
+            await actions[index].click();
+            return true;
+        }
+        return false;
+    }
+}
+exports.ScmChange = ScmChange;
+class MoreAction extends ElementWithContextMenu_1.ElementWithContexMenu {
+    constructor(scm) {
+        super(MoreAction.locators.ScmView.more, scm);
+    }
+    async openContextMenu() {
+        await this.click();
+        const shadowRootHost = await this.enclosingItem.findElements(selenium_webdriver_1.By.className('shadow-root-host'));
+        let actions = this.getDriver().actions();
+        await actions.clear();
+        await actions.sendKeys(selenium_webdriver_1.Key.ESCAPE).perform();
+        const webdriverCapabilities = await this.getDriver().getCapabilities();
+        const chromiumVersion = webdriverCapabilities.getBrowserVersion();
+        if (shadowRootHost.length > 0) {
+            if (await this.getAttribute('aria-expanded') !== 'true') {
+                await this.click();
+            }
+            let shadowRoot;
+            const webdriverCapabilities = await this.getDriver().getCapabilities();
+            const chromiumVersion = webdriverCapabilities.getBrowserVersion();
+            if (chromiumVersion && parseInt(chromiumVersion.split('.')[0]) >= 96) {
+                shadowRoot = await shadowRootHost[0].getShadowRoot();
+                return new __1.ContextMenu(await shadowRoot.findElement(selenium_webdriver_1.By.className('monaco-menu-container'))).wait();
+            }
+            else {
+                shadowRoot = await this.getDriver().executeScript('return arguments[0].shadowRoot', shadowRootHost[0]);
+                return new __1.ContextMenu(shadowRoot).wait();
+            }
+        }
+        else if (chromiumVersion && parseInt(chromiumVersion.split('.')[0]) >= 100) {
+            await this.click();
+            const workbench = await this.getDriver().findElement(ElementWithContextMenu_1.ElementWithContexMenu.locators.Workbench.constructor);
+            return new __1.ContextMenu(workbench).wait();
+        }
+        return await super.openContextMenu();
+    }
+}
+exports.MoreAction = MoreAction;
+//# sourceMappingURL=ScmView.js.map

package/out/components/sidebar/tree/TreeSection.d.ts

@@ -0,0 +1,14 @@
+import { ViewSection } from "../ViewSection";
+import { TreeItem } from "../ViewItem";
+import { error } from "selenium-webdriver";
+export declare class TreeItemNotFoundError extends error.NoSuchElementError {
+    constructor(msg?: string);
+}
+/**
+ * Abstract representation of a view section containing a tree
+ */
+export declare abstract class TreeSection extends ViewSection {
+    openItem(...path: string[]): Promise<TreeItem[]>;
+    abstract findItem(label: string, maxLevel?: number): Promise<TreeItem | undefined>;
+    abstract getVisibleItems(): Promise<TreeItem[]>;
+}

package/out/components/sidebar/tree/TreeSection.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeSection = exports.TreeItemNotFoundError = void 0;
+const ViewSection_1 = require("../ViewSection");
+const selenium_webdriver_1 = require("selenium-webdriver");
+class TreeItemNotFoundError extends selenium_webdriver_1.error.NoSuchElementError {
+    constructor(msg) {
+        super(msg);
+        this.name = 'TreeItemNotFoundError';
+    }
+}
+exports.TreeItemNotFoundError = TreeItemNotFoundError;
+/**
+ * Abstract representation of a view section containing a tree
+ */
+class TreeSection extends ViewSection_1.ViewSection {
+    async openItem(...path) {
+        let items = [];
+        for (let i = 0; i < path.length; i++) {
+            const item = await this.findItem(path[i], i + 1);
+            if (await item?.hasChildren() && !await item?.isExpanded()) {
+                await item?.expand();
+            }
+        }
+        let currentItem = await this.findItem(path[0], 1);
+        for (let i = 0; i < path.length; i++) {
+            if (!currentItem) {
+                if (i === 0) {
+                    items = await this.getVisibleItems();
+                }
+                let names = await Promise.all(items.map(item => item.getLabel()));
+                names = names.sort((a, b) => a > b ? 1 : (a < b ? -1 : 0));
+                const message = names.length < 1 ? `Current directory is empty.` : `Available items in current directory: [${names.toString()}]`;
+                throw new TreeItemNotFoundError(`Item '${path[i]}' not found. ${message}`);
+            }
+            items = await currentItem.getChildren();
+            if (items.length < 1) {
+                await currentItem.select();
+                return items;
+            }
+            if (i + 1 < path.length) {
+                currentItem = undefined;
+                for (const item of items) {
+                    if (await item.getLabel() === path[i + 1]) {
+                        currentItem = item;
+                        break;
+                    }
+                }
+            }
+        }
+        return items;
+    }
+}
+exports.TreeSection = TreeSection;
+//# sourceMappingURL=TreeSection.js.map

package/out/components/sidebar/tree/custom/CustomTreeItem.d.ts

@@ -0,0 +1,15 @@
+import { TreeItem } from "../../ViewItem";
+import { TreeSection } from "../TreeSection";
+import { WebElement } from "selenium-webdriver";
+/**
+ * View item in a custom-made content section (e.g. an extension tree view)
+ */
+export declare class CustomTreeItem extends TreeItem {
+    constructor(element: WebElement, viewPart: TreeSection);
+    getLabel(): Promise<string>;
+    getTooltip(): Promise<string>;
+    getDescription(): Promise<string>;
+    isExpanded(): Promise<boolean>;
+    getChildren(): Promise<TreeItem[]>;
+    isExpandable(): Promise<boolean>;
+}

package/out/components/sidebar/tree/custom/CustomTreeItem.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomTreeItem = void 0;
+const ViewItem_1 = require("../../ViewItem");
+/**
+ * View item in a custom-made content section (e.g. an extension tree view)
+ */
+class CustomTreeItem extends ViewItem_1.TreeItem {
+    constructor(element, viewPart) {
+        super(element, viewPart);
+    }
+    async getLabel() {
+        return await this.findElement(CustomTreeItem.locators.CustomTreeSection.itemLabel).getText();
+    }
+    async getTooltip() {
+        return await this.getAttribute(CustomTreeItem.locators.CustomTreeItem.tooltipAttribute);
+    }
+    async getDescription() {
+        return await this.findElement(CustomTreeItem.locators.CustomTreeItem.description).getText();
+    }
+    async isExpanded() {
+        const attr = await this.getAttribute(CustomTreeItem.locators.CustomTreeItem.expandedAttr);
+        return attr === CustomTreeItem.locators.CustomTreeItem.expandedValue;
+    }
+    async getChildren() {
+        const rows = await this.getChildItems(CustomTreeItem.locators.DefaultTreeSection.itemRow);
+        const items = await Promise.all(rows.map(async (row) => new CustomTreeItem(row, this.enclosingItem).wait()));
+        return items;
+    }
+    async isExpandable() {
+        const attr = await this.getAttribute(CustomTreeItem.locators.CustomTreeItem.expandedAttr);
+        return attr !== null;
+    }
+}
+exports.CustomTreeItem = CustomTreeItem;
+//# sourceMappingURL=CustomTreeItem.js.map