@allurereport/plugin-allure2 3.0.0-beta.9

package/README.md

@@ -0,0 +1,54 @@
+# Classic 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 a classic Allure Report.
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add @allurereport/plugin-classic
+yarn add @allurereport/plugin-classic
+pnpm add @allurereport/plugin-classic
+```
+
+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: {
++    classic: {
++      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`         |
+| `reportLanguage` | Default language of the report                  | `string`                                                     | OS language     |

package/dist/categories.d.ts

@@ -0,0 +1,7 @@
+import type { Allure2Category, Allure2Status } from "./model.js";
+export declare const matchCategories: (categories: Allure2Category[], result: {
+    statusMessage?: string;
+    statusTrace?: string;
+    status: Allure2Status;
+    flaky: boolean;
+}) => Allure2Category[];

package/dist/categories.js

@@ -0,0 +1,41 @@
+const productDefects = {
+    name: "Product defects",
+    matchedStatuses: ["failed"],
+};
+const testDefects = {
+    name: "Test defects",
+    matchedStatuses: ["broken"],
+};
+export const matchCategories = (categories, result) => {
+    const matched = categories.filter((category) => categoryMatch(category, result));
+    if (matched.length === 0 && categoryMatch(productDefects, result)) {
+        matched.push(productDefects);
+    }
+    if (matched.length === 0 && categoryMatch(testDefects, result)) {
+        matched.push(testDefects);
+    }
+    return matched;
+};
+const categoryMatch = (category, result) => {
+    const { status, statusMessage, statusTrace, flaky } = result;
+    const matchesStatus = !category.matchedStatuses || category.matchedStatuses.length === 0 || category.matchedStatuses.includes(status);
+    const matchesMessage = match(category.messageRegex, statusMessage);
+    const matchesTrace = match(category.traceRegex, statusTrace);
+    const matchesFlaky = (category.flaky ?? flaky) === flaky;
+    return matchesStatus && matchesMessage && matchesTrace && matchesFlaky;
+};
+const match = (regex, value) => {
+    if (!regex) {
+        return true;
+    }
+    if (!value) {
+        return false;
+    }
+    try {
+        const b = new RegExp(regex, "s").test(value);
+        return b;
+    }
+    catch (ignored) {
+        return false;
+    }
+};

package/dist/converters.d.ts

@@ -0,0 +1,11 @@
+import type { HistoryTestResult, TestFixtureResult, TestResult } from "@allurereport/core-api";
+import type { Allure2Category, Allure2TestResult } from "./model.js";
+type ConvertContext = {
+    attachmentMap: Map<string, string>;
+    fixtures: TestFixtureResult[];
+    categories: Allure2Category[];
+    retries: TestResult[];
+    history: HistoryTestResult[];
+};
+export declare const convertTestResult: (context: ConvertContext, test: TestResult) => Allure2TestResult;
+export {};

package/dist/converters.js

