@allurereport/web-commons 3.0.0-beta.9 → 3.0.0

package/dist/attachments.d.ts

@@ -0,0 +1,21 @@
+export interface Attachments {
+    id?: string;
+    ext?: string;
+    contentType?: string;
+    text?: string;
+    src?: string;
+    img?: string;
+}
+export declare const fetchFromUrl: ({ id, ext, contentType }: Attachments) => Promise<Response>;
+export declare const fetchAttachment: (id: string, ext: string, contentType?: string) => Promise<Attachments | null>;
+export declare const blobAttachment: (id: string, ext: string, contentType: string) => Promise<Blob>;
+export declare const downloadAttachment: (id: string, ext: string, contentType: string) => Promise<void>;
+export declare const openAttachmentInNewTab: (id: string, ext: string, contentType: string) => Promise<void>;
+export declare const attachmentType: (type?: string) => {
+    type: string;
+    icon: string;
+} | {
+    type: null;
+    icon: string;
+};
+export declare const restrictedContentTypes: string[];

package/dist/attachments.js

@@ -0,0 +1,162 @@
+import { fetchReportAttachment } from "./data.js";
+export const fetchFromUrl = async ({ id, ext, contentType }) => {
+    const fileName = `${id || "-"}${ext || ""}`;
+    return fetchReportAttachment(`data/attachments/${fileName}?attachment`, contentType);
+};
+export const fetchAttachment = async (id, ext, contentType) => {
+    if (!id && !ext) {
+        return null;
+    }
+    const response = await fetchFromUrl({ id, ext, contentType });
+    const fileType = attachmentType(contentType);
+    switch (fileType.type) {
+        case "svg":
+        case "image": {
+            const blob = await response.blob();
+            const img = URL.createObjectURL(blob);
+            return { img, id };
+        }
+        case "uri":
+        case "code":
+        case "html":
+        case "table":
+        case "text": {
+            const text = await response.text();
+            return { text };
+        }
+        case "video": {
+            const blob = await response.blob();
+            const src = URL.createObjectURL(blob);
+            return { src, id, contentType };
+        }
+        default:
+            return null;
+    }
+};
+export const blobAttachment = async (id, ext, contentType) => {
+    const response = await fetchFromUrl({ id, ext, contentType });
+    return await response.blob();
+};
+export const downloadAttachment = async (id, ext, contentType) => {
+    if (!id && !ext) {
+        return;
+    }
+    const fileName = `${id}${ext}`;
+    const blob = await blobAttachment(id, ext, contentType);
+    const linkUrl = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = linkUrl;
+    link.download = fileName;
+    link.click();
+    URL.revokeObjectURL(linkUrl);
+};
+export const openAttachmentInNewTab = async (id, ext, contentType) => {
+    if (!id && !ext) {
+        return;
+    }
+    const blob = await blobAttachment(id, ext, contentType);
+    const linkUrl = URL.createObjectURL(blob);
+    globalThis.open(linkUrl, "_blank");
+};
+export const attachmentType = (type) => {
+    switch (type) {
+        case "image/bmp":
+        case "image/gif":
+        case "image/tiff":
+        case "image/jpeg":
+        case "image/jpg":
+        case "image/png":
+        case "image/*":
+            return {
+                type: "image",
+                icon: "file",
+            };
+        case "text/xml":
+        case "text/json":
+        case "text/yaml":
+        case "text/javascript":
+        case "text/typescript":
+        case "text/ruby":
+        case "text/python":
+        case "text/php":
+        case "text/java":
+        case "text/csharp":
+        case "text/cpp":
+        case "text/c":
+        case "text/go":
+        case "text/rust":
+        case "text/swift":
+        case "text/kotlin":
+        case "text/scala":
+        case "text/perl":
+        case "text/r":
+        case "text/dart":
+        case "text/lua":
+        case "text/haskell":
+        case "text/sql":
+        case "text/x-yaml":
+        case "text/css":
+        case "application/yaml":
+        case "application/x-yaml":
+        case "application/xml":
+        case "application/json":
+            return {
+                type: "code",
+                icon: "file",
+            };
+        case "text/plain":
+        case "text/markdown":
+        case "text/*":
+            return {
+                type: "text",
+                icon: "txt",
+            };
+        case "text/html":
+            return {
+                type: "html",
+                icon: "file",
+            };
+        case "text/csv":
+            return {
+                type: "table",
+                icon: "csv",
+            };
+        case "text/tab-separated-values":
+            return {
+                type: "table",
+                icon: "table",
+            };
+        case "image/svg+xml":
+            return {
+                type: "svg",
+                icon: "file",
+            };
+        case "video/mp4":
+        case "video/ogg":
+        case "video/webm":
+            return {
+                type: "video",
+                icon: "file",
+            };
+        case "text/uri-list":
+            return {
+                type: "uri",
+                icon: "list",
+            };
+        case "application/x-tar":
+        case "application/x-gtar":
+        case "application/x-bzip2":
+        case "application/gzip":
+        case "application/zip":
+            return {
+                type: "archive",
+                icon: "file",
+            };
+        default:
+            return {
+                type: null,
+                icon: "file",
+            };
+    }
+};
+export const restrictedContentTypes = ["application/gzip"];

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

