@allurereport/plugin-api 3.0.0-beta.17 → 3.0.0-beta.19

package/dist/charts/accessors/coverageDiffTreeMapAccessor.d.ts

@@ -0,0 +1,17 @@
+import type { TreeMapNode } from "@allurereport/core-api";
+import type { TreeMapDataAccessor } from "../../charts.js";
+type ChangeType = "new" | "deleted" | "enabled" | "disabled" | "unchanged";
+type SubtreeMetrics = {
+    totalTests: number;
+    newCount: number;
+    deletedCount: number;
+    disabledCount: number;
+    enabledCount: number;
+};
+type LeafMetrics = {
+    changeType: ChangeType;
+};
+type GroupMetrics = Omit<SubtreeMetrics, "totalTests">;
+type ExtendedTreeMapNode = TreeMapNode<GroupMetrics & Partial<LeafMetrics>>;
+export declare const coverageDiffTreeMapAccessor: TreeMapDataAccessor<ExtendedTreeMapNode>;
+export {};

package/dist/charts/accessors/coverageDiffTreeMapAccessor.js

@@ -0,0 +1,181 @@
+import { isChildrenLeavesOnly } from "../../charts.js";
+import { md5 } from "../../utils/misc.js";
+import { createTreeByLabels } from "../../utils/tree.js";
+import { convertTreeDataToTreeMapNode, transformTreeMapNode } from "../treeMap.js";
+import { behaviorLabels, filterTestsWithBehaviorLabels } from "./utils/behavior.js";
+const groupFactoryFn = (parentId, groupClassifier) => ({
+    nodeId: md5((parentId ? `${parentId}.` : "") + groupClassifier),
+    name: groupClassifier,
+    value: 0,
+    newCount: 0,
+    deletedCount: 0,
+    disabledCount: 0,
+    enabledCount: 0,
+});
+const addLeafToGroupFn = (group, leaf) => {
+    group.value += leaf.value;
+    switch (leaf.changeType) {
+        case "new":
+            group.newCount++;
+            break;
+        case "deleted":
+            group.deletedCount++;
+            break;
+        case "enabled":
+            group.enabledCount++;
+            break;
+        case "disabled":
+            group.disabledCount++;
+            break;
+    }
+};
+const calculateColorValue = (metrics) => {
+    const netChange = metrics.newCount + metrics.enabledCount - (metrics.deletedCount + metrics.disabledCount);
+    const normalizedChange = netChange / metrics.totalTests;
+    return Math.max(0, Math.min(1, (normalizedChange + 1) / 2));
+};
+const isSkipped = (tr) => tr.status === "skipped";
+const getNewTestResults = (trs, closestHtrs) => {
+    return trs.filter((tr) => !closestHtrs[tr.historyId]);
+};
+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 getEnabledTestResults = (trs, closestHtrs) => {
+    return trs.filter((tr) => {
+        const historyPointTestResult = closestHtrs[tr.historyId];
+        return historyPointTestResult && isSkipped(historyPointTestResult) && !isSkipped(tr);
+    });
+};
+const getDisabledTestResults = (trs, closestHtrs) => {
+    return trs.filter((tr) => {
+        const historyPointTestResult = closestHtrs[tr.historyId];
+        return historyPointTestResult && !isSkipped(historyPointTestResult) && isSkipped(tr);
+    });
+};
+const calculateSubtreeMetrics = (node) => {
+    if (!node.children || node.children.length === 0) {
+        const changeType = node?.changeType;
+        return {
+            totalTests: 1,
+            newCount: changeType === "new" ? 1 : 0,
+            deletedCount: changeType === "deleted" ? 1 : 0,
+            disabledCount: changeType === "disabled" ? 1 : 0,
+            enabledCount: changeType === "enabled" ? 1 : 0,
+        };
+    }
+    let totalTests = 0;
+    let newCount = 0;
+    let deletedCount = 0;
+    let disabledCount = 0;
+    let enabledCount = 0;
+    for (const child of node.children) {
+        const childMetrics = calculateSubtreeMetrics(child);
+        totalTests += childMetrics.totalTests;
+        newCount += childMetrics.newCount;
+        deletedCount += childMetrics.deletedCount;
+        disabledCount += childMetrics.disabledCount;
+        enabledCount += childMetrics.enabledCount;
+    }
+    return { totalTests, newCount, deletedCount, disabledCount, enabledCount };
+};
+const createCoverageDiffTreeMap = (trs, closestHtrs) => {
+    const newTrs = getNewTestResults(trs, closestHtrs);
+    const removedHtrs = getRemovedTestResults(trs, closestHtrs);
+    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 allTests = [...trs, ...removedHtrs];
+    const getChangeType = (historyId) => {
+        if (newTestsById.has(historyId)) {
+            return "new";
+        }
+        if (deletedTestsById.has(historyId)) {
+            return "deleted";
+        }
+        if (enabledTestsById.has(historyId)) {
+            return "enabled";
+        }
+        if (disabledTestsById.has(historyId)) {
+            return "disabled";
+        }
+        return "unchanged";
+    };
+    const leafFactoryFnWithMaps = (test) => {
+        const changeType = getChangeType(test.historyId);
+        return {
+            nodeId: test.id,
+            name: test.name,
+            value: 1,
+            changeType,
+        };
+    };
+    const treeByLabels = createTreeByLabels(allTests, behaviorLabels, leafFactoryFnWithMaps, groupFactoryFn, addLeafToGroupFn);
+    const convertedTree = convertTreeDataToTreeMapNode(treeByLabels, (node, isGroup) => {
+        const baseNode = {
+            id: node.name,
+            value: isGroup ? undefined : node.value,
+        };
+        if (isGroup) {
+            const group = node;
+            return {
+                ...baseNode,
+                newCount: group.newCount,
+                deletedCount: group.deletedCount,
+                disabledCount: group.disabledCount,
+                enabledCount: group.enabledCount,
+            };
+        }
+        else {
+            const leaf = node;
+            return {
+                ...baseNode,
+                changeType: leaf.changeType,
+                newCount: leaf.changeType === "new" ? 1 : 0,
+                deletedCount: leaf.changeType === "deleted" ? 1 : 0,
+                disabledCount: leaf.changeType === "disabled" ? 1 : 0,
+                enabledCount: leaf.changeType === "enabled" ? 1 : 0,
+            };
+        }
+    }, () => ({
+        id: "root",
+        newCount: 0,
+        deletedCount: 0,
+        disabledCount: 0,
+        enabledCount: 0,
+    }));
+    return transformTreeMapNode(convertedTree, (node) => {
+        const subtreeMetrics = calculateSubtreeMetrics(node);
+        const colorValue = calculateColorValue(subtreeMetrics);
+        const { totalTests, ...restSubtreeMetrics } = subtreeMetrics;
+        if (isChildrenLeavesOnly(node)) {
+            return {
+                ...node,
+                value: totalTests,
+                children: undefined,
+                colorValue,
+                ...restSubtreeMetrics,
+            };
+        }
+        return {
+            ...node,
+            colorValue,
+            ...restSubtreeMetrics,
+        };
+    });
+};
+export const coverageDiffTreeMapAccessor = {
+    getTreeMap: ({ testResults, historyDataPoints }) => {
+        const testsWithBehaviorLabels = filterTestsWithBehaviorLabels(testResults);
+        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);
+    },
+};

