@allurereport/core 3.0.0-beta.9 → 3.0.0

package/dist/store/store.js

@@ -9,9 +9,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _DefaultAllureStore_testResults, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_eventEmitter;
-import { compareBy, nullsLast, ordinal, reverse } from "@allurereport/core-api";
-import { md5 } from "@allurereport/plugin-api";
+var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_globalAttachments, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_qualityGateResultsByRules, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_addEnvironments;
+import { DEFAULT_ENVIRONMENT, compareBy, getWorstStatus, htrsByTr, matchEnvironment, nullsLast, ordinal, reverse, } from "@allurereport/core-api";
+import { md5, } from "@allurereport/plugin-api";
+import { isFlaky } from "../utils/flaky.js";
+import { getStatusTransition } from "../utils/new.js";
 import { testFixtureResultRawToState, testResultRawToState } from "./convert.js";
 const index = (indexMap, key, ...items) => {
     if (key) {
@@ -22,8 +24,47 @@ const index = (indexMap, key, ...items) => {
         current.push(...items);
     }
 };
+const wasStartedEarlier = (first, second) => first.start === undefined || second.start === undefined || first.start < second.start;
+const hidePreviousAttempt = (state, testResult) => {
+    const { environment, historyId } = testResult;
+    if (environment) {
+        if (!state.has(environment)) {
+            state.set(environment, new Map());
+        }
+        if (historyId) {
+            const historyIdToLastAttemptResult = state.get(environment);
+            const currentLastAttemptResult = historyIdToLastAttemptResult.get(historyId);
+            if (currentLastAttemptResult) {
+                if (wasStartedEarlier(currentLastAttemptResult, testResult)) {
+                    historyIdToLastAttemptResult.set(historyId, testResult);
+                    currentLastAttemptResult.hidden = true;
+                }
+                else {
+                    testResult.hidden = true;
+                }
+            }
+            else {
+                historyIdToLastAttemptResult.set(historyId, testResult);
+            }
+        }
+    }
+};
+export const mapToObject = (map) => {
+    const result = {};
+    map.forEach((value, key) => {
+        result[key] = value;
+    });
+    return result;
+};
+export const updateMapWithRecord = (map, record) => {
+    Object.entries(record).forEach(([key, value]) => {
+        map.set(key, value);
+    });
+    return map;
+};
 export class DefaultAllureStore {
     constructor(params) {
+        _DefaultAllureStore_instances.add(this);
         _DefaultAllureStore_testResults.set(this, void 0);
         _DefaultAllureStore_attachments.set(this, void 0);
         _DefaultAllureStore_attachmentContents.set(this, void 0);
@@ -33,26 +74,95 @@ export class DefaultAllureStore {
         _DefaultAllureStore_known.set(this, void 0);
         _DefaultAllureStore_fixtures.set(this, void 0);
         _DefaultAllureStore_defaultLabels.set(this, {});
-        _DefaultAllureStore_eventEmitter.set(this, void 0);
+        _DefaultAllureStore_environment.set(this, void 0);
+        _DefaultAllureStore_environmentsConfig.set(this, {});
+        _DefaultAllureStore_reportVariables.set(this, {});
+        _DefaultAllureStore_realtimeDispatcher.set(this, void 0);
+        _DefaultAllureStore_realtimeSubscriber.set(this, void 0);
         this.indexTestResultByTestCase = new Map();
-        this.indexLatestTestResultByHistoryId = new Map();
+        this.indexLatestEnvTestResultByHistoryId = new Map();
         this.indexTestResultByHistoryId = new Map();
         this.indexAttachmentByTestResult = new Map();
         this.indexAttachmentByFixture = new Map();
         this.indexFixturesByTestResult = new Map();
         this.indexKnownByHistoryId = new Map();
-        const { history = [], known = [], eventEmitter, defaultLabels } = params ?? {};
+        _DefaultAllureStore_globalAttachments.set(this, []);
+        _DefaultAllureStore_globalErrors.set(this, []);
+        _DefaultAllureStore_globalExitCode.set(this, void 0);
+        _DefaultAllureStore_qualityGateResultsByRules.set(this, {});
+        _DefaultAllureStore_historyPoints.set(this, []);
+        _DefaultAllureStore_environments.set(this, []);
+        const { history, known = [], realtimeDispatcher, realtimeSubscriber, defaultLabels = {}, environment, environmentsConfig = {}, reportVariables = {}, } = params ?? {};
+        const environments = Object.keys(environmentsConfig)
+            .concat(environment ?? "")
+            .filter(Boolean);
         __classPrivateFieldSet(this, _DefaultAllureStore_testResults, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_attachments, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_attachmentContents, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_testCases, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_metadata, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_fixtures, new Map(), "f");
-        __classPrivateFieldSet(this, _DefaultAllureStore_history, [...history].sort(compareBy("timestamp", reverse(ordinal()))), "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_history, history, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_known, [...known], "f");
         __classPrivateFieldGet(this, _DefaultAllureStore_known, "f").forEach((ktf) => index(this.indexKnownByHistoryId, ktf.historyId, ktf));
-        __classPrivateFieldSet(this, _DefaultAllureStore_eventEmitter, eventEmitter, "f");
-        __classPrivateFieldSet(this, _DefaultAllureStore_defaultLabels, defaultLabels ?? {}, "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_realtimeDispatcher, realtimeDispatcher, "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_realtimeSubscriber, realtimeSubscriber, "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_defaultLabels, defaultLabels, "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_environmentsConfig, environmentsConfig, "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_environment, environment, "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_reportVariables, reportVariables, "f");
+        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, environments);
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onQualityGateResults(async (results) => {
+            results.forEach((result) => {
+                __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f")[result.rule] = result;
+            });
+        });
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalExitCode(async (exitCode) => {
+            __classPrivateFieldSet(this, _DefaultAllureStore_globalExitCode, exitCode, "f");
+        });
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalError(async (error) => {
+            __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f").push(error);
+        });
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalAttachment(async (attachment) => {
+            const attachmentLink = {
+                id: md5(attachment.getOriginalFileName()),
+                missed: false,
+                used: false,
+                ext: attachment.getExtension(),
+                originalFileName: attachment.getOriginalFileName(),
+                contentType: attachment.getContentType(),
+                contentLength: attachment.getContentLength(),
+            };
+            __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").set(attachmentLink.id, attachment);
+            __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f").push(attachmentLink);
+        });
+    }
+    async readHistory() {
+        if (!__classPrivateFieldGet(this, _DefaultAllureStore_history, "f")) {
+            return [];
+        }
+        __classPrivateFieldSet(this, _DefaultAllureStore_historyPoints, (await __classPrivateFieldGet(this, _DefaultAllureStore_history, "f").readHistory()) ?? [], "f");
+        __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f").sort(compareBy("timestamp", reverse(ordinal())));
+        return __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f");
+    }
+    async appendHistory(history) {
+        if (!__classPrivateFieldGet(this, _DefaultAllureStore_history, "f")) {
+            return;
+        }
+        __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f").push(history);
+        await __classPrivateFieldGet(this, _DefaultAllureStore_history, "f").appendHistory(history);
+    }
+    async qualityGateResults() {
+        return Object.values(__classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f"));
+    }
+    async globalExitCode() {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_globalExitCode, "f");
+    }
+    async allGlobalErrors() {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f");
+    }
+    async allGlobalAttachments() {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f");
     }
     async visitTestResult(raw, context) {
         const attachmentLinks = [];
@@ -75,26 +185,18 @@ export class DefaultAllureStore {
                 }
             });
         }
-        __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").set(testResult.id, testResult);
-        if (testResult.historyId) {
-            const maybeOther = this.indexLatestTestResultByHistoryId.get(testResult.historyId);
-            if (maybeOther) {
-                if (maybeOther.start === undefined || testResult.start === undefined || maybeOther.start < testResult.start) {
-                    this.indexLatestTestResultByHistoryId.set(testResult.historyId, testResult);
-                    maybeOther.hidden = true;
-                }
-                else {
-                    testResult.hidden = true;
-                }
-            }
-            else {
-                this.indexLatestTestResultByHistoryId.set(testResult.historyId, testResult);
-            }
+        testResult.environment = __classPrivateFieldGet(this, _DefaultAllureStore_environment, "f") || matchEnvironment(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), testResult);
+        const trHistory = await this.historyByTr(testResult);
+        if (trHistory) {
+            testResult.transition = getStatusTransition(testResult, trHistory);
+            testResult.flaky = isFlaky(testResult, trHistory);
         }
+        __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").set(testResult.id, testResult);
+        hidePreviousAttempt(this.indexLatestEnvTestResultByHistoryId, testResult);
         index(this.indexTestResultByTestCase, testResult.testCase?.id, testResult);
         index(this.indexTestResultByHistoryId, testResult.historyId, testResult);
         index(this.indexAttachmentByTestResult, testResult.id, ...attachmentLinks);
-        __classPrivateFieldGet(this, _DefaultAllureStore_eventEmitter, "f")?.emit("testResult", testResult.id);
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeDispatcher, "f")?.sendTestResult(testResult.id);
     }
     async visitTestFixtureResult(result, context) {
         const attachmentLinks = [];
@@ -107,7 +209,7 @@ export class DefaultAllureStore {
             index(this.indexFixturesByTestResult, trId, testFixtureResult);
         });
         index(this.indexAttachmentByFixture, testFixtureResult.id, ...attachmentLinks);