@@ -0,0 +1,16 @@
+import type { TreeMapDataAccessor, TreeMapNode } from "@allurereport/charts-api";
+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,183 @@
+import { createTreeByLabels, md5 } from "@allurereport/plugin-api";
+import { isChildrenLeavesOnly } from "../chart-utils.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);
+        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);
+    },
+};

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

@@ -0,0 +1,2 @@
+import type { HeatMapDataAccessor } from "@allurereport/charts-api";
+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 { TrendDataAccessor } from "@allurereport/charts-api";
+import type { SeverityLevel } from "@allurereport/core-api";
+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 "../chart-utils.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/statusTrendAccessor.d.ts

@@ -0,0 +1,3 @@
+import type { TrendDataAccessor } from "@allurereport/charts-api";
+import type { TestStatus } from "@allurereport/core-api";
+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 "../chart-utils.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/successRateDistributionTreeMapAccessor.d.ts

@@ -0,0 +1,14 @@
+import type { TreeMapDataAccessor, TreeMapNode } from "@allurereport/charts-api";
+import type { TestResult } from "@allurereport/core-api";
+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,110 @@
+import { createTreeByLabels, md5 } from "@allurereport/plugin-api";
+import { isChildrenLeavesOnly } from "../chart-utils.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 "../../chart-utils.js";
+export const behaviorLabels = ["epic", "feature", "story"];
+export const hasBehaviorLabels = (test) => hasLabels(test, behaviorLabels);
+export const filterTestsWithBehaviorLabels = (tests) => tests.filter(hasBehaviorLabels);

package/dist/charts/chart-utils.d.ts

@@ -0,0 +1,8 @@
+import type { TreeMapNode } from "@allurereport/charts-api";
+import type { HistoryDataPoint, HistoryTestResult, TestResult } from "@allurereport/core-api";
+export declare const limitHistoryDataPoints: (historyDataPoints: HistoryDataPoint[], limit: number) => HistoryDataPoint[];
+export declare const createEmptySeries: <T extends string>(items: readonly T[]) => Record<T, string[]>;
+export declare const createEmptyStats: <T extends string>(items: readonly T[]) => Record<T, number>;
+export declare const normalizeStatistic: <T extends string>(statistic: Partial<Record<T, number>>, itemType: readonly T[]) => Record<T, number>;
+export declare const hasLabels: <T extends string, TR extends TestResult | HistoryTestResult>(test: TR, labelHierarchy: T[]) => boolean;
+export declare const isChildrenLeavesOnly: <T extends TreeMapNode>(node: T) => boolean;

package/dist/charts/chart-utils.js

@@ -0,0 +1,22 @@
+export const limitHistoryDataPoints = (historyDataPoints, limit) => {
+    if (limit <= 0 || historyDataPoints.length === 0) {
+        return [];
+    }
+    const clampedLimit = Math.max(0, Math.floor(limit));
+    return historyDataPoints.slice(0, clampedLimit);
+};
+export const createEmptySeries = (items) => items.reduce((acc, item) => ({ ...acc, [item]: [] }), {});
+export const createEmptyStats = (items) => items.reduce((acc, item) => ({ ...acc, [item]: 0 }), {});
+export const normalizeStatistic = (statistic, itemType) => {
+    return itemType.reduce((acc, item) => {
+        acc[item] = statistic[item] ?? 0;
+        return acc;
+    }, {});
+};
+export const hasLabels = (test, labelHierarchy) => test.labels?.some((label) => {
+    const { name } = label;
+    return name && labelHierarchy.includes(name);
+}) ?? false;
+export const isChildrenLeavesOnly = (node) => {
+    return node.children ? node.children.every((child) => child.children === undefined) : false;
+};