@alfresco/aca-playwright-shared 5.1.1 → 5.2.0

package/esm2022/page-objects/components/dialogs/password-overlay-dialog.component.mjs

@@ -0,0 +1,71 @@
+/*!
+ * 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 PasswordOverlayDialogComponent extends BaseComponent {
+    static rootElement = '.cdk-overlay-pane';
+    closeButton = this.getChild('[data-automation-id="adf-password-dialog-close"]');
+    submitButton = this.getChild('[data-automation-id="adf-password-dialog-submit"]');
+    passwordInput = this.getChild('[data-automation-id="adf-password-dialog-input"]');
+    errorMessage = this.getChild('[data-automation-id="adf-password-dialog-error"]');
+    constructor(page, rootElement = PasswordOverlayDialogComponent.rootElement) {
+        super(page, rootElement);
+    }
+    async waitForDialogToOpen() {
+        await this.spinnerWaitForReload();
+        await this.passwordInput.waitFor({ state: 'attached', timeout: timeouts.large });
+        await this.passwordInput.isVisible();
+    }
+    async waitForDialogToClose() {
+        await this.passwordInput.waitFor({ state: 'detached', timeout: timeouts.large });
+    }
+    async isDialogOpen() {
+        await this.waitForDialogToOpen();
+        return this.passwordInput.isVisible();
+    }
+    async isCloseVisible() {
+        return this.closeButton.isVisible();
+    }
+    async isSubmitHidden() {
+        return this.submitButton.isHidden();
+    }
+    async isPasswordInputDisplayed() {
+        return this.passwordInput.isVisible();
+    }
+    async isErrorDisplayed() {
+        await this.errorMessage.waitFor({ state: 'visible', timeout: timeouts.short });
+        return this.errorMessage.isVisible();
+    }
+    async getErrorMessage() {
+        if (await this.isErrorDisplayed()) {
+            return this.errorMessage.innerText();
+        }
+        return '';
+    }
+    async enterPassword(password) {
+        await this.passwordInput.fill(password);
+    }
+}
+export { PasswordOverlayDialogComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFzc3dvcmQtb3ZlcmxheS1kaWFsb2cuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYWNhLXBsYXl3cmlnaHQtc2hhcmVkL3NyYy9wYWdlLW9iamVjdHMvY29tcG9uZW50cy9kaWFsb2dzL3Bhc3N3b3JkLW92ZXJsYXktZGlhbG9nLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUdILE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNsRCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFMUMsTUFBYSw4QkFBK0IsU0FBUSxhQUFhO0lBQ3ZELE1BQU0sQ0FBQyxXQUFXLEdBQUcsbUJBQW1CLENBQUM7SUFFMUMsV0FBVyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsa0RBQWtELENBQUMsQ0FBQztJQUNoRixZQUFZLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxtREFBbUQsQ0FBQyxDQUFDO0lBQ2xGLGFBQWEsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLGtEQUFrRCxDQUFDLENBQUM7SUFDbEYsWUFBWSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsa0RBQWtELENBQUMsQ0FBQztJQUV4RixZQUFZLElBQVUsRUFBRSxXQUFXLEdBQUcsOEJBQThCLENBQUMsV0FBVztRQUM5RSxLQUFLLENBQUMsSUFBSSxFQUFFLFdBQVcsQ0FBQyxDQUFDO0lBQzNCLENBQUM7SUFFRCxLQUFLLENBQUMsbUJBQW1CO1FBQ3ZCLE1BQU0sSUFBSSxDQUFDLG9CQUFvQixFQUFFLENBQUM7UUFDbEMsTUFBTSxJQUFJLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxFQUFFLEtBQUssRUFBRSxVQUFVLEVBQUUsT0FBTyxFQUFFLFFBQVEsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO1FBQ2pGLE1BQU0sSUFBSSxDQUFDLGFBQWEsQ0FBQyxTQUFTLEVBQUUsQ0FBQztJQUN2QyxDQUFDO0lBRUQsS0FBSyxDQUFDLG9CQUFvQjtRQUN4QixNQUFNLElBQUksQ0FBQyxhQUFhLENBQUMsT0FBTyxDQUFDLEVBQUUsS0FBSyxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUsUUFBUSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUM7SUFDbkYsQ0FBQztJQUVELEtBQUssQ0FBQyxZQUFZO1FBQ2hCLE1BQU0sSUFBSSxDQUFDLG1CQUFtQixFQUFFLENBQUM7UUFDakMsT0FBTyxJQUFJLENBQUMsYUFBYSxDQUFDLFNBQVMsRUFBRSxDQUFDO0lBQ3hDLENBQUM7SUFFRCxLQUFLLENBQUMsY0FBYztRQUNsQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDdEMsQ0FBQztJQUVELEtBQUssQ0FBQyxjQUFjO1FBQ2xCLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUN0QyxDQUFDO0lBRUQsS0FBSyxDQUFDLHdCQUF3QjtRQUM1QixPQUFPLElBQUksQ0FBQyxhQUFhLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDeEMsQ0FBQztJQUVELEtBQUssQ0FBQyxnQkFBZ0I7UUFDcEIsTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLFFBQVEsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO1FBQy9FLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxTQUFTLEVBQUUsQ0FBQztJQUN2QyxDQUFDO0lBRUQsS0FBSyxDQUFDLGVBQWU7UUFDbkIsSUFBSSxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxFQUFFO1lBQ2pDLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxTQUFTLEVBQUUsQ0FBQztTQUN0QztRQUNELE9BQU8sRUFBRSxDQUFDO0lBQ1osQ0FBQztJQUVELEtBQUssQ0FBQyxhQUFhLENBQUMsUUFBZ0I7UUFDbEMsTUFBTSxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUMxQyxDQUFDOztTQXJEVSw4QkFBOEIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjQgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb25cbiAqXG4gKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uLlxuICogSWYgdGhlIHNvZnR3YXJlIHdhcyBwdXJjaGFzZWQgdW5kZXIgYSBwYWlkIEFsZnJlc2NvIGxpY2Vuc2UsIHRoZSB0ZXJtcyBvZlxuICogdGhlIHBhaWQgbGljZW5zZSBhZ3JlZW1lbnQgd2lsbCBwcmV2YWlsLiBPdGhlcndpc2UsIHRoZSBzb2Z0d2FyZSBpc1xuICogcHJvdmlkZWQgdW5kZXIgdGhlIGZvbGxvd2luZyBvcGVuIHNvdXJjZSBsaWNlbnNlIHRlcm1zOlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeVxuICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5XG4gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvclxuICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi5cbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsXG4gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZlxuICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlXG4gKiBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy5cbiAqXG4gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2VcbiAqIGZyb20gSHlsYW5kIFNvZnR3YXJlLiBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uXG4gKi9cblxuaW1wb3J0IHsgUGFnZSB9IGZyb20gJ0BwbGF5d3JpZ2h0L3Rlc3QnO1xuaW1wb3J0IHsgQmFzZUNvbXBvbmVudCB9IGZyb20gJy4uL2Jhc2UuY29tcG9uZW50JztcbmltcG9ydCB7IHRpbWVvdXRzIH0gZnJvbSAnLi4vLi4vLi4vdXRpbHMnO1xuXG5leHBvcnQgY2xhc3MgUGFzc3dvcmRPdmVybGF5RGlhbG9nQ29tcG9uZW50IGV4dGVuZHMgQmFzZUNvbXBvbmVudCB7XG4gIHByaXZhdGUgc3RhdGljIHJvb3RFbGVtZW50ID0gJy5jZGstb3ZlcmxheS1wYW5lJztcblxuICBwdWJsaWMgY2xvc2VCdXR0b24gPSB0aGlzLmdldENoaWxkKCdbZGF0YS1hdXRvbWF0aW9uLWlkPVwiYWRmLXBhc3N3b3JkLWRpYWxvZy1jbG9zZVwiXScpO1xuICBwdWJsaWMgc3VibWl0QnV0dG9uID0gdGhpcy5nZXRDaGlsZCgnW2RhdGEtYXV0b21hdGlvbi1pZD1cImFkZi1wYXNzd29yZC1kaWFsb2ctc3VibWl0XCJdJyk7XG4gIHB1YmxpYyBwYXNzd29yZElucHV0ID0gdGhpcy5nZXRDaGlsZCgnW2RhdGEtYXV0b21hdGlvbi1pZD1cImFkZi1wYXNzd29yZC1kaWFsb2ctaW5wdXRcIl0nKTtcbiAgcHVibGljIGVycm9yTWVzc2FnZSA9IHRoaXMuZ2V0Q2hpbGQoJ1tkYXRhLWF1dG9tYXRpb24taWQ9XCJhZGYtcGFzc3dvcmQtZGlhbG9nLWVycm9yXCJdJyk7XG5cbiAgY29uc3RydWN0b3IocGFnZTogUGFnZSwgcm9vdEVsZW1lbnQgPSBQYXNzd29yZE92ZXJsYXlEaWFsb2dDb21wb25lbnQucm9vdEVsZW1lbnQpIHtcbiAgICBzdXBlcihwYWdlLCByb290RWxlbWVudCk7XG4gIH1cblxuICBhc3luYyB3YWl0Rm9yRGlhbG9nVG9PcGVuKCk6IFByb21pc2U8dm9pZD4ge1xuICAgIGF3YWl0IHRoaXMuc3Bpbm5lcldhaXRGb3JSZWxvYWQoKTtcbiAgICBhd2FpdCB0aGlzLnBhc3N3b3JkSW5wdXQud2FpdEZvcih7IHN0YXRlOiAnYXR0YWNoZWQnLCB0aW1lb3V0OiB0aW1lb3V0cy5sYXJnZSB9KTtcbiAgICBhd2FpdCB0aGlzLnBhc3N3b3JkSW5wdXQuaXNWaXNpYmxlKCk7XG4gIH1cblxuICBhc3luYyB3YWl0Rm9yRGlhbG9nVG9DbG9zZSgpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCB0aGlzLnBhc3N3b3JkSW5wdXQud2FpdEZvcih7IHN0YXRlOiAnZGV0YWNoZWQnLCB0aW1lb3V0OiB0aW1lb3V0cy5sYXJnZSB9KTtcbiAgfVxuXG4gIGFzeW5jIGlzRGlhbG9nT3BlbigpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgICBhd2FpdCB0aGlzLndhaXRGb3JEaWFsb2dUb09wZW4oKTtcbiAgICByZXR1cm4gdGhpcy5wYXNzd29yZElucHV0LmlzVmlzaWJsZSgpO1xuICB9XG5cbiAgYXN5bmMgaXNDbG9zZVZpc2libGUoKTogUHJvbWlzZTxib29sZWFuPiB7XG4gICAgcmV0dXJuIHRoaXMuY2xvc2VCdXR0b24uaXNWaXNpYmxlKCk7XG4gIH1cblxuICBhc3luYyBpc1N1Ym1pdEhpZGRlbigpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgICByZXR1cm4gdGhpcy5zdWJtaXRCdXR0b24uaXNIaWRkZW4oKTtcbiAgfVxuXG4gIGFzeW5jIGlzUGFzc3dvcmRJbnB1dERpc3BsYXllZCgpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgICByZXR1cm4gdGhpcy5wYXNzd29yZElucHV0LmlzVmlzaWJsZSgpO1xuICB9XG5cbiAgYXN5bmMgaXNFcnJvckRpc3BsYXllZCgpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgICBhd2FpdCB0aGlzLmVycm9yTWVzc2FnZS53YWl0Rm9yKHsgc3RhdGU6ICd2aXNpYmxlJywgdGltZW91dDogdGltZW91dHMuc2hvcnQgfSk7XG4gICAgcmV0dXJuIHRoaXMuZXJyb3JNZXNzYWdlLmlzVmlzaWJsZSgpO1xuICB9XG5cbiAgYXN5bmMgZ2V0RXJyb3JNZXNzYWdlKCk6IFByb21pc2U8c3RyaW5nPiB7XG4gICAgaWYgKGF3YWl0IHRoaXMuaXNFcnJvckRpc3BsYXllZCgpKSB7XG4gICAgICByZXR1cm4gdGhpcy5lcnJvck1lc3NhZ2UuaW5uZXJUZXh0KCk7XG4gICAgfVxuICAgIHJldHVybiAnJztcbiAgfVxuXG4gIGFzeW5jIGVudGVyUGFzc3dvcmQocGFzc3dvcmQ6IHN0cmluZyk6IFByb21pc2U8dm9pZD4ge1xuICAgIGF3YWl0IHRoaXMucGFzc3dvcmRJbnB1dC5maWxsKHBhc3N3b3JkKTtcbiAgfVxufVxuIl19

package/esm2022/page-objects/components/dialogs/share-dialog.component.mjs

@@ -0,0 +1,85 @@
+/*!
+ * 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';
+import { DateTimePicker } from '../datetime-picker/datetime-picker.component';
+class ShareDialogComponent extends BaseComponent {
+    static rootElement = 'adf-share-dialog';
+    constructor(page) {
+        super(page, ShareDialogComponent.rootElement);
+    }
+    closeButton = this.getChild('[data-automation-id="adf-share-dialog-close"]');
+    dialogTitle = this.getChild('[data-automation-id="adf-share-dialog-title"]');
+    infoText = this.getChild('.adf-share-link__info').first();
+    labels = '.adf-share-link__label';
+    shareToggle = this.getChild(`[data-automation-id='adf-share-toggle']`);
+    url = this.getChild(`[data-automation-id='adf-share-link']`);
+    urlAction = this.getChild('.adf-input-action');
+    expireToggle = this.getChild(`[data-automation-id='adf-expire-toggle']`);
+    expireInput = this.getChild('input[formcontrolname="time"]');
+    datetimePickerButton = this.getChild('.mat-datepicker-toggle');
+    dateTimePicker = new DateTimePicker(this.page);
+    getDialogLabel = () => this.getChild('label').innerText();
+    getErrorByText = (text) => this.page.locator('mat-error', { hasText: text });
+    async getLabels() {
+        return this.page.$$eval('.adf-share-link__label', (elements) => elements.map((element) => element.textContent));
+    }
+    async getDialogTitle() {
+        return this.dialogTitle.innerText();
+    }
+    async getInfoText() {
+        return this.infoText.innerText();
+    }
+    async getLinkUrl() {
+        return this.url.first().inputValue();
+    }
+    async isUrlReadOnly() {
+        const urlAttr = await this.url.getAttribute('readonly');
+        return urlAttr === 'true';
+    }
+    async isCloseEnabled() {
+        return this.closeButton.isEnabled();
+    }
+    async clickClose() {
+        await this.page.waitForTimeout(timeouts.tiny);
+        await this.closeButton.click();
+    }
+    async isToggleStatus(toggle, status) {
+        const toggleClass = await toggle.getAttribute('class');
+        return toggleClass.includes(status);
+    }
+    async isShareToggleChecked() {
+        const shareToggleElement = await this.shareToggle.elementHandle();
+        return this.isToggleStatus(shareToggleElement, 'checked');
+    }
+    async isExpireToggleEnabled() {
+        const expireToggleElement = await this.expireToggle.elementHandle();
+        return this.isToggleStatus(expireToggleElement, 'checked');
+    }
+    async getExpireDate() {
+        return this.expireInput.inputValue();
+    }
+}
+export { ShareDialogComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"share-dialog.component.js","sourceRoot":"","sources":["../../../../../../../projects/aca-playwright-shared/src/page-objects/components/dialogs/share-dialog.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AAE9E,MAAa,oBAAqB,SAAQ,aAAa;IAC7C,MAAM,CAAC,WAAW,GAAG,kBAAkB,CAAC;IAEhD,YAAY,IAAU;QACpB,KAAK,CAAC,IAAI,EAAE,oBAAoB,CAAC,WAAW,CAAC,CAAC;IAChD,CAAC;IAED,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,+CAA+C,CAAC,CAAC;IAC7E,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,+CAA+C,CAAC,CAAC;IAC7E,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,uBAAuB,CAAC,CAAC,KAAK,EAAE,CAAC;IAC1D,MAAM,GAAG,wBAAwB,CAAC;IAClC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,yCAAyC,CAAC,CAAC;IACvE,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,uCAAuC,CAAC,CAAC;IAC7D,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;IAC/C,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,0CAA0C,CAAC,CAAC;IACzE,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,+BAA+B,CAAC,CAAC;IAC7D,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC,wBAAwB,CAAC,CAAC;IAE/D,cAAc,GAAG,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAE/C,cAAc,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC;IAC1D,cAAc,GAAG,CAAC,IAAY,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IAE9F,KAAK,CAAC,SAAS;QACb,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,wBAAwB,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;IAClH,CAAC;IAED,KAAK,CAAC,cAAc;QAClB,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,WAAW;QACf,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;IACnC,CAAC;IAED,KAAK,CAAC,UAAU;QACd,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,CAAC;IACvC,CAAC;IAED,KAAK,CAAC,aAAa;QACjB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QACxD,OAAO,OAAO,KAAK,MAAM,CAAC;IAC5B,CAAC;IAED,KAAK,CAAC,cAAc;QAClB,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,UAAU;QACd,MAAM,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC9C,MAAM,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,MAAqB,EAAE,MAAc;QACxD,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACvD,OAAO,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,oBAAoB;QACxB,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC;QAClE,OAAO,IAAI,CAAC,cAAc,CAAC,kBAAkB,EAAE,SAAS,CAAC,CAAC;IAC5D,CAAC;IAED,KAAK,CAAC,qBAAqB;QACzB,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE,CAAC;QACpE,OAAO,IAAI,CAAC,cAAc,CAAC,mBAAmB,EAAE,SAAS,CAAC,CAAC;IAC7D,CAAC;IAED,KAAK,CAAC,aAAa;QACjB,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;IACvC,CAAC;;SAtEU,oBAAoB","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 { ElementHandle, Locator, Page } from '@playwright/test';\nimport { BaseComponent } from '../base.component';\nimport { timeouts } from '../../../utils';\nimport { DateTimePicker } from '../datetime-picker/datetime-picker.component';\n\nexport class ShareDialogComponent extends BaseComponent {\n  private static rootElement = 'adf-share-dialog';\n\n  constructor(page: Page) {\n    super(page, ShareDialogComponent.rootElement);\n  }\n\n  closeButton = this.getChild('[data-automation-id=\"adf-share-dialog-close\"]');\n  dialogTitle = this.getChild('[data-automation-id=\"adf-share-dialog-title\"]');\n  infoText = this.getChild('.adf-share-link__info').first();\n  labels = '.adf-share-link__label';\n  shareToggle = this.getChild(`[data-automation-id='adf-share-toggle']`);\n  url = this.getChild(`[data-automation-id='adf-share-link']`);\n  urlAction = this.getChild('.adf-input-action');\n  expireToggle = this.getChild(`[data-automation-id='adf-expire-toggle']`);\n  expireInput = this.getChild('input[formcontrolname=\"time\"]');\n  datetimePickerButton = this.getChild('.mat-datepicker-toggle');\n\n  dateTimePicker = new DateTimePicker(this.page);\n\n  getDialogLabel = () => this.getChild('label').innerText();\n  getErrorByText = (text: string): Locator => this.page.locator('mat-error', { hasText: text });\n\n  async getLabels(): Promise<Array<string>> {\n    return this.page.$$eval('.adf-share-link__label', (elements) => elements.map((element) => element.textContent));\n  }\n\n  async getDialogTitle(): Promise<string> {\n    return this.dialogTitle.innerText();\n  }\n\n  async getInfoText(): Promise<string> {\n    return this.infoText.innerText();\n  }\n\n  async getLinkUrl(): Promise<string> {\n    return this.url.first().inputValue();\n  }\n\n  async isUrlReadOnly(): Promise<boolean> {\n    const urlAttr = await this.url.getAttribute('readonly');\n    return urlAttr === 'true';\n  }\n\n  async isCloseEnabled(): Promise<boolean> {\n    return this.closeButton.isEnabled();\n  }\n\n  async clickClose(): Promise<void> {\n    await this.page.waitForTimeout(timeouts.tiny);\n    await this.closeButton.click();\n  }\n\n  async isToggleStatus(toggle: ElementHandle, status: string): Promise<boolean> {\n    const toggleClass = await toggle.getAttribute('class');\n    return toggleClass.includes(status);\n  }\n\n  async isShareToggleChecked(): Promise<boolean> {\n    const shareToggleElement = await this.shareToggle.elementHandle();\n    return this.isToggleStatus(shareToggleElement, 'checked');\n  }\n\n  async isExpireToggleEnabled(): Promise<boolean> {\n    const expireToggleElement = await this.expireToggle.elementHandle();\n    return this.isToggleStatus(expireToggleElement, 'checked');\n  }\n\n  async getExpireDate(): Promise<string> {\n    return this.expireInput.inputValue();\n  }\n}\n"]}

package/esm2022/page-objects/components/dialogs/upload-dialog.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 UploadDialog extends BaseComponent {
+    static rootElement = '.adf-upload-dialog';
+    uploadDialog = this.page.locator('.adf-upload-dialog');
+    closeButton = this.getChild('#adf-upload-dialog-close');
+    minimizeButton = this.page.locator('[data-automation-id="adf-upload-dialog__toggle-minimize"]');
+    uploadDialogMinimized = this.page.locator('.adf-upload-dialog--minimized');
+    constructor(page) {
+        super(page, UploadDialog.rootElement);
+    }
+}
+export { UploadDialog };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/components/dialogs/upload-new-version-dialog.component.mjs

@@ -0,0 +1,38 @@
+/*!
+ * 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 UploadNewVersionDialog extends BaseComponent {
+    static rootElement = 'adf-new-version-uploader-dialog';
+    cancelButton = this.getChild('#adf-new-version-cancel');
+    uploadButton = this.getChild('[data-automation-id="adf-new-version-file-upload"]');
+    majorOption = this.getChild('#adf-new-version-major');
+    minorOption = this.getChild('#adf-new-version-minor');
+    description = this.getChild('#adf-new-version-text-area');
+    title = this.getChild(' [data-automation-id="new-version-uploader-dialog-title"]');
+    constructor(page) {
+        super(page, UploadNewVersionDialog.rootElement);
+    }
+}
+export { UploadNewVersionDialog };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/components/dialogs/viewer-overlay-dialog.component.mjs

@@ -0,0 +1,56 @@
+/*!
+ * 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 ViewerOverlayDialogComponent extends BaseComponent {
+    static rootElement = '.cdk-overlay-pane';
+    closeButton = this.getChild('[data-automation-id="adf-password-dialog-close"]');
+    submitButton = this.getChild('[data-automation-id="adf-password-dialog-submit"]');
+    passwordInput = this.getChild('[data-automation-id="adf-password-dialog-input"]');
+    errorMessage = this.getChild('[data-automation-id="adf-password-dialog-error"]');
+    copyDialog = this.getChild('[data-automation-id="content-node-selector-title"]');
+    copyMenuButton = this.getChild('[id="app.viewer.copy"]');
+    deleteMenuButton = this.getChild('[id="app.viewer.delete"]');
+    favoriteMenuButton = this.getChild('[id="app.viewer.favorite.add"]');
+    removeFavoriteMenuButton = this.getChild('[id="app.viewer.favorite.remove"]');
+    shareDialogTitle = this.getChild('[data-automation-id="adf-share-dialog-title"]');
+    shareDialogClose = this.getChild('[data-automation-id="adf-share-dialog-close"]');
+    constructor(page, rootElement = ViewerOverlayDialogComponent.rootElement) {
+        super(page, rootElement);
+    }
+    async isCopyDialogOpen() {
+        await this.copyDialog.waitFor({ state: 'attached', timeout: timeouts.medium });
+        return this.copyDialog.isVisible();
+    }
+    async isCopyDialogClose() {
+        await this.copyDialog.waitFor({ state: 'detached', timeout: timeouts.medium });
+        return this.copyDialog.isVisible();
+    }
+    async clickActionsCopy() {
+        await this.copyMenuButton.waitFor({ state: 'attached', timeout: timeouts.medium });
+        await this.copyMenuButton.click();
+    }
+}
+export { ViewerOverlayDialogComponent };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,34 @@
+/*!
+ * 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 ErrorComponent extends BaseComponent {
+    static rootElement = 'aca-page-layout';
+    genericError = this.getChild('aca-generic-error');
+    genericErrorTitle = this.getChild('.generic-error__title');
+    constructor(page) {
+        super(page, ErrorComponent.rootElement);
+    }
+}
+export { ErrorComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/components/manageRules/manage-rules-dialog.component.mjs

@@ -0,0 +1,64 @@
+/*!
+ * 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 ManageRulesDialogComponent extends BaseComponent {
+    static rootElement = 'aca-edit-rule-dialog';
+    createRuleButton = this.getChild('[data-automation-id="edit-rule-dialog-submit"]');
+    cancelRuleButton = this.getChild('.aca-edit-rule-dialog__footer button').filter({ hasText: 'Cancel' });
+    ruleNameInputLocator = this.getChild('[id="rule-details-name-input"]');
+    ruleDescriptionInputLocator = this.getChild('[id="rule-details-description-textarea"]');
+    addConditionButton = this.getChild('[data-automation-id="add-condition-button"]');
+    addConditionGroupButton = this.getChild('[data-automation-id="add-group-button"]');
+    fieldDropDown = this.getChild('[data-automation-id="field-select"]');
+    comparatorDropDown = this.getChild('[data-automation-id="comparator-select"]');
+    valueField = this.getChild('[data-automation-id="value-input"]');
+    whenCreatedCheckbox = this.getChild('[data-automation-id="rule-trigger-checkbox-inbound"]');
+    whenUpdatedCheckbox = this.getChild('[data-automation-id="rule-trigger-checkbox-update"]');
+    whenDeletedCheckbox = this.getChild('[data-automation-id="rule-trigger-checkbox-outbound"]');
+    destinationFolderButton = this.getChild('[data-automation-id="card-textitem-clickable-icon-destination-folder"]');
+    ruleInBackgroundCheckbox = this.getChild('[data-automation-id="rule-option-checkbox-asynchronous"]');
+    ruleSubfoldersCheckbox = this.getChild('[data-automation-id="rule-option-checkbox-inheritable"]');
+    ruleDisableCheckbox = this.getChild('[data-automation-id="rule-option-checkbox-disabled"] input');
+    actionsEllipsisButtons = this.getChild('[data-automation-id="rule-action-list-action-menu"]');
+    actionsEllipsisDelete = this.page.locator('[data-automation-id="rule-action-list-remove-action-button"]');
+    conditionsEllipsisButtons = this.getChild('[data-automation-id="condition-actions-button"]');
+    conditionsEllipsisDelete = this.page.locator('button[title="Remove"]');
+    constructor(page) {
+        super(page, ManageRulesDialogComponent.rootElement);
+    }
+    async deleteActions(noActions) {
+        for (let i = 0; i < noActions; i++) {
+            await this.actionsEllipsisButtons.first().click();
+            await this.actionsEllipsisDelete.click();
+        }
+    }
+    async deleteConditions(noConditions) {
+        for (let i = 0; i < noConditions; i++) {
+            await this.conditionsEllipsisButtons.first().click();
+            await this.conditionsEllipsisDelete.click();
+        }
+    }
+}
+export { ManageRulesDialogComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manage-rules-dialog.component.js","sourceRoot":"","sources":["../../../../../../../projects/aca-playwright-shared/src/page-objects/components/manageRules/manage-rules-dialog.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGlD,MAAa,0BAA2B,SAAQ,aAAa;IACnD,MAAM,CAAC,WAAW,GAAG,sBAAsB,CAAC;IAE7C,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,gDAAgD,CAAC,CAAC;IACnF,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,sCAAsC,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC;IACvG,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC,gCAAgC,CAAC,CAAC;IACvE,2BAA2B,GAAG,IAAI,CAAC,QAAQ,CAAC,0CAA0C,CAAC,CAAC;IACxF,kBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC,6CAA6C,CAAC,CAAC;IAClF,uBAAuB,GAAG,IAAI,CAAC,QAAQ,CAAC,yCAAyC,CAAC,CAAC;IACnF,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,qCAAqC,CAAC,CAAC;IACrE,kBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC,0CAA0C,CAAC,CAAC;IAC/E,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,oCAAoC,CAAC,CAAC;IACjE,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC,sDAAsD,CAAC,CAAC;IAC5F,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC,qDAAqD,CAAC,CAAC;IAC3F,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC,uDAAuD,CAAC,CAAC;IAC7F,uBAAuB,GAAG,IAAI,CAAC,QAAQ,CAAC,wEAAwE,CAAC,CAAC;IAClH,wBAAwB,GAAG,IAAI,CAAC,QAAQ,CAAC,0DAA0D,CAAC,CAAC;IACrG,sBAAsB,GAAG,IAAI,CAAC,QAAQ,CAAC,yDAAyD,CAAC,CAAC;IAClG,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC,4DAA4D,CAAC,CAAC;IAClG,sBAAsB,GAAG,IAAI,CAAC,QAAQ,CAAC,qDAAqD,CAAC,CAAC;IAC9F,qBAAqB,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,8DAA8D,CAAC,CAAC;IAC1G,yBAAyB,GAAG,IAAI,CAAC,QAAQ,CAAC,iDAAiD,CAAC,CAAC;IAC7F,wBAAwB,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAE9E,YAAY,IAAU;QACpB,KAAK,CAAC,IAAI,EAAE,0BAA0B,CAAC,WAAW,CAAC,CAAC;IACtD,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,SAAiB;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE;YAClC,MAAM,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC;YAClD,MAAM,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,CAAC;SAC1C;IACH,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,YAAoB;QACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE;YACrC,MAAM,IAAI,CAAC,yBAAyB,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC;YACrD,MAAM,IAAI,CAAC,wBAAwB,CAAC,KAAK,EAAE,CAAC;SAC7C;IACH,CAAC;;SAxCU,0BAA0B","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 } from '@playwright/test';\n\nexport class ManageRulesDialogComponent extends BaseComponent {\n  private static rootElement = 'aca-edit-rule-dialog';\n\n  public createRuleButton = this.getChild('[data-automation-id=\"edit-rule-dialog-submit\"]');\n  public cancelRuleButton = this.getChild('.aca-edit-rule-dialog__footer button').filter({ hasText: 'Cancel' });\n  public ruleNameInputLocator = this.getChild('[id=\"rule-details-name-input\"]');\n  public ruleDescriptionInputLocator = this.getChild('[id=\"rule-details-description-textarea\"]');\n  public addConditionButton = this.getChild('[data-automation-id=\"add-condition-button\"]');\n  public addConditionGroupButton = this.getChild('[data-automation-id=\"add-group-button\"]');\n  public fieldDropDown = this.getChild('[data-automation-id=\"field-select\"]');\n  public comparatorDropDown = this.getChild('[data-automation-id=\"comparator-select\"]');\n  public valueField = this.getChild('[data-automation-id=\"value-input\"]');\n  public whenCreatedCheckbox = this.getChild('[data-automation-id=\"rule-trigger-checkbox-inbound\"]');\n  public whenUpdatedCheckbox = this.getChild('[data-automation-id=\"rule-trigger-checkbox-update\"]');\n  public whenDeletedCheckbox = this.getChild('[data-automation-id=\"rule-trigger-checkbox-outbound\"]');\n  public destinationFolderButton = this.getChild('[data-automation-id=\"card-textitem-clickable-icon-destination-folder\"]');\n  public ruleInBackgroundCheckbox = this.getChild('[data-automation-id=\"rule-option-checkbox-asynchronous\"]');\n  public ruleSubfoldersCheckbox = this.getChild('[data-automation-id=\"rule-option-checkbox-inheritable\"]');\n  public ruleDisableCheckbox = this.getChild('[data-automation-id=\"rule-option-checkbox-disabled\"] input');\n  public actionsEllipsisButtons = this.getChild('[data-automation-id=\"rule-action-list-action-menu\"]');\n  public actionsEllipsisDelete = this.page.locator('[data-automation-id=\"rule-action-list-remove-action-button\"]');\n  public conditionsEllipsisButtons = this.getChild('[data-automation-id=\"condition-actions-button\"]');\n  public conditionsEllipsisDelete = this.page.locator('button[title=\"Remove\"]');\n\n  constructor(page: Page) {\n    super(page, ManageRulesDialogComponent.rootElement);\n  }\n\n  async deleteActions(noActions: number): Promise<void> {\n    for (let i = 0; i < noActions; i++) {\n      await this.actionsEllipsisButtons.first().click();\n      await this.actionsEllipsisDelete.click();\n    }\n  }\n\n  async deleteConditions(noConditions: number): Promise<void> {\n    for (let i = 0; i < noConditions; i++) {\n      await this.conditionsEllipsisButtons.first().click();\n      await this.conditionsEllipsisDelete.click();\n    }\n  }\n}\n"]}

package/esm2022/page-objects/components/manageRules/manage-rules.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 { expect } from '@playwright/test';
+import { BaseComponent } from '../base.component';
+class ManageRules extends BaseComponent {
+    static rootElement = '.aca-manage-rules';
+    getGroupsList = (optionName) => this.getChild('.aca-rule-list-item__header', { hasText: optionName });
+    ruleToggle = this.getChild('.aca-manage-rules__container .mdc-switch').first();
+    ruleToggleFalse = this.getChild('aca-rule-list-grouping aca-rule-list-item .mdc-switch--unselected').first();
+    ruleDetailsTitle = this.getChild('.aca-manage-rules__container__rule-details__header__title__name');
+    ruleDetailsDeleteButton = this.getChild('#delete-rule-btn');
+    ruleDetailsEditButton = this.getChild('#edit-rule-btn');
+    ruleDetailsWhenText = this.getChild('[data-automation-id="rule-details-triggers-component"]');
+    ruleDetailsPerformActionsDiv = this.getChild('adf-card-view-textitem mat-form-field input');
+    rulesEmptyListTitle = this.getChild('.adf-empty-content__title');
+    ruleActions = this.getChild('aca-rule-action');
+    ruleConditionsInGroup = this.getChild('aca-rule-composite-condition aca-rule-simple-condition');
+    ruleDescription = this.getChild('.aca-manage-rules__container__rule-details__header__title__description');
+    constructor(page) {
+        super(page, ManageRules.rootElement);
+    }
+    async checkAspects(aspects) {
+        for (let i = 0; i < aspects.length; i++) {
+            const aspectsActions = await this.ruleDetailsPerformActionsDiv.nth(i).inputValue();
+            expect(aspects).toContain(aspectsActions);
+        }
+    }
+    async checkIfRuleListEmpty() {
+        return this.rulesEmptyListTitle.isVisible();
+    }
+    async checkIfRuleIsOnTheList(ruleName) {
+        await expect(this.getGroupsList(ruleName)).toBeVisible({ timeout: 5000 });
+    }
+    async countConditionsInGroup() {
+        return this.ruleConditionsInGroup.count();
+    }
+    async turnOffRuleToggle() {
+        await expect(async () => {
+            await this.ruleToggle.hover({ timeout: 1000 });
+            await this.ruleToggle.click();
+            await expect(this.ruleToggleFalse).toBeVisible();
+        }).toPass({
+            intervals: [2000, 2000, 2000, 2000, 2000, 2000, 2000],
+            timeout: 20000
+        });
+    }
+}
+export { ManageRules };
+//# sourceMappingURL=data:application/json;base64,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