@allurereport/web-commons 3.17.0 → 3.19.0

package/dist/attachments.js

@@ -201,6 +201,7 @@ export const attachmentType = (type) => {
         case "image/jpeg":
         case "image/jpg":
         case "image/png":
+        case "image/webp":
         case "image/*":
             return "image";
         case "text/xml":

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/accessors/successRateDistributionTreeMapAccessor.d.ts

@@ -2,6 +2,7 @@ import type { TreeMapDataAccessor, TreeMapNode } from "@allurereport/charts-api"
 import type { TestResult } from "@allurereport/core-api";
 type SubtreeMetrics = {
     totalTests: number;
+    eligibleCount: number;
     passedTests: number;
     failedTests: number;
     otherTests: number;

package/dist/charts/accessors/successRateDistributionTreeMapAccessor.js

@@ -1,3 +1,4 @@
+import { getSuccessRate, includedInSuccessRate } from "@allurereport/core-api";
 import { createTreeByLabels, md5 } from "@allurereport/plugin-api";
 import { isChildrenLeavesOnly } from "../chart-utils.js";
 import { convertTreeDataToTreeMapNode, transformTreeMapNode } from "../treeMapUtils.js";
@@ -11,6 +12,7 @@ const leafFactoryFn = ({ id, name, status }) => ({
 const groupFactoryFn = (parentId, groupClassifier) => ({
     nodeId: md5((parentId ? `${parentId}.` : "") + groupClassifier),
     name: groupClassifier,
+    eligibleCount: 0,
     value: 0,
     passedTests: 0,
     failedTests: 0,
@@ -18,34 +20,36 @@ const groupFactoryFn = (parentId, groupClassifier) => ({
 });
 const addLeafToGroupFn = (group, leaf) => {
     group.value += leaf.value;
+    group.eligibleCount += includedInSuccessRate.has(leaf.status) ? 1 : 0;
     group.passedTests += leaf.status === "passed" ? 1 : 0;
     group.failedTests += leaf.status === "failed" ? 1 : 0;
     group.otherTests += leaf?.status && !["passed", "failed"].includes(leaf.status) ? 1 : 0;
 };
-const calculateColorValue = ({ totalTests, passedTests }) => {
-    return totalTests > 0 ? passedTests / totalTests : 0;
-};
+const calculateColorValue = ({ eligibleCount, passedTests }) => getSuccessRate({ passed: passedTests, failed: eligibleCount - passedTests });
 const calculateSubtreeMetrics = (node) => {
     if (!node.children || node.children.length === 0) {
         return {
-            totalTests: 1,
+            totalTests: node.status ? 1 : 0,
+            eligibleCount: node.status && includedInSuccessRate.has(node.status) ? 1 : 0,
             passedTests: node?.status === "passed" ? 1 : 0,
             failedTests: node?.status === "failed" ? 1 : 0,
             otherTests: node?.status && !["passed", "failed"].includes(node.status) ? 1 : 0,
         };
     }
     let totalTests = 0;
+    let eligibleCount = 0;
     let passedTests = 0;
     let failedTests = 0;
     let otherTests = 0;
     for (const child of node.children) {
         const childMetrics = calculateSubtreeMetrics(child);
         totalTests += childMetrics.totalTests;
+        eligibleCount += childMetrics.eligibleCount;
         passedTests += childMetrics.passedTests;
         failedTests += childMetrics.failedTests;
         otherTests += childMetrics.otherTests;
     }
-    return { totalTests, passedTests, failedTests, otherTests };
+    return { totalTests, eligibleCount, passedTests, failedTests, otherTests };
 };
 export const createSuccessRateDistributionTreeMap = (testResults) => {
     const treeByLabels = createTreeByLabels(testResults, behaviorLabels, leafFactoryFn, groupFactoryFn, addLeafToGroupFn);
@@ -58,6 +62,7 @@ export const createSuccessRateDistributionTreeMap = (testResults) => {
             const group = node;
             return {
                 ...baseNode,
+                eligibleCount: group.eligibleCount,
                 passedTests: group.passedTests,
                 failedTests: group.failedTests,
                 otherTests: group.otherTests,
@@ -68,6 +73,7 @@ export const createSuccessRateDistributionTreeMap = (testResults) => {
             return {
                 ...baseNode,
                 status: leaf.status,
+                eligibleCount: includedInSuccessRate.has(leaf.status) ? 1 : 0,
                 passedTests: leaf?.status === "passed" ? 1 : 0,
                 failedTests: leaf?.status === "failed" ? 1 : 0,
                 otherTests: leaf?.status && !["passed", "failed"].includes(leaf.status) ? 1 : 0,
@@ -75,6 +81,7 @@ export const createSuccessRateDistributionTreeMap = (testResults) => {
         }
     }, () => ({
         id: "root",
+        eligibleCount: 0,
         passedTests: 0,
         failedTests: 0,
         otherTests: 0,
@@ -82,7 +89,7 @@ export const createSuccessRateDistributionTreeMap = (testResults) => {
     return transformTreeMapNode(convertedTree, (node) => {
         const subtreeMetrics = calculateSubtreeMetrics(node);
         const colorValue = calculateColorValue(subtreeMetrics);
-        const { totalTests, ...restSubtreeMetrics } = subtreeMetrics;
+        const { totalTests: _totalTests, ...restSubtreeMetrics } = subtreeMetrics;
         if (isChildrenLeavesOnly(node)) {
             const value = node.children?.reduce((acc, child) => {
                 return acc + (child.value ?? 0);

package/dist/charts/d3pie.js

@@ -1,6 +1,5 @@
-import { statusesList } from "@allurereport/core-api";
+import { getSuccessRate, statusesList } from "@allurereport/core-api";
 import { arc, pie } from "d3-shape";
-const getPercentage = (value, total) => Math.floor((value / total) * 10000) / 100;
 const createD3ArcGenerator = () => arc().innerRadius(40).outerRadius(50).cornerRadius(2).padAngle(0.03);
 const d3Pie = pie()
     .value((d) => d.count)
@@ -44,7 +43,7 @@ export const getPieChartValues = (stats) => {
         };
     })
         .filter((item) => item !== null);
-    const percentage = getPercentage(stats.passed ?? 0, stats.total);
+    const percentage = Math.floor(getSuccessRate(stats) * 10000) / 100;
     return {
         slices,
         percentage,

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/generateTestingPyramidChart.js

@@ -1,4 +1,5 @@
 import { ChartType } from "@allurereport/charts-api";
+import { emptyStatistic, getSuccessRate, getSuccessRateTotal, incrementStatistic, } from "@allurereport/core-api";
 const DEFAULT_LAYERS = ["unit", "integration", "e2e"];
 const getPercentage = (value, total) => {
     if (total === 0 || value === 0) {
@@ -14,13 +15,7 @@ export const generateTestingPyramidChart = (chartOptions, storeData) => {
         layersMap.set(layer, layer);
         layersMap.set(layer.toLocaleLowerCase(), layer);
     });
-    const statsByLayers = new Map();
-    layers.forEach((layer) => {
-        statsByLayers.set(layer, {
-            passed: 0,
-            total: 0,
-        });
-    });
+    const statsByLayers = new Map(layers.map((layer) => [layer, emptyStatistic()]));
     for (const testResult of testResults) {
         const trLayer = testResult.labels.find((label) => label.name === "layer")?.value;
         if (!trLayer) {
@@ -31,10 +26,7 @@ export const generateTestingPyramidChart = (chartOptions, storeData) => {
             continue;
         }
         const data = statsByLayers.get(layer);
-        data.total++;
-        if (testResult.status === "passed") {
-            data.passed++;
-        }
+        incrementStatistic(data, testResult.status);
     }
     return {
         type: ChartType.TestingPyramid,
@@ -44,7 +36,8 @@ export const generateTestingPyramidChart = (chartOptions, storeData) => {
             return {
                 layer,
                 testCount: data.total,
-                successRate: getPercentage(data.passed, data.total),
+                successRate: Math.floor(getSuccessRate(data) * 10000) / 100,
+                eligibleCount: getSuccessRateTotal(data),
                 percentage: getPercentage(data.total, testResults.length),
             };
         }),

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/clipboard.d.ts

@@ -0,0 +1 @@
+export declare const copyToClipboard: (text: string) => Promise<boolean>;

package/dist/clipboard.js

@@ -0,0 +1,21 @@
+export const copyToClipboard = async (text) => {
+    try {
+        if (navigator.clipboard) {
+            await navigator.clipboard.writeText(text);
+            return true;
+        }
+        const textarea = document.createElement("textarea");
+        textarea.value = text;
+        textarea.style.position = "fixed";
+        textarea.style.opacity = "0";
+        document.body.appendChild(textarea);
+        textarea.focus();
+        textarea.select();
+        document.execCommand("copy");
+        document.body.removeChild(textarea);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};

package/dist/filters/builders.js

@@ -44,6 +44,12 @@ const buildAqlFromFieldFilter = (field) => {
             valueType = "STRING";
             break;
         }
+        case "null": {
+            expressionValue = "null";
+            valueType = "NULL";
+            operator = "EQ";
+            break;
+        }
         default: {
             const exhaustiveCheck = type;
             throw new Error(`Unsupported field type: ${String(exhaustiveCheck)}`);

package/dist/filters/index.d.ts

@@ -1,3 +1,3 @@
 export * from "./builders.js";
-export type { ArrayField, BooleanField, Field, FieldFilter, FieldFilterGroup, Filter, LogicalOperator, NumberField, StringField, } from "./model.js";
+export type { ArrayField, BooleanField, Field, FieldFilter, FieldFilterGroup, Filter, LogicalOperator, NullField, NumberField, StringField, } from "./model.js";
 export { MAX_ARRAY_FIELD_VALUES } from "./model.js";

package/dist/filters/model.d.ts

@@ -27,13 +27,19 @@ export type BooleanField<T extends string = string> = {
     strict?: never;
     type: "boolean";
 };
+export type NullField<T extends string = string> = {
+    key: T;
+    value: null;
+    strict?: never;
+    type: "null";
+};
 export type ArrayField<T extends string = string> = {
     key: T;
     value: string[];
     strict?: boolean;
     type: "array";
 };
-export type Field<T extends string = string> = StringField<T> | NumberField<T> | BooleanField<T> | ArrayField<T>;
+export type Field<T extends string = string> = StringField<T> | NumberField<T> | BooleanField<T> | ArrayField<T> | NullField<T>;
 export type LogicalOperator = "AND" | "OR";
-export type AqlValueType = "STRING" | "NUMBER" | "BOOLEAN";
+export type AqlValueType = "STRING" | "NUMBER" | "BOOLEAN" | "NULL";
 export declare const MAX_ARRAY_FIELD_VALUES = 20;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./data.js";
 export * from "./attachments.js";
+export * from "./clipboard.js";
 export * from "./environments.js";
 export * from "./i18n.js";
 export * from "./charts/index.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from "./data.js";
 export * from "./attachments.js";
+export * from "./clipboard.js";
 export * from "./environments.js";
 export * from "./i18n.js";
 export * from "./charts/index.js";

package/dist/treeNavigation/scrollTreeFocus.d.ts

@@ -12,3 +12,7 @@ export declare const scrollFocusIntoView: (target: HTMLElement, options?: {
     inset?: number;
 }) => void;
 export declare const scrollTreePaneToTop: (anchor?: HTMLElement | null) => void;
+export declare const isFocusInView: (target: HTMLElement, options?: {
+    containerAttribute?: string;
+    inset?: number;
+}) => boolean;

package/dist/treeNavigation/scrollTreeFocus.js

@@ -80,3 +80,10 @@ export const scrollTreePaneToTop = (anchor) => {
         }
     }
 };
+export const isFocusInView = (target, options) => {
+    const containerAttribute = options?.containerAttribute ?? "data-tree-scroll-container";
+    const scrollRoot = findFocusScrollRoot(target, containerAttribute);
+    const rootRect = scrollRoot ? scrollRoot.getBoundingClientRect() : { top: 0, bottom: window.innerHeight };
+    const inset = scrollRoot ? computeStickyInset(scrollRoot, options?.inset ?? 4) : (options?.inset ?? 4);
+    return !isOutOfScrollport(target.getBoundingClientRect(), rootRect, inset);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/web-commons",
-  "version": "3.17.0",
+  "version": "3.19.0",
   "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.17.0",
-    "@allurereport/charts-api": "3.17.0",
-    "@allurereport/core-api": "3.17.0",
-    "@allurereport/plugin-api": "3.17.0",
+    "@allurereport/aql": "3.19.0",
+    "@allurereport/charts-api": "3.19.0",
+    "@allurereport/core-api": "3.19.0",
+    "@allurereport/plugin-api": "3.19.0",
     "@preact/signals": "^2.6.1",
     "@preact/signals-core": "^1.12.2",
     "ansi-to-html": "^0.7.2",
@@ -37,7 +37,7 @@
     "d3-scale": "^4.0.2",
     "d3-shape": "^3.2.0",
     "dompurify": "^3.4.0",
-    "nanoid": "^5.1.6"
+    "nanoid": "^5.1.16"
   },
   "devDependencies": {
     "@types/d3-interpolate": "^3.0.4",