@allurereport/plugin-awesome 3.1.0 → 3.3.1

package/dist/categories.d.ts

@@ -0,0 +1,13 @@
+import type { CategoryDefinition } from "@allurereport/core-api";
+import type { AwesomeTestResult } from "@allurereport/web-awesome";
+import type { AwesomeDataWriter } from "./writer.js";
+export declare const applyCategoriesToTestResults: (tests: AwesomeTestResult[], categories: CategoryDefinition[]) => void;
+export declare const generateCategories: (writer: AwesomeDataWriter, { tests, categories, filename, environmentCount, selectedEnvironmentCount, environments, defaultEnvironment, }: {
+    tests: AwesomeTestResult[];
+    categories: CategoryDefinition[];
+    filename?: string;
+    environmentCount?: number;
+    selectedEnvironmentCount?: number;
+    environments?: string[];
+    defaultEnvironment?: string;
+}) => Promise<void>;

package/dist/categories.js

@@ -0,0 +1,213 @@
+import { EMPTY_VALUE, buildEnvironmentSortOrder, compareChildNodes, extractErrorMatchingData, findLastByLabelName, incrementStatistic, matchCategory, } from "@allurereport/core-api";
+import { md5 } from "@allurereport/plugin-api";
+const emptyStat = () => ({
+    total: 0,
+});
+const msgKey = (m) => (m && m.trim().length ? m : EMPTY_VALUE);
+const envKey = (m) => (m && m.trim().length ? m : EMPTY_VALUE);
+const formatEmptyValue = (key) => {
+    if (key === "message") {
+        return "No message";
+    }
+    if (key === "transition") {
+        return "No transition";
+    }
+    if (key === "environment") {
+        return "No environment";
+    }
+    return `No ${key}`;
+};
+const hasEnvironmentSelector = (category) => category.groupBy.some((selector) => selector === "environment");
+const computeGroupEnvironments = (category, environmentCount, isSingleEnvironmentSelected) => {
+    if (isSingleEnvironmentSelected) {
+        return false;
+    }
+    if (category.groupEnvironments !== undefined) {
+        return category.groupEnvironments;
+    }
+    if (environmentCount > 1 && !hasEnvironmentSelector(category)) {
+        return true;
+    }
+    return false;
+};
+const displayGroupValue = (key, value) => (value === EMPTY_VALUE ? formatEmptyValue(key) : value);
+const formatGroupName = (key, value) => `${key}: ${displayGroupValue(key, value)}`;
+export const applyCategoriesToTestResults = (tests, categories) => {
+    for (const tr of tests) {
+        const matchingData = extractErrorMatchingData(tr);
+        const matched = matchCategory(categories, matchingData);
+        if (!matched) {
+            tr.categories = [];
+            continue;
+        }
+        tr.categories = [{ name: matched.name }];
+    }
+};
+const extractGroupValue = (selector, testResult) => {
+    if (selector === "flaky") {
+        const flakyValue = testResult.flaky ? "true" : "false";
+        return { key: "flaky", value: flakyValue, name: formatGroupName("flaky", flakyValue) };
+    }
+    if (selector === "transition") {
+        const transitionValue = testResult.transition ?? EMPTY_VALUE;
+        return { key: "transition", value: transitionValue, name: formatGroupName("transition", transitionValue) };
+    }
+    if (selector === "status") {
+        const statusValue = testResult.status ?? "unknown";
+        return { key: "status", value: statusValue, name: formatGroupName("status", statusValue) };
+    }
+    if (selector === "environment") {
+        const environmentValue = envKey(testResult.environment);
+        return { key: "environment", value: environmentValue, name: formatGroupName("environment", environmentValue) };
+    }
+    if (selector === "owner") {
+        const ownerValue = findLastByLabelName(testResult.labels, "owner") ?? EMPTY_VALUE;
+        return { key: "owner", value: ownerValue, name: formatGroupName("owner", ownerValue) };
+    }
+    if (selector === "severity") {
+        const fallbackValue = selector === "severity" ? "normal" : EMPTY_VALUE;
+        const builtInValue = findLastByLabelName(testResult.labels, selector) ?? fallbackValue;
+        return {
+            key: selector,
+            value: builtInValue,
+            name: formatGroupName(selector, builtInValue),
+        };
+    }
+    if (selector === "layer") {
+        const layerValue = findLastByLabelName(testResult.labels, "layer") ?? EMPTY_VALUE;
+        return { key: "layer", value: layerValue, name: formatGroupName("layer", layerValue) };
+    }
+    const labelName = selector.label;
+    const labelValue = findLastByLabelName(testResult.labels, labelName) ?? EMPTY_VALUE;
+    return { key: labelName, value: labelValue, name: formatGroupName(labelName, labelValue) };
+};
+const buildGroupLevels = (category, testResult, matchingData, environmentCount, isSingleEnvironmentSelected) => {
+    const levels = [];
+    for (const selector of category.groupBy) {
+        const groupValue = extractGroupValue(selector, testResult);
+        levels.push({ type: "group", key: groupValue.key, value: groupValue.value, name: groupValue.name });
+    }
+    if (category.groupByMessage) {
+        const messageValue = msgKey(matchingData.message);
+        levels.push({
+            type: "message",
+            key: "message",
+            value: messageValue,
+            name: displayGroupValue("message", messageValue),
+        });
+    }
+    const groupEnvironments = computeGroupEnvironments(category, environmentCount, isSingleEnvironmentSelected);
+    if (groupEnvironments) {
+        const testKeyValue = testResult.historyId ?? testResult.id;
+        const testDisplayName = testResult.name ?? testKeyValue;
+        levels.push({
+            type: "history",
+            key: "historyId",
+            value: testKeyValue,
+            name: testDisplayName,
+        });
+    }
+    return levels;
+};
+export const generateCategories = async (writer, { tests, categories, filename = "categories.json", environmentCount = 0, selectedEnvironmentCount, environments = [], defaultEnvironment = "default", }) => {
+    const visible = tests.filter((t) => !t.hidden);
+    const environmentOrderMap = buildEnvironmentSortOrder(environments, defaultEnvironment);
+    const nodes = {};
+    const roots = [];
+    const childrenMap = new Map();
+    const categoryOrder = categories.filter((cat) => !cat.hide).map((cat) => cat.name);
+    const categoryIds = new Map();
+    const categoryTouched = new Set();
+    const duplicateChecker = (node) => {
+        var _a;
+        nodes[_a = node.id] ?? (nodes[_a] = node);
+        return nodes[node.id];
+    };
+    const attachChild = (parentId, childId) => {
+        const set = childrenMap.get(parentId) ?? new Set();
+        set.add(childId);
+        childrenMap.set(parentId, set);
+    };
+    const bumpStat = (nodeId, status) => {
+        const node = nodes[nodeId];
+        node.statistic ?? (node.statistic = emptyStat());
+        incrementStatistic(node.statistic, status);
+    };
+    const ensureCategoryNode = (category) => {
+        const catId = categoryIds.get(category.name) ?? `cat:${md5(category.name)}`;
+        if (!categoryIds.has(category.name)) {
+            categoryIds.set(category.name, catId);
+        }
+        duplicateChecker({
+            id: catId,
+            type: "category",
+            name: category.name,
+            statistic: emptyStat(),
+            childrenIds: [],
+            expand: category.expand,
+        });
+        return catId;
+    };
+    for (const tr of visible) {
+        const matchingData = extractErrorMatchingData(tr);
+        const matchedCategory = matchCategory(categories, matchingData);
+        if (!matchedCategory || matchedCategory.hide) {
+            continue;
+        }
+        const catId = ensureCategoryNode(matchedCategory);
+        categoryTouched.add(matchedCategory.name);
+        bumpStat(catId, tr.status);
+        const environmentValue = envKey(tr.environment);
+        const isSingleEnvironmentSelected = selectedEnvironmentCount === 1;
+        const groupEnvironments = computeGroupEnvironments(matchedCategory, environmentCount, isSingleEnvironmentSelected);
+        const levels = buildGroupLevels(matchedCategory, tr, matchingData, environmentCount, isSingleEnvironmentSelected);
+        const leafName = groupEnvironments ? formatGroupName("environment", environmentValue) : tr.name;
+        let parentId = catId;
+        for (const level of levels) {
+            const levelId = `${level.type}:${md5(`${parentId}\n${level.key}\n${level.value}`)}`;
+            const historyId = level.type === "history" ? level.value : undefined;
+            duplicateChecker({
+                id: levelId,
+                type: level.type,
+                name: level.name,
+                key: level.key,
+                value: level.value,
+                historyId,
+                statistic: emptyStat(),
+                childrenIds: [],
+            });
+            bumpStat(levelId, tr.status);
+            attachChild(parentId, levelId);
+            parentId = levelId;
+        }
+        duplicateChecker({
+            id: tr.id,
+            type: "tr",
+            name: leafName,
+            key: groupEnvironments ? "environment" : undefined,
+            value: groupEnvironments ? environmentValue : undefined,
+            status: tr.status,
+            duration: tr.duration,
+            flaky: tr.flaky,
+            retriesCount: tr.retriesCount,
+            transition: tr.transition,
+            tooltips: tr.tooltips,
+        });
+        attachChild(parentId, tr.id);
+    }
+    for (const [parentNodeId, childNodeIds] of childrenMap.entries()) {
+        const sortedChildIds = Array.from(childNodeIds).sort((leftChildId, rightChildId) => compareChildNodes(leftChildId, rightChildId, nodes, environmentOrderMap));
+        nodes[parentNodeId].childrenIds = sortedChildIds;
+    }
+    for (const catName of categoryOrder) {
+        if (!categoryTouched.has(catName)) {
+            continue;
+        }
+        const id = categoryIds.get(catName);
+        if (id) {
+            roots.push(id);
+        }
+    }
+    const store = { roots, nodes };
+    await writer.writeWidget(filename, store);
+};