-        __classPrivateFieldGet(this, _DefaultAllureStore_eventEmitter, "f")?.emit("testFixtureResult", testFixtureResult.id);
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeDispatcher, "f")?.sendTestFixtureResult(testFixtureResult.id);
     }
     async visitAttachmentFile(resultFile, context) {
         const originalFileName = resultFile.getOriginalFileName();
@@ -132,7 +234,7 @@ export class DefaultAllureStore {
                 contentLength: resultFile.getContentLength(),
             });
         }
-        __classPrivateFieldGet(this, _DefaultAllureStore_eventEmitter, "f")?.emit("attachmentFile", id);
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeDispatcher, "f")?.sendAttachmentFile(id);
     }
     async visitMetadata(metadata) {
         Object.keys(metadata).forEach((key) => __classPrivateFieldGet(this, _DefaultAllureStore_metadata, "f").set(key, metadata[key]));
@@ -142,15 +244,28 @@ export class DefaultAllureStore {
     }
     async allTestResults(options = { includeHidden: false }) {
         const { includeHidden } = options;
-        const result = Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").values());
-        return includeHidden ? result : result.filter((tr) => !tr.hidden);
+        const result = [];
+        for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
+            if (!includeHidden && tr.hidden) {
+                continue;
+            }
+            result.push(tr);
+        }
+        return result;
     }
     async allAttachments(options = {}) {
         const { includeMissed = false, includeUnused = false } = options;
-        const attachments = Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").values());
-        return attachments
-            .filter((link) => (!includeMissed ? !link.missed : true))
-            .filter((link) => (!includeUnused ? link.used : true));
+        const filteredAttachments = [];
+        for (const [, attachment] of __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f")) {
+            if (!includeMissed && attachment.missed) {
+                continue;
+            }
+            if (!includeUnused && !attachment.used) {
+                continue;
+            }
+            filteredAttachments.push(attachment);
+        }
+        return filteredAttachments;
     }
     async allMetadata() {
         const result = {};
@@ -161,11 +276,53 @@ export class DefaultAllureStore {
         return Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f").values());
     }
     async allHistoryDataPoints() {
-        return __classPrivateFieldGet(this, _DefaultAllureStore_history, "f");
+        return __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f");
+    }
+    async allHistoryDataPointsByEnvironment(environment) {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f").reduce((result, dp) => {
+            const filteredTestResults = [];
+            for (const tr of Object.values(dp.testResults)) {
+                const hasLabels = tr.labels && tr.labels.length > 0;
+                const trEnvironment = tr.environment ??
+                    (hasLabels ? matchEnvironment(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), tr) : undefined);
+                if (trEnvironment === environment) {
+                    filteredTestResults.push(tr);
+                }
+            }
+            const hasNoEnvironmentTestResults = filteredTestResults.length === 0;
+            result.push({
+                ...dp,
+                testResults: hasNoEnvironmentTestResults
+                    ? {}
+                    : filteredTestResults.reduce((acc, tr) => {
+                        acc[tr.historyId] = tr;
+                        return acc;
+                    }, {}),
+                knownTestCaseIds: hasNoEnvironmentTestResults ? [] : filteredTestResults.map((tr) => tr.id),
+            });
+            return result;
+        }, []);
     }
     async allKnownIssues() {
         return __classPrivateFieldGet(this, _DefaultAllureStore_known, "f");
     }
