@jahia/cypress 6.3.1 → 6.4.1

package/docs/js-errors-logger.md

@@ -15,77 +15,51 @@ The JavaScript Errors Logger is a comprehensive monitoring and reporting module
 
 The logger supports three distinct strategies for handling JavaScript errors and warnings:
 
-### 1. Fail Fast (Default)
-- **Strategy**: `STRATEGY.failFast`
-- **Behavior**: Fails immediately when an error or warning is detected
-- **Use Case**: Best for development environments where immediate feedback is crucial
-- **Pros**: Quick identification of issues
-- **Cons**: May stop test execution on first error, preventing discovery of additional issues
-
-### 2. Fail After Each Test
+### 1. Fail After Each Test
 - **Strategy**: `STRATEGY.failAfterEach`
-- **Behavior**: Collects errors/warnings during test execution and fails at the end of each test
-- **Use Case**: Suitable when you want each test to complete but still get immediate feedback
-- **Pros**: Allows full test execution while providing per-test feedback
-- **Cons**: If errors occur in hooks (beforeEach/afterEach), remaining spec tests will be skipped
+- **Behavior**: Collects errors/warnings during test execution and fails at the end of the one; the rest of tests will be skipped
+- **Use Case**: Suitable when you want the test to complete but still get immediate feedback
+- **Pros**: Allows test to be executed till the end before providing a report
+- **Cons**: Since the analysis happens in afterEach() hook, the rest of spec will be ignored
 
-### 3. Fail After All Tests
+### 2. Fail After All Tests (default)
 - **Strategy**: `STRATEGY.failAfterAll`
-- **Behavior**: Collects all errors/warnings and reports them after the entire test suite completes
+- **Behavior**: Collects all errors/warnings and reports them after the entire test suite completes; the last test will be marked as failed
 - **Use Case**: Ideal for CI/CD environments where you want a complete test run overview
 - **Pros**: Complete test suite execution with comprehensive error reporting
 - **Cons**: Error reporting may be confusing as the last test will be marked as failed, since the errors analysis and reporting is done in after() hook
 
-## Configuration
-
-### Environment Variables
-
-| Variable | Type | Description |
-|----------|------|-------------|
-| `JS_LOGGER_DISABLED` | boolean | Disables the logger when set to `true` |
+## Usage
 
-### Programmatic Configuration
+### Basic Setup
 
-It is **strongly** recommended to add custom configuration in project's common files, e.g. `tests/cypress/support/e2e.js` to have it applied to all test-cases within the project.
+#### Enable the Logger for the repo
+This call should only be used in `tests/cypress/support/e2e.js`. Add the following code in the repo where functionality should be used:
 
 ```typescript
-import { jsErrorsLogger } from '@jahia/cypress';
-
-// Set preferrable error handling strategy
-jsErrorsLogger.setStrategy(jsErrorsLogger.STRATEGY.failAfterEach);
+import {jsErrorsLogger} from '@jahia/cypress';
 
-// Define allowed warnings that won't trigger failures
-jsErrorsLogger.setAllowedJsWarnings([
-  'Warning: React Hook',
-  'Warning: componentWillReceiveProps'
-]);
+// Enable and attach JS Errors Logger
+jsErrorsLogger.enable();
 ```
 
-## Usage
-
-### Basic Setup
-
-The logger is automatically initialized when jahia-cypress is imported and registered in the Cypress support files. No manual setup is required for basic functionality.
-
 ### Disabling the Logger
 
 #### Via Environment Variable
 
 ```bash
 # Disable in CI/CD or specific environments
-export JS_LOGGER_DISABLED=true
+export JAHIA_HOOKS_DISABLE_JS_LOGGER="true"
 ```
 
-#### Temporarily in Tests
+#### Disable for the specific Spec
 
 ```typescript
+import {jsErrorsLogger} from '@jahia/cypress';
+
 describe('Tests with disabled JS logger', () => {
   before(() => {
-    Cypress.env('JS_LOGGER_DISABLED', true);
-  });
-  
-  after(() => {
-    Cypress.env('JS_LOGGER_DISABLED', false);
+      jsErrorsLogger.disable();
   });
   
   it('should run without JS error monitoring', () => {
@@ -94,35 +68,76 @@ describe('Tests with disabled JS logger', () => {
 });
 ```
 
