@alfresco/aca-playwright-shared 5.1.1-10706961491

package/esm2020/utils/config.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/>.
+ */
+export const APP_ROUTES = {
+    FAVORITES: '/favorites',
+    MY_LIBRARIES: '/libraries',
+    FAVORITE_LIBRARIES: '/favorite/libraries',
+    LOGIN: '/login',
+    LOGOUT: '/logout',
+    PERSONAL_FILES: '/personal-files',
+    RECENT_FILES: '/recent-files',
+    SHARED_FILES: '/shared',
+    TRASHCAN: '/trashcan'
+};
+export const SIDEBAR_LABELS = {
+    PERSONAL_FILES: 'Personal Files',
+    MY_LIBRARIES: 'My Libraries',
+    FAVORITE_LIBRARIES: 'Favorite Libraries',
+    SHARED_FILES: 'Shared',
+    RECENT_FILES: 'Recent Files',
+    FAVORITES: 'Favorites',
+    TRASH: 'Trash'
+};
+export const SITE_ROLES = {
+    SITE_MANAGER: {
+        ROLE: 'SiteManager',
+        LABEL: 'Manager'
+    },
+    SITE_CONSUMER: {
+        ROLE: 'SiteConsumer',
+        LABEL: 'Consumer'
+    },
+    SITE_CONTRIBUTOR: {
+        ROLE: 'SiteContributor',
+        LABEL: 'Contributor'
+    },
+    SITE_COLLABORATOR: {
+        ROLE: 'SiteCollaborator',
+        LABEL: 'Collaborator'
+    },
+    NONE: {
+        LABEL: 'Not a member'
+    }
+};
+export const SITE_VISIBILITY = {
+    PUBLIC: 'PUBLIC',
+    MODERATED: 'MODERATED',
+    PRIVATE: 'PRIVATE'
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/error-strings.mjs

@@ -0,0 +1,39 @@
+/*!
+ * 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 const errorStrings = {
+    errorMessageNotPresent: 'Error message is not displayed',
+    nameIsRequiredError: 'Name is required',
+    nameWithSpecialCharactersError: `Name can't contain these characters * " < > \\ / ? : |`,
+    nameEndWithDotError: `Name can't end with a period .`,
+    nameContainOnlySpacesError: `Name can't contain only spaces`,
+    titleLengthLimitError: 'Use 256 characters or less for title',
+    descriptionLengthLimitError: 'Use 512 characters or less for description',
+    nameAlreadyUsedError: 'This name is already in use, try a different name.',
+    folderNameIsRequired: 'Folder name is required',
+    folderNameCantEndWithAPeriod: `Folder name can't end with a period .`,
+    folderNameCantContainTheseCharacters: `Folder name can't contain these characters`,
+    folderNameCantContainOnlySpaces: `Folder name can't contain only spaces`,
+    thereIsAlreadyAFolderWithThisName: `There's already a folder with this name. Try a different name.`
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/exclude-tests.mjs

@@ -0,0 +1,35 @@
+/*!
+ * 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 const getExcludedTestsRegExpArray = (excludedJson, projectName) => {
+    const prefix = `[ 🎭 Playwright Excludes - ${projectName} ]`;
+    const objectKeys = Object.keys(excludedJson);
+    if (!objectKeys.length) {
+        console.info(`${prefix} ✅ No excluded tests 🎉 `);
+    }
+    else {
+        console.warn(`${prefix} ❌ Tests excluded because of 🐛 : ${objectKeys}`);
+    }
+    return objectKeys.map((key) => new RegExp(key));
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/index.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/>.
+ */
+export * from './paths';
+export * from './timeouts';
+export * from './exclude-tests';
+export * from './state-helper';
+export * from './utils';
+export * from './library-errors';
+export * from './config';
+export * from './error-strings';
+export * from './api';
+export * from './logger';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/library-errors.mjs

@@ -0,0 +1,29 @@
+/*!
+ * 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 const libraryErrors = {
+    libraryIdIsNotAvailable: "This Library ID isn't available. Try a different Library ID.",
+    libraryIdIsAlreadyUsed: 'This Library ID is already used. Check the trashcan.',
+    useNumbersAndLettersOnly: 'Use numbers and letters only'
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/logger.mjs

@@ -0,0 +1,69 @@
+/*!
+ * 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/>.
+ */
+/* eslint-disable @typescript-eslint/naming-convention */
+export const infoColor = '\x1b[36m%s\x1b[0m';
+export const logColor = '\x1b[35m%s\x1b[0m';
+export const warnColor = '\x1b[33m%s\x1b[0m';
+export const errorColor = '\x1b[31m%s\x1b[0m';
+export class LogLevelsEnum extends Number {
+}
+LogLevelsEnum.TRACE = 5;
+LogLevelsEnum.DEBUG = 4;
+LogLevelsEnum.INFO = 3;
+LogLevelsEnum.WARN = 2;
+LogLevelsEnum.ERROR = 1;
+LogLevelsEnum.SILENT = 0;
+export const logLevels = [
+    { level: LogLevelsEnum.TRACE, name: 'TRACE' },
+    { level: LogLevelsEnum.DEBUG, name: 'DEBUG' },
+    { level: LogLevelsEnum.INFO, name: 'INFO' },
+    { level: LogLevelsEnum.WARN, name: 'WARN' },
+    { level: LogLevelsEnum.ERROR, name: 'ERROR' },
+    { level: LogLevelsEnum.SILENT, name: 'SILENT' }
+];
+/* eslint-disable no-console */
+export class GenericLogger {
+    constructor(logLevel) {
+        this.level = logLevels.find(({ name }) => name === logLevel)?.level || LogLevelsEnum.ERROR;
+    }
+    info(...messages) {
+        if (Number(this.level) >= LogLevelsEnum.INFO) {
+            console.log(infoColor, messages.join(''));
+        }
+    }
+    log(...messages) {
+        if (Number(this.level) >= LogLevelsEnum.TRACE) {
+            console.log(logColor, messages.join(''));
+        }
+    }
+    warn(...messages) {
+        if (Number(this.level) >= LogLevelsEnum.WARN) {
+            console.log(warnColor, messages.join(''));
+        }
+    }
+    error(...messages) {
+        console.log(errorColor, messages.join(''));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/paths.mjs

@@ -0,0 +1,32 @@
+/*!
+ * 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 rootFolder = 'e2e-output';
+export const paths = {
+    rootFolder,
+    allData: `${rootFolder}/playwright-data`,
+    files: `${rootFolder}/playwright-data/downloads`,
+    report: `${rootFolder}/playwright-data/report`,
+    userStates: `${rootFolder}/playwright-data/user-states`
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtcGxheXdyaWdodC1zaGFyZWQvc3JjL3V0aWxzL3BhdGhzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBRUgsTUFBTSxVQUFVLEdBQUcsWUFBWSxDQUFDO0FBRWhDLE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FBRztJQUNuQixVQUFVO0lBQ1YsT0FBTyxFQUFFLEdBQUcsVUFBVSxrQkFBa0I7SUFDeEMsS0FBSyxFQUFFLEdBQUcsVUFBVSw0QkFBNEI7SUFDaEQsTUFBTSxFQUFFLEdBQUcsVUFBVSx5QkFBeUI7SUFDOUMsVUFBVSxFQUFFLEdBQUcsVUFBVSw4QkFBOEI7Q0FDeEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNCBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvblxuICpcbiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24uXG4gKiBJZiB0aGUgc29mdHdhcmUgd2FzIHB1cmNoYXNlZCB1bmRlciBhIHBhaWQgQWxmcmVzY28gbGljZW5zZSwgdGhlIHRlcm1zIG9mXG4gKiB0aGUgcGFpZCBsaWNlbnNlIGFncmVlbWVudCB3aWxsIHByZXZhaWwuIE90aGVyd2lzZSwgdGhlIHNvZnR3YXJlIGlzXG4gKiBwcm92aWRlZCB1bmRlciB0aGUgZm9sbG93aW5nIG9wZW4gc291cmNlIGxpY2Vuc2UgdGVybXM6XG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBmcmVlIHNvZnR3YXJlOiB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5XG4gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnlcbiAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yXG4gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCxcbiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mXG4gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGVcbiAqIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLlxuICpcbiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZVxuICogZnJvbSBIeWxhbmQgU29mdHdhcmUuIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi5cbiAqL1xuXG5jb25zdCByb290Rm9sZGVyID0gJ2UyZS1vdXRwdXQnO1xuXG5leHBvcnQgY29uc3QgcGF0aHMgPSB7XG4gIHJvb3RGb2xkZXIsXG4gIGFsbERhdGE6IGAke3Jvb3RGb2xkZXJ9L3BsYXl3cmlnaHQtZGF0YWAsXG4gIGZpbGVzOiBgJHtyb290Rm9sZGVyfS9wbGF5d3JpZ2h0LWRhdGEvZG93bmxvYWRzYCxcbiAgcmVwb3J0OiBgJHtyb290Rm9sZGVyfS9wbGF5d3JpZ2h0LWRhdGEvcmVwb3J0YCxcbiAgdXNlclN0YXRlczogYCR7cm9vdEZvbGRlcn0vcGxheXdyaWdodC1kYXRhL3VzZXItc3RhdGVzYFxufTtcbiJdfQ==

package/esm2020/utils/state-helper.mjs

@@ -0,0 +1,29 @@
+/*!
+ * 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 { resolve } from 'path';
+import { paths } from '.';
+export function getUserState(user) {
+    return resolve(process.cwd(), `${paths.userStates}/${user}UserState.json`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/timeouts.mjs

@@ -0,0 +1,39 @@
+/*!
+ * 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 const timeouts = {
+    typingDelay: 50,
+    tiny: 500,
+    short: 1000,
+    normal: 2000,
+    medium: 5000,
+    big: 7500,
+    large: 10000,
+    extraLarge: 20 * 1000,
+    globalTest: 85 * 1000,
+    extendedTest: 150 * 1000,
+    extendedLongTest: 200 * 1000,
+    webServer: 240 * 1000,
+    globalSpec: 60 * 10 * 1000
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/utils.mjs

@@ -0,0 +1,144 @@
+/*!
+ * 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 crypto = require('crypto');
+import * as path from 'path';
+import { format, subDays, subMonths, endOfMonth } from 'date-fns';
+import StreamZip from 'node-stream-zip';
+export class Utils {
+    static random() {
+        return crypto.getRandomValues(new Uint32Array(1))[0].toString(36).substring(0, 5).toLowerCase();
+    }
+    static retryCall(fn, retry = 30, delay = 1500) {
+        const pause = (duration) => new Promise((res) => setTimeout(res, duration));
+        const run = (retries) => {
+            return fn().catch((err) => (retries > 1 ? pause(delay).then(() => run(retries - 1)) : Promise.reject(err)));
+        };
+        return run(retry);
+    }
+    static formatDate(date) {
+        return new Date(date).toLocaleDateString('en-US');
+    }
+    /**
+     * Method used to login user with navigation. Also waits for the page to load after login
+     *
+     * @param loginPage page context passed from the test
+     * @param username username string
+     * @param password password string
+     * @param errorMessage error message string if the login fails
+     *
+     */
+    static async tryLoginUser(loginPage, username, password, errorMessage = 'Error ') {
+        try {
+            await loginPage.loginUser({ username, password }, { withNavigation: true, waitForLoading: true });
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    /**
+     * Method used to delete nodes and sites from user's account
+     *
+     * @param nodesApi nodesApi initialized with user credentials passed from the test
+     * @param trashcanApi trashcanApi initialized with user credentials passed from the test
+     * @param errorMessage error message string if the deleting sites/nodes fails
+     * @param sitesApi sitesApi initialized with user credentials passed from the test
+     * @param sitesToDelete array of sites' ids
+     *
+     */
+    static async deleteNodesSitesEmptyTrashcan(nodesApi, trashcanApi, errorMessage = 'Error ', sitesApi, sitesToDelete) {
+        try {
+            await nodesApi?.deleteCurrentUserNodes();
+            await trashcanApi?.emptyTrashcan();
+            if (sitesToDelete?.length > 0) {
+                await sitesApi?.deleteSites(sitesToDelete);
+            }
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    static async uploadFileNewVersion(personalFilesPage, fileFromOS) {
+        const fileInput = await personalFilesPage.page.$('#app-upload-file-version');
+        await fileInput.setInputFiles(path.join(__dirname, `../resources/test-files/${fileFromOS}.docx`));
+    }
+    static async reloadPageIfRowNotVisible(pageContext, nodeName, errorMessage = 'reloadPageIfRowNotVisible Error ') {
+        try {
+            if (!(await pageContext.dataTable.getRowByName(nodeName).isVisible())) {
+                await pageContext.page.reload({ waitUntil: 'load' });
+            }
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    static async reloadPageIfDatatableEmpty(pageContext, errorMessage = 'reloadPageIfDatatableEmpty Error ') {
+        try {
+            if ((await pageContext.dataTable.getEmptyFolderLocator.isVisible()) || (await pageContext.dataTable.emptyListTitle.isVisible())) {
+                await pageContext.page.reload({ waitUntil: 'load' });
+            }
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    static getCurrentAndPreviousDay(currentDate = new Date()) {
+        let formattedDate;
+        let formattedDate2;
+        const formatDate = (date) => {
+            return format(date, 'dd-MMM-yy').toUpperCase();
+        };
+        if (currentDate.getDate() === 1) {
+            const lastDayOfPreviousMonth = endOfMonth(subMonths(currentDate, 1));
+            formattedDate = formatDate(lastDayOfPreviousMonth);
+            formattedDate2 = formatDate(subDays(lastDayOfPreviousMonth, 1));
+        }
+        else {
+            formattedDate = formatDate(currentDate);
+            formattedDate2 = formatDate(subDays(currentDate, 1));
+        }
+        return { currentDate: formattedDate, previousDate: formattedDate2 };
+    }
+    static async verifyZipFileContent(filePath, fileOrFolderName) {
+        const zip = new StreamZip({
+            file: filePath,
+            storeEntries: true
+        });
+        return new Promise((resolve) => {
+            zip.on('ready', () => {
+                const entries = zip.entries();
+                const found = this.isFileOrFolderInEntries(entries, fileOrFolderName);
+                zip.close();
+                resolve(found);
+            });
+        });
+    }
+    static isFileOrFolderInEntries(entries, fileOrFolderName) {
+        return fileOrFolderName.some((name) => {
+            return Object.keys(entries).some((entry) => entry.includes(name));
+        });
+    }
+}
+Utils.string257Long = 'x'.repeat(257);
+Utils.string513Long = 'x'.repeat(513);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/utils/utils.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\nconst crypto = require('crypto');\nimport * as path from 'path';\nimport { LoginPage, MyLibrariesPage, PersonalFilesPage, FavoritesLibrariesPage, SearchPage, SharedPage, TrashPage } from '../page-objects';\nimport { format, subDays, subMonths, endOfMonth } from 'date-fns';\nimport StreamZip from 'node-stream-zip';\nimport { NodesApi, SitesApi, TrashcanApi } from '../api';\n\nexport class Utils {\n  static string257Long = 'x'.repeat(257);\n  static string513Long = 'x'.repeat(513);\n\n  static random(): string {\n    return crypto.getRandomValues(new Uint32Array(1))[0].toString(36).substring(0, 5).toLowerCase();\n  }\n\n  static retryCall(fn: () => Promise<any>, retry: number = 30, delay: number = 1500): Promise<any> {\n    const pause = (duration: number) => new Promise((res) => setTimeout(res, duration));\n\n    const run = (retries: number): Promise<any> => {\n      return fn().catch((err) => (retries > 1 ? pause(delay).then(() => run(retries - 1)) : Promise.reject(err)));\n    };\n\n    return run(retry);\n  }\n\n  static formatDate(date: string): string {\n    return new Date(date).toLocaleDateString('en-US');\n  }\n\n  /**\n   * Method used to login user with navigation. Also waits for the page to load after login\n   *\n   * @param loginPage page context passed from the test\n   * @param username username string\n   * @param password password string\n   * @param errorMessage error message string if the login fails\n   *\n   */\n  static async tryLoginUser(loginPage: LoginPage, username: string, password: string, errorMessage = 'Error '): Promise<void> {\n    try {\n      await loginPage.loginUser({ username, password }, { withNavigation: true, waitForLoading: true });\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  /**\n   * Method used to delete nodes and sites from user's account\n   *\n   * @param nodesApi nodesApi initialized with user credentials passed from the test\n   * @param trashcanApi trashcanApi initialized with user credentials passed from the test\n   * @param errorMessage error message string if the deleting sites/nodes fails\n   * @param sitesApi sitesApi initialized with user credentials passed from the test\n   * @param sitesToDelete array of sites' ids\n   *\n   */\n  static async deleteNodesSitesEmptyTrashcan(\n    nodesApi?: NodesApi,\n    trashcanApi?: TrashcanApi,\n    errorMessage = 'Error ',\n    sitesApi?: SitesApi,\n    sitesToDelete?: string[]\n  ): Promise<void> {\n    try {\n      await nodesApi?.deleteCurrentUserNodes();\n      await trashcanApi?.emptyTrashcan();\n      if (sitesToDelete?.length > 0) {\n        await sitesApi?.deleteSites(sitesToDelete);\n      }\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  static async uploadFileNewVersion(personalFilesPage: PersonalFilesPage, fileFromOS: string): Promise<void> {\n    const fileInput = await personalFilesPage.page.$('#app-upload-file-version');\n    await fileInput.setInputFiles(path.join(__dirname, `../resources/test-files/${fileFromOS}.docx`));\n  }\n\n  static async reloadPageIfRowNotVisible(\n    pageContext: PersonalFilesPage | MyLibrariesPage | FavoritesLibrariesPage | SearchPage | SharedPage,\n    nodeName: string,\n    errorMessage = 'reloadPageIfRowNotVisible Error '\n  ): Promise<void> {\n    try {\n      if (!(await pageContext.dataTable.getRowByName(nodeName).isVisible())) {\n        await pageContext.page.reload({ waitUntil: 'load' });\n      }\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  static async reloadPageIfDatatableEmpty(\n    pageContext: PersonalFilesPage | MyLibrariesPage | FavoritesLibrariesPage | SearchPage | SharedPage | TrashPage,\n    errorMessage = 'reloadPageIfDatatableEmpty Error '\n  ): Promise<void> {\n    try {\n      if ((await pageContext.dataTable.getEmptyFolderLocator.isVisible()) || (await pageContext.dataTable.emptyListTitle.isVisible())) {\n        await pageContext.page.reload({ waitUntil: 'load' });\n      }\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  static getCurrentAndPreviousDay(currentDate = new Date()): { currentDate: string; previousDate: string } {\n    let formattedDate: string;\n    let formattedDate2: string;\n\n    const formatDate = (date: Date): string => {\n      return format(date, 'dd-MMM-yy').toUpperCase();\n    };\n\n    if (currentDate.getDate() === 1) {\n      const lastDayOfPreviousMonth: Date = endOfMonth(subMonths(currentDate, 1));\n      formattedDate = formatDate(lastDayOfPreviousMonth);\n      formattedDate2 = formatDate(subDays(lastDayOfPreviousMonth, 1));\n    } else {\n      formattedDate = formatDate(currentDate);\n      formattedDate2 = formatDate(subDays(currentDate, 1));\n    }\n\n    return { currentDate: formattedDate, previousDate: formattedDate2 };\n  }\n\n  static async verifyZipFileContent(filePath: string, fileOrFolderName: string[]): Promise<boolean> {\n    const zip = new StreamZip({\n      file: filePath,\n      storeEntries: true\n    });\n\n    return new Promise<boolean>((resolve) => {\n      zip.on('ready', () => {\n        const entries = zip.entries();\n        const found = this.isFileOrFolderInEntries(entries, fileOrFolderName);\n        zip.close();\n        resolve(found);\n      });\n    });\n  }\n\n  private static isFileOrFolderInEntries(entries: { [name: string]: StreamZip.ZipEntry }, fileOrFolderName: string[]): boolean {\n    return fileOrFolderName.some((name) => {\n      return Object.keys(entries).some((entry) => entry.includes(name));\n    });\n  }\n}\n"]}