@allurereport/plugin-awesome 3.20.0 → 3.21.0

package/dist/categories.js

@@ -198,6 +198,7 @@ export const generateCategories = async (writer, { tests, categories, filename =
             duration: tr.duration,
             flaky: tr.flaky,
             retriesCount: tr.retriesCount,
+            retriesStatusChange: tr.retriesStatusChange,
             transition: tr.transition,
             tooltips: tr.tooltips,
         });

package/dist/generators.d.ts

@@ -1,11 +1,12 @@
 import { type AttachmentLink, type EnvironmentIdentity, type EnvironmentItem, type HistoryTestResultUrlResolver, type MetricSample, type Statistic, type TestEnvGroup, type TestResult } from "@allurereport/core-api";
-import type { AllureStore, ReportExecutorInfo, ReportRunSummary, ReportTestResult, GlobalAttachmentLink, ExitCode, PluginContext, PluginGlobalError, QualityGateValidationResult, ReportFiles, ResultFile } from "@allurereport/plugin-api";
+import type { AllureStore, ReportExecutorInfo, ReportRunSummary, ReportTestResult, GlobalAttachmentLink, ExitCode, PluginContext, PluginGlobalError, QualityGateValidationResult, ReportFiles, ResultFile, TestResultRelatedData } from "@allurereport/plugin-api";
 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[], options: {
     pluginId: string;
     hideLabels?: readonly (string | RegExp)[];
+    related?: TestResultRelatedData;
     resolveHistoryUrl?: HistoryTestResultUrlResolver;
 }) => Promise<ReportTestResult[]>;
 export declare const generateTestCases: (writer: AwesomeDataWriter, trs: ReportTestResult[]) => Promise<void>;