package/dist/charts/accessors/problemsDistributionHeatMap.d.ts

@@ -0,0 +1,2 @@
+import type { HeatMapDataAccessor } from "../../charts.js";
+export declare const problemsDistributionHeatMapAccessor: HeatMapDataAccessor;

package/dist/charts/accessors/problemsDistributionHeatMap.js

@@ -0,0 +1,65 @@
+import { filterIncludedInSuccessRate } from "@allurereport/core-api";
+const groupTestsByEnvironment = (testResults) => {
+    return testResults.reduce((acc, testResult) => {
+        const key = testResult.environment;
+        if (key) {
+            const bucket = acc[key] || (acc[key] = []);
+            bucket.push(testResult);
+        }
+        return acc;
+    }, {});
+};
+const groupByExactLabel = (testResults, labelNames) => {
+    return testResults.reduce((acc, testResult) => {
+        const labels = testResult.labels;
+        if (!labels) {
+            return acc;
+        }
+        for (const label of labels) {
+            const key = label.value;
+            if (labelNames.includes(label.name) && key) {
+                const bucket = acc[key] || (acc[key] = []);
+                bucket.push(testResult);
+            }
+        }
+        return acc;
+    }, {});
+};
+const makeHeatMapSerie = (env, testResults) => {
+    const testResultsByExactLabel = groupByExactLabel(testResults, ["feature"]);
+    const data = [];
+    for (const [labelValue, testsByLabelValue] of Object.entries(testResultsByExactLabel)) {
+        const testsTotal = testsByLabelValue.length;
+        const totalNegative = testsByLabelValue.reduce((acc, test) => acc + (test.status !== "passed" ? 1 : 0), 0);
+        data.push({
+            x: labelValue,
+            y: totalNegative / testsTotal,
+        });
+    }
+    return {
+        id: env,
+        data: data.sort((a, b) => (a.y || 0) - (b.y || 0)),
+    };
+};
+const makeHeatMapData = (testsByEnvironment) => {
+    return Object.entries(testsByEnvironment).map(([env, tests]) => makeHeatMapSerie(env, tests));
+};
+const filterTestResultsBySignificantStatus = (testResults) => {
+    return testResults.filter(filterIncludedInSuccessRate);
+};
+const filterTestResultsByLabelNames = (testResults, labelNames) => {
+    return testResults.filter((test) => test.labels?.some((l) => labelNames.includes(l.name)));
+};
+export const problemsDistributionHeatMapAccessor = {
+    getHeatMap: ({ testResults }) => {
+        const filteredTestResults = filterTestResultsBySignificantStatus(filterTestResultsByLabelNames(testResults, ["feature"]));
+        const testsResultsByEnvironment = groupTestsByEnvironment(filteredTestResults);
+        const data = makeHeatMapData(testsResultsByEnvironment);
+        const totals = new Map();
+        for (const serie of data) {
+            const total = serie.data.reduce((acc, sd) => acc + (sd.y || 0), 0);
+            totals.set(serie.id, total);
+        }
+        return data.sort((a, b) => totals.get(a.id) - totals.get(b.id));
+    },
+};

