@allurereport/plugin-awesome 3.8.2 → 3.10.0

package/README.md

@@ -58,6 +58,27 @@ The plugin accepts the following options:
 | `groupBy`      | Grouping tests by labels or combining labels. By default, tests are grouped using the `titlePath` provided by the test framework. | `string`                                                      | `[]`(Grouping by `titlepath`) |
 | `appendTitlePath`| Special marker for `groupBy`. Forces a final grouping by `titlePath` after all label-based groups.                                                          | `boolean`                                                    | `false`                       |
 | `stepTreeExpansion` | Default expansion policy for step trees in test details. | `"collapsed" \| "expand_failed_only" \| "expanded"` | `"expand_failed_only"` |
+| `defaultSortBy` | Default sort order for the test tree. Accepted values: `order,asc`, `order,desc`, `duration,asc`, `duration,desc`, `name,asc`, `name,desc`, `status,asc`, `status,desc`. User's manual selection is preserved in `localStorage` and takes priority over this value. | `string` | `order,asc` |
+
+### Default sort order
+
+Use `defaultSortBy` to change the initial sort order of the test tree:
+
+```ts
+import { defineConfig } from "allure";
+
+export default defineConfig({
+  plugins: {
+    awesome: {
+      options: {
+        defaultSortBy: "name,asc",
+      },
+    },
+  },
+});
+```
+
+The user's last selected sort order is always preserved in `localStorage`, so once a user changes the sort manually, their preference takes priority over the configured default.
 
 ### Step tree expansion
 

package/dist/categories.js