@@ -49,6 +50,7 @@ export declare const generateStaticFiles: (payload: AwesomeOptions & {
     reportDataFiles: ReportFile[];
     reportUuid: string;
     reportName: string;
+    overviewHref?: string;
     executor?: ReportExecutorInfo;
     runSummary?: ReportRunSummary;
     runSummaryByEnv?: Record<string, ReportRunSummary>;

package/dist/generators.js

@@ -1,11 +1,12 @@
 import { randomUUID } from "node:crypto";
 import { defaultChartsConfig } from "@allurereport/charts-api";
-import { appLoaderFaviconDataUri, appLoaderStyles, compareBy, createAppLoaderMarkup, createBaseUrlScript, createFaviconLinkTag, createFontLinkTag, createReportDataScript, stringifyForInlineScript, createScriptTag, createStylesLinkTag, incrementStatistic, joinPosixPath, nullsLast, ordinal, severityLabelName, } from "@allurereport/core-api";
+import { appLoaderFaviconDataUri, appLoaderStyles, compareBy, createAppLoaderMarkup, createBaseUrlScript, createFaviconLinkTag, createFontLinkTag, injectReportDataScript, reportDataScriptPlaceholder, stringifyForInlineScript, createScriptTag, createStylesLinkTag, hasRetriesStatusChange, incrementStatistic, joinPosixPath, nullsLast, ordinal, redactParameters, severityLabelName, } from "@allurereport/core-api";
 import { collapseTreeGroups, createTreeByLabels, createTreeByLabelsAndTitlePath, createTreeByTitlePath, preciseTreeLabels, processTree, } from "@allurereport/plugin-api";
 import { copyReportStaticAssets, getReportStaticAsset, readReportStaticAssets, } from "@allurereport/plugin-api/static-assets";
 import { generateCharts, getPieChartValues } from "@allurereport/web-commons";
 import Handlebars from "handlebars";
 import { convertFixtureResult, convertTestResult } from "./converters.js";
+import { createSingleFileScripts } from "./singleFileAssets.js";
 const reportStaticArchive = new URL("../dist/static/report.tar", import.meta.url);
 const template = `<!DOCTYPE html>
 <html dir="ltr" lang="en">
@@ -78,9 +79,17 @@ const writeConcurrently = async (items, write, concurrency = 64) => {
         await Promise.all(items.slice(i, i + concurrency).map(write));
     }
 };
+const mapConcurrently = async (items, map, concurrency = 8) => {
+    const results = [];
+    for (let i = 0; i < items.length; i += concurrency) {
+        results.push(...(await Promise.all(items.slice(i, i + concurrency).map(map))));
+    }
+    return results;
+};
 export const generateTestResults = async (_writer, store, trs, options) => {
     let convertedTrs = [];
-    const related = await store.relatedByTestResultIds(trs.map(({ id }) => id));
+    const related = options.related ?? (await store.relatedByTestResultIds(trs.map(({ id }) => id)));
+    const resolutionIssuesByTrId = related.resolutionIssuesByTrId;
     for (const tr of trs) {
         const trFixtures = related.fixturesByTrId.get(tr.id) ?? [];
         const convertedTrFixtures = [...trFixtures]
@@ -89,7 +98,6 @@ export const generateTestResults = async (_writer, store, trs, options) => {
         const convertedTr = convertTestResult(tr, {
             hideLabels: options.hideLabels,
         });
-        const resolutionIssue = await store.resolutionIssueByTestResultId(tr.id);
         convertedTr.history = (related.historyByTrId.get(tr.id) ?? []).map((item) => ({
             ...item,
             url: options.resolveHistoryUrl?.(item.url, options.pluginId, item.id) ?? "",
@@ -97,6 +105,7 @@ export const generateTestResults = async (_writer, store, trs, options) => {
         convertedTr.retries = related.retriesByTrId.get(tr.id) ?? [];
         convertedTr.retriesCount = convertedTr.retries.length;
         convertedTr.retry = convertedTr.retriesCount > 0;
+        convertedTr.retriesStatusChange = hasRetriesStatusChange(tr, convertedTr.retries);
         convertedTr.isRetry = tr.isRetry;
         convertedTr.setup = convertedTrFixtures.filter((f) => f.type === "before");
         convertedTr.teardown = convertedTrFixtures.filter((f) => f.type === "after");
@@ -105,7 +114,9 @@ export const generateTestResults = async (_writer, store, trs, options) => {
             type: "attachment",
         }));
         convertedTr.breadcrumbs = createBreadcrumbs(convertedTr);
-        convertedTr.resolutionIssue = resolutionIssue;
+        convertedTr.resolutionIssue = resolutionIssuesByTrId
+            ? resolutionIssuesByTrId.get(tr.id)
+            : await store.resolutionIssueByTestResultId(tr.id);
         convertedTrs.push(convertedTr);
     }
     convertedTrs = convertedTrs.sort(nullsLast(compareBy("start", ordinal()))).map((tr, idx) => ({
@@ -128,7 +139,9 @@ export const generateNav = async (writer, trs, filename = "nav.json") => {
 };
 const SEARCHABLE_LABELS = new Set([
     "owner",
+    "parentSuite",
     "suite",
+    "subSuite",
     "package",
     "testClass",
     "testMethod",
@@ -166,6 +179,7 @@ const searchDocumentFactory = (test) => {
         id: test.id,
         nodeId: test.id,
         name: test.name,
+        titlePath: joinSearchValues(test.titlePath ?? []),
         fullName: test.fullName,
         retryHash: test.retryHash,
         labels: joinSearchValues(labels),
@@ -273,8 +287,9 @@ const buildTreeByTitlePath = (tests) => {
     };
 };
 const buildTreeByLabelsAndTitlePathCombined = (tests, labels) => collapseTreeGroups(createTreeByLabelsAndTitlePath(tests, labels, leafFactory, undefined, (group, leaf) => incrementStatistic(group.statistic, leaf.status)));
-const leafFactory = ({ id, name, status, duration, flaky, start, retry, retriesCount, resolution, transition, tooltips, retryHash, groupedLabels, categories, }) => {
+const leafFactory = ({ id, name, status, duration, flaky, start, retry, retriesCount, retriesStatusChange, resolution, transition, tooltips, retryHash, groupedLabels, categories, parameters, }) => {
     const unresolvedFailure = (status === "failed" || status === "broken") && !resolution;
+    const parameterValues = redactParameters(parameters).flatMap(({ value }) => (value ? [value] : []));
     const leaf = {
         nodeId: id,
         id: retryHash ?? id,
@@ -285,11 +300,15 @@ const leafFactory = ({ id, name, status, duration, flaky, start, retry, retriesC
         start,
         retry,
         retriesCount,
+        retriesStatusChange,
         resolution,
         resolutionStatus: resolution ?? (unresolvedFailure ? "none" : undefined),
         transition,
         tooltips,
     };
+    if (parameterValues.length) {
+        leaf.parameters = parameterValues;
+    }
     const severity = groupedLabels[severityLabelName]?.[0];
     if (severity) {
         leaf.severity = severity;
@@ -319,6 +338,7 @@ const resolutionTestResultFactory = (test, index) => ({
     transition: test.transition,
     retry: test.retry,
     retriesCount: test.retriesCount,
+    retriesStatusChange: test.retriesStatusChange,
     resolution: test.resolution,
     groupOrder: index + 1,
     tooltips: test.tooltips,
@@ -379,20 +399,19 @@ export const generateStatistic = async (writer, data) => {
     }
 };
 export const generateAttachmentsFiles = async (writer, attachmentLinks, contentFunction) => {
-    const result = new Map();
-    for (const { id, ext, ...link } of attachmentLinks) {
+    const writtenAttachments = await mapConcurrently(attachmentLinks, async ({ id, ext, ...link }) => {
         if (link.missed) {
-            continue;
+            return;
         }
         const content = await contentFunction(id);
         if (!content) {
-            continue;
+            return;
         }
         const src = `${id}${ext}`;
         await writer.writeAttachment(src, content);
-        result.set(id, src);
-    }
-    return result;
+        return [id, src];
+    });
+    return new Map(writtenAttachments.filter((attachment) => attachment !== undefined));
 };
 export const generateHistoryDataPoints = async (writer, store) => {
     const result = new Map();
@@ -413,15 +432,22 @@ export const generateGlobals = async (writer, payload) => {
     if (globalExitCode) {
         globals.exitCode = globalExitCode;
     }
-    for (const attachment of globalAttachments) {
+    const attachmentWrites = new Map();
+    const writtenAttachments = await mapConcurrently(globalAttachments, async (attachment) => {
         const src = `${attachment.id}${attachment.ext}`;
         const content = await contentFunction(attachment.id);
         if (!content) {
-            continue;
+            return;
         }
-        await writer.writeAttachment(src, content);
-        globals.attachments.push(attachment);
-    }
+        let write = attachmentWrites.get(src);
+        if (!write) {
+            write = writer.writeAttachment(src, content);
+            attachmentWrites.set(src, write);
+        }
+        await write;
+        return attachment;
+    });
+    globals.attachments = writtenAttachments.filter((attachment) => attachment !== undefined);
     Object.entries(globalAttachmentsByEnv).forEach(([environmentId, attachments]) => {
         const attachmentIds = new Set(globals.attachments.map(({ id }) => id));
         const writtenAttachments = attachments.filter(({ id }) => attachmentIds.has(id));
@@ -459,7 +485,7 @@ export const generateQualityGateResults = async (writer, qualityGateResults = {}
     await writer.writeWidget("quality-gate.json", resultsWithTrees);
 };
 export const generateStaticFiles = async (payload) => {
-    const { id, reportName = "Allure Report", reportLanguage = "en", logo = "", theme = "auto", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, layout = "base", defaultSection = "", ci, executor, runSummary, runSummaryByEnv, stepTreeExpansion, defaultSortBy, } = payload;
+    const { id, reportName = "Allure Report", reportLanguage = "en", logo = "", theme = "auto", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, layout = "base", defaultSection = "", ci, executor, runSummary, runSummaryByEnv, stepTreeExpansion, defaultSortBy, overviewHref, } = payload;
     const staticAssets = await readReportStaticAssets(reportStaticArchive);
     const { manifest } = staticAssets;
     const headTags = [];
@@ -487,8 +513,7 @@ export const generateStaticFiles = async (payload) => {
             const mainCssContent = getReportStaticAsset(staticAssets, mainCss);
             headTags.push(createStylesLinkTag(`data:text/css;base64,${mainCssContent.toString("base64")}`));
         }
-        const mainJsContent = getReportStaticAsset(staticAssets, mainJs);
-        bodyTags.push(createScriptTag(`data:text/javascript;base64,${mainJsContent.toString("base64")}`));
+        bodyTags.push(createSingleFileScripts(staticAssets.files, mainJs));
     }
     const now = Date.now();
     const reportOptions = {
@@ -511,12 +536,13 @@ export const generateStaticFiles = async (payload) => {
         defaultSection,
         stepTreeExpansion,
         defaultSortBy,
+        overviewHref,
     };
     try {
         const html = compiledTemplate({
             headTags: headTags.join("\n"),
             bodyTags: bodyTags.join("\n"),
-            reportFilesScript: createReportDataScript(reportDataFiles),
+            reportFilesScript: reportDataScriptPlaceholder,
             reportOptions: stringifyForInlineScript(reportOptions),
             analyticsEnable: true,
             allureVersion,
@@ -524,7 +550,7 @@ export const generateStaticFiles = async (payload) => {
             reportName,
             singleFile: payload.singleFile,
         });
-        await reportFiles.addFile("index.html", Buffer.from(html, "utf8"));
+        await reportFiles.addFile("index.html", injectReportDataScript(html, reportDataFiles));
     }
     catch (err) {
         if (err instanceof RangeError) {

package/dist/plugin.js

@@ -10,16 +10,15 @@ 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_generateAfterStart, _AwesomePlugin_generate;
-import { incrementStatistic, joinPosixPath, } from "@allurereport/core-api";
+import { incrementStatistic, hasRetriesStatusChange, validateEnvironmentId, joinPosixPath, } from "@allurereport/core-api";
 import { createPluginSummary, } from "@allurereport/plugin-api";
 import { preciseTreeLabels } from "@allurereport/plugin-api";
 import { applyCategoriesToTestResults, generateCategories } from "./categories.js";
 import { generateTimeline } from "./generateTimeline.js";
 import { generateAllCharts, generateAttachmentsFiles, generateEnvironmentJson, generateEnvirontmentsList, generateGlobals, generateHistoryDataPoints, generateMetricsWidget, generateNav, generateQualityGateResults, generateResolutionCategories, generateSearchIndex, generateStaticFiles, generateStatistic, generateTestCases, generateTestEnvGroups, generateTestResults, generateTree, generateTreeFilters, generateVariables, getRunSummary, } from "./generators.js";
 import { InMemoryReportDataWriter, ReportFileDataWriter } from "./writer.js";
-const statisticByTestResults = async (store, testResults) => {
+const statisticByTestResults = (testResults, retriesByTrId) => {
     const statistic = { total: 0 };
-    const related = await store.relatedByTestResultIds(testResults.map(({ id }) => id));
     const incrementResolution = (testResult) => {
         if (testResult.resolution === "issue") {
             statistic.resolutions ?? (statistic.resolutions = {});
@@ -39,9 +38,13 @@ const statisticByTestResults = async (store, testResults) => {
             continue;
         }
         incrementStatistic(statistic, testResult.status);
-        if ((related.retriesByTrId.get(testResult.id)?.length ?? 0) > 0) {
+        const retries = retriesByTrId.get(testResult.id) ?? [];
+        if (retries.length > 0) {
             statistic.retries = (statistic.retries ?? 0) + 1;
         }
+        if (hasRetriesStatusChange(testResult, retries)) {
+            statistic.retriesStatusChange = (statistic.retriesStatusChange ?? 0) + 1;
+        }
         if (testResult.flaky) {
             statistic.flaky = (statistic.flaky ?? 0) + 1;
         }
@@ -69,13 +72,15 @@ export class AwesomePlugin {
             const measure = (name, fn) => perf?.measure(name, fn) ?? fn();
             const hideLabels = context.hideLabels;
             const categories = context.categories ?? [];
-            const { environmentItems, executor, attachments, allTrs, runSummary, statistics, environments, allTestEnvGroups, globalAttachments, globalAttachmentsByEnv, globalExitCode, globalErrors, globalErrorsByEnv, qualityGateResults, } = await measure("readData", async () => {
+            const { environmentItems, executor, attachments, allTrs, related, runSummary, statistics, environments, allTestEnvGroups, globalAttachments, globalAttachmentsByEnv, globalExitCode, globalErrors, globalErrorsByEnv, qualityGateResults, } = await measure("readData", async () => {
                 const testResults = await store.allTestResults({ includeRetries: true, filter });
+                const relatedData = await store.relatedByTestResultIds(testResults.map(({ id }) => id));
                 return {
                     environmentItems: await store.metadataByKey("allure_environment"),
                     executor: await store.metadataByKey("allure2_executor"),
                     attachments: await store.allAttachments(),
                     allTrs: testResults,
+                    related: relatedData,
                     runSummary: getRunSummary(testResults),
                     statistics: await store.testsStatistic(filter),
                     environments: await store.allEnvironmentIdentities(),
@@ -117,8 +122,8 @@ export class AwesomePlugin {
             const trsByEnvId = new Map();
             await measure("stats", async () => {
                 const envStatistics = new Map();
-                const pieStatistics = await statisticByTestResults(store, allTrs.filter(isActiveStatisticTestResult));
                 const pieEnvStatistics = new Map();
+                const pieStatistics = statisticByTestResults(allTrs.filter(isActiveStatisticTestResult), related.retriesByTrId);
                 for (const tr of allTrs) {
                     const environmentId = envIdByTrId.get(tr.id);
                     if (!environmentId) {
@@ -134,8 +139,8 @@ export class AwesomePlugin {
                 }
                 await Promise.all(environments.map(async ({ id }) => {
                     const envTrs = trsByEnvId.get(id) ?? [];
-                    envStatistics.set(id, await statisticByTestResults(store, envTrs));
-                    pieEnvStatistics.set(id, await statisticByTestResults(store, envTrs.filter(isActiveStatisticTestResult)));
+                    envStatistics.set(id, statisticByTestResults(envTrs, related.retriesByTrId));
+                    pieEnvStatistics.set(id, statisticByTestResults(envTrs.filter(isActiveStatisticTestResult), related.retriesByTrId));
                 }));
                 await generateStatistic(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
                     stats: statistics,
@@ -157,6 +162,7 @@ export class AwesomePlugin {
             const convertedTrs = await measure("convert", () => generateTestResults(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, allTrs, {
                 pluginId: context.id,
                 hideLabels,
+                related,
                 resolveHistoryUrl: context.history?.resolveTestResultUrl,
             }));
             if (perf) {
@@ -194,7 +200,11 @@ export class AwesomePlugin {
             const convertedTrsById = new Map(convertedTrs.map((tr) => [tr.id, tr]));
             await measure("environmentsOutput", async () => {
                 for (const reportEnvironment of environments) {
-                    const envTrs = await store.testResultsByEnvironmentId(reportEnvironment.id, { includeRetries: true });
+                    const environmentIdValidation = validateEnvironmentId(reportEnvironment.id);
+                    if (!environmentIdValidation.valid) {
+                        throw new Error(`Invalid environmentId ${JSON.stringify(reportEnvironment.id)}: ${environmentIdValidation.reason}`);
+                    }
+                    const envTrs = trsByEnvId.get(reportEnvironment.id) ?? [];
                     const envConvertedTrs = envTrs
                         .map((tr) => convertedTrsById.get(tr.id))
                         .filter((tr) => Boolean(tr));
@@ -251,6 +261,7 @@ export class AwesomePlugin {
                 reportFiles: context.reportFiles,
                 reportUuid: context.reportUuid,
                 reportName: context.reportName,
+                overviewHref: context.overviewHref,
                 ci: context.ci,
                 executor,
                 runSummary,

package/dist/singleFileAssets.d.ts

@@ -0,0 +1 @@
+export declare const createSingleFileScripts: (files: ReadonlyMap<string, Buffer>, mainJs: string) => string;

package/dist/singleFileAssets.js

@@ -0,0 +1,81 @@
+import { gzipSync } from "node:zlib";
+import { stringifyForInlineScript } from "@allurereport/core-api";
+const embeddedAssetsElementId = "allure-single-file-assets";
+export const createSingleFileScripts = (files, mainJs) => {
+    const compressedScripts = Object.fromEntries([...files]
+        .filter(([fileName]) => fileName.endsWith(".js"))
+        .map(([fileName, content]) => [fileName, gzipSync(content, { level: 9 }).toString("base64")]));
+    if (!compressedScripts[mainJs]) {
+        throw new Error(`The report static assets do not contain the main script: ${mainJs}`);
+    }
+    return `
+    <script id="${embeddedAssetsElementId}" type="application/json">${stringifyForInlineScript(compressedScripts)}</script>
+    <script>
+      (function () {
+        const assetsElement = document.getElementById(${stringifyForInlineScript(embeddedAssetsElementId)});
+        const assets = JSON.parse(assetsElement.textContent || "{}");
+        const appendChild = document.head.appendChild;
+
+        assetsElement.remove();
+
+        function embeddedAssetName(script) {
+          const source = script.getAttribute("src");
+
+          if (!source) {
+            return undefined;
+          }
+
+          const path = source.split(/[?#]/, 1)[0];
+
+          return path.slice(path.lastIndexOf("/") + 1);
+        }
+
+        async function decompressAsset(encoded) {
+          const binary = atob(encoded);
+          const compressed = new Uint8Array(binary.length);
+
+          for (let index = 0; index < binary.length; index++) {
+            compressed[index] = binary.charCodeAt(index);
+          }
+
+          const stream = new Blob([compressed]).stream().pipeThrough(new DecompressionStream("gzip"));
+
+          return new Response(stream).text();
+        }
+
+        document.head.appendChild = function (node) {
+          if (node.tagName !== "SCRIPT") {
+            return appendChild.call(this, node);
+          }
+
+          const fileName = embeddedAssetName(node);
+          const encoded = fileName && Object.hasOwn(assets, fileName) ? assets[fileName] : undefined;
+
+          if (!encoded) {
+            return appendChild.call(this, node);
+          }
+
+          void decompressAsset(encoded)
+            .then(function (source) {
+              node.removeAttribute("src");
+              node.text = source;
+              delete assets[fileName];
+              appendChild.call(document.head, node);
+              node.dispatchEvent(new Event("load"));
+            })
+            .catch(function (error) {
+              console.error("Failed to load embedded report asset " + fileName, error);
+              node.dispatchEvent(new Event("error"));
+            });
+
+          return node;
+        };
+
+        const mainScript = document.createElement("script");
+
+        mainScript.src = ${stringifyForInlineScript(mainJs)};
+        document.head.appendChild(mainScript);
+      })();
+    </script>
+  `;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-awesome",
-  "version": "3.20.0",
+  "version": "3.21.0",
   "description": "Allure Awesome Plugin – brand new HTML report with modern design and new features",
   "keywords": [
     "allure",
@@ -23,26 +23,29 @@
     ".": "./dist/index.js"
   },
   "scripts": {
-    "build": "run clean && tsc --project ./tsconfig.json && node ../../scripts/pack-report-static.mjs ../web-awesome/dist/multi ./dist/static/report.tar",
+    "build": "run clean && tsc --project ./tsconfig.json && node ../../scripts/pack-report-static.mjs ../web-awesome/dist/multi ./dist/static/report.tar --allow-chunks",
     "clean": "rimraf ./dist",
     "test": "rimraf ./out && vitest run",
+    "test:unit": "yarn test",
     "lint": "oxlint --import-plugin src test features stories",
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/charts-api": "3.20.0",
-    "@allurereport/core-api": "3.20.0",
-    "@allurereport/plugin-api": "3.20.0",
-    "@allurereport/web-commons": "3.20.0",
+    "@allurereport/charts-api": "3.21.0",
+    "@allurereport/core-api": "3.21.0",
+    "@allurereport/plugin-api": "3.21.0",
+    "@allurereport/web-commons": "3.21.0",
     "d3-shape": "^3.2.0",
-    "handlebars": "^4.7.9",
-    "markdown-it": "^14.2.0"
+    "handlebars": "4.7.10",
+    "markdown-it": "^15.0.2"
   },
   "devDependencies": {
-    "@allurereport/web-awesome": "3.20.0",
+    "@allurereport/test-config": "3.21.0",
+    "@allurereport/web-awesome": "3.21.0",
     "@types/d3-shape": "^3.1.8",
     "@types/markdown-it": "^14.1.2",
     "@types/node": "^20",
+    "@vitest/coverage-istanbul": "^4.1.0",
     "@vitest/runner": "^2",
     "allure-js-commons": "^3",
     "allure-vitest": "^3",