package/dist/charts/accessors/severityTrendAccessor.d.ts

@@ -0,0 +1,3 @@
+import type { SeverityLevel } from "@allurereport/core-api";
+import type { TrendDataAccessor } from "../../charts.js";
+export declare const severityTrendDataAccessor: TrendDataAccessor<SeverityLevel>;

package/dist/charts/accessors/severityTrendAccessor.js

@@ -0,0 +1,21 @@
+import { severityLabelName, severityLevels } from "@allurereport/core-api";
+import { createEmptyStats } from "../../charts.js";
+const processTestResults = (testResults) => {
+    return testResults.reduce((acc, test) => {
+        const severityLabel = test.labels?.find((label) => label.name === severityLabelName);
+        const severity = severityLabel?.value?.toLowerCase();
+        if (severity) {
+            acc[severity] = (acc[severity] ?? 0) + 1;
+        }
+        return acc;
+    }, createEmptyStats(severityLevels));
+};
+export const severityTrendDataAccessor = {
+    getCurrentData: ({ testResults }) => {
+        return processTestResults(testResults);
+    },
+    getHistoricalData: (historyPoint) => {
+        return processTestResults(Object.values(historyPoint.testResults));
+    },
+    getAllValues: () => severityLevels,
+};

package/dist/charts/accessors/statusBySeverityBarAccessor.d.ts

@@ -0,0 +1,3 @@
+import type { SeverityLevel, TestStatus } from "@allurereport/core-api";
+import type { BarDataAccessor } from "../../charts.js";
+export declare const statusBySeverityBarDataAccessor: BarDataAccessor<SeverityLevel, TestStatus>;

package/dist/charts/accessors/statusBySeverityBarAccessor.js

