@alfresco/aca-playwright-shared 5.1.1 → 5.2.0

package/esm2022/page-objects/components/adf-info-drawer.component.mjs

@@ -0,0 +1,102 @@
+/*!
+ * 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 AdfInfoDrawerComponent extends BaseComponent {
+    static rootElement = 'adf-info-drawer';
+    constructor(page) {
+        super(page, AdfInfoDrawerComponent.rootElement);
+    }
+    categoriesManagement = this.getChild('adf-categories-management');
+    tagsCreator = this.getChild('adf-tags-creator');
+    getNameField = (labelText) => this.getChild(`[data-automation-id="library-name-properties-wrapper"] input[placeholder='${labelText}']`);
+    getIdField = (labelText) => this.getChild(`[data-automation-id="library-id-properties-wrapper"] input[placeholder='${labelText}']`);
+    getVisibilityField = (labelText) => this.getChild(`[data-automation-id="library-visibility-properties-wrapper"] mat-select[ng-reflect-placeholder='${labelText}']`);
+    getDescriptionField = this.getChild('[data-automation-id="library-description-properties-wrapper"] textarea');
+    propertiesTab = this.page.getByRole('tab', { name: 'Properties' });
+    commentsTab = this.page.getByRole('tab', { name: 'Comments' });
+    infoDrawerTabs = this.getChild('.adf-info-drawer-tab');
+    commentInputField = this.page.locator('#comment-input');
+    commentsHeader = this.getChild('#comment-header');
+    addCommentButton = this.getChild('[data-automation-id="comments-input-add"]');
+    commentsList = this.getChild('.adf-comment-list-item');
+    commentUsername = this.getChild('.adf-comment-user-name');
+    commentTextContent = this.getChild('.adf-comment-message');
+    commentTimestamp = this.getChild('.adf-comment-message-time');
+    infoDrawerPanel = this.page.locator('.adf-info-drawer');
+    headerTitle = this.page.locator('.adf-info-drawer-layout-header-title').getByRole('heading');
+    editButton = this.page.getByRole('button', { name: 'Edit' });
+    cancelButton = this.page.getByRole('button', { name: 'Cancel' });
+    updateButton = this.page.getByRole('button', { name: 'Update' });
+    hintMessage = this.page.locator('mat-hint');
+    errorMessage = this.page.locator('mat-error');
+    expandDetailsButton = this.getChild(`button[title='Expand panel']`);
+    expandedDetailsTabs = this.page.locator('.aca-details-container .mdc-tab__text-label');
+    expandedDetailsPermissionsTab = this.expandedDetailsTabs.getByText('Permissions');
+    nameField = this.page.locator('input[placeholder=Name]');
+    idField = this.page.locator(`input[placeholder='Library ID']`);
+    descriptionField = this.page.locator('textarea[placeholder=Description]');
+    visibilityField = this.infoDrawerPanel.getByRole('combobox');
+    selectVisibility = (visibilityOption) => this.page.getByRole('listbox').getByRole('option', { name: visibilityOption }).click();
+    tagsAccordion = this.getChild('[data-automation-id="adf-content-metadata-tags-panel"]');
+    categoriesAccordion = this.getChild('[data-automation-id="adf-content-metadata-categories-panel"]');
+    tagsAccordionPenButton = this.tagsAccordion.locator('[data-automation-id="showing-tag-input-button"]');
+    categoriesAccordionPenButton = this.categoriesAccordion.locator('[data-automation-id="meta-data-categories-edit"]');
+    tagsInput = this.tagsCreator.locator('input');
+    createTagButton = this.tagsCreator.locator('[role="button"]');
+    tagsChips = this.tagsCreator.locator('mat-chip');
+    tagsChipsXButton = this.tagsChips.locator('button');
+    tagsAccordionCancelButton = this.getChild('[data-automation-id="reset-tags-metadata"]');
+    tagsAccordionConfirmButton = this.getChild('[data-automation-id="save-tags-metadata"]');
+    categoriesAccordionCancelButton = this.getChild('[data-automation-id="reset-metadata"]');
+    categoriesAccordionConfirmButton = this.getChild('[data-automation-id="save-categories-metadata"]');
+    categoriesInput = this.categoriesManagement.locator('input');
+    categoriesListItems = this.categoriesManagement.locator('mat-list-item');
+    categoriesItemRemoveButton = this.categoriesManagement.locator('[data-automation-id="categories-remove-category-button"]');
+    categoriesCreatedList = this.getChild('.adf-metadata-categories');
+    async checkCommentsHeaderCount() {
+        const commentsCountTextContent = await this.commentsHeader.textContent();
+        const commentsCountString = commentsCountTextContent.match(/\d+/g)[0];
+        return parseInt(commentsCountString, 10);
+    }
+    async verifyCommentsCountFromList(expectedNumber) {
+        const commentsCountFromList = await this.commentsList.count();
+        expect(commentsCountFromList).toEqual(expectedNumber);
+    }
+    async waitForComments() {
+        await this.commentsList.first().waitFor();
+    }
+    async addCommentToNode(commentText) {
+        await this.commentInputField.fill(commentText);
+        await this.addCommentButton.click();
+    }
+    async getHeaderTitle() {
+        return this.headerTitle.textContent();
+    }
+    async getTabsCount() {
+        return this.infoDrawerTabs.count();
+    }
+}
+export { AdfInfoDrawerComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adf-info-drawer.component.js","sourceRoot":"","sources":["../../../../../../projects/aca-playwright-shared/src/page-objects/components/adf-info-drawer.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 { Page, expect } from '@playwright/test';\n\nexport class AdfInfoDrawerComponent extends BaseComponent {\n  private static rootElement = 'adf-info-drawer';\n\n  constructor(page: Page) {\n    super(page, AdfInfoDrawerComponent.rootElement);\n  }\n\n  private readonly categoriesManagement = this.getChild('adf-categories-management');\n  private readonly tagsCreator = this.getChild('adf-tags-creator');\n\n  public getNameField = (labelText: string) =>\n    this.getChild(`[data-automation-id=\"library-name-properties-wrapper\"] input[placeholder='${labelText}']`);\n  public getIdField = (labelText: string) => this.getChild(`[data-automation-id=\"library-id-properties-wrapper\"] input[placeholder='${labelText}']`);\n  public getVisibilityField = (labelText: string) =>\n    this.getChild(`[data-automation-id=\"library-visibility-properties-wrapper\"] mat-select[ng-reflect-placeholder='${labelText}']`);\n  public getDescriptionField = this.getChild('[data-automation-id=\"library-description-properties-wrapper\"] textarea');\n  public propertiesTab = this.page.getByRole('tab', { name: 'Properties' });\n  public commentsTab = this.page.getByRole('tab', { name: 'Comments' });\n  public infoDrawerTabs = this.getChild('.adf-info-drawer-tab');\n  public commentInputField = this.page.locator('#comment-input');\n  public commentsHeader = this.getChild('#comment-header');\n  public addCommentButton = this.getChild('[data-automation-id=\"comments-input-add\"]');\n  public commentsList = this.getChild('.adf-comment-list-item');\n  public commentUsername = this.getChild('.adf-comment-user-name');\n  public commentTextContent = this.getChild('.adf-comment-message');\n  public commentTimestamp = this.getChild('.adf-comment-message-time');\n  public infoDrawerPanel = this.page.locator('.adf-info-drawer');\n  public headerTitle = this.page.locator('.adf-info-drawer-layout-header-title').getByRole('heading');\n  public editButton = this.page.getByRole('button', { name: 'Edit' });\n  public cancelButton = this.page.getByRole('button', { name: 'Cancel' });\n  public updateButton = this.page.getByRole('button', { name: 'Update' });\n  public hintMessage = this.page.locator('mat-hint');\n  public errorMessage = this.page.locator('mat-error');\n  public expandDetailsButton = this.getChild(`button[title='Expand panel']`);\n  public expandedDetailsTabs = this.page.locator('.aca-details-container .mdc-tab__text-label');\n  public expandedDetailsPermissionsTab = this.expandedDetailsTabs.getByText('Permissions');\n  public nameField = this.page.locator('input[placeholder=Name]');\n  public idField = this.page.locator(`input[placeholder='Library ID']`);\n  public descriptionField = this.page.locator('textarea[placeholder=Description]');\n  public visibilityField = this.infoDrawerPanel.getByRole('combobox');\n  public selectVisibility = (visibilityOption: string) => this.page.getByRole('listbox').getByRole('option', { name: visibilityOption }).click();\n  public tagsAccordion = this.getChild('[data-automation-id=\"adf-content-metadata-tags-panel\"]');\n  public categoriesAccordion = this.getChild('[data-automation-id=\"adf-content-metadata-categories-panel\"]');\n  public tagsAccordionPenButton = this.tagsAccordion.locator('[data-automation-id=\"showing-tag-input-button\"]');\n  public categoriesAccordionPenButton = this.categoriesAccordion.locator('[data-automation-id=\"meta-data-categories-edit\"]');\n  public tagsInput = this.tagsCreator.locator('input');\n  public createTagButton = this.tagsCreator.locator('[role=\"button\"]');\n  public tagsChips = this.tagsCreator.locator('mat-chip');\n  public tagsChipsXButton = this.tagsChips.locator('button');\n  public tagsAccordionCancelButton = this.getChild('[data-automation-id=\"reset-tags-metadata\"]');\n  public tagsAccordionConfirmButton = this.getChild('[data-automation-id=\"save-tags-metadata\"]');\n  public categoriesAccordionCancelButton = this.getChild('[data-automation-id=\"reset-metadata\"]');\n  public categoriesAccordionConfirmButton = this.getChild('[data-automation-id=\"save-categories-metadata\"]');\n  public categoriesInput = this.categoriesManagement.locator('input');\n  public categoriesListItems = this.categoriesManagement.locator('mat-list-item');\n  public categoriesItemRemoveButton = this.categoriesManagement.locator('[data-automation-id=\"categories-remove-category-button\"]');\n  public categoriesCreatedList = this.getChild('.adf-metadata-categories');\n\n  async checkCommentsHeaderCount(): Promise<number> {\n    const commentsCountTextContent = await this.commentsHeader.textContent();\n    const commentsCountString = commentsCountTextContent.match(/\\d+/g)[0];\n    return parseInt(commentsCountString, 10);\n  }\n\n  async verifyCommentsCountFromList(expectedNumber: number): Promise<void> {\n    const commentsCountFromList = await this.commentsList.count();\n    expect(commentsCountFromList).toEqual(expectedNumber);\n  }\n\n  async waitForComments(): Promise<void> {\n    await this.commentsList.first().waitFor();\n  }\n\n  async addCommentToNode(commentText: string): Promise<void> {\n    await this.commentInputField.fill(commentText);\n    await this.addCommentButton.click();\n  }\n\n  async getHeaderTitle(): Promise<string> {\n    return this.headerTitle.textContent();\n  }\n\n  async getTabsCount(): Promise<number> {\n    return this.infoDrawerTabs.count();\n  }\n}\n"]}

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

@@ -0,0 +1,70 @@
+/*!
+ * 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 { PlaywrightBase } from '../playwright-base';
+import { timeouts } from '../../utils';
+export class BaseComponent extends PlaywrightBase {
+    rootElement;
+    overlayElement = this.page.locator('.cdk-overlay-backdrop-showing');
+    progressBar = this.page.locator('mat-progress-bar');
+    constructor(page, rootElement) {
+        super(page);
+        this.rootElement = rootElement;
+    }
+    /**
+     * Method which should be used across the repository, while creating
+     * reference to elements, which are in root element of component.
+     *
+     * @param cssLocator css selector as String. Need to be in the tree under the root element
+     * @param options if you want to localize it by text, then provide an optional hasText
+     * @returns Locator object
+     */
+    getChild(cssLocator, options) {
+        return this.page.locator(`${this.rootElement} ${cssLocator}`, options);
+    }
+    async closeAdditionalOverlayElementIfVisible() {
+        if (await this.overlayElement.isVisible()) {
+            await this.page.keyboard.press('Escape');
+            await this.overlayElement.waitFor({ state: 'detached', timeout: timeouts.medium });
+        }
+    }
+    async spinnerWaitForReload() {
+        try {
+            await this.page.locator('mat-progress-spinner').waitFor({ state: 'attached', timeout: timeouts.medium });
+            await this.page.locator('mat-progress-spinner').waitFor({ state: 'detached', timeout: timeouts.normal });
+        }
+        catch (e) {
+            this.logger.info('Spinner was not present');
+        }
+    }
+    async progressBarWaitForReload() {
+        try {
+            await this.progressBar.waitFor({ state: 'visible', timeout: timeouts.medium });
+            await this.progressBar.waitFor({ state: 'hidden', timeout: timeouts.normal });
+        }
+        catch (e) {
+            this.logger.info('Progress bar was not present');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,47 @@
+/*!
+ * 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 Breadcrumb extends BaseComponent {
+    static rootElement = 'adf-breadcrumb';
+    items = this.getChild('.adf-breadcrumb-item');
+    currentItem = this.getChild('.adf-breadcrumb-item-current');
+    getItemByTitle = (name) => this.getChild(`.adf-breadcrumb-item[title=${name}]`);
+    constructor(page) {
+        super(page, Breadcrumb.rootElement);
+    }
+    async getAllItems() {
+        const itemElements = await this.page.$$('adf-breadcrumb .adf-breadcrumb-item');
+        const itemTexts = await Promise.all(itemElements.map(async (elem) => {
+            const text = await elem.innerText();
+            return text.split('\nchevron_right')[0];
+        }));
+        return itemTexts;
+    }
+    async clickItem(name) {
+        const elem = this.getChild(`.adf-breadcrumb-item[title=${name}]`);
+        await elem.click();
+    }
+}
+export { Breadcrumb };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJlYWRjcnVtYi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtcGxheXdyaWdodC1zaGFyZWQvc3JjL3BhZ2Utb2JqZWN0cy9jb21wb25lbnRzL2JyZWFkY3J1bWIvYnJlYWRjcnVtYi5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FzQkc7QUFFSCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFcEQsTUFBYSxVQUFXLFNBQVEsYUFBYTtJQUNuQyxNQUFNLENBQUMsV0FBVyxHQUFHLGdCQUFnQixDQUFDO0lBQ3ZDLEtBQUssR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLHNCQUFzQixDQUFDLENBQUM7SUFDOUMsV0FBVyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsOEJBQThCLENBQUMsQ0FBQztJQUNuRSxjQUFjLEdBQUcsQ0FBQyxJQUFZLEVBQVcsRUFBRSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsOEJBQThCLElBQUksR0FBRyxDQUFDLENBQUM7SUFFakcsWUFBWSxJQUFVO1FBQ3BCLEtBQUssQ0FBQyxJQUFJLEVBQUUsVUFBVSxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ3RDLENBQUM7SUFFRCxLQUFLLENBQUMsV0FBVztRQUNmLE1BQU0sWUFBWSxHQUFHLE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMscUNBQXFDLENBQUMsQ0FBQztRQUMvRSxNQUFNLFNBQVMsR0FBRyxNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQ2pDLFlBQVksQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLElBQUksRUFBRSxFQUFFO1lBQzlCLE1BQU0sSUFBSSxHQUFHLE1BQU0sSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ3BDLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzFDLENBQUMsQ0FBQyxDQUNILENBQUM7UUFDRixPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0lBRUQsS0FBSyxDQUFDLFNBQVMsQ0FBQyxJQUFZO1FBQzFCLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsOEJBQThCLElBQUksR0FBRyxDQUFDLENBQUM7UUFDbEUsTUFBTSxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDckIsQ0FBQzs7U0F4QlUsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNCBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvblxuICpcbiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24uXG4gKiBJZiB0aGUgc29mdHdhcmUgd2FzIHB1cmNoYXNlZCB1bmRlciBhIHBhaWQgQWxmcmVzY28gbGljZW5zZSwgdGhlIHRlcm1zIG9mXG4gKiB0aGUgcGFpZCBsaWNlbnNlIGFncmVlbWVudCB3aWxsIHByZXZhaWwuIE90aGVyd2lzZSwgdGhlIHNvZnR3YXJlIGlzXG4gKiBwcm92aWRlZCB1bmRlciB0aGUgZm9sbG93aW5nIG9wZW4gc291cmNlIGxpY2Vuc2UgdGVybXM6XG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBmcmVlIHNvZnR3YXJlOiB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5XG4gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnlcbiAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yXG4gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCxcbiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mXG4gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGVcbiAqIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLlxuICpcbiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZVxuICogZnJvbSBIeWxhbmQgU29mdHdhcmUuIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi5cbiAqL1xuXG5pbXBvcnQgeyBCYXNlQ29tcG9uZW50IH0gZnJvbSAnLi4vLi9iYXNlLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBMb2NhdG9yLCBQYWdlIH0gZnJvbSAnQHBsYXl3cmlnaHQvdGVzdCc7XG5leHBvcnQgY2xhc3MgQnJlYWRjcnVtYiBleHRlbmRzIEJhc2VDb21wb25lbnQge1xuICBwcml2YXRlIHN0YXRpYyByb290RWxlbWVudCA9ICdhZGYtYnJlYWRjcnVtYic7XG4gIHB1YmxpYyBpdGVtcyA9IHRoaXMuZ2V0Q2hpbGQoJy5hZGYtYnJlYWRjcnVtYi1pdGVtJyk7XG4gIHB1YmxpYyBjdXJyZW50SXRlbSA9IHRoaXMuZ2V0Q2hpbGQoJy5hZGYtYnJlYWRjcnVtYi1pdGVtLWN1cnJlbnQnKTtcbiAgZ2V0SXRlbUJ5VGl0bGUgPSAobmFtZTogc3RyaW5nKTogTG9jYXRvciA9PiB0aGlzLmdldENoaWxkKGAuYWRmLWJyZWFkY3J1bWItaXRlbVt0aXRsZT0ke25hbWV9XWApO1xuXG4gIGNvbnN0cnVjdG9yKHBhZ2U6IFBhZ2UpIHtcbiAgICBzdXBlcihwYWdlLCBCcmVhZGNydW1iLnJvb3RFbGVtZW50KTtcbiAgfVxuXG4gIGFzeW5jIGdldEFsbEl0ZW1zKCk6IFByb21pc2U8c3RyaW5nW10+IHtcbiAgICBjb25zdCBpdGVtRWxlbWVudHMgPSBhd2FpdCB0aGlzLnBhZ2UuJCQoJ2FkZi1icmVhZGNydW1iIC5hZGYtYnJlYWRjcnVtYi1pdGVtJyk7XG4gICAgY29uc3QgaXRlbVRleHRzID0gYXdhaXQgUHJvbWlzZS5hbGwoXG4gICAgICBpdGVtRWxlbWVudHMubWFwKGFzeW5jIChlbGVtKSA9PiB7XG4gICAgICAgIGNvbnN0IHRleHQgPSBhd2FpdCBlbGVtLmlubmVyVGV4dCgpO1xuICAgICAgICByZXR1cm4gdGV4dC5zcGxpdCgnXFxuY2hldnJvbl9yaWdodCcpWzBdO1xuICAgICAgfSlcbiAgICApO1xuICAgIHJldHVybiBpdGVtVGV4dHM7XG4gIH1cblxuICBhc3luYyBjbGlja0l0ZW0obmFtZTogc3RyaW5nKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgZWxlbSA9IHRoaXMuZ2V0Q2hpbGQoYC5hZGYtYnJlYWRjcnVtYi1pdGVtW3RpdGxlPSR7bmFtZX1dYCk7XG4gICAgYXdhaXQgZWxlbS5jbGljaygpO1xuICB9XG59XG4iXX0=

package/esm2022/page-objects/components/conditions.component.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 { ManageRulesDialogComponent } from './manageRules/manage-rules-dialog.component';
+export var Field;
+(function (Field) {
+    Field["Name"] = "Name";
+    Field["Size"] = "Size";
+    Field["Mimetype"] = "Mimetype";
+    Field["Encoding"] = "Encoding";
+    Field["HasCategory"] = "Has category";
+    Field["HasTag"] = "Has tag";
+    Field["HasAspect"] = "Has aspect";
+})(Field || (Field = {}));
+export var Comparator;
+(function (Comparator) {
+    Comparator["Equals"] = "(=) Equals";
+    Comparator["Contains"] = "Contains";
+    Comparator["StartsWith"] = "Starts with";
+    Comparator["EndsWith"] = "Ends with";
+})(Comparator || (Comparator = {}));
+export class ConditionComponent extends ManageRulesDialogComponent {
+    getOptionLocator = (optionName) => this.page.locator(`.cdk-overlay-pane .mat-mdc-option span`, { hasText: optionName });
+    async selectField(fields, index) {
+        await this.fieldDropDown.nth(index).click();
+        const option = this.getOptionLocator(fields);
+        await option.click();
+    }
+    async selectComparator(comparators, index) {
+        await this.comparatorDropDown.nth(index).click();
+        const option = this.getOptionLocator(comparators);
+        await option.click();
+    }
+    async addCondition(fields, value, index, comparators) {
+        await this.addConditionButton.first().click();
+        await this.selectField(fields, index);
+        if (comparators) {
+            await this.selectComparator(comparators, index);
+        }
+        await this.valueField.nth(index).fill(value);
+    }
+    async addConditionGroup(fields, value, index, comparators) {
+        await this.addConditionGroupButton.last().click();
+        await this.addConditionButton.nth(index).click();
+        await this.selectField(fields, index);
+        if (comparators) {
+            await this.selectComparator(comparators, index);
+        }
+        await this.valueField.nth(index).fill(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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