@allurereport/plugin-api 3.0.0-beta.4 → 3.0.0-beta.6

package/dist/config.d.ts

@@ -8,4 +8,4 @@ export interface Config {
     qualityGate?: QualityGateConfig;
     plugins?: Record<string, PluginDescriptor>;
 }
-export declare const defineConfig: (allureConfig: Config) => Promise<Config>;
+export declare const defineConfig: (allureConfig: Config) => Config;

package/dist/config.js

@@ -1,3 +1,3 @@
-export const defineConfig = async (allureConfig) => {
+export const defineConfig = (allureConfig) => {
     return allureConfig;
 };

package/dist/resultFile.d.ts

@@ -2,6 +2,7 @@ import type { Readable } from "node:stream";
 export interface ResultFile {
     readContent: <T>(transform: (stream: Readable) => Promise<T | undefined>) => Promise<T | undefined>;
     getOriginalFileName: () => string;
+    getExtension: () => string;
     getContentType: () => string | undefined;
     getContentLength: () => number | undefined;
     asJson: <T>() => Promise<T | undefined>;

package/dist/utils/tree.d.ts

@@ -1,2 +1,7 @@
-import type { DefaultTreeGroup, DefaultTreeLeaf, TestResult, TreeData } from "@allurereport/core-api";
-export declare const createTreeByLabels: (data: TestResult[], labelNames: string[]) => TreeData<DefaultTreeLeaf, DefaultTreeGroup>;
+import { type Comparator, type DefaultTreeGroup, type DefaultTreeLeaf, type TestResult, type TreeData, type TreeGroup, type TreeLeaf } from "@allurereport/core-api";
+export declare const byLabels: (item: TestResult, labelNames: string[]) => string[][];
+export declare const filterTreeLabels: (data: TestResult[], labelNames: string[]) => string[];
+export declare const createTreeByLabels: <T = TestResult, L = DefaultTreeLeaf, G = DefaultTreeGroup>(data: T[], labelNames: string[], leafFactory?: (item: T) => TreeLeaf<L>, groupFactory?: (parentGroup: string | undefined, groupClassifier: string) => TreeGroup<G>, addLeafToGroup?: (group: TreeGroup<G>, leaf: TreeLeaf<L>) => void) => TreeData<L, G>;
+export declare const filterTree: <L, G>(tree: TreeData<L, G>, predicate: (leaf: TreeLeaf<L>) => boolean) => TreeData<L, G>;
+export declare const sortTree: <L, G>(tree: TreeData<L, G>, comparator: Comparator<TreeLeaf<L>>) => TreeData<L, G>;
+export declare const transformTree: <L, G>(tree: TreeData<L, G>, transformer: (leaf: TreeLeaf<L>, idx: number) => TreeLeaf<L>) => TreeData<L, G>;

package/dist/utils/tree.js

@@ -1,4 +1,5 @@
-import { emptyStatistic, incrementStatistic } from "@allurereport/core-api";
+import { findByLabelName, } from "@allurereport/core-api";
+import { emptyStatistic } from "@allurereport/core-api";
 import { md5 } from "./misc.js";
 const addLeaf = (node, nodeId) => {
     if (node.leaves === undefined) {
@@ -58,21 +59,110 @@ const createTree = (data, classifier, leafFactory, groupFactory, addLeafToGroup
         leavesById,
     };
 };
-const byLabels = (item, labelNames) => {
+export const byLabels = (item, labelNames) => {
     return labelNames.map((labelName) => item.labels.filter((label) => labelName === label.name).map((label) => label.value ?? "__unknown") ?? []);
 };
-export const createTreeByLabels = (data, labelNames) => {
-    return createTree(data, (item) => byLabels(item, labelNames), ({ id, name, status, duration, flaky }) => ({
-        nodeId: id,
-        name,
-        status,
-        duration,
-        flaky,
-    }), (parentId, groupClassifier) => ({
-        nodeId: md5((parentId ? `${parentId}.` : "") + groupClassifier),
-        name: groupClassifier,
-        statistic: emptyStatistic(),
-    }), (group, leaf) => {
-        incrementStatistic(group.statistic, leaf.status);
-    });
+export const filterTreeLabels = (data, labelNames) => {
+    return [...labelNames]
+        .reverse()
+        .filter((labelName) => data.find((item) => findByLabelName(item.labels, labelName)))
+        .reverse();
+};
+export const createTreeByLabels = (data, labelNames, leafFactory, groupFactory, addLeafToGroup = () => { }) => {
+    const leafFactoryFn = leafFactory ??
+        ((tr) => {
+            const { id, name, status, duration } = tr;
+            return {
+                nodeId: id,
+                name,
+                status,
+                duration,
+            };
+        });
+    const groupFactoryFn = groupFactory ??
+        ((parentId, groupClassifier) => ({
+            nodeId: md5((parentId ? `${parentId}.` : "") + groupClassifier),
+            name: groupClassifier,
+            statistic: emptyStatistic(),
+        }));
+    return createTree(data, (item) => byLabels(item, labelNames), leafFactoryFn, groupFactoryFn, addLeafToGroup);
+};
+export const filterTree = (tree, predicate) => {
+    const visitedGroups = new Set();
+    const { root, leavesById, groupsById } = tree;
+    const filterGroupLeaves = (group) => {
+        if (!predicate) {
+            return group;
+        }
+        if (group.groups?.length) {
+            group.groups.forEach((groupId) => {
+                const subGroup = groupsById[groupId];
+                if (!subGroup || visitedGroups.has(groupId)) {
+                    return;
+                }
+                filterGroupLeaves(subGroup);
+                visitedGroups.add(groupId);
+            });
+        }
+        if (group.leaves?.length) {
+            group.leaves = group.leaves.filter((leaveId) => predicate(leavesById[leaveId]));
+        }
+        return group;
+    };
+    filterGroupLeaves(root);
+    return tree;
+};
+export const sortTree = (tree, comparator) => {
+    const visitedGroups = new Set();
+    const { root, leavesById, groupsById } = tree;
+    const sortGroupLeaves = (group) => {
+        if (!comparator) {
+            return group;
+        }
+        if (group.groups?.length) {
+            group.groups.forEach((groupId) => {
+                if (visitedGroups.has(groupId)) {
+                    return;
+                }
+                sortGroupLeaves(groupsById[groupId]);
+                visitedGroups.add(groupId);
+            });
+        }
+        if (group.leaves?.length) {
+            group.leaves = group.leaves.sort((a, b) => {
+                const leafA = leavesById[a];
+                const leafB = leavesById[b];
+                return comparator(leafA, leafB);
+            });
+        }
+        return group;
+    };
+    sortGroupLeaves(root);
+    return tree;
+};
+export const transformTree = (tree, transformer) => {
+    const visitedGroups = new Set();
+    const { root, leavesById, groupsById } = tree;
+    const transformGroupLeaves = (group) => {
+        if (!transformer) {
+            return group;
+        }
+        if (group.groups?.length) {
+            group.groups.forEach((groupId) => {
+                if (visitedGroups.has(groupId)) {
+                    return;
+                }
+                transformGroupLeaves(groupsById[groupId]);
+                visitedGroups.add(groupId);
+            });
+        }
+        if (group.leaves?.length) {
+            group.leaves.forEach((leaf, i) => {
+                leavesById[leaf] = transformer(leavesById[leaf], i);
+            });
+        }
+        return group;
+    };
+    transformGroupLeaves(root);
+    return tree;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-api",
-  "version": "3.0.0-beta.4",
+  "version": "3.0.0-beta.6",
   "description": "Allure Plugin API",
   "keywords": [
     "allure"
@@ -26,7 +26,7 @@
     "test": "rimraf ./out && vitest run"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.0.0-beta.4"
+    "@allurereport/core-api": "3.0.0-beta.6"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^2.6.1",
@@ -35,6 +35,7 @@
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "@vitest/runner": "^2.1.8",
+    "@vitest/snapshot": "^2.1.8",
     "allure-vitest": "^3.0.7",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",