@@ -0,0 +1,33 @@
+import { BarGroupMode, severityLabelName, severityLevels, statusesList } from "@allurereport/core-api";
+const processTestResults = (testResults) => {
+    const resultMap = {
+        blocker: undefined,
+        critical: undefined,
+        normal: undefined,
+        minor: undefined,
+        trivial: undefined,
+    };
+    severityLevels.forEach((severity) => {
+        resultMap[severity] = statusesList.reduce((acc, status) => ({ ...acc, [status]: 0 }), {});
+    });
+    testResults.forEach((test) => {
+        const severityLabel = test.labels?.find((label) => label.name === severityLabelName);
+        const severity = severityLabel?.value?.toLowerCase();
+        if (severity && resultMap[severity]) {
+            resultMap[severity][test.status] = (resultMap[severity][test.status] ?? 0) + 1;
+        }
+    });
+    return Object.entries(resultMap).reduce((acc, [severity, values]) => {
+        if (values) {
+            acc.push({ groupId: severity, ...values });
+        }
+        return acc;
+    }, []);
+};
+export const statusBySeverityBarDataAccessor = {
+    getItems: ({ testResults }) => {
+        return processTestResults(testResults);
+    },
+    getGroupKeys: () => statusesList,
+    getGroupMode: () => BarGroupMode.Grouped,
+};

package/dist/charts/accessors/statusChangeTrendBarAccessor.d.ts

@@ -0,0 +1,4 @@
+import type { NewKey, RemovedKey, TestStatus } from "@allurereport/core-api";
+import { type BarDataAccessor } from "../../charts.js";
+export type StatusChangeTrendKeys = NewKey<TestStatus> | RemovedKey<TestStatus>;
+export declare const statusChangeTrendBarAccessor: BarDataAccessor<string, StatusChangeTrendKeys>;

package/dist/charts/accessors/statusChangeTrendBarAccessor.js

@@ -0,0 +1,92 @@
+import { BarGroupMode, capitalize } from "@allurereport/core-api";
+import { createEmptyStats } from "../../charts.js";
+const newGroupKeys = ["newPassed", "newFailed", "newBroken", "newSkipped", "newUnknown"];
+const removedGroupKeys = [
+    "removedPassed",
+    "removedFailed",
+    "removedBroken",
+    "removedSkipped",
+    "removedUnknown",
+];
+const groupKeys = [...newGroupKeys, ...removedGroupKeys];
+const getNewKey = (status) => {
+    const capitalizedStatus = capitalize(status);
+    return capitalizedStatus ? `new${capitalizedStatus}` : undefined;
+};
+const getRemovedKey = (status) => {
+    const capitalizedStatus = capitalize(status);
+    return capitalizedStatus ? `removed${capitalizedStatus}` : undefined;
+};
+const isHistoryIdIn = (trs, historyId) => {
+    return trs.some((tr) => tr.historyId === historyId);
+};
+const getDeletedFrom = (trs, hdpTrs) => {
+    const stats = createEmptyStats(groupKeys);
+    for (const hdpTr of hdpTrs) {
+        if (!isHistoryIdIn(trs, hdpTr.historyId)) {
+            const key = getRemovedKey(hdpTr.status);
+            if (key) {
+                stats[key]--;
+            }
+        }
+    }
+    return stats;
+};
+const getNewFrom = (trs, hdpTrs) => {
+    const stats = createEmptyStats(groupKeys);
+    for (const tr of trs) {
+        if (!isHistoryIdIn(hdpTrs, tr.historyId)) {
+            const key = getNewKey(tr.status);
+            if (key) {
+                stats[key]++;
+            }
+        }
+    }
+    return stats;
+};
+const getPointStats = (currentTrs, hdpTrs) => {
+    const emptyStats = createEmptyStats(groupKeys);
+    const newStats = getNewFrom(currentTrs, hdpTrs);
+    const deletedStats = getDeletedFrom(currentTrs, hdpTrs);
+    return Object.keys(emptyStats).reduce((acc, key) => {
+        const newStat = newStats[key] ?? 0;
+        const deletedStat = deletedStats[key] ?? 0;
+        acc[key] = newStat + deletedStat;
+        return acc;
+    }, {});
+};
+const getCurrentStats = (testResults, hdpTrs) => {
+    return {
+        groupId: "current",
+        ...getPointStats(testResults, hdpTrs),
+    };
+};
+const getHistoricalStats = (hdps) => {
+    const trendData = [];
+    for (let i = 0; i < hdps.length; i++) {
+        const currentHdp = hdps[i];
+        const currentHdpTrs = Object.values(currentHdp.testResults);
+        const previousHdpTrs = i + 1 < hdps.length ? Object.values(hdps[i + 1].testResults) : [];
+        trendData.push({
+            groupId: `Point ${hdps.length - i - 1}`,
+            ...getPointStats(currentHdpTrs, previousHdpTrs),
+        });
+    }
+    return trendData;
+};
+const getTrendData = (currentTrs, hdps) => {
+    const historicalStats = getHistoricalStats(hdps);
+    const currentStats = getCurrentStats(currentTrs, Object.values(hdps[0].testResults));
+    return [currentStats, ...historicalStats];
+};
+export const statusChangeTrendBarAccessor = {
+    getItems: ({ testResults }, limitedHdps, isFullHistory) => {
+        let trendData = getTrendData(testResults, limitedHdps);
+        if (!isFullHistory) {
+            trendData = trendData.slice(0, -1);
+        }
+        return trendData.reverse();
+    },
+    getGroupKeys: () => groupKeys,
+    getGroupMode: () => BarGroupMode.Stacked,
+};