@@ -0,0 +1,182 @@
+import { filterIncludedInSuccessRate, isStep } from "@allurereport/core-api";
+import { matchCategories } from "./categories.js";
+import { severityValues } from "./model.js";
+import { updateStatistic } from "./utils.js";
+const sortByTime = (a, b) => a.time.start !== undefined && b.time.start !== undefined ? a.time.start - b.time.start : 0;
+const convertStatus = (status) => status;
+const convertStageResult = (context, result) => {
+    const { name, ...testStage } = convertStep(context, {
+        name: "test",
+        steps: result.steps,
+        start: result.start,
+        stop: result.stop,
+        duration: result.duration,
+        status: result.status,
+        parameters: [],
+        type: "step",
+    });
+    return testStage;
+};
+const convertStep = (context, step) => {
+    if (isStep(step)) {
+        const name = step.name;
+        const steps = step.steps.map((child) => convertStep(context, child));
+        const stepsCount = steps.length;
+        const parameters = step.parameters;
+        const parametersCount = parameters.length;
+        const statusMessage = step.error?.message;
+        const shouldDisplayMessage = !!statusMessage || steps.findIndex((s) => s.statusMessage === statusMessage) > 0;
+        return {
+            name,
+            time: {
+                start: step.start,
+                stop: step.stop,
+                duration: step.duration,
+            },
+            status: step.status,
+            statusMessage,
+            statusTrace: step.error?.trace,
+            steps,
+            attachments: [],
+            parameters,
+            stepsCount,
+            attachmentsCount: 0,
+            hasContent: stepsCount + parametersCount > 0 || shouldDisplayMessage,
+            shouldDisplayMessage,
+            attachmentStep: false,
+        };
+    }
+    const stepName = step.link.name;
+    return {
+        name: stepName,
+        time: {},
+        status: "unknown",
+        steps: [],
+        attachments: [
+            {
+                ...convertAttachment(context, step),
+            },
+        ],
+        parameters: [],
+        stepsCount: 0,
+        attachmentsCount: 1,
+        hasContent: true,
+        shouldDisplayMessage: false,
+        attachmentStep: true,
+    };
+};
+const convertAttachment = (context, { link }) => ({
+    uid: link.id,
+    name: link.name,
+    source: context.attachmentMap.get(link.id) ?? link.originalFileName,
+    type: link.contentType,
+    size: !link.missed ? link.contentLength : undefined,
+});
+const findAllLabels = (test, labelName) => {
+    return test.labels
+        .filter((label) => label.name === labelName)
+        .map((label) => label.value)
+        .filter((value) => value)
+        .map((value) => value);
+};
+const findLabelValue = (test, labelName) => {
+    return test.labels.find((label) => label.name === labelName)?.value;
+};
+const extractSeverity = (test) => {
+    const maybeSeverity = findLabelValue(test, "severity")?.toLowerCase();
+    return (maybeSeverity ? severityValues.find((value) => value === maybeSeverity) : undefined) ?? "normal";
+};
+const importantStatuses = ["failed", "broken", "passed"];
+export const convertTestResult = (context, test) => {
+    const testStage = convertStageResult(context, test);
+    const beforeStages = context.fixtures
+        .filter((value) => value.type === "before")
+        .map((fixture) => convertStageResult(context, fixture))
+        .sort(sortByTime);
+    const afterStages = context.fixtures
+        .filter((value) => value.type === "after")
+        .map((fixture) => convertStageResult(context, fixture))
+        .sort(sortByTime);
+    const owner = findLabelValue(test, "owner");
+    const severity = extractSeverity(test);
+    const tags = findAllLabels(test, "tag");
+    const status = convertStatus(test.status);
+    const statusMessage = test.error?.message;
+    const statusTrace = test.error?.trace;
+    const flaky = false;
+    const categories = matchCategories(context.categories, { statusMessage, statusTrace, status, flaky });
+    const retries = context.retries.map((retry) => ({
+        uid: retry.id,
+        status: convertStatus(retry.status),
+        statusDetails: retry?.error?.message,
+        time: {
+            start: retry.start,
+            stop: retry.stop,
+            duration: retry.duration,
+        },
+    }));
+    const retriesStatusChange = status in importantStatuses &&
+        retries.find((tr) => tr.status in importantStatuses && tr.status !== status) !== undefined;
+    const lastHistoryStatus = context.history.find(filterIncludedInSuccessRate)?.status;
+    const newFailed = lastHistoryStatus === "passed" && test.status === "failed";
+    const newBroken = lastHistoryStatus === "passed" && test.status === "broken";
+    const newPassed = lastHistoryStatus !== undefined && lastHistoryStatus !== "passed" && test.status === "passed";
+    const historyItems = context.history.map((htr) => ({
+        uid: htr.id,
+        status: convertStatus(htr.status),
+        reportUrl: "unsupported",
+        statusDetails: htr.error?.message,
+        time: {
+            start: htr.start,
+            stop: htr.stop,
+            duration: htr.duration,
+        },
+    }));
+    const statistic = { total: 0 };
+    historyItems.forEach((historyItem) => updateStatistic(statistic, historyItem));
+    const history = {
+        statistic,
+        items: historyItems,
+    };
+    return {
+        uid: test.id,
+        name: test.name,
+        fullName: test.fullName,
+        historyId: test.historyId,
+        testId: test.testCase?.id,
+        time: {
+            start: test.start,
+            stop: test.stop,
+            duration: test.duration,
+        },
+        status,
+        description: test.description,
+        descriptionHtml: test.descriptionHtml,
+        statusMessage,
+        statusTrace,
+        labels: test.labels,
+        links: test.links,
+        parameters: test.parameters,
+        afterStages,
+        beforeStages,
+        testStage: testStage,
+        flaky,
+        hidden: test.hidden,
+        newFailed,
+        newBroken,
+        newPassed,
+        retry: test.hidden,
+        retriesStatusChange,
+        retriesCount: retries.length,
+        hostId: test.hostId,
+        threadId: test.threadId,
+        extra: {
+            owner,
+            severity,
+            tags,
+            categories,
+            retries,
+            history,
+        },
+    };
+};

package/dist/generators.d.ts

