@jahia/cypress 6.0.0 → 6.2.0

package/dist/support/index.d.ts

@@ -4,3 +4,4 @@ export * from './login';
 export * from './logout';
 export * from './repeatUntil';
 export * from './testStep';
+export * from './jsErrorsLogger';

package/dist/support/index.js

@@ -16,3 +16,4 @@ __exportStar(require("./login"), exports);
 __exportStar(require("./logout"), exports);
 __exportStar(require("./repeatUntil"), exports);
 __exportStar(require("./testStep"), exports);
+__exportStar(require("./jsErrorsLogger"), exports);

package/dist/support/jsErrorsLogger.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Module for monitoring and reporting JavaScript errors and warnings in Cypress tests.
+ * Provides methods to enable, disable, and check logger status.
+ */
+/**
+ * Strategy for handling JavaScript errors and warnings in Cypress tests.
+ * - failFast: Fail *immediately* when an error is detected.
+ * - failAfterEach: Collect all errors and warnings *during test* execution and fail if any issues are found.
+ * - failAfterAll: Collect all errors and warnings *after all tests* and fail at the end of the test suite.
+ */
+declare enum STRATEGY {
+    failFast = 0,
+    failAfterAll = 1,
+    failAfterEach = 2
+}
+/**
+ * Sets the strategy for handling JavaScript errors and warnings in Cypress tests.
+ * @param {STRATEGY} strategy - Strategy for handling JavaScript errors and warnings.
+ * @throws {Error} If an invalid strategy is provided.
+ * @returns {void}
+ */
+declare function setStrategy(strategy: STRATEGY): void;
+/**
+ * Sets the list of allowed warnings that will not be reported by the logger.
+ * @param warnings {string[]} - Array of warning messages to be allowed.
+ * @return {void}
+ */
+declare function setAllowedJsWarnings(warnings: string[]): void;
+/**
+ * Attaches custom hooks to Cypress events to monitor and report JavaScript errors and warnings.
+ * This method is called automatically in registerSupport.ts#registerSupport
+ * It sets up listeners for console errors and warnings, collects them after each test,
+ * and throws an error if any issues are found after all tests are executed.
+ */
+declare function attachHooks(): void;
+/**
+ * Exports the jsLogger module with methods to attach hooks, enable/disable logging, and set allowed warnings.
+ */
+export declare const jsErrorsLogger: {
+    attachHooks: typeof attachHooks;
+    setAllowedJsWarnings: typeof setAllowedJsWarnings;
+    setStrategy: typeof setStrategy;
+    STRATEGY: typeof STRATEGY;
+};
+export {};

package/dist/support/jsErrorsLogger.js