package/dist/charts/accessors/statusTrendAccessor.d.ts

@@ -0,0 +1,3 @@
+import type { TestStatus } from "@allurereport/core-api";
+import type { TrendDataAccessor } from "../../charts.js";
+export declare const statusTrendDataAccessor: TrendDataAccessor<TestStatus>;

package/dist/charts/accessors/statusTrendAccessor.js

@@ -0,0 +1,19 @@
+import { statusesList } from "@allurereport/core-api";
+import { createEmptyStats } from "../../charts.js";
+export const statusTrendDataAccessor = {
+    getCurrentData: ({ statistic }) => {
+        return {
+            ...createEmptyStats(statusesList),
+            ...statistic,
+        };
+    },
+    getHistoricalData: (historyPoint) => {
+        return Object.values(historyPoint.testResults).reduce((stat, test) => {
+            if (test.status) {
+                stat[test.status] = (stat[test.status] ?? 0) + 1;
+            }
+            return stat;
+        }, createEmptyStats(statusesList));
+    },
+    getAllValues: () => statusesList,
+};

package/dist/charts/accessors/statusTrendBarAccessor.d.ts

@@ -0,0 +1,5 @@
+import type { TestStatus } from "@allurereport/core-api";
+import { type BarDataAccessor } from "../../charts.js";
+type TrendKey = Extract<TestStatus, "passed" | "failed" | "broken">;
+export declare const statusTrendBarAccessor: BarDataAccessor<string, TrendKey>;
+export {};

package/dist/charts/accessors/statusTrendBarAccessor.js