+## Configuration
+
+### Environment Variables
+
+| Variable                        | Type | Description |
+|---------------------------------|------|-------------|
+| `JAHIA_HOOKS_DISABLE_JS_LOGGER` | boolean | Disables the logger when set to `true` |
+
+### Programmatic Configuration
+
+It is **strongly** recommended to add custom configuration in project's common files, e.g. `tests/cypress/support/e2e.js` to have it applied to all test-cases within the project.
+
+```typescript
+import {jsErrorsLogger} from '@jahia/cypress';
+
+// Enable and attach JS Errors Logger
+jsErrorsLogger.enable();
+
+// Set preferrable error handling strategy
+jsErrorsLogger.setStrategy(jsErrorsLogger.STRATEGY.failAfterAll);
+
+// Define allowed warnings that won't trigger failures
+jsErrorsLogger.setAllowedJsWarnings([
+  'Warning: React Hook',
+  'Warning: componentWillReceiveProps'
+]);
+```
+
 ## Error Reporting Format
 
-### Single Test Error (failFast/failAfterEach)
+### Single Test Error (failAfterEach)
 
 ```
-Error: CONSOLE ERRORS and WARNINGS FOUND:
-- TypeError: Cannot read property 'foo' of undefined
-- Warning: React Hook useEffect has missing dependency
+CONSOLE ERRORS and WARNINGS FOUND:
+
+❌️ TEST: Should be authenticated when correct credentials and code are provided: ❌️
+--------------------------------------------------
+URL: http://localhost:8080/jahia/dashboard
+ISSUES:
+- ⚠️ Unsatisfied version 5.0.1 from @jahia/jcontent of shared singleton module redux (required ^4.0.5)
+- ⚠️ Unsatisfied version 9.2.0 from @jahia/jcontent of shared singleton module react-redux (required ^8.0.5)
+- ❌️ TypeError: Cannot read property 'user' of undefined
 ```
 
 ### Multiple Test Errors (failAfterAll)
 
 ```
-Error: CONSOLE ERRORS and WARNINGS FOUND:
+CONSOLE ERRORS and WARNINGS FOUND:
 
-TEST: should load homepage
+❌️ TEST: Should be authenticated when correct credentials and code are provided: ❌️
+--------------------------------------------------
+URL: http://localhost:8080/jahia/dashboard
 ISSUES:
-- TypeError: Cannot read property 'user' of undefined
-- Warning: componentWillMount is deprecated
-
-TEST: should handle form submission
+- ⚠️ No satisfying version (^1.11.9) of shared module dayjs found in shared scope default.
+- ⚠️ No satisfying version (^3.0.6) of shared module @jahia/react-material found in shared scope default.
+- ❌️ TypeError: Cannot read property 'user' of undefined
+==================================================
+
+❌️ TEST: Should be authenticated on a specific site when correct credentials and code are provided: ❌️
+--------------------------------------------------
+URL: http://localhost:8080/jahia/admin
 ISSUES:
-- ReferenceError: handleSubmit is not defined
+- ⚠️ No satisfying version (^3.0.6) of shared module @jahia/react-material found in shared scope default.
+==================================================
 ```
 
 ## Best Practices
 
 ### Development Environment
-- Use `STRATEGY.failFast` for immediate feedback during development
+- Use `STRATEGY.failAfterEach` for immediate feedback during development
 - Configure comprehensive allowed warnings list for known, acceptable warnings
 - Enable detailed logging for debugging purposes
 
@@ -140,13 +155,15 @@ ISSUES:
 
 ### Methods
 
-| Method | Parameters | Return Type | Description |
-|--------|------------|-------------|-------------|
+| Method | Parameters | Return Type | Description                                            |
+|--------|------------|-------------|--------------------------------------------------------|
 | `setStrategy(strategy)` | STRATEGY enum | void | Sets the error handling strategy |
-| `setAllowedJsWarnings(warnings)` | string[] | void | Configures allowed warning messages |
+| `setAllowedJsWarnings(warnings)` | string[] | void | Configures allowed warning messages  |
+| `disable()` | - | void | Disables the logger for the current spec |
+| `enable()` | - | void | Enables the logger for the current repo |
 
 ### Enums
 
 | Enum | Values | Description |
 |------|--------|-------------|