@@ -0,0 +1,280 @@
+"use strict";
+/* eslint-disable brace-style */
+/* eslint-disable max-statements-per-line */
+/**
+ * Module for monitoring and reporting JavaScript errors and warnings in Cypress tests.
+ * Provides methods to enable, disable, and check logger status.
+ */
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+exports.__esModule = true;
+exports.jsErrorsLogger = void 0;
+var envVarDisabled = 'JS_LOGGER_DISABLED';
+var envVarCollector = '__JS_LOGGER_FAILURES__';
+var envVarAllowedWarnings = '__JS_LOGGER_ALLOWED_WARNINGS__';
+var envVarStrategy = '__JS_LOGGER_STRATEGY__';
+/**
+ * Strategy for handling JavaScript errors and warnings in Cypress tests.
+ * - failFast: Fail *immediately* when an error is detected.
+ * - failAfterEach: Collect all errors and warnings *during test* execution and fail if any issues are found.
+ * - failAfterAll: Collect all errors and warnings *after all tests* and fail at the end of the test suite.
+ */
+var STRATEGY;
+(function (STRATEGY) {
+    STRATEGY[STRATEGY["failFast"] = 0] = "failFast";
+    STRATEGY[STRATEGY["failAfterAll"] = 1] = "failAfterAll";
+    STRATEGY[STRATEGY["failAfterEach"] = 2] = "failAfterEach";
+})(STRATEGY || (STRATEGY = {}));
+/**
+ * Returns the current strategy for handling JavaScript errors and warnings in Cypress tests.
+ * @returns {STRATEGY} - The current strategy for handling JavaScript errors and warnings.
+ * @note be careful with Cypress.env(envVarStrategy), since it might return `0` for `failFast` strategy,
+ *       which is falsy in JavaScript, so we need to check if the variable is undefined.
+ */
+function getStrategy() {
+    return typeof Cypress.env(envVarStrategy) === 'undefined' ? STRATEGY.failFast : Cypress.env(envVarStrategy);
+}
+/**
+ * Sets the strategy for handling JavaScript errors and warnings in Cypress tests.
+ * @param {STRATEGY} strategy - Strategy for handling JavaScript errors and warnings.
+ * @throws {Error} If an invalid strategy is provided.
+ * @returns {void}
+ */
+function setStrategy(strategy) { Cypress.env(envVarStrategy, strategy); }
+/**
+ * Checks if the js errors and warnings logger is disabled.
+ * @returns {boolean} - true if the logger is disabled, false otherwise.
+ */
+function isDisabled() { return Cypress.env(envVarDisabled) === true; }
+/**
+ * Sets the list of allowed warnings that will not be reported by the logger.
+ * @param warnings {string[]} - Array of warning messages to be allowed.
+ * @return {void}
+ */
+function setAllowedJsWarnings(warnings) { Cypress.env(envVarAllowedWarnings, warnings); }
+/**
+ * Attaches custom hooks to Cypress events to monitor and report JavaScript errors and warnings.
+ * This method is called automatically in registerSupport.ts#registerSupport
+ * It sets up listeners for console errors and warnings, collects them after each test,
+ * and throws an error if any issues are found after all tests are executed.
+ */
+function attachHooks() {
+    // Skip hook attachment if the logger is disabled (e.g. from CI/CD pipeline)
+    if (isDisabled()) {
+        return;
+    }
+    switch (getStrategy()) {
+        case STRATEGY.failAfterAll:
+            attachFailAfterAll();
+            break;
+        case STRATEGY.failAfterEach:
+            attachFailAfterEach();
+            break;
+        default:
+            attachFailFast();
+    }
+}
+/**
+ * Custom hook implementation which fails the test after all tests are executed if any JavaScript errors or warnings are found.
+ *
+ * Proc: Allows all tests to run, collects console errors and warnings, and fails the test suite at the end if any issues are found.
+ *       This is useful for reporting all issues at once after all tests are executed, rather than failing immediately on the first issue.
+ * Cons: Reporting might be confusing, e.g. - cypress will report the very last test as failed, while many tests might have issues.
+ *       This is because the hook is executed after all tests are completed, so the last test is reported as failed.
+ */
+function attachFailAfterAll() {
+    /**
+     * Custom 'window:before:load' hook to spy on console errors and warnings
+     * This hook is executed before the page is loaded, allowing us to capture console messages.
+     */
+    Cypress.on('window:before:load', function (window) {
+        // Skip 'window:before:load' hook if the logger is not enabled
+        // Double-check in case if functionality was disabled within the test-case code
+        // to skip js validations for some particular test and enable it afterward
+        if (isDisabled()) {
+            return;
+        }
+        cy.spy(window.console, 'error').as('errors');
+        cy.spy(window.console, 'warn').as('warnings');
+    });
+    /**
+     * Custom 'afterEach' hook to collect console errors and warnings
+     */
+    afterEach(function () {
+        // Skip 'afterEach' hook if the logger is not enabled
+        // Double-check in case if functionality was disabled within the test-case code
+        // to skip js validations for some particular test and enable it afterward
+        if (isDisabled()) {
+            return;
+        }
+        var consoleIssues = [];
+        var allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
+        // All errors should be collected
+        cy.get('@errors')
+            .invoke('getCalls')
+            .then(function (calls) { consoleIssues = calls; });
+        // Only warnings not in the allowed list should be collected
+        cy.get('@warnings')
+            .invoke('getCalls')
+            .each(function (call) {
+            call.args.forEach(function (arg) {
+                if (!allowedWarnings.some(function (item) { return arg.includes(item); })) {
+                    consoleIssues.push(arg);
+                }
+            });
+        });
+        // Collect all issues and store them in the Cypress environment variable for later usage
+        cy.then(function () {
+            if (consoleIssues.length > 0) {
+                Cypress.env(envVarCollector, __spreadArray(__spreadArray([], (Cypress.env(envVarCollector) || [])), [{
+                        test: Cypress.currentTest.title,
+                        errors: consoleIssues
+                    }]));
+            }
+        });
+    });
+    /**
+     * Custom 'after' hook to analyze collected errors and warnings after all tests are executed.
+     */
+    after(function () {
+        // Skip 'after' hook if the logger is not enabled
+        // Double-check in case if functionality was disabled within the test-case code
+        // to skip js validations for some particular test and enable it afterward
+        if (isDisabled()) {
+            return;
+        }
+        // Analyze collected errors and warnings
+        var failures = Cypress.env(envVarCollector) || [];
+        cy.log('[JS ERRORS LOGGER] Analyze collected issues').then(function () {
+            if (failures.length > 0) {
+                // Format the error message for each test
+                var errorMessage = failures.map(function (failure) {
+                    return "TEST: " + failure.test + "\nISSUES:\n" + failure.errors.map(function (e) { return "- " + e; }).join('\n');
+                }).join('\n\n');
+                // Throw an error with the collected issues
+                throw new Error('CONSOLE ERRORS and WARNINGS FOUND:\n\n' + errorMessage);
+            }
+            else {
+                cy.log('[JS ERRORS LOGGER] No console errors or warnings found.');
+            }
+        });
+    });
+}
+/**
+ * Custom hook implementation which fails the test after each test execution if any JavaScript errors or warnings are found.
+ *
+ * Proc: Allows each test to run, collects console errors and warnings, and fails the particular test by the end of it's execution
+ *       if any issues are found.
+ * Cons: If errors or warnings were found during beforeEach or afterEach hook(s), the rest of spec will be ignored.
+ */
+function attachFailAfterEach() {
+    // Double-check in case if functionality was disabled within the test-case code
+    // to skip js validations for some particular test and enable it afterward
+    if (isDisabled()) {
+        return;
+    }
+    /**
+     * Custom 'window:before:load' hook to spy on console errors and warnings
+     * This hook is executed before the page is loaded, allowing us to capture console messages.
+     */
+    Cypress.on('window:before:load', function (window) {
+        cy.spy(window.console, 'error').as('errors');
+        cy.spy(window.console, 'warn').as('warnings');
+    });
+    /**
+     * Custom 'afterEach' hook to collect console errors and warnings
+     */
+    afterEach(function () {
+        var consoleIssues = [];
+        var allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
+        // All errors should be collected
+        cy.get('@errors')
+            .invoke('getCalls')
+            .then(function (calls) { consoleIssues = calls; });
+        // Only warnings not in the allowed list should be collected
+        cy.get('@warnings')
+            .invoke('getCalls')
+            .each(function (call) {
+            call.args.forEach(function (arg) {
+                if (!allowedWarnings.some(function (item) { return arg.includes(item); })) {
+                    consoleIssues.push(arg);
+                }
+            });
+        });
+        // Analyze collected errors and warnings
+        cy.log('[JS ERRORS LOGGER] Analyze collected issues').then(function () {
+            if (consoleIssues.length > 0) {
+                // Format the error message for each test
+                var errorMessage = consoleIssues.map(function (e) { return "- " + e; }).join('\n');
+                // Throw an error with the collected issues
+                throw new Error('CONSOLE ERRORS and WARNINGS FOUND:\n\n' + errorMessage);
+            }
+            else {
+                cy.log('[JS ERRORS LOGGER] No console errors or warnings found.');
+            }
+        });
+    });
+}
+/**
+ * Custom hook implementation which fails the test immediately when a JavaScript error or warning is detected.
+ *
+ * Proc: Allows each test to run, looks for console errors and warnings, and fails the particular test IMMEDIATELLY
+ *       if any issues are found.
+ * Cons: If errors or warnings were found during beforeEach or afterEach hook(s), the rest of spec will be ignored.
+ */
+function attachFailFast() {
+    // Double-check in case if functionality was disabled within the test-case code
+    // to skip js validations for some particular test and enable it afterward
+    if (isDisabled()) {
+        return;
+    }
+    /**
+     * Custom 'window:before:load' hook to spy on console errors and warnings
+     * This hook is executed before the page is loaded, allowing us to capture console messages.
+     */
+    Cypress.on('window:before:load', function (window) {
+        cy.spy(window.console, 'error').as('errors');
+        cy.spy(window.console, 'warn').as('warnings');
+    });
+    Cypress.on('window:load', function () {
+        // DOM should be loaded and parsed by now, so we can check for console errors and warnings
+        var consoleIssues = [];
+        var allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
+        // All errors should be collected
+        cy.get('@errors')
+            .invoke('getCalls')
+            .then(function (calls) { consoleIssues = calls; });
+        // Only warnings not in the allowed list should be collected
+        cy.get('@warnings')
+            .invoke('getCalls')
+            .each(function (call) {
+            call.args.forEach(function (arg) {
+                if (!allowedWarnings.some(function (item) { return arg.includes(item); })) {
+                    consoleIssues.push(arg);
+                }
+            });
+        }).then(function () {
+            if (consoleIssues.length > 0) {
+                // Format the error message for each test
+                var errorMessage = consoleIssues.map(function (e) { return "- " + e; }).join('\n');
+                // Throw an error with the collected issues
+                throw new Error('CONSOLE ERRORS and WARNINGS FOUND:\n' + errorMessage);
+            }
+            else {
+                cy.log('[JS ERRORS LOGGER] No console errors or warnings found.');
+            }
+        });
+    });
+}
+/**
+ * Exports the jsLogger module with methods to attach hooks, enable/disable logging, and set allowed warnings.
+ */
+exports.jsErrorsLogger = {
+    attachHooks: attachHooks,
+    setAllowedJsWarnings: setAllowedJsWarnings,
+    setStrategy: setStrategy,
+    STRATEGY: STRATEGY
+};