@@ -0,0 +1,63 @@
+import { BarGroupMode, htrsByTr } from "@allurereport/core-api";
+import { createEmptyStats } from "../../charts.js";
+const groupKeys = ["passed", "failed", "broken"];
+const isGroupKey = (key) => groupKeys.includes(key);
+const getSignedValueByStatus = (status) => (status === "passed" ? 1 : -1);
+const hasSignificantStatus = (htr) => isGroupKey(htr.status);
+const getLastSignificantStatus = (history = []) => {
+    const significantHtr = history.find(hasSignificantStatus);
+    return significantHtr?.status;
+};
+const isDifferentStatuses = (currentStatus, lastSignificantStatus) => {
+    return (!!lastSignificantStatus &&
+        isGroupKey(currentStatus) &&
+        isGroupKey(lastSignificantStatus) &&
+        currentStatus !== lastSignificantStatus);
+};
+const getPointStats = (currentTrs, hdps) => {
+    const stats = createEmptyStats(groupKeys);
+    for (const tr of currentTrs) {
+        const htrs = htrsByTr(hdps, tr);
+        const currentStatus = tr.status;
+        const lastSignificantStatus = getLastSignificantStatus(htrs);
+        if (isDifferentStatuses(currentStatus, lastSignificantStatus)) {
+            stats[currentStatus] = stats[currentStatus] + getSignedValueByStatus(currentStatus);
+        }
+    }
+    return stats;
+};
+const getCurrentStats = (testResults, hdps) => {
+    return {
+        groupId: "current",
+        ...getPointStats(testResults, hdps),
+    };
+};
+const getHistoricalStats = (hdps) => {
+    const trendData = [];
+    for (let i = 0; i < hdps.length; i++) {
+        const currentHdp = hdps[i];
+        const currentHdpTrs = Object.values(currentHdp.testResults);
+        const restHdps = i + 1 < hdps.length ? hdps.slice(i + 1, hdps.length) : [];
+        trendData.push({
+            groupId: `Point ${hdps.length - i - 1}`,
+            ...getPointStats(currentHdpTrs, restHdps),
+        });
+    }
+    return trendData;
+};
+const getTrendData = (currentTrs, hdps) => {
+    const historicalStats = getHistoricalStats(hdps);
+    const currentStats = getCurrentStats(currentTrs, hdps);
+    return [currentStats, ...historicalStats];
+};
+export const statusTrendBarAccessor = {
+    getItems: ({ testResults }, limitedHdps, isFullHistory) => {
+        let trendData = getTrendData(testResults, limitedHdps);
+        if (!isFullHistory) {
+            trendData = trendData.slice(0, -1);
+        }
+        return trendData.reverse();
+    },
+    getGroupKeys: () => groupKeys,
+    getGroupMode: () => BarGroupMode.Stacked,
+};

package/dist/charts/accessors/successRateDistributionTreeMapAccessor.d.ts

@@ -0,0 +1,14 @@
+import type { TestResult, TreeMapNode } from "@allurereport/core-api";
+import type { TreeMapDataAccessor } from "../../charts.js";
+type SubtreeMetrics = {
+    totalTests: number;
+    passedTests: number;
+    failedTests: number;
+    otherTests: number;
+};
+type LeafMetrics = Pick<TestResult, "status">;
+type GroupMetrics = Omit<SubtreeMetrics, "totalTests">;
+type ExtendedTreeMapNode = TreeMapNode<GroupMetrics & Partial<LeafMetrics>>;
+export declare const createSuccessRateDistributionTreeMap: (testResults: TestResult[]) => ExtendedTreeMapNode;
+export declare const successRateDistributionTreeMapAccessor: TreeMapDataAccessor<ExtendedTreeMapNode>;
+export {};

package/dist/charts/accessors/successRateDistributionTreeMapAccessor.js

