@alfresco/aca-playwright-shared 5.1.1-10706961491

package/esm2020/api/sites-api.mjs

@@ -0,0 +1,155 @@
+/*!
+ * 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 { ApiClientFactory } from './api-client-factory';
+import { Site, SiteMemberEntry } from '@alfresco/js-api';
+export class SitesApi {
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new SitesApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    async createSite(title, visibility, description, siteId) {
+        const site = {
+            title,
+            visibility: visibility || Site.VisibilityEnum.PUBLIC,
+            description: description,
+            id: siteId || title
+        };
+        try {
+            return this.apiService.sites.createSite(site);
+        }
+        catch (error) {
+            console.error(`SitesApi createSite : catch : `, error);
+            return null;
+        }
+    }
+    async getDocLibId(siteId) {
+        try {
+            return (await this.apiService.sites.listSiteContainers(siteId)).list.entries[0].entry.id;
+        }
+        catch (error) {
+            console.error(`SitesApi getDocLibId : catch : `, error);
+            return null;
+        }
+    }
+    /**
+     * Delete multiple sites/libraries.
+     * @param siteIds The list of the site/library IDs to delete.
+     * @param permanent Delete permanently, without moving to the trashcan? (default: true)
+     */
+    async deleteSites(siteIds, permanent = true) {
+        try {
+            if (siteIds && siteIds.length > 0) {
+                for (const siteId of siteIds) {
+                    await this.apiService.sites.deleteSite(siteId, { permanent });
+                }
+            }
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.deleteSites.name}`, error);
+        }
+    }
+    async updateSiteMember(siteId, userId, role) {
+        const siteRole = {
+            role: role
+        };
+        try {
+            return this.apiService.sites.updateSiteMembership(siteId, userId, siteRole);
+        }
+        catch (error) {
+            console.error(`SitesApi updateSiteMember : catch : `, error);
+            return new SiteMemberEntry();
+        }
+    }
+    async addSiteMember(siteId, userId, role) {
+        const memberBody = {
+            id: userId,
+            role: role
+        };
+        try {
+            return this.apiService.sites.createSiteMembership(siteId, memberBody);
+        }
+        catch (error) {
+            if (error.status === 409) {
+                return this.updateSiteMember(siteId, userId, role);
+            }
+            else {
+                console.error(`SitesApi addSiteMember : catch : `, error);
+                return new SiteMemberEntry();
+            }
+        }
+    }
+    async createSiteMembershipRequestForPerson(personId, siteId) {
+        const body = {
+            id: siteId
+        };
+        try {
+            return this.apiService.sites.createSiteMembershipRequestForPerson(personId, body);
+        }
+        catch (error) {
+            console.error(`SitesApi createSiteMembershipRequestForPerson : catch : `, error);
+            return null;
+        }
+    }
+    async approveSiteMembershipRequest(siteId, inviteeId) {
+        try {
+            return this.apiService.sites.approveSiteMembershipRequest(siteId, inviteeId);
+        }
+        catch (error) {
+            console.error(`SitesApi approveSiteMembershipRequest : catch : `, error);
+            return null;
+        }
+    }
+    async hasMembershipRequest(personId, siteId) {
+        try {
+            const requests = (await this.apiService.sites.listSiteMembershipRequestsForPerson(personId)).list.entries.map((e) => e.entry.id);
+            return requests.includes(siteId);
+        }
+        catch (error) {
+            console.error(`SitesApi hasMembershipRequest : catch : `, error);
+            return null;
+        }
+    }
+    async deleteSiteMember(siteId, userId) {
+        try {
+            return this.apiService.sites.deleteSiteMembership(siteId, userId);
+        }
+        catch (error) {
+            console.error(`SitesApi deleteSiteMember : catch : `, error);
+        }
+    }
+    async getSite(siteId) {
+        try {
+            return this.apiService.sites.getSite(siteId);
+        }
+        catch (error) {
+            console.error(`SitesApi getSite : catch : `, error);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sites-api.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/api/sites-api.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 { ApiClientFactory } from './api-client-factory';\nimport {\n  Site,\n  SiteBodyCreate,\n  SiteEntry,\n  SiteMemberEntry,\n  SiteMembershipBodyCreate,\n  SiteMembershipBodyUpdate,\n  SiteMembershipRequestBodyCreate,\n  SiteMembershipRequestEntry\n} from '@alfresco/js-api';\n\nexport class SitesApi {\n  private apiService: ApiClientFactory;\n\n  constructor() {\n    this.apiService = new ApiClientFactory();\n  }\n  static async initialize(userName: string, password?: string): Promise<SitesApi> {\n    const classObj = new SitesApi();\n    await classObj.apiService.setUpAcaBackend(userName, password);\n    return classObj;\n  }\n\n  async createSite(title: string, visibility?: string, description?: string, siteId?: string): Promise<SiteEntry | null> {\n    const site = {\n      title,\n      visibility: visibility || Site.VisibilityEnum.PUBLIC,\n      description: description,\n      id: siteId || title\n    } as SiteBodyCreate;\n\n    try {\n      return this.apiService.sites.createSite(site);\n    } catch (error) {\n      console.error(`SitesApi createSite : catch : `, error);\n      return null;\n    }\n  }\n\n  async getDocLibId(siteId: string): Promise<string> {\n    try {\n      return (await this.apiService.sites.listSiteContainers(siteId)).list.entries[0].entry.id;\n    } catch (error) {\n      console.error(`SitesApi getDocLibId : catch : `, error);\n      return null;\n    }\n  }\n\n  /**\n   * Delete multiple sites/libraries.\n   * @param siteIds The list of the site/library IDs to delete.\n   * @param permanent Delete permanently, without moving to the trashcan? (default: true)\n   */\n  async deleteSites(siteIds: string[], permanent: boolean = true) {\n    try {\n      if (siteIds && siteIds.length > 0) {\n        for (const siteId of siteIds) {\n          await this.apiService.sites.deleteSite(siteId, { permanent });\n        }\n      }\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.deleteSites.name}`, error);\n    }\n  }\n\n  async updateSiteMember(siteId: string, userId: string, role: string): Promise<SiteMemberEntry> {\n    const siteRole = {\n      role: role\n    } as SiteMembershipBodyUpdate;\n\n    try {\n      return this.apiService.sites.updateSiteMembership(siteId, userId, siteRole);\n    } catch (error) {\n      console.error(`SitesApi updateSiteMember : catch : `, error);\n      return new SiteMemberEntry();\n    }\n  }\n\n  async addSiteMember(siteId: string, userId: string, role: string): Promise<SiteMemberEntry> {\n    const memberBody = {\n      id: userId,\n      role: role\n    } as SiteMembershipBodyCreate;\n\n    try {\n      return this.apiService.sites.createSiteMembership(siteId, memberBody);\n    } catch (error) {\n      if (error.status === 409) {\n        return this.updateSiteMember(siteId, userId, role);\n      } else {\n        console.error(`SitesApi addSiteMember : catch : `, error);\n        return new SiteMemberEntry();\n      }\n    }\n  }\n\n  async createSiteMembershipRequestForPerson(personId: string, siteId: string): Promise<SiteMembershipRequestEntry> {\n    const body = {\n      id: siteId\n    } as SiteMembershipRequestBodyCreate;\n\n    try {\n      return this.apiService.sites.createSiteMembershipRequestForPerson(personId, body);\n    } catch (error) {\n      console.error(`SitesApi createSiteMembershipRequestForPerson : catch : `, error);\n      return null;\n    }\n  }\n\n  async approveSiteMembershipRequest(siteId: string, inviteeId: string): Promise<SiteMemberEntry> {\n    try {\n      return this.apiService.sites.approveSiteMembershipRequest(siteId, inviteeId);\n    } catch (error) {\n      console.error(`SitesApi approveSiteMembershipRequest : catch : `, error);\n      return null;\n    }\n  }\n\n  async hasMembershipRequest(personId: string, siteId: string): Promise<boolean> {\n    try {\n      const requests = (await this.apiService.sites.listSiteMembershipRequestsForPerson(personId)).list.entries.map((e) => e.entry.id);\n      return requests.includes(siteId);\n    } catch (error) {\n      console.error(`SitesApi hasMembershipRequest : catch : `, error);\n      return null;\n    }\n  }\n\n  async deleteSiteMember(siteId: string, userId: string) {\n    try {\n      return this.apiService.sites.deleteSiteMembership(siteId, userId);\n    } catch (error) {\n      console.error(`SitesApi deleteSiteMember : catch : `, error);\n    }\n  }\n\n  async getSite(siteId: string): Promise<SiteEntry> {\n    try {\n      return this.apiService.sites.getSite(siteId);\n    } catch (error) {\n      console.error(`SitesApi getSite : catch : `, error);\n      return null;\n    }\n  }\n}\n"]}

