@alfresco/aca-playwright-shared 5.1.1 → 5.2.0

package/esm2022/page-objects/components/search/search-filters.component.mjs

@@ -0,0 +1,45 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { BaseComponent } from '../base.component';
+class SearchFilters extends BaseComponent {
+    static rootElement = '.aca-content__advanced-filters';
+    constructor(page) {
+        super(page, SearchFilters.rootElement);
+    }
+    filtersButtons = this.page.locator('adf-search-widget-chip');
+    logicFilter = this.page.locator('adf-search-widget-chip', { hasText: 'Logic' });
+    propertiesFilter = this.page.locator('adf-search-widget-chip', { hasText: 'Properties' });
+    dateFilter = this.page.locator('adf-search-widget-chip', { hasText: 'Date' });
+    locationFilter = this.page.locator('adf-search-widget-chip', { hasText: 'Location' });
+    tagsFilter = this.page.locator('adf-search-widget-chip', { hasText: 'Tags' });
+    categoriesFilter = this.page.locator('adf-search-widget-chip', { hasText: 'Categories' });
+    resetButton = this.page.locator('button', { hasText: 'Reset' });
+    menuCardTitle = this.page.locator('.adf-search-filter-title');
+    menuCardClose = this.page.locator('.adf-search-filter-title-action');
+    menuCardClear = this.page.locator('#cancel-filter-button');
+    menuCardApply = this.page.locator('#apply-filter-button');
+    dropdownOptions = this.page.locator(`mat-option`);
+}
+export { SearchFilters };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/components/search/search-input.component.mjs