@@ -110,7 +110,7 @@ const buildGroupLevels = (category, testResult, matchingData, environmentCount,
     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 visible = tests.filter((t) => !t.isRetry);
     const environmentOrderMap = buildEnvironmentSortOrder(environments, defaultEnvironment);
     const nodes = {};
     const roots = [];

package/dist/converters.js

@@ -25,7 +25,7 @@ export const convertTestResult = (tr, options = {}) => {
         flaky: tr.flaky,
         muted: tr.muted,
         known: tr.known,
-        hidden: tr.hidden,
+        isRetry: tr.isRetry,
         labels,
         groupedLabels: mapLabelsByName(labels),
         parameters: tr.parameters,

package/dist/generateTimeline.js

@@ -26,7 +26,7 @@ export const generateTimeline = async (writer, trs, options, environmentIdByTrId
             historyId: test.historyId,
             name: test.name,
             status: test.status,
-            hidden: test.hidden,
+            isRetry: test.isRetry,
             host,
             thread,
             environment: environmentIdByTrId.get(test.id) ?? test.environment,

package/dist/generators.d.ts

@@ -1,15 +1,17 @@
 import { type AttachmentLink, type EnvironmentIdentity, type EnvironmentItem, type Statistic, type TestEnvGroup, type TestResult } from "@allurereport/core-api";
 import type { AllureStore, ExitCode, PluginContext, PluginGlobalAttachment, PluginGlobalError, QualityGateValidationResult, ReportFiles, ResultFile } from "@allurereport/plugin-api";
-import type { AwesomeTestResult } from "@allurereport/web-awesome";
+import type { AwesomeExecutorInfo, AwesomeRunSummary, 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[], options?: {
+export declare const generateTestResults: (_writer: AwesomeDataWriter, store: AllureStore, trs: TestResult[], options?: {
     hideLabels?: readonly (string | RegExp)[];
 }) => 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>;
+export declare const generateSearchIndex: (writer: AwesomeDataWriter, trs: AwesomeTestResult[], filename?: string) => Promise<void>;
+export declare const getRunSummary: (testResults: Pick<TestResult, "start" | "stop">[]) => AwesomeRunSummary | undefined;
 export declare const generateTree: (writer: AwesomeDataWriter, treeFilename: string, labels: string[], tests: AwesomeTestResult[], options?: {
     appendTitlePath?: boolean;
 }) => Promise<void>;
@@ -39,6 +41,8 @@ export declare const generateStaticFiles: (payload: AwesomeOptions & {
     reportDataFiles: ReportFile[];
     reportUuid: string;
     reportName: string;
+    executor?: AwesomeExecutorInfo;
+    runSummary?: AwesomeRunSummary;
 }) => Promise<void>;
 export declare const generateAllCharts: (writer: AwesomeDataWriter, store: AllureStore, options: AwesomeOptions, context: PluginContext) => Promise<void>;
 export declare const generateTreeFilters: (writer: AwesomeDataWriter, testResults: AwesomeTestResult[]) => Promise<void>;

package/dist/generators.js

@@ -1,10 +1,10 @@
 import { randomUUID } from "node:crypto";
-import { readFile } from "node:fs/promises";
+import { readFile, readdir } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { basename, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { defaultChartsConfig } from "@allurereport/charts-api";
 import { compareBy, createBaseUrlScript, createFontLinkTag, createReportDataScript, stringifyForInlineScript, createScriptTag, createStylesLinkTag, incrementStatistic, joinPosixPath, nullsLast, ordinal, } from "@allurereport/core-api";
-import { createTreeByLabels, createTreeByLabelsAndTitlePath, createTreeByTitlePath, filterTree, preciseTreeLabels, sortTree, transformTree, } from "@allurereport/plugin-api";
+import { createTreeByLabels, createTreeByLabelsAndTitlePath, createTreeByTitlePath, preciseTreeLabels, processTree, } from "@allurereport/plugin-api";
 import { generateCharts, getPieChartValues } from "@allurereport/web-commons";
 import Handlebars from "handlebars";
 import { convertFixtureResult, convertTestResult } from "./converters.js";
@@ -45,6 +45,7 @@ const template = `<!DOCTYPE html>
 </body>
 </html>
 `;
+const compiledTemplate = Handlebars.compile(template);
 export const readTemplateManifest = async (singleFileMode) => {
     const templateManifestSource = require.resolve(`@allurereport/web-awesome/dist/${singleFileMode ? "single" : "multi"}/manifest.json`);
     const templateManifest = await readFile(templateManifestSource, { encoding: "utf-8" });
@@ -73,21 +74,28 @@ const createBreadcrumbs = (convertedTr) => {
         return acc;
     }, []);
 };
-export const generateTestResults = async (writer, store, trs, options = {}) => {
+const writeConcurrently = async (items, write, concurrency = 64) => {
+    for (let i = 0; i < items.length; i += concurrency) {
+        await Promise.all(items.slice(i, i + concurrency).map(write));
+    }
+};
+export const generateTestResults = async (_writer, store, trs, options = {}) => {
     let convertedTrs = [];
+    const related = await store.relatedByTestResultIds(trs.map(({ id }) => id));
     for (const tr of trs) {
-        const trFixtures = await store.fixturesByTrId(tr.id);
+        const trFixtures = related.fixturesByTrId.get(tr.id) ?? [];
         const convertedTrFixtures = trFixtures.map(convertFixtureResult);
         const convertedTr = convertTestResult(tr, {
             hideLabels: options.hideLabels,
         });
-        convertedTr.history = (await store.historyByTrId(tr.id)) ?? [];
-        convertedTr.retries = await store.retriesByTrId(tr.id);
+        convertedTr.history = related.historyByTrId.get(tr.id) ?? [];
+        convertedTr.retries = related.retriesByTrId.get(tr.id) ?? [];
         convertedTr.retriesCount = convertedTr.retries.length;
         convertedTr.retry = convertedTr.retriesCount > 0;
+        convertedTr.isRetry = tr.isRetry;
         convertedTr.setup = convertedTrFixtures.filter((f) => f.type === "before");
         convertedTr.teardown = convertedTrFixtures.filter((f) => f.type === "after");
-        convertedTr.attachments = (await store.attachmentsByTrId(tr.id)).map((attachment) => ({
+        convertedTr.attachments = (related.attachmentsByTrId.get(tr.id) ?? []).map((attachment) => ({
             link: attachment,
             type: "attachment",
         }));
@@ -98,15 +106,10 @@ export const generateTestResults = async (writer, store, trs, options = {}) => {
         ...tr,
         order: idx + 1,
     }));
-    for (const convertedTr of convertedTrs) {
-        await writer.writeTestCase(convertedTr);
-    }
     return convertedTrs;
 };
 export const generateTestCases = async (writer, trs) => {
-    for (const tr of trs) {
-        await writer.writeTestCase(tr);
-    }
+    await writeConcurrently(trs, (tr) => writer.writeTestCase(tr));
 };
 export const generateTestEnvGroups = async (writer, groups) => {
     for (const group of groups) {
@@ -115,10 +118,75 @@ export const generateTestEnvGroups = async (writer, groups) => {
     }
 };
 export const generateNav = async (writer, trs, filename = "nav.json") => {
-    await writer.writeWidget(filename, trs.filter(({ hidden }) => !hidden).map(({ id }) => id));
+    await writer.writeWidget(filename, trs.filter(({ isRetry }) => !isRetry).map(({ id }) => id));
+};
+const SEARCHABLE_LABELS = new Set([
+    "owner",
+    "suite",
+    "package",
+    "testClass",
+    "testMethod",
+    "epic",
+    "feature",
+    "story",
+    "tag",
+    "host",
+    "thread",
+]);
+const joinSearchValues = (values) => {
+    const uniqueValues = new Set(values.map((value) => value?.trim()).filter((value) => Boolean(value)));
+    return uniqueValues.size > 0 ? [...uniqueValues].join(" ") : undefined;
+};
+const searchDocumentFactory = (test) => {
+    const labels = (test.labels ?? []).flatMap(({ name, value }) => {
+        if (!value || !SEARCHABLE_LABELS.has(name)) {
+            return [];
+        }
+        return [`${name}:${value}`, value];
+    });
+    const tags = (test.labels ?? []).flatMap(({ name, value }) => (name === "tag" && value ? [value] : []));
+    const parameters = (test.parameters ?? []).flatMap(({ name, value, hidden, masked }) => {
+        if (hidden) {
+            return [];
+        }
+        return masked ? [name] : [`${name}:${value}`, name, value];
+    });
+    const links = (test.links ?? []).flatMap(({ name, url, type }) => [name, url, type]);
+    const categories = test.categories?.map((category) => category.name);
+    return {
+        id: test.id,
+        nodeId: test.id,
+        name: test.name,
+        fullName: test.fullName,
+        historyId: test.historyId,
+        labels: joinSearchValues(labels),
+        owner: joinSearchValues(test.groupedLabels.owner ?? []),
+        tags: joinSearchValues(tags),
+        parameters: joinSearchValues(parameters),
+        categories: joinSearchValues(categories ?? []),
+        statusMessage: test.error?.message,
+        links: joinSearchValues(links),
+    };
+};
+export const generateSearchIndex = async (writer, trs, filename = "search-index.json") => {
+    const searchDocuments = trs.filter(({ isRetry }) => !isRetry).map(searchDocumentFactory);
+    await writer.writeWidget(filename, searchDocuments);
+};
+export const getRunSummary = (testResults) => {
+    let start = Infinity;
+    let stop = -Infinity;
+    for (const { start: s, stop: e } of testResults) {
+        if (typeof s === "number" && Number.isFinite(s) && typeof e === "number" && Number.isFinite(e)) {
+            start = Math.min(start, s);
+            stop = Math.max(stop, e);
+        }
+    }
+    return Number.isFinite(start) && Number.isFinite(stop)
+        ? { start, stop, duration: Math.max(0, stop - start) }
+        : undefined;
 };
 export const generateTree = async (writer, treeFilename, labels, tests, options) => {
-    const visibleTests = tests.filter((test) => !test.hidden);
+    const visibleTests = tests.filter((test) => !test.isRetry);
     const { appendTitlePath } = options || {};
     let tree;
     if (labels.length === 0) {
@@ -130,9 +198,10 @@ export const generateTree = async (writer, treeFilename, labels, tests, options)
     else {
         tree = buildTreeByLabels(visibleTests, labels);
     }
-    filterTree(tree, (leaf) => !leaf.hidden);
-    sortTree(tree, nullsLast(compareBy("start", ordinal())));
-    transformTree(tree, (leaf, idx) => ({ ...leaf, groupOrder: idx + 1 }));
+    processTree(tree, {
+        sort: nullsLast(compareBy("start", ordinal())),
+        transform: (leaf, idx) => ({ ...leaf, groupOrder: idx + 1 }),
+    });
     await writer.writeWidget(treeFilename, tree);
 };
 const buildTreeByLabels = (tests, labels) => {
@@ -306,16 +375,16 @@ export const generateQualityGateResults = async (writer, qualityGateResults = {}
     await writer.writeWidget("quality-gate.json", qualityGateResults);
 };
 export const generateStaticFiles = async (payload) => {
-    const { id, reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "auto", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, layout = "base", defaultSection = "", ci, stepTreeExpansion, } = payload;
-    const compile = Handlebars.compile(template);
+    const { id, reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "auto", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, layout = "base", defaultSection = "", ci, executor, runSummary, stepTreeExpansion, defaultSortBy, } = payload;
     const manifest = await readTemplateManifest(payload.singleFile);
     const headTags = [];
     const bodyTags = [];
     const sections = ["charts", "timeline"];
     if (!payload.singleFile) {
+        const manifestPath = require.resolve(join("@allurereport/web-awesome/dist", singleFile ? "single" : "multi", "manifest.json"));
+        const templateDir = dirname(manifestPath);
         for (const key in manifest) {
             const fileName = manifest[key];
-            const filePath = require.resolve(join("@allurereport/web-awesome/dist", singleFile ? "single" : "multi", fileName));
             if (key.includes(".woff")) {
                 headTags.push(createFontLinkTag(fileName));
             }
@@ -325,9 +394,12 @@ export const generateStaticFiles = async (payload) => {
             if (key === "main.js") {
                 bodyTags.push(createScriptTag(fileName));
             }
-            if (singleFile) {
+        }
+        for (const fileName of await readdir(templateDir)) {
+            if (fileName === "manifest.json") {
                 continue;
             }
+            const filePath = join(templateDir, fileName);
             const fileContent = await readFile(filePath);
             await reportFiles.addFile(basename(filePath), fileContent);
         }
@@ -350,14 +422,17 @@ export const generateStaticFiles = async (payload) => {
         groupBy: groupBy?.length ? groupBy : [],
         cacheKey: now.toString(),
         ci,
+        executor,
+        runSummary,
         layout,
         allureVersion,
         sections,
         defaultSection,
         stepTreeExpansion,
+        defaultSortBy,
     };
     try {
-        const html = compile({
+        const html = compiledTemplate({
             headTags: headTags.join("\n"),
             bodyTags: bodyTags.join("\n"),
             reportFilesScript: createReportDataScript(reportDataFiles),

package/dist/model.d.ts

@@ -21,6 +21,7 @@ export type AwesomeOptions = {
     publish?: boolean;
     appendTitlePath?: boolean;
     stepTreeExpansion?: StepTreeExpansion;
+    defaultSortBy?: string;
 };
 export type TemplateManifest = Record<string, string>;
 export type AwesomePluginOptions = AwesomeOptions;

package/dist/plugin.js

@@ -15,16 +15,17 @@ 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, generateNav, generateQualityGateResults, generateStaticFiles, generateStatistic, generateTestCases, generateTestEnvGroups, generateTestResults, generateTree, generateTreeFilters, generateVariables, } from "./generators.js";
+import { generateAllCharts, generateAttachmentsFiles, generateEnvironmentJson, generateEnvirontmentsList, generateGlobals, generateHistoryDataPoints, generateNav, generateQualityGateResults, 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 statistic = { total: 0 };
+    const related = await store.relatedByTestResultIds(testResults.map(({ id }) => id));
     for (const testResult of testResults) {
-        if (testResult.hidden) {
+        if (testResult.isRetry) {
             continue;
         }
         incrementStatistic(statistic, testResult.status);
-        if ((await store.retriesByTrId(testResult.id)).length > 0) {
+        if ((related.retriesByTrId.get(testResult.id)?.length ?? 0) > 0) {
             statistic.retries = (statistic.retries ?? 0) + 1;
         }
         if (testResult.flaky) {
@@ -45,8 +46,10 @@ export class AwesomePlugin {
             const hideLabels = context.hideLabels;
             const categories = context.categories ?? [];
             const environmentItems = await store.metadataByKey("allure_environment");
+            const executor = await store.metadataByKey("allure2_executor");
             const attachments = await store.allAttachments();
-            const allTrs = await store.allTestResults({ includeHidden: true, filter });
+            const allTrs = await store.allTestResults({ includeRetries: true, filter });
+            const runSummary = getRunSummary(allTrs);
             const statistics = await store.testsStatistic(filter);
             const environments = await store.allEnvironmentIdentities();
             const envStatistics = new Map();
@@ -66,7 +69,7 @@ export class AwesomePlugin {
                 envIdByTrId.set(tr.id, environmentId);
             }));
             await Promise.all(environments.map(async ({ id }) => {
-                const envTrs = await store.testResultsByEnvironmentId(id, { includeHidden: true });
+                const envTrs = await store.testResultsByEnvironmentId(id, { includeRetries: true });
                 envStatistics.set(id, await statisticByTestResults(store, envTrs));
             }));
             await generateStatistic(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
@@ -94,10 +97,11 @@ export class AwesomePlugin {
             await generateTestCases(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs);
             await generateTree(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), "tree.json", treeLabels, convertedTrs, { appendTitlePath });
             await generateNav(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs, "nav.json");
+            await generateSearchIndex(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs, "search-index.json");
             await generateTestEnvGroups(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), allTestEnvGroups);
             const convertedTrsById = new Map(convertedTrs.map((tr) => [tr.id, tr]));
             for (const reportEnvironment of environments) {
-                const envTrs = await store.testResultsByEnvironmentId(reportEnvironment.id, { includeHidden: true });
+                const envTrs = await store.testResultsByEnvironmentId(reportEnvironment.id, { includeRetries: true });
                 const envConvertedTrs = envTrs
                     .map((tr) => convertedTrsById.get(tr.id))
                     .filter((tr) => Boolean(tr));
@@ -105,6 +109,7 @@ export class AwesomePlugin {
                     appendTitlePath,
                 });
                 await generateNav(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), envConvertedTrs, joinPosixPath(reportEnvironment.id, "nav.json"));
+                await generateSearchIndex(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), envConvertedTrs, joinPosixPath(reportEnvironment.id, "search-index.json"));
                 await generateCategories(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
                     tests: envConvertedTrs,
                     categories,
@@ -139,6 +144,8 @@ export class AwesomePlugin {
                 reportUuid: context.reportUuid,
                 reportName: context.reportName,
                 ci: context.ci,
+                executor,
+                runSummary,
                 reportDataFiles,
             });
         });

package/dist/writer.d.ts

@@ -11,6 +11,7 @@ export interface AwesomeDataWriter {
     writeAttachment(source: string, file: ResultFile): Promise<void>;
 }
 export declare class FileSystemReportDataWriter implements AwesomeDataWriter {
+    #private;
     private readonly output;
     constructor(output: string);
     writeData(fileName: string, data: any): Promise<void>;

package/dist/writer.js

@@ -1,37 +1,56 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _InMemoryReportDataWriter_data;
+var _FileSystemReportDataWriter_dataDir, _FileSystemReportDataWriter_widgetsDir, _FileSystemReportDataWriter_testResultsDir, _FileSystemReportDataWriter_attachmentsDir, _FileSystemReportDataWriter_dataDirReady, _FileSystemReportDataWriter_widgetsDirReady, _FileSystemReportDataWriter_testResultsDirReady, _FileSystemReportDataWriter_attachmentsDirReady, _InMemoryReportDataWriter_data;
 import { mkdir, writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { joinPosixPath } from "@allurereport/core-api";
 export class FileSystemReportDataWriter {
     constructor(output) {
         this.output = output;
+        _FileSystemReportDataWriter_dataDir.set(this, void 0);
+        _FileSystemReportDataWriter_widgetsDir.set(this, void 0);
+        _FileSystemReportDataWriter_testResultsDir.set(this, void 0);
+        _FileSystemReportDataWriter_attachmentsDir.set(this, void 0);
+        _FileSystemReportDataWriter_dataDirReady.set(this, void 0);
+        _FileSystemReportDataWriter_widgetsDirReady.set(this, void 0);
+        _FileSystemReportDataWriter_testResultsDirReady.set(this, void 0);
+        _FileSystemReportDataWriter_attachmentsDirReady.set(this, void 0);
+        __classPrivateFieldSet(this, _FileSystemReportDataWriter_dataDir, resolve(this.output, "data"), "f");
+        __classPrivateFieldSet(this, _FileSystemReportDataWriter_widgetsDir, resolve(this.output, "widgets"), "f");
+        __classPrivateFieldSet(this, _FileSystemReportDataWriter_testResultsDir, resolve(this.output, "data", "test-results"), "f");
+        __classPrivateFieldSet(this, _FileSystemReportDataWriter_attachmentsDir, resolve(this.output, "data", "attachments"), "f");
+        __classPrivateFieldSet(this, _FileSystemReportDataWriter_dataDirReady, mkdir(__classPrivateFieldGet(this, _FileSystemReportDataWriter_dataDir, "f"), { recursive: true }), "f");
+        __classPrivateFieldSet(this, _FileSystemReportDataWriter_widgetsDirReady, mkdir(__classPrivateFieldGet(this, _FileSystemReportDataWriter_widgetsDir, "f"), { recursive: true }), "f");
+        __classPrivateFieldSet(this, _FileSystemReportDataWriter_testResultsDirReady, mkdir(__classPrivateFieldGet(this, _FileSystemReportDataWriter_testResultsDir, "f"), { recursive: true }), "f");
+        __classPrivateFieldSet(this, _FileSystemReportDataWriter_attachmentsDirReady, mkdir(__classPrivateFieldGet(this, _FileSystemReportDataWriter_attachmentsDir, "f"), { recursive: true }), "f");
     }
     async writeData(fileName, data) {
-        const distFolder = resolve(this.output, "data");
-        await mkdir(distFolder, { recursive: true });
-        await writeFile(resolve(distFolder, fileName), JSON.stringify(data), { encoding: "utf-8" });
+        await __classPrivateFieldGet(this, _FileSystemReportDataWriter_dataDirReady, "f");
+        await writeFile(resolve(__classPrivateFieldGet(this, _FileSystemReportDataWriter_dataDir, "f"), fileName), JSON.stringify(data), { encoding: "utf-8" });
     }
     async writeWidget(fileName, data) {
-        const distFolder = resolve(this.output, "widgets");
-        await mkdir(distFolder, { recursive: true });
-        await writeFile(resolve(distFolder, fileName), JSON.stringify(data), { encoding: "utf-8" });
+        await __classPrivateFieldGet(this, _FileSystemReportDataWriter_widgetsDirReady, "f");
+        await writeFile(resolve(__classPrivateFieldGet(this, _FileSystemReportDataWriter_widgetsDir, "f"), fileName), JSON.stringify(data), { encoding: "utf-8" });
     }
     async writeTestCase(test) {
-        const distFolder = resolve(this.output, "data", "test-results");
-        await mkdir(distFolder, { recursive: true });
-        await writeFile(resolve(distFolder, `${test.id}.json`), JSON.stringify(test), { encoding: "utf-8" });
+        await __classPrivateFieldGet(this, _FileSystemReportDataWriter_testResultsDirReady, "f");
+        await writeFile(resolve(__classPrivateFieldGet(this, _FileSystemReportDataWriter_testResultsDir, "f"), `${test.id}.json`), JSON.stringify(test), { encoding: "utf-8" });
     }
     async writeAttachment(source, file) {
-        const distFolder = resolve(this.output, "data", "attachments");
-        await mkdir(distFolder, { recursive: true });
-        await file.writeTo(resolve(distFolder, source));
+        await __classPrivateFieldGet(this, _FileSystemReportDataWriter_attachmentsDirReady, "f");
+        await file.writeTo(resolve(__classPrivateFieldGet(this, _FileSystemReportDataWriter_attachmentsDir, "f"), source));
     }
 }
+_FileSystemReportDataWriter_dataDir = new WeakMap(), _FileSystemReportDataWriter_widgetsDir = new WeakMap(), _FileSystemReportDataWriter_testResultsDir = new WeakMap(), _FileSystemReportDataWriter_attachmentsDir = new WeakMap(), _FileSystemReportDataWriter_dataDirReady = new WeakMap(), _FileSystemReportDataWriter_widgetsDirReady = new WeakMap(), _FileSystemReportDataWriter_testResultsDirReady = new WeakMap(), _FileSystemReportDataWriter_attachmentsDirReady = new WeakMap();
 export class InMemoryReportDataWriter {
     constructor() {
         _InMemoryReportDataWriter_data.set(this, {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-awesome",
-  "version": "3.8.2",
+  "version": "3.10.0",
   "description": "Allure Awesome Plugin – brand new HTML report with modern design and new features",
   "keywords": [
     "allure",
@@ -30,11 +30,11 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/charts-api": "3.8.2",
-    "@allurereport/core-api": "3.8.2",
-    "@allurereport/plugin-api": "3.8.2",
-    "@allurereport/web-awesome": "3.8.2",
-    "@allurereport/web-commons": "3.8.2",
+    "@allurereport/charts-api": "3.10.0",
+    "@allurereport/core-api": "3.10.0",
+    "@allurereport/plugin-api": "3.10.0",
+    "@allurereport/web-awesome": "3.10.0",
+    "@allurereport/web-commons": "3.10.0",
     "d3-shape": "^3.2.0",
     "handlebars": "^4.7.9",
     "markdown-it": "^14.1.0"
@@ -42,11 +42,12 @@
   "devDependencies": {
     "@types/d3-shape": "^3.1.6",
     "@types/markdown-it": "^14.1.2",
-    "@types/node": "^20.17.9",
-    "@vitest/runner": "^2.1.9",
-    "allure-vitest": "^3.3.3",
-    "rimraf": "^6.0.1",
-    "typescript": "^5.6.3",
-    "vitest": "^2.1.9"
+    "@types/node": "^20",
+    "@vitest/runner": "^2",
+    "allure-js-commons": "^3",
+    "allure-vitest": "^3",
+    "rimraf": "^6",
+    "typescript": "^5",
+    "vitest": "^4.1.0"
   }
 }