@@ -0,0 +1,111 @@
+import { isChildrenLeavesOnly } from "../../charts.js";
+import { md5 } from "../../utils/misc.js";
+import { createTreeByLabels } from "../../utils/tree.js";
+import { convertTreeDataToTreeMapNode, transformTreeMapNode } from "../treeMap.js";
+import { behaviorLabels, filterTestsWithBehaviorLabels } from "./utils/behavior.js";
+const leafFactoryFn = ({ id, name, status }) => ({
+    nodeId: id,
+    name,
+    status,
+    value: 1,
+});
+const groupFactoryFn = (parentId, groupClassifier) => ({
+    nodeId: md5((parentId ? `${parentId}.` : "") + groupClassifier),
+    name: groupClassifier,
+    value: 0,
+    passedTests: 0,
+    failedTests: 0,
+    otherTests: 0,
+});
+const addLeafToGroupFn = (group, leaf) => {
+    group.value += leaf.value;
+    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 calculateSubtreeMetrics = (node) => {
+    if (!node.children || node.children.length === 0) {
+        return {
+            totalTests: 1,
+            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 passedTests = 0;
+    let failedTests = 0;
+    let otherTests = 0;
+    for (const child of node.children) {
+        const childMetrics = calculateSubtreeMetrics(child);
+        totalTests += childMetrics.totalTests;
+        passedTests += childMetrics.passedTests;
+        failedTests += childMetrics.failedTests;
+        otherTests += childMetrics.otherTests;
+    }
+    return { totalTests, passedTests, failedTests, otherTests };
+};
+export const createSuccessRateDistributionTreeMap = (testResults) => {
+    const treeByLabels = createTreeByLabels(testResults, behaviorLabels, leafFactoryFn, groupFactoryFn, addLeafToGroupFn);
+    const convertedTree = convertTreeDataToTreeMapNode(treeByLabels, (node, isGroup) => {
+        const baseNode = {
+            id: node.name,
+            value: isGroup ? undefined : node.value,
+        };
+        if (isGroup) {
+            const group = node;
+            return {
+                ...baseNode,
+                passedTests: group.passedTests,
+                failedTests: group.failedTests,
+                otherTests: group.otherTests,
+            };
+        }
+        else {
+            const leaf = node;
+            return {
+                ...baseNode,
+                status: leaf.status,
+                passedTests: leaf?.status === "passed" ? 1 : 0,
+                failedTests: leaf?.status === "failed" ? 1 : 0,
+                otherTests: leaf?.status && !["passed", "failed"].includes(leaf.status) ? 1 : 0,
+            };
+        }
+    }, () => ({
+        id: "root",
+        passedTests: 0,
+        failedTests: 0,
+        otherTests: 0,
+    }));
+    return transformTreeMapNode(convertedTree, (node) => {
+        const subtreeMetrics = calculateSubtreeMetrics(node);
+        const colorValue = calculateColorValue(subtreeMetrics);
+        const { totalTests, ...restSubtreeMetrics } = subtreeMetrics;
+        if (isChildrenLeavesOnly(node)) {
+            const value = node.children?.reduce((acc, child) => {
+                return acc + (child.value ?? 0);
+            }, 0);
+            return {
+                ...node,
+                value,
+                children: undefined,
+                colorValue,
+                ...restSubtreeMetrics,
+            };
+        }
+        return {
+            ...node,
+            colorValue,
+            ...restSubtreeMetrics,
+        };
+    });
+};
+export const successRateDistributionTreeMapAccessor = {
+    getTreeMap: ({ testResults }) => {
+        const testsWithBehaviorLabels = filterTestsWithBehaviorLabels(testResults);
+        return createSuccessRateDistributionTreeMap(testsWithBehaviorLabels);
+    },
+};

package/dist/charts/accessors/utils/behavior.d.ts

@@ -0,0 +1,5 @@
+import type { HistoryTestResult, TestResult } from "@allurereport/core-api";
+export type BehaviorLabel = "epic" | "feature" | "story";
+export declare const behaviorLabels: BehaviorLabel[];
+export declare const hasBehaviorLabels: <T extends TestResult | HistoryTestResult>(test: T) => boolean;
+export declare const filterTestsWithBehaviorLabels: <T extends TestResult | HistoryTestResult>(tests: T[]) => T[];

package/dist/charts/accessors/utils/behavior.js

@@ -0,0 +1,4 @@
+import { hasLabels } from "../../../charts.js";
+export const behaviorLabels = ["epic", "feature", "story"];
+export const hasBehaviorLabels = (test) => hasLabels(test, behaviorLabels);
+export const filterTestsWithBehaviorLabels = (tests) => tests.filter(hasBehaviorLabels);

package/dist/charts/bar.d.ts

@@ -0,0 +1,3 @@
+import type { AllureChartsStoreData, BarChartData, BarChartOptions, BarDataAccessor } from "../charts.js";
+export declare const generateBarChartGeneric: <P extends string, T extends string>(options: BarChartOptions, storeData: AllureChartsStoreData, dataAccessor: BarDataAccessor<P, T>) => BarChartData | undefined;
+export declare const generateBarChart: (options: BarChartOptions, storeData: AllureChartsStoreData) => BarChartData | undefined;