@alfresco/aca-playwright-shared 5.1.1-10706961491

package/esm2020/fixtures/page-initialization.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 { test as base } from '@playwright/test';
+import { FavoritesLibrariesPage, LoginPage, MyLibrariesPage, NodesPage, PersonalFilesPage, RecentFilesPage, SharedPage, SearchPage, FavoritesPage, TrashPage } from '../page-objects';
+import { FileActionsApi, SharedLinksApi, FavoritesPageApi, NodesApi, SitesApi } from '../api';
+import { users } from '../base-config';
+export const test = base.extend({
+    personalFiles: async ({ page }, use) => {
+        await use(new PersonalFilesPage(page));
+    },
+    nodesPage: async ({ page }, use) => {
+        await use(new NodesPage(page));
+    },
+    recentFilesPage: async ({ page }, use) => {
+        await use(new RecentFilesPage(page));
+    },
+    sharedPage: async ({ page }, use) => {
+        await use(new SharedPage(page));
+    },
+    searchPage: async ({ page }, use) => {
+        await use(new SearchPage(page));
+    },
+    favoritePage: async ({ page }, use) => {
+        await use(new FavoritesPage(page));
+    },
+    favoritesLibrariesPage: async ({ page }, use) => {
+        await use(new FavoritesLibrariesPage(page));
+    },
+    trashPage: async ({ page }, use) => {
+        await use(new TrashPage(page));
+    },
+    loginPage: async ({ page }, use) => {
+        await use(new LoginPage(page));
+    },
+    // eslint-disable-next-line no-empty-pattern
+    fileAction: async ({}, use) => {
+        await use(await FileActionsApi.initialize(users.hruser.username));
+    },
+    // eslint-disable-next-line no-empty-pattern
+    shareAction: async ({}, use) => {
+        await use(await SharedLinksApi.initialize(users.hruser.username));
+    },
+    // eslint-disable-next-line no-empty-pattern
+    favoritesPageAction: async ({}, use) => {
+        await use(await FavoritesPageApi.initialize(users.hruser.username));
+    },
+    // eslint-disable-next-line no-empty-pattern
+    nodesApiAction: async ({}, use) => {
+        await use(await NodesApi.initialize(users.admin.username, users.admin.password));
+    },
+    // eslint-disable-next-line no-empty-pattern
+    sitesApiAction: async ({}, use) => {
+        await use(await SitesApi.initialize(users.hruser.username));
+    },
+    myLibrariesPage: async ({ page }, use) => {
+        await use(new MyLibrariesPage(page));
+    },
+    favoriteLibrariesPage: async ({ page }, use) => {
+        await use(new FavoritesLibrariesPage(page));
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"page-initialization.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/fixtures/page-initialization.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 { test as base } from '@playwright/test';\nimport {\n  FavoritesLibrariesPage,\n  LoginPage,\n  MyLibrariesPage,\n  NodesPage,\n  PersonalFilesPage,\n  RecentFilesPage,\n  SharedPage,\n  SearchPage,\n  FavoritesPage,\n  TrashPage\n} from '../page-objects';\nimport { FileActionsApi, SharedLinksApi, FavoritesPageApi, NodesApi, SitesApi } from '../api';\nimport { users } from '../base-config';\n\ninterface Pages {\n  personalFiles: PersonalFilesPage;\n  nodesPage: NodesPage;\n  myLibrariesPage: MyLibrariesPage;\n  recentFilesPage: RecentFilesPage;\n  sharedPage: SharedPage;\n  searchPage: SearchPage;\n  favoritePage: FavoritesPage;\n  favoritesLibrariesPage: FavoritesLibrariesPage;\n  trashPage: TrashPage;\n  loginPage: LoginPage;\n  favoriteLibrariesPage: FavoritesLibrariesPage;\n}\n\ninterface Api {\n  fileAction: FileActionsApi;\n  shareAction: SharedLinksApi;\n  favoritesPageAction: FavoritesPageApi;\n  nodesApiAction: NodesApi;\n  sitesApiAction: SitesApi;\n}\n\nexport const test = base.extend<Pages & Api>({\n  personalFiles: async ({ page }, use) => {\n    await use(new PersonalFilesPage(page));\n  },\n  nodesPage: async ({ page }, use) => {\n    await use(new NodesPage(page));\n  },\n  recentFilesPage: async ({ page }, use) => {\n    await use(new RecentFilesPage(page));\n  },\n  sharedPage: async ({ page }, use) => {\n    await use(new SharedPage(page));\n  },\n  searchPage: async ({ page }, use) => {\n    await use(new SearchPage(page));\n  },\n  favoritePage: async ({ page }, use) => {\n    await use(new FavoritesPage(page));\n  },\n  favoritesLibrariesPage: async ({ page }, use) => {\n    await use(new FavoritesLibrariesPage(page));\n  },\n  trashPage: async ({ page }, use) => {\n    await use(new TrashPage(page));\n  },\n  loginPage: async ({ page }, use) => {\n    await use(new LoginPage(page));\n  },\n  // eslint-disable-next-line no-empty-pattern\n  fileAction: async ({}, use) => {\n    await use(await FileActionsApi.initialize(users.hruser.username));\n  },\n  // eslint-disable-next-line no-empty-pattern\n  shareAction: async ({}, use) => {\n    await use(await SharedLinksApi.initialize(users.hruser.username));\n  },\n  // eslint-disable-next-line no-empty-pattern\n  favoritesPageAction: async ({}, use) => {\n    await use(await FavoritesPageApi.initialize(users.hruser.username));\n  },\n  // eslint-disable-next-line no-empty-pattern\n  nodesApiAction: async ({}, use) => {\n    await use(await NodesApi.initialize(users.admin.username, users.admin.password));\n  },\n  // eslint-disable-next-line no-empty-pattern\n  sitesApiAction: async ({}, use) => {\n    await use(await SitesApi.initialize(users.hruser.username));\n  },\n  myLibrariesPage: async ({ page }, use) => {\n    await use(new MyLibrariesPage(page));\n  },\n  favoriteLibrariesPage: async ({ page }, use) => {\n    await use(new FavoritesLibrariesPage(page));\n  }\n});\n"]}

package/esm2020/models/custom-config.mjs

@@ -0,0 +1,25 @@
+/*!
+ * 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/>.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/models/index.mjs

@@ -0,0 +1,26 @@
+/*!
+ * 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/>.
+ */
+export * from './user-model';
+export * from './custom-config';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtcGxheXdyaWdodC1zaGFyZWQvc3JjL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUVILGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjQgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb25cbiAqXG4gKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uLlxuICogSWYgdGhlIHNvZnR3YXJlIHdhcyBwdXJjaGFzZWQgdW5kZXIgYSBwYWlkIEFsZnJlc2NvIGxpY2Vuc2UsIHRoZSB0ZXJtcyBvZlxuICogdGhlIHBhaWQgbGljZW5zZSBhZ3JlZW1lbnQgd2lsbCBwcmV2YWlsLiBPdGhlcndpc2UsIHRoZSBzb2Z0d2FyZSBpc1xuICogcHJvdmlkZWQgdW5kZXIgdGhlIGZvbGxvd2luZyBvcGVuIHNvdXJjZSBsaWNlbnNlIHRlcm1zOlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeVxuICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5XG4gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvclxuICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi5cbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsXG4gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZlxuICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlXG4gKiBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy5cbiAqXG4gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2VcbiAqIGZyb20gSHlsYW5kIFNvZnR3YXJlLiBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi91c2VyLW1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vY3VzdG9tLWNvbmZpZyc7XG4iXX0=

package/esm2020/models/user-model.mjs

@@ -0,0 +1,55 @@
+/*!
+ * 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/>.
+ */
+const LOWER_CASE_ALPHA = 'helloworld';
+function generateRandomCharset(length = 8, charSet) {
+    let text = '';
+    for (let i = 0; i < length; i++) {
+        text += charSet.charAt(Math.floor(Math.random() * charSet.length));
+    }
+    return text;
+}
+export class UserModel {
+    constructor(details = {}) {
+        this.firstName = generateRandomCharset(7, LOWER_CASE_ALPHA);
+        this.lastName = generateRandomCharset(7, LOWER_CASE_ALPHA);
+        this.password = generateRandomCharset(7, LOWER_CASE_ALPHA);
+        this.type = 'enterprise';
+        const EMAIL_DOMAIN = 'alfresco';
+        this.firstName = details.firstName ?? this.firstName;
+        this.lastName = details.lastName ?? this.lastName;
+        const USER_IDENTIFY = `${this.firstName}${this.lastName}.${generateRandomCharset(7, LOWER_CASE_ALPHA)}`;
+        this.password = details.password ?? this.password;
+        this.email = details.email ?? `${USER_IDENTIFY}@${EMAIL_DOMAIN}.com`;
+        this.username = details.username ?? USER_IDENTIFY;
+        this.idIdentityService = details.idIdentityService ?? this.idIdentityService;
+        this.type = details.type ?? this.type;
+        this.tenantId = details.tenantId ?? this.tenantId;
+        this.company = details.company ?? this.company;
+        this.id = details.id ?? this.id;
+    }
+    get fullName() {
+        return `${this.firstName ?? ''} ${this.lastName ?? ''}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/page-objects/components/aca-header.component.mjs

@@ -0,0 +1,77 @@
+/*!
+ * 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 { MatMenuComponent } from './dataTable';
+import { BaseComponent } from './base.component';
+export class AcaHeader extends BaseComponent {
+    constructor(page) {
+        super(page, AcaHeader.rootElement);
+        this.moreActionsButton = this.getChild('button[id="app.viewer.toolbar.more"]');
+        this.toolbarMoreActions = this.getChild('button[id="app.toolbar.more"]');
+        this.createButton = this.getChild('[id="app.toolbar.create"]');
+        this.viewDetails = this.getChild('[title="View Details"]');
+        this.viewButton = this.getChild('button[title="View"]');
+        this.searchButton = this.getChild('button[id="app.toolbar.search"]');
+        this.fullScreenButton = this.getChild('button[id="app.viewer.fullscreen"]');
+        this.shareButton = this.getChild('button[id="share-action-button"]');
+        this.downloadButtonViewer = this.getChild('button[id="app.viewer.download"]');
+        this.downloadButton = this.getChild('button[id="app.toolbar.download"]');
+        this.sharedDownloadButton = this.getChild('button[id="app.viewer.shared.download"]');
+        this.uploadButton = this.getChild('button[id="app.toolbar.upload"]');
+        this.uploadFileButton = this.page.locator('button[id="app.create.uploadFile"]');
+        this.uploadInput = this.page.locator('input[id="app-upload-files"]');
+        this.uploadNewVersionButton = this.page.locator('#app-upload-file-version');
+        this.permanentlyDeleteButton = this.getChild('button[id="app.toolbar.purgeDeletedNodes"]');
+        this.restoreButton = this.getChild('button[id="app.toolbar.restoreDeletedNodes"]');
+        this.matMenu = new MatMenuComponent(this.page);
+    }
+    async clickViewerMoreActions() {
+        await this.moreActionsButton.waitFor({ state: 'attached' });
+        await this.moreActionsButton.click();
+    }
+    async clickMoreActions() {
+        await this.toolbarMoreActions.waitFor({ state: 'attached' });
+        await this.toolbarMoreActions.click();
+    }
+    async clickCreateFolderFromTemplate() {
+        await this.createButton.click();
+        await this.matMenu.createFolderFromTemplate.click();
+    }
+    async verifyToolbarPrimaryActions(expectedToolbarPrimary) {
+        const buttons = await this.page.$$('aca-toolbar button');
+        const actualPrimaryActions = await Promise.all(buttons.map(async (button) => {
+            const title = await button.getAttribute('title');
+            return title || '';
+        }));
+        for (const action of expectedToolbarPrimary) {
+            expect(actualPrimaryActions.includes(action), `Expected to contain ${action}`).toBe(true);
+        }
+    }
+    async clickCreateFileFromTemplate() {
+        await this.createButton.click();
+        await this.matMenu.createFileFromTemplate.click();
+    }
+}
+AcaHeader.rootElement = 'aca-toolbar';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aca-header.component.js","sourceRoot":"","sources":["../../../../../../projects/aca-playwright-shared/src/page-objects/components/aca-header.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAQ,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,OAAO,SAAU,SAAQ,aAAa;IAoB1C,YAAY,IAAU;QACpB,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;QAnB7B,sBAAiB,GAAG,IAAI,CAAC,QAAQ,CAAC,sCAAsC,CAAC,CAAC;QAC1E,uBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC,+BAA+B,CAAC,CAAC;QACrE,iBAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,2BAA2B,CAAC,CAAC;QAC1D,gBAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,wBAAwB,CAAC,CAAC;QACtD,eAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAC;QACnD,iBAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,iCAAiC,CAAC,CAAC;QAChE,qBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,oCAAoC,CAAC,CAAC;QACvE,gBAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,kCAAkC,CAAC,CAAC;QAChE,yBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC,kCAAkC,CAAC,CAAC;QACzE,mBAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,mCAAmC,CAAC,CAAC;QACpE,yBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC,yCAAyC,CAAC,CAAC;QAChF,iBAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,iCAAiC,CAAC,CAAC;QAChE,qBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,oCAAoC,CAAC,CAAC;QAC3E,gBAAW,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAC;QAChE,2BAAsB,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;QACvE,4BAAuB,GAAG,IAAI,CAAC,QAAQ,CAAC,4CAA4C,CAAC,CAAC;QACtF,kBAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,8CAA8C,CAAC,CAAC;QAK9E,YAAO,GAAG,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IADjD,CAAC;IAGD,KAAK,CAAC,sBAAsB;QAC1B,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;QAC5D,MAAM,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;IACvC,CAAC;IAED,KAAK,CAAC,gBAAgB;QACpB,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;QAC7D,MAAM,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;IACxC,CAAC;IAED,KAAK,CAAC,6BAA6B;QACjC,MAAM,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAChC,MAAM,IAAI,CAAC,OAAO,CAAC,wBAAwB,CAAC,KAAK,EAAE,CAAC;IACtD,CAAC;IAED,KAAK,CAAC,2BAA2B,CAAC,sBAAgC;QAChE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,oBAAoB,CAAC,CAAC;QACzD,MAAM,oBAAoB,GAAa,MAAM,OAAO,CAAC,GAAG,CACtD,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAC3B,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;YACjD,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,CAAC,CAAC,CACH,CAAC;QAEF,KAAK,MAAM,MAAM,IAAI,sBAAsB,EAAE;YAC3C,MAAM,CAAC,oBAAoB,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,uBAAuB,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC3F;IACH,CAAC;IAED,KAAK,CAAC,2BAA2B;QAC/B,MAAM,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAChC,MAAM,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,KAAK,EAAE,CAAC;IACpD,CAAC;;AAxDc,qBAAW,GAAG,aAAa,CAAC","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 { Page, expect } from '@playwright/test';\nimport { MatMenuComponent } from './dataTable';\nimport { BaseComponent } from './base.component';\n\nexport class AcaHeader extends BaseComponent {\n  private static rootElement = 'aca-toolbar';\n  private moreActionsButton = this.getChild('button[id=\"app.viewer.toolbar.more\"]');\n  private toolbarMoreActions = this.getChild('button[id=\"app.toolbar.more\"]');\n  public createButton = this.getChild('[id=\"app.toolbar.create\"]');\n  public viewDetails = this.getChild('[title=\"View Details\"]');\n  public viewButton = this.getChild('button[title=\"View\"]');\n  public searchButton = this.getChild('button[id=\"app.toolbar.search\"]');\n  public fullScreenButton = this.getChild('button[id=\"app.viewer.fullscreen\"]');\n  public shareButton = this.getChild('button[id=\"share-action-button\"]');\n  public downloadButtonViewer = this.getChild('button[id=\"app.viewer.download\"]');\n  public downloadButton = this.getChild('button[id=\"app.toolbar.download\"]');\n  public sharedDownloadButton = this.getChild('button[id=\"app.viewer.shared.download\"]');\n  public uploadButton = this.getChild('button[id=\"app.toolbar.upload\"]');\n  public uploadFileButton = this.page.locator('button[id=\"app.create.uploadFile\"]');\n  public uploadInput = this.page.locator('input[id=\"app-upload-files\"]');\n  public uploadNewVersionButton = this.page.locator('#app-upload-file-version');\n  public permanentlyDeleteButton = this.getChild('button[id=\"app.toolbar.purgeDeletedNodes\"]');\n  public restoreButton = this.getChild('button[id=\"app.toolbar.restoreDeletedNodes\"]');\n\n  constructor(page: Page) {\n    super(page, AcaHeader.rootElement);\n  }\n  public matMenu = new MatMenuComponent(this.page);\n\n  async clickViewerMoreActions(): Promise<void> {\n    await this.moreActionsButton.waitFor({ state: 'attached' });\n    await this.moreActionsButton.click();\n  }\n\n  async clickMoreActions(): Promise<void> {\n    await this.toolbarMoreActions.waitFor({ state: 'attached' });\n    await this.toolbarMoreActions.click();\n  }\n\n  async clickCreateFolderFromTemplate(): Promise<void> {\n    await this.createButton.click();\n    await this.matMenu.createFolderFromTemplate.click();\n  }\n\n  async verifyToolbarPrimaryActions(expectedToolbarPrimary: string[]): Promise<void> {\n    const buttons = await this.page.$$('aca-toolbar button');\n    const actualPrimaryActions: string[] = await Promise.all(\n      buttons.map(async (button) => {\n        const title = await button.getAttribute('title');\n        return title || '';\n      })\n    );\n\n    for (const action of expectedToolbarPrimary) {\n      expect(actualPrimaryActions.includes(action), `Expected to contain ${action}`).toBe(true);\n    }\n  }\n\n  async clickCreateFileFromTemplate(): Promise<void> {\n    await this.createButton.click();\n    await this.matMenu.createFileFromTemplate.click();\n  }\n}\n"]}

package/esm2020/page-objects/components/actions-dropdown.component.mjs

@@ -0,0 +1,99 @@
+/*!
+ * 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';
+export var ActionType;
+(function (ActionType) {
+    ActionType["AddAspect"] = "Add aspect";
+    ActionType["SimpleWorkflow"] = "Add simple workflow";
+    ActionType["IncrementCounter"] = "Increment Counter";
+    ActionType["CheckIn"] = "Check in";
+    ActionType["AutoDeclareOptions"] = "Auto-Declare Options";
+    ActionType["CheckOut"] = "Check out";
+    ActionType["Copy"] = "Copy";
+    ActionType["ExecuteScript"] = "Execute script";
+    ActionType["ExtractCommonMetadataFields"] = "Extract common metadata fields";
+    ActionType["FileAsRecord"] = "File as Record";
+    ActionType["FileVersionAsRecord"] = "File Version as Record";
+    ActionType["HideRecord"] = "Hide Record";
+    ActionType["Import"] = "Import";
+    ActionType["Move"] = "Move";
+    ActionType["RemoveAspect"] = "Remove aspect";
+    ActionType["RequestAIRenditions"] = "Request AI renditions";
+    ActionType["SendEmail"] = "Send email";
+    ActionType["SetPropertyValue"] = "Set property value";
+    ActionType["SpecialiseType"] = "Specialise type";
+    ActionType["TransformAndCopyContent"] = "Transform and copy content";
+    ActionType["TransformAndCopyImage"] = "Transform and copy image";
+})(ActionType || (ActionType = {}));
+export class ActionsDropdownComponent extends BaseComponent {
+    constructor(page) {
+        super(page, ActionsDropdownComponent.rootElement);
+        this.getOptionLocator = (optionName) => this.page.locator('.mat-mdc-select-panel .mdc-list-item__primary-text', { hasText: optionName }).first();
+        this.ruleActionLocator = this.getChild('aca-rule-action');
+        this.addActionButtonLocator = this.getChild('[data-automation-id="rule-action-list-add-action-button"]');
+        this.actionDropdownLocator = this.getChild('[data-automation-id="rule-action-select"]');
+        this.actionAspectNameLocator = '[data-automation-id="header-aspect-name"] .adf-property-field';
+        this.actionCheckInInputLocator = '[data-automation-id="header-description"] input';
+        this.actionAutoDeclareLocator = '[data-automation-id="header-version"] mat-select';
+        this.actionSimpleWorkflowStepInputLocator = '[data-automation-id="header-approve-step"] input';
+        this.actionSimpleWorkflowApproveFolderLocator = `[data-automation-id="header-approve-folder"] mat-icon`;
+        this.actionSimpleWorkflowActionChoiceLocator = '[data-automation-id="content-node-selector-actions-choose"]';
+        this.actionSimpleWorkflowLabelApproveLocator = `[data-automation-id="card-boolean-label-approve-move"]`;
+        this.actionSimpleWorkflowSRejectStepLocator = '[data-automation-id="header-reject-step"] input';
+        this.actionSimpleWorkflowRejectFolderLocator = `[data-automation-id="header-reject-folder"] input`;
+    }
+    async selectAction(action, index) {
+        if (index > 0) {
+            await this.addActionButtonLocator.click();
+        }
+        await this.actionDropdownLocator.nth(index).hover({ timeout: 1000 });
+        await this.actionDropdownLocator.nth(index).click();
+        const option = this.getOptionLocator(action);
+        await option.click();
+    }
+    async dropdownSelection(selectValue, locator, index) {
+        await this.ruleActionLocator.nth(index).locator(locator).click();
+        await this.getOptionLocator(selectValue).nth(0).click();
+    }
+    async insertCheckInActionValues(checkInValue, index) {
+        await this.ruleActionLocator.nth(index).locator(this.actionCheckInInputLocator).fill(checkInValue);
+    }
+    async insertAddAspectActionValues(AspectValue, index) {
+        await this.dropdownSelection(AspectValue, this.actionAspectNameLocator, index);
+    }
+    async insertAutoDeclareOptionsActionValues(autoDeclareOptionsValue, index) {
+        await this.dropdownSelection(autoDeclareOptionsValue, this.actionAutoDeclareLocator, index);
+    }
+    async insertSimpleWorkflowActionValues(stepValue, index) {
+        await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowStepInputLocator).fill(stepValue);
+        await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowApproveFolderLocator).click();
+        await this.page.locator(this.actionSimpleWorkflowActionChoiceLocator).click();
+        await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowLabelApproveLocator).click();
+        await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowSRejectStepLocator).fill(stepValue);
+        await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowRejectFolderLocator).click();
+        await this.page.locator(this.actionSimpleWorkflowActionChoiceLocator).click();
+    }
+}
+ActionsDropdownComponent.rootElement = 'aca-edit-rule-dialog aca-rule-action-list';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"actions-dropdown.component.js","sourceRoot":"","sources":["../../../../../../projects/aca-playwright-shared/src/page-objects/components/actions-dropdown.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 { Locator, Page } from '@playwright/test';\nimport { BaseComponent } from './base.component';\n\nexport enum ActionType {\n  AddAspect = 'Add aspect',\n  SimpleWorkflow = 'Add simple workflow',\n  IncrementCounter = 'Increment Counter',\n  CheckIn = 'Check in',\n  AutoDeclareOptions = 'Auto-Declare Options',\n  CheckOut = 'Check out',\n  Copy = 'Copy',\n  ExecuteScript = 'Execute script',\n  ExtractCommonMetadataFields = 'Extract common metadata fields',\n  FileAsRecord = 'File as Record',\n  FileVersionAsRecord = 'File Version as Record',\n  HideRecord = 'Hide Record',\n  Import = 'Import',\n  Move = 'Move',\n  RemoveAspect = 'Remove aspect',\n  RequestAIRenditions = 'Request AI renditions',\n  SendEmail = 'Send email',\n  SetPropertyValue = 'Set property value',\n  SpecialiseType = 'Specialise type',\n  TransformAndCopyContent = 'Transform and copy content',\n  TransformAndCopyImage = 'Transform and copy image'\n}\n\nexport class ActionsDropdownComponent extends BaseComponent {\n  private static rootElement = 'aca-edit-rule-dialog aca-rule-action-list';\n\n  private getOptionLocator = (optionName: string): Locator =>\n    this.page.locator('.mat-mdc-select-panel .mdc-list-item__primary-text', { hasText: optionName }).first();\n  private ruleActionLocator = this.getChild('aca-rule-action');\n  private addActionButtonLocator = this.getChild('[data-automation-id=\"rule-action-list-add-action-button\"]');\n  private actionDropdownLocator = this.getChild('[data-automation-id=\"rule-action-select\"]');\n  private actionAspectNameLocator = '[data-automation-id=\"header-aspect-name\"] .adf-property-field';\n  private actionCheckInInputLocator = '[data-automation-id=\"header-description\"] input';\n  private actionAutoDeclareLocator = '[data-automation-id=\"header-version\"] mat-select';\n  private actionSimpleWorkflowStepInputLocator = '[data-automation-id=\"header-approve-step\"] input';\n  private actionSimpleWorkflowApproveFolderLocator = `[data-automation-id=\"header-approve-folder\"] mat-icon`;\n  private actionSimpleWorkflowActionChoiceLocator = '[data-automation-id=\"content-node-selector-actions-choose\"]';\n  private actionSimpleWorkflowLabelApproveLocator = `[data-automation-id=\"card-boolean-label-approve-move\"]`;\n  private actionSimpleWorkflowSRejectStepLocator = '[data-automation-id=\"header-reject-step\"] input';\n  private actionSimpleWorkflowRejectFolderLocator = `[data-automation-id=\"header-reject-folder\"] input`;\n\n  constructor(page: Page) {\n    super(page, ActionsDropdownComponent.rootElement);\n  }\n\n  async selectAction(action: Partial<ActionType>, index: number): Promise<void> {\n    if (index > 0) {\n      await this.addActionButtonLocator.click();\n    }\n    await this.actionDropdownLocator.nth(index).hover({ timeout: 1000 });\n    await this.actionDropdownLocator.nth(index).click();\n    const option = this.getOptionLocator(action);\n    await option.click();\n  }\n\n  async dropdownSelection(selectValue: string, locator: string, index: number): Promise<void> {\n    await this.ruleActionLocator.nth(index).locator(locator).click();\n    await this.getOptionLocator(selectValue).nth(0).click();\n  }\n\n  async insertCheckInActionValues(checkInValue: string, index: number): Promise<void> {\n    await this.ruleActionLocator.nth(index).locator(this.actionCheckInInputLocator).fill(checkInValue);\n  }\n\n  async insertAddAspectActionValues(AspectValue: string, index: number): Promise<void> {\n    await this.dropdownSelection(AspectValue, this.actionAspectNameLocator, index);\n  }\n\n  async insertAutoDeclareOptionsActionValues(autoDeclareOptionsValue: string, index: number): Promise<void> {\n    await this.dropdownSelection(autoDeclareOptionsValue, this.actionAutoDeclareLocator, index);\n  }\n\n  async insertSimpleWorkflowActionValues(stepValue: string, index: number): Promise<void> {\n    await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowStepInputLocator).fill(stepValue);\n    await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowApproveFolderLocator).click();\n    await this.page.locator(this.actionSimpleWorkflowActionChoiceLocator).click();\n    await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowLabelApproveLocator).click();\n    await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowSRejectStepLocator).fill(stepValue);\n    await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowRejectFolderLocator).click();\n    await this.page.locator(this.actionSimpleWorkflowActionChoiceLocator).click();\n  }\n}\n"]}

package/esm2020/page-objects/components/adf-info-drawer.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';
+import { expect } from '@playwright/test';
+export class AdfInfoDrawerComponent extends BaseComponent {
+    constructor(page) {
+        super(page, AdfInfoDrawerComponent.rootElement);
+        this.getNameField = (labelText) => this.getChild(`[data-automation-id="library-name-properties-wrapper"] input[placeholder='${labelText}']`);
+        this.getIdField = (labelText) => this.getChild(`[data-automation-id="library-id-properties-wrapper"] input[placeholder='${labelText}']`);
+        this.getVisibilityField = (labelText) => this.getChild(`[data-automation-id="library-visibility-properties-wrapper"] mat-select[ng-reflect-placeholder='${labelText}']`);
+        this.getDescriptionField = this.getChild('[data-automation-id="library-description-properties-wrapper"] textarea');
+        this.propertiesTab = this.page.getByRole('tab', { name: 'Properties' });
+        this.commentsTab = this.page.getByRole('tab', { name: 'Comments' });
+        this.infoDrawerTabs = this.getChild('.adf-info-drawer-tab');
+        this.commentInputField = this.page.locator('#comment-input');
+        this.commentsHeader = this.getChild('#comment-header');
+        this.addCommentButton = this.getChild('[data-automation-id="comments-input-add"]');
+        this.commentsList = this.getChild('.adf-comment-list-item');
+        this.commentUsername = this.getChild('.adf-comment-user-name');
+        this.commentTextContent = this.getChild('.adf-comment-message');
+        this.commentTimestamp = this.getChild('.adf-comment-message-time');
+        this.infoDrawerPanel = this.page.locator('.adf-info-drawer');
+        this.headerTitle = this.page.locator('.adf-info-drawer-layout-header-title').getByRole('heading');
+        this.editButton = this.page.getByRole('button', { name: 'Edit' });
+        this.cancelButton = this.page.getByRole('button', { name: 'Cancel' });
+        this.updateButton = this.page.getByRole('button', { name: 'Update' });
+        this.hintMessage = this.page.locator('mat-hint');
+        this.errorMessage = this.page.locator('mat-error');
+        this.expandDetailsButton = this.getChild(`button[title='Expand panel']`);
+        this.expandedDetailsTabs = this.page.locator('.aca-details-container .mdc-tab__text-label');
+        this.expandedDetailsPermissionsTab = this.expandedDetailsTabs.getByText('Permissions');
+        this.nameField = this.page.locator('input[placeholder=Name]');
+        this.idField = this.page.locator(`input[placeholder='Library ID']`);
+        this.descriptionField = this.page.locator('textarea[placeholder=Description]');
+        this.visibilityField = this.infoDrawerPanel.getByRole('combobox');
+        this.selectVisibility = (visibilityOption) => this.page.getByRole('listbox').getByRole('option', { name: visibilityOption }).click();
+    }
+    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();
+    }
+}
+AdfInfoDrawerComponent.rootElement = 'adf-info-drawer';
+//# 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  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\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"]}