@@ -0,0 +1,37 @@
+import type { AttachmentLink, HistoryDataPoint } from "@allurereport/core-api";
+import type { ReportFiles, ResultFile } from "@allurereport/plugin-api";
+import type { Allure2ExecutorInfo, Allure2TestResult } from "./model.js";
+import type { Allure2DataWriter, ReportFile } from "./writer.js";
+export type TemplateManifest = Record<string, string>;
+export declare const readTemplateManifest: (singleFileMode?: boolean) => Promise<TemplateManifest>;
+export declare const readManifestEntry: (options: {
+    fileName: string;
+    singleFile?: boolean;
+    mimeType: string;
+    reportFiles: ReportFiles;
+    inserter: (content: string) => string;
+}) => Promise<string>;
+export declare const generateStaticFiles: (payload: {
+    allureVersion: string;
+    reportName: string;
+    reportLanguage: string;
+    singleFile: boolean;
+    reportFiles: ReportFiles;
+    reportDataFiles: ReportFile[];
+    reportUuid: string;
+}) => Promise<void>;
+export declare const generateTree: (writer: Allure2DataWriter, name: string, labelNames: string[], tests: Allure2TestResult[]) => Promise<void>;
+export declare const generatePackagesData: (writer: Allure2DataWriter, tests: Allure2TestResult[]) => Promise<void>;
+export declare const generateCategoriesData: (writer: Allure2DataWriter, tests: Allure2TestResult[]) => Promise<void>;
+export declare const generateTimelineData: (writer: Allure2DataWriter, tests: Allure2TestResult[]) => Promise<void>;
+export declare const generateTestResults: (writer: Allure2DataWriter, tests: Allure2TestResult[]) => Promise<void>;
+export declare const generateSummaryJson: (writer: Allure2DataWriter, reportName: string, tests: Allure2TestResult[]) => Promise<void>;
+export declare const generateEnvironmentJson: (writer: Allure2DataWriter, env: {
+    name: string;
+    values: string[];
+}[]) => Promise<void>;
+export declare const generateExecutorJson: (writer: Allure2DataWriter, executor?: Partial<Allure2ExecutorInfo>) => Promise<void>;
+export declare const generateDefaultWidgetData: (writer: Allure2DataWriter, tests: Allure2TestResult[], ...fileNames: string[]) => Promise<void>;
+export declare const generateEmptyTrendData: (writer: Allure2DataWriter, ...fileNames: string[]) => Promise<void>;
+export declare const generateTrendData: (writer: Allure2DataWriter, reportName: string, tests: Allure2TestResult[], historyDataPoints: HistoryDataPoint[]) => Promise<void>;
+export declare const generateAttachmentsData: (writer: Allure2DataWriter, attachmentLinks: AttachmentLink[], contentFunction: (id: string) => Promise<ResultFile | undefined>) => Promise<Map<string, string>>;

package/dist/generators.js