package/dist/converters.d.ts

@@ -1,4 +1,4 @@
-import type { TestFixtureResult, TestResult, TestStepResult } from "@allurereport/core-api";
+import { type TestFixtureResult, type TestResult, type TestStepResult } from "@allurereport/core-api";
 import type { AwesomeFixtureResult, AwesomeTestResult, AwesomeTestStepResult } from "@allurereport/web-awesome";
 export declare const convertTestResult: (tr: TestResult) => AwesomeTestResult;
 export declare const convertTestStepResult: (tsr: TestStepResult) => AwesomeTestStepResult;

package/dist/converters.js

@@ -1,3 +1,7 @@
+import { createDictionary, } from "@allurereport/core-api";
+import MarkdownIt from "markdown-it";
+const md = new MarkdownIt();
+const markdownToHtml = (value) => (value ? md.render(value) : undefined);
 const mapLabelsByName = (labels) => {
     return labels.reduce((acc, { name, value }) => {
         acc[name] = acc[name] || [];
@@ -5,7 +9,7 @@ const mapLabelsByName = (labels) => {
             acc[name].push(value);
         }
         return acc;
-    }, {});
+    }, createDictionary());
 };
 export const convertTestResult = (tr) => {
     return {
@@ -28,6 +32,7 @@ export const convertTestResult = (tr) => {
         steps: tr.steps,
         error: tr.error,
         testCase: tr.testCase,
+        descriptionHtml: tr.descriptionHtml ?? markdownToHtml(tr.description),
         environment: tr.environment,
         setup: [],
         teardown: [],

package/dist/generateTimeline.d.ts

@@ -1,7 +1,7 @@
-import type { AllureStore } from "@allurereport/plugin-api";
+import type { AwesomeTestResult } from "@allurereport/web-awesome";
 import type { AwesomeOptions } from "./model.js";
 type Writer = {
     writeWidget(fileName: string, data: any): Promise<void>;
 };
-export declare const generateTimeline: (writer: Writer, store: AllureStore, options: AwesomeOptions) => Promise<void>;
+export declare const generateTimeline: (writer: Writer, trs: AwesomeTestResult[], options: AwesomeOptions) => Promise<void>;
 export {};

package/dist/generateTimeline.js

@@ -1,16 +1,12 @@
-import { hasLabels } from "@allurereport/web-commons";
 const DEFAULT_MIN_DURATION = 1;
-const HOST_LABEL = "host";
-const THREAD_LABEL = "thread";
 const DEFAULT_TIMELINE_OPTIONS = {
     minDuration: DEFAULT_MIN_DURATION,
 };
-export const generateTimeline = async (writer, store, options) => {
+export const generateTimeline = async (writer, trs, options) => {
     const { timeline = DEFAULT_TIMELINE_OPTIONS } = options;
     const { minDuration = DEFAULT_MIN_DURATION } = timeline;
-    const testResults = await store.allTestResults({ includeHidden: true });
     const result = [];
-    for (const test of testResults) {
+    for (const test of trs) {
         const hasStart = Number.isInteger(test.start);
         const hasStop = Number.isInteger(test.stop);
         if (!hasStart || !hasStop) {
@@ -20,7 +16,8 @@ export const generateTimeline = async (writer, store, options) => {
         if (duration < minDuration) {
             continue;
         }
-        if (!hasLabels(test, [HOST_LABEL, THREAD_LABEL])) {
+        const { host, thread } = test.groupedLabels;
+        if (!host?.length || !thread?.length) {
             continue;
         }
         result.push({
@@ -29,10 +26,10 @@ export const generateTimeline = async (writer, store, options) => {
             name: test.name,
             status: test.status,
             hidden: test.hidden,
-            labels: test.labels,
+            host: host[0],
+            thread: thread[0],
             environment: test.environment,
             start: test.start,
-            stop: test.stop,
             duration,
         });
     }

package/dist/generators.d.ts

@@ -1,10 +1,10 @@
 import { type AttachmentLink, type EnvironmentItem, type Statistic, type TestEnvGroup, type TestError, type TestResult } from "@allurereport/core-api";
-import type { AllureStore, ExitCode, PluginContext, QualityGateValidationResult, ReportFiles, ResultFile, TestResultFilter } from "@allurereport/plugin-api";
+import type { AllureStore, ExitCode, PluginContext, QualityGateValidationResult, ReportFiles, ResultFile } from "@allurereport/plugin-api";
 import type { AwesomeTestResult } from "@allurereport/web-awesome";
 import type { AwesomeOptions, TemplateManifest } from "./model.js";
 import type { AwesomeDataWriter, ReportFile } from "./writer.js";
 export declare const readTemplateManifest: (singleFileMode?: boolean) => Promise<TemplateManifest>;
-export declare const generateTestResults: (writer: AwesomeDataWriter, store: AllureStore, trs: TestResult[], filter?: TestResultFilter) => Promise<AwesomeTestResult[]>;
+export declare const generateTestResults: (writer: AwesomeDataWriter, store: AllureStore, trs: TestResult[]) => Promise<AwesomeTestResult[]>;
 export declare const generateTestCases: (writer: AwesomeDataWriter, trs: AwesomeTestResult[]) => Promise<void>;
 export declare const generateTestEnvGroups: (writer: AwesomeDataWriter, groups: TestEnvGroup[]) => Promise<void>;
 export declare const generateNav: (writer: AwesomeDataWriter, trs: AwesomeTestResult[], filename?: string) => Promise<void>;
@@ -27,7 +27,7 @@ export declare const generateGlobals: (writer: AwesomeDataWriter, payload: {
     globalErrors?: TestError[];
     contentFunction: (id: string) => Promise<ResultFile | undefined>;
 }) => Promise<void>;
-export declare const generateQualityGateResults: (writer: AwesomeDataWriter, qualityGateResults?: QualityGateValidationResult[]) => Promise<void>;
+export declare const generateQualityGateResults: (writer: AwesomeDataWriter, qualityGateResults?: Record<string, QualityGateValidationResult[]>) => Promise<void>;
 export declare const generateStaticFiles: (payload: AwesomeOptions & {
     id: string;
     allureVersion: string;
@@ -37,4 +37,4 @@ export declare const generateStaticFiles: (payload: AwesomeOptions & {
     reportName: string;
 }) => Promise<void>;
 export declare const generateAllCharts: (writer: AwesomeDataWriter, store: AllureStore, options: AwesomeOptions, context: PluginContext) => Promise<void>;
-export declare const generateTreeFilters: (writer: AwesomeDataWriter, store: AllureStore) => Promise<void>;
+export declare const generateTreeFilters: (writer: AwesomeDataWriter, testResults: AwesomeTestResult[]) => Promise<void>;

package/dist/generators.js

@@ -58,9 +58,9 @@ const createBreadcrumbs = (convertedTr) => {
         acc[label.name].push(label.value || "");
         return acc;
     }, {});
-    const parentSuites = labelsByType.parentSuite || [""];
-    const suites = labelsByType.suite || [""];
-    const subSuites = labelsByType.subSuite || [""];
+    const parentSuites = labelsByType.parentSuite ?? [""];
+    const suites = labelsByType.suite ?? [""];
+    const subSuites = labelsByType.subSuite ?? [""];
     return parentSuites.reduce((acc, parentSuite) => {
         suites.forEach((suite) => {
             subSuites.forEach((subSuite) => {
@@ -73,10 +73,9 @@ const createBreadcrumbs = (convertedTr) => {
         return acc;
     }, []);
 };
-export const generateTestResults = async (writer, store, trs, filter) => {
-    const allTr = trs.filter((tr) => (filter ? filter(tr) : true));
+export const generateTestResults = async (writer, store, trs) => {
     let convertedTrs = [];
-    for (const tr of allTr) {
+    for (const tr of trs) {
         const trFixtures = await store.fixturesByTrId(tr.id);
         const convertedTrFixtures = trFixtures.map(convertFixtureResult);
         const convertedTr = convertTestResult(tr);
@@ -190,7 +189,7 @@ const buildTreeByTitlePath = (tests) => {
     };
 };
 const buildTreeByLabelsAndTitlePathCombined = (tests, labels) => createTreeByLabelsAndTitlePath(tests, labels, leafFactory, undefined, (group, leaf) => incrementStatistic(group.statistic, leaf.status));
-const leafFactory = ({ id, name, status, duration, flaky, start, retry, retriesCount, transition, tooltips, historyId, groupedLabels, }) => {
+const leafFactory = ({ id, name, status, duration, flaky, start, retry, retriesCount, transition, tooltips, historyId, groupedLabels, categories, }) => {
     const leaf = {
         nodeId: id,
         id: historyId ?? id,
@@ -207,6 +206,9 @@ const leafFactory = ({ id, name, status, duration, flaky, start, retry, retriesC
     if (groupedLabels.tag && groupedLabels.tag.length > 0) {
         leaf.tags = groupedLabels.tag;
     }
+    if (categories?.length) {
+        leaf.categories = categories.map((category) => category.name).filter(Boolean);
+    }
     return leaf;
 };
 export const generateEnvironmentJson = async (writer, env) => {
@@ -283,7 +285,7 @@ export const generateGlobals = async (writer, payload) => {
     }
     await writer.writeWidget("globals.json", globals);
 };
-export const generateQualityGateResults = async (writer, qualityGateResults = []) => {
+export const generateQualityGateResults = async (writer, qualityGateResults = {}) => {
     await writer.writeWidget("quality-gate.json", qualityGateResults);
 };
 export const generateStaticFiles = async (payload) => {
@@ -359,28 +361,29 @@ export const generateStaticFiles = async (payload) => {
     }
 };
 export const generateAllCharts = async (writer, store, options, context) => {
-    const { charts = defaultChartsConfig } = options;
-    const generatedChartsData = await generateCharts(charts, store, context.reportName, randomUUID);
+    const { charts = defaultChartsConfig, filter } = options;
+    const generatedChartsData = await generateCharts(charts, store, context.reportName, randomUUID, filter);
     if (Object.keys(generatedChartsData.general).length > 0) {
         await writer.writeWidget("charts.json", generatedChartsData);
     }
 };
-export const generateTreeFilters = async (writer, store) => {
+export const generateTreeFilters = async (writer, testResults) => {
     const trTags = new Set();
-    const trs = await store.allTestResults({ includeHidden: false });
-    for (const tr of trs) {
-        if (tr.labels.length === 0) {
-            continue;
+    const trCategories = new Set();
+    for (const tr of testResults) {
+        for (const tag of tr.groupedLabels.tag ?? []) {
+            trTags.add(tag);
         }
-        tr.labels.forEach((label) => {
-            if (label.name === "tag" && !!label.value) {
-                trTags.add(label.value);
+        tr.categories?.forEach((category) => {
+            if (category.name) {
+                trCategories.add(category.name);
             }
         });
     }
-    if (trTags.size === 0) {
+    if (trTags.size === 0 && trCategories.size === 0) {
         return Promise.resolve();
     }
     const tags = Array.from(trTags).sort((a, b) => a.localeCompare(b));
-    await writer.writeWidget("tree-filters.json", { tags });
+    const categories = Array.from(trCategories).sort((a, b) => a.localeCompare(b));
+    await writer.writeWidget("tree-filters.json", { tags, categories });
 };

package/dist/model.d.ts

@@ -5,7 +5,7 @@ export type AwesomeOptions = {
     singleFile?: boolean;
     logo?: string;
     theme?: "light" | "dark" | "auto";
-    reportLanguage?: "en";
+    reportLanguage?: string;
     groupBy?: string[];
     layout?: "base" | "split";
     environments?: Record<string, EnvironmentsConfig>;

package/dist/plugin.js

@@ -10,10 +10,10 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 var _AwesomePlugin_writer, _AwesomePlugin_generate;
-import { getWorstStatus } from "@allurereport/core-api";
-import { convertToSummaryTestResult, } from "@allurereport/plugin-api";
+import { createPluginSummary, } from "@allurereport/plugin-api";
 import { preciseTreeLabels } from "@allurereport/plugin-api";
 import { join } from "node:path";
+import { applyCategoriesToTestResults, generateCategories } from "./categories.js";
 import { filterEnv } from "./environments.js";
 import { generateTimeline } from "./generateTimeline.js";
 import { generateAllCharts, generateAttachmentsFiles, generateEnvironmentJson, generateEnvirontmentsList, generateGlobals, generateHistoryDataPoints, generateNav, generateQualityGateResults, generateStaticFiles, generateStatistic, generateTestCases, generateTestEnvGroups, generateTestResults, generateTree, generateTreeFilters, generateVariables, } from "./generators.js";
@@ -24,10 +24,11 @@ export class AwesomePlugin {
         _AwesomePlugin_writer.set(this, void 0);
         _AwesomePlugin_generate.set(this, async (context, store) => {
             const { singleFile, groupBy = [], filter, appendTitlePath } = this.options ?? {};
+            const categories = context.categories ?? [];
             const environmentItems = await store.metadataByKey("allure_environment");
             const reportEnvironments = await store.allEnvironments();
             const attachments = await store.allAttachments();
-            const allTrs = await store.allTestResults({ includeHidden: true });
+            const allTrs = await store.allTestResults({ includeHidden: true, filter });
             const statistics = await store.testsStatistic(filter);
             const environments = await store.allEnvironments();
             const envStatistics = new Map();
@@ -35,7 +36,7 @@ export class AwesomePlugin {
             const globalAttachments = await store.allGlobalAttachments();
             const globalExitCode = await store.globalExitCode();
             const globalErrors = await store.allGlobalErrors();
-            const qualityGateResults = await store.qualityGateResults();
+            const qualityGateResults = await store.qualityGateResultsByEnv();
             for (const env of environments) {
                 envStatistics.set(env, await store.testsStatistic(filterEnv(env, filter)));
             }
@@ -45,9 +46,18 @@ export class AwesomePlugin {
                 envs: environments,
             });
             await generateAllCharts(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, this.options, context);
-            await generateTimeline(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, this.options);
-            const convertedTrs = await generateTestResults(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, allTrs, this.options.filter);
+            const convertedTrs = await generateTestResults(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, allTrs);
+            applyCategoriesToTestResults(convertedTrs, categories);
+            await generateCategories(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
+                tests: convertedTrs,
+                categories,
+                environmentCount: environments.length,
+                environments,
+                defaultEnvironment: "default",
+                selectedEnvironmentCount: environments.length,
+            });
             const hasGroupBy = groupBy.length > 0;
+            await generateTimeline(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs, this.options);
             const treeLabels = hasGroupBy
                 ? preciseTreeLabels(groupBy, convertedTrs, ({ labels }) => labels.map(({ name }) => name))
                 : [];
@@ -62,8 +72,16 @@ export class AwesomePlugin {
                     appendTitlePath,
                 });
                 await generateNav(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), envConvertedTrs, join(reportEnvironment, "nav.json"));
+                await generateCategories(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
+                    tests: envConvertedTrs,
+                    categories,
+                    environmentCount: 1,
+                    defaultEnvironment: "default",
+                    selectedEnvironmentCount: 1,
+                    filename: join(reportEnvironment, "categories.json"),
+                });
             }
-            await generateTreeFilters(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
+            await generateTreeFilters(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs);
             await generateEnvirontmentsList(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
             await generateVariables(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
             if (environmentItems?.length) {
@@ -114,29 +132,19 @@ export class AwesomePlugin {
         };
     }
     async info(context, store) {
-        const allTrs = (await store.allTestResults()).filter((tr) => this.options.filter ? this.options.filter(tr) : true);
-        const newTrs = await store.allNewTestResults();
-        const retryTrs = allTrs.filter((tr) => !!tr?.retries?.length);
-        const flakyTrs = allTrs.filter((tr) => !!tr?.flaky);
-        const duration = allTrs.reduce((acc, { duration: trDuration = 0 }) => acc + trDuration, 0);
-        const worstStatus = getWorstStatus(allTrs.map(({ status }) => status));
-        const createdAt = allTrs.reduce((acc, { stop }) => Math.max(acc, stop || 0), 0);
-        return {
+        return createPluginSummary({
             name: this.options.reportName || context.reportName,
-            stats: await store.testsStatistic(this.options.filter),
-            status: worstStatus ?? "passed",
-            duration,
-            createdAt,
             plugin: "Awesome",
-            newTests: newTrs.map(convertToSummaryTestResult),
-            flakyTests: flakyTrs.map(convertToSummaryTestResult),
-            retryTests: retryTrs.map(convertToSummaryTestResult),
             meta: {
                 reportId: context.reportUuid,
                 singleFile: this.options.singleFile ?? false,
                 withTestResultsLinks: true,
             },
-        };
+            filter: this.options.filter,
+            ci: context.ci,
+            history: context.history,
+            store,
+        });
     }
 }
 _AwesomePlugin_writer = new WeakMap(), _AwesomePlugin_generate = new WeakMap();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-awesome",
-  "version": "3.1.0",
+  "version": "3.3.1",
   "description": "Allure Awesome Plugin – brand new HTML report with modern design and new features",
   "keywords": [
     "allure",
@@ -30,18 +30,20 @@
     "test": "rimraf ./out && vitest run"
   },
   "dependencies": {
-    "@allurereport/charts-api": "3.1.0",
-    "@allurereport/core-api": "3.1.0",
-    "@allurereport/plugin-api": "3.1.0",
-    "@allurereport/web-awesome": "3.1.0",
-    "@allurereport/web-commons": "3.1.0",
+    "@allurereport/charts-api": "3.3.1",
+    "@allurereport/core-api": "3.3.1",
+    "@allurereport/plugin-api": "3.3.1",
+    "@allurereport/web-awesome": "3.3.1",
+    "@allurereport/web-commons": "3.3.1",
     "d3-shape": "^3.2.0",
-    "handlebars": "^4.7.8"
+    "handlebars": "^4.7.8",
+    "markdown-it": "^14.1.0"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^2.6.1",
     "@types/d3-shape": "^3.1.6",
     "@types/eslint": "^8.56.11",
+    "@types/markdown-it": "^14.1.2",
     "@types/node": "^20.17.9",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",