@applitools/eyes-playwright 1.40.7 → 1.41.1

package/dist/fixture/report-plugin/management/pollingManager.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingManager = void 0;
+const statusUtils_js_1 = require("./statusUtils.js");
+const playwrightStatusUpdater_js_1 = require("./playwrightStatusUpdater.js");
+const reportDataManager_js_1 = require("./reportDataManager.js");
+const urlManager_js_1 = require("../data/urlManager.js");
+const log_1 = __importDefault(require("../core/log"));
+const logger = (0, log_1.default)();
+class PollingManager {
+    constructor() {
+        this._statusPollingTimeout = null;
+        this._isPolling = false;
+        this._currentResults = null;
+        this.onStatusUpdate = null;
+    }
+    async startPolling(waitForResults) {
+        if (this._isPolling) {
+            return waitForResults;
+        }
+        this._isPolling = true;
+        this._pollLoop(waitForResults);
+        return waitForResults;
+    }
+    stopPolling() {
+        if (this._statusPollingTimeout) {
+            clearTimeout(this._statusPollingTimeout);
+            this._statusPollingTimeout = null;
+        }
+        this._isPolling = false;
+    }
+    async _pollLoop(waitForResults) {
+        try {
+            logger.log('[Eyes Polling Manager] Polling started.');
+            const testResults = await waitForResults;
+            // Store current results for next iteration
+            if (!this._currentResults) {
+                this._currentResults = testResults;
+            }
+            // Check if all tests are settled (not new/unresolved/running)
+            const allSettled = this._areAllTestsSettled(this._currentResults);
+            if (allSettled) {
+                this.stopPolling();
+                return;
+            }
+            // Fetch status updates from Eyes server and merge
+            const hasChanges = await this._fetchAndMergeStatuses(this._currentResults);
+            if (!hasChanges) {
+                // No status changes detected - skip data refresh and UI update
+            }
+            else {
+                // Status changes detected - refresh data and notify UI
+                // Refresh report data (re-zip and update window.playwrightReportBase64)
+                await (0, reportDataManager_js_1.refreshReportData)(this._currentResults.testsFiles, this._currentResults.report);
+                // Call the update callback if provided
+                if (this.onStatusUpdate && typeof this.onStatusUpdate === 'function') {
+                    this.onStatusUpdate(this._currentResults);
+                }
+                // Check again after updates - tests may have just settled
+                const nowSettled = this._areAllTestsSettled(this._currentResults);
+                if (nowSettled) {
+                    this.stopPolling();
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            logger.error('[Eyes Polling Manager] Error during polling:', error);
+        }
+        finally {
+            // Schedule next poll in 5 seconds (only if still polling)
+            if (this._isPolling) {
+                this._statusPollingTimeout = setTimeout(() => this._pollLoop(Promise.resolve(this._currentResults)), PollingManager.POLLING_INTERVAL_MS);
+            }
+        }
+    }
+    /**
+     * Fetch status updates from Eyes server and merge with local results
+     * Updates the testResults object in place
+     */
+    async _fetchAndMergeStatuses(testResults) {
+        const { sessionsByBatchId } = testResults;
+        if (!sessionsByBatchId || Object.keys(sessionsByBatchId).length === 0) {
+            return false;
+        }
+        try {
+            // Fetch status for all batches in parallel
+            const results = await Promise.all(Object.keys(sessionsByBatchId).map(async (batchId) => {
+                return this._getServerDataForBatch(batchId, sessionsByBatchId[batchId]);
+            }));
+            // Flatten all session results
+            const allResults = results.map(result => (result === null || result === void 0 ? void 0 : result.sessions) || []).flat();
+            if (allResults.length === 0) {
+                return false;
+            }
+            // Create lookup map by session ID
+            const statusBySessionId = allResults.reduce((acc, result) => {
+                acc[result.id] = result;
+                return acc;
+            }, {});
+            // Merge server statuses into test results (modifies testResults in place)
+            const hasChanges = this._mergeServerStatuses(testResults, statusBySessionId);
+            return hasChanges;
+        }
+        catch (error) {
+            logger.error('[Eyes Polling Manager] Failed to fetch status updates:', error);
+            return false;
+        }
+    }
+    async _getServerDataForBatch(batchId, batchData) {
+        const chunkSize = 300;
+        const chunks = [];
+        // Split sessions into chunks for API calls
+        for (let i = 0; i < batchData.sessions.length; i += chunkSize) {
+            chunks.push(batchData.sessions.slice(i, i + chunkSize));
+        }
+        const url = (0, urlManager_js_1.fixEyesUrl)(batchData.eyesServerUrl);
+        const apiKey = batchData.apiKey;
+        try {
+            const headers = new Headers();
+            headers.set('Content-Type', 'application/json');
+            // Fetch status for all chunks in parallel
+            const results = await Promise.all(chunks.map(async (chunk) => {
+                try {
+                    const response = await fetch(`${url}api/sessions/batches/${batchId}/sessions/sdkquery?apiKey=${apiKey}`, {
+                        method: 'POST',
+                        headers,
+                        body: JSON.stringify({ sessions: chunk }),
+                    });
+                    if (!response.ok) {
+                        logger.warn(`[Eyes Polling Manager] Failed to get status for batch ${batchId}:`, response.statusText);
+                        return { sessions: [], errors: [] };
+                    }
+                    return response.json();
+                }
+                catch (error) {
+                    logger.error(`[Eyes Polling Manager] Error fetching batch ${batchId}:`, error);
+                    return { sessions: [], errors: [] };
+                }
+            }));
+            return {
+                sessions: results.map(result => result.sessions).flat(),
+                errors: results.map(result => result.errors).flat(),
+            };
+        }
+        catch (error) {
+            logger.error(`[Eyes Polling Manager] Failed to get status for batch ${batchId}:`, error);
+            return { sessions: [], errors: [] };
+        }
+    }
+    _mergeServerStatuses(testResults, statusBySessionId) {
+        let changedCount = 0;
+        // Update Eyes test results with server status
+        Object.values(testResults.eyesTestResult).forEach(test => {
+            test.eyesResults.forEach(result => {
+                const serverStatus = statusBySessionId[result.id];
+                if (!serverStatus)
+                    return;
+                // Check if status actually changed
+                const statusChanged = result.status !== serverStatus.status ||
+                    result.isDifferent !== serverStatus.isDifferent ||
+                    result.isNew !== serverStatus.isNew ||
+                    result.isAborted !== serverStatus.isAborted;
+                if (statusChanged) {
+                    changedCount++;
+                }
+                // Update high-level status fields
+                result.status = serverStatus.status;
+                result.isDifferent = serverStatus.isDifferent;
+                result.isNew = serverStatus.isNew;
+                result.isAborted = serverStatus.isAborted;
+                // Update step-level information
+                if (result.stepsInfo && Array.isArray(result.stepsInfo)) {
+                    result.stepsInfo.forEach((step, index) => {
+                        var _a, _b;
+                        const expectedAppOutput = serverStatus.expectedAppOutput ? serverStatus.expectedAppOutput[index] : null;
+                        const actualAppOutput = serverStatus.actualAppOutput ? serverStatus.actualAppOutput[index] : null;
+                        const appOutputResolution = serverStatus.appOutputResolution
+                            ? serverStatus.appOutputResolution[index]
+                            : null;
+                        step.expectedImageSize = (_a = expectedAppOutput === null || expectedAppOutput === void 0 ? void 0 : expectedAppOutput.image) === null || _a === void 0 ? void 0 : _a.size;
+                        step.actualImageSize = (_b = actualAppOutput === null || actualAppOutput === void 0 ? void 0 : actualAppOutput.image) === null || _b === void 0 ? void 0 : _b.size;
+                        step.appOutputResolution = appOutputResolution !== null && appOutputResolution !== void 0 ? appOutputResolution : undefined;
+                        step.expectedAppOutput = expectedAppOutput !== null && expectedAppOutput !== void 0 ? expectedAppOutput : undefined;
+                        step.actualAppOutput = actualAppOutput !== null && actualAppOutput !== void 0 ? actualAppOutput : undefined;
+                    });
+                }
+            });
+        });
+        // Update Playwright test statuses based on Eyes results (only if changes occurred)
+        if (changedCount > 0) {
+            (0, playwrightStatusUpdater_js_1.updateAllPlaywrightTestStatuses)(testResults);
+        }
+        return changedCount > 0;
+    }
+    /**
+     * Check if all tests have reached their final settled status
+     * Settled statuses: passed, failed, aborted
+     * Unsettled statuses: unresolved, new, running
+     *
+     * Important: Only checks the LAST retry's status for each test.
+     * Uses getLastRetryResults() from statusUtils for consistency.
+     * Earlier retries are ignored - only the final attempt determines if test is settled.
+     */
+    _areAllTestsSettled(testResults) {
+        if (!testResults || !testResults.eyesTestResult) {
+            return true; // No Eyes tests, nothing to poll
+        }
+        const eyesTests = Object.values(testResults.eyesTestResult);
+        if (eyesTests.length === 0) {
+            return true; // No Eyes tests
+        }
+        // Count unsettled tests
+        let unsettledCount = 0;
+        eyesTests.forEach(test => {
+            // Get only the results from the last retry (using centralized utility)
+            const lastRetryResults = (0, statusUtils_js_1.getLastRetryResults)(test.eyesResults);
+            // Check if the last retry has any unsettled results
+            const hasUnsettledResults = lastRetryResults.some(result => {
+                const status = result.status.toLowerCase();
+                // Unsettled statuses: unresolved, new, running
+                return status !== 'aborted';
+            });
+            if (hasUnsettledResults) {
+                unsettledCount++;
+            }
+        });
+        return unsettledCount === 0;
+    }
+}
+exports.PollingManager = PollingManager;
+PollingManager.POLLING_INTERVAL_MS = 5000;

package/dist/fixture/report-plugin/management/reportDataManager.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshReportData = void 0;
+const jszip_1 = __importDefault(require("jszip"));
+const log_1 = __importDefault(require("../core/log"));
+const logger = (0, log_1.default)();
+/**
+ * Re-zip report data and update window.playwrightReportBase64
+ * This is necessary because test statuses have been modified in memory
+ * and Playwright's UI needs to see the updated data
+ */
+async function refreshReportData(testsFiles, report) {
+    const newZip = new jszip_1.default();
+    const newFiles = { ...testsFiles, 'report.json': report };
+    Object.keys(newFiles).forEach(fileName => {
+        newZip.file(fileName, JSON.stringify(newFiles[fileName]));
+    });
+    const generatedZip = await newZip.generateAsync({ type: 'base64' });
+    window.playwrightReportBase64 = `data:application/zip;base64,${generatedZip}`;
+    logger.log('[Report Data Manager] Report data refreshed.');
+    // Also store in localStorage for HMR support PW 1.55 and above
+    try {
+        localStorage.setItem('playwrightReportStorageForHMR', generatedZip);
+    }
+    catch (e) {
+        logger.warn('[Report Data Manager] Unable to access localStorage:', e);
+    }
+}
+exports.refreshReportData = refreshReportData;

package/dist/fixture/report-plugin/management/statusUtils.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSingleSessionStatus = exports.countTestsByStatus = exports.getStatus = exports.getLastRetryResults = void 0;
+const SESSION_STATUS = {
+    Failed: 'failed',
+    Passed: 'passed',
+    Running: 'running',
+    Unresolved: 'unresolved',
+};
+const STATUS = {
+    Aborted: 'aborted',
+    Default: 'default',
+    Failed: 'failed',
+    New: 'new',
+    Passed: 'passed',
+    Running: 'running',
+    Unresolved: 'unresolved',
+    Unsaved: 'unsaved',
+    Empty: 'empty',
+};
+const STATUS_PRIORITY = [
+    SESSION_STATUS.Running,
+    SESSION_STATUS.Passed,
+    SESSION_STATUS.Failed,
+    SESSION_STATUS.Unresolved,
+];
+function getLastRetryResults(eyesResults) {
+    if (eyesResults.length === 0) {
+        return [];
+    }
+    // Find the highest retry number (last retry attempt)
+    const maxRetry = Math.max(...eyesResults.map(r => { var _a; return (_a = r.playwrightRetry) !== null && _a !== void 0 ? _a : 0; }));
+    // Return only results from the last retry
+    return eyesResults.filter(r => { var _a; return ((_a = r.playwrightRetry) !== null && _a !== void 0 ? _a : 0) === maxRetry; });
+}
+exports.getLastRetryResults = getLastRetryResults;
+function getStatus(eyesResults) {
+    // Use only the last retry's results
+    const lastRetryResults = getLastRetryResults(eyesResults);
+    if (lastRetryResults.length === 0) {
+        // No results at all
+        return { status: 'empty', statusText: STATUS.Empty, icon: null };
+    }
+    // Aggregate result flags using reduce for better functional style
+    const { maxPriority, isAborted, isNew, isDifferent, isEmpty } = lastRetryResults.reduce((acc, result) => {
+        const statusPriority = STATUS_PRIORITY.indexOf(result.status.toLowerCase());
+        return {
+            maxPriority: Math.max(statusPriority, acc.maxPriority),
+            isAborted: acc.isAborted || result.isAborted,
+            isNew: acc.isNew || result.isNew,
+            isDifferent: acc.isDifferent || result.isDifferent,
+            isEmpty: acc.isEmpty && result.steps === 0,
+        };
+    }, { maxPriority: 0, isAborted: false, isNew: false, isDifferent: false, isEmpty: true });
+    const priorityIndex = isAborted ? Math.max(2, maxPriority) : maxPriority;
+    const status = STATUS_PRIORITY[priorityIndex];
+    const statusText = isAborted
+        ? STATUS.Aborted
+        : isEmpty
+            ? STATUS.Empty
+            : status !== SESSION_STATUS.Running && isNew
+                ? STATUS.New
+                : status;
+    const icon = isAborted ? null : isNew ? 'new' : isDifferent ? 'different' : 'resolved';
+    return { status, statusText, icon };
+}
+exports.getStatus = getStatus;
+function countTestsByStatus(eyesTestResult) {
+    return Object.values(eyesTestResult).reduce((counts, test) => {
+        counts.total++;
+        // getStatus() automatically uses only the last retry's results
+        const status = getStatus(test.eyesResults).status;
+        // Use type-safe property access with mapped type
+        if (status === 'passed' || status === 'failed' || status === 'unresolved') {
+            counts[status]++;
+        }
+        return counts;
+    }, { total: 0, passed: 0, failed: 0, unresolved: 0 });
+}
+exports.countTestsByStatus = countTestsByStatus;
+function getSingleSessionStatus(test) {
+    let maxPriority = Math.max(STATUS_PRIORITY.indexOf(test.status.toLowerCase()), 0);
+    let statusText;
+    let status = STATUS_PRIORITY[maxPriority];
+    const isEmpty = test.steps === 0;
+    if (test.isAborted) {
+        maxPriority = Math.max(2, maxPriority);
+        status = STATUS_PRIORITY[maxPriority];
+        statusText = STATUS.Aborted;
+    }
+    else if (isEmpty) {
+        statusText = STATUS.Empty;
+    }
+    else if (status !== STATUS.Running && test.isNew) {
+        statusText = STATUS.New;
+    }
+    else {
+        statusText = status;
+    }
+    return { status, statusText };
+}
+exports.getSingleSessionStatus = getSingleSessionStatus;

package/dist/fixture/report-plugin/reportRenderer.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Report Renderer - Orchestrates Eyes integration into Playwright HTML reports
+ *
+ * Initial Flow:
+ * 1. Waits for test results, calls window.onload() to refresh Playwright UI with Eyes data
+ * 2. After 200ms delay (for React render), creates Eyes UI elements via DOM observer
+ * 3. Renders batch link (list mode), navigation filters, test badges (list mode), iframes (detail mode)
+ * 4. Starts polling Eyes server every 5s for status updates
+ *
+ * Polling & Update Flow:
+ * - Detects changes by comparing status fields before updating
+ * - Continues indefinitely unless all tests reach `aborted` status
+ * - On changes: merges updates, recalculates Playwright statuses, updates window.playwrightReportBase64
+ * - Triggers window.onload() for React re-render (removes all Eyes elements from DOM)
+ * - After 200ms delay, recreates Eyes elements in order: batch link, filters, badges, iframes
+ */
+const dataParser_js_1 = require("./data/dataParser.js");
+const navigationState_js_1 = require("./state/navigationState.js");
+const scrollPreserver_js_1 = require("./utils/scrollPreserver.js");
+const eyesResultsBatchLinkUI_js_1 = require("./ui/eyesResultsBatchLinkUI.js");
+const navigationUI_js_1 = require("./ui/navigationUI.js");
+const filterManager_js_1 = require("./ui/filterManager.js");
+const testListUI_js_1 = require("./ui/testListUI.js");
+const testDetailUI_js_1 = require("./ui/testDetailUI.js");
+const pollingManager_js_1 = require("./management/pollingManager.js");
+const urlChangeHandler_js_1 = require("./handlers/urlChangeHandler.js");
+const domChangesHandler_js_1 = require("./handlers/domChangesHandler.js");
+const statusUpdateHandler_js_1 = require("./handlers/statusUpdateHandler.js");
+const log_1 = __importDefault(require("./core/log"));
+const logger = (0, log_1.default)();
+class ReportRenderer {
+    constructor(waitForResults, options = {}) {
+        this.updatePlaywrightWithEyesResults = () => {
+            // Capture scroll position before triggering window.onload
+            this.scrollPreserver.captureScrollPosition();
+            if (typeof window.onload === 'function') {
+                const onloadHandler = window.onload;
+                onloadHandler(new Event('load'));
+            }
+            setTimeout(() => {
+                this.urlChangeHandler.handleUrlChange();
+                // Restore scroll position after React has re-rendered
+                this.scrollPreserver.restoreScrollPosition();
+            }, 200);
+        };
+        this.handleStatusUpdate = async (testResults) => {
+            this.waitForResults = Promise.resolve(testResults);
+            await this.statusUpdateHandler.handleStatusUpdate(testResults);
+        };
+        this.waitForResults = waitForResults;
+        this.useTestMode = options.useTestMode || false;
+        // Create shared navigation state
+        this.navigationState = new navigationState_js_1.NavigationState();
+        this.scrollPreserver = new scrollPreserver_js_1.ScrollPreserver();
+        this.filterManager = new filterManager_js_1.FilterManager();
+        this.eyesResultsBatchLinkUI = new eyesResultsBatchLinkUI_js_1.EyesResultsBatchLinkUI();
+        this.navigationUI = new navigationUI_js_1.NavigationUI(this.filterManager);
+        this.testListUI = new testListUI_js_1.TestListUI();
+        this.testDetailUI = new testDetailUI_js_1.TestDetailUI(this.navigationState, { useTestMode: this.useTestMode });
+        this.urlChangeHandler = new urlChangeHandler_js_1.UrlChangeHandler(this.waitForResults, this.navigationState, this.filterManager, this.eyesResultsBatchLinkUI, this.navigationUI, this.testDetailUI);
+        this.domChangesHandler = new domChangesHandler_js_1.DomChangesHandler(this.waitForResults, this.filterManager, this.eyesResultsBatchLinkUI, this.navigationUI, this.testListUI);
+        this.statusUpdateHandler = new statusUpdateHandler_js_1.StatusUpdateHandler(this.scrollPreserver, this.eyesResultsBatchLinkUI, this.navigationUI, this.testListUI, this.testDetailUI);
+        this.pollingManager = new pollingManager_js_1.PollingManager();
+        this.pollingManager.onStatusUpdate = this.handleStatusUpdate;
+        this.waitForResults.then(this.updatePlaywrightWithEyesResults);
+    }
+    render() {
+        window.addEventListener('hashchange', this.urlChangeHandler.handleUrlChange);
+        window.addEventListener('popstate', this.urlChangeHandler.handleUrlChange);
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', this.urlChangeHandler.handleUrlChange);
+        }
+        else {
+            this.urlChangeHandler.handleUrlChange();
+        }
+        this.observeDomChanges();
+        this.pollingManager.startPolling(this.waitForResults);
+    }
+    observeDomChanges() {
+        const mutationObserver = new MutationObserver(this.domChangesHandler.handleDomChanges);
+        const rootElement = document.getElementById('root');
+        if (!rootElement) {
+            logger.warn('No root element found for observation');
+            return;
+        }
+        mutationObserver.observe(rootElement, {
+            childList: true,
+            subtree: true,
+        });
+    }
+    updateFilterCounts(testResults) {
+        this.navigationUI.updateFilterCounts(testResults);
+    }
+}
+window.__initEyesReport = (options = {}) => {
+    const useTestMode = options.useTestMode || false;
+    logger.log('Before Initialized');
+    const waitForResults = (0, dataParser_js_1.getTestResults)();
+    const reportRenderer = new ReportRenderer(waitForResults, { useTestMode });
+    reportRenderer.render();
+    logger.log('Initialized');
+};

package/dist/fixture/report-plugin/state/navigationState.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Navigation State - Shared state for managing active test navigation
+ *
+ * This class provides a centralized location for tracking which test is currently
+ * active in the UI. It eliminates duplicate state between UrlChangeHandler and TestDetailUI.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NavigationState = void 0;
+class NavigationState {
+    constructor() {
+        this._activeTestId = null;
+    }
+    get activeTestId() {
+        return this._activeTestId;
+    }
+    setActiveTestId(testId) {
+        this._activeTestId = testId;
+    }
+    clearActiveTestId() {
+        this._activeTestId = null;
+    }
+}
+exports.NavigationState = NavigationState;

package/dist/fixture/report-plugin/ui/eyesResultsBatchLinkUI.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EyesResultsBatchLinkUI = void 0;
+const urlManager_js_1 = require("../data/urlManager.js");
+const log_js_1 = __importDefault(require("../core/log.js"));
+const logger = (0, log_js_1.default)();
+class EyesResultsBatchLinkUI {
+    constructor() {
+        this._linkCreated = false;
+    }
+    createLinkToBatch(testResults) {
+        var _a, _b;
+        if (!(0, urlManager_js_1.isListMode)()) {
+            this.removeLinkToBatch();
+            return;
+        }
+        const existingLink = document.getElementsByClassName('eyes-batch-link')[0];
+        if (existingLink) {
+            return;
+        }
+        const firstChip = document.getElementsByClassName('chip')[0];
+        if (!firstChip) {
+            logger.warn('No chip element found, cannot create link');
+            return;
+        }
+        const firstResult = (_a = Object.values(testResults.eyesTestResult)[0]) === null || _a === void 0 ? void 0 : _a.eyesResults[0];
+        if (!firstResult || !((_b = firstResult.appUrls) === null || _b === void 0 ? void 0 : _b.batch)) {
+            logger.warn('No Eyes results with batch URL found');
+            return;
+        }
+        const linkContainer = document.createElement('div');
+        linkContainer.classList.add('eyes-batch-link');
+        linkContainer.innerHTML = `<a target='_blank' href='${firstResult.appUrls.batch}'>Results in Eyes Dashboard</a>`;
+        firstChip.parentNode.insertBefore(linkContainer, firstChip);
+        this._linkCreated = true;
+    }
+    removeLinkToBatch() {
+        const link = document.getElementsByClassName('eyes-batch-link')[0];
+        if (link) {
+            link.remove();
+            this._linkCreated = false;
+        }
+    }
+    isLinkDisplayed() {
+        return this._linkCreated && document.getElementsByClassName('eyes-batch-link')[0] !== undefined;
+    }
+}
+exports.EyesResultsBatchLinkUI = EyesResultsBatchLinkUI;

package/dist/fixture/report-plugin/ui/filterManager.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterManager = void 0;
+const log_1 = __importDefault(require("../core/log"));
+const logger = (0, log_1.default)();
+class FilterManager {
+    constructor() {
+        this._activeFilters = {
+            eyes: false,
+            unresolved: false,
+        };
+    }
+    applyFiltersFromUrl(hash) {
+        const eyesFilter = hash.get('eyes');
+        const unresolvedFilter = hash.get('unresolved');
+        this.setEyesFilter(!!eyesFilter);
+        this.setUnresolvedFilter(!!unresolvedFilter);
+    }
+    setEyesFilter(active) {
+        this._activeFilters.eyes = active;
+        const htmlreport = document.getElementsByClassName('htmlreport')[0];
+        if (!htmlreport) {
+            logger.warn('[Filter Manager] No .htmlreport element found');
+            return;
+        }
+        if (active) {
+            htmlreport.classList.add('eyes-filter');
+        }
+        else {
+            htmlreport.classList.remove('eyes-filter');
+        }
+    }
+    setUnresolvedFilter(active) {
+        this._activeFilters.unresolved = active;
+        const htmlreport = document.getElementsByClassName('htmlreport')[0];
+        if (!htmlreport) {
+            logger.warn('[Filter Manager] No .htmlreport element found');
+            return;
+        }
+        if (active) {
+            htmlreport.classList.add('unresolved-filter');
+        }
+        else {
+            htmlreport.classList.remove('unresolved-filter');
+        }
+    }
+    isEyesFilterActive() {
+        return this._activeFilters.eyes;
+    }
+    isUnresolvedFilterActive() {
+        return this._activeFilters.unresolved;
+    }
+    getActiveFilters() {
+        return { ...this._activeFilters };
+    }
+}
+exports.FilterManager = FilterManager;