@alfresco/aca-playwright-shared 5.1.1 → 5.2.0

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

@@ -0,0 +1,174 @@
+/*!
+ * 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 { MatMenuComponent } from './dataTable/mat-menu.component';
+import { timeouts } from '../../utils';
+export var PaginationActionsType;
+(function (PaginationActionsType) {
+    PaginationActionsType["PageSizeSelector"] = "Page size selector";
+    PaginationActionsType["CurrentPageSelector"] = "Current page selector";
+    PaginationActionsType["NextPageSelector"] = "Next page button";
+})(PaginationActionsType || (PaginationActionsType = {}));
+class PaginationComponent extends BaseComponent {
+    static rootElement = 'adf-pagination';
+    constructor(page) {
+        super(page, PaginationComponent.rootElement);
+    }
+    range = this.getChild('.adf-pagination__range');
+    maxItems = this.getChild('.adf-pagination__max-items');
+    currentPage = this.getChild('.adf-pagination__current-page');
+    totalPages = this.getChild('.adf-pagination__total-pages');
+    previousButton = this.getChild('.adf-pagination__previous-button');
+    nextButton = this.getChild('.adf-pagination__next-button');
+    maxItemsButton = this.getChild('.adf-pagination__max-items + button[mat-icon-button]');
+    itemsPerPageMenu = new MatMenuComponent(this.page);
+    currentPageLocator = this.getChild('.adf-pagination__current-page');
+    totalPageLocator = this.getChild('.adf-pagination__total-pages');
+    getArrowLocatorFor = (action) => this.getChild(`[aria-label="${action}"]`);
+    async setItemsPerPage(amount) {
+        await this.getArrowLocatorFor(PaginationActionsType.PageSizeSelector).click();
+        await this.itemsPerPageMenu.getButtonByText(amount.toString()).click();
+        await this.spinnerWaitForReload();
+    }
+    async navigateToPage(pageNumber) {
+        await this.getArrowLocatorFor(PaginationActionsType.CurrentPageSelector).click();
+        await this.itemsPerPageMenu.getButtonByText(pageNumber.toString()).click();
+        await this.spinnerWaitForReload();
+    }
+    async spinnerWaitForReload() {
+        try {
+            await this.page.locator('mat-progress-spinner').waitFor({ state: 'attached', timeout: 2000 });
+            await this.page.locator('mat-progress-spinner').waitFor({ state: 'detached', timeout: 2000 });
+        }
+        catch (e) {
+            this.logger.info('Spinner was not present');
+        }
+    }
+    async getRange() {
+        return this.range.innerText();
+    }
+    async getMaxItems() {
+        return this.maxItems.innerText();
+    }
+    async getCurrentPage() {
+        return this.currentPage.innerText();
+    }
+    async getTotalPages() {
+        return this.totalPages.innerText();
+    }
+    async isPreviousEnabled() {
+        return this.previousButton.isEnabled();
+    }
+    async isNextEnabled() {
+        await this.page.waitForTimeout(timeouts.tiny);
+        return this.nextButton.isEnabled();
+    }
+    async clickOnNextPage() {
+        try {
+            if (await this.isNextEnabled()) {
+                await this.nextButton.click();
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed on previous click: ${error}`);
+        }
+    }
+    async clickOnPreviousPage() {
+        try {
+            if (await this.isPreviousEnabled()) {
+                await this.previousButton.click();
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed on previous click: ${error}`);
+        }
+    }
+    async openMaxItemsMenu() {
+        try {
+            await this.maxItemsButton.waitFor({ state: 'visible' });
+            await this.maxItemsButton.click();
+        }
+        catch (error) {
+            throw new Error(`Open max items catch: ${error}`);
+        }
+    }
+    async resetToDefaultPageSize() {
+        try {
+            await this.openMaxItemsMenu();
+            await this.clickNthItem(1);
+            await this.page.waitForTimeout(timeouts.tiny);
+        }
+        catch (error) {
+            throw new Error(`Reset to default page size catch: ${error}`);
+        }
+    }
+    async clickMenuItem(menuItem) {
+        try {
+            await this.page.getByRole('menuitem', { name: menuItem }).click();
+        }
+        catch (e) {
+            throw new Error(`Click menu item catch : failed to click on: ${e}`);
+        }
+    }
+    async getNthItem(nth) {
+        return this.page.getByRole('menuitem').nth(nth - 1);
+    }
+    async getItemsCount() {
+        return this.page.getByRole('menuitem').count();
+    }
+    async clickNthItem(nth) {
+        try {
+            await (await this.getNthItem(nth)).click();
+        }
+        catch (e) {
+            throw new Error(`Click nth menu item catch: ${e}`);
+        }
+    }
+    async closeMenu() {
+        await this.page.keyboard.press('Escape');
+    }
+    async isRangePresent() {
+        return this.range.isVisible();
+    }
+    async getMaxRange() {
+        return this.range.textContent();
+    }
+    async isMaxItemsPresent() {
+        return this.maxItems.isVisible();
+    }
+    async isCurrentPagePresent() {
+        return this.currentPage.isVisible();
+    }
+    async isTotalPagesPresent() {
+        return this.totalPages.isVisible();
+    }
+    async isPreviousButtonPresent() {
+        return this.previousButton.isVisible();
+    }
+    async isNextButtonPresent() {
+        return this.nextButton.isVisible();
+    }
+}
+export { PaginationComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.component.js","sourceRoot":"","sources":["../../../../../../projects/aca-playwright-shared/src/page-objects/components/pagination.component.ts"],"names":[],"mappings":"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","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 { BaseComponent } from './base.component';\nimport { Locator, Page } from '@playwright/test';\nimport { MatMenuComponent } from './dataTable/mat-menu.component';\nimport { timeouts } from '../../utils';\n\nexport enum PaginationActionsType {\n  PageSizeSelector = 'Page size selector',\n  CurrentPageSelector = 'Current page selector',\n  NextPageSelector = 'Next page button'\n}\n\nexport class PaginationComponent extends BaseComponent {\n  private static rootElement = 'adf-pagination';\n\n  constructor(page: Page) {\n    super(page, PaginationComponent.rootElement);\n  }\n\n  private range = this.getChild('.adf-pagination__range');\n  private maxItems = this.getChild('.adf-pagination__max-items');\n  private currentPage = this.getChild('.adf-pagination__current-page');\n  private totalPages = this.getChild('.adf-pagination__total-pages');\n  private previousButton = this.getChild('.adf-pagination__previous-button');\n  private nextButton = this.getChild('.adf-pagination__next-button');\n  private maxItemsButton = this.getChild('.adf-pagination__max-items + button[mat-icon-button]');\n\n  private itemsPerPageMenu = new MatMenuComponent(this.page);\n\n  public currentPageLocator = this.getChild('.adf-pagination__current-page');\n  public totalPageLocator = this.getChild('.adf-pagination__total-pages');\n  public getArrowLocatorFor = (action: PaginationActionsType) => this.getChild(`[aria-label=\"${action}\"]`);\n\n  async setItemsPerPage(amount: number): Promise<void> {\n    await this.getArrowLocatorFor(PaginationActionsType.PageSizeSelector).click();\n    await this.itemsPerPageMenu.getButtonByText(amount.toString()).click();\n    await this.spinnerWaitForReload();\n  }\n\n  async navigateToPage(pageNumber: number): Promise<void> {\n    await this.getArrowLocatorFor(PaginationActionsType.CurrentPageSelector).click();\n    await this.itemsPerPageMenu.getButtonByText(pageNumber.toString()).click();\n    await this.spinnerWaitForReload();\n  }\n\n  async spinnerWaitForReload(): Promise<void> {\n    try {\n      await this.page.locator('mat-progress-spinner').waitFor({ state: 'attached', timeout: 2000 });\n      await this.page.locator('mat-progress-spinner').waitFor({ state: 'detached', timeout: 2000 });\n    } catch (e) {\n      this.logger.info('Spinner was not present');\n    }\n  }\n\n  async getRange(): Promise<string> {\n    return this.range.innerText();\n  }\n\n  async getMaxItems(): Promise<string> {\n    return this.maxItems.innerText();\n  }\n\n  async getCurrentPage(): Promise<string> {\n    return this.currentPage.innerText();\n  }\n\n  async getTotalPages(): Promise<string> {\n    return this.totalPages.innerText();\n  }\n\n  async isPreviousEnabled(): Promise<boolean> {\n    return this.previousButton.isEnabled();\n  }\n\n  async isNextEnabled(): Promise<boolean> {\n    await this.page.waitForTimeout(timeouts.tiny);\n    return this.nextButton.isEnabled();\n  }\n\n  async clickOnNextPage(): Promise<void> {\n    try {\n      if (await this.isNextEnabled()) {\n        await this.nextButton.click();\n      }\n    } catch (error) {\n      throw new Error(`Failed on previous click: ${error}`);\n    }\n  }\n\n  async clickOnPreviousPage(): Promise<void> {\n    try {\n      if (await this.isPreviousEnabled()) {\n        await this.previousButton.click();\n      }\n    } catch (error) {\n      throw new Error(`Failed on previous click: ${error}`);\n    }\n  }\n\n  async openMaxItemsMenu(): Promise<void> {\n    try {\n      await this.maxItemsButton.waitFor({ state: 'visible' });\n      await this.maxItemsButton.click();\n    } catch (error) {\n      throw new Error(`Open max items catch: ${error}`);\n    }\n  }\n\n  async resetToDefaultPageSize(): Promise<void> {\n    try {\n      await this.openMaxItemsMenu();\n      await this.clickNthItem(1);\n      await this.page.waitForTimeout(timeouts.tiny);\n    } catch (error) {\n      throw new Error(`Reset to default page size catch: ${error}`);\n    }\n  }\n\n  async clickMenuItem(menuItem: string): Promise<void> {\n    try {\n      await this.page.getByRole('menuitem', { name: menuItem }).click();\n    } catch (e) {\n      throw new Error(`Click menu item catch : failed to click on: ${e}`);\n    }\n  }\n\n  async getNthItem(nth: number): Promise<Locator> {\n    return this.page.getByRole('menuitem').nth(nth - 1);\n  }\n\n  async getItemsCount(): Promise<number> {\n    return this.page.getByRole('menuitem').count();\n  }\n\n  async clickNthItem(nth: number): Promise<void> {\n    try {\n      await (await this.getNthItem(nth)).click();\n    } catch (e) {\n      throw new Error(`Click nth menu item catch: ${e}`);\n    }\n  }\n\n  async closeMenu(): Promise<void> {\n    await this.page.keyboard.press('Escape');\n  }\n\n  async isRangePresent(): Promise<boolean> {\n    return this.range.isVisible();\n  }\n\n  async getMaxRange(): Promise<string> {\n    return this.range.textContent();\n  }\n\n  async isMaxItemsPresent(): Promise<boolean> {\n    return this.maxItems.isVisible();\n  }\n\n  async isCurrentPagePresent(): Promise<boolean> {\n    return this.currentPage.isVisible();\n  }\n\n  async isTotalPagesPresent(): Promise<boolean> {\n    return this.totalPages.isVisible();\n  }\n\n  async isPreviousButtonPresent(): Promise<boolean> {\n    return this.previousButton.isVisible();\n  }\n\n  async isNextButtonPresent(): Promise<boolean> {\n    return this.nextButton.isVisible();\n  }\n}\n"]}

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

@@ -0,0 +1,33 @@
+/*!
+ * 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 SearchFiltersCategories extends BaseComponent {
+    static rootElement = '.adf-search-filter-menu-card';
+    constructor(page) {
+        super(page, SearchFiltersCategories.rootElement);
+    }
+    addOptionInput = this.getChild(`[data-automation-id$='adf-search-chip-autocomplete-input']`);
+}
+export { SearchFiltersCategories };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLWZpbHRlcnMtY2F0ZWdvcmllcy5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtcGxheXdyaWdodC1zaGFyZWQvc3JjL3BhZ2Utb2JqZWN0cy9jb21wb25lbnRzL3NlYXJjaC9zZWFyY2gtZmlsdGVycy9zZWFyY2gtZmlsdGVycy1jYXRlZ29yaWVzLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUVILE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUdyRCxNQUFhLHVCQUF3QixTQUFRLGFBQWE7SUFDaEQsTUFBTSxDQUFDLFdBQVcsR0FBRyw4QkFBOEIsQ0FBQztJQUU1RCxZQUFZLElBQVU7UUFDcEIsS0FBSyxDQUFDLElBQUksRUFBRSx1QkFBdUIsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNuRCxDQUFDO0lBRU0sY0FBYyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsNERBQTRELENBQUMsQ0FBQzs7U0FQekYsdUJBQXVCIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI0IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uXG4gKlxuICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbi5cbiAqIElmIHRoZSBzb2Z0d2FyZSB3YXMgcHVyY2hhc2VkIHVuZGVyIGEgcGFpZCBBbGZyZXNjbyBsaWNlbnNlLCB0aGUgdGVybXMgb2ZcbiAqIHRoZSBwYWlkIGxpY2Vuc2UgYWdyZWVtZW50IHdpbGwgcHJldmFpbC4gT3RoZXJ3aXNlLCB0aGUgc29mdHdhcmUgaXNcbiAqIHByb3ZpZGVkIHVuZGVyIHRoZSBmb2xsb3dpbmcgb3BlbiBzb3VyY2UgbGljZW5zZSB0ZXJtczpcbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnlcbiAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieVxuICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3JcbiAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uXG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLFxuICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2ZcbiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZVxuICogR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuXG4gKlxuICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlXG4gKiBmcm9tIEh5bGFuZCBTb2Z0d2FyZS4gSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LlxuICovXG5cbmltcG9ydCB7IEJhc2VDb21wb25lbnQgfSBmcm9tICcuLi8uLi9iYXNlLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBQYWdlIH0gZnJvbSAnQHBsYXl3cmlnaHQvdGVzdCc7XG5cbmV4cG9ydCBjbGFzcyBTZWFyY2hGaWx0ZXJzQ2F0ZWdvcmllcyBleHRlbmRzIEJhc2VDb21wb25lbnQge1xuICBwcml2YXRlIHN0YXRpYyByb290RWxlbWVudCA9ICcuYWRmLXNlYXJjaC1maWx0ZXItbWVudS1jYXJkJztcblxuICBjb25zdHJ1Y3RvcihwYWdlOiBQYWdlKSB7XG4gICAgc3VwZXIocGFnZSwgU2VhcmNoRmlsdGVyc0NhdGVnb3JpZXMucm9vdEVsZW1lbnQpO1xuICB9XG5cbiAgcHVibGljIGFkZE9wdGlvbklucHV0ID0gdGhpcy5nZXRDaGlsZChgW2RhdGEtYXV0b21hdGlvbi1pZCQ9J2FkZi1zZWFyY2gtY2hpcC1hdXRvY29tcGxldGUtaW5wdXQnXWApO1xufVxuIl19

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

@@ -0,0 +1,115 @@
+/*!
+ * 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 { expect } from '@playwright/test';
+class SearchFiltersDate extends BaseComponent {
+    static rootElement = '.adf-search-filter-menu-card';
+    constructor(page) {
+        super(page, SearchFiltersDate.rootElement);
+    }
+    createdTab = this.getChild(`[role='tab']`, { hasText: 'Created' });
+    modifiedTab = this.getChild(`[role='tab']`, { hasText: 'Modified' });
+    createdTabTitle = this.createdTab.locator(`div`);
+    modifiedTabTitle = this.modifiedTab.locator(`div`);
+    anytimeButton = this.getChild(`[data-automation-id$='date-range-anytime']`);
+    anytimeRadioButton = this.anytimeButton.locator(`input`);
+    inTheLastButton = this.getChild(`[data-automation-id$='date-range-in-last']`);
+    inTheLastInput = this.getChild(`[data-automation-id$='date-range-in-last-input']`);
+    inTheLastDropdown = this.getChild(`[data-automation-id$='date-range-in-last-dropdown']`);
+    betweenButton = this.getChild(`[data-automation-id$='date-range-between']`);
+    betweenRadioButton = this.betweenButton.locator(`input`);
+    betweenStartDate = this.getChild(`[data-automation-id$='date-range-between-start-input']`);
+    betweenEndDate = this.getChild(`[data-automation-id$='date-range-between-end-input']`);
+    async openCreatedModifiedTab(page, tab) {
+        switch (tab) {
+            case 'Created':
+                await page.searchFiltersDate.createdTab.click();
+                break;
+            case 'Modified':
+                await page.searchFiltersDate.modifiedTab.click();
+                break;
+            default:
+                break;
+        }
+        await page.page.waitForTimeout(2000);
+    }
+    /**
+     * Method used in cases where we want to filter search results by Date
+     *
+     * @param searchPage page context for the test
+     * @param filterType filter type for the Date filter
+     * @param dateFilterTab tab in Date filter. Either Created or Modified
+     * @param searchPhrase search phrase for the search
+     * @param searchType type of items we want in search results e.g. files or folders
+     * @param expectSearchResults expect a number of search results
+     * @param inTheLastInputValue a value for 'in the last' input. e.g. in the last X days
+     * @param startDay start day for time-frame search. DD-MMMM-YY
+     * @param endDay end day for time-frame search. DD-MMMM-YY
+     */
+    async filterFilesByDate(params) {
+        const { searchPage, filterType, dateFilterTab, searchPhrase, searchType, expectSearchResults, inTheLastInputValue, startDay, endDay } = params;
+        await searchPage.searchWithin(searchPhrase, searchType);
+        await searchPage.searchFilters.dateFilter.click();
+        if (dateFilterTab === 'Modified') {
+            await searchPage.searchFiltersDate.openCreatedModifiedTab(searchPage, 'Modified');
+        }
+        switch (filterType) {
+            case 'anytime':
+                await searchPage.searchFiltersDate.anytimeButton.click();
+                break;
+            case 'inTheLast':
+                await searchPage.searchFiltersDate.inTheLastButton.click();
+                await searchPage.searchFiltersDate.inTheLastInput.fill(inTheLastInputValue);
+                break;
+            case 'between':
+                await searchPage.searchFiltersDate.betweenButton.click();
+                await searchPage.searchFiltersDate.betweenStartDate.fill(startDay);
+                await searchPage.searchFiltersDate.betweenEndDate.fill(endDay);
+                break;
+            default:
+                throw new Error('Invalid filter type');
+        }
+        await searchPage.searchFilters.menuCardApply.click();
+        await searchPage.dataTable.spinnerWaitForReload();
+        expect(await searchPage.dataTable.getRowsCount()).toEqual(expectSearchResults);
+        let dateText;
+        if (filterType === 'between') {
+            if (dateFilterTab === 'Modified') {
+                dateText = `Modified: ${startDay} - ${endDay}`;
+            }
+            else {
+                dateText = `Created: ${startDay} - ${endDay}`;
+            }
+            await expect(searchPage.searchFilters.dateFilter).toContainText(dateText, { ignoreCase: true });
+        }
+    }
+    async isModifiedTabSelected() {
+        return this.modifiedTab.getAttribute('aria-selected');
+    }
+    async isSearchTabSelected() {
+        return this.createdTab.getAttribute('aria-selected');
+    }
+}
+export { SearchFiltersDate };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-filters-date.component.js","sourceRoot":"","sources":["../../../../../../../../projects/aca-playwright-shared/src/page-objects/components/search/search-filters/search-filters-date.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAQ,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAiBhD,MAAa,iBAAkB,SAAQ,aAAa;IAC1C,MAAM,CAAC,WAAW,GAAG,8BAA8B,CAAC;IAE5D,YAAY,IAAU;QACpB,KAAK,CAAC,IAAI,EAAE,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAC7C,CAAC;IAEM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;IACnE,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC;IACrE,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACjD,gBAAgB,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACnD,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,4CAA4C,CAAC,CAAC;IAC5E,kBAAkB,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACzD,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,4CAA4C,CAAC,CAAC;IAC9E,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,kDAAkD,CAAC,CAAC;IACnF,iBAAiB,GAAG,IAAI,CAAC,QAAQ,CAAC,qDAAqD,CAAC,CAAC;IACzF,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,4CAA4C,CAAC,CAAC;IAC5E,kBAAkB,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACzD,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,wDAAwD,CAAC,CAAC;IAC3F,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,sDAAsD,CAAC,CAAC;IAE9F,KAAK,CAAC,sBAAsB,CAAC,IAAgB,EAAE,GAAc;QAC3D,QAAQ,GAAG,EAAE;YACX,KAAK,SAAS;gBACZ,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;gBAChD,MAAM;YACR,KAAK,UAAU;gBACb,MAAM,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;gBACjD,MAAM;YACR;gBACE,MAAM;SACT;QACD,MAAM,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,iBAAiB,CAAC,MAA+B;QACrD,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;QAE/I,MAAM,UAAU,CAAC,YAAY,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QACxD,MAAM,UAAU,CAAC,aAAa,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QAElD,IAAI,aAAa,KAAK,UAAU,EAAE;YAChC,MAAM,UAAU,CAAC,iBAAiB,CAAC,sBAAsB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;SACnF;QAED,QAAQ,UAAU,EAAE;YAClB,KAAK,SAAS;gBACZ,MAAM,UAAU,CAAC,iBAAiB,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;gBACzD,MAAM;YACR,KAAK,WAAW;gBACd,MAAM,UAAU,CAAC,iBAAiB,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;gBAC3D,MAAM,UAAU,CAAC,iBAAiB,CAAC,cAAc,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;gBAC5E,MAAM;YACR,KAAK,SAAS;gBACZ,MAAM,UAAU,CAAC,iBAAiB,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;gBACzD,MAAM,UAAU,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACnE,MAAM,UAAU,CAAC,iBAAiB,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAC/D,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;SAC1C;QAED,MAAM,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QACrD,MAAM,UAAU,CAAC,SAAS,CAAC,oBAAoB,EAAE,CAAC;QAClD,MAAM,CAAC,MAAM,UAAU,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;QAE/E,IAAI,QAAgB,CAAC;QACrB,IAAI,UAAU,KAAK,SAAS,EAAE;YAC5B,IAAI,aAAa,KAAK,UAAU,EAAE;gBAChC,QAAQ,GAAG,aAAa,QAAQ,MAAM,MAAM,EAAE,CAAC;aAChD;iBAAM;gBACL,QAAQ,GAAG,YAAY,QAAQ,MAAM,MAAM,EAAE,CAAC;aAC/C;YACD,MAAM,MAAM,CAAC,UAAU,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,aAAa,CAAC,QAAQ,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;SACjG;IACH,CAAC;IAED,KAAK,CAAC,qBAAqB;QACzB,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC;IACxD,CAAC;IAED,KAAK,CAAC,mBAAmB;QACvB,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC;IACvD,CAAC;;SAhGU,iBAAiB","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 { BaseComponent } from '../../base.component';\nimport { Page, expect } from '@playwright/test';\nimport { SearchPage, SearchType } from '../../../pages';\n\ntype FilterTab = 'Created' | 'Modified';\n\ninterface FilterFilesByDateParams {\n  searchPage: SearchPage;\n  filterType: 'anytime' | 'inTheLast' | 'between';\n  dateFilterTab: FilterTab;\n  searchPhrase: string;\n  searchType: SearchType;\n  expectSearchResults: number;\n  inTheLastInputValue?: string;\n  startDay?: string;\n  endDay?: string;\n}\n\nexport class SearchFiltersDate extends BaseComponent {\n  private static rootElement = '.adf-search-filter-menu-card';\n\n  constructor(page: Page) {\n    super(page, SearchFiltersDate.rootElement);\n  }\n\n  public createdTab = this.getChild(`[role='tab']`, { hasText: 'Created' });\n  public modifiedTab = this.getChild(`[role='tab']`, { hasText: 'Modified' });\n  public createdTabTitle = this.createdTab.locator(`div`);\n  public modifiedTabTitle = this.modifiedTab.locator(`div`);\n  public anytimeButton = this.getChild(`[data-automation-id$='date-range-anytime']`);\n  public anytimeRadioButton = this.anytimeButton.locator(`input`);\n  public inTheLastButton = this.getChild(`[data-automation-id$='date-range-in-last']`);\n  public inTheLastInput = this.getChild(`[data-automation-id$='date-range-in-last-input']`);\n  public inTheLastDropdown = this.getChild(`[data-automation-id$='date-range-in-last-dropdown']`);\n  public betweenButton = this.getChild(`[data-automation-id$='date-range-between']`);\n  public betweenRadioButton = this.betweenButton.locator(`input`);\n  public betweenStartDate = this.getChild(`[data-automation-id$='date-range-between-start-input']`);\n  public betweenEndDate = this.getChild(`[data-automation-id$='date-range-between-end-input']`);\n\n  async openCreatedModifiedTab(page: SearchPage, tab: FilterTab): Promise<void> {\n    switch (tab) {\n      case 'Created':\n        await page.searchFiltersDate.createdTab.click();\n        break;\n      case 'Modified':\n        await page.searchFiltersDate.modifiedTab.click();\n        break;\n      default:\n        break;\n    }\n    await page.page.waitForTimeout(2000);\n  }\n\n  /**\n   * Method used in cases where we want to filter search results by Date\n   *\n   * @param searchPage page context for the test\n   * @param filterType filter type for the Date filter\n   * @param dateFilterTab tab in Date filter. Either Created or Modified\n   * @param searchPhrase search phrase for the search\n   * @param searchType type of items we want in search results e.g. files or folders\n   * @param expectSearchResults expect a number of search results\n   * @param inTheLastInputValue a value for 'in the last' input. e.g. in the last X days\n   * @param startDay start day for time-frame search. DD-MMMM-YY\n   * @param endDay end day for time-frame search. DD-MMMM-YY\n   */\n  async filterFilesByDate(params: FilterFilesByDateParams) {\n    const { searchPage, filterType, dateFilterTab, searchPhrase, searchType, expectSearchResults, inTheLastInputValue, startDay, endDay } = params;\n\n    await searchPage.searchWithin(searchPhrase, searchType);\n    await searchPage.searchFilters.dateFilter.click();\n\n    if (dateFilterTab === 'Modified') {\n      await searchPage.searchFiltersDate.openCreatedModifiedTab(searchPage, 'Modified');\n    }\n\n    switch (filterType) {\n      case 'anytime':\n        await searchPage.searchFiltersDate.anytimeButton.click();\n        break;\n      case 'inTheLast':\n        await searchPage.searchFiltersDate.inTheLastButton.click();\n        await searchPage.searchFiltersDate.inTheLastInput.fill(inTheLastInputValue);\n        break;\n      case 'between':\n        await searchPage.searchFiltersDate.betweenButton.click();\n        await searchPage.searchFiltersDate.betweenStartDate.fill(startDay);\n        await searchPage.searchFiltersDate.betweenEndDate.fill(endDay);\n        break;\n      default:\n        throw new Error('Invalid filter type');\n    }\n\n    await searchPage.searchFilters.menuCardApply.click();\n    await searchPage.dataTable.spinnerWaitForReload();\n    expect(await searchPage.dataTable.getRowsCount()).toEqual(expectSearchResults);\n\n    let dateText: string;\n    if (filterType === 'between') {\n      if (dateFilterTab === 'Modified') {\n        dateText = `Modified: ${startDay} - ${endDay}`;\n      } else {\n        dateText = `Created: ${startDay} - ${endDay}`;\n      }\n      await expect(searchPage.searchFilters.dateFilter).toContainText(dateText, { ignoreCase: true });\n    }\n  }\n\n  async isModifiedTabSelected(): Promise<string> {\n    return this.modifiedTab.getAttribute('aria-selected');\n  }\n\n  async isSearchTabSelected(): Promise<string> {\n    return this.createdTab.getAttribute('aria-selected');\n  }\n}\n"]}

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

