@allurereport/plugin-awesome 3.0.0-beta.3

package/README.md

@@ -0,0 +1,57 @@
+# Awesome Plugin
+
+[<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")
+
+- Learn more about Allure Report at https://allurereport.org
+- 📚 [Documentation](https://allurereport.org/docs/) – discover official documentation for Allure Report
+- ❓ [Questions and Support](https://github.com/orgs/allure-framework/discussions/categories/questions-support) – get help from the team and community
+- 📢 [Official announcements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
+- 💬 [General Discussion ](https://github.com/orgs/allure-framework/discussions/categories/general-discussion) – engage in casual conversations, share insights and ideas with the community
+
+---
+
+## Overview
+
+The plugin generates brand new Allure Report with modern design and new features.
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add @allurereport/plugin-awesome
+yarn add @allurereport/plugin-awesome
+pnpm add @allurereport/plugin-awesome
+```
+
+Then, add the plugin to the Allure configuration file:
+
+```diff
+import { defineConfig } from "allure";
+
+export default defineConfig({
+  name: "Allure Report",
+  output: "./allure-report",
+  historyPath: "./history.jsonl",
+  plugins: {
++    awesome: {
++      options: {
++        reportName: "HelloWorld",
++      },
++    },
+  },
+});
+```
+
+## Options
+
+The plugin accepts the following options:
+
+| Option           | Description                                     | Type                                                         | Default         |
+|------------------|-------------------------------------------------|--------------------------------------------------------------|-----------------|
+| `reportName`     | Name of the report                              | `string`                                                     | `Allure Report` |
+| `singleFile`     | Writes the report as a single `index.html` file | `boolean`                                                    | `false`         |
+| `logo`           | Path to the logo image                          | `string`                                                     | `null`          |
+| `theme`          | Default color theme of the report               | `light \| dark`                                              | OS theme        |
+| `reportLanguage` | Default language of the report                  | `string`                                                     | OS language     |
+| `ci`             | CI data which will be rendered in the report    | `{ type: "github" \| "jenkins", url: string, name: string }` | `undefined`     |

package/dist/charts.d.ts

@@ -0,0 +1,14 @@
+import type { Statistic, TestStatus } from "@allurereport/core-api";
+import { PieArcDatum } from "d3-shape";
+export type TestResultSlice = {
+    status: TestStatus;
+    count: number;
+};
+export type TestResultChartData = {
+    percentage: number;
+    slices: TestResultSlice[];
+};
+export declare const d3Arc: import("d3-shape").Arc<any, PieArcDatum<TestResultSlice>>;
+export declare const d3Pie: import("d3-shape").Pie<any, TestResultSlice>;
+export declare function getPercentage(value: number, total: number): number;
+export declare const getChartData: (stats: Statistic) => TestResultChartData;

package/dist/charts.js

@@ -0,0 +1,28 @@
+import { statusesList } from "@allurereport/core-api";
+import { arc, pie } from "d3-shape";
+export const d3Arc = arc().innerRadius(40).outerRadius(50).cornerRadius(2).padAngle(0.03);
+export const d3Pie = pie()
+    .value((d) => d.count)
+    .padAngle(0.03)
+    .sortValues((a, b) => a - b);
+export function getPercentage(value, total) {
+    return Math.floor((value / total) * 10000) / 100;
+}
+export const getChartData = (stats) => {
+    const convertedStatuses = statusesList
+        .filter((status) => !!stats?.[status])
+        .map((status) => ({
+        status,
+        count: stats[status],
+    }));
+    const arcsData = d3Pie(convertedStatuses);
+    const slices = arcsData.map((arc) => ({
+        d: d3Arc(arc),
+        ...arc.data,
+    }));
+    const percentage = getPercentage(stats.passed ?? 0, stats.total);
+    return {
+        slices,
+        percentage,
+    };
+};

package/dist/converters.d.ts

@@ -0,0 +1,5 @@
+import type { TestFixtureResult, TestResult, TestStepResult } from "@allurereport/core-api";
+import type { AllureAwesomeFixtureResult, AllureAwesomeTestResult, AllureAwesomeTestStepResult } from "@allurereport/web-awesome";
+export declare const convertTestResult: (tr: TestResult) => AllureAwesomeTestResult;
+export declare const convertTestStepResult: (tsr: TestStepResult) => AllureAwesomeTestStepResult;
+export declare const convertFixtureResult: (fr: TestFixtureResult) => AllureAwesomeFixtureResult;

package/dist/converters.js

@@ -0,0 +1,48 @@
+const mapLabelsByName = (labels) => {
+    return labels.reduce((acc, { name, value }) => {
+        acc[name] = acc[name] || [];
+        if (value) {
+            acc[name].push(value);
+        }
+        return acc;
+    }, {});
+};
+export const convertTestResult = (tr) => {
+    return {
+        id: tr.id,
+        name: tr.name,
+        duration: tr.duration,
+        status: tr.status,
+        fullName: tr.fullName,
+        historyId: tr.historyId,
+        flaky: tr.flaky,
+        muted: tr.muted,
+        known: tr.known,
+        hidden: tr.hidden,
+        labels: tr.labels,
+        groupedLabels: mapLabelsByName(tr.labels),
+        parameters: tr.parameters,
+        links: tr.links,
+        steps: tr.steps,
+        message: tr.message,
+        trace: tr.trace,
+        setup: [],
+        teardown: [],
+        history: [],
+        retries: [],
+        breadcrumbs: [],
+    };
+};
+export const convertTestStepResult = (tsr) => {
+    return tsr;
+};
+export const convertFixtureResult = (fr) => {
+    return {
+        id: fr.id,
+        type: fr.type,
+        name: fr.name,
+        status: fr.status,
+        steps: fr.steps.map(convertTestStepResult),
+        duration: fr.duration,
+    };
+};

package/dist/generators.d.ts

@@ -0,0 +1,19 @@
+import type { AttachmentLink, EnvironmentItem, Statistic, TestResult } from "@allurereport/core-api";
+import type { AllureStore, ReportFiles, ResultFile } from "@allurereport/plugin-api";
+import type { AllureAwesomeOptions, TemplateManifest } from "./model.js";
+import type { AllureAwesomeDataWriter, ReportFile } from "./writer.js";
+export declare const readTemplateManifest: (singleFileMode?: boolean) => Promise<TemplateManifest>;
+export declare const generateTestResults: (writer: AllureAwesomeDataWriter, store: AllureStore) => Promise<void>;
+export declare const generateTree: (writer: AllureAwesomeDataWriter, treeName: string, labels: string[], tests: TestResult[]) => Promise<void>;
+export declare const generateEnvironmentJson: (writer: AllureAwesomeDataWriter, env: EnvironmentItem[]) => Promise<void>;
+export declare const generateStatistic: (writer: AllureAwesomeDataWriter, statistic: Statistic) => Promise<void>;
+export declare const generatePieChart: (writer: AllureAwesomeDataWriter, statistic: Statistic) => Promise<void>;
+export declare const generateAttachmentsFiles: (writer: AllureAwesomeDataWriter, attachmentLinks: AttachmentLink[], contentFunction: (id: string) => Promise<ResultFile | undefined>) => Promise<Map<string, string> | undefined>;
+export declare const generateHistoryDataPoints: (writer: AllureAwesomeDataWriter, store: AllureStore) => Promise<Map<string, string>>;
+export declare const generateStaticFiles: (payload: AllureAwesomeOptions & {
+    allureVersion: string;
+    reportFiles: ReportFiles;
+    reportDataFiles: ReportFile[];
+    reportUuid: string;
+    reportName: string;
+}) => Promise<void>;

package/dist/generators.js

@@ -0,0 +1,189 @@
+import { createTreeByLabels } from "@allurereport/plugin-api";
+import { createBaseUrlScript, createFontLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, } from "@allurereport/web-commons";
+import Handlebars from "handlebars";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { basename, join } from "node:path";
+import { getChartData } from "./charts.js";
+import { convertFixtureResult, convertTestResult } from "./converters.js";
+const require = createRequire(import.meta.url);
+const template = `<!DOCTYPE html>
+<html dir="ltr" lang="en">
+<head>
+    <meta charset="utf-8">
+    <title> {{ reportName }} </title>
+    <link rel="icon" href="favicon.ico">
+    {{{ headTags }}}
+</head>
+<body>
+    <div id="app"></div>
+    ${createBaseUrlScript()}
+    <script>
+      window.allure = window.allure || {};
+    </script>
+    {{{ bodyTags }}}
+    {{#if analyticsEnable}}
+    <script async src="https://www.googletagmanager.com/gtag/js?id=G-LNDJ3J7WT0"></script>
+    <script>
+        window.dataLayer = window.dataLayer || [];
+        function gtag(){dataLayer.push(arguments);}
+        gtag('js', new Date());
+        gtag('config', 'G-LNDJ3J7WT0', {
+          "report": "awesome",
+          "allureVersion": "{{ allureVersion }}",
+          "reportUuid": "{{ reportUuid }}",
+          "single_file": "{{singleFile}}"
+        });
+    </script>
+    {{/if}} 
+    <script>
+      window.allureReportOptions = {{{ reportOptions }}}
+    </script>
+    {{{ reportFilesScript }}}
+</body>
+</html>
+`;
+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" });
+    return JSON.parse(templateManifest);
+};
+const createBreadcrumbs = (convertedTr) => {
+    const labelsByType = convertedTr.labels.reduce((acc, label) => {
+        if (!acc[label.name]) {
+            acc[label.name] = [];
+        }
+        acc[label.name].push(label.value || "");
+        return acc;
+    }, {});
+    const parentSuites = labelsByType.parentSuite || [""];
+    const suites = labelsByType.suite || [""];
+    const subSuites = labelsByType.subSuite || [""];
+    return parentSuites.reduce((acc, parentSuite) => {
+        suites.forEach((suite) => {
+            subSuites.forEach((subSuite) => {
+                const path = [parentSuite, suite, subSuite].filter(Boolean);
+                if (path.length > 0) {
+                    acc.push(path);
+                }
+            });
+        });
+        return acc;
+    }, []);
+};
+export const generateTestResults = async (writer, store) => {
+    const allTr = await store.allTestResults({ includeHidden: true });
+    const convertedTrs = [];
+    for (const tr of allTr) {
+        const trFixtures = await store.fixturesByTrId(tr.id);
+        const convertedTrFixtures = trFixtures.map(convertFixtureResult);
+        const convertedTr = convertTestResult(tr);
+        convertedTr.history = await store.historyByTrId(tr.id);
+        convertedTr.retries = await store.retriesByTrId(tr.id);
+        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) => ({
+            link: attachment,
+            type: "attachment",
+        }));
+        convertedTr.breadcrumbs = createBreadcrumbs(convertedTr);
+        convertedTrs.push(convertedTr);
+    }
+    for (const convertedTr of convertedTrs) {
+        await writer.writeTestCase(convertedTr);
+    }
+};
+export const generateTree = async (writer, treeName, labels, tests) => {
+    const visibleTests = tests.filter((test) => !test.hidden);
+    const tree = createTreeByLabels(visibleTests, labels);
+    await writer.writeWidget(`${treeName}.json`, tree);
+};
+export const generateEnvironmentJson = async (writer, env) => {
+    await writer.writeWidget("allure_environment.json", env);
+};
+export const generateStatistic = async (writer, statistic) => {
+    await writer.writeWidget("allure_statistic.json", statistic);
+};
+export const generatePieChart = async (writer, statistic) => {
+    const chartData = getChartData(statistic);
+    await writer.writeWidget("allure_pie_chart.json", chartData);
+};
+export const generateAttachmentsFiles = async (writer, attachmentLinks, contentFunction) => {
+    const result = new Map();
+    for (const { id, ext, ...link } of attachmentLinks) {
+        if (link.missed) {
+            return;
+        }
+        const content = await contentFunction(id);
+        if (!content) {
+            continue;
+        }
+        const src = `${id}${ext}`;
+        await writer.writeAttachment(src, content);
+        result.set(id, src);
+    }
+    return result;
+};
+export const generateHistoryDataPoints = async (writer, store) => {
+    const result = new Map();
+    const allHistoryPoints = await store.allHistoryDataPoints();
+    allHistoryPoints.sort((a, b) => b.timestamp - a.timestamp);
+    for (const historyPoint of allHistoryPoints?.slice(0, 6)) {
+        const src = `history/${historyPoint.uuid}.json`;
+        await writer.writeData(src, historyPoint);
+    }
+    return result;
+};
+export const generateStaticFiles = async (payload) => {
+    const { reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "light", reportFiles, reportDataFiles, reportUuid, allureVersion, } = payload;
+    const compile = Handlebars.compile(template);
+    const manifest = await readTemplateManifest(payload.singleFile);
+    const headTags = [];
+    const bodyTags = [];
+    if (!payload.singleFile) {
+        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));
+            }
+            if (key === "main.css") {
+                headTags.push(createStylesLinkTag(fileName));
+            }
+            if (key === "main.js") {
+                bodyTags.push(createScriptTag(fileName));
+            }
+            if (singleFile) {
+                continue;
+            }
+            const fileContent = await readFile(filePath);
+            await reportFiles.addFile(basename(filePath), fileContent);
+        }
+    }
+    else {
+        const mainJs = manifest["main.js"];
+        const mainJsSource = require.resolve(`@allurereport/web-awesome/dist/single/${mainJs}`);
+        const mainJsContentBuffer = await readFile(mainJsSource);
+        bodyTags.push(createScriptTag(`data:text/javascript;base64,${mainJsContentBuffer.toString("base64")}`));
+    }
+    const reportOptions = {
+        reportName,
+        logo,
+        theme,
+        reportLanguage,
+        createdAt: Date.now(),
+        reportUuid,
+    };
+    const html = compile({
+        headTags: headTags.join("\n"),
+        bodyTags: bodyTags.join("\n"),
+        reportFilesScript: createReportDataScript(reportDataFiles),
+        reportOptions: JSON.stringify(reportOptions),
+        analyticsEnable: true,
+        allureVersion,
+        reportUuid,
+        reportName,
+        singleFile: payload.singleFile,
+    });
+    await reportFiles.addFile("index.html", Buffer.from(html, "utf8"));
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { AllureAwesomePlugin } from "./plugin.js";
+export default AllureAwesomePlugin;

package/dist/index.js

@@ -0,0 +1,2 @@
+import { AllureAwesomePlugin } from "./plugin.js";
+export default AllureAwesomePlugin;

package/dist/model.d.ts

@@ -0,0 +1,14 @@
+export type AllureAwesomeOptions = {
+    reportName?: string;
+    singleFile?: boolean;
+    logo?: string;
+    theme?: "light" | "dark";
+    reportLanguage?: "en" | "ru";
+    ci?: {
+        type: "github" | "jenkins";
+        url: string;
+        name: string;
+    };
+};
+export type TemplateManifest = Record<string, string>;
+export type AllureAwesomePluginOptions = AllureAwesomeOptions;

package/dist/model.js

@@ -0,0 +1 @@
+export {};

package/dist/plugin.d.ts

@@ -0,0 +1,10 @@
+import type { AllureStore, Plugin, PluginContext } from "@allurereport/plugin-api";
+import type { AllureAwesomePluginOptions } from "./model.js";
+export declare class AllureAwesomePlugin implements Plugin {
+    #private;
+    readonly options: AllureAwesomePluginOptions;
+    constructor(options?: AllureAwesomePluginOptions);
+    start: (context: PluginContext) => Promise<void>;
+    update: (context: PluginContext, store: AllureStore) => Promise<void>;
+    done: (context: PluginContext, store: AllureStore) => Promise<void>;
+}

package/dist/plugin.js

@@ -0,0 +1,71 @@
+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 __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 _AllureAwesomePlugin_writer, _AllureAwesomePlugin_generate;
+import { findByLabelName } from "@allurereport/core-api";
+import { generateAttachmentsFiles, generateEnvironmentJson, generateHistoryDataPoints, generatePieChart, generateStaticFiles, generateStatistic, generateTestResults, generateTree, } from "./generators.js";
+import { InMemoryReportDataWriter, ReportFileDataWriter } from "./writer.js";
+export class AllureAwesomePlugin {
+    constructor(options = {}) {
+        this.options = options;
+        _AllureAwesomePlugin_writer.set(this, void 0);
+        _AllureAwesomePlugin_generate.set(this, async (context, store) => {
+            const { singleFile } = this.options ?? {};
+            const environmentItems = await store.metadataByKey("allure_environment");
+            const statistic = await store.testsStatistic();
+            const allTr = await store.allTestResults({ includeHidden: true });
+            const attachments = await store.allAttachments();
+            await generateStatistic(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), statistic);
+            await generatePieChart(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), statistic);
+            const noParentSuite = allTr.find((tr) => findByLabelName(tr.labels, "parentSuite")) === undefined;
+            await generateTree(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), "suites", noParentSuite ? ["suite", "subSuite"] : ["parentSuite", "suite", "subSuite"], allTr);
+            await generateTestResults(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), store);
+            await generateHistoryDataPoints(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), store);
+            if (environmentItems?.length) {
+                await generateEnvironmentJson(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), environmentItems);
+            }
+            if (attachments?.length) {
+                await generateAttachmentsFiles(__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f"), attachments, (id) => store.attachmentContentById(id));
+            }
+            const reportDataFiles = singleFile ? __classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f").reportFiles() : [];
+            await generateStaticFiles({
+                ...this.options,
+                allureVersion: context.allureVersion,
+                reportFiles: context.reportFiles,
+                reportDataFiles,
+                reportUuid: context.reportUuid,
+                reportName: context.reportName,
+            });
+        });
+        this.start = async (context) => {
+            const { singleFile } = this.options;
+            if (singleFile) {
+                __classPrivateFieldSet(this, _AllureAwesomePlugin_writer, new InMemoryReportDataWriter(), "f");
+                return;
+            }
+            __classPrivateFieldSet(this, _AllureAwesomePlugin_writer, new ReportFileDataWriter(context.reportFiles), "f");
+            await Promise.resolve();
+        };
+        this.update = async (context, store) => {
+            if (!__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f")) {
+                throw new Error("call start first");
+            }
+            await __classPrivateFieldGet(this, _AllureAwesomePlugin_generate, "f").call(this, context, store);
+        };
+        this.done = async (context, store) => {
+            if (!__classPrivateFieldGet(this, _AllureAwesomePlugin_writer, "f")) {
+                throw new Error("call start first");
+            }
+            await __classPrivateFieldGet(this, _AllureAwesomePlugin_generate, "f").call(this, context, store);
+        };
+    }
+}
+_AllureAwesomePlugin_writer = new WeakMap(), _AllureAwesomePlugin_generate = new WeakMap();

package/dist/writer.d.ts

@@ -0,0 +1,36 @@
+import type { ReportFiles, ResultFile } from "@allurereport/plugin-api";
+import type { AllureAwesomeTestResult } from "@allurereport/web-awesome";
+export interface ReportFile {
+    name: string;
+    value: string;
+}
+export interface AllureAwesomeDataWriter {
+    writeData(fileName: string, data: any): Promise<void>;
+    writeWidget(fileName: string, data: any): Promise<void>;
+    writeTestCase(test: AllureAwesomeTestResult): Promise<void>;
+    writeAttachment(source: string, file: ResultFile): Promise<void>;
+}
+export declare class FileSystemReportDataWriter implements AllureAwesomeDataWriter {
+    private readonly output;
+    constructor(output: string);
+    writeData(fileName: string, data: any): Promise<void>;
+    writeWidget(fileName: string, data: any): Promise<void>;
+    writeTestCase(test: AllureAwesomeTestResult): Promise<void>;
+    writeAttachment(source: string, file: ResultFile): Promise<void>;
+}
+export declare class InMemoryReportDataWriter implements AllureAwesomeDataWriter {
+    #private;
+    writeData(fileName: string, data: any): Promise<void>;
+    writeWidget(fileName: string, data: any): Promise<void>;
+    writeTestCase(test: AllureAwesomeTestResult): Promise<void>;
+    writeAttachment(fileName: string, file: ResultFile): Promise<void>;
+    reportFiles(): ReportFile[];
+}
+export declare class ReportFileDataWriter implements AllureAwesomeDataWriter {
+    readonly reportFiles: ReportFiles;
+    constructor(reportFiles: ReportFiles);
+    writeData(fileName: string, data: any): Promise<void>;
+    writeWidget(fileName: string, data: any): Promise<void>;
+    writeAttachment(source: string, file: ResultFile): Promise<void>;
+    writeTestCase(test: AllureAwesomeTestResult): Promise<void>;
+}

package/dist/writer.js

@@ -0,0 +1,82 @@
+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;
+import { mkdir, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+export class FileSystemReportDataWriter {
+    constructor(output) {
+        this.output = output;
+    }
+    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" });
+    }
+    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" });
+    }
+    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" });
+    }
+    async writeAttachment(source, file) {
+        const distFolder = resolve(this.output, "data", "attachments");
+        await mkdir(distFolder, { recursive: true });
+        await file.writeTo(resolve(distFolder, source));
+    }
+}
+export class InMemoryReportDataWriter {
+    constructor() {
+        _InMemoryReportDataWriter_data.set(this, {});
+    }
+    async writeData(fileName, data) {
+        const dist = join("data", fileName);
+        __classPrivateFieldGet(this, _InMemoryReportDataWriter_data, "f")[dist] = Buffer.from(JSON.stringify(data), "utf-8");
+    }
+    async writeWidget(fileName, data) {
+        const dist = join("widgets", fileName);
+        __classPrivateFieldGet(this, _InMemoryReportDataWriter_data, "f")[dist] = Buffer.from(JSON.stringify(data), "utf-8");
+    }
+    async writeTestCase(test) {
+        const dist = join("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 = join("data", "attachments", fileName);
+        const content = await file.asBuffer();
+        if (content) {
+            __classPrivateFieldGet(this, _InMemoryReportDataWriter_data, "f")[dist] = content;
+        }
+    }
+    reportFiles() {
+        return Object.keys(__classPrivateFieldGet(this, _InMemoryReportDataWriter_data, "f")).map((key) => ({ name: key, value: __classPrivateFieldGet(this, _InMemoryReportDataWriter_data, "f")[key].toString("base64") }));
+    }
+}
+_InMemoryReportDataWriter_data = new WeakMap();
+export class ReportFileDataWriter {
+    constructor(reportFiles) {
+        this.reportFiles = reportFiles;
+    }
+    async writeData(fileName, data) {
+        await this.reportFiles.addFile(join("data", fileName), Buffer.from(JSON.stringify(data), "utf-8"));
+    }
+    async writeWidget(fileName, data) {
+        await this.reportFiles.addFile(join("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(join("data", "attachments", source), contentBuffer);
+    }
+    async writeTestCase(test) {
+        await this.reportFiles.addFile(join("data", "test-results", `${test.id}.json`), Buffer.from(JSON.stringify(test), "utf8"));
+    }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@allurereport/plugin-awesome",
+  "version": "3.0.0-beta.3",
+  "description": "Allure Awesome Plugin – brand new HTML report with modern design and new features",
+  "keywords": [
+    "allure",
+    "testing",
+    "report",
+    "plugin",
+    "html"
+  ],
+  "repository": "https://github.com/allure-framework/allure3",
+  "license": "Apache-2.0",
+  "author": "Qameta Software",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "./dist"
+  ],
+  "scripts": {
+    "build": "run clean && tsc --project ./tsconfig.json",
+    "clean": "rimraf ./dist",
+    "test": "rimraf ./out && vitest run"
+  },
+  "dependencies": {
+    "@allurereport/core-api": "3.0.0-beta.3",
+    "@allurereport/plugin-api": "3.0.0-beta.3",
+    "@allurereport/web-awesome": "3.0.0-beta.3",
+    "@allurereport/web-commons": "3.0.0-beta.3",
+    "d3-shape": "^3.2.0",
+    "handlebars": "^4.7.8"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/d3-shape": "^3.1.6",
+    "@types/eslint": "^8.56.11",
+    "@types/node": "^20.17.9",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@vitest/runner": "^2.1.8",
+    "allure-vitest": "^3.0.7",
+    "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.8"
+  }
+}