@@ -0,0 +1,276 @@
+import { createBaseUrlScript, createFaviconLinkTag, 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 { byLabels, collapseTree, createTree, createWidget } from "./tree.js";
+import { updateStatistic, updateTime } from "./utils.js";
+const require = createRequire(import.meta.url);
+const template = `<!DOCTYPE html>
+<html dir="ltr" lang="{{reportLanguage}}">
+<head>
+    <meta charset="utf-8">
+    <title>{{reportName}}</title>
+    {{{ headTags }}}
+</head>
+<body>
+    <svg id="__SVG_SPRITE_NODE__" aria-hidden="true" style="position: absolute; width: 0; height: 0"></svg>
+    <div id="alert"></div>
+    <div id="content">
+        <span class="spinner">
+            <span class="spinner__circle"></span>
+        </span>
+    </div>
+    <div id="popup"></div>
+    {{{ bodyTags }}}
+    ${createBaseUrlScript()}
+    {{#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', {
+          'allureVersion': '{{allureVersion}}',
+          'report':'classic',
+          '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-allure2/dist/${singleFileMode ? "single" : "multi"}/manifest.json`);
+    const templateManifest = await readFile(templateManifestSource, { encoding: "utf-8" });
+    return JSON.parse(templateManifest);
+};
+export const readManifestEntry = async (options) => {
+    const { fileName, singleFile, mimeType, inserter, reportFiles } = options;
+    const filePath = require.resolve(join("@allurereport/web-allure2/dist", singleFile ? "single" : "multi", fileName));
+    const scriptContentBuffer = await readFile(filePath);
+    if (singleFile) {
+        return inserter(`data:${mimeType};base64,${scriptContentBuffer.toString("base64")}`);
+    }
+    await reportFiles.addFile(fileName, scriptContentBuffer);
+    return inserter(fileName);
+};
+export const generateStaticFiles = async (payload) => {
+    const { reportName, reportLanguage, singleFile, reportFiles, reportDataFiles, reportUuid, allureVersion } = payload;
+    const compile = Handlebars.compile(template);
+    const manifest = await readTemplateManifest(singleFile);
+    const headTags = [];
+    const bodyTags = [];
+    for (const key in manifest) {
+        const fileName = manifest[key];
+        const filePath = require.resolve(join("@allurereport/web-allure2/dist", singleFile ? "single" : "multi", fileName));
+        if (key === "favicon.ico") {
+            const tag = await readManifestEntry({
+                fileName,
+                singleFile,
+                reportFiles,
+                inserter: createFaviconLinkTag,
+                mimeType: "image/x-icon",
+            });
+            headTags.push(tag);
+            continue;
+        }
+        if (key === "main.css") {
+            const tag = await readManifestEntry({
+                fileName,
+                singleFile,
+                reportFiles,
+                inserter: createStylesLinkTag,
+                mimeType: "text/css",
+            });
+            headTags.push(tag);
+            continue;
+        }
+        if (key === "main.js") {
+            const tag = await readManifestEntry({
+                fileName,
+                singleFile,
+                reportFiles,
+                inserter: createScriptTag,
+                mimeType: "text/javascript",
+            });
+            bodyTags.push(tag);
+            continue;
+        }
+        if (singleFile) {
+            continue;
+        }
+        const fileContent = await readFile(filePath);
+        await reportFiles.addFile(basename(filePath), fileContent);
+    }
+    const reportOptions = {
+        reportName: reportName ?? "Allure Report",
+        reportLanguage: reportLanguage ?? "en",
+        createdAt: Date.now(),
+    };
+    const html = compile({
+        headTags: headTags.join("\n"),
+        bodyTags: bodyTags.join("\n"),
+        reportFilesScript: createReportDataScript(reportDataFiles),
+        reportOptions: JSON.stringify(reportOptions),
+        analyticsEnable: true,
+        allureVersion,
+        reportLanguage,
+        reportUuid,
+        reportName,
+        singleFile,
+    });
+    await reportFiles.addFile("index.html", Buffer.from(html, "utf8"));
+};
+export const generateTree = async (writer, name, labelNames, tests) => {
+    const fileName = `${name}.json`;
+    const data = createTree(tests, byLabels(labelNames));
+    await writer.writeData(fileName, data);
+    const widgetData = createWidget(data);
+    await writer.writeWidget(fileName, widgetData);
+};
+export const generatePackagesData = async (writer, tests) => {
+    const classifier = (test) => {
+        return (test.labels
+            .find((label) => label.name === "package")
+            ?.value?.split(".")
+            ?.map((group) => ({
+            groups: [group],
+        })) ?? []);
+    };
+    const data = createTree(tests, classifier);
+    const packagesData = collapseTree(data);
+    await writer.writeData("packages.json", packagesData);
+};
+export const generateCategoriesData = async (writer, tests) => {
+    const classifier = (test) => {
+        const byMessage = { groups: [test.statusMessage ?? "No message"] };
+        const categories = test.extra.categories;
+        if (!categories || categories.length === 0) {
+            return undefined;
+        }
+        const groups = categories.map((c) => c.name);
+        return [{ groups }, byMessage];
+    };
+    const data = createTree(tests, classifier);
+    const fileName = "categories.json";
+    await writer.writeData(fileName, data);
+    const widgetData = createWidget(data);
+    await writer.writeWidget(fileName, widgetData);
+};
+export const generateTimelineData = async (writer, tests) => {
+    const classifier = (test) => {
+        return [{ groups: [test.hostId ?? "Default"] }, { groups: [test.threadId ?? "Default"] }];
+    };
+    const data = createTree(tests, classifier);
+    await writer.writeData("timeline.json", data);
+};
+export const generateTestResults = async (writer, tests) => {
+    for (const test of tests) {
+        await writer.writeTestCase(test);
+    }
+};
+export const generateSummaryJson = async (writer, reportName, tests) => {
+    const statistic = { total: 0 };
+    const time = {};
+    tests
+        .filter((test) => !test.hidden)
+        .forEach((test) => {
+        updateStatistic(statistic, test);
+        updateTime(time, test);
+    });
+    const data = {
+        reportName,
+        statistic,
+        time,
+    };
+    await writer.writeWidget("summary.json", data);
+};
+export const generateEnvironmentJson = async (writer, env) => {
+    await writer.writeWidget("environment.json", env);
+};
+export const generateExecutorJson = async (writer, executor) => {
+    await writer.writeWidget("executors.json", executor ? [executor] : []);
+};
+export const generateDefaultWidgetData = async (writer, tests, ...fileNames) => {
+    const statusChartData = tests
+        .filter((test) => !test.hidden)
+        .map(({ uid, name, status, time, extra: { severity = "normal" } }) => {
+        return {
+            uid,
+            name,
+            status,
+            time,
+            severity,
+        };
+    });
+    for (const fileName of fileNames) {
+        await writer.writeWidget(fileName, statusChartData);
+    }
+};
+export const generateEmptyTrendData = async (writer, ...fileNames) => {
+    for (const fileName of fileNames) {
+        await writer.writeWidget(fileName, [
+            {
+                uid: "invalid",
+                name: "invalid",
+                statistic: { total: 0 },
+            },
+        ]);
+    }
+};
+export const generateTrendData = async (writer, reportName, tests, historyDataPoints) => {
+    const statistic = { total: 0 };
+    tests
+        .filter((test) => !test.hidden)
+        .forEach((test) => {
+        updateStatistic(statistic, test);
+    });
+    const history = historyDataPoints.map((point) => {
+        const stat = { total: 0 };
+        Object.values(point.testResults).forEach((testResult) => {
+            updateStatistic(stat, testResult);
+        });
+        return {
+            data: stat,
+            timestamp: point.timestamp,
+            reportName: point.name,
+        };
+    });
+    history
+        .sort((a, b) => b.timestamp - a.timestamp)
+        .forEach((element, index) => {
+        element.buildOrder = history.length - index;
+    });
+    const data = [
+        {
+            data: statistic,
+            timestamp: new Date().getTime(),
+            buildOrder: history.length + 1,
+            reportName: reportName,
+        },
+        ...history,
+    ];
+    await writer.writeWidget("history-trend.json", data);
+};
+export const generateAttachmentsData = async (writer, attachmentLinks, contentFunction) => {
+    const result = new Map();
+    for (const { id, ext, ...link } of attachmentLinks) {
+        if (link.missed) {
+            continue;
+        }
+        const content = await contentFunction(id);
+        if (!content) {
+            continue;
+        }
+        const src = `${id}${ext}`;
+        await writer.writeAttachment(src, content);
+        result.set(id, src);
+    }
+    return result;
+};

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/model.d.ts