@@ -0,0 +1,40 @@
+/*!
+ * 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 SearchFiltersLocation extends BaseComponent {
+    static rootElement = '.adf-search-filter-menu-card';
+    constructor(page) {
+        super(page, SearchFiltersLocation.rootElement);
+    }
+    addOptionInput = this.getChild(`[data-automation-id$='adf-search-chip-autocomplete-input']`);
+    async filterByLocation(page, location) {
+        await page.searchFilters.locationFilter.click();
+        await page.searchFiltersLocation.addOptionInput.fill(location);
+        await page.page.keyboard.press('Enter');
+        await page.searchFilters.menuCardApply.click();
+        await page.dataTable.progressBarWaitForReload();
+    }
+}
+export { SearchFiltersLocation };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,36 @@
+/*!
+ * 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 SearchFiltersLogic extends BaseComponent {
+    static rootElement = '.adf-search-filter-menu-card';
+    constructor(page) {
+        super(page, SearchFiltersLogic.rootElement);
+    }
+    matchAllInput = this.getChild(`[placeholder$='Results will match all words entered here']`);
+    matchAnyInput = this.getChild(`[placeholder$='Results will match any words entered here']`);
+    excludeInput = this.getChild(`[placeholder$='Results will exclude matches with these words']`);
+    matchExactInput = this.getChild(`[placeholder$='Results will match this entire phrase']`);
+}
+export { SearchFiltersLogic };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/components/search/search-filters/search-filters-properties.component.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 SearchFiltersProperties extends BaseComponent {
+    static rootElement = '.adf-search-filter-menu-card';
+    constructor(page) {
+        super(page, SearchFiltersProperties.rootElement);
+    }
+    operatorButton = this.getChild(`.adf-search-properties-file-size-operator`);
+    fileSizeInput = this.getChild(`[placeholder$='Enter file size']`);
+    unitButton = this.getChild(`.adf-search-properties-file-size-unit`);
+    fileTypeInput = this.getChild(`[placeholder$='File Type']`);
+    atLeastOption = this.page.locator(`mat-option`, { hasText: 'At Least' });
+    atMostOption = this.page.locator(`mat-option`, { hasText: 'At Most' });
+    exactlyOption = this.page.locator(`mat-option`, { hasText: 'Exactly' });
+    kbUnit = this.page.locator(`mat-option`, { hasText: 'KB' });
+    mbUnit = this.page.locator(`mat-option`, { hasText: 'MB' });
+    gbUnit = this.page.locator(`mat-option`, { hasText: 'GB' });
+    dropdownOptions = this.page.locator(`mat-option`);
+    async setPropertiesParameters(page, operator, unit, fileSizeInputText, fileTypeInputText) {
+        await page.searchFilters.propertiesFilter.click();
+        if (operator) {
+            await this.operatorButton?.click();
+            switch (operator) {
+                case 'At Least':
+                    await this.atLeastOption?.click();
+                    break;
+                case 'At Most':
+                    await this.atMostOption?.click();
+                    break;
+                case 'Exactly':
+                    await this.exactlyOption?.click();
+                    break;
+            }
+        }
+        if (unit) {
+            await this.unitButton?.click();
+            switch (unit) {
+                case 'KB':
+                    await this.kbUnit?.click();
+                    break;
+                case 'MB':
+                    await this.mbUnit?.click();
+                    break;
+                case 'GB':
+                    await this.gbUnit?.click();
+                    break;
+            }
+        }
+        if (fileSizeInputText) {
+            await this.fileSizeInput?.fill(fileSizeInputText);
+        }
+        if (fileTypeInputText) {
+            await this.fileTypeInput?.fill(fileTypeInputText);
+            await this.dropdownOptions.first().click();
+        }
+        await page.searchFilters.menuCardApply.click();
+        await page.dataTable.progressBarWaitForReload();
+    }
+}
+export { SearchFiltersProperties };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-filters-properties.component.js","sourceRoot":"","sources":["../../../../../../../../projects/aca-playwright-shared/src/page-objects/components/search/search-filters/search-filters-properties.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGrD,MAAa,uBAAwB,SAAQ,aAAa;IAChD,MAAM,CAAC,WAAW,GAAG,8BAA8B,CAAC;IAE5D,YAAY,IAAU;QACpB,KAAK,CAAC,IAAI,EAAE,uBAAuB,CAAC,WAAW,CAAC,CAAC;IACnD,CAAC;IAEM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,2CAA2C,CAAC,CAAC;IAC5E,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,kCAAkC,CAAC,CAAC;IAClE,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,uCAAuC,CAAC,CAAC;IACpE,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,4BAA4B,CAAC,CAAC;IAC5D,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC;IACzE,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;IACvE,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;IACxE,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5D,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5D,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5D,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;IAEzD,KAAK,CAAC,uBAAuB,CAC3B,IAAgB,EAChB,QAA6C,EAC7C,IAAyB,EACzB,iBAA0B,EAC1B,iBAA0B;QAE1B,MAAM,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;QAElD,IAAI,QAAQ,EAAE;YACZ,MAAM,IAAI,CAAC,cAAc,EAAE,KAAK,EAAE,CAAC;YACnC,QAAQ,QAAQ,EAAE;gBAChB,KAAK,UAAU;oBACb,MAAM,IAAI,CAAC,aAAa,EAAE,KAAK,EAAE,CAAC;oBAClC,MAAM;gBACR,KAAK,SAAS;oBACZ,MAAM,IAAI,CAAC,YAAY,EAAE,KAAK,EAAE,CAAC;oBACjC,MAAM;gBACR,KAAK,SAAS;oBACZ,MAAM,IAAI,CAAC,aAAa,EAAE,KAAK,EAAE,CAAC;oBAClC,MAAM;aACT;SACF;QAED,IAAI,IAAI,EAAE;YACR,MAAM,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE,CAAC;YAC/B,QAAQ,IAAI,EAAE;gBACZ,KAAK,IAAI;oBACP,MAAM,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;oBAC3B,MAAM;gBACR,KAAK,IAAI;oBACP,MAAM,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;oBAC3B,MAAM;gBACR,KAAK,IAAI;oBACP,MAAM,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;oBAC3B,MAAM;aACT;SACF;QAED,IAAI,iBAAiB,EAAE;YACrB,MAAM,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;SACnD;QAED,IAAI,iBAAiB,EAAE;YACrB,MAAM,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;YAClD,MAAM,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC;SAC5C;QAED,MAAM,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC/C,MAAM,IAAI,CAAC,SAAS,CAAC,wBAAwB,EAAE,CAAC;IAClD,CAAC;;SArEU,uBAAuB","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 { SearchPage } from '../../../pages';\nimport { BaseComponent } from '../../base.component';\nimport { Page } from '@playwright/test';\n\nexport class SearchFiltersProperties extends BaseComponent {\n  private static rootElement = '.adf-search-filter-menu-card';\n\n  constructor(page: Page) {\n    super(page, SearchFiltersProperties.rootElement);\n  }\n\n  public operatorButton = this.getChild(`.adf-search-properties-file-size-operator`);\n  public fileSizeInput = this.getChild(`[placeholder$='Enter file size']`);\n  public unitButton = this.getChild(`.adf-search-properties-file-size-unit`);\n  public fileTypeInput = this.getChild(`[placeholder$='File Type']`);\n  public atLeastOption = this.page.locator(`mat-option`, { hasText: 'At Least' });\n  public atMostOption = this.page.locator(`mat-option`, { hasText: 'At Most' });\n  public exactlyOption = this.page.locator(`mat-option`, { hasText: 'Exactly' });\n  public kbUnit = this.page.locator(`mat-option`, { hasText: 'KB' });\n  public mbUnit = this.page.locator(`mat-option`, { hasText: 'MB' });\n  public gbUnit = this.page.locator(`mat-option`, { hasText: 'GB' });\n  public dropdownOptions = this.page.locator(`mat-option`);\n\n  async setPropertiesParameters(\n    page: SearchPage,\n    operator?: 'At Least' | 'At Most' | 'Exactly',\n    unit?: 'KB' | 'MB' | 'GB',\n    fileSizeInputText?: string,\n    fileTypeInputText?: string\n  ): Promise<void> {\n    await page.searchFilters.propertiesFilter.click();\n\n    if (operator) {\n      await this.operatorButton?.click();\n      switch (operator) {\n        case 'At Least':\n          await this.atLeastOption?.click();\n          break;\n        case 'At Most':\n          await this.atMostOption?.click();\n          break;\n        case 'Exactly':\n          await this.exactlyOption?.click();\n          break;\n      }\n    }\n\n    if (unit) {\n      await this.unitButton?.click();\n      switch (unit) {\n        case 'KB':\n          await this.kbUnit?.click();\n          break;\n        case 'MB':\n          await this.mbUnit?.click();\n          break;\n        case 'GB':\n          await this.gbUnit?.click();\n          break;\n      }\n    }\n\n    if (fileSizeInputText) {\n      await this.fileSizeInput?.fill(fileSizeInputText);\n    }\n\n    if (fileTypeInputText) {\n      await this.fileTypeInput?.fill(fileTypeInputText);\n      await this.dropdownOptions.first().click();\n    }\n\n    await page.searchFilters.menuCardApply.click();\n    await page.dataTable.progressBarWaitForReload();\n  }\n}\n"]}

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

@@ -0,0 +1,40 @@
+/*!
+ * 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 SearchFiltersTags extends BaseComponent {
+    static rootElement = '.adf-search-filter-menu-card';
+    constructor(page) {
+        super(page, SearchFiltersTags.rootElement);
+    }
+    addOptionInput = this.getChild(`[data-automation-id$='adf-search-chip-autocomplete-input']`);
+    async filterByTag(page, tag) {
+        await page.searchFilters.tagsFilter.click();
+        await page.searchFiltersTags.addOptionInput.fill(tag);
+        await page.page.keyboard.press('Enter');
+        await page.searchFilters.menuCardApply.click();
+        await page.dataTable.progressBarWaitForReload();
+    }
+}
+export { SearchFiltersTags };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLWZpbHRlcnMtdGFncy5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtcGxheXdyaWdodC1zaGFyZWQvc3JjL3BhZ2Utb2JqZWN0cy9jb21wb25lbnRzL3NlYXJjaC9zZWFyY2gtZmlsdGVycy9zZWFyY2gtZmlsdGVycy10YWdzLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUdILE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUdyRCxNQUFhLGlCQUFrQixTQUFRLGFBQWE7SUFDMUMsTUFBTSxDQUFDLFdBQVcsR0FBRyw4QkFBOEIsQ0FBQztJQUU1RCxZQUFZLElBQVU7UUFDcEIsS0FBSyxDQUFDLElBQUksRUFBRSxpQkFBaUIsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUM3QyxDQUFDO0lBRU0sY0FBYyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsNERBQTRELENBQUMsQ0FBQztJQUVwRyxLQUFLLENBQUMsV0FBVyxDQUFDLElBQWdCLEVBQUUsR0FBVztRQUM3QyxNQUFNLElBQUksQ0FBQyxhQUFhLENBQUMsVUFBVSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQzVDLE1BQU0sSUFBSSxDQUFDLGlCQUFpQixDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDdEQsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDeEMsTUFBTSxJQUFJLENBQUMsYUFBYSxDQUFDLGFBQWEsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUMvQyxNQUFNLElBQUksQ0FBQyxTQUFTLENBQUMsd0JBQXdCLEVBQUUsQ0FBQztJQUNsRCxDQUFDOztTQWZVLGlCQUFpQiIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNCBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvblxuICpcbiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24uXG4gKiBJZiB0aGUgc29mdHdhcmUgd2FzIHB1cmNoYXNlZCB1bmRlciBhIHBhaWQgQWxmcmVzY28gbGljZW5zZSwgdGhlIHRlcm1zIG9mXG4gKiB0aGUgcGFpZCBsaWNlbnNlIGFncmVlbWVudCB3aWxsIHByZXZhaWwuIE90aGVyd2lzZSwgdGhlIHNvZnR3YXJlIGlzXG4gKiBwcm92aWRlZCB1bmRlciB0aGUgZm9sbG93aW5nIG9wZW4gc291cmNlIGxpY2Vuc2UgdGVybXM6XG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBmcmVlIHNvZnR3YXJlOiB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5XG4gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnlcbiAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yXG4gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCxcbiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mXG4gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGVcbiAqIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLlxuICpcbiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZVxuICogZnJvbSBIeWxhbmQgU29mdHdhcmUuIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi5cbiAqL1xuXG5pbXBvcnQgeyBTZWFyY2hQYWdlIH0gZnJvbSAnLi4vLi4vLi4vcGFnZXMnO1xuaW1wb3J0IHsgQmFzZUNvbXBvbmVudCB9IGZyb20gJy4uLy4uL2Jhc2UuY29tcG9uZW50JztcbmltcG9ydCB7IFBhZ2UgfSBmcm9tICdAcGxheXdyaWdodC90ZXN0JztcblxuZXhwb3J0IGNsYXNzIFNlYXJjaEZpbHRlcnNUYWdzIGV4dGVuZHMgQmFzZUNvbXBvbmVudCB7XG4gIHByaXZhdGUgc3RhdGljIHJvb3RFbGVtZW50ID0gJy5hZGYtc2VhcmNoLWZpbHRlci1tZW51LWNhcmQnO1xuXG4gIGNvbnN0cnVjdG9yKHBhZ2U6IFBhZ2UpIHtcbiAgICBzdXBlcihwYWdlLCBTZWFyY2hGaWx0ZXJzVGFncy5yb290RWxlbWVudCk7XG4gIH1cblxuICBwdWJsaWMgYWRkT3B0aW9uSW5wdXQgPSB0aGlzLmdldENoaWxkKGBbZGF0YS1hdXRvbWF0aW9uLWlkJD0nYWRmLXNlYXJjaC1jaGlwLWF1dG9jb21wbGV0ZS1pbnB1dCddYCk7XG5cbiAgYXN5bmMgZmlsdGVyQnlUYWcocGFnZTogU2VhcmNoUGFnZSwgdGFnOiBzdHJpbmcpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCBwYWdlLnNlYXJjaEZpbHRlcnMudGFnc0ZpbHRlci5jbGljaygpO1xuICAgIGF3YWl0IHBhZ2Uuc2VhcmNoRmlsdGVyc1RhZ3MuYWRkT3B0aW9uSW5wdXQuZmlsbCh0YWcpO1xuICAgIGF3YWl0IHBhZ2UucGFnZS5rZXlib2FyZC5wcmVzcygnRW50ZXInKTtcbiAgICBhd2FpdCBwYWdlLnNlYXJjaEZpbHRlcnMubWVudUNhcmRBcHBseS5jbGljaygpO1xuICAgIGF3YWl0IHBhZ2UuZGF0YVRhYmxlLnByb2dyZXNzQmFyV2FpdEZvclJlbG9hZCgpO1xuICB9XG59XG4iXX0=