@redhat-developer/page-objects 1.0.0

package/out/components/bottomBar/Views.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalView = exports.DebugConsoleView = exports.OutputView = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const __1 = require("../..");
+const AbstractViews_1 = require("./AbstractViews");
+const ElementWithContextMenu_1 = require("../ElementWithContextMenu");
+/**
+ * Output view of the bottom panel
+ */
+class OutputView extends AbstractViews_1.TextView {
+    constructor(panel = new __1.BottomBarPanel()) {
+        super(OutputView.locators.OutputView.constructor, panel);
+        this.actionsLabel = OutputView.locators.OutputView.actionsLabel;
+    }
+    /**
+     * Select a channel using the selector combo
+     * @param name name of the channel to open
+     */
+    async selectChannel(name) {
+        await super.selectChannel(name);
+    }
+}
+exports.OutputView = OutputView;
+/**
+ * Debug Console view on the bottom panel
+ * Most functionality will only be available when a debug session is running
+ */
+class DebugConsoleView extends ElementWithContextMenu_1.ElementWithContexMenu {
+    constructor(panel = new __1.BottomBarPanel()) {
+        super(DebugConsoleView.locators.DebugConsoleView.constructor, panel);
+    }
+    /**
+     * Clear the console of all text
+     */
+    async clearText() {
+        const menu = await this.openContextMenu();
+        await menu.select('Clear Console');
+    }
+    /**
+     * Type an expression into the debug console text area
+     * @param expression expression in form of a string
+     */
+    async setExpression(expression) {
+        const textarea = await this.findElement(DebugConsoleView.locators.BottomBarViews.textArea);
+        await textarea.clear();
+        await textarea.sendKeys(expression);
+    }
+    /**
+     * Evaluate an expression:
+     *  - if no argument is supplied, evaluate the current expression present in debug console text area
+     *  - if a string argument is supplied, replace the current expression with the `expression` argument and evaluate
+     *
+     * @param expression expression to evaluate. To use existing contents of the debug console text area instead, don't define this argument
+     */
+    async evaluateExpression(expression) {
+        const textarea = await this.findElement(DebugConsoleView.locators.BottomBarViews.textArea);
+        if (expression) {
+            await this.setExpression(expression);
+        }
+        await textarea.sendKeys(selenium_webdriver_1.Key.ENTER);
+    }
+    /**
+     * Create a content assist page object
+     * @returns promise resolving to ContentAssist object
+     */
+    async getContentAssist() {
+        await this.getDriver().wait(selenium_webdriver_1.until.elementLocated(__1.ContentAssist.locators.ContentAssist.constructor), 1000);
+        return new __1.ContentAssist(this).wait();
+    }
+}
+exports.DebugConsoleView = DebugConsoleView;
+/**
+ * Terminal view on the bottom panel
+ */
+class TerminalView extends AbstractViews_1.ChannelView {
+    constructor(panel = new __1.BottomBarPanel()) {
+        super(TerminalView.locators.TerminalView.constructor, panel);
+        this.actionsLabel = TerminalView.locators.TerminalView.actionsLabel;
+    }
+    /**
+     * Execute command in the internal terminal and wait for results
+     * @param command text of the command
+     * @param timeout optional maximum time to wait for completion in milliseconds, 0 for unlimited
+     * @returns Promise resolving when the command is finished
+     */
+    async executeCommand(command, timeout = 0) {
+        const input = await this.findElement(TerminalView.locators.TerminalView.textArea);
+        try {
+            await input.clear();
+        }
+        catch (err) {
+            // 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');
+    }
+    /**
+     * Get all text from the internal terminal
+     * Beware, no formatting.
+     *
+     * @returns Promise resolving to all terminal text
+     */
+    async getText() {
+        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 workbench = new __1.Workbench();
+        await workbench.executeCommand('terminal select all');
+        await workbench.getDriver().sleep(500);
+        const text = clipboard.readSync();
+        if (originalClipboard.length > 0) {
+            clipboard.writeSync(originalClipboard);
+        }
+        return text;
+    }
+    /**
+     * Destroy the currently open terminal
+     * @returns Promise resolving when Kill Terminal button is pressed
+     */
+    async killTerminal() {
+        await new __1.Workbench().executeCommand('terminal: kill the active terminal instance');
+    }
+    /**
+     * Initiate new terminal creation
+     * @returns Promise resolving when New Terminal button is pressed
+     */
+    async newTerminal() {
+        await new __1.Workbench().executeCommand(TerminalView.locators.TerminalView.newCommand);
+        const combo = await this.enclosingItem.findElements(AbstractViews_1.ChannelView.locators.BottomBarViews.channelCombo);
+        if (combo.length < 1) {
+            await this.getDriver().wait(async () => {
+                const list = await this.findElements(TerminalView.locators.TerminalView.tabList);
+                return list.length > 0;
+            }, 5000);
+        }
+    }
+    async getCurrentChannel() {
+        const combo = await this.enclosingItem.findElements(AbstractViews_1.ChannelView.locators.BottomBarViews.channelCombo);
+        if (combo.length > 0) {
+            return await super.getCurrentChannel();
+        }
+        const singleTerm = await this.enclosingItem.findElements(TerminalView.locators.TerminalView.singleTab);
+        if (singleTerm.length > 0) {
+            return await singleTerm[0].getText();
+        }
+        const list = await this.findElement(TerminalView.locators.TerminalView.tabList);
+        const row = await list.findElement(TerminalView.locators.TerminalView.selectedRow);
+        await this.getDriver().sleep(1000);
+        const label = (await row.getAttribute('aria-label')).split(' ');
+        return `${label[1]}: ${label[2]}`;
+    }
+    async selectChannel(name) {
+        const combo = await this.enclosingItem.findElements(AbstractViews_1.ChannelView.locators.BottomBarViews.channelCombo);
+        if (combo.length > 0) {
+            return await super.selectChannel(name);
+        }
+        const singleTerm = await this.enclosingItem.findElements(TerminalView.locators.TerminalView.singleTab);
+        if (singleTerm.length > 0) {
+            return;
+        }
+        const matches = /.*(\d+).?\s.*/.exec(name);
+        if (matches === null || !matches[1]) {
+            throw new Error(`Channel ${name} not found`);
+        }
+        const channelNumber = matches[1];
+        const list = await this.findElement(TerminalView.locators.TerminalView.tabList);
+        const rows = await list.findElements(TerminalView.locators.TerminalView.row);
+        for (const row of rows) {
+            const label = await row.getAttribute('aria-label');
+            if (label.includes(channelNumber)) {
+                await row.click();
+                return;
+            }
+        }
+        throw new Error(`Channel ${name} not found`);
+    }
+}
+exports.TerminalView = TerminalView;
+//# sourceMappingURL=Views.js.map

package/out/components/bottomBar/WebviewView.d.ts

@@ -0,0 +1,12 @@
+import { WebElement } from "selenium-webdriver";
+import { AbstractElement } from "../AbstractElement";
+/**
+ * Page object representing a user-contributed panel implemented using a Webview.
+ */
+declare class WebviewViewBase extends AbstractElement {
+    constructor();
+    getViewToSwitchTo(handle: string): Promise<WebElement | undefined>;
+}
+export declare const WebviewView: new (...args: any[]) => WebviewViewBase & import("../WebviewMixin").WebviewMixinType;
+export type WebviewView = InstanceType<typeof WebviewView>;
+export {};

package/out/components/bottomBar/WebviewView.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebviewView = void 0;
+const AbstractElement_1 = require("../AbstractElement");
+const WebviewMixin_1 = __importDefault(require("../WebviewMixin"));
+/**
+ * Page object representing a user-contributed panel implemented using a Webview.
+ */
+class WebviewViewBase extends AbstractElement_1.AbstractElement {
+    constructor() {
+        super(WebviewViewBase.locators.Workbench.constructor);
+    }
+    async getViewToSwitchTo(handle) {
+        return await this.getDriver().findElement(WebviewViewBase.locators.WebviewView.iframe);
+    }
+}
+exports.WebviewView = (0, WebviewMixin_1.default)(WebviewViewBase);
+//# sourceMappingURL=WebviewView.js.map

package/out/components/dialog/ModalDialog.d.ts

@@ -0,0 +1,32 @@
+import { WebElement } from "selenium-webdriver";
+import { AbstractElement } from "../AbstractElement";
+/**
+ * Page Object for Custom Style Modal Dialogs (non-native)
+ */
+export declare class ModalDialog extends AbstractElement {
+    constructor();
+    /**
+     * Get the dialog's message in a Promise
+     */
+    getMessage(): Promise<string>;
+    /**
+     * Get the details message in a Promise
+     */
+    getDetails(): Promise<string>;
+    /**
+     * Get the list of buttons as WebElements
+     *
+     * @returns Promise resolving to Array of WebElement items representing the buttons
+     */
+    getButtons(): Promise<WebElement[]>;
+    /**
+     * Push a button with given title if it exists
+     *
+     * @param title title/text of the button
+     */
+    pushButton(title: string): Promise<void>;
+    /**
+     * Close the dialog using the 'cross' button
+     */
+    close(): Promise<void>;
+}

package/out/components/dialog/ModalDialog.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalDialog = void 0;
+const AbstractElement_1 = require("../AbstractElement");
+/**
+ * Page Object for Custom Style Modal Dialogs (non-native)
+ */
+class ModalDialog extends AbstractElement_1.AbstractElement {
+    constructor() {
+        super(ModalDialog.locators.Dialog.constructor);
+    }
+    /**
+     * Get the dialog's message in a Promise
+     */
+    async getMessage() {
+        const message = await this.findElement(ModalDialog.locators.Dialog.message);
+        return await message.getText();
+    }
+    /**
+     * Get the details message in a Promise
+     */
+    async getDetails() {
+        const details = await this.findElement(ModalDialog.locators.Dialog.details);
+        return await details.getText();
+    }
+    /**
+     * Get the list of buttons as WebElements
+     *
+     * @returns Promise resolving to Array of WebElement items representing the buttons
+     */
+    async getButtons() {
+        return await this.findElement(ModalDialog.locators.Dialog.buttonContainer).findElements(ModalDialog.locators.Dialog.button);
+    }
+    /**
+     * Push a button with given title if it exists
+     *
+     * @param title title/text of the button
+     */
+    async pushButton(title) {
+        const buttons = await this.getButtons();
+        const titles = await Promise.all(buttons.map(async (btn) => ModalDialog.locators.Dialog.buttonLabel.value(btn)));
+        const index = titles.findIndex(value => value === title);
+        if (index > -1) {
+            await buttons[index].click();
+        }
+    }
+    /**
+     * Close the dialog using the 'cross' button
+     */
+    async close() {
+        const btn = await this.findElement(ModalDialog.locators.Dialog.closeButton);
+        return await btn.click();
+    }
+}
+exports.ModalDialog = ModalDialog;
+//# sourceMappingURL=ModalDialog.js.map

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

@@ -0,0 +1,18 @@
+import { WebElement } from 'selenium-webdriver';
+import { AbstractElement } from '../AbstractElement';
+export declare class Breakpoint extends AbstractElement {
+    private lineElement;
+    constructor(breakpoint: WebElement, lineElement: WebElement);
+    isEnabled(): Promise<boolean>;
+    isPaused(): Promise<boolean>;
+    /**
+     * Return line number of the breakpoint.
+     * @returns number indicating line where breakpoint is set
+     */
+    getLineNumber(): Promise<number>;
+    /**
+     * Remove breakpoint.
+     * @param timeout time in ms when operation is considered to be unsuccessful
+     */
+    remove(timeout?: number): Promise<void>;
+}

package/out/components/editor/Breakpoint.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Breakpoint = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const AbstractElement_1 = require("../AbstractElement");
+class Breakpoint extends AbstractElement_1.AbstractElement {
+    lineElement;
+    constructor(breakpoint, lineElement) {
+        super(breakpoint, lineElement);
+        this.lineElement = lineElement;
+    }
+    async isEnabled() {
+        return await Breakpoint.locators.TextEditor.breakpoint.properties.enabled(this);
+    }
+    async isPaused() {
+        return await Breakpoint.locators.TextEditor.breakpoint.properties.paused(this);
+    }
+    /**
+     * Return line number of the breakpoint.
+     * @returns number indicating line where breakpoint is set
+     */
+    async getLineNumber() {
+        const breakpointLocators = Breakpoint.locators.TextEditor.breakpoint;
+        const line = await this.lineElement.findElement(breakpointLocators.properties.line.selector);
+        const lineNumber = await breakpointLocators.properties.line.number(line);
+        return lineNumber;
+    }
+    /**
+     * Remove breakpoint.
+     * @param timeout time in ms when operation is considered to be unsuccessful
+     */
+    async remove(timeout = 5000) {
+        await this.click();
+        await this.getDriver().wait(selenium_webdriver_1.until.stalenessOf(this), timeout);
+    }
+}
+exports.Breakpoint = Breakpoint;
+//# sourceMappingURL=Breakpoint.js.map

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

@@ -0,0 +1,34 @@
+import { TextEditor, Menu, MenuItem, DebugConsoleView } from "../..";
+import { WebElement } from 'selenium-webdriver';
+/**
+ * Page object representing the content assistant
+ */
+export declare class ContentAssist extends Menu {
+    constructor(parent: TextEditor | DebugConsoleView);
+    /**
+     * Get content assist item by name/text, scroll through the list
+     * until the item is found, or the end is reached
+     *
+     * @param name name/text to search by
+     * @returns Promise resolving to ContentAssistItem object if found, undefined otherwise
+     */
+    getItem(name: string): Promise<ContentAssistItem | undefined>;
+    /**
+     * Get all visible content assist items
+     * @returns Promise resolving to array of ContentAssistItem objects
+     */
+    getItems(): Promise<ContentAssistItem[]>;
+    /**
+     * Find if the content assist is still loading the suggestions
+     * @returns promise that resolves to true when suggestions are done loading,
+     * to false otherwise
+     */
+    isLoaded(): Promise<boolean>;
+}
+/**
+ * Page object for a content assist item
+ */
+export declare class ContentAssistItem extends MenuItem {
+    constructor(item: WebElement, contentAssist: ContentAssist);
+    getLabel(): Promise<string>;
+}

package/out/components/editor/ContentAssist.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentAssistItem = exports.ContentAssist = void 0;
+const __1 = require("../..");
+const selenium_webdriver_1 = require("selenium-webdriver");
+/**
+ * Page object representing the content assistant
+ */
+class ContentAssist extends __1.Menu {
+    constructor(parent) {
+        super(ContentAssist.locators.ContentAssist.constructor, parent);
+    }
+    /**
+     * Get content assist item by name/text, scroll through the list
+     * until the item is found, or the end is reached
+     *
+     * @param name name/text to search by
+     * @returns Promise resolving to ContentAssistItem object if found, undefined otherwise
+     */
+    async getItem(name) {
+        let lastItem = false;
+        const scrollable = await this.findElement(ContentAssist.locators.ContentAssist.itemList);
+        let firstItem = await this.findElements(ContentAssist.locators.ContentAssist.firstItem);
+        while (firstItem.length < 1) {
+            await scrollable.sendKeys(selenium_webdriver_1.Key.PAGE_UP, selenium_webdriver_1.Key.NULL);
+            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;
+                }
+                lastItem = lastItem || (await item.getAttribute('data-last-element')) === 'true';
+            }
+            if (!lastItem) {
+                await scrollable.sendKeys(selenium_webdriver_1.Key.PAGE_DOWN);
+                await new Promise(res => setTimeout(res, 100));
+            }
+        }
+    }
+    /**
+     * Get all visible content assist items
+     * @returns Promise resolving to array of ContentAssistItem objects
+     */
+    async getItems() {
+        await this.getDriver().wait(async () => { return await this.isLoaded(); });
+        const elements = await this.findElement(ContentAssist.locators.ContentAssist.itemRows)
+            .findElements(ContentAssist.locators.ContentAssist.itemRow);
+        const items = [];
+        for (const item of elements) {
+            try {
+                items.push(await new ContentAssistItem(item, this).wait());
+            }
+            catch (err) {
+                if (!(err instanceof selenium_webdriver_1.error.StaleElementReferenceError)) {
+                    throw err;
+                }
+            }
+        }
+        return items;
+    }
+    /**
+     * Find if the content assist is still loading the suggestions
+     * @returns promise that resolves to true when suggestions are done loading,
+     * to false otherwise
+     */
+    async isLoaded() {
+        const message = await this.findElement(ContentAssist.locators.ContentAssist.message);
+        if (await message.isDisplayed()) {
+            if ((await message.getText()).startsWith('No suggestions')) {
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
+}
+exports.ContentAssist = ContentAssist;
+/**
+ * Page object for a content assist item
+ */
+class ContentAssistItem extends __1.MenuItem {
+    constructor(item, contentAssist) {
+        super(item, contentAssist);
+        this.parent = contentAssist;
+    }
+    async getLabel() {
+        const labelDiv = await this.findElement(ContentAssist.locators.ContentAssist.itemLabel);
+        return await labelDiv.getText();
+    }
+}
+exports.ContentAssistItem = ContentAssistItem;
+//# sourceMappingURL=ContentAssist.js.map

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

@@ -0,0 +1,26 @@
+import { Editor, InputBox, WebView } from "../..";
+/**
+ * Page object for custom editors
+ */
+export declare class CustomEditor extends Editor {
+    /**
+     * Get the WebView object contained in the editor
+     * @returns WebView page object
+     */
+    getWebView(): WebView;
+    /**
+     * Check if the editor has unsaved changes
+     * @returns Promise resolving to true if there are unsaved changes, false otherwise
+     */
+    isDirty(): Promise<boolean>;
+    /**
+     * Save the editor
+     */
+    save(): Promise<void>;
+    /**
+     * Open the Save as prompt
+     *
+     * @returns InputBox serving as a simple file dialog
+     */
+    saveAs(): Promise<InputBox>;
+}

package/out/components/editor/CustomEditor.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomEditor = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const __1 = require("../..");
+/**
+ * Page object for custom editors
+ */
+class CustomEditor extends __1.Editor {
+    /**
+     * Get the WebView object contained in the editor
+     * @returns WebView page object
+     */
+    getWebView() {
+        return new __1.WebView();
+    }
+    /**
+     * Check if the editor has unsaved changes
+     * @returns Promise resolving to true if there are unsaved changes, false otherwise
+     */
+    async isDirty() {
+        const tab = await this.getTab();
+        const klass = await tab.getAttribute('class');
+        return klass.includes('dirty');
+    }
+    /**
+     * Save the editor
+     */
+    async save() {
+        const tab = await this.getTab();
+        await tab.sendKeys(selenium_webdriver_1.Key.chord(CustomEditor.ctlKey, 's'));
+    }
+    /**
+     * Open the Save as prompt
+     *
+     * @returns InputBox serving as a simple file dialog
+     */
+    async saveAs() {
+        const tab = await this.getTab();
+        await tab.sendKeys(selenium_webdriver_1.Key.chord(CustomEditor.ctlKey, selenium_webdriver_1.Key.SHIFT, 's'));
+        return await __1.InputBox.create();
+    }
+}
+exports.CustomEditor = CustomEditor;
+//# sourceMappingURL=CustomEditor.js.map

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

@@ -0,0 +1,19 @@
+import { Editor } from './Editor';
+import { TextEditor } from './TextEditor';
+/**
+ * Page object representing a diff editor
+ */
+export declare class DiffEditor extends Editor {
+    /**
+     * Gets the text editor corresponding to the originalside.
+     * (The left side of the diff editor)
+     * @returns Promise resolving to TextEditor object
+     */
+    getOriginalEditor(): Promise<TextEditor>;
+    /**
+     * Gets the text editor corresponding to the modified side.
+     * (The right side of the diff editor)
+     * @returns Promise resolving to TextEditor object
+     */
+    getModifiedEditor(): Promise<TextEditor>;
+}

package/out/components/editor/DiffEditor.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffEditor = void 0;
+const Editor_1 = require("./Editor");
+const TextEditor_1 = require("./TextEditor");
+const EditorView_1 = require("./EditorView");
+/**
+ * Page object representing a diff editor
+ */
+class DiffEditor extends Editor_1.Editor {
+    /**
+     * Gets the text editor corresponding to the originalside.
+     * (The left side of the diff editor)
+     * @returns Promise resolving to TextEditor object
+     */
+    async getOriginalEditor() {
+        const element = await this.getEnclosingElement().findElement(DiffEditor.locators.DiffEditor.originalEditor);
+        return new TextEditor_1.TextEditor(new EditorView_1.EditorView(), element);
+    }
+    /**
+     * Gets the text editor corresponding to the modified side.
+     * (The right side of the diff editor)
+     * @returns Promise resolving to TextEditor object
+     */
+    async getModifiedEditor() {
+        const element = await this.getEnclosingElement().findElement(DiffEditor.locators.DiffEditor.modifiedEditor);
+        return new TextEditor_1.TextEditor(new EditorView_1.EditorView(), element);
+    }
+}
+exports.DiffEditor = DiffEditor;
+//# sourceMappingURL=DiffEditor.js.map

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

@@ -0,0 +1,17 @@
+import { ElementWithContexMenu } from "../ElementWithContextMenu";
+import { EditorTab, EditorView, EditorGroup } from "../..";
+import { WebElement, Locator } from 'selenium-webdriver';
+/**
+ * Abstract representation of an editor tab
+ */
+export declare abstract class Editor extends ElementWithContexMenu {
+    constructor(view?: EditorView | EditorGroup, base?: Locator | WebElement);
+    /**
+     * Get title/name of the open editor
+     */
+    getTitle(): Promise<string>;
+    /**
+     * Get the corresponding editor tab
+     */
+    getTab(): Promise<EditorTab>;
+}

package/out/components/editor/Editor.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Editor = void 0;
+const ElementWithContextMenu_1 = require("../ElementWithContextMenu");
+const __1 = require("../..");
+/**
+ * Abstract representation of an editor tab
+ */
+class Editor extends ElementWithContextMenu_1.ElementWithContexMenu {
+    constructor(view = new __1.EditorView(), base = Editor.locators.Editor.constructor) {
+        super(base, view);
+    }
+    /**
+     * Get title/name of the open editor
+     */
+    async getTitle() {
+        const tab = await this.getTab();
+        return await tab.getTitle();
+    }
+    /**
+     * Get the corresponding editor tab
+     */
+    async getTab() {
+        const element = this.enclosingItem;
+        return await element.getActiveTab();
+    }
+}
+exports.Editor = Editor;
+//# sourceMappingURL=Editor.js.map