@@ -0,0 +1,146 @@
+import type { Statistic } from "@allurereport/core-api";
+export type Allure2Status = "failed" | "broken" | "passed" | "skipped" | "unknown";
+export interface Allure2Time {
+    start?: number;
+    stop?: number;
+    duration?: number;
+}
+export interface Allure2Label {
+    name?: string;
+    value?: string;
+}
+export interface Allure2Link {
+    name?: string;
+    url?: string;
+    type?: string;
+}
+export interface Allure2Parameter {
+    name?: string;
+    value?: string;
+}
+export interface Allure2Attachment {
+    uid: string;
+    name?: string;
+    source?: string;
+    type?: string;
+    size?: number;
+}
+export interface Allure2Step {
+    name: string;
+    time: Allure2Time;
+    status: Allure2Status;
+    statusMessage?: string;
+    statusTrace?: string;
+    steps: Allure2Step[];
+    attachments: Allure2Attachment[];
+    parameters: Allure2Parameter[];
+    stepsCount: number;
+    attachmentsCount: number;
+    shouldDisplayMessage: boolean;
+    hasContent: boolean;
+    attachmentStep: boolean;
+}
+export type Allure2StageResult = Allure2Step | Omit<Allure2Step, "name">;
+export interface Allure2TestResult {
+    uid: string;
+    name: string;
+    fullName?: string;
+    historyId?: string;
+    testId?: string;
+    time: Allure2Time;
+    description?: string;
+    descriptionHtml?: string;
+    status: Allure2Status;
+    statusMessage?: string;
+    statusTrace?: string;
+    flaky: boolean;
+    newFailed: boolean;
+    newBroken: boolean;
+    newPassed: boolean;
+    retriesCount: number;
+    retriesStatusChange: boolean;
+    beforeStages: Allure2StageResult[];
+    testStage: Allure2StageResult;
+    afterStages: Allure2StageResult[];
+    labels: Allure2Label[];
+    parameters: Allure2Parameter[];
+    links: Allure2Link[];
+    hostId?: string;
+    threadId?: string;
+    hidden: boolean;
+    retry: boolean;
+    extra: {
+        [key: string]: any;
+    };
+}
+export declare const statisticKeys: (keyof Statistic)[];
+export interface GroupTime {
+    start?: number;
+    stop?: number;
+    duration?: number;
+    minDuration?: number;
+    maxDuration?: number;
+    sumDuration?: number;
+}
+export interface SummaryData {
+    reportName: string;
+    statistic: Statistic;
+    time: GroupTime;
+}
+export type Allure2SeverityLevel = "blocker" | "critical" | "normal" | "minor" | "trivial";
+export declare const severityValues: Allure2SeverityLevel[];
+export interface StatusChartData {
+    uid: string;
+    name: string;
+    time: Allure2Time;
+    status: Allure2Status;
+    severity: Allure2SeverityLevel;
+}
+export interface Allure2Category {
+    name: string;
+    description?: string;
+    descriptionHtml?: string;
+    messageRegex?: string;
+    traceRegex?: string;
+    matchedStatuses?: Allure2Status[];
+    flaky?: boolean;
+}
+export interface Allure2RetryItem {
+    uid: string;
+    status: Allure2Status;
+    statusDetails?: string;
+    time: Allure2Time;
+}
+export interface Allure2HistoryItem {
+    uid: string;
+    reportUrl: string;
+    status: Allure2Status;
+    statusDetails?: string;
+    time: Allure2Time;
+}
+export interface Allure2HistoryData {
+    statistic: Statistic;
+    items: Allure2HistoryItem[];
+}
+export interface Allure2HistoryTrendItem {
+    data: Statistic;
+    buildOrder?: number;
+    reportUrl?: string;
+    reportName?: string;
+}
+export type Allure2Options = {
+    reportName?: string;
+    singleFile?: boolean;
+    reportLanguage?: string;
+};
+export type Allure2PluginOptions = Allure2Options;
+export interface Allure2ExecutorInfo {
+    name: string;
+    type: string;
+    url: string;
+    buildOrder: number;
+    buildName: string;
+    buildUrl: string;
+    reportName: string;
+    reportUrl: string;
+}