@@ -0,0 +1,48 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { BaseComponent } from '.././base.component';
+import { timeouts } from '../../../utils';
+class SearchInputComponent extends BaseComponent {
+    static rootElement = 'aca-page-layout';
+    searchInput = this.page.locator('#app-control-input');
+    searchButton = this.page.locator('.aca-search-input--search-button');
+    searchCloseButton = this.page.locator('.aca-search-input--close-button');
+    /**
+     * Method used in cases where user have possibility to navigate "inside" the element (it's clickable and has link attribute).
+     * Perform action .click() to navigate inside it
+     *
+     * @returns reference to cell element which contains link.
+     */
+    getCellLinkByName = (name) => this.getChild('.adf-datatable-row[role="row"]', { hasText: name });
+    constructor(page, rootElement = SearchInputComponent.rootElement) {
+        super(page, rootElement);
+    }
+    async performDoubleClickFolderOrFileToOpen(name) {
+        await this.getCellLinkByName(name).waitFor({ state: 'visible', timeout: timeouts.medium });
+        await this.getCellLinkByName(name).dblclick();
+        await this.spinnerWaitForReload();
+    }
+}
+export { SearchInputComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/components/search/search-overlay.components.mjs

@@ -0,0 +1,83 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { BaseComponent } from '.././base.component';
+class SearchOverlayComponent extends BaseComponent {
+    static rootElement = '.cdk-overlay-pane';
+    searchFilesOption = this.getChild('input#content-input');
+    searchFoldersOption = this.getChild('input#folder-input');
+    searchLibrariesOption = this.getChild('input#libraries-input');
+    searchInput = this.page.locator('#app-control-input');
+    searchButton = this.page.locator('app-search-input-control button[title="Search"]');
+    searchInputControl = this.page.locator('.app-search-control');
+    searchOptions = this.page.locator('.app-search-options');
+    constructor(page, rootElement = SearchOverlayComponent.rootElement) {
+        super(page, rootElement);
+    }
+    async isFoldersOptionChecked() {
+        const optClass = await this.searchFoldersOption.getAttribute('class');
+        return optClass.includes('.mat-mdc-checkbox-checked');
+    }
+    async isFilesOptionChecked() {
+        const optClass = await this.searchFilesOption.getAttribute('class');
+        return optClass.includes('.mat-mdc-checkbox-checked');
+    }
+    async isLibrariesOptionChecked() {
+        const optClass = await this.searchLibrariesOption.getAttribute('class');
+        return optClass.includes('.mat-mdc-checkbox-checked');
+    }
+    async clearOptions() {
+        if (await this.isFilesOptionChecked()) {
+            await this.searchFilesOption.click();
+        }
+        if (await this.isFoldersOptionChecked()) {
+            await this.searchFoldersOption.click();
+        }
+        if (await this.isLibrariesOptionChecked()) {
+            await this.searchLibrariesOption.click();
+        }
+    }
+    async checkOnlyFolders() {
+        await this.clearOptions();
+        await this.searchFoldersOption.click();
+    }
+    async checkOnlyFiles() {
+        await this.clearOptions();
+        await this.searchFilesOption.click();
+    }
+    async checkLibraries() {
+        await this.clearOptions();
+        await this.searchLibrariesOption.click();
+    }
+    async checkFilesAndFolders() {
+        await this.clearOptions();
+        await this.searchFilesOption.click();
+        await this.searchFoldersOption.click();
+    }
+    async searchFor(input) {
+        await this.searchInput.fill(input);
+        await this.searchButton.click({ force: true });
+    }
+}
+export { SearchOverlayComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/components/search/search-sorting-picker.components.mjs

@@ -0,0 +1,72 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { BaseComponent } from '../base.component';
+class SearchSortingPicker extends BaseComponent {
+    static rootElement = '#aca-button-action-menu';
+    actionMenu = this.page.locator('[data-automation-id="auto_header_content_id_$thumbnail"]');
+    sortOrderButton = this.page.locator('#aca-button-sorting-menu');
+    sortByDropdownExpanded = this.page.locator('.mat-mdc-menu-panel').first();
+    sortByList = this.page.locator('.mat-mdc-menu-panel button');
+    constructor(page, rootElement = SearchSortingPicker.rootElement) {
+        super(page, rootElement);
+    }
+    async waitForSortByDropdownToExpand() {
+        await this.sortByDropdownExpanded.waitFor();
+    }
+    async isSortOrderButtonDisplayed() {
+        return this.sortOrderButton.isVisible();
+    }
+    async isSortByDropdownExpanded() {
+        return this.sortByDropdownExpanded.isVisible();
+    }
+    async clickSortByDropdown() {
+        await this.sortOrderButton.click();
+        await this.waitForSortByDropdownToExpand();
+    }
+    async getSortByOptionsList() {
+        const sortOptionsCount = await this.sortByList.count();
+        const sortByOptions = [];
+        for (let i = 1; i < sortOptionsCount; i++) {
+            const textContent = (await this.sortByList.nth(i).textContent()).trim();
+            sortByOptions.push(textContent);
+        }
+        sortByOptions.sort((a, b) => a.localeCompare(b));
+        return sortByOptions;
+    }
+    async sortBy(option, direction) {
+        await this.actionMenu.click();
+        await this.clickSortByDropdown();
+        if (!(await this.isSortByDropdownExpanded())) {
+            await this.clickSortByDropdown();
+        }
+        const elem = this.sortByList.getByText(option);
+        const optionId = await elem.locator('..').getAttribute('id');
+        await elem.click();
+        const directionSortElement = this.page.locator(`[id="${optionId}-${direction.toLocaleLowerCase()}"]`);
+        await directionSortElement.click();
+        await this.progressBarWaitForReload();
+    }
+}
+export { SearchSortingPicker };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/components/sidenav.component.mjs

@@ -0,0 +1,88 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { SIDEBAR_LABELS, timeouts } from '../../utils';
+import { BaseComponent } from './base.component';
+class SidenavComponent extends BaseComponent {
+    static rootElement = 'app-sidenav';
+    personalFiles = this.getChild(`[data-automation-id='app.navbar.personalFiles']`);
+    myLibraries = this.getChild(`[data-automation-id='app.navbar.libraries.files']`);
+    favoriteLibraries = this.getChild(`[data-automation-id='app.navbar.libraries.favorite']`);
+    shared = this.getChild(`[data-automation-id='app.navbar.shared']`);
+    recentFiles = this.getChild(`[data-automation-id='app.navbar.recentFiles']`);
+    favorites = this.getChild(`[data-automation-id='app.navbar.favorites']`);
+    trash = this.getChild(`[data-automation-id='app.navbar.trashcan']`);
+    sidenavToggle = this.getChild(`.aca-sidenav-header-title-logo`);
+    sidenavExpand = this.page.getByTitle('Expand navigation menu');
+    expandedSidenav = this.page.locator(`[data-automation-id='expanded']`);
+    constructor(page) {
+        super(page, SidenavComponent.rootElement);
+    }
+    async isActive(name) {
+        const cssClass = await this.getLinkLabel(name).getAttribute('class');
+        return cssClass.includes('action-button--active');
+    }
+    async openPanel(name) {
+        await this.getLinkLabel(name).click();
+    }
+    getLinkLabel(name) {
+        switch (name) {
+            case SIDEBAR_LABELS.PERSONAL_FILES:
+                return this.personalFiles;
+            case SIDEBAR_LABELS.MY_LIBRARIES:
+                return this.myLibraries;
+            case SIDEBAR_LABELS.FAVORITE_LIBRARIES:
+                return this.favoriteLibraries;
+            case SIDEBAR_LABELS.SHARED_FILES:
+                return this.shared;
+            case SIDEBAR_LABELS.RECENT_FILES:
+                return this.recentFiles;
+            case SIDEBAR_LABELS.FAVORITES:
+                return this.favorites;
+            case SIDEBAR_LABELS.TRASH:
+                return this.trash;
+            default:
+                return this.personalFiles;
+        }
+    }
+    async isSidenavExpanded() {
+        await this.page.waitForTimeout(timeouts.tiny);
+        return this.expandedSidenav.isVisible();
+    }
+    async expandSideNav() {
+        const expanded = await this.isSidenavExpanded();
+        if (!expanded) {
+            await this.sidenavExpand.click();
+            await this.expandedSidenav.waitFor({ state: 'attached' });
+        }
+    }
+    async collapseSideNav() {
+        const expanded = await this.isSidenavExpanded();
+        if (expanded) {
+            await this.sidenavToggle.click();
+            await this.expandedSidenav.waitFor({ state: 'detached' });
+        }
+    }
+}
+export { SidenavComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sidenav.component.js","sourceRoot":"","sources":["../../../../../../projects/aca-playwright-shared/src/page-objects/components/sidenav.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,MAAa,gBAAiB,SAAQ,aAAa;IACzC,MAAM,CAAC,WAAW,GAAG,aAAa,CAAC;IAEnC,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,iDAAiD,CAAC,CAAC;IACjF,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,mDAAmD,CAAC,CAAC;IACjF,iBAAiB,GAAG,IAAI,CAAC,QAAQ,CAAC,sDAAsD,CAAC,CAAC;IAC1F,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,0CAA0C,CAAC,CAAC;IACnE,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,+CAA+C,CAAC,CAAC;IAC7E,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,6CAA6C,CAAC,CAAC;IACzE,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,4CAA4C,CAAC,CAAC;IACpE,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,gCAAgC,CAAC,CAAC;IAChE,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,wBAAwB,CAAC,CAAC;IAChE,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,iCAAiC,CAAC,CAAC;IAE9E,YAAY,IAAU;QACpB,KAAK,CAAC,IAAI,EAAE,gBAAgB,CAAC,WAAW,CAAC,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,IAAY;QACzB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACrE,OAAO,QAAQ,CAAC,QAAQ,CAAC,uBAAuB,CAAC,CAAC;IACpD,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,IAAY;QAC1B,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;IACxC,CAAC;IAEO,YAAY,CAAC,IAAY;QAC/B,QAAQ,IAAI,EAAE;YACZ,KAAK,cAAc,CAAC,cAAc;gBAChC,OAAO,IAAI,CAAC,aAAa,CAAC;YAC5B,KAAK,cAAc,CAAC,YAAY;gBAC9B,OAAO,IAAI,CAAC,WAAW,CAAC;YAC1B,KAAK,cAAc,CAAC,kBAAkB;gBACpC,OAAO,IAAI,CAAC,iBAAiB,CAAC;YAChC,KAAK,cAAc,CAAC,YAAY;gBAC9B,OAAO,IAAI,CAAC,MAAM,CAAC;YACrB,KAAK,cAAc,CAAC,YAAY;gBAC9B,OAAO,IAAI,CAAC,WAAW,CAAC;YAC1B,KAAK,cAAc,CAAC,SAAS;gBAC3B,OAAO,IAAI,CAAC,SAAS,CAAC;YACxB,KAAK,cAAc,CAAC,KAAK;gBACvB,OAAO,IAAI,CAAC,KAAK,CAAC;YACpB;gBACE,OAAO,IAAI,CAAC,aAAa,CAAC;SAC7B;IACH,CAAC;IAED,KAAK,CAAC,iBAAiB;QACrB,MAAM,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC9C,OAAO,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC;IAC1C,CAAC;IAED,KAAK,CAAC,aAAa;QACjB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAChD,IAAI,CAAC,QAAQ,EAAE;YACb,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YACjC,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;SAC3D;IACH,CAAC;IAED,KAAK,CAAC,eAAe;QACnB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAChD,IAAI,QAAQ,EAAE;YACZ,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YACjC,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;SAC3D;IACH,CAAC;;SAnEU,gBAAgB","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { SIDEBAR_LABELS, timeouts } from '../../utils';\nimport { BaseComponent } from './base.component';\nimport { Locator, Page } from '@playwright/test';\n\nexport class SidenavComponent extends BaseComponent {\n  private static rootElement = 'app-sidenav';\n\n  private personalFiles = this.getChild(`[data-automation-id='app.navbar.personalFiles']`);\n  private myLibraries = this.getChild(`[data-automation-id='app.navbar.libraries.files']`);\n  private favoriteLibraries = this.getChild(`[data-automation-id='app.navbar.libraries.favorite']`);\n  private shared = this.getChild(`[data-automation-id='app.navbar.shared']`);\n  private recentFiles = this.getChild(`[data-automation-id='app.navbar.recentFiles']`);\n  private favorites = this.getChild(`[data-automation-id='app.navbar.favorites']`);\n  private trash = this.getChild(`[data-automation-id='app.navbar.trashcan']`);\n  private sidenavToggle = this.getChild(`.aca-sidenav-header-title-logo`);\n  private sidenavExpand = this.page.getByTitle('Expand navigation menu');\n  public expandedSidenav = this.page.locator(`[data-automation-id='expanded']`);\n\n  constructor(page: Page) {\n    super(page, SidenavComponent.rootElement);\n  }\n\n  async isActive(name: string): Promise<boolean> {\n    const cssClass = await this.getLinkLabel(name).getAttribute('class');\n    return cssClass.includes('action-button--active');\n  }\n\n  async openPanel(name: string): Promise<void> {\n    await this.getLinkLabel(name).click();\n  }\n\n  private getLinkLabel(name: string): Locator {\n    switch (name) {\n      case SIDEBAR_LABELS.PERSONAL_FILES:\n        return this.personalFiles;\n      case SIDEBAR_LABELS.MY_LIBRARIES:\n        return this.myLibraries;\n      case SIDEBAR_LABELS.FAVORITE_LIBRARIES:\n        return this.favoriteLibraries;\n      case SIDEBAR_LABELS.SHARED_FILES:\n        return this.shared;\n      case SIDEBAR_LABELS.RECENT_FILES:\n        return this.recentFiles;\n      case SIDEBAR_LABELS.FAVORITES:\n        return this.favorites;\n      case SIDEBAR_LABELS.TRASH:\n        return this.trash;\n      default:\n        return this.personalFiles;\n    }\n  }\n\n  async isSidenavExpanded(): Promise<boolean> {\n    await this.page.waitForTimeout(timeouts.tiny);\n    return this.expandedSidenav.isVisible();\n  }\n\n  async expandSideNav(): Promise<void> {\n    const expanded = await this.isSidenavExpanded();\n    if (!expanded) {\n      await this.sidenavExpand.click();\n      await this.expandedSidenav.waitFor({ state: 'attached' });\n    }\n  }\n\n  async collapseSideNav(): Promise<void> {\n    const expanded = await this.isSidenavExpanded();\n    if (expanded) {\n      await this.sidenavToggle.click();\n      await this.expandedSidenav.waitFor({ state: 'detached' });\n    }\n  }\n}\n"]}

package/esm2022/page-objects/components/snackBar/snack-bar.component.mjs

@@ -0,0 +1,54 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { expect } from '@playwright/test';
+import { BaseComponent } from '../base.component';
+class SnackBarComponent extends BaseComponent {
+    static rootElement = 'adf-snackbar-content';
+    message = this.getChild('[data-automation-id="adf-snackbar-message-content"]').first();
+    actionButton = this.getChild('[data-automation-id="adf-snackbar-message-content-action-button"]');
+    closeIcon = this.getChild('.adf-snackbar-message-content-action-icon');
+    getByMessageLocator = (message) => this.getChild(`[data-automation-id='adf-snackbar-message-content']`, { hasText: message }).first();
+    constructor(page, rootElement = SnackBarComponent.rootElement) {
+        super(page, rootElement);
+    }
+    async getSnackBarMessage() {
+        return this.message.textContent();
+    }
+    async getSnackBarActionText() {
+        if (await this.actionButton.isVisible()) {
+            return this.actionButton.textContent();
+        }
+        else {
+            return '';
+        }
+    }
+    async verifySnackBarActionText(text) {
+        expect(await this.message.textContent()).toContain(text);
+    }
+    async clickSnackBarAction() {
+        await this.actionButton.click();
+    }
+}
+export { SnackBarComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/components/spinner.component.mjs

@@ -0,0 +1,41 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { BaseComponent } from './base.component';
+class SpinnerComponent extends BaseComponent {
+    static rootElement = 'mat-progress-spinner';
+    constructor(page, rootElement = SpinnerComponent.rootElement) {
+        super(page, rootElement);
+    }
+    async waitForReload() {
+        try {
+            await this.getChild('').waitFor({ state: 'attached', timeout: 2000 });
+            await this.getChild('').waitFor({ state: 'detached', timeout: 2000 });
+        }
+        catch (e) {
+            this.logger.info('Spinner was not present');
+        }
+    }
+}
+export { SpinnerComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Bpbm5lci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtcGxheXdyaWdodC1zaGFyZWQvc3JjL3BhZ2Utb2JqZWN0cy9jb21wb25lbnRzL3NwaW5uZXIuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBR0gsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRWpELE1BQWEsZ0JBQWlCLFNBQVEsYUFBYTtJQUN6QyxNQUFNLENBQUMsV0FBVyxHQUFHLHNCQUFzQixDQUFDO0lBRXBELFlBQVksSUFBVSxFQUFFLFdBQVcsR0FBRyxnQkFBZ0IsQ0FBQyxXQUFXO1FBQ2hFLEtBQUssQ0FBQyxJQUFJLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVELEtBQUssQ0FBQyxhQUFhO1FBQ2pCLElBQUk7WUFDRixNQUFNLElBQUksQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUMsT0FBTyxDQUFDLEVBQUUsS0FBSyxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztZQUN0RSxNQUFNLElBQUksQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUMsT0FBTyxDQUFDLEVBQUUsS0FBSyxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztTQUN2RTtRQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQ1YsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMseUJBQXlCLENBQUMsQ0FBQztTQUM3QztJQUNILENBQUM7O1NBZFUsZ0JBQWdCIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI0IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uXG4gKlxuICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbi5cbiAqIElmIHRoZSBzb2Z0d2FyZSB3YXMgcHVyY2hhc2VkIHVuZGVyIGEgcGFpZCBBbGZyZXNjbyBsaWNlbnNlLCB0aGUgdGVybXMgb2ZcbiAqIHRoZSBwYWlkIGxpY2Vuc2UgYWdyZWVtZW50IHdpbGwgcHJldmFpbC4gT3RoZXJ3aXNlLCB0aGUgc29mdHdhcmUgaXNcbiAqIHByb3ZpZGVkIHVuZGVyIHRoZSBmb2xsb3dpbmcgb3BlbiBzb3VyY2UgbGljZW5zZSB0ZXJtczpcbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnlcbiAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieVxuICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3JcbiAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uXG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLFxuICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2ZcbiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZVxuICogR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuXG4gKlxuICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlXG4gKiBmcm9tIEh5bGFuZCBTb2Z0d2FyZS4gSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LlxuICovXG5cbmltcG9ydCB7IFBhZ2UgfSBmcm9tICdAcGxheXdyaWdodC90ZXN0JztcbmltcG9ydCB7IEJhc2VDb21wb25lbnQgfSBmcm9tICcuL2Jhc2UuY29tcG9uZW50JztcblxuZXhwb3J0IGNsYXNzIFNwaW5uZXJDb21wb25lbnQgZXh0ZW5kcyBCYXNlQ29tcG9uZW50IHtcbiAgcHJpdmF0ZSBzdGF0aWMgcm9vdEVsZW1lbnQgPSAnbWF0LXByb2dyZXNzLXNwaW5uZXInO1xuXG4gIGNvbnN0cnVjdG9yKHBhZ2U6IFBhZ2UsIHJvb3RFbGVtZW50ID0gU3Bpbm5lckNvbXBvbmVudC5yb290RWxlbWVudCkge1xuICAgIHN1cGVyKHBhZ2UsIHJvb3RFbGVtZW50KTtcbiAgfVxuXG4gIGFzeW5jIHdhaXRGb3JSZWxvYWQoKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgdHJ5IHtcbiAgICAgIGF3YWl0IHRoaXMuZ2V0Q2hpbGQoJycpLndhaXRGb3IoeyBzdGF0ZTogJ2F0dGFjaGVkJywgdGltZW91dDogMjAwMCB9KTtcbiAgICAgIGF3YWl0IHRoaXMuZ2V0Q2hpbGQoJycpLndhaXRGb3IoeyBzdGF0ZTogJ2RldGFjaGVkJywgdGltZW91dDogMjAwMCB9KTtcbiAgICB9IGNhdGNoIChlKSB7XG4gICAgICB0aGlzLmxvZ2dlci5pbmZvKCdTcGlubmVyIHdhcyBub3QgcHJlc2VudCcpO1xuICAgIH1cbiAgfVxufVxuIl19