@allurereport/web-commons 3.18.0 → 3.19.1

package/dist/charts/accessors/coverageDiffTreeMapAccessor.js

@@ -1,3 +1,4 @@
+import { createHistoryTestResultLookup, } from "@allurereport/core-api";
 import { createTreeByLabels, md5 } from "@allurereport/plugin-api";
 import { isChildrenLeavesOnly } from "../chart-utils.js";
 import { convertTreeDataToTreeMapNode, transformTreeMapNode } from "../treeMapUtils.js";
@@ -35,22 +36,20 @@ const calculateColorValue = (metrics) => {
 };
 const isSkipped = (tr) => tr.status === "skipped";
 const getNewTestResults = (trs, closestHtrs) => {
-    return trs.filter((tr) => !closestHtrs[tr.historyId]);
+    return trs.filter((tr) => !closestHtrs[tr.retryHash]);
 };
-const getRemovedTestResults = (trs, closestHtrs) => {
-    const historyPointTestResultsAsArray = Object.values(closestHtrs);
-    const testResultsAsDictionary = Object.fromEntries(trs.map((tr) => [tr.historyId, tr]));
-    return historyPointTestResultsAsArray.filter((htr) => !testResultsAsDictionary[htr.historyId]);
+const getRemovedTestResults = (historyTestResults, matchedHistoryTestResults) => {
+    return historyTestResults.filter((htr) => !matchedHistoryTestResults.has(htr));
 };
 const getEnabledTestResults = (trs, closestHtrs) => {
     return trs.filter((tr) => {
-        const historyPointTestResult = closestHtrs[tr.historyId];
+        const historyPointTestResult = closestHtrs[tr.retryHash];
         return historyPointTestResult && isSkipped(historyPointTestResult) && !isSkipped(tr);
     });
 };
 const getDisabledTestResults = (trs, closestHtrs) => {
     return trs.filter((tr) => {
-        const historyPointTestResult = closestHtrs[tr.historyId];
+        const historyPointTestResult = closestHtrs[tr.retryHash];
         return historyPointTestResult && !isSkipped(historyPointTestResult) && isSkipped(tr);
     });
 };
@@ -80,33 +79,33 @@ const calculateSubtreeMetrics = (node) => {
     }
     return { totalTests, newCount, deletedCount, disabledCount, enabledCount };
 };