-| `STRATEGY` | `failFast`, `failAfterAll`, `failAfterEach` | Error handling strategies |
+| `STRATEGY` | `failAfterAll`, `failAfterEach` | Error handling strategies |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jahia/cypress",
-  "version": "6.3.1",
+  "version": "6.4.1",
   "scripts": {
     "build": "tsc",
     "lint": "eslint src -c .eslintrc.json --ext .ts --max-warnings=0"

package/src/support/jsErrorsLogger.ts

@@ -5,27 +5,63 @@
  * Provides methods to enable, disable, and check logger status.
  */
 
-const envVarDisabled = 'JS_LOGGER_DISABLED';
+const envVarDisableAll = 'JAHIA_HOOKS_DISABLE';
+const envVarDisableJsLogger = 'JAHIA_HOOKS_DISABLE_JS_LOGGER';
 const envVarCollector = '__JS_LOGGER_FAILURES__';
 const envVarAllowedWarnings = '__JS_LOGGER_ALLOWED_WARNINGS__';
 const 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.
+ *
+ *   Proc: Allows each test to run, collects console errors and warnings,
+ *         and fails the particular test by the end of its execution if any issues are found.
+ *   Cons: Since the analysis happens in afterEach() hook, the rest of spec will be ignored.
+ *
  * - failAfterAll: Collect all errors and warnings *after all tests* and fail at the end of the test suite.
+ *
+ *  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.
+ */
+enum STRATEGY { failAfterEach, failAfterAll }
+
+/**
+ * Auxiliary type to represent a single item in the collector.
+ * It contains the test title and an array of error or warning messages collected during the test.
+ */
+type CollectorItem = {
+    url: string; // URL of the current page where the issue was found
+    test: string; // The title of the test where the issue was found
+    errors: {type: string; msg: string}[]; // Array of error or warning messages collected during the test
+};
+
+/**
+ * Returns an emoji based on the type of message.
+ * @param {string} type
  */
-enum STRATEGY { failFast, failAfterAll, failAfterEach }
+function getEmoji(type: string): string {
+    switch (type) {
+        case 'warn':
+            return '⚠️';
+        case 'error':
+            return '❌️';
+        default:
+            return '';
+    }
+}
 
 /**
  * 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,
+ * @note be careful with Cypress.env(envVarStrategy), since it might return `0` for `failAfterEach` strategy,
  *       which is falsy in JavaScript, so we need to check if the variable is undefined.
  */
 function getStrategy(): STRATEGY {
-    return typeof Cypress.env(envVarStrategy) === 'undefined' ? STRATEGY.failFast : Cypress.env(envVarStrategy);
+    return typeof Cypress.env(envVarStrategy) === 'undefined' ? STRATEGY.failAfterAll : Cypress.env(envVarStrategy);
 }
 
 /**
@@ -36,11 +72,29 @@ function getStrategy(): STRATEGY {
  */
 function setStrategy(strategy: STRATEGY): void { Cypress.env(envVarStrategy, strategy); }
 
+/**
+ * Returns console issues collected during the test execution.
+ * @returns {CollectorItem []} - Array of collected issues, each issue is an object with test title and errors.
+ */
+function getCollectedIssues(): CollectorItem [] { return Cypress.env(envVarCollector) || []; }
+
+/**
+ * Sets the console issues collected during the test execution.
+ * @returns {void}
+ */
+function setCollectedIssues(items: CollectorItem []): void { Cypress.env(envVarCollector, items); }
+
 /**
  * Checks if the js errors and warnings logger is disabled.
  * @returns {boolean} - true if the logger is disabled, false otherwise.
  */
-function isDisabled(): boolean { return Cypress.env(envVarDisabled) === true; }
+function isDisabled(): boolean { return ((Cypress.env(envVarDisableAll) === true) || (Cypress.env(envVarDisableJsLogger) === true)); }
+
+/**
+ * Returns the list of allowed warnings that will not be reported by the logger.
+ * @returns {string[]} - Array of allowed warning messages.
+ */
+function getAllowedJsWarnings(): string[] { return Cypress.env(envVarAllowedWarnings) || []; }
 
 /**
  * Sets the list of allowed warnings that will not be reported by the logger.
@@ -50,223 +104,146 @@ function isDisabled(): boolean { return Cypress.env(envVarDisabled) === true; }
 function setAllowedJsWarnings(warnings: string[]): void { 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(): void {
-    // 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.
+ * Attaches a custom JavaScript interceptor to capture console errors and warnings.
  */
-function attachFailAfterAll(): void {
+function attachJsInterceptor(): void {
     /**
-     * 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.
+     * Custom 'window:before:load' hook to attach interceptors before the page is loaded,
+     * allowing us to spy on console messages.
      */
     Cypress.on('window:before:load', 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
+        // Skip 'window:before:load' hook if the logger is disabled
         if (isDisabled()) { return; }
-
+        // Spy on console.error and console.warn to capture errors and warnings
         cy.spy(window.console, 'error').as('errors');
         cy.spy(window.console, 'warn').as('warnings');
     });
 
     /**
-     * Custom 'afterEach' hook to collect console errors and warnings
+     * Custom 'window:load' hook to collect JavaScript errors and warnings right after the page is loaded.
      */
-    afterEach(() => {
-        // 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
+    Cypress.on('window:load', win => {
+        // Skip 'window:load' hook if the logger is disabled
         if (isDisabled()) { return; }
+        // Collect issues immediately after the window is loaded and analyze them
+        collectIssues(win);
+    });
+}
 
-        let consoleIssues = [];
-        const allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
-
-        // All errors should be collected
-        cy.get('@errors')
-            .invoke('getCalls')
-            .then(calls => { consoleIssues = calls; });
+/**
+ * Collects JavaScript errors and warnings using the spies set up in attachJsInterceptor.
+ * @returns {Cypress.Chainable} - Cypress chainable object that resolves when issues are collected.
+ */
+function collectIssues(win: Cypress.AUTWindow): Cypress.Chainable {
+    const allowedWarnings = getAllowedJsWarnings();
+    let consoleIssues: {type: string, msg: string}[] = [];
+    const url = win.location.href;
 
-        // Only warnings not in the allowed list should be collected
-        cy.get('@warnings')
-            .invoke('getCalls')
-            .each((call: { args: string[]}) => {
-                call.args.forEach((arg: string) => {
-                    if (!allowedWarnings.some((item: string) => arg.includes(item))) {
-                        consoleIssues.push(arg);
-                    }
+    // Look for console errors and warnings, collected by the spies
+    return cy.get('@errors')
+        .invoke('getCalls')
+        .then(errorCalls => {
+            // All errors should be collected
+            consoleIssues = errorCalls.flatMap((call: { args: unknown[] }) => call.args.map((arg: string) => ({type: 'error', msg: String(arg)})));
+        })
+        .then(() => {
+            // Analyze warnings
+            cy.get('@warnings')
+                .invoke('getCalls')
+                .then(warningCalls => {
+                    warningCalls.flatMap((call: { args: unknown[] }) => call.args).forEach((arg: string) => {
+                        // Only warnings not in the allowed list should be collected
+                        if (!allowedWarnings.some((item: string) => arg.includes(item))) { consoleIssues.push({type: 'warn', msg: String(arg)}); }
+                    });
                 });
-            });
-
-        // Collect all issues and store them in the Cypress environment variable for later usage
-        cy.then(() => {
+        })
+        .then(() => {
+            // Update the Cypress environment variable with the collected issues
             if (consoleIssues.length > 0) {
-                Cypress.env(envVarCollector, [...(Cypress.env(envVarCollector) || []), {
-                    test: Cypress.currentTest.title,
-                    errors: consoleIssues
-                }]);
+                setCollectedIssues([
+                    ...getCollectedIssues(),
+                    {url: url, test: Cypress.currentTest.title, errors: consoleIssues}
+                ]);
             }
         });
-    });
-
-    /**
-     * Custom 'after' hook to analyze collected errors and warnings after all tests are executed.
-     */
-    after(() => {
-        // 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
-        const failures = Cypress.env(envVarCollector) || [];
-        cy.log('[JS ERRORS LOGGER] Analyze collected issues').then(() => {
-            if (failures.length > 0) {
-                // Format the error message for each test
-                const errorMessage = failures.map((failure: { test: string; errors: string[]; }) => {
-                    return `TEST: ${failure.test}\nISSUES:\n${failure.errors.map((e: string) => `- ${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.
+ * Analyzes collected JavaScript errors and warnings and throws an error if any were found.
  */
-function attachFailAfterEach(): void {
-    // 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; }
+function analyzeIssues(): void {
+    cy.then(() => {
+        const failures = getCollectedIssues();
 
-    /**
-     * 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', window => {
-        cy.spy(window.console, 'error').as('errors');
-        cy.spy(window.console, 'warn').as('warnings');
-    });
+        if (failures.length > 0) {
+            // Group all issues by test title
+            const groupedByTest = failures.reduce((acc: Record<string, CollectorItem[]>, failure) => {
+                acc[failure.test] = acc[failure.test] || [];
+                acc[failure.test].push(failure);
 
-    /**
-     * Custom 'afterEach' hook to collect console errors and warnings
-     */
-    afterEach(() => {
-        let consoleIssues = [];
-        const allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
+                return acc;
+            }, {} as Record<string, CollectorItem[]>);
 
-        // All errors should be collected
-        cy.get('@errors')
-            .invoke('getCalls')
-            .then(calls => { consoleIssues = calls; });
+            // Format the error message for each test with its collected issues
+            const errorMessage = Object.entries(groupedByTest).map(([test, items]) => {
+                const urlsAndErrors = items.map(item =>
+                    `URL: ${item.url}\nISSUES:\n${item.errors.map((e: {
+                        type: string;
+                        msg: string
+                    }) => `- ${e.type === 'warn' ? getEmoji('warn') : getEmoji('error')} ${e.msg}`).join('\n')}`
+                ).join('\n\n');
 
-        // Only warnings not in the allowed list should be collected
-        cy.get('@warnings')
-            .invoke('getCalls')
-            .each((call: { args: string[]}) => {
-                call.args.forEach((arg: string) => {
-                    if (!allowedWarnings.some((item: string) => arg.includes(item))) {
-                        consoleIssues.push(arg);
-                    }
-                });
-            });
+                // Return the formatted message for the test;
+                // Intentionally use fixed-width (50 chars) separators for better readability,
+                // when the message might be wrapped
+                return `${getEmoji('error')}️ TEST: ${test.trim()} ${getEmoji('error')}️\n${'-'.repeat(50)}\n${urlsAndErrors}\n${'='.repeat(50)}`;
+            }).join('\n\n');
 
-        // Analyze collected errors and warnings
-        cy.log('[JS ERRORS LOGGER] Analyze collected issues').then(() => {
-            if (consoleIssues.length > 0) {
-                // Format the error message for each test
-                const errorMessage = consoleIssues.map((e: string) => `- ${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.');
-            }
-        });
+            // Reset the collector for the next test run
+            setCollectedIssues([]);
+
+            // Throw an error with the collected issues
+            throw new Error('CONSOLE ERRORS and WARNINGS FOUND:\n\n' + errorMessage);
+        }
     });
 }
 
 /**
- * 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.
+ * Disables the js errors and warnings logger.
+ * @returns {void}
  */
-function attachFailFast(): void {
-    // 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; }
+function disable(): void { Cypress.env(envVarDisableJsLogger, true); }
+
+/**
+ * Attaches custom hooks to Cypress events to monitor and report JavaScript errors and warnings.
+ * It sets up listeners for console errors and warnings, collects them for each visited URL in each test,
+ * and throws an error if any issues are found after each or all tests are executed (depending on the strategy chosen).
+ */
+function enable(): void {
+    // Ensure the logger is enabled by default
+    Cypress.env(envVarDisableJsLogger, false);
+
+    // Attach errors and warnings collector
+    attachJsInterceptor();
 
     /**
-     * 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.
+     * Custom 'afterEach' hook to analyze JavaScript errors and warnings after EACH test execution.
      */
-    Cypress.on('window:before:load', window => {
-        cy.spy(window.console, 'error').as('errors');
-        cy.spy(window.console, 'warn').as('warnings');
+    afterEach(() => {
+        // Skip the hook if the logger is disabled or if the strategy is not failAfterEach
+        if (isDisabled() || getStrategy() !== STRATEGY.failAfterEach) { return; }
+        // Analyze collected errors and warnings
+        analyzeIssues();
     });
 
-    Cypress.on('window:load', () => {
-        // DOM should be loaded and parsed by now, so we can check for console errors and warnings
-        let consoleIssues = [];
-        const allowedWarnings = Cypress.env(envVarAllowedWarnings) || [];
-
-        // All errors should be collected
-        cy.get('@errors')
-            .invoke('getCalls')
-            .then(calls => { consoleIssues = calls; });
-
-        // Only warnings not in the allowed list should be collected
-        cy.get('@warnings')
-            .invoke('getCalls')
-            .each((call: { args: string[]}) => {
-                call.args.forEach((arg: string) => {
-                    if (!allowedWarnings.some((item: string) => arg.includes(item))) {
-                        consoleIssues.push(arg);
-                    }
-                });
-            }).then(() => {
-                if (consoleIssues.length > 0) {
-                    // Format the error message for each test
-                    const errorMessage = consoleIssues.map((e: string) => `- ${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.');
-                }
-            });
+    /**
+     * Custom 'after' hook to analyze JavaScript errors and warnings after ALL tests execution.
+     */
+    after(() => {
+        // Skip the hook if the logger is disabled or if the strategy is not failAfterAll
+        if (isDisabled() || getStrategy() !== STRATEGY.failAfterAll) { return; }
+        // Analyze collected errors and warnings
+        analyzeIssues();
     });
 }
 
@@ -274,8 +251,11 @@ function attachFailFast(): void {
  * Exports the jsLogger module with methods to attach hooks, enable/disable logging, and set allowed warnings.
  */
 export const jsErrorsLogger = {
-    attachHooks,
     setAllowedJsWarnings,
+    getAllowedJsWarnings,
     setStrategy,
+    getStrategy,
+    enable,
+    disable,
     STRATEGY
 };