@allurereport/plugin-awesome 3.3.1 → 3.4.1

package/dist/categories.js

@@ -40,7 +40,7 @@ export const applyCategoriesToTestResults = (tests, categories) => {
             tr.categories = [];
             continue;
         }
-        tr.categories = [{ name: matched.name }];
+        tr.categories = [{ id: matched.id, name: matched.name }];
     }
 };
 const extractGroupValue = (selector, testResult) => {
@@ -115,8 +115,8 @@ export const generateCategories = async (writer, { tests, categories, filename =
     const nodes = {};
     const roots = [];
     const childrenMap = new Map();
-    const categoryOrder = categories.filter((cat) => !cat.hide).map((cat) => cat.name);
-    const categoryIds = new Map();
+    const categoryOrder = categories.filter((category) => !category.hide).map((category) => category.id);
+    const categoryNodeIds = new Map();
     const categoryTouched = new Set();
     const duplicateChecker = (node) => {
         var _a;
@@ -134,9 +134,9 @@ export const generateCategories = async (writer, { tests, categories, filename =
         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);
+        const catId = categoryNodeIds.get(category.id) ?? `cat:${md5(category.id)}`;
+        if (!categoryNodeIds.has(category.id)) {
+            categoryNodeIds.set(category.id, catId);
         }
         duplicateChecker({
             id: catId,
@@ -155,7 +155,7 @@ export const generateCategories = async (writer, { tests, categories, filename =
             continue;
         }
         const catId = ensureCategoryNode(matchedCategory);
-        categoryTouched.add(matchedCategory.name);
+        categoryTouched.add(matchedCategory.id);
         bumpStat(catId, tr.status);
         const environmentValue = envKey(tr.environment);
         const isSingleEnvironmentSelected = selectedEnvironmentCount === 1;
@@ -180,6 +180,12 @@ export const generateCategories = async (writer, { tests, categories, filename =
             attachChild(parentId, levelId);
             parentId = levelId;
         }
+        tr.categories = [
+            {
+                name: matchedCategory.name,
+                grouping: levels.map((l) => ({ key: l.key, value: l.value, name: l.name })),
+            },
+        ];
         duplicateChecker({
             id: tr.id,
             type: "tr",
@@ -199,11 +205,11 @@ export const generateCategories = async (writer, { tests, categories, filename =
         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)) {
+    for (const categoryId of categoryOrder) {
+        if (!categoryTouched.has(categoryId)) {
             continue;
         }
-        const id = categoryIds.get(catName);
+        const id = categoryNodeIds.get(categoryId);
         if (id) {
             roots.push(id);
         }

package/dist/converters.d.ts

@@ -1,5 +1,7 @@
 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 convertTestResult: (tr: TestResult, options?: {
+    hideLabels?: readonly (string | RegExp)[];
+}) => AwesomeTestResult;
 export declare const convertTestStepResult: (tsr: TestStepResult) => AwesomeTestStepResult;
 export declare const convertFixtureResult: (fr: TestFixtureResult) => AwesomeFixtureResult;

package/dist/converters.js

@@ -1,4 +1,4 @@
-import { createDictionary, } from "@allurereport/core-api";
+import { createDictionary, shouldHideLabel, } from "@allurereport/core-api";
 import MarkdownIt from "markdown-it";
 const md = new MarkdownIt();
 const markdownToHtml = (value) => (value ? md.render(value) : undefined);
@@ -11,7 +11,8 @@ const mapLabelsByName = (labels) => {
         return acc;
     }, createDictionary());
 };
-export const convertTestResult = (tr) => {
+export const convertTestResult = (tr, options = {}) => {
+    const labels = tr.labels.filter(({ name }) => !shouldHideLabel(name, options.hideLabels));
     return {
         id: tr.id,
         name: tr.name,
@@ -25,8 +26,8 @@ export const convertTestResult = (tr) => {
         muted: tr.muted,
         known: tr.known,
         hidden: tr.hidden,
-        labels: tr.labels,
-        groupedLabels: mapLabelsByName(tr.labels),
+        labels,
+        groupedLabels: mapLabelsByName(labels),
         parameters: tr.parameters,
         links: tr.links,
         steps: tr.steps,

package/dist/generateTimeline.d.ts

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

package/dist/generateTimeline.js

@@ -2,7 +2,7 @@ const DEFAULT_MIN_DURATION = 1;
 const DEFAULT_TIMELINE_OPTIONS = {
     minDuration: DEFAULT_MIN_DURATION,
 };
-export const generateTimeline = async (writer, trs, options) => {
+export const generateTimeline = async (writer, trs, options, environmentIdByTrId) => {
     const { timeline = DEFAULT_TIMELINE_OPTIONS } = options;
     const { minDuration = DEFAULT_MIN_DURATION } = timeline;
     const result = [];
@@ -16,7 +16,8 @@ export const generateTimeline = async (writer, trs, options) => {
         if (duration < minDuration) {
             continue;
         }
-        const { host, thread } = test.groupedLabels;
+        const host = test.labels?.find(({ name }) => name === "host")?.value;
+        const thread = test.labels?.find(({ name }) => name === "thread")?.value;
         if (!host?.length || !thread?.length) {
             continue;
         }
@@ -26,9 +27,10 @@ export const generateTimeline = async (writer, trs, options) => {
             name: test.name,
             status: test.status,
             hidden: test.hidden,
-            host: host[0],
-            thread: thread[0],
-            environment: test.environment,
+            host,
+            thread,
+            environment: environmentIdByTrId.get(test.id) ?? test.environment,
+            environmentName: test.environment,
             start: test.start,
             duration,
         });

package/dist/generators.d.ts

@@ -1,10 +1,12 @@
-import { type AttachmentLink, type EnvironmentItem, type Statistic, type TestEnvGroup, type TestError, type TestResult } from "@allurereport/core-api";
+import { type AttachmentLink, type EnvironmentIdentity, type EnvironmentItem, type Statistic, type TestEnvGroup, type TestError, type TestResult } from "@allurereport/core-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[]) => Promise<AwesomeTestResult[]>;
+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>;
@@ -17,7 +19,7 @@ export declare const generateVariables: (writer: AwesomeDataWriter, store: Allur
 export declare const generateStatistic: (writer: AwesomeDataWriter, data: {
     stats: Statistic;
     statsByEnv: Map<string, Statistic>;
-    envs: string[];
+    envs: EnvironmentIdentity[];
 }) => Promise<void>;
 export declare const generateAttachmentsFiles: (writer: AwesomeDataWriter, attachmentLinks: AttachmentLink[], contentFunction: (id: string) => Promise<ResultFile | undefined>) => Promise<Map<string, string> | undefined>;
 export declare const generateHistoryDataPoints: (writer: AwesomeDataWriter, store: AllureStore) => Promise<Map<string, string>>;

package/dist/generators.js

@@ -1,12 +1,12 @@
-import { defaultChartsConfig } from "@allurereport/charts-api";
-import { compareBy, createBaseUrlScript, createFontLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, incrementStatistic, nullsLast, ordinal, } from "@allurereport/core-api";
-import { createTreeByLabels, createTreeByLabelsAndTitlePath, createTreeByTitlePath, filterTree, preciseTreeLabels, sortTree, transformTree, } from "@allurereport/plugin-api";
-import { generateCharts, getPieChartValues } from "@allurereport/web-commons";
-import Handlebars from "handlebars";
 import { randomUUID } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { basename, 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 { generateCharts, getPieChartValues } from "@allurereport/web-commons";
+import Handlebars from "handlebars";
 import { convertFixtureResult, convertTestResult } from "./converters.js";
 const require = createRequire(import.meta.url);
 const template = `<!DOCTYPE html>
@@ -73,12 +73,12 @@ const createBreadcrumbs = (convertedTr) => {
         return acc;
     }, []);
 };
-export const generateTestResults = async (writer, store, trs) => {
+export const generateTestResults = async (writer, store, trs, options = {}) => {
     let convertedTrs = [];
     for (const tr of trs) {
         const trFixtures = await store.fixturesByTrId(tr.id);
         const convertedTrFixtures = trFixtures.map(convertFixtureResult);
-        const convertedTr = convertTestResult(tr);
+        const convertedTr = convertTestResult(tr, { hideLabels: options.hideLabels });
         convertedTr.history = (await store.historyByTrId(tr.id)) ?? [];
         convertedTr.retries = await store.retriesByTrId(tr.id);
         convertedTr.retriesCount = convertedTr.retries.length;
@@ -108,7 +108,7 @@ export const generateTestCases = async (writer, trs) => {
 };
 export const generateTestEnvGroups = async (writer, groups) => {
     for (const group of groups) {
-        const src = join("test-env-groups", `${group.id}.json`);
+        const src = joinPosixPath("test-env-groups", `${group.id}.json`);
         await writer.writeData(src, group);
     }
 };
@@ -215,16 +215,16 @@ export const generateEnvironmentJson = async (writer, env) => {
     await writer.writeWidget("allure_environment.json", env);
 };
 export const generateEnvirontmentsList = async (writer, store) => {
-    const environments = await store.allEnvironments();
+    const environments = await store.allEnvironmentIdentities();
     await writer.writeWidget("environments.json", environments);
 };
 export const generateVariables = async (writer, store) => {
     const reportVariables = await store.allVariables();
-    const environments = await store.allEnvironments();
+    const environments = await store.allEnvironmentIdentities();
     await writer.writeWidget("variables.json", reportVariables);
     for (const env of environments) {
-        const envVariables = await store.envVariables(env);
-        await writer.writeWidget(join(env, "variables.json"), envVariables);
+        const envVariables = await store.envVariablesByEnvironmentId(env.id);
+        await writer.writeWidget(joinPosixPath(env.id, "variables.json"), envVariables);
     }
 };
 export const generateStatistic = async (writer, data) => {
@@ -232,12 +232,12 @@ export const generateStatistic = async (writer, data) => {
     await writer.writeWidget("statistic.json", stats);
     await writer.writeWidget("pie_chart.json", getPieChartValues(stats));
     for (const env of envs) {
-        const envStats = statsByEnv.get(env);
+        const envStats = statsByEnv.get(env.id);
         if (!envStats) {
             continue;
         }
-        await writer.writeWidget(join(env, "statistic.json"), envStats);
-        await writer.writeWidget(join(env, "pie_chart.json"), envStats);
+        await writer.writeWidget(joinPosixPath(env.id, "statistic.json"), envStats);
+        await writer.writeWidget(joinPosixPath(env.id, "pie_chart.json"), envStats);
     }
 };
 export const generateAttachmentsFiles = async (writer, attachmentLinks, contentFunction) => {
@@ -343,7 +343,7 @@ export const generateStaticFiles = async (payload) => {
             headTags: headTags.join("\n"),
             bodyTags: bodyTags.join("\n"),
             reportFilesScript: createReportDataScript(reportDataFiles),
-            reportOptions: JSON.stringify(reportOptions),
+            reportOptions: stringifyForInlineScript(reportOptions),
             analyticsEnable: true,
             allureVersion,
             reportUuid,

package/dist/plugin.js

@@ -10,54 +10,89 @@ 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 { incrementStatistic, joinPosixPath } from "@allurereport/core-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";
 import { InMemoryReportDataWriter, ReportFileDataWriter } from "./writer.js";
+const statisticByTestResults = async (store, testResults) => {
+    const statistic = { total: 0 };
+    for (const testResult of testResults) {
+        if (testResult.hidden) {
+            continue;
+        }
+        statistic.total++;
+        incrementStatistic(statistic, testResult.status);
+        if ((await store.retriesByTrId(testResult.id)).length > 0) {
+            statistic.retries = (statistic.retries ?? 0) + 1;
+        }
+        if (testResult.flaky) {
+            statistic.flaky = (statistic.flaky ?? 0) + 1;
+        }
+        if (testResult.transition === "new") {
+            statistic.new = (statistic.new ?? 0) + 1;
+        }
+    }
+    return statistic;
+};
 export class AwesomePlugin {
     constructor(options = {}) {
         this.options = options;
         _AwesomePlugin_writer.set(this, void 0);
         _AwesomePlugin_generate.set(this, async (context, store) => {
             const { singleFile, groupBy = [], filter, appendTitlePath } = this.options ?? {};
+            const hideLabels = context.hideLabels;
             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, filter });
             const statistics = await store.testsStatistic(filter);
-            const environments = await store.allEnvironments();
+            const environments = await store.allEnvironmentIdentities();
             const envStatistics = new Map();
             const allTestEnvGroups = await store.allTestEnvGroups();
             const globalAttachments = await store.allGlobalAttachments();
             const globalExitCode = await store.globalExitCode();
             const globalErrors = await store.allGlobalErrors();
-            const qualityGateResults = await store.qualityGateResultsByEnv();
-            for (const env of environments) {
-                envStatistics.set(env, await store.testsStatistic(filterEnv(env, filter)));
-            }
+            const qualityGateResults = await store.qualityGateResultsByEnvironmentId();
+            const envResultsById = new Map();
+            const envIdByTrId = new Map();
+            environments.forEach(({ id }) => {
+                envResultsById.set(id, []);
+            });
+            await Promise.all(allTrs.map(async (tr) => {
+                const environmentId = await store.environmentIdByTrId(tr.id);
+                if (!environmentId) {
+                    return;
+                }
+                envIdByTrId.set(tr.id, environmentId);
+                if (!envResultsById.has(environmentId)) {
+                    envResultsById.set(environmentId, []);
+                }
+                envResultsById.get(environmentId).push(tr);
+            }));
+            await Promise.all(environments.map(async ({ id }) => {
+                envStatistics.set(id, await statisticByTestResults(store, envResultsById.get(id) ?? []));
+            }));
             await generateStatistic(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
                 stats: statistics,
                 statsByEnv: envStatistics,
                 envs: environments,
             });
             await generateAllCharts(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, this.options, context);
-            const convertedTrs = await generateTestResults(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, allTrs);
+            const convertedTrs = await generateTestResults(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, allTrs, { hideLabels });
             applyCategoriesToTestResults(convertedTrs, categories);
             await generateCategories(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
                 tests: convertedTrs,
                 categories,
                 environmentCount: environments.length,
-                environments,
+                environments: environments.map(({ name }) => name),
                 defaultEnvironment: "default",
                 selectedEnvironmentCount: environments.length,
             });
             const hasGroupBy = groupBy.length > 0;
-            await generateTimeline(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs, this.options);
+            await generateTimeline(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), allTrs, this.options, envIdByTrId);
             const treeLabels = hasGroupBy
                 ? preciseTreeLabels(groupBy, convertedTrs, ({ labels }) => labels.map(({ name }) => name))
                 : [];
@@ -66,19 +101,30 @@ export class AwesomePlugin {
             await generateTree(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), "tree.json", treeLabels, convertedTrs, { appendTitlePath });
             await generateNav(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs, "nav.json");
             await generateTestEnvGroups(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), allTestEnvGroups);
-            for (const reportEnvironment of reportEnvironments) {
-                const envConvertedTrs = convertedTrs.filter(({ environment }) => environment === reportEnvironment);
-                await generateTree(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), join(reportEnvironment, "tree.json"), treeLabels, envConvertedTrs, {
+            const envConvertedTrsById = new Map();
+            convertedTrs.forEach((tr) => {
+                const environmentId = envIdByTrId.get(tr.id);
+                if (!environmentId) {
+                    return;
+                }
+                if (!envConvertedTrsById.has(environmentId)) {
+                    envConvertedTrsById.set(environmentId, []);
+                }
+                envConvertedTrsById.get(environmentId).push(tr);
+            });
+            for (const reportEnvironment of environments) {
+                const envConvertedTrs = envConvertedTrsById.get(reportEnvironment.id) ?? [];
+                await generateTree(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), joinPosixPath(reportEnvironment.id, "tree.json"), treeLabels, envConvertedTrs, {
                     appendTitlePath,
                 });
-                await generateNav(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), envConvertedTrs, join(reportEnvironment, "nav.json"));
+                await generateNav(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), envConvertedTrs, joinPosixPath(reportEnvironment.id, "nav.json"));
                 await generateCategories(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
                     tests: envConvertedTrs,
                     categories,
                     environmentCount: 1,
                     defaultEnvironment: "default",
                     selectedEnvironmentCount: 1,
-                    filename: join(reportEnvironment, "categories.json"),
+                    filename: joinPosixPath(reportEnvironment.id, "categories.json"),
                 });
             }
             await generateTreeFilters(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs);

package/dist/writer.js

@@ -6,7 +6,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _InMemoryReportDataWriter_data;
 import { mkdir, writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { join as joinPosix } from "node:path/posix";
+import { joinPosixPath } from "@allurereport/core-api";
 export class FileSystemReportDataWriter {
     constructor(output) {
         this.output = output;
@@ -37,19 +37,19 @@ export class InMemoryReportDataWriter {
         _InMemoryReportDataWriter_data.set(this, {});
     }
     async writeData(fileName, data) {
-        const dist = joinPosix("data", fileName);
+        const dist = joinPosixPath("data", fileName);
         __classPrivateFieldGet(this, _InMemoryReportDataWriter_data, "f")[dist] = Buffer.from(JSON.stringify(data), "utf-8");
     }
     async writeWidget(fileName, data) {
-        const dist = joinPosix("widgets", fileName);
+        const dist = joinPosixPath("widgets", fileName);
         __classPrivateFieldGet(this, _InMemoryReportDataWriter_data, "f")[dist] = Buffer.from(JSON.stringify(data), "utf-8");
     }
     async writeTestCase(test) {
-        const dist = joinPosix("data", "test-results", `${test.id}.json`);
+        const dist = joinPosixPath("data", "test-results", `${test.id}.json`);
         __classPrivateFieldGet(this, _InMemoryReportDataWriter_data, "f")[dist] = Buffer.from(JSON.stringify(test), "utf-8");
     }
     async writeAttachment(fileName, file) {
-        const dist = joinPosix("data", "attachments", fileName);
+        const dist = joinPosixPath("data", "attachments", fileName);
         const content = await file.asBuffer();
         if (content) {
             __classPrivateFieldGet(this, _InMemoryReportDataWriter_data, "f")[dist] = content;
@@ -68,19 +68,19 @@ export class ReportFileDataWriter {
         this.reportFiles = reportFiles;
     }
     async writeData(fileName, data) {
-        await this.reportFiles.addFile(joinPosix("data", fileName), Buffer.from(JSON.stringify(data), "utf-8"));
+        await this.reportFiles.addFile(joinPosixPath("data", fileName), Buffer.from(JSON.stringify(data), "utf-8"));
     }
     async writeWidget(fileName, data) {
-        await this.reportFiles.addFile(joinPosix("widgets", fileName), Buffer.from(JSON.stringify(data), "utf-8"));
+        await this.reportFiles.addFile(joinPosixPath("widgets", fileName), Buffer.from(JSON.stringify(data), "utf-8"));
     }
     async writeAttachment(source, file) {
         const contentBuffer = await file.asBuffer();
         if (!contentBuffer) {
             return;
         }
-        await this.reportFiles.addFile(joinPosix("data", "attachments", source), contentBuffer);
+        await this.reportFiles.addFile(joinPosixPath("data", "attachments", source), contentBuffer);
     }
     async writeTestCase(test) {
-        await this.reportFiles.addFile(joinPosix("data", "test-results", `${test.id}.json`), Buffer.from(JSON.stringify(test), "utf8"));
+        await this.reportFiles.addFile(joinPosixPath("data", "test-results", `${test.id}.json`), Buffer.from(JSON.stringify(test), "utf8"));
     }
 }

package/package.json

@@ -1,61 +1,50 @@
 {
   "name": "@allurereport/plugin-awesome",
-  "version": "3.3.1",
+  "version": "3.4.1",
   "description": "Allure Awesome Plugin – brand new HTML report with modern design and new features",
   "keywords": [
     "allure",
-    "testing",
-    "report",
+    "html",
     "plugin",
-    "html"
+    "report",
+    "testing"
   ],
-  "repository": "https://github.com/allure-framework/allure3",
   "license": "Apache-2.0",
   "author": "Qameta Software",
+  "repository": "https://github.com/allure-framework/allure3",
+  "files": [
+    "./dist"
+  ],
   "type": "module",
-  "exports": {
-    ".": "./dist/index.js"
-  },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": [
-    "./dist"
-  ],
+  "exports": {
+    ".": "./dist/index.js"
+  },
   "scripts": {
     "build": "run clean && tsc --project ./tsconfig.json",
     "clean": "rimraf ./dist",
-    "eslint": "eslint ./src/**/*.{js,jsx,ts,tsx}",
-    "eslint:format": "eslint --fix ./src/**/*.{js,jsx,ts,tsx}",
-    "test": "rimraf ./out && vitest run"
+    "test": "rimraf ./out && vitest run",
+    "lint": "oxlint --import-plugin src test features stories",
+    "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@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",
+    "@allurereport/charts-api": "3.4.1",
+    "@allurereport/core-api": "3.4.1",
+    "@allurereport/plugin-api": "3.4.1",
+    "@allurereport/web-awesome": "3.4.1",
+    "@allurereport/web-commons": "3.4.1",
     "d3-shape": "^3.2.0",
-    "handlebars": "^4.7.8",
+    "handlebars": "^4.7.9",
     "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",
     "@vitest/runner": "^2.1.9",
     "allure-vitest": "^3.3.3",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jsdoc": "^50.0.0",
-    "eslint-plugin-n": "^17.10.1",
-    "eslint-plugin-no-null": "^1.0.2",
-    "eslint-plugin-prefer-arrow": "^1.2.3",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.3",
     "vitest": "^2.1.9"

package/dist/environments.d.ts

@@ -1,3 +0,0 @@
-import type { TestResult } from "@allurereport/core-api";
-import type { TestResultFilter } from "@allurereport/plugin-api";
-export declare const filterEnv: (env: string, filter?: TestResultFilter) => (testResult: TestResult) => boolean;

package/dist/environments.js

@@ -1,8 +0,0 @@
-export const filterEnv = (env, filter) => {
-    return (testResult) => {
-        if (testResult.environment !== env) {
-            return false;
-        }
-        return filter ? filter(testResult) : true;
-    };
-};