package/dist/model.js

@@ -0,0 +1,2 @@
+export const statisticKeys = ["failed", "broken", "passed", "skipped", "unknown", "total"];
+export const severityValues = ["blocker", "critical", "normal", "minor", "trivial"];

package/dist/plugin.d.ts

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

package/dist/plugin.js

@@ -0,0 +1,76 @@
+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 _Allure2Plugin_generate;
+import { preciseTreeLabels } from "@allurereport/plugin-api";
+import { convertTestResult } from "./converters.js";
+import { generateAttachmentsData, generateCategoriesData, generateDefaultWidgetData, generateEmptyTrendData, generateEnvironmentJson, generateExecutorJson, generatePackagesData, generateStaticFiles, generateSummaryJson, generateTestResults, generateTimelineData, generateTree, generateTrendData, } from "./generators.js";
+import { InMemoryReportDataWriter, ReportFileDataWriter } from "./writer.js";
+export class Allure2Plugin {
+    constructor(options = {}) {
+        this.options = options;
+        _Allure2Plugin_generate.set(this, async (context, store) => {
+            const { reportName = "Allure Report", singleFile = false, reportLanguage = "en" } = this.options ?? {};
+            const writer = singleFile ? new InMemoryReportDataWriter() : new ReportFileDataWriter(context.reportFiles);
+            const attachmentLinks = await store.allAttachments();
+            const attachmentMap = await generateAttachmentsData(writer, attachmentLinks, (id) => store.attachmentContentById(id));
+            const categories = (await store.metadataByKey("allure2_categories")) ?? [];
+            const environmentItems = (await store.metadataByKey("allure_environment")) ?? [];
+            const tests = await store.allTestResults({ includeHidden: true });
+            const allTr = [];
+            for (const value of tests) {
+                const fixtures = await store.fixturesByTrId(value.id);
+                const retries = await store.retriesByTrId(value.id);
+                const history = await store.historyByTrId(value.id);
+                const allure2TestResult = convertTestResult({
+                    attachmentMap,
+                    fixtures,
+                    categories,
+                    retries,
+                    history,
+                }, value);
+                allTr.push(allure2TestResult);
+            }
+            await generateTestResults(writer, allTr);
+            const displayedTr = allTr.filter((atr) => !atr.hidden);
+            const treeLabelNamesFactory = (labelNames) => preciseTreeLabels(labelNames, displayedTr, (tr) => {
+                if (tr.labels) {
+                    return tr.labels.map(({ name }) => name);
+                }
+                return [];
+            });
+            await generateTree(writer, "suites", treeLabelNamesFactory(["parentSuite", "suite", "subSuite"]), displayedTr);
+            await generateTree(writer, "behaviors", treeLabelNamesFactory(["epic", "feature", "story"]), displayedTr);
+            await generatePackagesData(writer, displayedTr);
+            await generateCategoriesData(writer, displayedTr);
+            await generateTimelineData(writer, allTr);
+            await generateSummaryJson(writer, reportName, displayedTr);
+            await generateEnvironmentJson(writer, environmentItems);
+            const executor = await store.metadataByKey("allure2_executor");
+            const historyDataPoints = await store.allHistoryDataPoints();
+            await generateExecutorJson(writer, executor);
+            await generateDefaultWidgetData(writer, displayedTr, "duration.json", "status-chart.json", "severity.json");
+            await generateTrendData(writer, reportName, displayedTr, historyDataPoints);
+            await generateEmptyTrendData(writer, "duration-trend.json", "categories-trend.json", "retry-trend.json");
+            const reportDataFiles = singleFile ? writer.reportFiles() : [];
+            await generateStaticFiles({
+                allureVersion: context.allureVersion,
+                reportName,
+                reportLanguage,
+                singleFile,
+                reportFiles: context.reportFiles,
+                reportDataFiles,
+                reportUuid: context.reportUuid,
+            });
+        });
+        this.update = async (context, store) => {
+            await __classPrivateFieldGet(this, _Allure2Plugin_generate, "f").call(this, context, store);
+        };
+        this.done = async (context, store) => {
+            await this.update(context, store);
+        };
+    }
+}
+_Allure2Plugin_generate = new WeakMap();

