@umbraco/playwright-testhelpers 2.0.0-beta.9 → 2.0.0-beta.91

package/dist/lib/helpers/ContentUiHelper.js

@@ -0,0 +1,569 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentUiHelper = void 0;
+const test_1 = require("@playwright/test");
+const UiBaseLocators_1 = require("./UiBaseLocators");
+class ContentUiHelper extends UiBaseLocators_1.UiBaseLocators {
+    contentNameTxt;
+    saveAndPublishBtn;
+    actionsBtn;
+    publishBtn;
+    unpublishBtn;
+    actionMenuForContentBtn;
+    openedModal;
+    textstringTxt;
+    infoTab;
+    linkContent;
+    historyItems;
+    generalItem;
+    publicationStatus;
+    createdDate;
+    editDocumentTypeBtn;
+    addTemplateBtn;
+    id;
+    cultureAndHostnamesBtn;
+    cultureLanguageDropdownBox;
+    addNewDomainBtn;
+    domainTxt;
+    domainLanguageDropdownBox;
+    deleteDomainBtn;
+    reloadChildrenThreeDotsBtn;
+    contentTree;
+    richTextAreaTxt;
+    textAreaTxt;
+    plusIconBtn;
+    enterTagTxt;
+    menuItemTree;
+    domainComboBox;
+    confirmToUnpublishBtn;
+    saveModalBtn;
+    createDocumentBlueprintBtn;
+    dropdown;
+    setADateTxt;
+    chooseMediaPickerBtn;
+    chooseMemberPickerBtn;
+    numericTxt;
+    resetFocalPointBtn;
+    addMultiURLPickerBtn;
+    linkTxt;
+    anchorQuerystringTxt;
+    linkTitleTxt;
+    tagItems;
+    removeFilesBtn;
+    toggleBtn;
+    toggleInput;
+    documentTypeWorkspace;
+    addMultipleTextStringBtn;
+    multipleTextStringValueTxt;
+    markdownTxt;
+    codeEditorTxt;
+    sliderInput;
+    tabItems;
+    documentWorkspace;
+    documentTableColumnNames;
+    searchTxt;
+    variantSelectorBtn;
+    variantAddModeBtn;
+    saveAndCloseBtn;
+    enterNameInContainerTxt;
+    listView;
+    nameBtn;
+    listViewTableRow;
+    publishSelectedListItems;
+    unpublishSelectedListItems;
+    duplicateToSelectedListItems;
+    moveToSelectedListItems;
+    trashSelectedListItems;
+    modalContent;
+    trashBtn;
+    documentListView;
+    documentGridView;
+    documentTreeItem;
+    constructor(page) {
+        super(page);
+        this.contentNameTxt = page.locator('#name-input input');
+        this.saveAndPublishBtn = page.getByLabel('Save And Publish');
+        this.actionsBtn = page.getByLabel('Actions', { exact: true });
+        this.publishBtn = page.getByRole('button', { name: 'Publish', exact: true });
+        this.unpublishBtn = page.getByRole('button', { name: 'Unpublish', exact: true });
+        this.actionMenuForContentBtn = page.locator('#header [label="Open actions menu"]');
+        this.openedModal = page.locator('uui-modal-container[backdrop]');
+        this.textstringTxt = page.locator('umb-property-editor-ui-text-box #input');
+        this.reloadChildrenThreeDotsBtn = page.getByRole('button', { name: 'Reload children...' });
+        this.contentTree = page.locator('umb-tree[alias="Umb.Tree.Document"]');
+        this.richTextAreaTxt = page.frameLocator('iframe[title="Rich Text Area"]').locator('#tinymce');
+        this.textAreaTxt = page.locator('umb-property-editor-ui-textarea textarea');
+        this.plusIconBtn = page.locator('#icon-add svg');
+        this.enterTagTxt = page.getByPlaceholder('Enter tag');
+        this.menuItemTree = page.locator('umb-menu-item-tree-default');
+        this.confirmToUnpublishBtn = page.locator('umb-document-unpublish-modal').getByLabel('Unpublish');
+        this.createDocumentBlueprintBtn = page.getByLabel('Create Document Blueprint');
+        this.dropdown = page.locator('select#native');
+        this.setADateTxt = page.getByLabel('Set a date...');
+        this.chooseMediaPickerBtn = page.locator('umb-property-editor-ui-media-picker #btn-add');
+        this.chooseMemberPickerBtn = page.locator('umb-property-editor-ui-member-picker #btn-add');
+        this.numericTxt = page.locator('umb-property-editor-ui-number input');
+        this.addMultiURLPickerBtn = page.locator('umb-property-editor-ui-multi-url-picker #btn-add');
+        this.linkTxt = page.getByLabel('URL');
+        this.anchorQuerystringTxt = page.getByLabel('#value or ?key=value');
+        this.linkTitleTxt = page.getByLabel('Link title');
+        this.tagItems = page.locator('uui-tag');
+        this.removeFilesBtn = page.locator('umb-input-upload-field [label="Remove file(s)"]');
+        this.toggleBtn = page.locator('umb-property-editor-ui-toggle #slider');
+        this.toggleInput = page.locator('umb-property-editor-ui-toggle #input');
+        this.documentTypeWorkspace = this.sidebarModal.locator('umb-document-type-workspace-editor');
+        this.addMultipleTextStringBtn = page.locator('umb-input-multiple-text-string').getByLabel('Add');
+        this.multipleTextStringValueTxt = page.locator('umb-input-multiple-text-string').getByLabel('Value');
+        this.markdownTxt = page.locator('umb-input-markdown textarea');
+        this.codeEditorTxt = page.locator('umb-code-editor textarea');
+        this.sliderInput = page.locator('umb-property-editor-ui-slider #input');
+        this.tabItems = page.locator('uui-tab');
+        this.documentWorkspace = page.locator('umb-document-workspace-editor');
+        this.documentTableColumnNames = page.locator('umb-document-table-column-name');
+        this.searchTxt = this.documentWorkspace.locator('#input-search input');
+        this.variantSelectorBtn = page.locator('#variant-selector-toggle');
+        this.variantAddModeBtn = page.locator('.variant-selector-switch-button.add-mode');
+        this.saveAndCloseBtn = page.getByLabel('Save and close');
+        this.documentTreeItem = page.locator('umb-document-tree-item');
+        // Info tab
+        this.infoTab = page.getByRole('tab', { name: 'Info' });
+        this.linkContent = page.locator('.link-content');
+        this.historyItems = page.locator('umb-history-item');
+        this.generalItem = page.locator('.general-item');
+        this.publicationStatus = this.generalItem.filter({ hasText: 'Publication Status' }).locator('uui-tag');
+        this.createdDate = this.generalItem.filter({ hasText: 'Created' }).locator('umb-localize-date');
+        this.editDocumentTypeBtn = this.generalItem.filter({ hasText: 'Document Type' }).locator('#button');
+        this.addTemplateBtn = this.generalItem.filter({ hasText: 'Template' }).locator('#button');
+        this.id = this.generalItem.filter({ hasText: 'Id' }).locator('span');
+        // Culture and Hostname
+        this.cultureAndHostnamesBtn = page.getByRole('button', { name: 'Culture and Hostnames', exact: true });
+        this.cultureLanguageDropdownBox = page.locator('[headline="Culture"]').getByLabel('combobox-input');
+        this.addNewDomainBtn = page.getByLabel('Add new domain');
+        this.domainTxt = page.getByLabel('Domain', { exact: true });
+        this.domainLanguageDropdownBox = page.locator('[headline="Domains"]').getByLabel('combobox-input');
+        this.deleteDomainBtn = page.locator('[headline="Domains"] [name="icon-trash"] svg');
+        this.domainComboBox = page.locator('#domains uui-combobox');
+        this.saveModalBtn = this.sidebarModal.getByLabel('Save', { exact: true });
+        this.resetFocalPointBtn = this.page.getByLabel('Reset focal point');
+        // List View
+        this.enterNameInContainerTxt = page.locator('#container').getByLabel('Enter a name...');
+        this.listView = page.locator('umb-document-table-collection-view');
+        this.nameBtn = page.getByRole('button', { name: 'Name' });
+        this.listViewTableRow = this.listView.locator('uui-table-row');
+        this.publishSelectedListItems = page.getByRole('button', { name: 'Publish', exact: true });
+        this.unpublishSelectedListItems = page.getByRole('button', { name: 'Unpublish', exact: true });
+        this.duplicateToSelectedListItems = page.getByRole('button', { name: 'Duplicate to', exact: true });
+        this.moveToSelectedListItems = page.getByRole('button', { name: 'Move to', exact: true });
+        this.trashSelectedListItems = page.getByRole('button', { name: 'Trash', exact: true });
+        this.modalContent = page.locator('umb-tree-picker-modal');
+        this.trashBtn = page.getByLabel('Trash');
+        this.documentListView = page.locator('umb-document-table-collection-view');
+        this.documentGridView = page.locator('umb-document-grid-collection-view');
+    }
+    async enterContentName(name) {
+        await (0, test_1.expect)(this.contentNameTxt).toBeVisible();
+        await this.contentNameTxt.clear();
+        await this.contentNameTxt.fill(name);
+    }
+    async clickSaveAndPublishButton() {
+        await this.saveAndPublishBtn.click();
+    }
+    async clickActionsButton() {
+        await this.actionsBtn.click();
+    }
+    async clickPublishButton() {
+        await this.publishBtn.click();
+    }
+    async clickUnpublishButton() {
+        await this.unpublishBtn.click();
+    }
+    async clickReloadChildrenThreeDotsButton() {
+        await this.reloadChildrenThreeDotsBtn.click();
+    }
+    async clickActionsMenuAtRoot() {
+        await this.actionMenuForContentBtn.click();
+    }
+    async goToContentWithName(contentName) {
+        await this.menuItemTree.getByText(contentName, { exact: true }).click();
+    }
+    async clickActionsMenuForContent(name) {
+        await this.clickActionsMenuForName(name);
+    }
+    async clickCaretButtonForContentName(name) {
+        await this.menuItemTree.filter({ hasText: name }).last().locator('#caret-button').last().click();
+    }
+    async waitForModalVisible() {
+        await this.openedModal.waitFor({ state: 'attached' });
+    }
+    async waitForModalHidden() {
+        await this.openedModal.waitFor({ state: 'hidden' });
+    }
+    async enterTextstring(text) {
+        await this.textstringTxt.clear();
+        await this.textstringTxt.fill(text);
+    }
+    async doesContentTreeHaveName(contentName) {
+        await (0, test_1.expect)(this.contentTree).toContainText(contentName);
+    }
+    async enterRichTextArea(value) {
+        await (0, test_1.expect)(this.richTextAreaTxt).toBeVisible();
+        await this.richTextAreaTxt.fill(value);
+    }
+    async enterTextArea(value) {
+        await (0, test_1.expect)(this.textAreaTxt).toBeVisible();
+        await this.page.waitForTimeout(200);
+        await this.textAreaTxt.clear();
+        await this.textAreaTxt.fill(value);
+    }
+    async clickConfirmToUnpublishButton() {
+        await this.confirmToUnpublishBtn.click();
+    }
+    async clickCreateDocumentBlueprintButton() {
+        await this.createDocumentBlueprintBtn.click();
+    }
+    // Info Tab
+    async clickInfoTab() {
+        await this.infoTab.click({ force: true });
+    }
+    async doesLinkHaveText(text) {
+        await (0, test_1.expect)(this.linkContent).toHaveText(text);
+    }
+    async doesHistoryHaveText(text) {
+        await (0, test_1.expect)(this.historyItems).toHaveText(text);
+    }
+    async doesPublicationStatusHaveText(text) {
+        await (0, test_1.expect)(this.publicationStatus).toHaveText(text);
+    }
+    async doesCreatedDateHaveText(text) {
+        await (0, test_1.expect)(this.createdDate).toHaveText(text);
+    }
+    async doesIdHaveText(text) {
+        await (0, test_1.expect)(this.id).toHaveText(text);
+    }
+    async clickEditDocumentTypeButton() {
+        await this.editDocumentTypeBtn.click();
+    }
+    async clickAddTemplateButton() {
+        await this.addTemplateBtn.click();
+    }
+    async clickDocumentTypeByName(documentTypeName) {
+        await this.page.locator('uui-ref-node-document-type[name="' + documentTypeName + '"]').click();
+    }
+    async clickTemplateByName(templateName) {
+        await this.page.locator('uui-ref-node[name="' + templateName + '"]').click();
+    }
+    async isDocumentTypeModalVisible(documentTypeName) {
+        await (0, test_1.expect)(this.documentTypeWorkspace.filter({ hasText: documentTypeName })).toBeVisible();
+    }
+    async isTemplateModalVisible(templateName) {
+        await (0, test_1.expect)(this.breadcrumbsTemplateModal.getByText(templateName)).toBeVisible();
+    }
+    async clickEditTemplateByName(templateName) {
+        await this.page.locator('uui-ref-node[name="' + templateName + '"]').getByLabel('Choose').click();
+    }
+    async changeTemplate(oldTemplate, newTemplate) {
+        await this.clickEditTemplateByName(oldTemplate);
+        await this.sidebarModal.getByLabel(newTemplate).click();
+        await this.chooseModalBtn.click();
+    }
+    async isTemplateNameDisabled(templateName) {
+        await (0, test_1.expect)(this.sidebarModal.getByLabel(templateName)).toBeDisabled();
+    }
+    // Culture and Hostnames
+    async clickCultureAndHostnamesButton() {
+        await this.cultureAndHostnamesBtn.click();
+    }
+    async selectCultureLanguageOption(option) {
+        await this.cultureLanguageDropdownBox.click();
+        await this.page.getByText(option).click();
+    }
+    async selectDomainLanguageOption(option, index = 0) {
+        await this.domainLanguageDropdownBox.nth(index).click();
+        await this.domainComboBox.nth(index).getByText(option).click();
+    }
+    async clickAddNewDomainButton() {
+        await this.addNewDomainBtn.click();
+    }
+    async enterDomain(value, index = 0) {
+        await this.domainTxt.nth(index).clear();
+        await this.domainTxt.nth(index).fill(value);
+    }
+    async clickDeleteDomainButton() {
+        await this.deleteDomainBtn.first().click();
+    }
+    async clickSaveModalButton() {
+        await this.saveModalBtn.click();
+    }
+    async chooseDocumentType(documentTypeName) {
+        await this.documentTypeNode.filter({ hasText: documentTypeName }).click();
+    }
+    // Approved Color
+    async clickApprovedColorByValue(value) {
+        await this.page.locator('uui-color-swatch[value="#' + value + '"] #swatch').click();
+    }
+    // Checkbox list
+    async chooseCheckboxListOption(optionValue) {
+        await this.page.locator('uui-checkbox[value="' + optionValue + '"] svg').click();
+    }
+    // Content Picker
+    async addContentPicker(contentName) {
+        await this.clickChooseButton();
+        await this.sidebarModal.getByText(contentName).click();
+        await this.chooseModalBtn.click();
+    }
+    async isOpenButtonVisibleInContentPicker(contentPickerName, isVisible = true) {
+        return (0, test_1.expect)(this.page.getByLabel('Open ' + contentPickerName)).toBeVisible({ visible: isVisible });
+    }
+    async clickContentPickerOpenButton(contentPickerName) {
+        await this.page.getByLabel('Open ' + contentPickerName).click();
+    }
+    async isNodeOpenForContentPicker(contentPickerName) {
+        return (0, test_1.expect)(this.openedModal.getByText(contentPickerName)).toBeVisible();
+    }
+    async isContentNameVisible(contentName, isVisible = true) {
+        return (0, test_1.expect)(this.sidebarModal.getByText(contentName)).toBeVisible({ visible: isVisible });
+    }
+    async isContentVisible(name, isVisible = true) {
+        return (0, test_1.expect)(this.documentTreeItem.getByLabel(name, { exact: true })).toBeVisible({ visible: isVisible });
+    }
+    async isChildContentVisible(parentName, childName, isVisible = true) {
+        return (0, test_1.expect)(this.documentTreeItem.filter({ hasText: parentName }).getByLabel(childName)).toBeVisible({ visible: isVisible });
+    }
+    async removeContentPicker(contentPickerName) {
+        await this.page.locator('[name="' + contentPickerName + '"]').getByLabel('Remove').click();
+        await this.clickConfirmRemoveButton();
+    }
+    // Dropdown
+    async chooseDropdownOption(optionValues) {
+        await this.dropdown.selectOption(optionValues);
+    }
+    // Date Picker
+    async enterADate(date) {
+        await this.setADateTxt.fill(date);
+    }
+    // Media Picker
+    async clickChooseMediaPickerButton() {
+        await this.chooseMediaPickerBtn.click();
+    }
+    async clickMediaByNameInMediaPicker(mediaName) {
+        await this.mediaCardItems.filter({ hasText: mediaName }).click();
+    }
+    async selectMediaByName(mediaName) {
+        await this.clickChooseMediaPickerButton();
+        await this.clickMediaByNameInMediaPicker(mediaName);
+    }
+    async removeMediaPickerByName(mediaPickerName) {
+        await this.page.locator('[name="' + mediaPickerName + '"] [label="Remove"] svg').click();
+        await this.clickConfirmRemoveButton();
+    }
+    async isMediaNameVisible(mediaName, isVisible = true) {
+        return (0, test_1.expect)(this.mediaCardItems.filter({ hasText: mediaName })).toBeVisible({ visible: isVisible });
+    }
+    async clickResetFocalPointButton() {
+        await this.resetFocalPointBtn.click();
+    }
+    async setFocalPoint(widthPercentage = 50, heightPercentage = 50) {
+        await this.page.waitForTimeout(1000);
+        const element = await this.page.locator('#image').boundingBox();
+        if (!element) {
+            throw new Error('Element not found');
+        }
+        const centerX = element.x + element.width / 2;
+        const centerY = element.y + element.height / 2;
+        const x = element.x + (element.width * widthPercentage) / 100;
+        const y = element.y + (element.height * heightPercentage) / 100;
+        await this.page.waitForTimeout(200);
+        await this.page.mouse.move(centerX, centerY, { steps: 5 });
+        await this.page.waitForTimeout(200);
+        await this.page.mouse.down();
+        await this.page.waitForTimeout(200);
+        await this.page.mouse.move(x, y);
+        await this.page.waitForTimeout(200);
+        await this.page.mouse.up();
+    }
+    // Member Picker
+    async clickChooseMemberPickerButton() {
+        await this.chooseMemberPickerBtn.click();
+    }
+    async selectMemberByName(memberName) {
+        await this.sidebarModal.getByText(memberName, { exact: true }).click();
+    }
+    async removeMemberPickerByName(memberName) {
+        await this.page.locator('[name="' + memberName + '"]').getByLabel('Remove').click();
+        await this.clickConfirmRemoveButton();
+    }
+    // Numeric
+    async enterNumeric(number) {
+        await this.numericTxt.clear();
+        await this.numericTxt.fill(number.toString());
+    }
+    // Radiobox
+    async chooseRadioboxOption(optionValue) {
+        await this.page.locator('uui-radio[value="' + optionValue + '"] #button').click();
+    }
+    // Tags
+    async clickPlusIconButton() {
+        await this.plusIconBtn.click();
+    }
+    async enterTag(tagName) {
+        await this.enterTagTxt.fill(tagName);
+        await this.enterTagTxt.press('Enter');
+    }
+    async removeTagByName(tagName) {
+        await this.tagItems.filter({ hasText: tagName }).locator('svg').click();
+    }
+    // Multi URL Picker
+    async clickAddMultiURLPickerButton() {
+        await this.addMultiURLPickerBtn.click();
+    }
+    async selectLinkByName(linkName) {
+        await this.sidebarModal.getByText(linkName, { exact: true }).click();
+    }
+    async enterLink(value) {
+        await this.linkTxt.clear();
+        await this.linkTxt.fill(value);
+    }
+    async enterAnchorOrQuerystring(value) {
+        await this.anchorQuerystringTxt.clear();
+        await this.anchorQuerystringTxt.fill(value);
+    }
+    async enterLinkTitle(value) {
+        await this.linkTitleTxt.clear();
+        await this.linkTitleTxt.fill(value);
+    }
+    async removeUrlPickerByName(linkName) {
+        await this.page.locator('[name="' + linkName + '"]').getByLabel('Remove').click();
+        await this.clickConfirmRemoveButton();
+    }
+    async clickEditUrlPickerButtonByName(linkName) {
+        await this.page.locator('[name="' + linkName + '"]').getByLabel('Edit').click();
+    }
+    // Upload
+    async clickRemoveFilesButton() {
+        await this.removeFilesBtn.click();
+    }
+    // True/false
+    async clickToggleButton() {
+        await this.toggleBtn.click();
+    }
+    async doesToggleHaveLabel(label) {
+        return await (0, test_1.expect)(this.toggleInput).toHaveAttribute('aria-label', label);
+    }
+    // Multiple Text String
+    async clickAddMultipleTextStringButton() {
+        await this.addMultipleTextStringBtn.click();
+    }
+    async enterMultipleTextStringValue(value) {
+        await this.multipleTextStringValueTxt.clear();
+        await this.multipleTextStringValueTxt.fill(value);
+    }
+    async addMultipleTextStringItem(value) {
+        await this.clickAddMultipleTextStringButton();
+        await this.enterMultipleTextStringValue(value);
+    }
+    // Code Editor
+    async enterCodeEditorValue(value) {
+        await this.codeEditorTxt.clear();
+        await this.codeEditorTxt.fill(value);
+    }
+    // Markdown Editor
+    async enterMarkdownEditorValue(value) {
+        await this.markdownTxt.clear();
+        await this.markdownTxt.fill(value);
+    }
+    // Slider
+    async changeSliderValue(value) {
+        await this.sliderInput.fill(value);
+    }
+    async isDocumentTypeNameVisible(contentName, isVisible = true) {
+        return (0, test_1.expect)(this.sidebarModal.getByText(contentName)).toBeVisible({ visible: isVisible });
+    }
+    async doesModalHaveText(text) {
+        return (0, test_1.expect)(this.sidebarModal).toContainText(text);
+    }
+    // Collection tab
+    async isTabNameVisible(tabName) {
+        return (0, test_1.expect)(this.tabItems.filter({ hasText: tabName })).toBeVisible();
+    }
+    async doesDocumentWorkspaceHaveText(text) {
+        return (0, test_1.expect)(this.documentWorkspace).toContainText(text);
+    }
+    async doesDocumentTableColumnNameValuesMatch(expectedValues) {
+        return expectedValues.forEach((text, index) => {
+            (0, test_1.expect)(this.documentTableColumnNames.nth(index)).toHaveText(text);
+        });
+    }
+    async searchByKeywordInCollection(keyword) {
+        await this.searchTxt.clear();
+        await this.searchTxt.fill(keyword);
+        await this.searchTxt.press('Enter');
+        await this.page.waitForTimeout(500);
+    }
+    async clickVariantSelectorButton() {
+        await this.variantSelectorBtn.click();
+    }
+    async clickVariantAddModeButton() {
+        await this.variantAddModeBtn.first().click();
+        await this.page.waitForTimeout(500);
+    }
+    async clickSaveAndCloseButton() {
+        await this.saveAndCloseBtn.click();
+    }
+    // List View
+    async clickCreateContentWithName(name) {
+        await (0, test_1.expect)(this.page.getByLabel('Create ' + name)).toBeVisible();
+        await this.page.getByLabel('Create ' + name).click();
+    }
+    async enterNameInContainer(name) {
+        await this.enterNameInContainerTxt.fill(name);
+    }
+    async goToContentInListViewWithName(contentName) {
+        await this.listView.getByLabel(contentName).click();
+    }
+    async doesListViewHaveNoItemsInList() {
+        await (0, test_1.expect)(this.listView.filter({ hasText: 'There are no items to show in the list.' })).toBeVisible();
+    }
+    async clickNameButtonInListView() {
+        await this.nameBtn.click();
+    }
+    async doesFirstItemInListViewHaveName(name) {
+        await (0, test_1.expect)(this.listViewTableRow.first()).toContainText(name);
+    }
+    async doesListViewContainCount(count) {
+        await (0, test_1.expect)(this.listViewTableRow).toHaveCount(count);
+    }
+    async selectContentWithNameInListView(name) {
+        await this.listViewTableRow.filter({ hasText: name }).click();
+    }
+    async clickPublishSelectedListItems() {
+        await this.publishSelectedListItems.click();
+    }
+    async clickUnpublishSelectedListItems() {
+        await this.unpublishSelectedListItems.click();
+    }
+    async clickDuplicateToSelectedListItems() {
+        await this.duplicateToSelectedListItems.click({ force: true });
+    }
+    async clickMoveToSelectedListItems() {
+        await this.moveToSelectedListItems.click({ force: true });
+    }
+    async clickTrashSelectedListItems() {
+        await this.trashSelectedListItems.click();
+    }
+    async selectDocumentWithNameAtRoot(name) {
+        await this.clickCaretButtonForName('Content');
+        await this.modalContent.getByLabel(name).click({ force: true });
+        await this.clickChooseButton();
+    }
+    async clickTrashButton(toForceClick = false) {
+        await this.trashBtn.click({ force: toForceClick });
+    }
+    async isDocumentListViewVisible(isVisible = true) {
+        await (0, test_1.expect)(this.documentListView).toBeVisible({ visible: isVisible });
+    }
+    async isDocumentGridViewVisible(isVisible = true) {
+        await (0, test_1.expect)(this.documentGridView).toBeVisible({ visible: isVisible });
+    }
+}
+exports.ContentUiHelper = ContentUiHelper;
+//# sourceMappingURL=ContentUiHelper.js.map