package/esm2020/api/tags-api.mjs

@@ -0,0 +1,61 @@
+/*!
+ * 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 { ApiClientFactory } from './api-client-factory';
+export class TagsApi {
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new TagsApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    async createTags(tags) {
+        try {
+            return this.apiService.tagsApi.createTags(tags);
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    }
+    async assignTagToNode(nodeId, tag) {
+        try {
+            return this.apiService.tagsApi.assignTagToNode(nodeId, tag);
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    }
+    async deleteTag(tagId) {
+        try {
+            return this.apiService.tagsApi.deleteTag(tagId);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFncy1hcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtcGxheXdyaWdodC1zaGFyZWQvc3JjL2FwaS90YWdzLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUdILE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRXhELE1BQU0sT0FBTyxPQUFPO0lBR2xCO1FBQ0UsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLGdCQUFnQixFQUFFLENBQUM7SUFDM0MsQ0FBQztJQUVELE1BQU0sQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLFFBQWdCLEVBQUUsUUFBaUI7UUFDekQsTUFBTSxRQUFRLEdBQUcsSUFBSSxPQUFPLEVBQUUsQ0FBQztRQUMvQixNQUFNLFFBQVEsQ0FBQyxVQUFVLENBQUMsZUFBZSxDQUFDLFFBQVEsRUFBRSxRQUFRLENBQUMsQ0FBQztRQUM5RCxPQUFPLFFBQVEsQ0FBQztJQUNsQixDQUFDO0lBRUQsS0FBSyxDQUFDLFVBQVUsQ0FBQyxJQUFlO1FBQzlCLElBQUk7WUFDRixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQztTQUNqRDtRQUFDLE9BQU8sS0FBSyxFQUFFO1lBQ2QsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUNyQixPQUFPLElBQUksQ0FBQztTQUNiO0lBQ0gsQ0FBQztJQUVELEtBQUssQ0FBQyxlQUFlLENBQUMsTUFBYyxFQUFFLEdBQVk7UUFDaEQsSUFBSTtZQUNGLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDLE1BQU0sRUFBRSxHQUFHLENBQUMsQ0FBQztTQUM3RDtRQUFDLE9BQU8sS0FBSyxFQUFFO1lBQ2QsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUNyQixPQUFPLElBQUksQ0FBQztTQUNiO0lBQ0gsQ0FBQztJQUVELEtBQUssQ0FBQyxTQUFTLENBQUMsS0FBYTtRQUMzQixJQUFJO1lBQ0YsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUM7U0FDakQ7UUFBQyxPQUFPLEtBQUssRUFBRTtZQUNkLE9BQU8sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7U0FDdEI7SUFDSCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjQgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb25cbiAqXG4gKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uLlxuICogSWYgdGhlIHNvZnR3YXJlIHdhcyBwdXJjaGFzZWQgdW5kZXIgYSBwYWlkIEFsZnJlc2NvIGxpY2Vuc2UsIHRoZSB0ZXJtcyBvZlxuICogdGhlIHBhaWQgbGljZW5zZSBhZ3JlZW1lbnQgd2lsbCBwcmV2YWlsLiBPdGhlcndpc2UsIHRoZSBzb2Z0d2FyZSBpc1xuICogcHJvdmlkZWQgdW5kZXIgdGhlIGZvbGxvd2luZyBvcGVuIHNvdXJjZSBsaWNlbnNlIHRlcm1zOlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeVxuICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5XG4gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvclxuICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi5cbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsXG4gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZlxuICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlXG4gKiBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy5cbiAqXG4gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2VcbiAqIGZyb20gSHlsYW5kIFNvZnR3YXJlLiBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uXG4gKi9cblxuaW1wb3J0IHsgVGFnQm9keSwgVGFnRW50cnkgfSBmcm9tICdAYWxmcmVzY28vanMtYXBpJztcbmltcG9ydCB7IEFwaUNsaWVudEZhY3RvcnkgfSBmcm9tICcuL2FwaS1jbGllbnQtZmFjdG9yeSc7XG5cbmV4cG9ydCBjbGFzcyBUYWdzQXBpIHtcbiAgcHJpdmF0ZSBhcGlTZXJ2aWNlOiBBcGlDbGllbnRGYWN0b3J5O1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHRoaXMuYXBpU2VydmljZSA9IG5ldyBBcGlDbGllbnRGYWN0b3J5KCk7XG4gIH1cblxuICBzdGF0aWMgYXN5bmMgaW5pdGlhbGl6ZSh1c2VyTmFtZTogc3RyaW5nLCBwYXNzd29yZD86IHN0cmluZyk6IFByb21pc2U8VGFnc0FwaT4ge1xuICAgIGNvbnN0IGNsYXNzT2JqID0gbmV3IFRhZ3NBcGkoKTtcbiAgICBhd2FpdCBjbGFzc09iai5hcGlTZXJ2aWNlLnNldFVwQWNhQmFja2VuZCh1c2VyTmFtZSwgcGFzc3dvcmQpO1xuICAgIHJldHVybiBjbGFzc09iajtcbiAgfVxuXG4gIGFzeW5jIGNyZWF0ZVRhZ3ModGFnczogVGFnQm9keVtdKTogUHJvbWlzZTxUYWdFbnRyeVtdPiB7XG4gICAgdHJ5IHtcbiAgICAgIHJldHVybiB0aGlzLmFwaVNlcnZpY2UudGFnc0FwaS5jcmVhdGVUYWdzKHRhZ3MpO1xuICAgIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgICBjb25zb2xlLmVycm9yKGVycm9yKTtcbiAgICAgIHJldHVybiBudWxsO1xuICAgIH1cbiAgfVxuXG4gIGFzeW5jIGFzc2lnblRhZ1RvTm9kZShub2RlSWQ6IHN0cmluZywgdGFnOiBUYWdCb2R5KTogUHJvbWlzZTxUYWdFbnRyeT4ge1xuICAgIHRyeSB7XG4gICAgICByZXR1cm4gdGhpcy5hcGlTZXJ2aWNlLnRhZ3NBcGkuYXNzaWduVGFnVG9Ob2RlKG5vZGVJZCwgdGFnKTtcbiAgICB9IGNhdGNoIChlcnJvcikge1xuICAgICAgY29uc29sZS5lcnJvcihlcnJvcik7XG4gICAgICByZXR1cm4gbnVsbDtcbiAgICB9XG4gIH1cblxuICBhc3luYyBkZWxldGVUYWcodGFnSWQ6IHN0cmluZyk6IFByb21pc2U8dm9pZD4ge1xuICAgIHRyeSB7XG4gICAgICByZXR1cm4gdGhpcy5hcGlTZXJ2aWNlLnRhZ3NBcGkuZGVsZXRlVGFnKHRhZ0lkKTtcbiAgICB9IGNhdGNoIChlcnJvcikge1xuICAgICAgY29uc29sZS5lcnJvcihlcnJvcik7XG4gICAgfVxuICB9XG59XG4iXX0=

package/esm2020/api/trashcan-api.mjs

@@ -0,0 +1,54 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { ApiClientFactory } from './api-client-factory';
+export class TrashcanApi {
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new TrashcanApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    /**
+     * Empties the trashcan. Uses multiple batches 1000 nodes each.
+     */
+    async emptyTrashcan() {
+        try {
+            const nodes = await this.apiService.trashCan.listDeletedNodes({
+                maxItems: 1000
+            });
+            if (nodes?.list?.entries?.length > 0) {
+                const ids = nodes.list.entries.map((entries) => entries.entry.id);
+                for (const nodeId of ids) {
+                    await this.apiService.trashCan.deleteDeletedNode(nodeId);
+                }
+            }
+        }
+        catch (error) {
+            console.error('User Actions - emptyTrashcan failed : ', error);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/base-config/global-variables.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/>.
+ */
+const env = process.env;
+export const testEmailDomain = env.E2E_EMAIL_DOMAIN;
+export const users = {
+    hruser: {
+        username: env.HR_USER,
+        password: env.HR_USER_PASSWORD
+    },
+    admin: {
+        username: env.ADMIN_EMAIL,
+        password: env.ADMIN_PASSWORD
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/base-config/global.setup.mjs

@@ -0,0 +1,66 @@
+/*!
+ * 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 { chromium } from '@playwright/test';
+import { LoginPage } from '../page-objects';
+import { users } from './global-variables';
+import fs from 'fs';
+import { paths } from '../utils/paths';
+async function globalSetup(config) {
+    const { use } = config.projects[0];
+    await removeOutputFolders();
+    await createOutputFolders();
+    if (use.users) {
+        for (const user of use.users) {
+            if (users[user].username) {
+                const browser = await chromium.launch();
+                const page = await browser.newPage();
+                const loginPage = new LoginPage(page);
+                await page.goto(use.baseURL);
+                await loginPage.loginUser({ username: users[user].username, password: users[user].password }, {
+                    withNavigation: false,
+                    waitForLoading: true
+                });
+                await page.context().storageState({ path: `${paths.userStates}/${user}UserState.json` });
+                await browser.close();
+            }
+            else {
+                throw new Error(`Add credentials for ${user} to you .env file!`);
+            }
+        }
+    }
+}
+async function createOutputFolders() {
+    for (const path in paths) {
+        if (!fs.existsSync(paths[path])) {
+            fs.mkdirSync(paths[path], { recursive: true });
+        }
+    }
+}
+async function removeOutputFolders() {
+    if (fs.existsSync(paths.rootFolder)) {
+        fs.rmdirSync(paths.rootFolder, { recursive: true });
+    }
+}
+export default globalSetup;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/base-config/index.mjs

@@ -0,0 +1,27 @@
+/*!
+ * 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 './global.setup';
+export * from './playwright.config';
+export * from './global-variables';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/base-config/playwright.config.mjs

@@ -0,0 +1,78 @@
+/*!
+ * 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 { devices } from '@playwright/test';
+import { timeouts } from '../utils';
+import { getReporter } from './report-portal.config';
+require('@alfresco/adf-cli/tooling').dotenvConfig();
+const { env } = process;
+export const getGlobalConfig = {
+    timeout: timeouts.globalTest,
+    globalTimeout: timeouts.globalSpec,
+    expect: {
+        /**
+         * Maximum time expect() should wait for the condition to be met.
+         * For example in `await expect(locator).toHaveText();`
+         */
+        timeout: timeouts.medium
+    },
+    /* Run tests in files in parallel */
+    fullyParallel: true,
+    /* Fail the build on CI if you accidentally left test.only in the source code. */
+    forbidOnly: !!env.CI,
+    /* Retry on CI only */
+    retries: env.CI ? 2 : 0,
+    /* Opt out of parallel tests on CI. */
+    workers: 3,
+    /* Reporter to use. See https://playwright.dev/docs/test-reporters */
+    reporter: [['list'], ...getReporter()],
+    globalSetup: require.resolve('./global.setup'),
+    testMatch: ['**/*.e2e.ts'],
+    use: {
+        /* Maximum time each action such as `click()` can take. Defaults to 0 (no limit). */
+        actionTimeout: 0,
+        /* Base URL to use in actions like `await page.goto('/')`. */
+        baseURL: env.PLAYWRIGHT_E2E_HOST,
+        headless: env.PLAYWRIGHT_HEADLESS === 'true' || !!env.CI,
+        ignoreHTTPSErrors: true,
+        bypassCSP: true,
+        /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+        trace: 'retain-on-failure',
+        video: 'retain-on-failure',
+        screenshot: 'only-on-failure',
+        launchOptions: {
+            devtools: false,
+            args: ['--no-sandbox', '--disable-site-isolation-trials']
+        }
+    },
+    /* Configure projects for major browsers */
+    projects: [
+        {
+            name: 'chromium',
+            use: {
+                ...devices['Desktop Chrome']
+            }
+        }
+    ]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxheXdyaWdodC5jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtcGxheXdyaWdodC1zaGFyZWQvc3JjL2Jhc2UtY29uZmlnL3BsYXl3cmlnaHQuY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBRUgsT0FBTyxFQUF3QixPQUFPLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNqRSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUVyRCxPQUFPLENBQUMsMkJBQTJCLENBQUMsQ0FBQyxZQUFZLEVBQUUsQ0FBQztBQUNwRCxNQUFNLEVBQUUsR0FBRyxFQUFFLEdBQUcsT0FBTyxDQUFDO0FBRXhCLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBeUI7SUFDbkQsT0FBTyxFQUFFLFFBQVEsQ0FBQyxVQUFVO0lBQzVCLGFBQWEsRUFBRSxRQUFRLENBQUMsVUFBVTtJQUNsQyxNQUFNLEVBQUU7UUFDTjs7O1dBR0c7UUFDSCxPQUFPLEVBQUUsUUFBUSxDQUFDLE1BQU07S0FDekI7SUFDRCxvQ0FBb0M7SUFDcEMsYUFBYSxFQUFFLElBQUk7SUFDbkIsaUZBQWlGO0lBQ2pGLFVBQVUsRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLEVBQUU7SUFDcEIsc0JBQXNCO0lBQ3RCLE9BQU8sRUFBRSxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDdkIsc0NBQXNDO0lBQ3RDLE9BQU8sRUFBRSxDQUFDO0lBQ1YscUVBQXFFO0lBQ3JFLFFBQVEsRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsR0FBRyxXQUFXLEVBQUUsQ0FBQztJQUN0QyxXQUFXLEVBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQztJQUM5QyxTQUFTLEVBQUUsQ0FBQyxhQUFhLENBQUM7SUFDMUIsR0FBRyxFQUFFO1FBQ0gsb0ZBQW9GO1FBQ3BGLGFBQWEsRUFBRSxDQUFDO1FBQ2hCLDZEQUE2RDtRQUM3RCxPQUFPLEVBQUUsR0FBRyxDQUFDLG1CQUFtQjtRQUNoQyxRQUFRLEVBQUUsR0FBRyxDQUFDLG1CQUFtQixLQUFLLE1BQU0sSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLEVBQUU7UUFDeEQsaUJBQWlCLEVBQUUsSUFBSTtRQUN2QixTQUFTLEVBQUUsSUFBSTtRQUNmLCtGQUErRjtRQUMvRixLQUFLLEVBQUUsbUJBQW1CO1FBQzFCLEtBQUssRUFBRSxtQkFBbUI7UUFDMUIsVUFBVSxFQUFFLGlCQUFpQjtRQUM3QixhQUFhLEVBQUU7WUFDYixRQUFRLEVBQUUsS0FBSztZQUNmLElBQUksRUFBRSxDQUFDLGNBQWMsRUFBRSxpQ0FBaUMsQ0FBQztTQUMxRDtLQUNGO0lBRUQsMkNBQTJDO0lBQzNDLFFBQVEsRUFBRTtRQUNSO1lBQ0UsSUFBSSxFQUFFLFVBQVU7WUFDaEIsR0FBRyxFQUFFO2dCQUNILEdBQUcsT0FBTyxDQUFDLGdCQUFnQixDQUFDO2FBQzdCO1NBQ0Y7S0FDRjtDQUNGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjQgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb25cbiAqXG4gKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uLlxuICogSWYgdGhlIHNvZnR3YXJlIHdhcyBwdXJjaGFzZWQgdW5kZXIgYSBwYWlkIEFsZnJlc2NvIGxpY2Vuc2UsIHRoZSB0ZXJtcyBvZlxuICogdGhlIHBhaWQgbGljZW5zZSBhZ3JlZW1lbnQgd2lsbCBwcmV2YWlsLiBPdGhlcndpc2UsIHRoZSBzb2Z0d2FyZSBpc1xuICogcHJvdmlkZWQgdW5kZXIgdGhlIGZvbGxvd2luZyBvcGVuIHNvdXJjZSBsaWNlbnNlIHRlcm1zOlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeVxuICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5XG4gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvclxuICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi5cbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsXG4gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZlxuICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlXG4gKiBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy5cbiAqXG4gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2VcbiAqIGZyb20gSHlsYW5kIFNvZnR3YXJlLiBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uXG4gKi9cblxuaW1wb3J0IHsgUGxheXdyaWdodFRlc3RDb25maWcsIGRldmljZXMgfSBmcm9tICdAcGxheXdyaWdodC90ZXN0JztcbmltcG9ydCB7IHRpbWVvdXRzIH0gZnJvbSAnLi4vdXRpbHMnO1xuaW1wb3J0IHsgZ2V0UmVwb3J0ZXIgfSBmcm9tICcuL3JlcG9ydC1wb3J0YWwuY29uZmlnJztcblxucmVxdWlyZSgnQGFsZnJlc2NvL2FkZi1jbGkvdG9vbGluZycpLmRvdGVudkNvbmZpZygpO1xuY29uc3QgeyBlbnYgfSA9IHByb2Nlc3M7XG5cbmV4cG9ydCBjb25zdCBnZXRHbG9iYWxDb25maWc6IFBsYXl3cmlnaHRUZXN0Q29uZmlnID0ge1xuICB0aW1lb3V0OiB0aW1lb3V0cy5nbG9iYWxUZXN0LFxuICBnbG9iYWxUaW1lb3V0OiB0aW1lb3V0cy5nbG9iYWxTcGVjLFxuICBleHBlY3Q6IHtcbiAgICAvKipcbiAgICAgKiBNYXhpbXVtIHRpbWUgZXhwZWN0KCkgc2hvdWxkIHdhaXQgZm9yIHRoZSBjb25kaXRpb24gdG8gYmUgbWV0LlxuICAgICAqIEZvciBleGFtcGxlIGluIGBhd2FpdCBleHBlY3QobG9jYXRvcikudG9IYXZlVGV4dCgpO2BcbiAgICAgKi9cbiAgICB0aW1lb3V0OiB0aW1lb3V0cy5tZWRpdW1cbiAgfSxcbiAgLyogUnVuIHRlc3RzIGluIGZpbGVzIGluIHBhcmFsbGVsICovXG4gIGZ1bGx5UGFyYWxsZWw6IHRydWUsXG4gIC8qIEZhaWwgdGhlIGJ1aWxkIG9uIENJIGlmIHlvdSBhY2NpZGVudGFsbHkgbGVmdCB0ZXN0Lm9ubHkgaW4gdGhlIHNvdXJjZSBjb2RlLiAqL1xuICBmb3JiaWRPbmx5OiAhIWVudi5DSSxcbiAgLyogUmV0cnkgb24gQ0kgb25seSAqL1xuICByZXRyaWVzOiBlbnYuQ0kgPyAyIDogMCxcbiAgLyogT3B0IG91dCBvZiBwYXJhbGxlbCB0ZXN0cyBvbiBDSS4gKi9cbiAgd29ya2VyczogMyxcbiAgLyogUmVwb3J0ZXIgdG8gdXNlLiBTZWUgaHR0cHM6Ly9wbGF5d3JpZ2h0LmRldi9kb2NzL3Rlc3QtcmVwb3J0ZXJzICovXG4gIHJlcG9ydGVyOiBbWydsaXN0J10sIC4uLmdldFJlcG9ydGVyKCldLFxuICBnbG9iYWxTZXR1cDogcmVxdWlyZS5yZXNvbHZlKCcuL2dsb2JhbC5zZXR1cCcpLFxuICB0ZXN0TWF0Y2g6IFsnKiovKi5lMmUudHMnXSxcbiAgdXNlOiB7XG4gICAgLyogTWF4aW11bSB0aW1lIGVhY2ggYWN0aW9uIHN1Y2ggYXMgYGNsaWNrKClgIGNhbiB0YWtlLiBEZWZhdWx0cyB0byAwIChubyBsaW1pdCkuICovXG4gICAgYWN0aW9uVGltZW91dDogMCxcbiAgICAvKiBCYXNlIFVSTCB0byB1c2UgaW4gYWN0aW9ucyBsaWtlIGBhd2FpdCBwYWdlLmdvdG8oJy8nKWAuICovXG4gICAgYmFzZVVSTDogZW52LlBMQVlXUklHSFRfRTJFX0hPU1QsXG4gICAgaGVhZGxlc3M6IGVudi5QTEFZV1JJR0hUX0hFQURMRVNTID09PSAndHJ1ZScgfHwgISFlbnYuQ0ksXG4gICAgaWdub3JlSFRUUFNFcnJvcnM6IHRydWUsXG4gICAgYnlwYXNzQ1NQOiB0cnVlLFxuICAgIC8qIENvbGxlY3QgdHJhY2Ugd2hlbiByZXRyeWluZyB0aGUgZmFpbGVkIHRlc3QuIFNlZSBodHRwczovL3BsYXl3cmlnaHQuZGV2L2RvY3MvdHJhY2Utdmlld2VyICovXG4gICAgdHJhY2U6ICdyZXRhaW4tb24tZmFpbHVyZScsXG4gICAgdmlkZW86ICdyZXRhaW4tb24tZmFpbHVyZScsXG4gICAgc2NyZWVuc2hvdDogJ29ubHktb24tZmFpbHVyZScsXG4gICAgbGF1bmNoT3B0aW9uczoge1xuICAgICAgZGV2dG9vbHM6IGZhbHNlLFxuICAgICAgYXJnczogWyctLW5vLXNhbmRib3gnLCAnLS1kaXNhYmxlLXNpdGUtaXNvbGF0aW9uLXRyaWFscyddXG4gICAgfVxuICB9LFxuXG4gIC8qIENvbmZpZ3VyZSBwcm9qZWN0cyBmb3IgbWFqb3IgYnJvd3NlcnMgKi9cbiAgcHJvamVjdHM6IFtcbiAgICB7XG4gICAgICBuYW1lOiAnY2hyb21pdW0nLFxuICAgICAgdXNlOiB7XG4gICAgICAgIC4uLmRldmljZXNbJ0Rlc2t0b3AgQ2hyb21lJ11cbiAgICAgIH1cbiAgICB9XG4gIF1cbn07XG4iXX0=

package/esm2020/base-config/report-portal.config.mjs

@@ -0,0 +1,48 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { timeouts } from '../utils';
+const { env } = process;
+export const getReportPortalConfig = () => {
+    const attributes = [
+        { key: 'Job', value: `${env.GITHUB_JOB}` },
+        { key: 'Build_type', value: `${env.GITHUB_EVENT_NAME}` },
+        { key: 'Repository', value: `${env.GITHUB_REPOSITORY}` },
+        { key: 'Branch', value: `${env.GITHUB_HEAD_REF || env.GITHUB_REF}` }
+    ];
+    const launch = `GitHub Actions - ACA`;
+    return {
+        endpoint: env.REPORT_PORTAL_URL,
+        apiKey: env.REPORT_PORTAL_TOKEN,
+        project: 'alfresco-content-app',
+        launch,
+        includeTestSteps: true,
+        restClientConfig: {
+            timeout: timeouts.extendedTest
+        },
+        attributes,
+        description: `[Run on GitHub Actions ${env.GITHUB_RUN_ID}](${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}/actions/runs/${env.GITHUB_RUN_ID})`
+    };
+};
+export const getReporter = () => env.CI ? [['@reportportal/agent-js-playwright', getReportPortalConfig()], ['github']] : [['html']];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/fixtures/index.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 * from './page-initialization';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtcGxheXdyaWdodC1zaGFyZWQvc3JjL2ZpeHR1cmVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBRUgsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNCBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvblxuICpcbiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24uXG4gKiBJZiB0aGUgc29mdHdhcmUgd2FzIHB1cmNoYXNlZCB1bmRlciBhIHBhaWQgQWxmcmVzY28gbGljZW5zZSwgdGhlIHRlcm1zIG9mXG4gKiB0aGUgcGFpZCBsaWNlbnNlIGFncmVlbWVudCB3aWxsIHByZXZhaWwuIE90aGVyd2lzZSwgdGhlIHNvZnR3YXJlIGlzXG4gKiBwcm92aWRlZCB1bmRlciB0aGUgZm9sbG93aW5nIG9wZW4gc291cmNlIGxpY2Vuc2UgdGVybXM6XG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBmcmVlIHNvZnR3YXJlOiB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5XG4gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnlcbiAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yXG4gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCxcbiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mXG4gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGVcbiAqIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLlxuICpcbiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZVxuICogZnJvbSBIeWxhbmQgU29mdHdhcmUuIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3BhZ2UtaW5pdGlhbGl6YXRpb24nO1xuIl19