-const createCoverageDiffTreeMap = (trs, closestHtrs) => {
+const createCoverageDiffTreeMap = (trs, closestHtrs, historyTestResults = [], matchedHistoryTestResults = new Set()) => {
     const newTrs = getNewTestResults(trs, closestHtrs);
-    const removedHtrs = getRemovedTestResults(trs, closestHtrs);
+    const removedHtrs = getRemovedTestResults(historyTestResults, matchedHistoryTestResults);
     const enabledTrs = getEnabledTestResults(trs, closestHtrs);
     const disabledTrs = getDisabledTestResults(trs, closestHtrs);
-    const newTestsById = new Map(newTrs.map((tr) => [tr.historyId, tr]));
-    const deletedTestsById = new Map(removedHtrs.map((htr) => [htr.historyId, htr]));
-    const enabledTestsById = new Map(enabledTrs.map((tr) => [tr.historyId, tr]));
-    const disabledTestsById = new Map(disabledTrs.map((tr) => [tr.historyId, tr]));
+    const newTestsById = new Map(newTrs.map((tr) => [tr.retryHash, tr]));
+    const deletedTestsById = new Map(removedHtrs.map((htr) => [htr.retryHash, htr]));
+    const enabledTestsById = new Map(enabledTrs.map((tr) => [tr.retryHash, tr]));
+    const disabledTestsById = new Map(disabledTrs.map((tr) => [tr.retryHash, tr]));
     const allTests = [...trs, ...removedHtrs];
-    const getChangeType = (historyId) => {
-        if (newTestsById.has(historyId)) {
+    const getChangeType = (retryHash) => {
+        if (newTestsById.has(retryHash)) {
             return "new";
         }
-        if (deletedTestsById.has(historyId)) {
+        if (deletedTestsById.has(retryHash)) {
             return "deleted";
         }
-        if (enabledTestsById.has(historyId)) {
+        if (enabledTestsById.has(retryHash)) {
             return "enabled";
         }
-        if (disabledTestsById.has(historyId)) {
+        if (disabledTestsById.has(retryHash)) {
             return "disabled";
         }
         return "unchanged";
     };
     const leafFactoryFnWithMaps = (test) => {
-        const changeType = getChangeType(test.historyId);
+        const changeType = getChangeType(test.retryHash);
         return {
             nodeId: test.id,
             name: test.name,
@@ -169,15 +168,29 @@ const createCoverageDiffTreeMap = (trs, closestHtrs) => {
     });
 };
 export const coverageDiffTreeMapAccessor = {
-    getTreeMap: ({ testResults, historyDataPoints }) => {
+    getTreeMap: ({ testResults, historyDataPoints, allTestResults }) => {
+        const lookupHistoryTestResult = createHistoryTestResultLookup(allTestResults ?? testResults);
         const testsWithBehaviorLabels = filterTestsWithBehaviorLabels(testResults);
         if (!historyDataPoints || historyDataPoints.length === 0) {
             return createCoverageDiffTreeMap(testsWithBehaviorLabels, {});
         }
         const closestHdp = historyDataPoints[0];
-        const closestHtrs = closestHdp.testResults;
-        const closestHtrsWithBehaviorLabels = filterTestsWithBehaviorLabels(Object.values(closestHtrs));
-        const closestHtrsWithBehaviorLabelsById = Object.fromEntries(closestHtrsWithBehaviorLabels.map((htr) => [htr.historyId, htr]));
-        return createCoverageDiffTreeMap(testsWithBehaviorLabels, closestHtrsWithBehaviorLabelsById);
+        const closestHtrsWithBehaviorLabels = filterTestsWithBehaviorLabels(Object.values(closestHdp.testResults)).filter((tr) => {
+            const selected = lookupHistoryTestResult(closestHdp, tr);
+            return !selected || selected === tr;
+        });
+        const selectedHtrsByCurrentRetryHash = {};
+        const matchedHistoryTestResults = new Set();
+        for (const testResult of testsWithBehaviorLabels) {
+            if (!testResult.retryHash) {
+                continue;
+            }
+            const historicalTestResult = lookupHistoryTestResult(closestHdp, testResult);
+            if (historicalTestResult) {
+                selectedHtrsByCurrentRetryHash[testResult.retryHash] = historicalTestResult;
+                matchedHistoryTestResults.add(historicalTestResult);
+            }
+        }
+        return createCoverageDiffTreeMap(testsWithBehaviorLabels, selectedHtrsByCurrentRetryHash, closestHtrsWithBehaviorLabels, matchedHistoryTestResults);
     },
 };

package/dist/charts/generateDurationDynamicsChart.js

@@ -63,7 +63,7 @@ export const generateDurationDynamicsChart = (props) => {
         ...limitedHistoryPoints,
         {
             testResults: testResults.reduce((acc, testResult) => {
-                acc[testResult.historyId ?? testResult.id] = testResult;
+                acc[testResult.retryHash ?? testResult.id] = testResult;
                 return acc;
             }, {}),
             uuid: "current",

package/dist/charts/generateStabilityDistributionChart.d.ts

@@ -1,5 +1,5 @@
 import type { AllureChartsStoreData, StabilityDistributionChartData, StabilityDistributionChartOptions } from "@allurereport/charts-api";
-import type { TestStatus } from "@allurereport/core-api";
+import { type TestStatus } from "@allurereport/core-api";
 export declare const getStabilityScore: (statuses: TestStatus[], historyDepth: number, stabilizationPeriod: number) => number | undefined;
 export declare const generateStabilityDistributionChart: (props: {
     options: StabilityDistributionChartOptions;

package/dist/charts/generateStabilityDistributionChart.js

@@ -1,4 +1,5 @@
 import { ChartType } from "@allurereport/charts-api";
+import { createHistoryTestResultLookup, } from "@allurereport/core-api";
 import { createHashStorage, createMapWithDefault } from "./utils.js";
 const DEFAULT_LIMIT = 10;
 const DEFAULT_STABILIZATION_PERIOD = 5;
@@ -79,10 +80,10 @@ export const getStabilityScore = (statuses, historyDepth, stabilizationPeriod) =
     }
     return instabilitySumNumerator / denominator;
 };
-const getStatusSequence = (historyDataPoints, tr) => {
+const getStatusSequence = (historyDataPoints, tr, lookupHistoryTestResult) => {
     let block = [];
     for (const hdp of historyDataPoints) {
-        const htr = hdp.testResults[tr.historyId];
+        const htr = lookupHistoryTestResult(hdp, tr);
         if (!htr) {
             block = [];
             continue;
@@ -100,6 +101,7 @@ export const generateStabilityDistributionChart = (props) => {
     const { options, storeData } = props;
     const { title, limit = DEFAULT_LIMIT, stabilizationPeriod = DEFAULT_STABILIZATION_PERIOD, threshold = DEFAULT_THRESHOLD, skipStatuses: skipStatusesList = NON_SIGNIFICANT_STATUSES, groupBy = DEFAULT_GROUP_BY, groupValues = [], } = options;
     const { testResults, historyDataPoints } = storeData;
+    const lookupHistoryTestResult = createHistoryTestResultLookup(storeData.allTestResults ?? testResults);
     const effectiveStabilizationPeriod = Math.min(stabilizationPeriod, limit);
     if (historyDataPoints.length < effectiveStabilizationPeriod) {
         return {
@@ -120,7 +122,7 @@ export const generateStabilityDistributionChart = (props) => {
     const hashes = createHashStorage();
     const skipStatuses = new Set(skipStatusesList);
     for (const tr of testResults) {
-        if (!tr.historyId) {
+        if (!tr.retryHash) {
             continue;
         }
         if (!isSignificantStatus(tr.status)) {
@@ -133,7 +135,7 @@ export const generateStabilityDistributionChart = (props) => {
         if (!labelValue || (groupValuesSet.size > 0 && !groupValuesSet.has(labelValue))) {
             continue;
         }
-        const statusSequence = getStatusSequence(limitedHistoryDataPoints, tr);
+        const statusSequence = getStatusSequence(limitedHistoryDataPoints, tr, lookupHistoryTestResult);
         const stabilityScore = getStabilityScore(statusSequence, limit, effectiveStabilizationPeriod);
         if (stabilityScore === undefined) {
             continue;

package/dist/charts/generateStatusAgePyramid.js

@@ -1,4 +1,5 @@
 import { ChartType, DEFAULT_CHART_HISTORY_LIMIT } from "@allurereport/charts-api";
+import { createHistoryTestResultLookup } from "@allurereport/core-api";
 import { limitHistoryDataPoints } from "./chart-utils.js";
 const createEmptyStats = () => {
     return STATUSES.reduce((acc, status) => {
@@ -12,6 +13,7 @@ export const generateStatusAgePyramid = (props) => {
     const { options, storeData } = props;
     const { limit = DEFAULT_CHART_HISTORY_LIMIT } = options;
     const { historyDataPoints, testResults } = storeData;
+    const lookupHistoryTestResult = createHistoryTestResultLookup(storeData.allTestResults ?? testResults);
     const currentReportTimestamp = testResults.reduce((acc, testResult) => Math.max(acc, testResult.stop ?? 0), 0);
     const limitedHistoryPoints = limitHistoryDataPoints(historyDataPoints, limit).sort((a, b) => a.timestamp - b.timestamp);
     if (limitedHistoryPoints.length === 0) {
@@ -28,59 +30,48 @@ export const generateStatusAgePyramid = (props) => {
             statuses: STATUSES,
         };
     }
-    const currTrIds = new Set(testResults.map((tr) => tr.historyId ?? tr.id));
-    const hdps = limitedHistoryPoints.map((datapoint) => ({
-        ...datapoint,
-        testResults: Object.values(datapoint.testResults).reduce((acc, testResult) => {
-            if (!testResult.historyId) {
-                return acc;
-            }
-            const isInCurrentRun = currTrIds.has(testResult.historyId);
-            if (isInCurrentRun) {
-                acc[testResult.historyId] = testResult;
+    const data = limitedHistoryPoints.map((historyDataPoint, index) => {
+        const stats = createEmptyStats();
+        for (const testResult of testResults) {
+            const historicalTestResult = lookupHistoryTestResult(historyDataPoint, testResult);
+            if (!historicalTestResult) {
+                continue;
             }
-            return acc;
-        }, {}),
-    }));
-    const dataPoints = [
-        ...hdps.map((hdp) => ({
-            ...hdp,
-            ...createEmptyStats(),
-        })),
-        {
-            testResults: testResults.reduce((acc, testResult) => {
-                acc[testResult.historyId ?? testResult.id] = testResult;
-                return acc;
-            }, {}),
-            uuid: "current",
-            timestamp: currentReportTimestamp,
-            ...createEmptyStats(),
-        },
-    ];
-    dataPoints.forEach((dp, index, dps) => {
-        const { testResults: trs } = dp;
-        const historyAfter = dps.slice(index, dps.length - 1);
-        const currentTrs = Object.values(trs);
-        for (const cTr of currentTrs) {
-            const currentTrStatus = cTr.status;
+            const currentTrStatus = historicalTestResult.status;
             if (!isFBSUStatus(currentTrStatus)) {
                 continue;
             }
-            const historyAfterTrsStatuses = historyAfter.map((hdp) => hdp.testResults[cTr.historyId]?.status ?? undefined);
+            const historyAfterTrsStatuses = limitedHistoryPoints
+                .slice(index)
+                .map((historyAfterPoint) => lookupHistoryTestResult(historyAfterPoint, testResult)?.status);
             if (historyAfterTrsStatuses.some((status) => status !== currentTrStatus)) {
                 continue;
             }
-            dp[currentTrStatus]++;
+            stats[currentTrStatus]++;
         }
+        return {
+            id: historyDataPoint.uuid,
+            timestamp: historyDataPoint.timestamp,
+            failed: stats.failed,
+            broken: stats.broken,
+            skipped: stats.skipped,
+            unknown: stats.unknown,
+        };
+    });
+    const currentStats = createEmptyStats();
+    for (const testResult of testResults) {
+        if (isFBSUStatus(testResult.status)) {
+            currentStats[testResult.status]++;
+        }
+    }
+    data.push({
+        id: "current",
+        timestamp: currentReportTimestamp,
+        failed: currentStats.failed,
+        broken: currentStats.broken,
+        skipped: currentStats.skipped,
+        unknown: currentStats.unknown,
     });
-    const data = dataPoints.map(({ uuid, timestamp, ...stats }) => ({
-        id: uuid,
-        timestamp,
-        failed: stats.failed ?? 0,
-        broken: stats.broken ?? 0,
-        skipped: stats.skipped ?? 0,
-        unknown: stats.unknown ?? 0,
-    }));
     return {
         type: ChartType.StatusAgePyramid,
         title: options.title,

package/dist/charts/generateStatusTransitionsChart.js

@@ -1,5 +1,5 @@
 import { ChartType, DEFAULT_CHART_HISTORY_LIMIT, } from "@allurereport/charts-api";
-import { htrsByTr } from "@allurereport/core-api";
+import { createHistoryTestResultLookup, } from "@allurereport/core-api";
 import { limitHistoryDataPoints } from "./chart-utils.js";
 const getLastSignificantStatus = (history = []) => {
     const significantHtr = [...history]
@@ -31,6 +31,7 @@ export const generateStatusTransitionsChart = (props) => {
     const { options, storeData } = props;
     const { limit = DEFAULT_CHART_HISTORY_LIMIT } = options;
     const { historyDataPoints, testResults } = storeData;
+    const lookupHistoryTestResult = createHistoryTestResultLookup(storeData.allTestResults ?? testResults);
     const limitedHdps = limitHistoryDataPoints(historyDataPoints, limit).sort((a, b) => a.timestamp - b.timestamp);
     const currentReportTimestamp = testResults.reduce((acc, testResult) => Math.max(acc, testResult.stop ?? 0), 0);
     if (limitedHdps.length === 0) {
@@ -55,7 +56,7 @@ export const generateStatusTransitionsChart = (props) => {
         ...hdps,
         {
             testResults: testResults.reduce((acc, testResult) => {
-                acc[testResult.historyId ?? testResult.id] = testResult;
+                acc[testResult.retryHash ?? testResult.id] = testResult;
                 return acc;
             }, {}),
             uuid: "current",
@@ -73,9 +74,15 @@ export const generateStatusTransitionsChart = (props) => {
             malfunctioned: 0,
         };
         data.push(newDataItem);
-        const cTrs = Object.values(trs);
+        const cTrs = Object.values(trs).filter((tr) => {
+            const selected = lookupHistoryTestResult({ testResults: trs }, tr);
+            return !selected || selected === tr;
+        });
         for (const cTr of cTrs) {
-            const htrs = htrsByTr(hpsPriorToCurrent, cTr);
+            const htrs = hpsPriorToCurrent.flatMap((historyDataPoint) => {
+                const historicalTestResult = lookupHistoryTestResult(historyDataPoint, cTr);
+                return historicalTestResult ? [historicalTestResult] : [];
+            });
             const transition = getStatusTransition(cTr, htrs);
             if (!transition || transition === "new") {
                 continue;

package/dist/charts/generateTestBaseGrowthDynamicsChart.js

@@ -1,5 +1,5 @@
 import { ChartType, DEFAULT_CHART_HISTORY_LIMIT } from "@allurereport/charts-api";
-import { htrsByTr, statusesList } from "@allurereport/core-api";
+import { createHistoryTestResultLookup, statusesList, } from "@allurereport/core-api";
 import { limitHistoryDataPoints } from "./chart-utils.js";
 const createEmptyStats = (statuses) => {
     return statuses.reduce((acc, status) => {
@@ -13,6 +13,7 @@ export const generateTestBaseGrowthDynamicsChart = (props) => {
     const { options, storeData } = props;
     const { limit = DEFAULT_CHART_HISTORY_LIMIT, statuses = DEFAULT_STATUSES } = options;
     const { historyDataPoints, testResults } = storeData;
+    const lookupHistoryTestResult = createHistoryTestResultLookup(storeData.allTestResults ?? testResults);
     const currentReportTimestamp = testResults.reduce((acc, testResult) => Math.max(acc, testResult.stop ?? 0), 0);
     const statusList = statuses.length > 0 ? statuses : DEFAULT_STATUSES;
     const limitedHistoryPoints = limitHistoryDataPoints(historyDataPoints, limit).sort((a, b) => a.timestamp - b.timestamp);
@@ -38,7 +39,7 @@ export const generateTestBaseGrowthDynamicsChart = (props) => {
         })),
         {
             testResults: testResults.reduce((acc, testResult) => {
-                acc[testResult.historyId ?? testResult.id] = testResult;
+                acc[testResult.retryHash ?? testResult.id] = testResult;
                 return acc;
             }, {}),
             uuid: "current",
@@ -51,19 +52,28 @@ export const generateTestBaseGrowthDynamicsChart = (props) => {
         const isLast = index === dataPoints.length - 1;
         const hpsPriorToCurrent = isFirst ? [earliestHdp] : dataPoints.slice(0, index);
         const hpsAfterCurrent = dataPoints.slice(index + 1);
-        const currentTrs = Object.values(trs);
+        const currentTrs = Object.values(trs).filter((tr) => {
+            const selected = lookupHistoryTestResult({ testResults: trs }, tr);
+            return !selected || selected === tr;
+        });
         for (const cTr of currentTrs) {
             if (!statusList.includes(cTr.status)) {
                 continue;
             }
-            const htrsPriortoCurr = htrsByTr(hpsPriorToCurrent, cTr);
+            const htrsPriortoCurr = hpsPriorToCurrent.flatMap((historyDataPoint) => {
+                const historicalTestResult = lookupHistoryTestResult(historyDataPoint, cTr);
+                return historicalTestResult ? [historicalTestResult] : [];
+            });
             if (htrsPriortoCurr.length === 0) {
                 stats[`new:${cTr.status}`]++;
             }
             if (isLast) {
                 continue;
             }
-            const htrsAfterCurrent = htrsByTr(hpsAfterCurrent, cTr);
+            const htrsAfterCurrent = hpsAfterCurrent.flatMap((historyDataPoint) => {
+                const historicalTestResult = lookupHistoryTestResult(historyDataPoint, cTr);
+                return historicalTestResult ? [historicalTestResult] : [];
+            });
             if (htrsAfterCurrent.length === 0) {
                 stats[`removed:${cTr.status}`]++;
             }

package/dist/charts/generators.js

@@ -1,5 +1,5 @@
 import { ChartType, } from "@allurereport/charts-api";
-import { DEFAULT_ENVIRONMENT, emptyStatistic, getFallbackHistoryId, incrementStatistic, } from "@allurereport/core-api";
+import { DEFAULT_ENVIRONMENT, emptyStatistic, incrementStatistic, } from "@allurereport/core-api";
 import { generateCurrentStatusChart } from "./generateCurrentStatusChart.js";
 import { generateDurationDynamicsChart } from "./generateDurationDynamicsChart.js";
 import { generateDurationsChart } from "./generateDurationsChart.js";
@@ -12,60 +12,6 @@ import { generateTestingPyramidChart } from "./generateTestingPyramidChart.js";
 import { generateTrSeveritiesChart } from "./generateTrSeveritiesChart.js";
 import { generateHeatMapChart } from "./heatMap.js";
 import { generateTreeMapChart } from "./treeMap.js";
-const buildFallbackHistoryAliases = (testResults) => {
-    const aliases = new Map();
-    const ambiguousAliases = new Set();
-    for (const testResult of testResults) {
-        if (!testResult.historyId) {
-            continue;
-        }
-        const fallbackHistoryId = getFallbackHistoryId(testResult);
-        if (!fallbackHistoryId || fallbackHistoryId === testResult.historyId) {
-            continue;
-        }
-        const existingAlias = aliases.get(fallbackHistoryId);
-        if (existingAlias && existingAlias !== testResult.historyId) {
-            aliases.delete(fallbackHistoryId);
-            ambiguousAliases.add(fallbackHistoryId);
-            continue;
-        }
-        if (!ambiguousAliases.has(fallbackHistoryId)) {
-            aliases.set(fallbackHistoryId, testResult.historyId);
-        }
-    }
-    return aliases;
-};
-const normalizeHistoryDataPointsByAliases = (historyDataPoints, aliases) => {
-    if (aliases.size === 0) {
-        return historyDataPoints;
-    }
-    return historyDataPoints.map((historyDataPoint) => {
-        let testResults = historyDataPoint.testResults;
-        for (const [legacyHistoryId, primaryHistoryId] of aliases) {
-            if (!Object.prototype.hasOwnProperty.call(testResults, legacyHistoryId)) {
-                continue;
-            }
-            if (Object.prototype.hasOwnProperty.call(testResults, primaryHistoryId)) {
-                continue;
-            }
-            if (testResults === historyDataPoint.testResults) {
-                testResults = { ...testResults };
-            }
-            testResults[primaryHistoryId] = {
-                ...testResults[legacyHistoryId],
-                historyId: primaryHistoryId,
-            };
-            delete testResults[legacyHistoryId];
-        }
-        if (testResults === historyDataPoint.testResults) {
-            return historyDataPoint;
-        }
-        return {
-            ...historyDataPoint,
-            testResults,
-        };
-    });
-};
 const generateChartData = async (props) => {
     const { envId, chartsOptions, store, generateUuid, filter } = props;
     const result = {};
@@ -116,14 +62,17 @@ const generateChartData = async (props) => {
         }
         return statistic;
     };
-    const storeData = await Promise.all([getHistoryDataPoints(), getTrs(), getStatistic()]).then(([historyDataPoints, testResults, statistic]) => {
-        const fallbackHistoryAliases = buildFallbackHistoryAliases(testResults);
-        return {
-            historyDataPoints: normalizeHistoryDataPointsByAliases(historyDataPoints, fallbackHistoryAliases),
-            testResults,
-            statistic,
-        };
-    });
+    const storeData = await Promise.all([
+        getHistoryDataPoints(),
+        getTrs(),
+        getStatistic(),
+        store.allTestResults({ includeRetries: true }),
+    ]).then(([historyDataPoints, testResults, statistic, allTestResults]) => ({
+        historyDataPoints,
+        testResults,
+        statistic,
+        allTestResults,
+    }));
     for (const chartOption of chartsOptions) {
         const chartId = generateUuid();
         switch (chartOption.type) {

package/dist/strings.d.ts

@@ -10,5 +10,6 @@ export interface AnsiToHtmlConfig {
 }
 export declare const isAnsi: (text?: string) => boolean;
 export declare const ansiSemanticColors: Record<number, string>;
+export declare const normalizeEscapedAnsiSequences: (text: string) => string;
 export declare const normalizeAnsiForegroundColors: (text: string) => string;
 export declare const ansiToHTML: (text: string, config?: AnsiToHtmlConfig) => string;

package/dist/strings.js

@@ -1,5 +1,7 @@
 import AnsiToHtml from "ansi-to-html";
 const ansiRegex = /\x1B\[[0-9;?]*[ -/]*[@-~]/g;
+const ansiEscape = "\u001B";
+const ansiControlSequencePattern = new RegExp(`${ansiEscape}\\[([0-9;]*)m`, "g");
 export const isAnsi = (text) => typeof text === "string" && new RegExp(ansiRegex).test(text);
 const semanticAnsiColor = {
     primary: 256,
@@ -81,7 +83,8 @@ const getXtermColorRgb = (colorIndex) => {
     }
 };
 const isValidColorPart = (value) => Number.isInteger(value) && value >= 0 && value <= 255;
-export const normalizeAnsiForegroundColors = (text) => text.replace(/\x1b\[([0-9;]*)m/g, (match, sequence) => {
+export const normalizeEscapedAnsiSequences = (text) => text.replace(/\\u001b(?=\[)/giu, ansiEscape).replace(/\\x1b(?=\[)/giu, ansiEscape);
+export const normalizeAnsiForegroundColors = (text) => text.replace(ansiControlSequencePattern, (match, sequence) => {
     const codes = sequence.length === 0 ? [0] : sequence.split(";").map(Number);
     if (codes.some((code) => !Number.isInteger(code))) {
         return match;
@@ -114,8 +117,6 @@ export const normalizeAnsiForegroundColors = (text) => text.replace(/\x1b\[([0-9
             continue;
         }
         if (code === 48 && codes[index + 1] === 5 && isValidColorPart(codes[index + 2])) {
-            flushDisplayCodes();
-            fragments.push(`\x1b[48;5;${codes[index + 2]}m`);
             index += 3;
             continue;
         }
@@ -124,11 +125,13 @@ export const normalizeAnsiForegroundColors = (text) => text.replace(/\x1b\[([0-9
             isValidColorPart(codes[index + 2]) &&
             isValidColorPart(codes[index + 3]) &&
             isValidColorPart(codes[index + 4])) {
-            flushDisplayCodes();
-            fragments.push(`\x1b[48;2;${codes[index + 2]};${codes[index + 3]};${codes[index + 4]}m`);
             index += 5;
             continue;
         }
+        if ((code >= 40 && code <= 47) || code === 49 || (code >= 100 && code <= 107)) {
+            index += 1;
+            continue;
+        }
         displayCodes.push(code);
         index += 1;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/web-commons",
-  "version": "3.18.0",
+  "version": "3.19.1",
   "description": "Collection of utilities used across the web Allure reports",
   "keywords": [
     "allure",
@@ -26,10 +26,10 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/aql": "3.18.0",
-    "@allurereport/charts-api": "3.18.0",
-    "@allurereport/core-api": "3.18.0",
-    "@allurereport/plugin-api": "3.18.0",
+    "@allurereport/aql": "3.19.1",
+    "@allurereport/charts-api": "3.19.1",
+    "@allurereport/core-api": "3.19.1",
+    "@allurereport/plugin-api": "3.19.1",
     "@preact/signals": "^2.6.1",
     "@preact/signals-core": "^1.12.2",
     "ansi-to-html": "^0.7.2",