package/dist/tree.d.ts

@@ -0,0 +1,44 @@
+import type { Statistic } from "@allurereport/core-api";
+import type { Allure2Status, Allure2TestResult, Allure2Time } from "./model.js";
+export interface TreeNode {
+    name: string;
+}
+export interface TreeGroup extends TreeNode {
+    uid: string;
+    name: string;
+    children: TreeNode[];
+}
+export interface TreeLeaf extends TreeNode {
+    uid: string;
+    parentUid: string;
+    status: Allure2Status;
+    time: Allure2Time;
+    flaky: boolean;
+    newFailed: boolean;
+    newBroken: boolean;
+    newPassed: boolean;
+    retriesCount: number;
+    retriesStatusChange: boolean;
+    tags: string[];
+    parameters: string[];
+}
+export interface TreeLayer {
+    groups: string[];
+}
+export interface WidgetItem {
+    uid: string;
+    name: string;
+    statistic: Statistic;
+}
+export interface WidgetData {
+    items: WidgetItem[];
+    total: number;
+}
+declare const createLeaf: (endNode: TreeGroup, test: Allure2TestResult) => TreeLeaf;
+export type LeafFactory = typeof createLeaf;
+export type Classifier = (test: Allure2TestResult) => TreeLayer[] | undefined;
+export declare const byLabels: (labelNames: string[]) => Classifier;
+export declare const createTree: (tests: Allure2TestResult[], classifier: Classifier, leafFactory?: LeafFactory) => TreeGroup;
+export declare const collapseTree: (treeGroup: TreeGroup, separator?: string) => TreeGroup;
+export declare const createWidget: (root: TreeGroup) => WidgetData;
+export {};

package/dist/tree.js

@@ -0,0 +1,112 @@
+import { byStatistic, compareBy } from "@allurereport/core-api";
+import { createHash } from "node:crypto";
+import { calculateStatisticByLeafs } from "./utils.js";
+const rootNodeUid = "__ROOT__";
+const createLeaf = (endNode, test) => {
+    const leaf = {
+        parentUid: endNode.uid,
+        uid: test.uid,
+        name: test.name,
+        status: test.status,
+        time: { ...test.time },
+        flaky: test.flaky,
+        newFailed: test.newFailed,
+        newBroken: test.newBroken,
+        newPassed: test.newPassed,
+        retriesCount: test.retriesCount,
+        retriesStatusChange: test.retriesStatusChange,
+        parameters: test.parameters.filter((p) => p.value).map((p) => p.value),
+        tags: test.extra.tags ?? [],
+    };
+    return leaf;
+};
+export const byLabels = (labelNames) => {
+    return (test) => groupByLabels(test, labelNames);
+};
+export const createTree = (tests, classifier, leafFactory = createLeaf) => {
+    const groups = new Map();
+    const root = { uid: rootNodeUid, name: rootNodeUid, children: [] };
+    groups.set(root.uid, root);
+    for (const test of tests) {
+        const treeLayers = classifier(test);
+        if (!treeLayers) {
+            continue;
+        }
+        getEndNodes(test, root, treeLayers, 0, groups).forEach((endNode) => {
+            const leaf = leafFactory(endNode, test);
+            endNode.children.push(leaf);
+        });
+    }
+    return root;
+};
+const getEndNodes = (item, node, classifiers, index, groups) => {
+    if (index >= classifiers.length) {
+        return [node];
+    }
+    const layer = classifiers[index];
+    return layer.groups.flatMap((name) => {
+        const uid = groupUid(node.uid, name);
+        if (!groups.has(uid)) {
+            const value = { uid, name, children: [] };
+            groups.set(uid, value);
+            node.children.push(value);
+        }
+        const treeGroup = groups.get(uid);
+        return getEndNodes(item, treeGroup, classifiers, index + 1, groups);
+    });
+};
+const groupByLabels = (test, labelNames) => {
+    const result = [];
+    for (const name of labelNames) {
+        const groups = test.labels
+            .filter((label) => label.name === name)
+            .filter((label) => !!label.value)
+            .map((label) => label.value);
+        if (groups.length !== 0) {
+            result.push({ groups: Array.from(new Set(groups)) });
+        }
+    }
+    return result;
+};
+const groupUid = (parentUid, groupName) => {
+    return md5(parentUid ? `${parentUid}.${groupName}` : groupName);
+};
+const md5 = (data) => createHash("md5").update(data).digest("hex");
+export const collapseTree = (treeGroup, separator = ".") => {
+    const newChildren = treeGroup.children.map((c) => {
+        if (!("children" in c)) {
+            return c;
+        }
+        let res = c;
+        while (res.children.length === 1 && "children" in res.children[0]) {
+            const child = res.children[0];
+            res = {
+                uid: groupUid(res.uid, child.uid),
+                name: res.name + separator + child.name,
+                children: child.children,
+            };
+        }
+        return res;
+    });
+    treeGroup.children = newChildren;
+    return treeGroup;
+};
+export const createWidget = (root) => {
+    const items = root.children
+        .map((c) => {
+        if (!("children" in c)) {
+            return undefined;
+        }
+        const res = c;
+        const statistic = calculateStatisticByLeafs(res);
+        return { uid: res.uid, name: res.name, statistic };
+    })
+        .filter((value) => value)
+        .map((value) => value)
+        .sort(compareBy("statistic", byStatistic()))
+        .slice(0, 10);
+    return {
+        items,
+        total: root.children.length,
+    };
+};

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+import type { Statistic } from "@allurereport/core-api";
+import type { Allure2Status, Allure2TestResult, GroupTime } from "./model.js";
+import type { TreeGroup } from "./tree.js";
+export declare const updateStatistic: (statistic: Statistic, test: {
+    status: Allure2Status;
+}) => undefined;
+export declare const updateTime: (time: GroupTime, test: Allure2TestResult) => undefined;
+export declare const calculateStatisticByLeafs: (treeGroup: TreeGroup) => Statistic;