+    async allNewTestResults() {
+        const newTrs = [];
+        const allHistoryDps = await this.allHistoryDataPoints();
+        for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
+            if (tr.hidden) {
+                continue;
+            }
+            if (!tr.historyId) {
+                newTrs.push(tr);
+                continue;
+            }
+            if (!allHistoryDps.some((dp) => dp.testResults[tr.historyId])) {
+                newTrs.push(tr);
+            }
+        }
+        return newTrs;
+    }
     async testCaseById(tcId) {
         return __classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f").get(tcId);
     }
@@ -187,8 +344,7 @@ export class DefaultAllureStore {
     async attachmentsByTrId(trId) {
         return this.indexAttachmentByTestResult.get(trId) ?? [];
     }
-    async retriesByTrId(trId) {
-        const tr = await this.testResultById(trId);
+    async retriesByTr(tr) {
         if (!tr || tr.hidden || !tr.historyId) {
             return [];
         }
@@ -196,21 +352,37 @@ export class DefaultAllureStore {
             .filter((r) => r.hidden)
             .sort(nullsLast(compareBy("start", reverse(ordinal()))));
     }
+    async retriesByTrId(trId) {
+        const tr = await this.testResultById(trId);
+        return tr ? this.retriesByTr(tr) : [];
+    }
+    async historyByTr(tr) {
+        if (!__classPrivateFieldGet(this, _DefaultAllureStore_history, "f")) {
+            return undefined;
+        }
+        return htrsByTr(__classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f"), tr);
+    }
     async historyByTrId(trId) {
         const tr = await this.testResultById(trId);
-        if (!tr?.historyId) {
-            return [];
+        if (!tr) {
+            return undefined;
         }
-        return [...__classPrivateFieldGet(this, _DefaultAllureStore_history, "f")]
-            .filter((dp) => !!dp.testResults[tr.historyId])
-            .map((dp) => ({ ...dp.testResults[tr.historyId] }));
+        return this.historyByTr(tr);
     }
     async fixturesByTrId(trId) {
         return this.indexFixturesByTestResult.get(trId) ?? [];
     }
     async failedTestResults() {
-        const allTestResults = await this.allTestResults();
-        return allTestResults.filter(({ status }) => status === "failed" || status === "broken");
+        const failedTrs = [];
+        for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
+            if (tr.hidden) {
+                continue;
+            }
+            if (tr.status === "failed" || tr.status === "broken") {
+                failedTrs.push(tr);
+            }
+        }
+        return failedTrs;
     }
     async unknownFailedTestResults() {
         const failedTestResults = await this.failedTestResults();
@@ -224,12 +396,14 @@ export class DefaultAllureStore {
         const results = {
             _: [],
         };
-        const all = await this.allTestResults();
-        all.forEach((test) => {
+        for (const [, test] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
+            if (test.hidden) {
+                continue;
+            }
             const targetLabels = (test.labels ?? []).filter((label) => label.name === labelName);
             if (targetLabels.length === 0) {
                 results._.push(test);
-                return;
+                continue;
             }
             targetLabels.forEach((label) => {
                 if (!results[label.value]) {
@@ -237,18 +411,235 @@ export class DefaultAllureStore {
                 }
                 results[label.value].push(test);
             });
-        });
+        }
         return results;
     }
-    async testsStatistic() {
-        const all = await this.allTestResults();
-        return all.reduce((acc, test) => {
-            if (!acc[test.status]) {
-                acc[test.status] = 0;
+    async testsStatistic(filter) {
+        const statistic = { total: 0 };
+        for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
+            if (tr.hidden) {
+                continue;
             }
-            acc[test.status]++;
+            if (filter && !filter(tr)) {
+                continue;
+            }
+            statistic.total++;
+            const retries = await this.retriesByTr(tr);
+            if (retries.length > 0) {
+                statistic.retries = (statistic.retries ?? 0) + 1;
+            }
+            if (tr.flaky) {
+                statistic.flaky = (statistic.flaky ?? 0) + 1;
+            }
+            if (tr.transition === "new") {
+                statistic.new = (statistic.new ?? 0) + 1;
+            }
+            if (!statistic[tr.status]) {
+                statistic[tr.status] = 0;
+            }
+            statistic[tr.status]++;
+        }
+        return statistic;
+    }
+    async allEnvironments() {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_environments, "f");
+    }
+    async testResultsByEnvironment(env, options = { includeHidden: false }) {
+        const trs = [];
+        for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
+            if (!options.includeHidden && tr.hidden) {
+                continue;
+            }
+            if (tr.environment === env) {
+                trs.push(tr);
+            }
+        }
+        return trs;
+    }
+    async allTestEnvGroups() {
+        const trByTestCaseId = {};
+        for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
+            const testCaseId = tr?.testCase?.id;
+            if (!testCaseId) {
+                continue;
+            }
+            if (trByTestCaseId[testCaseId]) {
+                trByTestCaseId[testCaseId].push(tr);
+            }
+            else {
+                trByTestCaseId[testCaseId] = [tr];
+            }
+        }
+        return Object.entries(trByTestCaseId).reduce((acc, [testCaseId, trs]) => {
+            if (trs.length === 0) {
+                return acc;
+            }
+            const { fullName, name } = trs[0];
+            const envGroup = {
+                id: testCaseId,
+                fullName,
+                name,
+                status: getWorstStatus(trs.map(({ status }) => status)) ?? "passed",
+                testResultsByEnv: {},
+            };
+            trs.forEach((tr) => {
+                const env = tr.environment || __classPrivateFieldGet(this, _DefaultAllureStore_environment, "f") || matchEnvironment(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), tr);
+                envGroup.testResultsByEnv[env] = tr.id;
+            });
+            acc.push(envGroup);
             return acc;
-        }, { total: all.length });
+        }, []);
+    }
+    async allVariables() {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f");
+    }
+    async envVariables(env) {
+        return {
+            ...__classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"),
+            ...(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f")?.[env]?.variables ?? {}),
+        };
+    }
+    dumpState() {
+        const storeDump = {
+            testResults: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")),
+            attachments: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f")),
+            testCases: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f")),
+            fixtures: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f")),
+            environments: __classPrivateFieldGet(this, _DefaultAllureStore_environments, "f"),
+            reportVariables: __classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"),
+            globalAttachments: __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f"),
+            globalErrors: __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f"),
+            indexLatestEnvTestResultByHistoryId: {},
+            indexAttachmentByTestResult: {},
+            indexTestResultByHistoryId: {},
+            indexTestResultByTestCase: {},
+            indexAttachmentByFixture: {},
+            indexFixturesByTestResult: {},
+            indexKnownByHistoryId: {},
+            qualityGateResultsByRules: __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f"),
+        };
+        this.indexLatestEnvTestResultByHistoryId.forEach((envMap) => {
+            envMap.forEach((tr, historyId) => {
+                storeDump.indexLatestEnvTestResultByHistoryId[historyId] = tr.id;
+            });
+        });
+        this.indexAttachmentByFixture.forEach((link, fxId) => {
+            storeDump.indexAttachmentByFixture[fxId] = link.map((l) => l.id);
+        });
+        this.indexAttachmentByTestResult.forEach((links, trId) => {
+            storeDump.indexAttachmentByTestResult[trId] = links.map((l) => l.id);
+        });
+        this.indexTestResultByHistoryId.forEach((trs, historyId) => {
+            storeDump.indexTestResultByHistoryId[historyId] = trs.map((tr) => tr.id);
+        });
+        this.indexTestResultByTestCase.forEach((trs, tcId) => {
+            storeDump.indexTestResultByTestCase[tcId] = trs.map((tr) => tr.id);
+        });
+        this.indexFixturesByTestResult.forEach((fixtures, trId) => {
+            storeDump.indexFixturesByTestResult[trId] = fixtures.map((f) => f.id);
+        });
+        this.indexKnownByHistoryId.forEach((known, historyId) => {
+            storeDump.indexKnownByHistoryId[historyId] = known;
+        });
+        return storeDump;
+    }
+    async restoreState(stateDump, attachmentsContents = {}) {
+        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachments = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResultsByRules = {}, } = stateDump;
+        updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f"), testResults);
+        updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f"), attachments);
+        updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f"), testCases);
+        updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f"), fixtures);
+        updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f"), attachmentsContents);
+        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, environments);
+        __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f").push(...globalAttachments);
+        __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f").push(...globalErrors);
+        Object.assign(__classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"), reportVariables);
+        Object.entries(indexAttachmentByTestResult).forEach(([trId, links]) => {
+            const attachmentsLinks = links.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id)).filter(Boolean);
+            if (attachmentsLinks.length === 0) {
+                return;
+            }
+            const existingLinks = this.indexAttachmentByTestResult.get(trId);
+            if (!existingLinks) {
+                this.indexAttachmentByTestResult.set(trId, attachmentsLinks);
+                return;
+            }
+            existingLinks.push(...attachmentsLinks);
+        });
+        Object.entries(indexTestResultByHistoryId).forEach(([historyId, trIds]) => {
+            const trs = trIds.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").get(id)).filter(Boolean);
+            if (trs.length === 0) {
+                return;
+            }
+            const existingTrs = this.indexTestResultByHistoryId.get(historyId);
+            if (!existingTrs) {
+                this.indexTestResultByHistoryId.set(historyId, trs);
+                return;
+            }
+            existingTrs.push(...trs);
+        });
+        Object.entries(indexTestResultByTestCase).forEach(([tcId, trIds]) => {
+            const trs = trIds.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").get(id)).filter(Boolean);
+            if (trs.length === 0) {
+                return;
+            }
+            const existingTrs = this.indexTestResultByTestCase.get(tcId);
+            if (!existingTrs) {
+                this.indexTestResultByTestCase.set(tcId, trs);
+                return;
+            }
+            existingTrs.push(...trs);
+        });
+        Object.entries(indexAttachmentByFixture).forEach(([fxId, attachmentIds]) => {
+            const attachmentsLinks = attachmentIds.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id)).filter(Boolean);
+            if (attachmentsLinks.length === 0) {
+                return;
+            }
+            const existingLinks = this.indexAttachmentByFixture.get(fxId);
+            if (!existingLinks) {
+                this.indexAttachmentByFixture.set(fxId, attachmentsLinks);
+                return;
+            }
+            existingLinks.push(...attachmentsLinks);
+        });
+        Object.entries(indexFixturesByTestResult).forEach(([trId, fixtureIds]) => {
+            const fxs = fixtureIds.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f").get(id)).filter(Boolean);
+            if (fxs.length === 0) {
+                return;
+            }
+            const existingFixtures = this.indexFixturesByTestResult.get(trId);
+            if (!existingFixtures) {
+                this.indexFixturesByTestResult.set(trId, fxs);
+                return;
+            }
+            existingFixtures.push(...fxs);
+        });
+        Object.entries(indexKnownByHistoryId).forEach(([historyId, knownFailures]) => {
+            const existingKnown = this.indexKnownByHistoryId.get(historyId);
+            if (!existingKnown) {
+                this.indexKnownByHistoryId.set(historyId, knownFailures);
+                return;
+            }
+            existingKnown.push(...knownFailures);
+        });
+        Object.values(indexLatestEnvTestResultByHistoryId).forEach((trId) => {
+            const tr = __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").get(trId);
+            if (!tr) {
+                return;
+            }
+            hidePreviousAttempt(this.indexLatestEnvTestResultByHistoryId, tr);
+        });
+        Object.assign(__classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f"), qualityGateResultsByRules);
     }
 }
-_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_known = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_eventEmitter = new WeakMap();
+_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_known = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_globalAttachments = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_qualityGateResultsByRules = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_addEnvironments = function _DefaultAllureStore_addEnvironments(envs) {
+    if (__classPrivateFieldGet(this, _DefaultAllureStore_environments, "f").length === 0) {
+        __classPrivateFieldGet(this, _DefaultAllureStore_environments, "f").push(DEFAULT_ENVIRONMENT);
+    }
+    __classPrivateFieldSet(this, _DefaultAllureStore_environments, Array.from(new Set([...__classPrivateFieldGet(this, _DefaultAllureStore_environments, "f"), ...envs])), "f");
+    envs.forEach((key) => {
+        if (!this.indexLatestEnvTestResultByHistoryId.has(key)) {
+            this.indexLatestEnvTestResultByHistoryId.set(key, new Map());
+        }
+    });
+};