package/dist/support/provisioning/executeGroovy.js

@@ -18,7 +18,8 @@ var executeGroovy = function (scriptFile, replacements, jahiaServer) {
         files: [{
                 fileName: scriptFile,
                 replacements: replacements,
-                type: 'text/plain'
+                type: 'text/plain',
+                encoding: 'utf-8'
             }],
         jahiaServer: jahiaServer
     }).then(function (r) { return r[0]; });

package/dist/support/provisioning/runProvisioningScript.js

@@ -20,6 +20,14 @@ function processContent(formFile) {
         });
     }
     formFile.fileContent = content;
+    // If the file has an encoding, create a Blob with the new Blob constructor. It handle correctly the encoding
+    // for the groovy scripts
+    // Did not change for all files because jar files can be added as well, which are binary files
+    // In that case the function binaryStringToBlob will be used
+    if (formFile.encoding) {
+        return new Blob([content], { type: formFile.type });
+    }
+    // Default to binary string to blob conversion
     return Cypress.Blob.binaryStringToBlob(content, formFile.type);
 }
 function append(formFile, formData, key) {

package/dist/support/registerSupport.js

@@ -8,6 +8,8 @@ var logout_1 = require("./logout");
 var fixture_1 = require("./fixture");
 var repeatUntil_1 = require("./repeatUntil");
 var testStep_1 = require("./testStep");
+// FUNCTIONALITY IS TEMPORARY DISABLED DUE TO UNEXPECTED ISSUES
+// import {jsErrorsLogger} from './jsErrorsLogger';
 var registerSupport = function () {
     Cypress.Commands.add('apolloClient', apollo_1.apolloClient);
     Cypress.Commands.add('apollo', { prevSubject: 'optional' }, apollo_1.apollo);
@@ -22,5 +24,11 @@ var registerSupport = function () {
     Cypress.Commands.add('repeatUntil', repeatUntil_1.repeatUntil);
     Cypress.Commands.overwrite('fixture', fixture_1.fixture);
     Cypress.Commands.add('step', testStep_1.step);
+    // Since registerSupport() function is called in each repo from e2e.js,
+    // attaching the JavaScript errors logger hooks here ensures that logger is initialized automatically
+    // for all tests without needing to call it explicitly in each test file.
+    // This is useful for capturing and logging JavaScript errors across all tests.
+    // FUNCTIONALITY IS TEMPORARY DISABLED DUE TO UNEXPECTED ISSUES
+    // jsErrorsLogger.attachHooks();
 };
 exports.registerSupport = registerSupport;

package/dist/utils/Logger.d.ts

@@ -1,46 +1,54 @@
 /**
- * Helper class to decorate Cypress log messages with different log levels (INFO and DEBUG at the moment).
- * Class contains only static methods and should not be instantiated.
+ * Helper module to decorate Cypress log messages with different log levels (INFO and DEBUG at the moment).
  * @example
+ *      // Switch default logging verbosity to DEBUG
+ *      Log.setVerbosity(Log.LEVELS.DEBUG);
+ *
  *      Log.info('This is an info message');
  *      Log.debug('This is a debug message');
- *      Log.json('DEBUG', myJSON);
+ *      Log.json(Log.LEVELS.DEBUG, myJSON);
  *      Log.info('My info message').then(() => { ... });
- * @note The log level can be set by changing the `Log.LEVEL` variable in the code (default is `INFO`).
+ *
+ * @note The log verbosity can be set by calling `Log.setVerbosity(Log.LEVELS.DEBUG)` in the code (default is `INFO`).
  *       It tells the logger to log only messages with the given level and above.
  */
-export declare class Log {
-    static LEVEL: string;
-    private static levels;
-    /**
-     * Logs INFO message
-     * @param {string} message - log message
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     */
-    static info(message: string): Cypress.Chainable;
-    /**
-     * Logs DEBUG message
-     * @param {string} message - log message
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     */
-    static debug(message: string): Cypress.Chainable;
-    /**
-     * Logs JSON object with logging level given
-     * @param {string} level - log level (e.g. 'INFO', 'DEBUG')
-     * @param {string} json - json object to be logged
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     */
-    static json(level: string, json: string): Cypress.Chainable;
-    /**
-     * Private method to send the log message to Cypress log
-     * @param {string} level - log level (e.g. 'INFO', 'DEBUG')
-     * @param {string} message - log message
-     * @note The method checks if the log level is enabled before sending the message to Cypress log
-     *       and uses the Cypress.log method to display the message in the Cypress log
-     * @note The method is private and should not be called directly
-     *       Use the public methods (info, debug, error, warning) to send log messages
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     * @private
-     */
-    private static _send_;
+/**
+ * Logging levels enumerator.
+ */
+declare enum LEVEL {
+    DEBUG = 0,
+    INFO = 1
 }
+/**
+ * Sets the logging verbosity level for the logger. Messages with a level lower than the set level will not be logged.
+ * @param {LEVEL} level - log level to be set (e.g. 'DEBUG', 'INFO')
+ * @return {void}
+ */
+declare function setVerbosity(level: LEVEL): void;
+/**
+ * Logs INFO message
+ * @param {string} message - log message
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ */
+declare function info(message: string): Cypress.Chainable;
+/**
+ * Logs DEBUG message
+ * @param {string} message - log message
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ */
+declare function debug(message: string): Cypress.Chainable;
+/**
+ * Logs JSON object with logging level given
+ * @param {LEVEL} level - log level (e.g. 'INFO', 'DEBUG')
+ * @param {string} text - json object to be logged
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ */
+declare function json(level: LEVEL, text: string): Cypress.Chainable;
+export declare const Log: {
+    info: typeof info;
+    debug: typeof debug;
+    json: typeof json;
+    setVerbosity: typeof setVerbosity;
+    LEVEL: typeof LEVEL;
+};
+export {};

package/dist/utils/Logger.js

@@ -1,79 +1,105 @@
 "use strict";
-exports.__esModule = true;
-exports.Log = void 0;
 /**
- * Helper class to decorate Cypress log messages with different log levels (INFO and DEBUG at the moment).
- * Class contains only static methods and should not be instantiated.
+ * Helper module to decorate Cypress log messages with different log levels (INFO and DEBUG at the moment).
  * @example
+ *      // Switch default logging verbosity to DEBUG
+ *      Log.setVerbosity(Log.LEVELS.DEBUG);
+ *
  *      Log.info('This is an info message');
  *      Log.debug('This is a debug message');
- *      Log.json('DEBUG', myJSON);
+ *      Log.json(Log.LEVELS.DEBUG, myJSON);
  *      Log.info('My info message').then(() => { ... });
- * @note The log level can be set by changing the `Log.LEVEL` variable in the code (default is `INFO`).
+ *
+ * @note The log verbosity can be set by calling `Log.setVerbosity(Log.LEVELS.DEBUG)` in the code (default is `INFO`).
  *       It tells the logger to log only messages with the given level and above.
  */
-var Log = /** @class */ (function () {
-    function Log() {
+exports.__esModule = true;
+exports.Log = void 0;
+// ENV variable to store the logging verbosity level
+var envVarLoggingVerbosity = '__LOG_VERBOSITY__';
+/**
+ * Logging levels enumerator.
+ */
+var LEVEL;
+(function (LEVEL) {
+    LEVEL[LEVEL["DEBUG"] = 0] = "DEBUG";
+    LEVEL[LEVEL["INFO"] = 1] = "INFO";
+})(LEVEL || (LEVEL = {}));
+/**
+ * Return the current logging verbosity level.
+ * @returns {LEVEL} - current logging level set in Cypress environment variable `__LOG_VERBOSITY__`
+ * @note be careful with Cypress.env(envVarLoggingVerbosity), since it might return `0` for `DEBUG` level,
+ *       which is falsy in JavaScript, so we need to check if the variable is undefined.
+ */
+function getVerbosity() {
+    return typeof Cypress.env(envVarLoggingVerbosity) === 'undefined' ? LEVEL.INFO : Cypress.env(envVarLoggingVerbosity);
+}
+/**
+ * Sets the logging verbosity level for the logger. Messages with a level lower than the set level will not be logged.
+ * @param {LEVEL} level - log level to be set (e.g. 'DEBUG', 'INFO')
+ * @return {void}
+ */
+function setVerbosity(level) {
+    Cypress.env(envVarLoggingVerbosity, level);
+}
+/**
+ * Logs INFO message
+ * @param {string} message - log message
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ */
+function info(message) {
+    return _send_(exports.Log.LEVEL.INFO, message);
+}
+/**
+ * Logs DEBUG message
+ * @param {string} message - log message
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ */
+function debug(message) {
+    return _send_(exports.Log.LEVEL.DEBUG, message);
+}
+/**
+ * Logs JSON object with logging level given
+ * @param {LEVEL} level - log level (e.g. 'INFO', 'DEBUG')
+ * @param {string} text - json object to be logged
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ */
+function json(level, text) {
+    return _send_(level, JSON.stringify(text, null, 2));
+}
+/**
+ * Private method to send the log message to Cypress log
+ * @param {LEVEL} level - log level (e.g. 'INFO', 'DEBUG')
+ * @param {string} message - log message
+ * @note The method checks if the log level is enabled before sending the message to Cypress log
+ *       and uses the Cypress.log method to display the message in the Cypress log
+ * @note The method is private and should not be called directly
+ *       Use the public methods (info, debug, error, warning) to send log messages
+ * @returns {Cypress.Chainable} - Cypress chainable object
+ * @private
+ */
+function _send_(level, message) {
+    // Check if the log level is valid
+    if (!Object.values(exports.Log.LEVEL).includes(level)) {
+        throw new Error("Log level \"" + level + "\" is not supported. Supported levels are: " + exports.Log.LEVEL);
+    }
+    // Check if the log level is enabled,
+    // take into account the log level set in Cypress.env('LOG_LEVEL') and the log level set in the Log.LEVEL variable.
+    // If the log level is enabled, send the message to Cypress log.
+    if (level >= getVerbosity()) {
+        // Send the message to Cypress log
+        // use cy.then() to ensure that the log message is sent in the correct order
+        // and use cy.wrap() to return the Cypress chainable object
+        return cy.then(function () {
+            Cypress.log({ displayName: "[ " + exports.Log.LEVEL[level].toUpperCase() + " ]", message: "" + message });
+        }).then(cy.wrap);
     }
-    /**
-     * Logs INFO message
-     * @param {string} message - log message
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     */
-    Log.info = function (message) {
-        return Log._send_('INFO', message);
-    };
-    /**
-     * Logs DEBUG message
-     * @param {string} message - log message
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     */
-    Log.debug = function (message) {
-        return Log._send_('DEBUG', message);
-    };
-    /**
-     * Logs JSON object with logging level given
-     * @param {string} level - log level (e.g. 'INFO', 'DEBUG')
-     * @param {string} json - json object to be logged
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     */
-    Log.json = function (level, json) {
-        return Log._send_(level, JSON.stringify(json, null, 2));
-    };
-    /**
-     * Private method to send the log message to Cypress log
-     * @param {string} level - log level (e.g. 'INFO', 'DEBUG')
-     * @param {string} message - log message
-     * @note The method checks if the log level is enabled before sending the message to Cypress log
-     *       and uses the Cypress.log method to display the message in the Cypress log
-     * @note The method is private and should not be called directly
-     *       Use the public methods (info, debug, error, warning) to send log messages
-     * @returns {Cypress.Chainable} - Cypress chainable object
-     * @private
-     */
-    Log._send_ = function (level, message) {
-        var _a, _b;
-        // Check if the log level is valid
-        if (!Log.levels.includes(level.toUpperCase())) {
-            throw new Error("Log level \"" + level + "\" is not supported. Supported levels are: " + Log.levels.join(', '));
-        }
-        // Check if the log level is enabled,
-        // take into account the log level set in Cypress.env('LOG_LEVEL') and the log level set in the Log.LEVEL variable.
-        // If the log level is enabled, send the message to Cypress log.
-        if ((Log.levels.includes((_a = Cypress.env('LOG_LEVEL')) === null || _a === void 0 ? void 0 : _a.toUpperCase()) && Log.levels.indexOf(level.toUpperCase()) >= Log.levels.indexOf((_b = Cypress.env('LOG_LEVEL')) === null || _b === void 0 ? void 0 : _b.toUpperCase())) ||
-            Log.levels.indexOf(level.toUpperCase()) >= Log.levels.indexOf(Log.LEVEL)) {
-            // Send the message to Cypress log
-            // use cy.then() to ensure that the log message is sent in the correct order
-            // and use cy.wrap() to return the Cypress chainable object
-            return cy.then(function () {
-                Cypress.log({ displayName: "[ " + level.toUpperCase() + " ]", message: "" + message });
-            }).then(cy.wrap);
-        }
-    };
-    // The default log level is set to 'INFO' and can be changed by setting the Log.LEVEL variable in the code
-    Log.LEVEL = 'INFO';
-    // The log levels are defined in the levels array and are ordered from the lowest to the highest priority
-    Log.levels = ['DEBUG', 'INFO'];
-    return Log;
-}());
-exports.Log = Log;
+}
+// Export the Log module with methods to log messages and set the logging level
+exports.Log = {
+    info: info,
+    debug: debug,
+    json: json,
+    setVerbosity: setVerbosity,
+    LEVEL: LEVEL
+};