package/dist/utils.js

@@ -0,0 +1,43 @@
+import { statisticKeys } from "./model.js";
+export const updateStatistic = (statistic, test) => {
+    statistic[test.status] = (statistic[test.status] ?? 0) + 1;
+    statistic.total = (statistic.total ?? 0) + 1;
+};
+export const updateTime = (time, test) => {
+    const { start, stop, duration } = test.time;
+    if (duration === undefined) {
+        return;
+    }
+    time.maxDuration = Math.max(time.maxDuration ?? 0, duration);
+    time.minDuration = Math.min(time.minDuration ?? Number.MAX_VALUE, duration);
+    time.sumDuration = (time.sumDuration ?? 0) + duration;
+    if (start !== undefined) {
+        time.start = Math.min(time.start ?? Number.MAX_VALUE, start);
+    }
+    if (stop !== undefined) {
+        time.stop = Math.max(time.stop ?? Number.MIN_VALUE, stop);
+    }
+    if (time.start !== undefined && time.stop !== undefined) {
+        time.duration = Math.max(0, time.stop - time.start);
+    }
+};
+export const calculateStatisticByLeafs = (treeGroup) => {
+    const current = { total: 0 };
+    treeGroup.children.forEach((child) => {
+        if ("children" in child) {
+            const childGroup = child;
+            const statistic = calculateStatisticByLeafs(childGroup);
+            statisticKeys.forEach((key) => {
+                const statisticElement = statistic[key];
+                if (statisticElement !== undefined) {
+                    current[key] = (current[key] ?? 0) + statisticElement;
+                }
+            });
+        }
+        else {
+            const childLeaf = child;
+            updateStatistic(current, childLeaf);
+        }
+    });
+    return current;
+};

package/dist/writer.d.ts

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

package/dist/writer.js

@@ -0,0 +1,85 @@
+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-cases");
+        await mkdir(distFolder, { recursive: true });
+        await writeFile(resolve(distFolder, `${test.uid}.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-cases", `${test.uid}.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-cases", `${test.uid}.json`), Buffer.from(JSON.stringify(test), "utf8"));
+    }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@allurereport/plugin-allure2",
+  "version": "3.0.0-beta.9",
+  "description": "The classic version of Allure HTML report",
+  "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",
+    "eslint": "eslint ./src/**/*.{js,jsx,ts,tsx}",
+    "eslint:format": "eslint --fix ./src/**/*.{js,jsx,ts,tsx}",
+    "test": "rimraf ./out && vitest run"
+  },
+  "dependencies": {
+    "@allurereport/core-api": "3.0.0-beta.9",
+    "@allurereport/plugin-api": "3.0.0-beta.9",
+    "@allurereport/web-allure2": "3.0.0-beta.9",
+    "@allurereport/web-commons": "3.0.0-beta.9",
+    "handlebars": "^4.7.8"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2.6.1",
+    "@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.9",
+    "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"
+  }
+}